diff options
Diffstat (limited to 'make/stub_includes/embedded/IntelGDL')
| -rw-r--r-- | make/stub_includes/embedded/IntelGDL/gdl.h | 1329 | ||||
| -rw-r--r-- | make/stub_includes/embedded/IntelGDL/gdl_pd.h | 938 | ||||
| -rw-r--r-- | make/stub_includes/embedded/IntelGDL/gdl_types.h | 1579 | ||||
| -rw-r--r-- | make/stub_includes/embedded/IntelGDL/gdl_version.h | 119 |
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 |