NativeWindowFactory:

    - If property 'nativewindow.ws.name' is set,
      use it as the custom windowing type returned by
      getNativeWindowType(true)

NEWT:
    - Using NativeWindowFactory's property 'nativewindow.ws.name'
      as a package name for custom NEWT windowing imlementations,
      ie:
        -Dnativewindow.ws.name=com.sun.javafx.newt.intel.gdl
        -Dnativewindow.ws.name=com.sun.javafx.newt.broadcom.egl
      This allows far more flexibility to add custom impl.

    - Add Intel-GDL, define property 'useIntelGDL'
      to build the native part.
      Intel GDL is impl in the package 'com.sun.javafx.newt.intel.gdl'

JOGL:
    - All impl. of 'createGLDrawable(..)', which were actually creating
      onscreen drawable only, were renamed to 'createOnscreenDrawable(..)'.

    - GLDrawableFactoryImpl impl. 'createGLDrawable(..)' now
      and dispatches to the actual create* methods in respect to
      the Capabilities, ie onscreen, pbuffer and offscreen.

    - GLDrawableFactory:
        - If using a native ES profile -> EGLDrawableFactory
        - If existing native OS factory -> Use that ..
        - Else -> Use EGLDrawableFactory, if available

4 files changed, 3965 insertions, 0 deletions

diff --git a/make/stub_includes/embedded/IntelGDL/gdl.h b/make/stub_includes/embedded/IntelGDL/gdl.h
new file mode 100644
index 000000000..f1990349c
--- /dev/null
+++ b/make/stub_includes/embedded/IntelGDL/gdl.h
@@ -0,0 +1,1329 @@
+//-----------------------------------------------------------------------------
+// Copyright (c) 2006-2009 Intel Corporation
+//
+// DISTRIBUTABLE AS SAMPLE SOURCE SOFTWARE
+//
+// This Distributable As Sample Source Software is subject to the terms and
+// conditions of the Intel Software License Agreement provided with the Intel(R)
+// Media Processor Software Development Kit.
+//-----------------------------------------------------------------------------
+
+#ifndef _GDL_H_
+#define _GDL_H_
+
+#include "gdl_types.h"
+#include "gdl_pd.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/*------------------------------------------------------------------------------
+ * IMPORTANT!
+ *
+ * Change of a structure/type or a function prototype requires rolling of an
+ * appropriate version number. For more information see gdl_version.h
+ *----------------------------------------------------------------------------*/
+
+/**@mainpage
+ * This document is applicable to the Intel� Media Processor CE 3100 and the
+ * Sodaville processor. In this document, both processors are referred to as
+ * the Intel� CE Media Processors. When functional differences occur,
+ * applicability to platform/silicon will be delineated.
+ */
+
+/**@defgroup general        General */
+
+/**@defgroup disp_mode      Display Mode*/
+
+/**@defgroup plane_management Plane Management
+
+  A plane is a unit of hardware that can supply pixel data to be composited
+  with the pixel data of other planes for output to the display.  Different
+  kinds of planes have different capabilities.  The Intel� CE Media Processors
+  contain two kinds of planes:
+  - Universal Pixel Planes (UPPs)
+  - Indexed/Alpha Planes (IAPs)
+
+  The Plane Management API provides a generic way to configure a plane and
+  populate it with pixel data.  The main components of the API are:
+
+  - <b>A predefined set of plane attributes.</b> Attributes are specified as
+    name/value pairs. The enumeration #gdl_plane_attr_t defines the attribute
+    names. The documentation of this data type describes each attribute
+    including:
+    - the plane capability controlled by the attribute.
+    - the data type of the attribute's value.
+    - the range of valid values that can be assigned to the attribute.
+    - the default value of the attribute.
+
+  - <b>The ability to query a plane for its capabilities.</b> Each plane type
+    may support a different subset of the defined attributes and different
+    set of pixel formats.  gdl_plane_capabilities() returns a description of
+    the attributes and pixel formats supported by a specified plane.
+
+  - <b>A set of attribute query functions.</b> These functions return the
+    current hardware setting of the specified attribute on the specified plane.
+    The only difference between the functions is the data type returned.
+    - gdl_plane_get_attr()
+    - gdl_plane_get_int()
+    - gdl_plane_get_uint()
+    - gdl_plane_get_rect()
+
+  - <b>A set of attribute configuration functions.</b> For each of the query
+    functions there is a corresponding set function.  All attribute set
+    function calls must be bracketed by calls to configuration begin/end
+    functions.  The specified attributes values are "batched" and executed
+    only when the end function is called.  Batching provides atomicity of
+    configuration changes and avoids getting into invalid states when related
+    attributes must be changed at the same time.  The sequence of calls made
+    to configure a plane is as follows:
+    - gdl_plane_config_begin()
+    - one or more calls to:
+          - gdl_plane_set_attr()
+          - gdl_plane_set_int()
+          - gdl_plane_set_uint()
+          - gdl_plane_set_rect()
+    - gdl_plane_config_end()
+
+  - <b>A surface flip function.</b>  A surface is a memory buffer containing
+    pixel information.  See @ref surface for more information.  The gdl_flip()
+    function "flips" a surface onto a plane, making the pixels in that surface
+    visible.
+
+  @warning  Plane defaults (including if they are enabled or disabled) are
+            set when the display driver is loaded, and when
+            @ref gdl_plane_reset() and @ref gdl_plane_reset_all() are called.
+            They are <b>not</b> set by @ref gdl_init().
+ */
+
+/**@defgroup surface        Surface Management
+
+  A surface is a memory buffer containing pixel data.
+ */
+
+/**@defgroup disp_vbi       VBI and Polarity */
+
+/**@defgroup disp_pd        Port Drivers */
+
+/**@defgroup debug          Debug helpers
+
+  The majority of the functions in this group dump the contents of data
+  structures to stdout or return string representations (that can be used in
+  messages) for the values of various GDL enumerations.
+ */
+
+#ifndef DOXYGEN_SKIP
+#define GDL_API __attribute__ ((visibility ("default")))
+#else
+#define GDL_API " "
+#endif
+
+GDL_API gdl_ret_t
+gdl_init(
+    gdl_void * reserved0
+    );
+    /**< @ingroup general
+
+    This routine initializes the session and initiates communication with
+    the display driver server daemon.  Calls to any other GDL functions will
+    fail until this call is made. It must be called once per process. All
+    threads in a process are then able to use the GDL API.
+
+    Subsequent calls to gdl_init() (without an intervening call to gdl_close())
+    will return #GDL_SUCCESS and increment an internal reference count.
+
+    @param [in] reserved0
+    This parameter is reserved for future use and should be set to 0.
+
+    @note   This routine does not restore plane or port driver defaults
+            that may have been changed by a previously running GDL
+            application.  Plane defaults can be restored by using
+            @ref gdl_plane_reset() and @ref gdl_plane_reset_all().  No
+            restoration functionality exists for port drivers.
+    */
+
+#ifndef DOXYGEN_SKIP /* DOXYGEN_SKIP only defined when docs are generated */
+GDL_API gdl_ret_t _gdl_init(gdl_uint32 version);
+#define gdl_init(reserved0) _gdl_init((GDL_HEADER_VERSION_MAJOR << 16) \
+                                      | GDL_HEADER_VERSION_MINOR)
+#endif
+
+GDL_API gdl_ret_t
+gdl_close(
+    void
+    );
+    /**< @ingroup general
+
+    This function decrements the internal reference count that gdl_open()
+    increments.  Once the reference count goes to zero, communication with the
+    display driver server daemon is closed and the session is terminated.
+    Subsequent calls to the GDL API from within the same process will fail until
+    gdl_init() is called again.
+
+    The use of a reference account allows pairs of gdl_open()/gdl_close() calls
+    to be used, for instance, in separate threads in the same process without
+    interference.
+
+    When the session is terminated, any unfreed surfaces that were allocated by
+    the calling process are freed, and warnings are printed to the console. If
+    a surface freed in this manner is currently being displayed, the plane it is
+    displayed on is first disabled.  No other hardware settings are changed;
+    applications launched subsequently will inherit the hardware configuration
+    left behind by the closing process.
+    */
+
+GDL_API gdl_ret_t
+gdl_get_driver_info(
+    gdl_driver_info_t * driver_info
+    );
+    /**< @ingroup general
+
+    This routine returns driver information to the caller.  This information
+    can be used to verify the version of the gdl driver.
+
+    @param [out] driver_info
+    This parameter is of type #gdl_driver_info_t.  This info contains the
+    driver version as well as other info.
+    */
+
+GDL_API gdl_ret_t
+gdl_closed_caption_source(
+    gdl_plane_id_t plane_id
+    );
+    /**< @ingroup general
+
+    This function allows specification of the video stream to be used as the
+    source for closed caption data.
+
+    The vbd_flip() function (of the VBD interface) allows the caller to flip a
+    field/frame from a video stream onto a specified Universal Pixel Plane.
+    Closed caption data associated with the frame is passed along in the same
+    call.
+
+    However, it is possible for multiple video streams to be displayed at the
+    same time, on different planes.  The internal TV encoder(s) can only process
+    one CC stream at a time -- intermixing streams will result in garbage being
+    displayed for CC text.
+
+    The plane ID passed to this function determines which CC stream will be
+    passed along to the internal TV encoder(s).  CC data passed for streams
+    flipped onto any other planes will be discarded.
+
+    By default, the CC source is GDL_PLANE_ID_UNDEFINED, which causes *all* CC
+    data passed to vbd_flip() to be ignored.
+
+    @param [in]  plane_id
+    The ID of the Universal Pixel Plane to which the currently selected CC
+    stream will be directed.  If the value is GDL_PLANE_ID_UNDEFINED, all CC
+    data passed via vbd_flip() calls will be ignored.
+    */
+
+GDL_API gdl_ret_t
+gdl_get_display_info(
+    gdl_display_id_t     display_id,
+    gdl_display_info_t * display_info
+    );
+    /**< @ingroup disp_mode
+
+    This routine returns the current display settings including resolution,
+    refresh rate, and so on.
+
+    @param [in] display_id
+    The ID of the display whose settings should be retrieved.
+
+    @param [out] display_info
+    A pointer to a #gdl_display_info_t structure that will receive the current
+    display settings.
+    */
+
+GDL_API gdl_ret_t
+gdl_set_display_info(
+    gdl_display_info_t * display_info
+    );
+    /**< @ingroup disp_mode
+
+    This routine sets the display to the configuration specified by the
+    display_info parameter.
+
+    @param [in] display_info
+    The desired display configuration.  The 'id' field of the structure
+    indicates the display that is to be configured.
+    */
+
+GDL_API gdl_ret_t
+gdl_check_tvmode(
+    gdl_display_id_t id,
+    gdl_tvmode_t *   mode
+    );
+    /**< @ingroup disp_mode
+
+    Returns #GDL_SUCCESS if and only if the specified display mode is supported
+    on all of the port drivers currently active on the specified display.
+
+    @param [in] id
+    Display of interest.
+
+    @param [in] mode
+    Mode of interest.
+    */
+
+GDL_API gdl_ret_t
+gdl_get_port_tvmode_by_index(
+    gdl_pd_id_t    id,
+    gdl_uint32     index,
+    gdl_tvmode_t * mode
+    );
+    /**< @ingroup disp_mode
+
+    This routine can be used to enumerate the display modes supported by a
+    given port driver.  The supported modes are indexed by 0-based consecutive
+    integer values.  Calling this function with index==0 will return
+    information about the first supported mode; calling it with index==1
+    will return information about the second supported mode; and so on.
+
+    The function returns GDL_SUCCESS as long as 'index' < N, where N is the
+    number of modes supported by the port driver.
+
+    @param [in] id
+    Port driver of interest.
+
+    @param [in] index
+    Mode index.
+
+    @param [out] mode
+    Display mode information is returned here if the return value is
+    GDL_SUCCESS; otherwise, the contents of this structure are meaningless.
+    */
+
+GDL_API gdl_ret_t
+gdl_wait_for_vblank(
+    gdl_polarity_t * polarity
+    );
+    /**< @ingroup disp_vbi
+
+    This routine will block until the next Vertical Blanking Interval (VBI) has
+    begun, as indicated by the VBlank signal.  Return value other than
+    GDL_SUCCESS indicates that no VBI occurred during the expected time
+    interval. This may indicate that PIPE A is not enabled.
+    @b NOTE: The latency between VBI and return from this call can be affected
+    by a system load. 
+
+    @param [out] polarity
+    If this argument is NULL it is ignored.  Otherwise, the polarity of the new
+    active region is returned, as a value of type #gdl_polarity_t
+    */
+
+GDL_API gdl_ret_t
+gdl_get_display_polarity(
+    gdl_polarity_t * polarity
+    );
+    /**< @ingroup disp_vbi
+
+    This routine will return immediately the current display polarity.
+
+    @param [out] polarity
+    The polarity is returned here.  See #gdl_polarity_t.
+    */
+
+GDL_API gdl_ret_t
+gdl_alloc_surface(
+    gdl_pixel_format_t   pixel_format,
+    gdl_uint32           width,
+    gdl_uint32           height,
+    gdl_uint32           flags,
+    gdl_surface_info_t * surface_info
+    );
+    /**< @ingroup surface
+
+    This routine allocates a surface with the specified characteristics.  The
+    driver will determine the required alignment and validate the requested
+    surface attributes, and may alter them according to the device status.
+
+    @param [in] pixel_format
+    The pixel format of the surface.
+
+    @param [in] width
+    The width of the surface in pixels.
+
+    @param [in] height
+    The height of the surface in pixels.
+
+    @param [in] flags
+    Any number of flags of type #gdl_surface_flag_t OR'd together that
+    describe the type of surface and the intended usage.
+
+    @param [out] surface_info
+    This parameter is returned to the caller and contains information about the
+    surface that was just created.
+
+    @b NOTE
+    Exiting the application or terminating the GDL session via a call to
+    gdl_close() without freeing the surface will result in its automatic
+    deallocation. A warning message will be printed to the system console and
+    log.
+    */
+
+GDL_API gdl_ret_t
+gdl_get_surface_info(
+    gdl_surface_id_t     surface_id,
+    gdl_surface_info_t * surface_info
+    );
+    /**< @ingroup surface
+
+    This routine returns the gdl_surface_info_t data structure for the requested
+    surface.
+
+    @param [in] surface_id
+    The ID of the surface for which information is requested.
+
+    @param [out] surface_info
+    A pointer to a #gdl_surface_info_t structure to be filled with information
+    about the specified surface.
+    */
+
+GDL_API gdl_ret_t
+gdl_flush_surface(
+    gdl_surface_id_t surface_id
+    );
+    /**< @ingroup surface
+
+    This routine flushes cached memory used by the surface. Flushing only has any
+    effect when surface is allocated with #GDL_SURFACE_CACHED flag.
+
+    @param [in] surface_id
+    The ID of the surface to be flushed.
+    */
+
+GDL_API gdl_ret_t
+gdl_map_surface(
+    gdl_surface_id_t surface_id,
+    gdl_uint8 **     pointer,
+    gdl_uint32 *     pitch
+    );
+    /**< @ingroup surface
+
+    This routine provides a direct pointer to the surface's buffer mapped into
+    the caller's address space. Synchronization of any graphics operations
+    pending on that surface must be handled by the caller before using the
+    pointer.
+
+    A surface may be mapped by more than one thread.
+
+    The surface must be unmapped prior to freeing it; an attempt to free a
+    mapped surface will fail.
+
+    @param [in] surface_id
+    The ID of the surface that to be mapped.
+
+    @param [out] pointer
+    CPU accessible address of the surface.
+
+    @param [out] pitch
+    The pitch of the mapped surface in bytes.  This is an optional output
+    parameter and will be ignored if it is NULL.  In the case of a YUV
+    planar or pseudo-planar surface, this is the pitch of the Y surface.
+    */
+
+GDL_API gdl_ret_t
+gdl_unmap_surface(
+    gdl_surface_id_t surface_id
+    );
+    /**< @ingroup surface
+
+    This routine unmaps the surface's buffer from the callers address space.
+    All surfaces should be unmapped when the pointer is no longer needed.
+    An attempt to free a mapped surface will fail.
+
+    @param [in] surface_id
+    The ID of the surface that is to be unmapped.
+    */
+
+GDL_API gdl_ret_t
+gdl_free_surface(
+    gdl_surface_id_t surface_id
+    );
+    /**< @ingroup surface
+
+    This routine destroys the memory associated with the specified surface.
+
+    @param [in] surface_id
+    The ID of the surface that to be destroyed.
+
+    @b NOTE
+    - Freeing a surface that is currently being displayed on a plane, will cause
+      the plane to be disabled. A warning will be printed to the system console
+      and log.
+
+    - Attempting to free a surface that is currently mapped by anyone will
+      result in a #GDL_ERR_MAPPED error.
+
+    - Passing an invalid surface ID or the ID GDL_SURFACE_INVALID will result in
+      an error return.
+    */
+
+GDL_API gdl_ret_t
+gdl_get_palette(
+    gdl_surface_id_t surface_id,
+    gdl_palette_t *  palette
+    );
+    /**< @ingroup surface
+
+    This routine returns the palette entries for the specified surface.
+
+     @param [in] surface_id
+     The ID of the surface whose palette entries are to be returned.
+
+     @param [in,out] palette
+     The length field of the palette structure contains the number of palette
+     entries requested by the user. Upon completion of this call it may be
+     updated with the actual number of palette entries (if less than the
+     specified length) or with zero(if there is no palette associated with the
+     surface). The data field will be filled with palette entries.
+     */
+
+GDL_API gdl_ret_t
+gdl_set_palette(
+    gdl_surface_id_t surface_id,
+    gdl_palette_t *  palette
+    );
+    /**< @ingroup surface
+
+    This routine assigns the specified palette to the specified surface.
+    An error will be returned if the pixel format of the surface is not a
+    palettized format.
+
+    Note that the palette info is copied into the driver: changing entries in
+    a palette has no effect until the next time gdl_set_palette() is called.
+
+    Also note that changing the palette of a surface that is currently flipped
+    onto a plane does <b>not</b> change the displayed colors: the surface
+    must be flipped onto the plane again after the palette is set.
+
+    @param [in] surface_id
+    The ID of the surface whose palette entries will be set.
+
+    @param [in] palette
+    A pointer to a palette structure containing color data as well as number
+    of active palette elements
+    */
+
+GDL_API gdl_ret_t
+gdl_get(
+    gdl_surface_id_t  surface_id,
+    gdl_rectangle_t * rect,
+    gdl_uint32        pitch,
+    gdl_void *        data,
+    gdl_uint32        flags
+    );
+    /**< @ingroup surface
+
+    This routine copies a rectangular region of pixel data out of a surface to
+    a buffer.
+
+    @param [in] surface_id
+    The ID of the surface from which the pixel data is read. This function is
+    currently only implemented for the following pixel formats, and will return
+    an error code if the surface has any other pixel format:
+    - GDL_PF_ARGB_32
+    - GDL_PF_RGB_32
+    - GDL_PF_RGB_24
+    - GDL_PF_ARGB_16_4444
+    - GDL_PF_RGB_16
+    - GDL_PF_RGB_15
+
+    @param [in] rect
+    The rectangle within the surface from which the data is to be read.
+    The origin is relative to the origin of the surface.  Both the origin
+    coordinates and the dimensions of the rectangle are specified in pixels.
+    A NULL pointer indicates that the rectangle is the entire surface.
+
+    @param [in] pitch
+    The pitch of the output data buffer. It must be greater than or equal to
+    @code
+    rect->width * <bytes-per-pixel>
+    @endcode
+
+    @param [out] data
+    The address of the buffer to which the pixel data should be copied.
+    The size of the buffer must be greater than or equal to
+    @code
+    rect->height * pitch
+    @endcode
+
+    @param [in] flags
+    None currently defined -- pass as 0.
+    */
+
+GDL_API gdl_ret_t
+gdl_put(
+    gdl_surface_id_t  surface_id,
+    gdl_rectangle_t * rect,
+    gdl_uint32        pitch,
+    gdl_void*         data,
+    gdl_uint32        flags
+    );
+    /**< @ingroup surface
+
+    This routine copies a rectangular region of pixel data into a surface from
+    a buffer.
+
+    @param [in] surface_id
+    The ID of the surface to which the pixel data will be written.  This
+    function is currently only implemented for the following pixel formats, and
+    will return an error code if the surface has any other pixel format:
+    - GDL_PF_ARGB_32
+    - GDL_PF_RGB_32
+    - GDL_PF_RGB_24
+    - GDL_PF_ARGB_16_4444
+    - GDL_PF_RGB_16
+    - GDL_PF_RGB_15
+
+    @param [in] rect
+    The rectangle within the surface to which the data is to be written.
+    The origin is relative to the origin of the surface.  Both the origin
+    coordinates and the dimensions of the rectangle are specified in pixels.
+    A NULL pointer indicates that the rectangle is the entire surface.
+
+    @param [in] pitch
+    The pitch of the input data buffer. It must be greater than or equal to
+    @code
+    rect->width * <bytes-per-pixel>
+    @endcode
+
+    @param [in] data
+    The address of the buffer from which the pixel data should be copied.
+    The pixel format of the data is assumed to be that of the surface.
+    The size of the buffer must be greater than or equal to
+    @code
+    rect->height * pitch
+    @endcode
+
+    @param [in] flags
+    None currently defined -- pass as 0.
+    */
+
+GDL_API gdl_ret_t
+gdl_clear_surface(
+    gdl_surface_id_t surface_id,
+    gdl_color_t *    color
+    );
+    /**< @ingroup surface
+
+    This routine clears a surface by setting all of its pixels to the specified
+    color.
+
+    @param [in] surface_id
+    The ID of the surface to be cleared.  Only packed pixel formats are
+    supported by this function;  if the surface has a pseudo-planar video pixel
+    format, the call will fail.
+
+    @param [in] color
+    The input color for the operation. Note that:
+    - The pixel format of the surface will determine which fields and bits
+      of the gdl_color_t item are used.  For example, if the pixel format is
+      GDL_PF_RGB_16, then:
+      - none of the alpha_index field will be used.
+      - the low-order 5 bits of the r_y field will be used.
+      - the low-order 6 bits of the g_u field will be used.
+      - the low-order 5 bits of the b-v field will be used.
+      .
+    - If the surface is supposed to contain pixels with premultiplied alpha
+      it is the programmer's responsibility to pass a color whose components
+      have been premultiplied.
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_capabilities(
+    gdl_plane_id_t     plane_id,
+    gdl_plane_info_t * info
+    );
+    /**< @ingroup plane_management
+
+    This function returns information about the hardware capabilities of the
+    specified display plane.
+
+    The returned data structure will report the plane name, the
+    programmer-configurable attributes, and the pixel formats supported by the
+    plane.  See #gdl_plane_info_t to determine how to interpret the returned
+    information.
+
+    @param [in]  plane_id
+    The ID of the plane for which information should be returned.
+
+    @param [out] info
+    Plane information is returned here.
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_config_begin(
+    gdl_plane_id_t plane_id
+    );
+    /**< @ingroup plane_management
+
+    This function begins a configuration transaction for the specified plane.
+
+    After making this call, the application program can call the gdl_plane_set_*
+    functions to change the attributes of interest.  No new attribute values
+    are actually set in the hardware until a call is made to
+    gdl_plane_config_end().
+
+    The "batching" of attribute settings reduces the number of round trips
+    made to the driver and helps avoid invalid intermediate states when
+    interrelated attributes are being changed.
+
+    Only one transaction can be open at a time.  If a corresponding call to
+    gdl_plane_config_end() is not made before the next call to
+    gdl_plane_config_begin(), an error will be returned.
+
+    @param [in]  plane_id
+        The ID of the plane for which a configuration transaction should be
+        begun.
+
+    @see gdl_plane_config_end(), gdl_plane_set_uint(), gdl_plane_set_int(),
+         gdl_plane_set_rect(), gdl_plane_set_attr(),
+    */
+
+
+GDL_API gdl_ret_t
+gdl_plane_config_end(
+    gdl_boolean_t abort
+    );
+    /**< @ingroup plane_management
+
+    This function delimits the end of a configuration transaction.  All
+    attributes specified via gdl_plane_set_* calls since the last call to
+    gdl_plane_config_begin() are validated and applied.
+
+    The 'abort' argument causes all pending configuration settings to be
+    discarded without being applied.
+
+    It is an error to call this function without a preceding call to
+    gdl_plane_config_begin().  If this function is called with abort=#GDL_TRUE,
+    the return value can be safely ignored and the caller is guaranteed that
+    there are no configuration operations pending or in progress for the calling
+    application.
+
+    @param [in] abort
+        If #GDL_FALSE, all plane attributes set since the last call to
+        gdl_plane_config_begin() are validated and applied.  Otherwise, all
+        pending settings are discarded and the transaction is terminated
+        without any change to the hardware.
+
+    @see gdl_plane_config_begin()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_set_int(
+    gdl_plane_attr_t name,
+    gdl_int32        value
+    );
+    /**< @ingroup plane_management
+         See gdl_plane_set_attr()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_set_uint(
+    gdl_plane_attr_t name,
+    gdl_uint32       value
+    );
+    /**< @ingroup plane_management
+         See gdl_plane_set_attr()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_set_rect(
+    gdl_plane_attr_t  name,
+    gdl_rectangle_t * value
+    );
+    /**< @ingroup plane_management
+         See gdl_plane_set_attr()
+    */
+
+
+GDL_API gdl_ret_t
+gdl_plane_set_attr(
+    gdl_plane_attr_t name,
+    void *           value
+    );
+    /**< @ingroup plane_management
+    These functions queue the specified attribute setting for execution in the
+    currently open configuration transaction.  They vary from each other only
+    in the type of value they accept, which must be appropriate for the
+    specified attribute.
+
+    It is an error to call any of these functions with the "name" of an
+    attribute that has a type different from that of the function.
+
+    It is an error to call any of these functions without a preceding call to
+    gdl_plane_config_begin().
+
+    The plane is not actually reconfigured until the next call to
+    gdl_plane_config_end().  It is possible that an error caused by passing
+    erroneous or conflicting values to the "set" functions will not be
+    detected until then.
+
+    Note that data values passed to these routines are cached -- the
+    application does @b not need to preserve the data or pointers until the
+    gdl_plane_config_end() is called.
+
+    @param [in] name
+        The attribute to be changed.
+
+    @param [in] value
+        The new setting (or, for multi-word values, pointer to the new setting)
+        for the attribute.
+
+    @see gdl_plane_config_begin(),  gdl_plane_config_end()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_get_int(
+    gdl_plane_id_t   plane,
+    gdl_plane_attr_t name,
+    gdl_int32 *      value
+    );
+    /**< @ingroup plane_management
+     See gdl_plane_get_attr()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_get_uint(
+    gdl_plane_id_t   plane,
+    gdl_plane_attr_t name,
+    gdl_uint32 *     value
+    );
+    /**< @ingroup plane_management
+      See gdl_plane_get_attr()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_get_rect(
+    gdl_plane_id_t    plane,
+    gdl_plane_attr_t  name,
+    gdl_rectangle_t * value
+    );
+    /**< @ingroup plane_management
+      See gdl_plane_get_attr()
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_get_attr(
+    gdl_plane_id_t   plane,
+    gdl_plane_attr_t name,
+    void *           value
+    );
+    /**< @ingroup plane_management
+    These functions retrieve the current value of the specified attribute
+    for the specified plane.  These functions vary from each other only in the
+    type of value they return.
+
+    It is an error to call any of these functions with the "name" of an
+    attribute that has a type different from that of the function.
+
+    @param [in] plane
+        The plane to be queried.
+
+    @param [in] name
+        The attribute whose value is to be retrieved.
+
+    @param [out] value
+        The current value of the attribute is returned here.
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_reset(
+    gdl_plane_id_t plane
+    );
+    /**< @ingroup plane_management
+    Disables the specified plane and resets its attributes to their defaults.
+
+    @param [in] plane
+        The plane to be reset.
+    */
+
+GDL_API gdl_ret_t
+gdl_plane_reset_all(
+    void
+    );
+    /**< @ingroup plane_management
+    Disables all planes and reset their attributes to their defaults.
+    */
+
+GDL_API gdl_ret_t
+gdl_flip(
+    gdl_plane_id_t   plane_id,
+    gdl_surface_id_t surface_id,
+    gdl_flip_t       sync
+    );
+    /**< @ingroup plane_management
+
+    This function makes a specified surface visible on the specified plane.
+    The pixel format and dimensions of the surface must match the current
+    configuration of the plane.
+
+    @param [in] plane_id
+    The plane onto which the surface should be flipped.
+
+    @param [in] surface_id
+    The ID of the surface to be flipped onto the plane, normally returned by
+    gdl_alloc_surface().  If the surface ID is #GDL_SURFACE_INVALID, the plane
+    will be disabled; otherwise, the plane is enabled if necessary.
+
+    @param [in] sync
+    Determines how flipping of the surface is synchronized with the caller.
+    See the description of #gdl_flip_t for details.
+
+    @b NOTE
+    - If the client that allocated a displayed surface exits,
+      deallocates the surface or calls #gdl_close, then the plane on which
+      the surface was flipped will automatically be disabled.
+    */
+
+
+GDL_API gdl_ret_t
+gdl_port_pd_load(
+    char *     pd_name,
+    gdl_uint32 args_num,
+    char **    args
+    );
+    /**< @ingroup  disp_pd
+
+    Load a port driver and optionally pass it arguments.
+
+    @param [in] pd_name
+    Name of port driver (specified as path to the port driver .so file).
+
+    @param [in] args_num
+    Number of supplied arguments.
+
+    @param [in] args
+    Array of arguments, where each argument is a string of the form
+    "<attr>=<value>".
+    */
+
+GDL_API gdl_ret_t
+gdl_port_pd_unload(
+    char *pd_name
+    );
+
+    /**< @ingroup  disp_pd
+
+    Unload a port driver.
+
+    @param [in] pd_name
+    Name of the port driver (specified as the name of its .so file, but
+    without the .so extension).
+    */
+
+GDL_API gdl_ret_t
+gdl_port_set_attr(
+    gdl_pd_id_t           pd_id,
+    gdl_pd_attribute_id_t attribute_id,
+    void *                attribute_value
+    );
+    /**< @ingroup disp_pd
+
+    Set the current value of a port driver attribute.
+
+    @param [in] pd_id
+    Port driver ID.
+
+    @param [in] attribute_id
+    Attribute ID.
+
+    @param [in] attribute_value
+    Pointer to value to which attribute should be set.
+    */
+
+GDL_API gdl_ret_t
+gdl_port_get_attr(
+    gdl_pd_id_t           pd_id,
+    gdl_pd_attribute_id_t attribute_id,
+    gdl_pd_attribute_t *  attribute
+    );
+    /**< @ingroup disp_pd
+
+    Retrieve the current value of a port driver attribute.
+
+    @param [in] pd_id
+    Port driver ID.
+
+    @param [in] attribute_id
+    Attribute ID.
+
+    @param [out] attribute
+    Attribute value returned here.
+    */
+
+GDL_API gdl_ret_t
+gdl_port_send(
+    gdl_pd_id_t   pd_id,
+    gdl_pd_send_t data_id,
+    void *        data,
+    unsigned int  data_size
+    );
+    /**< @ingroup disp_pd
+
+    Send port-specific data to a port driver. This function allows the sending
+    of port-specific data structures, which in turn may kick off device-specific
+    operations.
+
+    @param [in] pd_id
+    Port driver ID.
+
+    @param [in] data_id
+    An identifier indicating the kind of data structure being sent.  Based
+    on this ID, the port driver will determine the format of the data and the
+    operation to be performed.  See the description of #gdl_pd_send_t for more
+    details.
+
+    @param [in] data
+    Pointer to the beginning of the data structure to be sent.
+
+    @param [in] data_size
+    Size of the data structure in bytes.
+    */
+
+GDL_API gdl_ret_t
+gdl_port_recv(
+    gdl_pd_id_t   pd_id,
+    gdl_pd_recv_t data_id,
+    void *        data,
+    unsigned int  data_size
+    );
+    /**< @ingroup disp_pd
+
+    Retrieve port-specific data from a port driver.
+
+    @param [in] pd_id
+    Port driver ID.
+
+    @param [in] data_id
+    An identifier indicating the kind of data structure to be returned.  Based
+    on this ID, the port driver will determine how to retrieve the data and
+    how to format it for output.  See the description of #gdl_pd_recv_t for
+    more details.
+
+    @param [out] data
+    The data structure is returned here.
+
+    @param [in] data_size
+    Size, in bytes, of the output buffer pointed at by 'data'.
+    */
+
+GDL_API char *
+gdl_get_error_string(
+    gdl_ret_t gdl_ret
+    );
+    /**< @ingroup debug
+
+    This function returns a character string representation of the passed
+    enumerator.
+
+    @param [in] gdl_ret
+    A GDL return value.
+    */
+
+GDL_API void
+gdl_dbg_dump_display_info(
+    gdl_display_info_t * d
+    );
+    /**< @ingroup debug
+
+    This function prints the content of the specified #gdl_display_info_t to
+    stdout.
+
+    @param [in] d
+    The structure whose contents are to be printed
+    */
+
+GDL_API void
+gdl_dbg_dump_surface_info(
+    gdl_surface_info_t * s
+    );
+    /**< @ingroup debug
+
+    This function prints the content of the specified #gdl_surface_info_t to
+    stdout.
+
+    @param [in] s
+    The structure whose contents are to be printed
+    */
+
+GDL_API char *
+gdl_dbg_string_attribute(
+    gdl_plane_attr_t attr
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of a
+    plane attribute ID.
+
+    @param [in] attr
+    The ID for which the string should be returned.
+    */
+
+GDL_API char *
+gdl_dbg_string_pixel_format(
+    gdl_pixel_format_t pf
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of a
+    pixel format ID.
+
+    @param [in] pf
+    The ID for which the string should be returned.
+    */
+
+GDL_API char *
+gdl_dbg_string_plane_id(
+    gdl_plane_id_t pid
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of a
+    plane ID.
+
+    @param [in] pid
+    The plane ID for which the string should be returned.
+    */
+
+GDL_API char *
+gdl_dbg_string_refresh(
+    gdl_refresh_t r
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of a
+    display refresh rate enumerator.
+
+    @param [in] r
+    The enumerator for which the string should be returned.
+    */
+
+GDL_API char *
+gdl_dbg_string_sampling_rate(
+    gdl_hdmi_audio_fs_t fs
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of an
+    HDMI audio sampling rate enumerator.
+
+    @param [in] fs
+    The enumerator for which the string should be returned.
+    */
+
+GDL_API char *
+gdl_dbg_string_sample_size(
+    gdl_hdmi_audio_ss_t ss
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of an
+    HDMI audio sample size enumerator.
+
+    @param [in] ss
+    The enumerator for which the string should be returned.
+    */
+
+
+GDL_API char *
+gdl_dbg_string_audio_format(
+    gdl_hdmi_audio_fmt_t fmt
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of an
+    HDMI audio format enumerator.
+
+    @param [in] fmt
+    The enumerator for which the string should be returned.
+    */
+
+GDL_API char *
+gdl_dbg_string_speaker_map(
+    gdl_hdmi_audio_speaker_map_t map
+    );
+    /**< @ingroup debug
+
+    This function returns a pointer to a 0-terminated string representation of an
+    HDMI speaker allocation enumerator.
+
+    @param [in] map
+    The enumerator for which the string should be returned.
+    */
+
+GDL_API gdl_ret_t
+gdl_event_register(
+    gdl_app_event_t      event,
+    gdl_event_callback_t callback,
+    void *               user_data
+    );
+    /**< @ingroup general
+    This function registers a callback function for the specified event, 
+    causing the function to be called every time the event occurs.
+
+    Only one callback may be registered for a particular event.
+    however, the same callback function can be registered for multiple events.
+    The event which triggered the callback will be passed to the function
+    when it is evoked.
+
+    The callback function will be called asynchronously and should take the
+    necessary precautions to prevent contention for global data structures.
+    Callback functions do not have to be re-entrant: once any callback has
+    been invoked for an event, all other events are put on hold until the
+    callback returns. This could require the function to register the event
+    with the application for synchronous processing and return to the caller
+    ASAP.
+    
+    Every time a callback function is called it will be passed 'user_data'.
+    
+    @param [in] event
+    Event of interest.
+
+    @param [in] callback
+    Callback function
+
+    @param [in] user_data
+    User data that will be passed into a callback function.
+    */
+
+GDL_API gdl_ret_t
+gdl_event_unregister(
+    gdl_app_event_t    event
+    );
+    /**< @ingroup general
+    This function unregisters the callback from being called for a specified event.
+    Since the same callback function can be registered for more than one event, 
+    other events will continue triggering an execution of the callback function.
+    
+    @param [in] event
+    Event of interest
+    */
+
+GDL_API gdl_ret_t
+gdl_debug_log_start(
+    char *       filename,
+    unsigned int flags
+    );
+    /**< @ingroup debug
+    This function begins logging of function calls within the GDL daemon.
+    This type of logging is primarily intended for use by GDL driver developers
+    in trouble-shooting problems.
+    
+    @param [in] filename
+    The pathname of the file to which the log information will be written.  If
+    a file with the same pathname already exists, it will be deleted before
+    logging begin.
+
+    @param [in] flags
+    The type of information that should be logged, passed as the OR-ed
+    combination members of the #gdl_log_flag_t enumeration.
+    */
+
+GDL_API gdl_ret_t
+gdl_debug_log_stop(
+    void
+    );
+    /**< @ingroup debug
+    This function terminates driver-side logging previously started with
+    gdl_debug_log_start().
+    */
+
+
+GDL_API gdl_ret_t
+gdl_create_surface(
+    gdl_surface_info_t * surface_info
+    );
+    /**< @ingroup surface
+    This function allows a surface to be created from memory allocated outside of
+    the display driver.
+    
+    The memory must be @b physically contiguous, and must remain available until
+    after the surface is freed.
+ 
+    @param [in,out] surface_info
+    The surface information used to create the GDL surface.  The @b physical
+    address of the start of the memory must be passed in the
+    'surface_info.phys_addr' field.  @b All other fields must be correctly
+    filled before the structure is passed to this function, with the
+    exception of the following:
+    - id:  will be filled in with a value surface ID upon successful return
+      from this function.
+    - heap_phys_addr: will be ignored and overwritten by this function.
+    */
+
+
+GDL_API gdl_ret_t
+gdl_attach_heap(
+    const char * heap_name
+    );
+    /**< @ingroup surface
+    This function makes the specified heap available for allocation of surfaces
+    in the calling process via #gdl_alloc_surface().
+    
+    heap_name must appear in the platform configuration file under the node 
+    'platform.startup.memory.layout'. The memory whose physical
+    base address and size are specified there will be made available to the
+    calling process.
+
+    Once a heap is attached to a process, the display driver may satisfy surface
+    allocation requests from either its default (static) heap or the attached
+    one.
+
+    Multiple processes may attach the same heap. A process may attach multiple
+    heaps. An error will be returned if a process tries to attach to two
+    differnt heaps that overlap.
+
+    There is no need to de-attach a heap; it is sufficient to free all surfaces
+    allocated by the process. The display driver will automatically free any
+    remaining surfaces allocated by a proces when #gdl_close() is called.
+
+    An attached heap is available to a process from the moment it is attached
+    until the GDL session for the process is terminated.
+
+    This function allows device memory (physical memory beyond the end of the
+    operating system) normally reserved for video playback to be reallocated
+    at runtime for use by graphics-intensive operations. It is expected that
+    the controlling application will terminate video playback to make the 
+    memory available before starting a graphics-intensive application that
+    will attach the heap. The controlling application itself should not
+    attach the memory as there will be no way to relinquish it when the 
+    graphics application stops and it is time to play video again
+    
+    @param [in] heap_name
+    The name of the heap as it appears in the platform configuration file under
+    the 'platform.startup.memory.layout' node.
+    */
+
+
+GDL_API gdl_ret_t
+gdl_heap_in_use(
+    const char    * heap_name,
+    gdl_boolean_t * status
+    );
+    /**< @ingroup surface
+    This function determines whether any surfaces are currently allocated from 
+    the specified heap.
+
+    Returns status GDL_FALSE if no surfaces are currently allocated from the
+    specified heap or GDL_TRUE otherwise. Fails if the heap name does not
+    appear in the platform configuration file.
+
+    @param [in] heap_name
+    A name of the heap as it appears in platform configuration file under the
+    'platform.startup.memory.layout'. 
+
+    @param [out] status
+    Returned status.
+    */
+
+
+#if defined(__cplusplus)
+};
+#endif
+
+#endif
diff --git a/make/stub_includes/embedded/IntelGDL/gdl_pd.h b/make/stub_includes/embedded/IntelGDL/gdl_pd.h
new file mode 100644
index 000000000..c39f1a6f0
--- /dev/null
+++ b/make/stub_includes/embedded/IntelGDL/gdl_pd.h
@@ -0,0 +1,938 @@
+//-----------------------------------------------------------------------------
+// This file is provided under a dual BSD/GPLv2 license.  When using or 
+// redistributing this file, you may do so under either license.
+//
+// GPL LICENSE SUMMARY
+//
+// Copyright(c) 2005-2009 Intel Corporation. All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify 
+// it under the terms of version 2 of the GNU General Public License as
+// published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful, but 
+// WITHOUT ANY WARRANTY; without even the implied warranty of 
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License 
+// along with this program; if not, write to the Free Software 
+// Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+// The full GNU General Public License is included in this distribution 
+// in the file called LICENSE.GPL.
+//
+// Contact Information:
+//      Intel Corporation
+//      2200 Mission College Blvd.
+//      Santa Clara, CA  97052
+//
+// BSD LICENSE 
+//
+// Copyright(c) 2005-2009 Intel Corporation. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without 
+// modification, are permitted provided that the following conditions 
+// are met:
+//
+//   - Redistributions of source code must retain the above copyright 
+//     notice, this list of conditions and the following disclaimer.
+//   - Redistributions in binary form must reproduce the above copyright 
+//     notice, this list of conditions and the following disclaimer in 
+//     the documentation and/or other materials provided with the 
+//     distribution.
+//   - Neither the name of Intel Corporation nor the names of its 
+//     contributors may be used to endorse or promote products derived 
+//     from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//---------------------------------------------------------------------------*/
+
+#ifndef _GDL_PD_H_
+#define _GDL_PD_H_
+
+#include "gdl_types.h"
+
+
+/** @ingroup disp_pd
+ Existing port driver IDs with room for user specified port drivers.
+ When communicating with a specific port driver the port id must be passed.
+*/
+typedef enum
+{
+    GDL_PD_MIN_SUPPORTED_DRIVERS=0, ///< Port Driver IDs start at this value
+
+    GDL_PD_ID_INTTVENC = GDL_PD_MIN_SUPPORTED_DRIVERS,  ///< CVBS TV encoder
+    GDL_PD_ID_INTTVENC_COMPONENT, ///< Component TV encoder
+    GDL_PD_ID_HDMI,               ///< HDMI
+    GDL_PD_ID_USER_MIN,           ///< Begin user defined drivers
+    GDL_PD_ID_USER_MAX = 8,       ///< End user defined drivers
+
+    GDL_PD_MAX_SUPPORTED_DRIVERS  ///< Maximum number of port drivers.
+} gdl_pd_id_t;
+
+
+
+/** @ingroup disp_pd
+Defined port driver attributes.  Which ones are supported (and exactly how)
+can vary from one port driver to another.  See the Intel� CE Media Processors
+GDL 3.0 Programming Guide for details on the attributes supported by
+each port driver.
+*/
+
+// *NOTE* Extend pd_lib.c::__pd_attr_get_name() when adding new entries
+typedef enum
+{
+    GDL_PD_MIN_SUPPORTED_ATTRIBUTES=0,  ///< Attribute ID enum's start at this value
+
+    // HDMI RELATED
+    GDL_PD_ATTR_ID_HDCP = GDL_PD_MIN_SUPPORTED_ATTRIBUTES, ///< HDCP control
+    GDL_PD_ATTR_ID_HDCP_AUTO_MUTE,      ///< HDCP auto mute
+    GDL_PD_ATTR_ID_HDCP_STATUS,         ///< HDCP status
+    GDL_PD_ATTR_ID_HDCP_1P1,            ///< HDCP 1.1 Pj check control
+    GDL_PD_ATTR_ID_COLOR_SPACE_INPUT,   ///< Input colorspace
+    GDL_PD_ATTR_ID_PIXEL_FORMAT_OUTPUT, ///< Output colorspace
+    GDL_PD_ATTR_ID_PIXEL_DEPTH,         ///< Depth of outgoing pixels
+    GDL_PD_ATTR_ID_BG_COLOR,            ///< Fixed color for HDCP failure
+    GDL_PD_ATTR_ID_CABLE_STATUS,        ///< Cable status
+    GDL_PD_ATTR_ID_PAR,                 ///< Picture aspect ratio
+    GDL_PD_ATTR_ID_FAR,                 ///< Format aspect ratio
+    GDL_PD_ATTR_ID_USE_EDID,            ///< TV timings source
+    GDL_PD_ATTR_ID_SLOW_DDC,            ///< DDC bus speed
+    GDL_PD_ATTR_ID_EQUALIZE,            ///< Equalization level
+    GDL_PD_ATTR_ID_TRANSMIT_LEVEL,      ///< Transmit level amplitude
+    GDL_PD_ATTR_ID_TERMINATION,         ///< Termination impedance
+    GDL_PD_ATTR_ID_AUDIO_CLOCK,         ///< Audio clock
+    GDL_PD_ATTR_ID_COLOR_SPACE_EXT,     ///< Extended colorimetry
+    GDL_PD_ATTR_ID_SENSE_DELAY,         ///< TV sensing delay after HPD
+    GDL_PD_ATTR_ID_OUTPUT_CLAMP,        ///< Clamp the output in (16,235) when 
+                                        ///< it is RGB color space. In YCbCr output
+                                        ///< this attribute is ignored.
+
+    // ANALOG RELATED
+    GDL_PD_ATTR_ID_BRIGHTNESS,          ///< Brightness Level
+    GDL_PD_ATTR_ID_CONTRAST,            ///< Contrast Level
+    GDL_PD_ATTR_ID_HUE,                 ///< Hue Angle
+    GDL_PD_ATTR_ID_SATURATION,          ///< Saturation Level
+    GDL_PD_ATTR_ID_ACP,                 ///< Analog Content Protection
+    GDL_PD_ATTR_ID_CC,                  ///< Closed Captioning
+    GDL_PD_ATTR_ID_UNDERSCAN,           ///< Output scaler
+    GDL_PD_ATTR_ID_SHARPNESS_HLUMA,     ///< Horizontal Luma filter
+    GDL_PD_ATTR_ID_SHARPNESS_HCHROMA,   ///< Horizontal Chroma Filter
+    GDL_PD_ATTR_ID_BLANK_LEVEL,         ///< Sync pulse level
+    GDL_PD_ATTR_ID_BLACK_LEVEL,         ///< Black Level
+    GDL_PD_ATTR_ID_BURST_LEVEL,         ///< Burst Level
+    GDL_PD_ATTR_ID_FLICKER,             ///< Adaptive Flicker Filter
+    GDL_PD_ATTR_ID_CHROMA_FILTER,       ///< Pre Chroma filter
+    GDL_PD_ATTR_ID_TVOUT_TYPE,          ///< Current DAC configuration
+    GDL_PD_ATTR_ID_TESTMODE,            ///< Test pattern generator
+    GDL_PD_ATTR_ID_3CH_SYNC,            ///< 3 Channel sync
+    GDL_PD_ATTR_ID_SD_OPTION,           ///< Alternate SD mode (e.g.: PAL-M,
+                                        ///<    PAL-N, etc.)
+    GDL_PD_ATTR_ID_RGB,                 ///< RGB / YPbPr output selection
+    GDL_PD_ATTR_ID_CGMS_MODE,           ///< Current Copy Generation mode
+    GDL_PD_ATTR_ID_NO_SYNC,             ///< Sync removal from green (y) signal
+    GDL_PD_ATTR_ID_YC_DELAY,            ///< Luma vs Chroma delay 
+
+    // COMMON
+    GDL_PD_ATTR_ID_POWER,               ///< Disable DAC output
+    GDL_PD_ATTR_ID_NAME,                ///< Driver name
+    GDL_PD_ATTR_ID_VERSION_MAJOR,       ///< Driver major version
+    GDL_PD_ATTR_ID_VERSION_MINOR,       ///< Driver minor version
+    GDL_PD_ATTR_ID_DEBUG,               ///< Debug log
+    GDL_PD_ATTR_ID_BUILD_DATE,          ///< Driver Build date
+    GDL_PD_ATTR_ID_BUILD_TIME,          ///< Driver Build time
+    GDL_PD_ATTR_ID_DISPLAY_PIPE,        ///< Display Pipeline assigned
+
+    // ANALOG RELATED
+    GDL_PD_ATTR_ID_SVIDEO,              ///< Assignment of component Pb & Pr DACs 
+                                        ///<    for S-Video output
+
+    // HDMI RELATED
+    GDL_PD_ATTR_ID_AUDIO_STATUS,        ///< Status of audio playback
+
+    // EXTENDED
+    GDL_PD_ATTR_ID_USER_MIN,            ///< Start of user defined attributes
+    GDL_PD_ATTR_ID_USER_MAX = 100,      ///< Max user defined attribute
+
+    GDL_PD_MAX_SUPPORTED_ATTRIBUTES     ///< End of attribute IDs; must be last
+} gdl_pd_attribute_id_t;
+
+
+/** @ingroup disp_pd
+
+ Attribute usage flags.
+*/
+// TODO: Move GDL_PD_ATTR_FLAG_SUPPORTED since it's internal to PD */
+typedef enum
+{
+    GDL_PD_ATTR_FLAG_WRITE     = 0x1, /**< Attribute can be written           */
+    GDL_PD_ATTR_FLAG_SUPPORTED = 0x2, /**< Attribute is supported on this port
+                                           driver. FOR INTERNAL USE ONLY.     */
+    GDL_PD_ATTR_FLAG_INTERNAL  = 0x4, /**< Attribute is invisible to outside
+                                         world. FOR INTERNAL USE ONLY         */
+} gdl_pd_attribute_flag_t;
+
+//------------------------------------------------------------------------------
+// Attribute flags used internally to override / extend certain behavior
+// NOTE: Make sure values don't collide with gdl_pd_attribute_flag_t
+//------------------------------------------------------------------------------
+#define GDL_PD_ATTR_FLAG_FORCED 0x8000   // Read only is ignored
+
+/** @ingroup disp_pd
+    Attribute types
+*/
+typedef enum
+{
+    GDL_PD_ATTR_TYPE_UINT,      /**< Attribute is of type #gdl_uint32.      */
+    GDL_PD_ATTR_TYPE_BOOLEAN,   /**< Attribute is of type #gdl_boolean_t.   */
+    GDL_PD_ATTR_TYPE_STRING     /**< Attribute is a read-only 0-terminated
+                                     ASCII string.
+                                */
+} gdl_pd_attribute_type_t;
+
+/** @ingroup disp_pd
+   Maximum size of PD string attributes
+*/ 
+#define GDL_PD_MAX_STRING_LENGTH 16
+
+/** @ingroup disp_pd
+     This structure represents port driver attribute
+*/
+typedef struct
+{
+    gdl_pd_attribute_id_t   id;     ///<  Global attribute ID.
+    gdl_pd_attribute_type_t type;   ///<  Data type of attribute.
+    gdl_pd_attribute_flag_t flags;  ///<  Access permissions and internal use
+
+    char                    name[GDL_PD_MAX_STRING_LENGTH+1];
+    
+    union ///< Attribute data dependent on attribute type
+    {
+        struct
+        {
+            gdl_uint32      value_default;  ///<  default value
+            gdl_uint32      value_min;      ///<  minimum value
+            gdl_uint32      value_max;      ///<  maximum value
+            gdl_uint32      value;          ///<  current value
+        } _uint;
+        
+        struct
+        {
+            gdl_boolean_t   value_default;  ///<  default value
+            gdl_boolean_t   value;          ///<  current value
+        } _bool;
+
+        struct
+        {
+            char    value[GDL_PD_MAX_STRING_LENGTH+1]; ///< current value
+        } string;
+
+    } content;
+} gdl_pd_attribute_t;
+
+/** @ingroup disp_pd
+    The Internal TV Encoders can support several different TV standards when
+    they are used in Standard Definition (SD) resolutions.  The entries in
+    this enumeration are values that can be used to set the
+    GDL_PD_ATR_ID_SD_OPTION attribute to specify the standard to be used for SD.
+*/
+typedef enum 
+{
+    TV_STD_UNDEFINED   = 0, ///< Use Default per resolution
+    TV_STD_NTSC        = 0, ///< Use NTSC for 720x480i mode.
+    TV_STD_PAL         = 0, ///< Use PAL for 720x576i mode.
+    TV_STD_NTSC_J      = 1, ///< Use NTSC-J (Japan) for 720x480i mode.
+    TV_STD_PAL_M       = 2, ///< Use PAL-M (Brazil) for 720x480i mode.
+    TV_STD_PAL_N       = 3, ///< Use PAL-N (Argentina) for 720x576i mode.
+    TV_STD_MAX              ///< The number of IDs in this enumeration.
+} gdl_pd_sd_option_t;
+
+//-----------------------------------------------------------------------------
+// Unique IDs for [end user -> port driver] communication
+//-----------------------------------------------------------------------------
+/** @ingroup disp_pd
+    Command codes for the gdl_port_send() function.
+*/
+typedef enum
+{
+    GDL_PD_SEND_CC = 0,
+        ///< Closed Captioning data; see #gdl_cc_data_t
+    GDL_PD_SEND_PAL_WSS,
+        ///< Pal Wide Screen signaling; See #gdl_wss_data_t
+    GDL_PD_SEND_CGMS_A,
+        ///< CGMS-A for NTSC and ATSC formats; See #gdl_cgms_data_t
+    GDL_PD_SEND_HDMI_AUDIO_CTRL,
+        ///< HDMI audio data; See #gdl_hdmi_audio_ctrl_t
+    GDL_PD_SEND_HDMI_HDCP_SRM,
+        ///< HDCP System Renewability Message
+    GDL_PD_SEND_HDMI_PACKET,
+        ///< Generic HDMI packet; See #gdl_hdmi_packet_info_t
+    GDL_PD_SEND_USER_MIN,
+        /**< External (non-Intel) port drivers may define command codes starting
+             with this value.
+        */
+    GDL_PD_SEND_USER_MAX = 30
+        /**< External (non-Intel) port drivers may define command codes up to
+             this value.
+        */
+} gdl_pd_send_t;
+
+//-----------------------------------------------------------------------------
+// Unique IDs for [port driver -> end user] communication
+//-----------------------------------------------------------------------------
+/** @ingroup disp_pd
+    Command codes for retrieving port driver extended information 
+    via gdl_port_recv().
+*/
+typedef enum
+{
+    GDL_PD_RECV_HDMI_AUDIO_CTRL = 0, /**< Audio control information 
+                                          see #gdl_hdmi_audio_ctrl_t       */
+    GDL_PD_RECV_HDMI_SINK_INFO,      /**< HDMI sink information 
+                                          see #gdl_hdmi_sink_info_t        */
+    GDL_PD_RECV_HDMI_EDID_BLOCK,     /**< 128 bytes of raw EDID
+                                          see #gdl_hdmi_edid_block_t       */
+    GDL_PD_RECV_HDMI_HDCP_INFO,      /**< HDCP information        */
+    GDL_PD_RECV_HDMI_HDCP_KSVS,      /**< HDCP keys selection vectors      */
+    GDL_PD_RECV_USER_MIN,            /**< Begin user defined command codes */
+    GDL_PD_RECV_USER_MAX = 30        /**< End user defined command codes   */
+} gdl_pd_recv_t;
+
+//-----------------------------------------------------------------------------
+// Output pixel format
+//-----------------------------------------------------------------------------
+/** @ingroup disp_pd
+    Attribute values for the HDMI output pixel format.
+    See #GDL_PD_ATTR_ID_PIXEL_FORMAT_OUTPUT.
+*/
+typedef enum
+{
+    GDL_PD_OPF_RGB444 = 0,          ///< RGB 4:4:4 Output
+    GDL_PD_OPF_YUV422,              ///< YUV 4:2:2 Output
+    GDL_PD_OPF_YUV444,              ///< YUV 4:4:4 Output
+    GDL_PD_OPF_COUNT                ///< Number of output pixel formats + 1
+} gdl_pd_output_pixel_format_t;
+
+//-----------------------------------------------------------------------------
+// Output pixel depth
+//-----------------------------------------------------------------------------
+/** @ingroup disp_pd
+    Attribute values for the HDMI output pixel depth.
+    See #GDL_PD_ATTR_ID_PIXEL_DEPTH.
+*/
+typedef enum
+{
+    GDL_PD_OPD_24BIT = 0,       ///< 24 bits per pixel
+    GDL_PD_OPD_30BIT,           ///< 30 bits per pixel
+    GDL_PD_OPD_36BIT,           ///< 36 bits per pixel
+    GDL_PD_PIXEL_DEPTH_COUNT    ///< Number of supported pixel depths + 1
+} gdl_pd_output_pixel_depth_t;
+
+//------------------------------------------------------------------------------
+// Picture Aspect Ratio infoframe code
+//------------------------------------------------------------------------------
+/** @ingroup disp_pd
+    Attribute values for the HDMI Picture Aspect Ratio information sent via
+    AVI infoframes. See #GDL_PD_ATTR_ID_PAR .
+*/
+typedef enum
+{
+    GDL_PD_PAR_NO_DATA = 0x00,      ///< No aspect ratio specified
+    GDL_PD_PAR_4_3     = 0x01,      ///< 4:3 aspect ratio
+    GDL_PD_PAR_16_9    = 0x02,      ///< 16:9 aspect ratio
+} gdl_pd_par_t;
+
+//------------------------------------------------------------------------------
+// Format Aspect Ratio infoframe code
+//------------------------------------------------------------------------------
+/** @ingroup disp_pd
+    Attribute values for the HDMI Format Aspect Ratio information sent via
+    AVI infoframes. See #GDL_PD_ATTR_ID_FAR.
+*/
+typedef enum
+{
+    GDL_PD_FAR_16_9_TOP      = 0x02, ///< box 16:9 (top)
+    GDL_PD_FAR_14_9_TOP      = 0x03, ///< box 14:9 (top)
+    GDL_PD_FAR_G_14_9_CENTER = 0x04, ///< box > 16:9 (center)
+    GDL_PD_FAR_SAME_AS_PAR   = 0x08, ///< As encoded frame
+    GDL_PD_FAR_4_3_CENTER    = 0x09, ///< 4:3 center
+    GDL_PD_FAR_16_9_CENTER   = 0x0A, ///< 16:9 center
+    GDL_PD_FAR_14_9_CENTER   = 0x0B, ///< 14:9 center
+    GDL_PD_FAR_4_3_SP_14_9   = 0x0D, ///< 4:3 with s&p 14:9 center
+    GDL_PD_FAR_16_9_SP_14_9  = 0x0E, ///< 16:9 with s&p 14:9 center
+    GDL_PD_FAR_16_9_SP_4_3   = 0x0F, ///< 4:3 with s&p 4:3 center
+} gdl_pd_far_t;
+
+
+//------------------------------------------------------------------------------
+// V B I   S E R V I C E S
+//------------------------------------------------------------------------------
+/** @ingroup disp_pd
+    When inserting VBI information into the analog TV signal, this enumeration
+    is used to indicate the field into which the information should be inserted.
+*/
+typedef enum 
+{
+    VBI_FIELD_ID_ODD       = 1, /**< Odd field (field 1).   */
+    VBI_FIELD_ID_EVEN      = 2, /**< Even field (field 2).  */
+    VBI_FIELD_ID_UNDEFINED = 3  /**< This value should be passed when the
+                                     display is in a progressive (frame) mode.
+                                */
+} gdl_pd_vbi_fieldid_t;
+
+/** @ingroup disp_pd
+
+    This enumeration is used to specify values for the #GDL_PD_ATTR_ID_ACP
+    attribute (the Analog Copy Protection mode).
+*/
+typedef enum
+{
+    ACP_MODE_OFF,           ///<  ACP Off
+    ACP_MODE_PSP,           ///<  Pseudo Sync Pulse + No Color Stripes
+    ACP_MODE_PSP_CS_2_LINES,///<  Pseudo Sync Pulse + Color Stripes (2 lines)
+    ACP_MODE_PSP_CS_4_LINES ///<  Pseudo Sync Pulse + Color Stripes (4 lines)
+} gdl_pd_acp_mode_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for CGMS-A copy permission states to be
+    inserted into the analog TV signal. See the #gdl_cgms_data_t data structure.
+*/
+typedef enum 
+{
+    CGMS_A_COPY_FREELY     = 1, ///< Unlimited Copies can be made
+    CGMS_A_COPY_NOMORE     = 2, ///< Copy has already been made (was reserved)
+    CGMS_A_COPY_ONCE       = 3, ///< One copy can be made
+    CGMS_A_COPY_NEVER      = 4, ///< No copies can be made
+    CGMS_A_NO_DATA         = 5  ///< No data. Word 1 will be 1111
+} gdl_pd_cgms_copy_t;
+
+/** @ingroup disp_pd
+    
+    This enumeration specifies values for CGMS-A aspect ratios to be inserted
+    into the analog TV signal. See the #gdl_cgms_data_t data structure.
+*/
+typedef enum 
+{
+    CGMS_A_4_3      = 1,    ///< Normal 4:3 aspect ratio
+    CGMS_A_4_3_LB   = 2,    ///< 4:3 aspect ratio letterboxed
+    CGMS_A_16_9     = 3     ///< 16:9 aspect ratio (Not available at 480i/576i)
+} gdl_pd_cgms_aspect_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for Wide Screen Signalling aspect ration
+    information to be inserted into the analog TV signal. See the
+    #gdl_wss_data_t data structure.
+*/
+typedef enum 
+{
+    /* PAL specific Modes */
+    WSS_4_3_FF          = 0,    ///< 4:3 Full Format
+    WSS_14_9_LB_C       = 1,    ///< 14:9 Letterbox, Centered
+    WSS_14_9_LB_T       = 2,    ///< 14:9 Letterbox, Top
+    WSS_16_9_LB_C       = 3,    ///< 16:9 Letterbox, Centered
+    WSS_16_9_LB_T       = 4,    ///< 16:9 Letterbox, Top
+    WSS_G_16_9_LB_C     = 5,    ///< >16:9 Letterbox, Centered
+    WSS_14_9_FF         = 6,    ///< 14:9 Full Format
+    WSS_16_9_ANAMORPHIC = 7,    ///< 16:9 Anamorphic
+} gdl_pd_wss_aspect_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for Wide Screen Signalling camera mode
+    information to be inserted into the analog TV signal. See the
+    #gdl_wss_data_t data structure.
+*/
+typedef enum 
+{
+    WSS_CAMERA_MODE = 0, ///< Camera Mode
+    WSS_FILM_MODE   = 1, ///< Film Mode
+} gdl_pd_wss_camera_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for Wide Screen Signalling color encoding
+    information to be inserted into the analog TV signal. See the
+    #gdl_wss_data_t data structure.
+*/
+typedef enum 
+{
+    WSS_CE_NORMAL_PAL = 10, ///< Normal PAL Colors
+    WSS_CE_COLOR_PLUS = 11, ///< Motion Adaptive Color Plus
+} gdl_pd_wss_ce_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values to indicate  Wide Screen Signalling
+    helpers state, to be inserted into the analog TV signal. See the 
+    #gdl_wss_data_t data structure.
+*/
+typedef enum 
+{
+    WSS_HELPERS_NOT_PRESENT = 1, ///< No Helper
+    WSS_HELPERS_PRESENT     = 2, ///< Modulated helper
+
+} gdl_pd_wss_helpers_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for Wide Screen Signalling open subtitles
+    state, to be inserted into the analog TV signal. See the #gdl_wss_data_t
+    data structure.
+*/
+typedef enum 
+{
+    WSS_OPEN_SUBTITLES_NO       = 1,    ///< No open subtitles
+    WSS_OPEN_SUBTITLES_INSIDE   = 2,    ///< Subtitles in active image area
+    WSS_OPEN_SUBTITLES_OUTSIDE  = 3,    ///< Subtitles out of active image area
+} gdl_pd_wss_opensub_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for Wide Screen Signalling surround sound
+    state, to be inserted into the analog TV signal. See the #gdl_wss_data_t
+    data structure.
+*/
+typedef enum 
+{
+    WSS_SURROUND_NO     = 1,    ///< No surround sound information
+    WSS_SURROUND_YES    = 2,    ///< Surround sound present
+} gdl_pd_wss_surround_t;
+
+/** @ingroup disp_pd
+    This enumeration contains the data type identifier for the WSS information
+    to pass to the TV encoder to be inserted into the analog TV signal.
+*/
+typedef enum 
+{
+    WSS_NO_COPYRIGHT    = 1,    ///< No Copyright asserted or status unknown
+    WSS_COPYRIGHT       = 2,    ///< Copyright Asserted
+} gdl_pd_wss_copyright_t;
+
+/** @ingroup disp_pd
+    This enumeration specifies values for Wide Screen Signalling copy
+    restriction state, to be inserted into the analog TV signal. See the
+    #gdl_wss_data_t data structure.
+*/
+typedef enum 
+{
+    WSS_COPY_NO_REST    = 1,    ///< Copying not restricted
+    WSS_COPY_RESTRICTED = 2     ///< Copying Restricted
+} gdl_pd_wss_copy_t;
+
+
+/** @ingroup disp_pd
+
+    This data structure is used to pass closed captioning information to the
+    display driver.  The driver will pass this information to the TV encoder to
+    be inserted into the analog TV signal.
+*/
+typedef struct
+{
+   gdl_pd_vbi_fieldid_t pd_vbi_field_id;
+                                /**< Field ID identifier; See
+                                     #gdl_pd_vbi_fieldid_t.
+                                */
+   unsigned char        data_length;
+                                /**< Number of valid closed caption data bytes
+                                     passed; must be an even number, with a
+                                     maximum value of 8.
+                                */
+   unsigned char        ccdata[8];
+                                /**< Array containing the closed caption data
+                                     to be inserted.
+                                */
+} gdl_cc_data_t;
+
+/** @ingroup disp_pd
+
+    This data structure is used to pass PAL Wide Screen signaling from an
+    application to the display driver.  The driver will pass this
+    information to the TV encoder to be inserted into the PAL analog TV signal.
+
+    Teletext is not supported in silicon. Teletext in subtitle always is 0.
+
+    Standard in use:
+    ETSI EN 300 294 V1.4.1 2003-2004 
+*/
+typedef struct
+{
+    gdl_boolean_t           enabled;     ///< GDL_TRUE => Enabled
+    gdl_pd_wss_aspect_t     aspect;      ///< Aspect Ratio
+    gdl_pd_wss_camera_t     cam_mode;    ///< Camera Mode
+    gdl_pd_wss_ce_t         color_enc;   ///< Color Encoding
+    gdl_pd_wss_helpers_t    helpers;     ///< Helpers Present
+    gdl_pd_wss_opensub_t    open_sub;    ///< Open Subtitles
+    gdl_pd_wss_surround_t   surround;    ///< Surround sound
+    gdl_pd_wss_copyright_t  copyright;   ///< Copyright assertion
+    gdl_pd_wss_copy_t       copy_rest;   ///< Copy Restriction
+} gdl_wss_data_t;
+
+/** @ingroup disp_pd
+
+    This data structure is used to pass Copy Generation Management System
+    (Analog) information from the application to the display driver.  The driver
+    will pass this information to the TV encoder to be inserted into the analog
+    TV signal.
+
+    XDS CEA-608 based CGMS-A should be passed using the Closed Captioning API.
+    See #gdl_cc_data_t
+ 
+    Standard is use: IEC 61880 480i Line20, EIA/CEA-805 480p Line 41, 
+                     720p Line 24 , and 1080i Line 19 
+*/
+typedef struct
+{
+    gdl_boolean_t         enabled;   ///< GDL_TRUE => Enabled
+    gdl_pd_cgms_copy_t    copyGen;   ///< CGMS-A data see #gdl_pd_cgms_copy_t
+    gdl_pd_cgms_aspect_t  aspect;    ///< Wide Screen signaling.
+    gdl_pd_acp_mode_t     mv;        ///< APS
+    gdl_boolean_t         analog_src;///< Analog Source Bit
+} gdl_cgms_data_t;
+
+/** @ingroup disp_pd
+    This enumeration is used to specify values for the #GDL_PD_ATTR_ID_SVIDEO
+    attribute
+*/
+typedef enum
+{
+    GDL_PD_TVOUT_TYPE_COMPOSITE, ///< Composite only
+    GDL_PD_TVOUT_TYPE_SVIDEO,    ///< S-Video only
+    GDL_PD_TVOUT_TYPE_COMPONENT, ///< Reserved for internal use
+    GDL_PD_TVOUT_TYPE_CVBSSV,    ///< Composite and S-video
+} gdl_pd_tvout_type_t;
+
+//------------------------------------------------------------------------------
+//    H D M I   S P E C I F I C   D A T A   T Y P E S
+//------------------------------------------------------------------------------
+
+/** @ingroup disp_pd
+   This structure defines the HDMI audio data blocks.
+*/
+typedef struct
+{
+    gdl_uint32 format;
+    gdl_uint32 max_channels;
+    gdl_uint32 fs;
+    gdl_uint32 ss_bitrate;
+} gdl_hdmi_audio_cap_t;
+
+/** @ingroup disp_pd
+    A CEC Source Physical Address.
+*/
+typedef struct
+{
+    gdl_uint8 a;
+    gdl_uint8 b;
+    gdl_uint8 c;
+    gdl_uint8 d;
+} gdl_src_phys_addr_t;
+
+/** @ingroup disp_pd
+    This data structure represents additional sink details not-available through
+    port attributes
+*/
+typedef struct
+{
+    gdl_uint16          manufac_id;   ///< Sink manufacturer ID
+    gdl_uint16          product_code; ///< Sink product code
+    gdl_boolean_t       hdmi;         ///< Sink is HDMI
+    gdl_boolean_t       ycbcr444;     ///< Sink supports YCbCr444
+    gdl_boolean_t       ycbcr422;     ///< Sink supports YCbCr422
+    gdl_src_phys_addr_t spa;          ///< CEC source physical address a.b.c.d
+    gdl_uint32          speaker_map;  ///< Speaker allocation map
+    gdl_boolean_t       dc_30;        ///< Sink supports 30-bit color
+    gdl_boolean_t       dc_36;        ///< Sink supports 36-bit color
+    gdl_boolean_t       dc_y444;      ///< Sink supports YCbCr444 in supported DC modes
+    gdl_boolean_t       xvycc601;     ///< Sink supports xvYCC BT601 Colorimetry
+    gdl_boolean_t       xvycc709;     ///< Sink supports xvYCC BT709 Colorimetry
+    gdl_boolean_t       supports_ai;  ///< Sink supports aux audio information
+} gdl_hdmi_sink_info_t;
+
+/** @ingroup disp_pd
+    This data structure represents 128 byte EDID block
+*/
+typedef struct
+{
+    gdl_uint8 index;     ///< Block number to read
+    gdl_uint8 data[128]; ///< Block contents
+} gdl_hdmi_edid_block_t;
+
+/** @ingroup disp_pd
+    This data structure represents HDCP topology information
+*/
+typedef struct
+{
+    gdl_boolean_t hdcp_1p1;             ///< Sink supports HDCP 1.1
+    gdl_boolean_t repeater;             ///< Sink is a repeater
+    gdl_boolean_t max_cascade_exceeded; ///< Maximum allowed depth exceeded
+    gdl_uint32    depth;                ///< Topology depth
+    gdl_boolean_t max_devs_exceeded;    ///< Maximum allowed device number exceeded
+    gdl_uint32    device_count;         ///< Number of devices connected to the repeater
+} gdl_hdmi_hdcp_info_t;
+
+/** @ingroup disp_pd
+    This enumeration defines the command IDs for the HDMI audio commands.
+    See #gdl_hdmi_audio_ctrl_t.
+*/
+typedef enum
+{
+    GDL_HDMI_AUDIO_START,           ///< Start audio playback
+    GDL_HDMI_AUDIO_STOP,            ///< Stop audio playback
+    GDL_HDMI_AUDIO_SET_FORMAT,      ///< Set audio format
+    GDL_HDMI_AUDIO_GET_CAPS,        ///< Retrieve descriptor of audio blocks
+    GDL_HDMI_AUDIO_WRITE,           ///< For driver internal use only
+} gdl_hdmi_audio_cmd_id_t;
+
+
+/** @ingroup disp_pd
+    This enumeration defines IDs for different HDMI audio formats.
+*/
+// IMPORTANT: DO NOT change order!!!
+typedef enum
+{
+    GDL_HDMI_AUDIO_FORMAT_UNDEFINED = 0x00,
+    GDL_HDMI_AUDIO_FORMAT_PCM,
+    GDL_HDMI_AUDIO_FORMAT_AC3,
+    GDL_HDMI_AUDIO_FORMAT_MPEG1,
+    GDL_HDMI_AUDIO_FORMAT_MP3,
+    GDL_HDMI_AUDIO_FORMAT_MPEG2,
+    GDL_HDMI_AUDIO_FORMAT_AAC,
+    GDL_HDMI_AUDIO_FORMAT_DTS,
+    GDL_HDMI_AUDIO_FORMAT_ATRAC,
+    GDL_HDMI_AUDIO_FORMAT_OBA,
+    GDL_HDMI_AUDIO_FORMAT_DDP,
+    GDL_HDMI_AUDIO_FORMAT_DTSHD,
+    GDL_HDMI_AUDIO_FORMAT_MLP,
+    GDL_HDMI_AUDIO_FORMAT_DST,
+    GDL_HDMI_AUDIO_FORMAT_WMA_PRO,
+} gdl_hdmi_audio_fmt_t;
+
+/** @ingroup disp_pd
+    This enumeration defines IDs for different HDMI audio sampling frequencies.
+*/
+typedef enum
+{
+    GDL_HDMI_AUDIO_FS_32_KHZ    = 0x01,
+    GDL_HDMI_AUDIO_FS_44_1_KHZ  = 0x02,
+    GDL_HDMI_AUDIO_FS_48_KHZ    = 0x04,
+    GDL_HDMI_AUDIO_FS_88_2_KHZ  = 0x08,
+    GDL_HDMI_AUDIO_FS_96_KHZ    = 0x10,
+    GDL_HDMI_AUDIO_FS_176_4_KHZ = 0x20,
+    GDL_HDMI_AUDIO_FS_192_KHZ   = 0x40,
+} gdl_hdmi_audio_fs_t;
+
+/** @ingroup disp_pd
+    This enumeration defines IDs for different HDMI audio sample sizes.
+*/
+typedef enum
+{
+    GDL_HDMI_AUDIO_SS_UNDEFINED  = 0x00, ///< Undefined value
+    GDL_HDMI_AUDIO_SS_16         = 0x01, ///< 16 bits
+    GDL_HDMI_AUDIO_SS_20         = 0x02, ///< 20 bits
+    GDL_HDMI_AUDIO_SS_24         = 0x04, ///< 24 bits
+} gdl_hdmi_audio_ss_t;
+
+/** @ingroup disp_pd
+    Enumeration of the different audio speaker allocation options defined in the
+    CEA-861D specification.
+*/
+typedef enum
+{
+    GDL_HDMI_AUDIO_SPEAKER_MAP_FLFR   = 0x0001,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_LFE    = 0x0002,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_FC     = 0x0004,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_RLRR   = 0x0008,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_RC     = 0x0010,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_FLCFRC = 0x0020,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_RLCRRC = 0x0040,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_FLWFRW = 0x0080,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_FLHFRH = 0x0100,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_TC     = 0x0200,
+    GDL_HDMI_AUDIO_SPEAKER_MAP_FCH    = 0x0400,
+} gdl_hdmi_audio_speaker_map_t;
+
+/** @ingroup disp_pd
+    This structure represents different audio commands
+*/
+typedef struct
+{
+    gdl_hdmi_audio_cmd_id_t cmd_id;  ///< Audio command type
+    
+    union  ///< Audio command details
+    {
+        struct   ///< Arguments for #GDL_HDMI_AUDIO_SET_FORMAT command.
+        {
+            gdl_hdmi_audio_fmt_t fmt;   ///< Audio format
+            gdl_hdmi_audio_fs_t  fs;    ///< Sampling frequency
+            unsigned int         ch;    ///< Number of channels
+            gdl_hdmi_audio_ss_t  ss;    ///< Sample size [in bits]
+            gdl_hdmi_audio_speaker_map_t map;
+                                        ///< Speaker allocation map
+        } _set_config;
+        
+        struct   ///< Arguments for #GDL_HDMI_AUDIO_GET_CAPS command.
+        {
+            unsigned int    index;      ///< Capability number
+            gdl_hdmi_audio_cap_t cap;   ///< Capability content
+        } _get_caps;
+        
+        struct   ///< Arguments for #GDL_HDMI_AUDIO_WRITE command
+        {
+            unsigned int  samples;      ///< Audio samples buffer address
+            unsigned int  silence;      ///< Audio silence buffer address
+            unsigned int  size;         ///< Audio data buffer size
+            unsigned int  id;           ///< Audio buffer ID
+            gdl_boolean_t sync;         ///< Type of write operation
+        } _write;
+        
+        struct   ///< Arguments for #GDL_HDMI_AUDIO_STOP command
+        {
+            gdl_boolean_t sync;          ///< Type of stop request
+        } _stop;
+    
+    } data;
+    
+} gdl_hdmi_audio_ctrl_t;
+
+/** @ingroup disp_pd
+    This structure represents generic HDMI packet
+*/
+typedef struct
+{
+    unsigned char header[3];
+    unsigned char data[28];
+} gdl_hdmi_packet_t;
+
+/** @ingroup disp_pd
+    This structure represents HDMI packet slot number
+*/
+typedef enum
+{
+    GDL_HDMI_PACKET_SLOT_0,
+    GDL_HDMI_PACKET_SLOT_1,
+} gdl_hdmi_packet_slot_t;
+
+/** @ingroup disp_pd
+    This structure is used to submit data via #GDL_PD_SEND_HDMI_PACKET service
+    provided by #gdl_port_send
+*/
+typedef struct
+{
+    gdl_hdmi_packet_t      packet;
+    gdl_hdmi_packet_slot_t slot;
+} gdl_hdmi_packet_info_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents YC Delay amounts
+*/
+typedef enum
+{
+    GDL_YC_DELAY_NONE,    ///< No YC delay 
+    GDL_YC_DELAY_ADVANCE, ///< Y 0.5 Pixel Advance delay
+    GDL_YC_DELAY_MINUS    ///< Y 1.0 Pixel delay
+} gdl_yc_delay_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents vswing equalization values
+*/
+typedef enum
+{
+    GDL_HDMI_EQUALIZE_NONE, ///< Equalization disabled
+    GDL_HDMI_EQUALIZE_10,   ///< Equalization 10%, not supported on CE3100
+    GDL_HDMI_EQUALIZE_20,   ///< Equalization 20%
+    GDL_HDMI_EQUALIZE_30,   ///< Equalization 30%, not supported on CE3100
+    GDL_HDMI_EQUALIZE_40,   ///< Equalization 40%
+    GDL_HDMI_EQUALIZE_50,   ///< Equalization 50%, not supported on CE3100
+    GDL_HDMI_EQUALIZE_60,   ///< Equalization 60%
+    GDL_HDMI_EQUALIZE_70,   ///< Equalization 70%, not supported on CE3100
+    GDL_HDMI_EQUALIZE_80,   ///< Equalization 80%
+} gdl_hdmi_equalize_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents transmit level amplitude values
+*/
+typedef enum
+{
+    GDL_HDMI_TRANSMIT_LEVEL_300, ///< 300 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_325, ///< 325 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_350, ///< 350 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_375, ///< 375 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_400, ///< 400 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_425, ///< 425 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_450, ///< 450 mV
+    GDL_HDMI_TRANSMIT_LEVEL_475, ///< 475 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_500, ///< 500 mV
+    GDL_HDMI_TRANSMIT_LEVEL_525, ///< 525 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_550, ///< 550 mV
+    GDL_HDMI_TRANSMIT_LEVEL_575, ///< 575 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_600, ///< 600 mV
+    GDL_HDMI_TRANSMIT_LEVEL_625, ///< 625 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_650, ///< 650 mV, not supported on CE3100
+    GDL_HDMI_TRANSMIT_LEVEL_675, ///< 675 mV, not supported on CE3100
+} gdl_hdmi_transmit_level_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents termination impedance values
+*/
+typedef enum
+{
+    GDL_HDMI_TERMINATION_OPEN, ///< Open
+    GDL_HDMI_TERMINATION_677,  ///< 677 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_398,  ///< 398 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_250,  ///< 250 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_200,  ///< 200 Ohm
+    GDL_HDMI_TERMINATION_100,  ///< 100 Ohm
+    GDL_HDMI_TERMINATION_88,   ///<  88 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_78,   ///<  78 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_72,   ///<  72 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_67,   ///<  67 Ohm
+    GDL_HDMI_TERMINATION_65,   ///<  65 Ohm, not supported on CE3100
+    GDL_HDMI_TERMINATION_50,   ///<  50 Ohm
+} gdl_hdmi_termination_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents band gap resistor values
+*/
+typedef enum
+{
+    GDL_HDMI_BGLVL_788,  ///< 0.788v not supported on Sodaville
+    GDL_HDMI_BGLVL_818,  ///< 0.818v not supported on Sodaville
+    GDL_HDMI_BGLVL_854,  ///< 0.854v not supported on Sodaville [CE3100 default]
+    GDL_HDMI_BGLVL_891,  ///< 0.891v not supported on Sodaville
+    GDL_HDMI_BGLVL_820,  ///< 0.82v  not supported on CE3100 [Sodaville default]
+    GDL_HDMI_BGLVL_800,  ///< 0.80v  not supported on CE3100
+    GDL_HDMI_BGLVL_780,  ///< 0.78v  not supported on CE3100
+    GDL_HDMI_BGLVL_760,  ///< 0.76v  not supported on CE3100
+    GDL_HDMI_BGLVL_750,  ///< 0.75v  not supported on CE3100
+    GDL_HDMI_BGLVL_720,  ///< 0.72v  not supported on CE3100
+    GDL_HDMI_BGLVL_660,  ///< 0.66v  not supported on CE3100
+    GDL_HDMI_BGLVL_600,  ///< 0.60v  not supported on CE3100
+} gdl_hdmi_bglvl_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents different HDCP states
+*/
+typedef enum
+{
+    GDL_HDCP_STATUS_OFF,         ///< HDCP is disabled
+    GDL_HDCP_STATUS_IN_PROGRESS, ///< HDCP is enabled but not authenticated yet
+    GDL_HDCP_STATUS_ON,          ///< HDCP is enabled and is authenticated
+} gdl_hdcp_status_t;
+
+/** @ingroup disp_pd
+*   This enumeration represents audio clock values with respect to which
+*   internal audio divisor value is chosen
+*/
+typedef enum
+{
+    GDL_HDMI_AUDIO_CLOCK_24, ///< Audio clock is running at 24MHz
+    GDL_HDMI_AUDIO_CLOCK_36, ///< Audio clock is running at 36Mhz
+} gdl_hdmi_audio_clock_t;
+
+
+#endif // _GDL_PD_H_
diff --git a/make/stub_includes/embedded/IntelGDL/gdl_types.h b/make/stub_includes/embedded/IntelGDL/gdl_types.h
new file mode 100644
index 000000000..e160c4966
--- /dev/null
+++ b/make/stub_includes/embedded/IntelGDL/gdl_types.h
@@ -0,0 +1,1579 @@
+//-----------------------------------------------------------------------------
+// This file is provided under a dual BSD/GPLv2 license.  When using or
+// redistributing this file, you may do so under either license.
+//
+// GPL LICENSE SUMMARY
+//
+// Copyright(c) 2005-2009 Intel Corporation. All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of version 2 of the GNU General Public License as
+// published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+// The full GNU General Public License is included in this distribution
+// in the file called LICENSE.GPL.
+//
+// Contact Information:
+//      Intel Corporation
+//      2200 Mission College Blvd.
+//      Santa Clara, CA  97052
+//
+// BSD LICENSE
+//
+// Copyright(c) 2005-2009 Intel Corporation. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//   - Redistributions of source code must retain the above copyright
+//     notice, this list of conditions and the following disclaimer.
+//   - Redistributions in binary form must reproduce the above copyright
+//     notice, this list of conditions and the following disclaimer in
+//     the documentation and/or other materials provided with the
+//     distribution.
+//   - Neither the name of Intel Corporation nor the names of its
+//     contributors may be used to endorse or promote products derived
+//     from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//---------------------------------------------------------------------------*/
+
+#ifndef _GDL_TYPES_H_
+#define _GDL_TYPES_H_
+
+/*----------------------------------------------------------------------
+ *                     G E N E R A L
+ *---------------------------------------------------------------------*/
+
+/** @ingroup general */
+/**@{*/
+typedef unsigned char      gdl_uint8; ///< Unsigned 8 bit integer.
+typedef unsigned short     gdl_uint16;///< Unsigned 16 bit integer.
+typedef unsigned int       gdl_uint32;///< Unsigned 32 bit integer.
+typedef unsigned long long gdl_uint64;///< Unsigned 64 bit integer.
+typedef char               gdl_int8;  ///< Signed 8 bit integer.
+typedef short              gdl_int16; ///< Signed 16 bit integer.
+typedef int                gdl_int32; ///< Signed 32 bit integer.
+typedef long long          gdl_int64; ///< Signed 64 bit integer.
+typedef void               gdl_void;  ///< Void data type.
+typedef float              gdl_f32;   ///< Single precision floating point
+typedef double             gdl_f64;   ///< Double precision floating point
+
+typedef unsigned long      physaddr_t; ///< A physical memory address
+/**@}*/
+
+/** @ingroup general
+    Boolean data type
+*/
+typedef enum
+{
+    GDL_FALSE   = 0,        ///< Boolean false.
+    GDL_TRUE    = 1         ///< Boolean true.
+} gdl_boolean_t;
+
+
+/** @ingroup general
+*/
+typedef struct
+{
+    gdl_int32 x;            ///< Point X-coordinate
+    gdl_int32 y;            ///< Point Y-coordinate
+} gdl_point_t;
+
+
+/** @ingroup general
+*/
+typedef struct
+{
+    gdl_point_t  origin;    ///< Rectangle origin
+    gdl_uint32   width;     ///< Rectangle width
+    gdl_uint32   height;    ///< Rectangle height
+} gdl_rectangle_t;
+
+
+// Return 0 if two gdl_rectangle_t variables are not equal, non-zero otherwise
+static __inline int
+rect_eq( gdl_rectangle_t *rect1, gdl_rectangle_t *rect2)
+{
+    return  (rect1->origin.x == rect2->origin.x)
+        &&  (rect1->origin.y == rect2->origin.y)
+        &&  (rect1->width    == rect2->width   )
+        &&  (rect1->height   == rect2->height  );
+}
+
+/** @ingroup general
+    Bit flags returned in the 'flags' field of #gdl_driver_info_t.
+*/
+typedef enum
+{
+    GDL_DRIVER_INFO_HDCP_ENABLED        = 1,
+        ///< Driver is running on a chip with HDCP enabled.
+    GDL_DRIVER_INFO_MACROVISION_ENABLED = 4,
+        ///< Driver is running on a chip with Macrovision support enabled.
+    GDL_DRIVER_INFO_1080P_ENABLED       = 8
+        ///< Driver is running on a chip with 1080p display mode enabled.
+} gdl_driver_info_flag_t;
+
+
+/** @ingroup general
+    Display Driver information structure returned by gdl_get_driver_info().
+*/
+typedef struct
+{
+    gdl_int16       header_version_major;
+                    /**< Major version number of header files. */
+    gdl_int16       header_version_minor;
+                    /**< Minor version number of header files. */
+    gdl_uint32      gdl_version;
+                    /**< Driver version number */
+    gdl_int32       build_tag;
+                    /**< Driver build tag. */
+    gdl_driver_info_flag_t flags;
+                    /**< Capabilities of chip on which the driver is running. */
+    char            name[64];
+                    /**< Display driver name as a 0-terminated ASCII string. */
+    gdl_uint32      mem_size;
+                    /**< Total number of bytes allocated for driver memory.
+                     * Extra heaps will be visible only if the caller attached
+                     * them previously. See #gdl_attach_heap for details.
+                     */
+    gdl_uint32      mem_avail;
+                    /**< Number of bytes of driver memory currently unused.
+                     * Extra heaps will be visible only if the caller attached
+                     * them previously. See #gdl_attach_heap for details.
+                     */
+} gdl_driver_info_t;
+
+
+/** @ingroup general
+    Pixel component extension options.  The blender operates on pixels
+    with 10-bit components (i.e., 10-bit R, G, and B values for RGB pixel
+    formats; 10-bit chroma/luma values for YUV pixel formats).  However, most
+    of the pixel formats supported by the planes have component values of less
+    than 10 bits; as the planes output such pixels, they extend them to 10 bits
+    using one of the methods described by this enumeration.
+*/
+typedef enum
+{
+    GDL_PIXEL_EXTENSION_ZERO_PAD,
+            /**<
+            Pixel component values are extended from N to 10 bits by
+            shifting them left (10-N) bits and appending 0's. E.g., the
+            8-bit value 0x7f [0111 1111] becomes 0x1fc [01 1111 1100].
+            With this method, the difference between any two consecutive
+            output values is a constant, but the highest possible value is
+            0x3fc (11 1111 1100).
+            */
+    GDL_PIXEL_EXTENSION_MSB_SHADOW,
+            /**<
+            Pixel component values are first extended from N to 10 bits by
+            shifting them left (10-N) bits and appending 0's. Then the
+            (10-N) most significant bits are OR'd into the low-order (10-N)
+            places. E.g., the 8-bit value 0x7f (0111 1111) becomes 0x1fd
+            (01 1111 1101).   With this method, the difference between any
+            two consecutive output values is NOT constant, but the values at
+            either end of the output range are fully saturated (0x000 and 0x3ff).
+            */
+    GDL_PIXEL_EXTENSION_COUNT
+            /**<
+            Number of valid entries in this enumeration.
+            */
+} gdl_pixel_extension_t;
+
+
+/** @ingroup general
+    Pixel format identifiers.  Note that the appearance of a pixel format in
+    this list does not guarantee that is is supported by the hardware.
+ */
+typedef enum
+{
+    /* RGB types */
+    GDL_PF_ARGB_32,         ///< ARGB 32bpp 8:8:8:8  LE
+    GDL_PF_RGB_32,          ///< xRGB 32bpp x:8:8:8  LE
+    GDL_PF_RGB_30,          ///<  RGB 30bpp 10:10:10 LE [fully packed]
+    GDL_PF_RGB_24,          ///<  RGB 24bpp 8:8:8    LE [fully packed]
+    GDL_PF_ARGB_16_1555,    ///< ARGB 16bpp 1:5:5:5  LE
+    GDL_PF_ARGB_16_4444,    ///< ARGB 16bpp 4:4:4:4  LE
+    GDL_PF_RGB_16,          ///<  RGB 16bpp 5:6:5    LE
+    GDL_PF_RGB_15,          ///< xRGB 16bpp x:5:5:5  LE
+
+    /* CLUT types */
+    GDL_PF_RGB_8,           ///<  RGB 8bpp - 24bpp palette RGB 8:8:8
+    GDL_PF_ARGB_8,          ///< ARGB 8bpp - 32bpp palette ARGB 8:8:8:8
+    GDL_PF_AYUV_8,          ///< AYUV 8bpp - 32bpp palette AYUV 8:8:8:8
+
+    /* Packed YUV types */
+    GDL_PF_YUY2,            ///< Packed YUV 4:2:2 32-bit: V0:Y1:U0:Y0 LE
+    GDL_PF_UYVY,            ///< Packed YUV 4:2:2 32-bit: Y1:V0:Y0:U0 LE
+    GDL_PF_YVYU,            ///< Packed YUV 4:2:2 32-bit: U0:Y1:V0:Y0 LE
+    GDL_PF_VYUY,
+
+    /* Planar YUV types */
+    GDL_PF_YV12,            ///< YVU 4:2:0 Planar (V plane precedes U)
+    GDL_PF_YVU9,            ///< YUV 4:2:0 Planar
+    GDL_PF_I420,            ///< YUV 4:2:0 Planar (U plane precedes V)
+    GDL_PF_IYUV=GDL_PF_I420,///< Synonym for I420
+
+            //************************************************************
+            // NOTE!: GDL_PF_IYUV must immediately follow GDL_PF_I420!
+            //************************************************************
+
+    GDL_PF_I422,            ///< YUV 4:2:2 Planar (U plane precedes V)
+    GDL_PF_YV16,            ///< YVU 4:2:2 Planar (V plane precedes U)
+
+    /* Pseudo-planar YUV types */
+    GDL_PF_NV12,            ///< YUV 4:2:0 Pseudo-planar
+    GDL_PF_NV16,            ///< YUV 4:2:2 Pseudo-planar
+    GDL_PF_NV20,            ///< YUV 4:2:2 Pseudo-planar, 10-bit components
+
+    GDL_PF_A1,              ///< 1-bit Alpha-only surface
+    GDL_PF_A4,              ///< 4-bit Alpha-only surface
+    GDL_PF_A8,              ///< 8-bit Alpha-only surface
+
+    GDL_PF_AY16,            ///< Alpha-luminance 8:8. Used for video textures
+    GDL_PF_COUNT            ///< Number of defined pixel formats
+} gdl_pixel_format_t;
+
+
+/** @ingroup general
+    Error codes that can be returned by GDL functions.  Note that more detailed
+    information about an error may also be printed on the system console.
+*/
+typedef enum
+{
+    GDL_SUCCESS             = 0,
+        /**<
+        Function executed without errors
+        */
+    GDL_ERR_INVAL           = 0x01,
+        /**<
+        An invalid argument was passed.
+        */
+    GDL_ERR_BUSY            = 0x02,
+        /**<
+        An operation could not be completed because a needed resource is in use.
+        */
+    GDL_ERR_DISPLAY         = 0x03,
+        /**<
+        An invalid display ID was passed.
+        */
+    GDL_ERR_SURFACE         = 0x04,
+        /**<
+        An invalid surface ID, or the ID of a surface that is not
+        appropriate for the requested operation, was passed.
+        */
+    GDL_ERR_COMMAND         = 0x05,
+        /**<
+        An internal command processing error occurred
+        */
+    GDL_ERR_NULL_ARG        = 0x06,
+        /**<
+        A required argument was missing.  Either a NULL pointer or a count
+        of 0 was passed for a required argument.
+        */
+    GDL_ERR_NO_MEMORY       = 0x07,
+        /**<
+        Could not allocate memory.
+        */
+    GDL_ERR_FAILED          = 0x08,
+        /**<
+        This is a generic error code that generally means that a system
+        call or call to some other software external to the driver
+        returned a failure code.
+        */
+    GDL_ERR_INTERNAL        = 0x09,
+        /**<
+        A condition that "should not be possible" was detected within the
+        driver.  This generally means there is nothing the application can
+        do to correct the problem.
+        */
+    GDL_ERR_NOT_IMPL        = 0x0a,
+        /**<
+        The function is not currently implemented for the target chip.
+        */
+    GDL_ERR_MAPPED          = 0x0b,
+        /**<
+        Operation not permitted on the mapped surface.
+        */
+    GDL_ERR_NO_INIT         = 0x0c,
+        /**<
+        A GDL function was called without a preceding call to gdl_init().
+        */
+    GDL_ERR_NO_HW_SUPPORT   = 0x0d,
+        /**<
+        The target chip does not support the requested function.  Examples:
+        - A graphics rendering option is not supported by the graphics core
+          in the target chip.
+        - A plane or port driver does not support a requested attribute.
+        - An attempt was made to request the attribute list from a port
+          driver that does not support any attributes.
+        */
+    GDL_ERR_INVAL_PF        = 0x0e,
+        /**<
+        An unknown pixel format, or a pixel format not supported by the
+        attempted operation, was passed.
+        */
+    GDL_ERR_INVAL_RECT      = 0x0f,
+        /**<
+        An invalid argument of type #gdl_rectangle_t was passed to the function.
+        */
+    GDL_ERR_ATTR_ID         = 0x10,
+        /**<
+        An undefined ID was specified for a plane attribute or a port
+        driver attribute.
+        */
+    GDL_ERR_ATTR_NO_SUPPORT = 0x11,
+        /**<
+        An unsupported ID was specified for a plane attribute or a port
+        driver attribute.
+        */
+    GDL_ERR_ATTR_READONLY   = 0x12,
+        /**<
+        An attempt was made to set the value of a read-only plane attribute
+        or port driver attribute.
+        */
+    GDL_ERR_ATTR_VALUE      = 0x13,
+        /**<
+        An invalid value was specified for a plane attribute or a port
+        driver attribute.
+        */
+    GDL_ERR_PLANE_CONFLICT  = 0x14,
+        /**<
+        An attempt was made to change the display mode to a resolution too
+        small to accommodate all of the currently enabled planes at their
+        current positions on the display. Move/shrink the affected planes first.
+        */
+    GDL_ERR_DISPLAY_CONFLICT= 0x15,
+        /**<
+        An attempt was made to change the size or origin of a plane such
+        that part/all of the plane would no longer be on the display.
+        Increase the display resolution first.
+        */
+    GDL_ERR_TIMEOUT        = 0x16,
+        /**<
+        The requested timeout period occurred before the requested
+        operation trigger occurred.
+        */
+    GDL_ERR_MISSING_BEGIN  = 0x17,
+         /**<
+         An attempt was made to set a plane attribute without first calling
+         gdl_config_begin().
+         */
+    GDL_ERR_PLANE_ID       = 0x18,
+        /**<
+        An invalid plane ID was passed.  The ID is undefined, the plane is not
+        supported by the target chip, or the plane is not supported by the
+        called function.
+        */
+    GDL_ERR_INVAL_PTR      = 0x19,
+        /**<
+        On Linux, a copy between user and kernel space failed.  This
+        probably indicates an invalid user space (argument) pointer.
+        */
+
+    GDL_ERR_INVAL_HEAP = 0x1a,
+        /**<
+        An invalid heap was passed for addition or removal. Attempt
+        to add overlaping heaps will cause this error too.
+        */
+
+    GDL_ERR_HEAP_IN_USE = 0x1b,
+        /**<
+        Heap removal was attempted while at least one surface was allocated
+        from that heap.
+        */
+
+    GDL_ERR_INVAL_CALLBACK = 0x1c,
+        /**<
+        Invalid callback (null) was passed to gdl_event_register() function
+        */
+
+    GDL_ERR_SCALING_POLICY  = 0x1d,
+        /**<
+        A single scaling policy is required and was not specified for the
+        #gdl_display_info_t structure used, or scaling policies are
+        unsupported for the specified display ID.
+        */
+
+    GDL_ERR_INVAL_EVENT = 0x1e,
+        /**<
+        Invalid event was passed to functions expecting #gdl_app_event_t.
+        */
+
+    GDL_ERR_INVAL_IOCTL     = 0x1f,
+        /**<
+        Invalid IOCTL request was sent to kernel module
+        */
+    GDL_ERR_SCHED_IN_ATOMIC = 0x20,
+        /**<
+        Scheduling was attempted while being in atomic context.
+        */
+    GDL_ERR_MMAP            = 0x21,
+        /**<
+        Memory mapping failed
+        */
+    GDL_ERR_HDCP            = 0x22,
+        /**<
+        HDCP failure
+        */
+    GDL_ERR_CONFIG          = 0x23,
+        /**<
+        Platform config file error: either a required entry in the
+        platform configuration file is missing, or its entry is invalid.
+        */
+    GDL_ERR_HDMI_AUDIO_PLAYBACK = 0x24,
+        /**<
+        HDMI Audio start / stop / set buffer / set format command was
+        initiated at the wrong time.
+        */
+    GDL_ERR_HDMI_AUDIO_BUFFER_FULL = 0x25,
+        /**<
+        Given data does not fit in the internal buffer
+        */
+    GDL_ERR_PLANE_ORIGIN_ODD   = 0x26,
+        /**<
+        In interlaced display modes, active planes must be configured with
+        their origins on even display lines. This error is returned when:
+        - in a progressive display mode: an attempt is made to change to an
+          interlaced display mode while there is an active plane does not
+          meet this requirement.
+        - in an interlaced display mode:
+           - an attempt is made to reconfigure an active plane's origin
+             to an odd line number, OR
+           - an attempt is made to activate (by flipping a surface to) a
+             plane that doesn't meet this requirement.
+        */
+    GDL_ERR_PLANE_HEIGHT_ODD   = 0x27,
+        /**<
+        In interlaced display modes, active planes must be configured with
+        their even heights. This error is returned when:
+        - in a progressive display mode: an attempt is made to change to an
+          interlaced display mode while there is an active plane does not
+          meet this requirement.
+        - in an interlaced display mode:
+           - an attempt is made to reconfigure an active plane's height
+             to an odd value, OR
+           - an attempt is made to activate (by flipping a surface to) a
+             plane that doesn't meet this requirement.
+        */
+    GDL_ERR_HANDLE              = 0x28,
+        /**<
+        Given handle is not valid
+        */
+    GDL_ERR_TVMODE_UNDEFINED    = 0x29,
+        /**<
+        Display has undefined tv mode set on it.
+        */
+    GDL_ERR_PREMULT_CONFLICT    = 0x2a,
+        /**<
+        An attempt was made to enable the #GDL_PLANE_ALPHA_PREMULT attribute and
+        one of the following incompatible features at the same time:
+        - Chroma keying on the same plane (#GDL_PLANE_CHROMA_KEY_SRC_ENABLE set
+          to #GDL_TRUE).
+        - Gamma removal on the same plane (#GDL_PLANE_REVERSE_GAMMA_TYPE set to
+          a value other than #GDL_GAMMA_LINEAR.
+        - color space conversion (the value of the plane's
+          #GDL_PLANE_SRC_COLOR_SPACE attribute is different from the color
+          space of the display to which it is connected).
+        - a non-RGB pixel format.
+        */
+
+    GDL_ERR_SUSPENDED = 0x2b,
+        /**<
+        An attempt was made to execute a command while the driver was in a
+        suspended mode. During the suspended mode driver is in a low-power
+        state and no access to hardware is allowed.
+        */
+
+    //**********************************************************************
+    // ATTENTION!!: WHEN ADDING AN ERROR CODE MAKE SURE TO:
+    // - Search for a value marked "Currently unused" in the list above
+    //   before adding a new value at the end.
+    // - Include inline (doxygen) documentation for the new error.
+    // - Add the new error to _error_string() in debug.c
+    //**********************************************************************
+} gdl_ret_t;
+
+/** @ingroup general */
+#define GDLFAIL(err) ((err) != GDL_SUCCESS)
+/** @ingroup general */
+#define GDLPASS(err) (!GDLFAIL(err))
+
+/** @ingroup general
+
+    Types of gamma curves. There are three standard values of gamma:
+    - 1.0: (linear) leaves the input luminance unchanged.
+    - 2.2: NTSC and HDTV content is typically generated with this value.
+    - 2.8: PAL and SECAM standards indicate this value, although 2.2
+      is commonly used.
+*/
+typedef enum
+{
+    GDL_GAMMA_LINEAR,   ///< 1.0
+    GDL_GAMMA_2_2,      ///< 2.2
+    GDL_GAMMA_2_8,      ///< 2.8
+    GDL_GAMMA_COUNT,    ///< Number of entries in this enumeration
+} gdl_gamma_t;
+
+
+/** @ingroup general
+    The occurrence of the VSync signal indicates completion of the updating of
+    video output with a new image.  In interlaced display modes, this image
+    may be either a top field or a bottom field; in progressive display modes
+    it is always a full frame.
+
+    The type of image update cycle that has just been completed may be thought
+    of as the 'polarity' of the VSync signal.
+
+    This enumeration defines values for all three image types.
+*/
+typedef enum
+{
+    GDL_POLARITY_FRAME=1,       ///< Frame (Progressive)
+    GDL_POLARITY_FIELD_TOP=2,   ///< Top field (Interlaced)
+    GDL_POLARITY_FIELD_BOTTOM=3 ///< Bottom field (Interlaced)
+} gdl_polarity_t;
+
+//----------------------------------------------------------------------
+//                 D I S P L A Y   M O D E
+//----------------------------------------------------------------------
+
+/** @ingroup disp_mode
+    Refresh rates for TV mode definitions.
+
+    Refresh rate is the number of times the display is updated per second.
+    This is the number of frames per second for progressive display modes;
+    the number of fields (half the number of frames) per second for interlaced
+    display modes.
+
+    IF WRITING AN EXTERNAL (non-Intel) PORT DRIVER: if new rates need to be
+    defined, create a new enumeration whose first entry has a value equal to
+    #GDL_REFRESH_USER_DEFINED.  Since no internal port driver will support those
+    modes, applications must make sure that only the external port driver is
+    active on a display before setting the display to one of those modes.
+*/
+typedef enum
+{
+    GDL_REFRESH_23_98,      /**< 23.98... (24/1.001)    */
+    GDL_REFRESH_24,         /**< 24                     */
+    GDL_REFRESH_25,         /**< 25                     */
+    GDL_REFRESH_29_97,      /**< 29.97... (30/1.001)    */
+    GDL_REFRESH_30,         /**< 30 - DEPRECATED: This value is normally only
+                                 used on computer systems and should be used
+                                 with care, if at all. The corresponding TV
+                                 rate is 30/(1.001) (see #GDL_REFRESH_29_97).
+                            */
+    GDL_REFRESH_50,         /**< 50                     */
+    GDL_REFRESH_59_94,      /**< 59.94... (60/1.001)    */
+    GDL_REFRESH_60,         /**< 60 - DEPRECATED: This value is normally only
+                                 used on computer systems and should be used
+                                 with care, if at all. The corresponding TV
+                                 rate is 60/(1.001) (see #GDL_REFRESH_59_94).
+                            */
+    GDL_REFRESH_USER_DEFINED/* External (non-Intel) port drivers may define
+                               additional refresh rates that the support. Their
+                               IDs must be numbered starting at this value.
+                             */
+} gdl_refresh_t;
+
+
+/** @ingroup disp_mode
+    Display (pipe) ids.  The Intel� CE Media Processors have two displays.
+*/
+typedef enum
+{
+    GDL_DISPLAY_ID_0 = 0,       ///< [Pipe A] Main display/HDMI
+    GDL_DISPLAY_ID_1,           ///< [Pipe B] Secondary display/Composite
+    GDL_DISPLAY_ID_UNDEFINED    ///< Undefined Pipe Internal Use Only
+} gdl_display_id_t;
+
+
+/** @ingroup disp_mode
+
+    This structure describes a TV display mode.
+*/
+typedef struct
+{
+    gdl_uint32    width;      ///< Active display width in pixels
+    gdl_uint32    height;     ///< Active display height in pixels
+    gdl_refresh_t refresh;    /**< Refresh frame rate: frames/sec in
+                                   progressive display modes, fields/sec in
+                                   interlaced display modes.
+                              */
+    gdl_boolean_t interlaced; ///< GDL_TRUE=>interlaced, GDL_FALSE=>progressive
+} gdl_tvmode_t;
+
+/** @ingroup disp_mode
+    Defines supported color spaces
+
+*/
+typedef enum
+{
+    GDL_COLOR_SPACE_BT601, ///< Normally used for Standard Definition YCbCr content
+    GDL_COLOR_SPACE_BT709, ///< Normally used for High Definition YCbCr content
+    GDL_COLOR_SPACE_RGB,   ///< Used for all RGB pixel formats
+    GDL_COLOR_SPACE_COUNT  ///< Number of entries in this enumeration
+} gdl_color_space_t;
+
+
+/**@ingroup disp_mode
+
+    Values that can be OR'd together to create an entry for the flags field of
+    the #gdl_display_info_t structure.
+    */
+typedef enum
+{
+    GDL_DISPLAY_ZOOM_TO_FIT      = 0x00000001,
+        /**<
+        Display 1 can only be configured for SD display modes, which have a
+        4:3 aspect ratio. When display 0 is in a 16:9 display mode, the
+        setting of this flag is consulted to determine how the display 0 image
+        should be scaled for output on display 1.
+        
+        The default (if this flag is not specified) is to scale the 16:9 image
+        to 4:3 -- no data is lost, no black bars are displayed, but the image
+        is distorted.  In this case, the application may wish to enable Wide
+        Screen Signaling in the port driver.
+
+        Specifying this flag selects a "zoom to fit" (letterboxing) scaling
+        policy. This maintains the 16:9 aspect ratio on display 1 by scaling
+        the image to the point where its width fills the display area. Black
+        bars appear above and below the image.
+
+        @note
+        This flag can @b only be specified for display 1.
+        */
+
+    GDL_DISPLAY_SHARPEN          = 0x00000002
+        /**<
+        This flag can be selected to "sharpen" the output on display 1 when
+        displaying a static, full-screen graphic frame.
+
+        Setting this flag will @b only produce optimal results if:
+        - the graphics plane is configured to @b full-screen resolution (the
+          resolution to which display 0 is currently configured), and
+        - the original graphics content has the same resolution as the current
+          configuration of display 1 (720x480 or 720x576).
+
+        Setting this flag will probably @b degrade the quality of any animated
+        or video plane being displayed.
+
+        @note
+        This flag can @b only be specified for display 1.
+        */
+} gdl_display_flag_t;
+
+
+/** @ingroup disp_mode
+
+    This structure describes the state of one of the displays.
+*/
+typedef struct
+{
+    gdl_display_id_t    id;
+        /**< The ID of the display. */
+
+    gdl_tvmode_t        tvmode;
+        /**< The display mode */
+
+    gdl_uint32          flags;
+        /**<
+        This is a set of bit flags formed by OR-ing together members of the
+        #gdl_display_flag_t enumeration.
+        */
+
+    gdl_uint32          bg_color;
+        /**<
+        An RGB 10/10/10 value designating the "canvas" color that will appear
+        on any part of the display that is not completely obscured by one or
+        more opaque planes.
+        @note
+        Display 1's bg_color will never been seen unless the
+        #GDL_DISPLAY_ZOOM_TO_FIT flag is set, in which case it will be used as
+        the color of the horizontal bars used to "letter-box" 16:9 images on
+        display 1. In all other cases, the blended display 0 image is always
+        scaled to fit the display 1 exactly, leaving no portion of the canvas
+        uncovered; even if there are no planes enabled on display 0, it
+        is the display 0 bg_color that will be seen on display 1.
+        */
+
+    gdl_gamma_t         gamma;
+        /**< Additive gamma to be applied to blended output sent to the display.
+         */
+
+    gdl_color_space_t   color_space;
+        /**< The colorspace in which pixels are output on this display.
+             Planes on this pipe whose source pixels are in a different color
+             space will be configured to perform color space conversion before
+             outputting pixels to the blender.
+        */
+} gdl_display_info_t;
+
+
+/*----------------------------------------------------------------------
+ *                 P L A N E   M A N A G E M E N T
+ *---------------------------------------------------------------------*/
+
+
+/** @ingroup plane_management
+    Plane IDs
+*/
+typedef enum
+{
+    GDL_PLANE_ID_UNDEFINED = 0,     /**< A plane ID guaranteed to be invalid.
+                                         Useful for initializing variables.
+                                    */
+    GDL_PLANE_ID_IAP_A,             ///< Indexed alpha plane A
+    GDL_PLANE_ID_IAP_B,             ///< Indexed alpha plane B
+    GDL_PLANE_ID_UPP_A,             ///< Universal pixel plane A
+    GDL_PLANE_ID_UPP_B,             ///< Universal pixel plane B
+    GDL_PLANE_ID_UPP_C,             ///< Universal pixel plane C
+    GDL_PLANE_ID_UPP_D,             ///< Universal pixel plane D
+    GDL_PLANE_ID_UPP_E,             /**< Universal pixel plane E
+                                      *  -- only available in blender
+                                      *     configuration 1.
+                                      */
+    GDL_MAX_PLANES=GDL_PLANE_ID_UPP_E, ///< The total number of planes
+
+#ifndef DOXYGEN_SKIP /* Omit the following when docs are generated */
+    /* THESE ARE FOR INTERNAL DRIVER USE ONLY */
+    GDL_PLANE_ID_UPP_WB,
+    GDL_PLANE_ID_WBP,
+    GDL_MAX_PLANES_INTERNAL=GDL_PLANE_ID_WBP
+#endif
+} gdl_plane_id_t;
+
+
+/** @ingroup plane_management
+
+    This structure specifies a color in a manner independent of exact pixel
+    format.  It is generally used to supply the color component values of a
+    pixel in a context in which the pixel format and/or color space are
+    indicated separately by enumerators of the appropriate type.
+
+    For formats that include alpha components (or that are alpha-only), the
+    alpha_index field holds the alpha value.
+
+    For palettized (CLUT) color formats, only the alpha_index field is used, and
+    it holds the 0-based palette index.
+
+    For other RGB formats:
+    - r_y holds the Red   color component
+    - g_u holds the Green color component
+    - b_v holds the Blue  color component
+
+    For YUV (YCbCr) formats:
+    - r_y holds the Y component
+    - g_u holds the U (Cb) component
+    - b_v holds the V (Cr) component
+*/
+typedef struct
+{
+    gdl_uint16 alpha_index; ///< Alpha or Index component
+    gdl_uint16 r_y;         ///< Red,   Y, or Y' component
+    gdl_uint16 g_u;         ///< Green, U, or Cb component
+    gdl_uint16 b_v;         ///< Blue,  V, or Cr component
+} gdl_color_t;
+
+
+/** @ingroup plane_management
+    Flags indicating how a surface flip should be scheduled by gdl_flip().
+*/
+typedef enum
+{
+    GDL_FLIP_ASYNC = 3,
+        /**<
+        gdl_flip() returns immediately to the caller. The flip begins on the
+        next VBlank, as long as it is not over-ridden by a new flip to the same
+        plane before then.
+        */
+
+    GDL_FLIP_SYNC = 4,
+        /**<
+        gdl_flip() does not return to the caller until scan-out of the surface
+        onto the display has begun. New flip can be submitted at this point
+        to the same plane without over-writing the previous flip.
+        */
+} gdl_flip_t;
+
+
+/** @ingroup plane_management
+    This enumeration defines the various attributes that may be implemented by
+    a hardware plane.  These values are used in three different ways:
+
+    - to determine plane capabilities\n\n
+      The function gdl_plane_capabilities() returns a plane capability array.
+      To determine if an attribute is supported by the plane, use the
+      corresponding enumeration value as an index into the array.  If the
+      indexed entry is non-zero, the attribute is supported; otherwise it isn't.
+
+    - to configure a plane\n\n
+      The various set functions (e.g., gdl_plane_set_int()) allow the setting
+      of individual attributes of the plane by specifying attribute name-value
+      pairs.  The "names" in these pairs are members of this enumeration.
+
+    - to examine the configuration of a plane\n\n
+      The various get functions (e.g., gdl_plane_get_int()) allow the current
+      value of an attribute to be queried by name.  The "names" used in these
+      queries are members of this enumeration.
+
+    The descriptions of the individual enumerated values contain the following
+    fields:
+    - @b Capability: what a non-zero entry in the corresponding entry of
+         the capabilities array indicates.\n
+    - @b Attribute: what the attribute controls.\n
+    - @b Value: the data type of the attribute, which determines which get/set
+         function should be used to manipulate it.  Where relevant, the
+         range of legal values for the attribute is listed.  Note that
+         enumerations are treated as uint values with a range restricted by the
+         enum definition.
+    - @b Default: the default setting of the attribute when the system is
+         powered up.
+
+    On the Intel� CE Media Processors, the capabilities supported by the planes
+    are as follows:
+    - All planes:
+        - #GDL_PLANE_ALPHA_GLOBAL
+        - #GDL_PLANE_ALPHA_PREMULT
+        - #GDL_PLANE_DISPLAYED_SURFACE
+        - #GDL_PLANE_DST_RECT
+        - #GDL_PLANE_FLIP
+        - #GDL_PLANE_LINE_REPLICATION
+        - #GDL_PLANE_PIXEL_EXTENSION
+        - #GDL_PLANE_PIXEL_FORMAT
+        - #GDL_PLANE_PIXEL_REPLICATION
+        - #GDL_PLANE_SRC_COLOR_SPACE
+        - #GDL_PLANE_SRC_RECT
+        - #GDL_PLANE_ZORDER
+    - Universal pixel planes:
+        - #GDL_PLANE_CHROMA_KEY_SRC_ENABLE,
+        - #GDL_PLANE_CHROMA_KEY_SRC_HIGH,
+        - #GDL_PLANE_CHROMA_KEY_SRC_LOW,
+        - #GDL_PLANE_NUM_GFX_SURFACES,
+        - #GDL_PLANE_REVERSE_GAMMA_TYPE,
+        - #GDL_PLANE_UPSCALE
+        - #GDL_PLANE_VBD_DEST_OVERRIDE
+        - #GDL_PLANE_VBD_MUTE
+    - Indexed/alpha planes:
+        - #GDL_PLANE_ALPHA_OUT
+*/
+typedef enum
+{
+    GDL_PLANE_ALPHA_GLOBAL,
+        /**<
+        @b Capability: the plane supports a settable global alpha value.\n
+        @b Attribute: the current global alpha value.\n
+        @b Value: uint in [0, 255]\n
+        @b Default: 255 (opaque)\n
+        \n
+        */
+
+    GDL_PLANE_ALPHA_OUT,
+        /**<
+        @b Capability: the plane can provide alpha values for another plane.\n
+        @b Attribute: the ID of the plane to which the alpha values should be
+            sent.\n
+        @b Value: gdl_plane_id_t\n
+        @b Default: #GDL_PLANE_ID_UNDEFINED\n
+        <b>Programming Notes</b>
+        - This attribute is available on IAPs (Indexed/Alpha planes) only.
+        - When the value of this attribute is set to #GDL_PLANE_ID_UNDEFINED,
+          the IAP is configured to output 8-bit palette-based pixels, and its
+          #GDL_PLANE_PIXEL_FORMAT attribute must be set to specify an 8-bit
+          CLUT pixel format.
+        - When the value of this attribute is set to a valid plane ID, the IAP
+          is configured to provide alpha values for the specified plane, and its
+          #GDL_PLANE_PIXEL_FORMAT attribute must specify an alpha format.
+          Each pixel in the IAP provides the alpha value for the pixel it
+          overlaps on-screen in the specified destination plane.
+        - On the Intel� CE Media Processors,
+            - IAP A can provide alpha values for any one of UPPs A, B, and C.
+            - IAP B can only provide alpha values for UPP D.
+            .
+        - If the destination rectangle of an IAP is different from that of
+          its associated UPP, the UPP pixels where there is no overlap will
+          receive alpha values of @b zero and will become transparent.
+        - Similarly, if an IAP is @b disabled without removing the assignment,
+          the associated UPP will become completely transparent.
+        .
+        \n
+        */
+
+    GDL_PLANE_ALPHA_PREMULT,
+        /**<
+        @b Capability: the plane's pixel values can be interpreted as containing
+        premultiplied alpha values.\n
+        @b Attribute: enables/disables use of premultiplied alpha.\n
+        @b Value: uint (#gdl_boolean_t)\n
+        @b Default: #GDL_FALSE (disabled)\n
+        <b>Programming Notes</b>
+        - This value is ignored if the plane's current pixel format does not
+          include a per-pixel alpha value.
+        - @b CAUTION: This attribute cannot operate correctly in conjunction
+          with the following features.  An attempt to enable premultiplied alpha
+          and any of the following at the same time will return an error of type
+          #GDL_ERR_PREMULT_CONFLICT.
+          - chroma keying on the same plane (#GDL_PLANE_CHROMA_KEY_SRC_ENABLE
+            set to #GDL_TRUE)
+          - gamma removal from the same plane (#GDL_PLANE_REVERSE_GAMMA_TYPE set
+            to a value other than #GDL_GAMMA_LINEAR).
+          - color space conversion (the value of the plane's
+            #GDL_PLANE_SRC_COLOR_SPACE attribute is different from the color
+            space of the display to which it is connected).
+          - a non-RGB pixel format.
+          .
+        .
+        \n
+        */
+
+    GDL_PLANE_CHROMA_KEY_SRC_ENABLE,
+        /**<
+        @b Capability: The plane supports source luma/chroma keying.\n
+        @b Attribute: Enables/disables luma/chroma keying on the plane.\n
+                      Actual chroma key values are set through the
+                      #GDL_PLANE_CHROMA_KEY_SRC_HIGH and
+                      #GDL_PLANE_CHROMA_KEY_SRC_LOW attributes.\n
+        @b Value: #gdl_boolean_t\n
+        @b Default: #GDL_FALSE (Chroma keying is disabled)\n
+        \n
+        */
+
+    GDL_PLANE_CHROMA_KEY_SRC_HIGH,
+        /**<
+        @b Capability: Plane supports source chroma key range.\n
+        @b Attribute: The upper limit of the luma/chroma keying range. This
+                      value is ignored unless the
+                      #GDL_PLANE_CHROMA_KEY_SRC_ENABLE is set to #GDL_TRUE\n
+        @b Value: #gdl_color_t\n
+        @b Default: 0,0,0\n
+        <b>Programming Notes</b>
+        - The value is interpreted as RGB or YCbCr according to the plane's
+          current #GDL_PLANE_SRC_COLOR_SPACE attribute setting.
+        - The number of bits used in each field of the structure should
+          correspond to the current #GDL_PLANE_PIXEL_FORMAT attribute.  E.g.,
+          if the pixel format is #GDL_PF_RGB_16, y_g should be a 6-bit value and
+          cb_b/cr_r should be 5-bit values.
+        - The programmer is responsible for correctly coordinating the values of
+          #GDL_PLANE_CHROMA_KEY_SRC_HIGH and #GDL_PLANE_CHROMA_KEY_SRC_LOW with
+          the settings of #GDL_PLANE_SRC_COLOR_SPACE, #GDL_PLANE_PIXEL_FORMAT,
+          and #GDL_PLANE_ALPHA_PREMULT.
+        .
+        \n
+        */
+
+    GDL_PLANE_CHROMA_KEY_SRC_LOW,
+        /**<
+        Same as #GDL_PLANE_CHROMA_KEY_SRC_HIGH, except that it identifies the
+        lower end of the luma/chroma keying range.\n\n
+        */
+
+    GDL_PLANE_DISPLAYED_SURFACE,
+        /**<
+        @b Capability: Surfaces can be flipped onto the plane with the
+           gdl_flip() function. See also #GDL_PLANE_FLIP.\n
+        @b Attribute: The ID of the surface currently being scanned out by the
+           plane.  The surface is at least partially visible.  If the value of
+           this attribute is #GDL_PLANE_ID_UNDEFINED, the plane is disabled.\n
+        @b Value: uint (#gdl_surface_id_t)\n
+        @b Default: N/A. <b>THIS VALUE IS READ-ONLY</b>.\n
+        */
+
+    GDL_PLANE_DST_RECT,
+        /**<
+        @b Capability: The plane's dimensions and its location on the display
+            can be changed.\n
+        @b Attribute: A rectangle defining the dimensions of the plane and its
+            location on the display.\n
+        @b Value: rect (#gdl_rectangle_t)\n
+        @b Default: 320x240\n
+        <b>Programming Notes</b>
+        - The rectangle's origin:
+            - is relative to the upper left corner of the display.
+            - must have non-negative coordinates.
+            - must lie within the active display region.
+        - The rectangle's height and width must be such that the lower right
+          corner of the rectangle also lies within the active display region.
+          Line and pixel replication (if enabled) must be taken into account
+          when determining the rectangle's size.
+        - On the Intel� CE Media Processors, the plane can not be less than 16
+        pixels wide by 2 pixels high.
+        - If the display is in an interlaced mode:
+            - the y-coordinate of the origin must specify an even-numbered
+              display line (the top line of the display is line 0).
+            - the height must be even.
+            .
+        .
+        \n
+        */
+
+    GDL_PLANE_FLIP,
+        /**<
+        @b Capability: Surfaces can be flipped onto the plane with the
+            gdl_flip() function. See also #GDL_PLANE_DISPLAYED_SURFACE.\n
+        @b Attribute: The ID of the surface currently flipped onto the plane.\n
+
+           "Flipping" a surface is the act of programming the VDC registers
+           with the address of the surface buffer.  However, the plane does not
+           begin to scan out the contents of the surface until the next
+           Framestart signal after the programming is done. (Framestart occurs
+           sometime between VBlank and VSync). Therefore, the surface whose
+           ID is returned as this attribute may not actually be visible
+           yet.  See #GDL_PLANE_DISPLAYED_SURFACE for the ID of the
+           currently displayed surface.  If the value of GDL_PLANE_FLIP
+           is #GDL_PLANE_ID_UNDEFINED, the plane will be @b disabled at the
+           next Framestart (if it isn't already).\n
+        @b Value: uint (#gdl_surface_id_t)\n
+        @b Default: N/A. <b>THIS VALUE IS READ-ONLY</b>.\n
+        \n
+        */
+
+    GDL_PLANE_LINE_REPLICATION,
+        /**<
+        @b Capability: The plane can output each scan line multiple times.\n
+        @b Attribute: The number of times each line should be output.  A value
+           of 1 indicates normal output; a value of 2 indicates line-doubling.\n
+        @b Value: uint in [1,2]\n
+        @b Default: 1\n
+        <b>Programming Notes</b>
+           - The #GDL_PLANE_DST_RECT attribute should be set to the
+             non-replicated dimensions.  E.g, a plane whose dimensions are
+             720x240 will be displayed as 720x240 when line replication is 1,
+             and 720x480 when line replication is 2. #GDL_ERR_DISPLAY_CONFLICT
+             will be returned if turning on line replication would cause the
+             plane not to fit entirely within the display.
+           - Pixel and line replication are not supported while
+             #GDL_PLANE_UPSCALE attribute is enabled on that plane.
+           .
+        \n
+        */
+
+    GDL_PLANE_NUM_GFX_SURFACES,
+        /**<
+        @b Capability: The plane can support flip chains for the graphics
+           driver APIs.\n
+        @b Attribute: Indicates whether the plane will be double-, or
+           triple-buffered for flip operations performed via the graphics APIs.
+           The value of this attribute is only used when the plane's ID is
+           passed to eglWindowSurfaceCreate() (see the Intel� CE Media
+           Processors Graphics Driver Programming Guide):
+           - The EGL function examines the attribute to determine the number of
+             flippable surfaces to request from the display driver (subject to
+             memory availability).
+           - The pixel format and dimensions of the surfaces will be based on
+             the plane's pixel format and dimensions at the time of the call.
+           .
+        @b Value: uint in [2,3]\n
+        @b Default: 3\n
+        \n
+        */
+
+    GDL_PLANE_PIXEL_EXTENSION,
+        /**<
+        @b Capability: The plane supports pixel component extension.
+            Internally, all planes extend their pixels to 10-bits per component
+            prior to blending.  See the description of #gdl_pixel_extension_t
+            for further details.\n
+        @b Attribute: Method used to extend pixel component values.\n
+        @b Value: uint (#gdl_pixel_extension_t)\n
+        @b Default: #GDL_PIXEL_EXTENSION_ZERO_PAD\n
+        \n
+        */
+
+    GDL_PLANE_PIXEL_FORMAT,
+        /**<
+        @b Capability: The plane's pixel format can be changed.\n
+        @b Attribute: The plane's current pixel format.\n
+        @b Value: uint (#gdl_pixel_format_t)\n
+        @b Default:
+           - for UPPs: #GDL_PF_NV16
+           - for IAPs: #GDL_PF_ARGB_8
+           .
+        \n
+        */
+
+    GDL_PLANE_PIXEL_REPLICATION,
+        /**<
+        @b Capability: The plane can output each pixel on a line multiple
+            times.\n
+        @b Attribute: The number of times each pixel on a line is output.  A
+            value of 1 indicates normal output; a value of 2 indicates
+            pixel-doubling.\n
+        @b Value: uint in [1,2]\n
+        @b Default: 1\n
+        <b>Programming Notes</b>
+           - The #GDL_PLANE_DST_RECT attribute should be set to the
+             non-replicated dimensions.  E.g, a plane whose dimensions are
+             360x480 will be displayed as 360x480 when pixel replication is 1,
+             and 720x480 when pixel replication is 2. #GDL_ERR_DISPLAY_CONFLICT
+             will be returned if turning on pixel replication would cause the
+             plane not to fit entirely within the display.\n
+           - Pixel and line replication are not supported while
+             #GDL_PLANE_UPSCALE attribute is enabled on that plane.
+           .
+        \n
+        */
+
+    GDL_PLANE_REVERSE_GAMMA_TYPE,
+        /**<
+        @b Capability: The plane can remove gamma correction from source
+        material prior to outputting pixels for blending with other planes.\n
+        @b Attribute: The type of reverse gamma correction currently in use.\n
+        @b Value: uint (#gdl_gamma_t)\n
+        @b Default: #GDL_GAMMA_LINEAR\n
+        <b>Programming Notes</b>
+            - Gamma removal will work correctly only if the gamma was originally
+              applied in the same color space as the one in which blending is
+              currently being done (the current color space of Display 0).
+            - Note that it is impossible to detect from a video clip the color
+              space in which gamma was applied.  The color space of the clip
+              can be determined, e.g. BT601, but the gamma may have been
+              applied in RGB color space by the camera before it output BT601.
+            - It is the application's responsibility to determine that the
+              feature will work correctly in a given display mode for a given
+              clip.  If the results do not look correct, it is likely that this
+              requirement was not met.
+        \n
+        */
+
+    GDL_PLANE_UPSCALE,
+        /**<
+        @b Capability: The plane can perform upscaling of the surfaces flipped
+            to the plane based on the relative sizes of the plane's source and
+            destination rectangles.\n
+        @b Attribute: Enables/disables upscaling on the plane.\n
+        @b Value: #gdl_boolean_t\n
+        @b Default: #GDL_FALSE\n
+        <b>Programming Notes</b>
+           - Only one UPP can support upscaling at a time. If upscaling is
+             already enabled for a UPP, it must be disabled on that UPP, before
+             it can be enabled on a new one.
+           - It is an error to enable plane upscaling and pixel/line doubling
+             at the same time. The programmer must explicitly disable one when
+             (or before) enabling the other.
+           - It may be necessary to change the source and/or destination
+             rectangles of the plane in the same configuration transaction as
+             the enabling / disabling of the upscaling in order to achieve the
+             desired results. For example, since UPPs are only capable of
+             upscaling, it is an error to enable scaling with the dimensions of
+             the source rectangle greater than those of the destination
+             rectangle.\n
+           - It is assumed that upscale will be enabled only for progressive
+             content such as graphics. Upscaling an interlaced content may
+             result in a bad output image quality.
+           - When upscaling is enabled, the width of the #GDL_PLANE_SRC_RECT
+             cannot exceed 1280.
+           .
+        \n
+        */
+
+    GDL_PLANE_SRC_COLOR_SPACE,
+        /**<
+        @b Capability: the plane can perform color space conversion when its
+            pixel data is output to the blender.\n
+        @b Attribute: an enumerated value indicating the color space of the
+            plane's source pixels (the color space of pixels in surfaces that
+            will be flipped onto the plane).  The pixels will be converted from
+            that color space to the current blender color space when they are
+            output by the plane.  NOTE: on IAPs, this attribute is ignored when
+            the plane is used in alpha output mode (i.e., when the
+            #GDL_PLANE_ALPHA_OUT attribute is set to a value other than
+            #GDL_PLANE_ID_UNDEFINED)\n
+        @b Value: uint (#gdl_color_space_t)\n
+        @b Default:
+            - For UPPs: #GDL_COLOR_SPACE_BT601
+            - For IAPs: #GDL_COLOR_SPACE_RGB
+            .
+        \n
+        */
+
+    GDL_PLANE_SRC_RECT,
+        /**<
+        @b Capability: The plane supports the ability to pan and/or scale source
+          surfaces\n
+        @b Attribute: A rectangle applied to all surfaces flipped onto the
+             plane, where:
+             - The @b origin allows panning over a surface that is larger than
+               the plane. The origin is specified as non-negative coordinates
+               relative to the upper left corner of the surface. It indicates
+               the surface pixel that will appear at the origin (upper left
+               corner) of the plane.
+             - The @b height and @b width are interpreted as follows:
+                - If the plane is a UPP on which scaling has been enabled (i.e.,
+                  the #GDL_PLANE_UPSCALE attribute has been set to #GDL_TRUE),
+                  the region of the surface specified by these dimensions is
+                  scaled to fit the destination rectangle.  Since downscaling
+                  is not supported, the dimensions of the source rectangle may
+                  not exceed those of the destination rectangle.
+                - Otherwise, the height and width of the source rectangle
+                  @b are @b ignored.  The region of the surface that is
+                  displayed is determined by the height and width of the
+                  destination rectangle.
+             .
+        @b Value: rect (#gdl_rectangle_t)\n
+        @b Default: Initial value of #GDL_PLANE_DST_RECT.\n
+        <b>Programming Notes</b>
+            - If an interlaced display mode is in effect, the low order bit of
+              the y-coordinate is ignored (the origin will always be on an
+              even-numbered display line).
+            - A flip will fail if the plane's source rectangle results in an
+              origin or a lower right corner that does not lie within the
+              surface being flipped.
+            - When #GDL_PLANE_UPSCALE is enabled, the width of the source
+              rectangle cannot exceed 1280.
+            .
+        \n
+        */
+
+    GDL_PLANE_VBD_DEST_OVERRIDE,
+        /**<
+        @b Capability:
+            The plane can be made a video sink for the SMD video
+            pipeline (by passing its ID to ismd_vidrend_set_video_plane()).
+            \n
+        @b Attribute:
+            Once a plane has been designated a video sink, video frames are
+            displayed on it automatically by the SMD pipeline via the
+            kernel-level VBD interface to the display driver.  By default, if
+            the dimensions of a frame passed in this way do not match the
+            plane's current destination rectangle, an opaque black frame is
+            displayed instead.  This is because events such as channel changes
+            might cause an application to reconfigure the plane for a new
+            resolution while there are still one or two video frames with the
+            old resolution still in the pipeline. This behavior can be
+            overridden by setting GDL_PLANE_VBD_DEST_OVERRIDE to GDL_TRUE; in
+            this case, the plane's destination rectangle will be automatically
+            reprogrammed to accommodate any change in the sizes of frames
+            passed via the VBD interface.\n
+        @b Value: gdl_boolean_t\n
+        @b Default: GDL_FALSE\n
+        @b Note:
+             - If the value is set to GDL_TRUE and video is resized through VBD
+             interface a "GDL_APP_EVENT_VBD_RECT_CHANGE" event will be sent to
+             all clients registered for that event. See #gdl_app_event_t for
+             more details on application events.\n
+        */
+
+    GDL_PLANE_VBD_MUTE,
+        /**<
+        @b Capability:
+            The plane can be made a video sink for the SMD video
+            pipeline (by passing its ID to ismd_vidrend_set_video_plane()).\n
+        @b Attribute:
+            Once a plane has been designated a video sink, video frames are
+            displayed on it automatically by the SMD video pipeline. Whenever
+            this attribute is set to #GDL_TRUE, the display driver will ignore
+            all frames flipped to the plane by the video pipeline, and the
+            plane can be used for any purpose by the application.\n
+        @b Value: gdl_boolean_t\n
+        @b Default: GDL_FALSE\n
+        */
+
+    GDL_PLANE_ZORDER,
+        /**<
+        @b Capability: Planes have different "depth" levels, and enabled planes
+            are blended in order from lowest to top-most.\n
+        @b Attribute: The plane's Z-order.  <b>THIS VALUE IS READ-ONLY</b>.\n
+        @b Value: uint [0,NumberOfPlanes-1], where:
+        - N is the number of planes in the system, and
+        - 0 is the top-most plane.
+        .
+        @b Default: The values returned for each plane are:
+        - IAPB: 0
+        - IAPA: 1
+        - UPPE: 2
+        - UPPD: 3
+        - UPPC: 4
+        - UPPB: 5
+        - UPPA: 6
+        .
+        \n
+        */
+
+    GDL_PLANE_ATTRIBUTE_COUNT
+        /**<
+        The total number of defined plane attributes (not an actual attribute
+        ID).
+        */
+} gdl_plane_attr_t;
+
+
+/** @ingroup plane_management
+    The total number of characters that may be present in a plane's
+    name string, including the zero terminator.
+*/
+#define GDL_PLANE_NAME_LENGTH   32
+
+/** @ingroup plane_management
+
+    Structure that describes the hardware of a display plane.
+    This information is retrieved by a call to gdl_plane_capabilities().
+*/
+typedef struct
+{
+    gdl_plane_id_t  id;
+        /**< The ID of the plane described by this structure. */
+
+    char            name[ GDL_PLANE_NAME_LENGTH ];
+        /**<
+        The name of the plane as a 0-terminated string, for use in messages
+        and debugging.
+        */
+
+    gdl_uint8       attr[ GDL_PLANE_ATTRIBUTE_COUNT ];
+        /**<
+        The programmable attributes of the plane.
+
+        The values of the #gdl_plane_attr_t enumeration are used to index this
+        array: if the corresponding entry in the array is non-zero, the
+        attribute is supported by the plane.
+
+        See the descriptions of the members of #gdl_plane_attr_t for further
+        information about individual attributes.
+        */
+
+    gdl_uint8       pixel_formats[ GDL_PF_COUNT ];
+        /**<
+        The pixel formats supported by the plane.
+
+        The values of the #gdl_pixel_format_t enumeration are used to index this
+        array: if the corresponding entry in the array is non-zero, that pixel
+        format is supported by the plane.
+        */
+
+    gdl_rectangle_t max_dst_rect;
+        /**<
+        The width/height fields of this rectangle specify the maximum dimensions
+        allowed by the hardware for the plane's destination rectangle
+        (on-display window).
+        */
+
+    gdl_rectangle_t min_dst_rect;
+        /**<
+        The width/height fields of this rectangle specify the minimum dimensions
+        allowed by the hardware for the plane's destination rectangle
+        (on-display window).
+        */
+
+} gdl_plane_info_t;
+
+
+/*----------------------------------------------------------------------
+ *              S U R F A C E   M A N A G E M E N T
+ *---------------------------------------------------------------------*/
+
+/** @ingroup surf
+ *
+    A structure describing an individual palette element.
+
+*/
+typedef struct
+{
+    gdl_uint8 a;               ///< Alpha component
+    gdl_uint8 r_y;             ///< Red (or Y) component
+    gdl_uint8 g_u;             ///< Green (or U/Cb) component
+    gdl_uint8 b_v;             ///< Blue (or V/Cr) component
+} gdl_palette_entry_t;
+
+
+/** @ingroup surf
+    A structure describing an 8-bit indexed palette (CLUT).
+*/
+typedef struct
+{
+    gdl_palette_entry_t data[256]; ///< Palette elements
+    gdl_uint32          length;    ///< Number of valid entries in palette
+} gdl_palette_t;
+
+
+/** @ingroup surf
+
+    Surfaces are referenced by IDs.  The IDs are unsigned integers.
+*/
+typedef enum
+{
+    GDL_SURFACE_INVALID = 0
+        /**<
+        This value is never allocated for a valid surface.  It can be used
+        in data structures to indicate an invalid or uninitialized surface ID.
+        */
+} gdl_surface_id_t;
+
+
+/**@ingroup surf
+
+    These flags are used with gdl_alloc_surface() to indicate how the surface
+    is intended to be used.
+*/
+typedef enum
+{
+    GDL_SURFACE_CACHED      = 0x00000002,
+        /**<
+        This flag should be set on a surface that the caller would like to
+        be in 'cached' memory. If the surface is passed to any other execution
+        unit besides cpu, cached surface must be flushed first using
+        #gdl_flush_surface API call. Automatic flush of the cache will occur
+        internally during #gdl_flip call.
+        */
+    GDL_SURFACE_DISABLE_AUTOCLEANUP = 0x00000004,
+        /**
+        This flag when set disables surface from participating in automatic
+        cleanup. Upon exit of applcation remaining surfaces marked with this
+        flag will not be automatically deleted.
+        @bNote: This flag should only be set by applications that perform their
+        own memory management.
+        */
+} gdl_surface_flag_t;
+
+
+/** @ingroup surf
+    This structure describes a surface.
+*/
+typedef struct
+{
+    gdl_surface_id_t    id;
+        /**< Surface ID, used in GDL calls that operate on this surface */
+
+    gdl_uint32          flags;
+        /**< Any combination of OR'd values of type #gdl_surface_flag_t. */
+
+    gdl_pixel_format_t  pixel_format;
+        /**< Pixel format of the surface of type #gdl_pixel_format_t. */
+
+    gdl_uint32          width;
+        /**<
+        Surface width in pixels.  In the case of a YUV format surface, this is
+        also the number of active pixels in a line of the Y-plane.
+        */
+
+    gdl_uint32          height;
+        /**<
+        Surface height in pixels.  In the case of a YUV format surface, this is
+        also the number of lines in the Y-plane.
+        */
+
+    gdl_uint32          size;
+        /**<
+        Total number of bytes allocated for the surface, including any padding
+        added for stride alignment.
+        */
+
+    gdl_uint32          pitch;
+        /**<
+        Byte stride; i.e., the byte offset that must be added to the address
+        of pixel in order to access the pixel with the same x-offset in the
+        line below it. In the case of a YUV format surface, this is the pitch
+        of the Y plane.
+        */
+
+    gdl_uint32         phys_addr;
+        /**<
+        Physical address of the surface.
+        */
+
+    gdl_uint32         heap_phys_addr;
+        /**<
+        Physical address of the heaps base.
+        */
+
+    gdl_uint32          y_size;
+        /**<
+         NOT USED FOR PACKED PIXEL FORMATS.
+         For YUV planar and pseudo-planar formats, this is the total number of
+         bytes allocated for the Y plane, including any padding for stride
+         alignment.  Note that the Y plane always begins at offset 0 into the
+         surface.
+         */
+
+    gdl_uint32          u_offset;
+        /**<
+        NOT USED FOR PACKED PIXEL FORMATS.
+        For YUV planar formats, this is the (non-zero) offset from the
+        start of the surface to the start of the U plane. For YUV
+        pseudo-planar surfaces, this is the (non-zero) offset of the
+        interleaved UV samples.
+        */
+
+    gdl_uint32          v_offset;
+        /**<
+        NOT USED FOR PACKED PIXEL FORMATS.
+        For YUV planar formats, this is the (non-zero) offset from the start of
+        the surface to the start of the V plane.  For YUV pseudo-planar
+        surfaces, this value is meaningless and will be set to 0.
+        */
+
+    gdl_uint32          uv_size;
+        /**<
+        NOT USED FOR PACKED PIXEL FORMATS.
+        The total number of bytes allocated for each of the subsampled
+        chrominance planes, including any padding for stride alignment.  For
+        YUV planar formats, both the U & V planes are this size. For YUV
+        pseudo-planar formats, this is the total allocated for the interleaved
+        UV samples.
+        */
+
+    gdl_uint32          uv_pitch;
+        /**<
+        NOT USED FOR PACKED PIXEL FORMATS.
+        The byte stride of the subsampled chrominance planes. For YUV planar
+        formats, both the U and V planes have this pitch. For pseudo-planar
+        formats, this is the pitch of the interleaved UV samples
+        */
+
+} gdl_surface_info_t;
+
+
+/** @ingroup general
+    This enumeration represents events that can be used for callback
+    registration with the gdl_event_register() API.
+*/
+typedef enum
+{
+    GDL_APP_EVENT_HDCP_FAILURE=0,    ///< HDCP has failed
+    GDL_APP_EVENT_HDCP_SUCCESS,      ///< HDCP authentication has succeeded
+    GDL_APP_EVENT_HOTPLUG_DETECT,    ///< HDMI cable was connected
+    GDL_APP_EVENT_HOTPLUG_LOSS,      ///< HDMI cable was disconnected
+    GDL_APP_EVENT_VBD_RECT_CHANGE,   ///< VBD rectangle dimensions changed
+    GDL_APP_EVENT_COUNT,
+} gdl_app_event_t;
+
+
+/** @ingroup general
+    Type for a callback function used with #gdl_event_register API
+    call. See #gdl_event_register for more information
+*/
+typedef void (*gdl_event_callback_t)(gdl_app_event_t event, void * user_data);
+
+
+/** @ingroup debug
+    These flags are used with gdl_debug_log_start() to indicate the type of
+    information to be logged.
+*/
+
+typedef enum
+{
+    GDL_LOG_THREAD_ID   = 0x00000001, ///< Log Thread ids
+    GDL_LOG_TIMESTAMP   = 0x00000002, ///< Log timestamp for function entry/exit
+    GDL_LOG_SURFACES    = 0x00000004, ///< Log surface-related information
+    GDL_LOG_PLANES      = 0x00000008, ///< Log plane-related information
+} gdl_log_flag_t;
+
+#endif
diff --git a/make/stub_includes/embedded/IntelGDL/gdl_version.h b/make/stub_includes/embedded/IntelGDL/gdl_version.h
new file mode 100644
index 000000000..2ac6694e7
--- /dev/null
+++ b/make/stub_includes/embedded/IntelGDL/gdl_version.h
@@ -0,0 +1,119 @@
+//-----------------------------------------------------------------------------
+// This file is provided under a dual BSD/GPLv2 license.  When using or
+// redistributing this file, you may do so under either license.
+//
+// GPL LICENSE SUMMARY
+//
+// Copyright(c) 2005-2009 Intel Corporation. All rights reserved.
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of version 2 of the GNU General Public License as
+// published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
+// The full GNU General Public License is included in this distribution
+// in the file called LICENSE.GPL.
+//
+// Contact Information:
+//      Intel Corporation
+//      2200 Mission College Blvd.
+//      Santa Clara, CA  97052
+//
+// BSD LICENSE
+//
+// Copyright(c) 2005-2009 Intel Corporation. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+//
+//   - Redistributions of source code must retain the above copyright
+//     notice, this list of conditions and the following disclaimer.
+//   - Redistributions in binary form must reproduce the above copyright
+//     notice, this list of conditions and the following disclaimer in
+//     the documentation and/or other materials provided with the
+//     distribution.
+//   - Neither the name of Intel Corporation nor the names of its
+//     contributors may be used to endorse or promote products derived
+//     from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//----------------------------------------------------------------------------
+
+
+/*------------------------------------------------------------------------------
+ * GDL VERSION NUMBERS
+ *
+ * We currently maintain two types of version information:
+ *
+ * GDL version
+ *      This varies with major redefinitions of the user API. It comprises:
+ *        - a 4-bit major version number
+ *        - a 16-bit minor version number, and
+ *        - a 4-bit hotfix number (which will normally be 0).
+ *      These numbers are determined by the #define's below.  Hotfix numbers
+ *      should be incremented for each hotfix release, and should be reset to 0
+ *      when one of the other numbers is rolled.
+ *
+ *      An application can retrieve the version number via the
+ *      gdl_get_driver_info() API.
+ *
+ * Header version
+ *      It is possible for internal changes to be made to shared header files
+ *      resulting in incompatibility among the following components if they
+ *      are built with different versions of the header files:
+ *          - user applications
+ *          - libgdl.so
+ *          - gdl_mm.ko
+ *          - gdl_server
+ *
+ *      The header version number is composed of 16-bit major and minor numbers
+ *      assigned via the #define's below.  THE MINOR NUMBER SHOULD BE ROLLED
+ *      whenever a backward-compatible change is made.  THE MAJOR NUMBER SHOULD
+ *      BE ROLLED whenever changes are made that are incompatible with previous
+ *      versions of the user library.
+ *
+ *      Compatibility is checked in gdl_init().
+ *
+ *      The header version is also returned via the gdl_get_driver() API.
+ *----------------------------------------------------------------------------*/
+
+#ifndef __GDL_VERSION_H__
+#define __GDL_VERSION_H__
+
+#define GDL_VERSION_MAJOR           3
+#define GDL_VERSION_MINOR           0
+#define GDL_VERSION_HOTFIX          0
+
+#define GDL_HEADER_VERSION_MAJOR    65
+#define GDL_HEADER_VERSION_MINOR    4
+
+/* Macro to create a GDL version number from major, minor, and hotfix
+   components.  The GDL version number is of type gdl_uint32.
+*/
+#define MAKE_GDL_VERSION(major,minor,hotfix) \
+    ((((major)<<24) & 0xff000000) | (((minor)<<8) & 0xffff00) | (hotfix & 0xff))
+
+/* Macro to return the major/minor/hotfix versions from a GDL version number. */
+#define GET_GDL_VERSION_MAJOR(version)  (((version) >> 24) & 0xff)
+#define GET_GDL_VERSION_MINOR(version)  (((version) >> 8)  & 0xffff)
+#define GET_GDL_VERSION_HOTFIX(version) ((version) & 0xff)
+
+#endif