/*
 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

#ifndef EGL_EXTERNAL_PLATFORM_H
#define EGL_EXTERNAL_PLATFORM_H

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include "eglexternalplatformversion.h"

/* EGL external platform interface objects */
typedef struct EGLExtPlatformExports EGLExtPlatformExports;
typedef struct EGLExtPlatform        EGLExtPlatform;
typedef struct EGLExtDriver          EGLExtDriver;

/* EGLExtPlatformString enum. This indicates what string to query through
 * queryString() */
typedef enum {
    /*
     * Platform client extensions
     *
     * Returns a extension string including the specific platform client
     * extensions. E.g. EGL_EXT_platform_wayland on Wayland platform.
     *
     * The <dpy> parameter is EGL_NO_DISPLAY.
     */
    EGL_EXT_PLATFORM_PLATFORM_CLIENT_EXTENSIONS = 0,

    /*
     * Display extensions
     *
     * Returns a extension string including all display extensions supported on
     * the given display by the external platform implementation.
     */
    EGL_EXT_PLATFORM_DISPLAY_EXTENSIONS,

    EGL_EXT_PLATFORM_STRING_NAME_COUNT
} EGLExtPlatformString;


/*
 * loadEGLExternalPlatform()
 *
 * Loads the EGL external platform and returns a EGLExtPlatform object where
 * external platform data and exported functions have been properly set
 * according to the given major and minor version numbers
 *
 * If a compatible external platform is found for <major>.<minor>, EGL_TRUE is
 * returned and <platform> is properly initialized. Otherwise, EGL_FALSE is
 * returned and <platform> remains unchanged
 *
 * A reference to the underlying EGL implementation that must be used is passed
 * in <driver>.
 */
typedef EGLBoolean (*PEGLEXTFNLOADEGLEXTERNALPLATFORM) (int major, int minor, const EGLExtDriver *driver, EGLExtPlatform *platform);

/*
 * unloadEGLExternalPlatform()
 *
 * Unloads the EGL external platform, freeing any resources associated to the
 * given platform data structure that may have been allocated and not yet freed.
 *
 * If all resources are properly freed, EGL_TRUE is returned and the given
 * platform data pointer becomes invalid. Otherwise, EGL_FALSE is returned.
 *
 * Prior to version 1.2, the driver called this after it had finished most of
 * its internal teardown, so calling into the driver was not safe. In version
 * 1.2 or later, however, it's safe to call into the driver, and any internal
 * EGLDisplays will still be valid.
 */
typedef EGLBoolean (*PEGLEXTFNUNLOADEGLEXTERNALPLATFORM) (void *platformData);

/*
 * getHookAddress()
 *
 * The EGL external platform interface defines a minimum set of functions that
 * must be provided by any EGL external platform at loadEGLExternalPlatform()
 * time.
 *
 * However, most of the other EGL functions can be overwritten by an EGL
 * external platform.
 *
 * The EGL implementation will call into getHookAddress() to retrieve any
 * additional EGL function that the external platform may implement. Its
 * behavior is comparable to eglGetProcAddress().
 *
 * Returns the hook address if the given functions is implemented; otherwise,
 * returns NULL.
 */
typedef void* (*PEGLEXTFNGETHOOKADDRESS) (void *platformData, const char *name);

/*
 * isValidNativeDisplay()
 *
 * Validity check function for a native display. It will return EGL_TRUE if the
 * given native display is valid and belongs to the external platform
 * implementation; otherwise, it will return EGL_FALSE.
 */
typedef EGLBoolean (*PEGLEXTFNISVALIDNATIVEDISPLAY) (void *platformData, void *nativeDisplay);

/*
 * getPlatformDisplay()
 *
 * Same as eglGetPlatformDisplay()
 */
typedef EGLDisplay (*PEGLEXTFNGETPLATFORMDISPLAY) (void *platformData, EGLenum platform, void *nativeDisplay, const EGLAttrib* attribs);

/*
 * queryString()
 *
 * Similar to eglQueryString(), but takes its own enumeration as the string name
 * parameter.
 *
 * Returns the appropriate extension string which is supported by the external
 * platform. See descriptions of EGLExtPlatformString enums for more details.
 */
typedef const char * (*PEGLEXTFNQUERYSTRING) (void *platformData, EGLDisplay dpy, EGLExtPlatformString name);

/*
 * getInternalHandle()
 *
 * Conversion function from an EGL external object handle to its corresponding
 * EGL internal one. It will return the internal EGL object handle if the given
 * external handle is valid and belongs to the given EGLDisplay; otherwise, it
 * will return NULL.
 *
 * Note that the object handle type must be provided by the caller. Its value
 * must be one of the object type enums as defined in EGL_KHR_debug.
 */
typedef void* (*PEGLEXTFNGETINTERNALHANDLE) (EGLDisplay dpy, EGLenum type, void *handle);

/*
 * getObjectLabel()
 *
 * Returns an EGL external object label previously attached with
 * eglLabelObjectKHR() from EGL_KHR_debug.
 *
 * Note that the object handle type must be provided by the caller. Its value
 * must be one of the object type enums as defined in EGL_KHR_debug.
 */
typedef void* (*PEGLEXTFNGETOBJECTLABEL) (EGLDisplay dpy, EGLenum type, void *handle);


/*
 * EGLExtPlatformExports definition. This is the exports table an external
 * platform must fill out and make available for the EGL implementation to use
 */
struct EGLExtPlatformExports {
    PEGLEXTFNUNLOADEGLEXTERNALPLATFORM unloadEGLExternalPlatform;
    PEGLEXTFNGETHOOKADDRESS            getHookAddress;

    PEGLEXTFNISVALIDNATIVEDISPLAY      isValidNativeDisplay;
    PEGLEXTFNGETPLATFORMDISPLAY        getPlatformDisplay;

    PEGLEXTFNQUERYSTRING               queryString;

    PEGLEXTFNGETINTERNALHANDLE         getInternalHandle;

    PEGLEXTFNGETOBJECTLABEL            getObjectLabel;
};

/*
 * EGLExtPlatform definition. This is common to all external platforms
 *
 * Fields:
 *  - major/minor: External platform major/minor version number. Specify the EGL
 *                 external platform interface version number the given platform
 *                 implements. They are tied to EGL external platform interface
 *                 changes.
 *  - micro:       External platform micro version number. Similar to
 *                 major/minor numbers, but it is tied to specific external
 *                 platform implementation changes.
 *  - platform:    EGL platform enumeration the corresponding external platform
 *                 implements.
 *  - data:        Opaque pointer to platform specific data. At platform
 *                 load time, the external platform can initialize its own data
 *                 structure to store any information that may be required by
 *                 any function that does not take an EGLDisplay or the display
 *                 belongs to another platform.
 *  - exports:     External platform exports table.
 */
struct EGLExtPlatform {
    struct {
        int major;
        int minor;
        int micro;
    }                      version;
    EGLenum                platform;
    void                  *data;
    EGLExtPlatformExports  exports;
};


/*
 * getProcAddress()
 *
 * Equivalent to eglGetProcAddress() to fetch EGL methods provided by a
 * specific EGL driver.
 */
typedef void* (*PEGLEXTFNGETPROCADDRESS) (const char *name);

/*
 * setError()
 *
 * Sets the last EGL error, which can be queried with eglGetError() later on. It
 * also calls the EGL_KHR_debug callback if such extension is supported by the
 * driver.
 *
 * Takes the EGL error code and both message type and string as defined in
 * EGL_KHR_debug for the debug callback function.
 */
typedef void (*PEGLEXTFNSETERROR) (EGLint error, EGLint msgType, const char *msg);

/*
 * debugMessage()
 *
 * Calls the EGL_KHR_debug callback if such extension is supported by the
 * driver.
 *
 * Takes both message type and string as defined in EGL_KHR_debug for the debug
 * callback function.
 */
typedef void* (*PEGLEXTFNDEBUGMESSAGE) (EGLint msgType, const char *msg);

/*
 * streamSwapInterval()
 *
 * Handle swapinterval on the EGLStream consumer side. Should be a noop for
 * any consumer that does not present directly to a display.
 *
 * Takes the stream handle and a pointer to the interval value as parameters.
 *
 * Returns one of the following EGL error codes:
 *  - EGL_SUCCESS:    The interval setting operation succeeded (or noop).
 *  - EGL_BAD_MATCH:  A server-side interval override is in place. The override
 *                    value is returned in the <interval> parameter.
 *  - EGL_BAD_ACCESS: The interval setting operation failed.
 */
typedef EGLint (*PEGLEXTFNSTREAMSWAPINTERVAL) (EGLStreamKHR stream, int *interval);

/*
 * EGLExtDriver definition. The EGL external driver is the component in
 * charge of dispatching EGL calls to the underlying EGL implementation.
 */
struct EGLExtDriver {
    PEGLEXTFNGETPROCADDRESS     getProcAddress;
    PEGLEXTFNSETERROR           setError;
    PEGLEXTFNDEBUGMESSAGE       debugMessage;
    PEGLEXTFNSTREAMSWAPINTERVAL streamSwapInterval;
#if EGL_EXTERNAL_PLATFORM_HAS(DRIVER_VERSION)
    int major;
    int minor;
#endif
};

#endif // EGL_EXTERNAL_PLATFORM_H
