From: John Hodge Date: Sat, 31 Jan 2015 09:31:21 +0000 (+0800) Subject: UDI/include - add [com]buster's copy of udi_gfx.h (for comparison purposes) X-Git-Url: https://git.ucc.asn.au/?a=commitdiff_plain;h=0a44d8898569e739ebe46df6d2473dca0319dfd4;p=tpg%2Facess2.git UDI/include - add [com]buster's copy of udi_gfx.h (for comparison purposes) --- diff --git a/UDI/include/udi_gfx.h.ORIG b/UDI/include/udi_gfx.h.ORIG new file mode 100644 index 00000000..fcaa5b74 --- /dev/null +++ b/UDI/include/udi_gfx.h.ORIG @@ -0,0 +1,848 @@ +/** + * Summary: udi_gfx.h + * Contains the graphics metalanguage interface details + * + * Author: + * Marcel Sondaar + * + * License: + * + * + * Origin: + * http://www.d-rift.nl/combuster/mos3/?p=viewsource&file=/include/common/udi_gfx.h + */ + +// note that the specification, and thus, the contents of this file is not fixed. + +#ifndef __UDI_GFX_H__ +#define __UDI_GFX_H__ + +#include + +#ifndef UDI_GFX_VERSION +#error "UDI_GFX_VERSION not defined." +#elif UDI_GFX_VERSION != 0x101 +#error "UDI_GFX_VERSION not supported." +#endif + +/** + * Enumeration: UDI_GFX_PROP + * Lists the various UDI properties + */ + +// General state properties +/* Constant: UDI_GFX_PROP_ENABLE + * + * Valid values: + * 0 - disabled + * 1 - enabled + * 2 - reset + * + * Ranges: + * Must include at least 1 + * + * The primary state of the connector or engine. An enabled state indicates + * it is functioning and generating live output. A disabled state is one where + * it is not contributing to any output but is otherwise functional. Finally + * the reset state is where the driver is free to deallocate all resources + * corresponding to this component and trash any state not referenced by other + * components. + * + * A disabled or reset engine forwards all data from the previous stage + * unmodified. The disabled state indicates that the component might be + * returned to its enabled state within short notice. + * + * A disabled connector will not send pixel data, but can perform other + * initialisation communication such as DDC. A reset connector will not respond + * in any fashion and can not be used for other purposes. Hardware is expected + * to be powered down in such state. + * + * Users should expect significant delays when moving components in and out of + * the reset state. Moving engines between the enabled and disabled state should + * take effect within one frame, such transition should take effect on a frame + * boundary when supported. + */ +#define UDI_GFX_PROP_ENABLE 0 + +#define UDI_GFX_PROP_ENABLE_DISABLED 0 +#define UDI_GFX_PROP_ENABLE_ENABLED 1 +#define UDI_GFX_PROP_ENABLE_RESET 2 +/* Constant: UDI_GFX_PROP_INPUT + * + * Valid values: + * Any valid engine ID, provided no dependency cycles are created, or -1 + * + * Ranges: + * Any non-empty set of valid values. Often hardwired. + * + * Points to the engine that is processed before this unit. In the case of a + * connector, it points to the last engine in a pipeline, and each engine points + * to the next engine in the sequence. A value of -1 indicates a source that + * only yields black pixels. Implementations must not allow cyclic structures. + * Changing this value may reallocate resources, and engines that are no longer + * referenced may lose their data (but not their state) when it is not part of + * any pipeline. If preservation is required, the ENABLE state should be used + * instead. Valid ranges includes one or more from the list of engines and -1 + * combined. In most cases, this property can not be modified. + */ +#define UDI_GFX_PROP_INPUT 1 +/* Constant: UDI_GFX_PROP_WIDTH + * + * Valid values: + * Any non-zero positive number. + * + * Ranges: + * Contains at least one valid value. Often only multiples of UNIT_WIDTH + * or a power of two are allowed. May be hardwired. + * + * Contains the amount of pixels in the horizontal direction. For connectors, + * this is the amount of data pixels rendered horizontally. For engines, this + * is the width in pixels of the image. Pixels requested from an engine outside + * the range (0..width-1) are defined according to the + * property. In some cases, hardware may support only fixed combinations of + * width and height. In such cases, changing the width will also change the + * height to a corresponding valid number. Valid ranges include any values + * strictly above zero. For connectors, expect large continuous ranges, large + * ranges with a certain modulus, a limited number of fixed values, or a + * constant value. + */ +#define UDI_GFX_PROP_WIDTH 2 +/* Constant: UDI_GFX_PROP_HEIGHT + * + * Valid values: + * Any non-zero positive number. + * + * Ranges: + * Contains at least one valid value. Often only multiples of UNIT_HEIGHT + * or a power of two are allowed. May be hardwired. + * + * Contains the amount of pixels in the vertical direction. Functions similar + * to the width property, but changing it will not alter the width property, + * and it's range at any time contains the valid range for the currently + * selected width. + */ +#define UDI_GFX_PROP_HEIGHT 3 + +/* Constant: UDI_GFX_PROP_CUSTOM + * The first property index of the driver's custom range. These are not assigned + * directly assigned by the UDI specification, but may be specified in the + * operator tree. + */ +#define UDI_GFX_PROP_CUSTOM 1024 + +// engine properties + +/* Constant: UDI_GFX_PROP_CLIP + * + * Valid values: + * 0 - points outside width x height are passed unmodified from input + * 1 - the engine's contents is tiled with size width x height + * 2 - points outside the width overflow into the y coordinate + * 3 - points outside the height overflow into the x coordinate + * + * Ranges: + * Hardwired zero for connectors. Any non-empty subset for engines, usually + * hardwired. + * + * For engines, contains the behaviour for pixels requested outside the width + * and height of the engine. Can be either 0 (pass from next stage), 1 (the + * coordinates are wrapped modulus the height and width), 2 (the coordinates + * overflow onto the next scanline horizontally, and wrap vertically), 3 (the + * coordinates overflow onto the next column vertically, and wrap horizontally). + * Valid ranges contain one or more of these options. For overlays and sprites, + * a value 0 is common. For framebuffers, 2 is the most common value. For + * connectors, this property is always 0 since they do not store pixel data + */ +#define UDI_GFX_PROP_CLIP 4 + +/* Constant: UDI_GFX_PROP_UNIT_WIDTH + * + * Valid values: + * Any non-zero positive value + * + * Ranges: + * Any non-empty set of valid values. May be hardwired to 1 for + * framebuffers, or a range of small values for hardware scaling, or any + * larger hardwired number or set for tiling engines. + * + * Tiles are used to indicate that the hardware groups sets of pixels and have + * each group share certain properties, i.e. color or tile index, or share the + * same chroma subsample with only a different intensity. If the engine has no + * such grouping, or shares all properties over the entire contents, the value + * of this property should be 1. Some tile examples include rescaling, where a + * tile width of 2 indicates a pixel doubling in X direction, or in text mode + * where a tile width of 8 or 9 corresponds with the width of common bitmap + * fonts + */ +#define UDI_GFX_PROP_UNIT_WIDTH 5 + +/* Constant: UDI_GFX_PROP_UNIT_HEIGHT + * + * Valid values: + * Any non-zero positive value + * + * Ranges: + * Any non-empty set of valid values. May be hardwired to 1 for + * framebuffers, or a range of small values for hardware scaling, or any + * larger hardwired number or set for tiling engines. + * + * See , but for the Y direction. Common values are + * 1-2 for framebuffers (doublescanning on or off), identical to the tile + * width, or mostly independent. + */ +#define UDI_GFX_PROP_UNIT_HEIGHT 6 + +/* Constant: UDI_GFX_PROP_TRANSLATEX + * + * Valid values: + * Any, signed value. + * + * Ranges: + * Any non-empty set. Typical values are hardwired zero, continuous + * between -WIDTH and WIDTH, -WIDTH to zero inclusive, or all possible values + * + * The horizontal offset where drawing starts. A positive value means the top-left + * corner moves towards the right end of the screen, a negative value moves the + * origin off the screen on the left side. Clipped areas moved off the screen do + * not reappear on the opposite side. + * + * With clipping enabled, this field combined with + * determines the area where the image should be drawn, which is the horizontal + * range from UDI_GFX_PROP_TRANSLATEX to UDI_GFX_PROP_WIDTH + + * UDI_GFX_PROP_TRANSLATEX - 1 + */ +#define UDI_GFX_PROP_TRANSLATEX 7 + +/* Constant: UDI_GFX_PROP_TRANSLATEY + * + * Valid values: + * Any signed value. + * + * Ranges: + * Any non-empty set. Typical values are hardwired zero, continuous + * between -WIDTH and WIDTH, or all possible values + * + * See but for the Y direction. + */ +#define UDI_GFX_PROP_TRANSLATEY 8 + +#define UDI_GFX_PROP_GL_VERSION 14 +#define UDI_GFX_PROP_GLES_VERSION 15 +#define UDI_GFX_PROP_STATE_BLOCK 16 +#define UDI_GFX_PROP_COLOR_BITS 22 +#define UDI_GFX_PROP_GL_TARGET 23 + +/* Constant: UDI_GFX_PROP_STOCK_FORMAT + * + * Value: + * Zero, or any constant from + * + * Ranges: + * Any non-empty set of valid values. + * + * This field indicates the storage format is one from a limited set of + * typical configurations. If the field is zero, the engine is not knowingly + * configured as a common framebuffer. If nonzero, the operator chain and any + * dependent settings are defined to be functionally equivalent to that of a + * typical framebuffer device. + * + * The value zero does not imply that the device does not actually follow a + * set convention. This saves drivers from writing elaborate checking code + * to determine the condition in question. + * + * Writing this field potentially modifies other property fields within the + * same engine to establish the requested configuration. Manually writing such + * properties after changing this setting may in turn revert this property to + * the zero state, even if there was no modification or the behaviour is still + * as previously advertised by this property. + */ +#define UDI_GFX_PROP_STOCK_FORMAT 27 + +/* Constant: UDI_GFX_PROP_OPERATOR_COUNT + * + * Valid values: + * Any non-zero positive number + * + * Ranges: + * Most likely constant. Can be any set of valid values. + * + * The current value is the number of entries in the operator tree that can + * be requested for this engine using and + * + */ +#define UDI_GFX_PROP_OPERATOR_COUNT 28 + +// properties for removal: +#define UDI_GFX_PROP_STORE_COUNT 24 // not generic +#define UDI_GFX_PROP_STORE_WIDTH 9 // not generic +#define UDI_GFX_PROP_STORE_HEIGHT 10 // not generic +#define UDI_GFX_PROP_STORE_BITS 11 // not generic +#define UDI_GFX_PROP_PALETTE 1024 // optional, can be derived from the operator tree +#define UDI_GFX_PROP_BUFFER 1025 // optional, can be derived from the operator tree +#define UDI_GFX_PROP_TILESHEET 1026 // optional, can be derived from the operator tree +#define UDI_GFX_PROP_OPERATOR_INDEX 17 // deprecated for dedicated methods +#define UDI_GFX_PROP_OPERATOR_OPCODE 18 // deprecated for dedicated methods +#define UDI_GFX_PROP_OPERATOR_ARG_1 19 // deprecated for dedicated methods +#define UDI_GFX_PROP_OPERATOR_ARG_2 20 // deprecated for dedicated methods +#define UDI_GFX_PROP_OPERATOR_ARG_3 21 // deprecated for dedicated methods +#define UDI_GFX_PROP_SOURCE_WIDTH 12 // should have been documented when I still knew what it did. +#define UDI_GFX_PROP_SOURCE_HEIGHT 13 // should have been documented when I still knew what it did. +#define UDI_GFX_PROP_INPUTX 25 // should have been documented when I still knew what it did. +#define UDI_GFX_PROP_INPUTY 26 // should have been documented when I still knew what it did. + +// connector properties +#define UDI_GFX_PROP_SIGNAL 23 +#define UDI_GFX_PROP_CONNECTOR_TYPE 24 +#define UDI_GFX_PROP_VGA_H_FRONT_PORCH 25 +#define UDI_GFX_PROP_VGA_H_BACK_PORCH 26 +#define UDI_GFX_PROP_VGA_H_SYNC 27 +#define UDI_GFX_PROP_VGA_V_FRONT_PORCH 28 +#define UDI_GFX_PROP_VGA_V_BACK_PORCH 29 +#define UDI_GFX_PROP_VGA_V_SYNC 30 +#define UDI_GFX_PROP_DOT_CLOCK 31 +#define UDI_GFX_PROP_VGA_H_SYNC_POL 32 +#define UDI_GFX_PROP_VGA_V_SYNC_POL 33 + +/** + * Enumeration: UDI_GFX_SIGNAL + * Lists the various signal types + */ +#define UDI_GFX_SIGNAL_HIDDEN 0 +#define UDI_GFX_SIGNAL_INTEGRATED 0 +#define UDI_GFX_SIGNAL_RGBHV 1 +#define UDI_GFX_SIGNAL_RGBS 2 +#define UDI_GFX_SIGNAL_RGSB 3 +#define UDI_GFX_SIGNAL_YPBPR 4 +#define UDI_GFX_SIGNAL_DVID 5 +#define UDI_GFX_SIGNAL_YUV 6 +#define UDI_GFX_SIGNAL_YIQ 7 +#define UDI_GFX_SIGNAL_Y_UV 8 +#define UDI_GFX_SIGNAL_Y_IQ 9 +#define UDI_GFX_SIGNAL_HDMI 10 +#define UDI_GFX_SIGNAL_TEXT 11 +#define UDI_GFX_SIGNAL_CUSTOM 12 + +/** + * Enumeration: UDI_GFX_CONNECTOR + * Lists the various external connectors + */ +#define UDI_GFX_CONNECTOR_HIDDEN 0 +#define UDI_GFX_CONNECTOR_VGA 1 +#define UDI_GFX_CONNECTOR_DVI 2 +#define UDI_GFX_CONNECTOR_SVIDEO 3 +#define UDI_GFX_CONNECTOR_COMPONENT 4 +#define UDI_GFX_CONNECTOR_HDMI 5 +#define UDI_GFX_CONNECTOR_RF 6 +#define UDI_GFX_CONNECTOR_SCART 7 +#define UDI_GFX_CONNECTOR_COMPOSITE 8 +#define UDI_GFX_CONNECTOR_MEMBUFFER 9 + +/** + * Enumeration: UDI_GFX_OPERATOR + * Lists the display output operator + */ +#define UDI_GFX_OPERATOR_RGB 0 // output = (color) red(a1) + green(a2) + blue(a3) (each component is UDI_GFX_PROP_COLOR_BITS +#define UDI_GFX_OPERATOR_YUV 1 // output = (color) Y(a1) + U(a2) + V(a3) +#define UDI_GFX_OPERATOR_YIQ 2 // output = (color) Y(a1) + I(a2) + Q(a3) +#define UDI_GFX_OPERATOR_I 3 // output = (color) intensity(a1) +#define UDI_GFX_OPERATOR_ALPHA 4 // output = (color) a1 + alpha(a2) +#define UDI_GFX_OPERATOR_ADD 5 // output = a1 + a2 + v3 +#define UDI_GFX_OPERATOR_SUB 6 // output = a1 - a2 - v3 +#define UDI_GFX_OPERATOR_MUL 7 // output = a1 * a2 +#define UDI_GFX_OPERATOR_DIV 8 // output = a1 / a2 +#define UDI_GFX_OPERATOR_MAD 9 // output = a1 * a2 + a3 +#define UDI_GFX_OPERATOR_FRC 10 // output = (a1 * a2) / a3 +#define UDI_GFX_OPERATOR_SHR 11 // output = a1 >> (a2 + v3) +#define UDI_GFX_OPERATOR_SHL 12 // output = a1 << (a2 + v3) +#define UDI_GFX_OPERATOR_ROR 13 // output = a1 >> a2 (over a3 bits) +#define UDI_GFX_OPERATOR_ROL 14 // output = a1 << a2 (over a3 bits) +#define UDI_GFX_OPERATOR_SAR 15 // output = a1 >> a2 (width is a3 bits, i.e. empties are filled with bit a3-1) +#define UDI_GFX_OPERATOR_SAL 16 // output = a1 <<< (a2 + v3) (empties filled with bit 0) +#define UDI_GFX_OPERATOR_AND 17 // output = a1 & a2 +#define UDI_GFX_OPERATOR_OR 18 // output = a1 | a2 | v3 +#define UDI_GFX_OPERATOR_NOT 19 // output = ~a1 +#define UDI_GFX_OPERATOR_XOR 20 // output = a1 ^ a2 ^ v3 +#define UDI_GFX_OPERATOR_NEG 21 // output = -a1 +#define UDI_GFX_OPERATOR_SEG 22 // output = (a1 >> v2) & (2**v3-1) (select v3 bits starting from bit v2) +#define UDI_GFX_OPERATOR_RANGE 23 // output = (a1 > a2) ? a2 : ((a1 < a3) ? a3 : a1) +#define UDI_GFX_OPERATOR_CONST 24 // output = v1 +#define UDI_GFX_OPERATOR_ATTR 25 // output = property[a1 + v2] +#define UDI_GFX_OPERATOR_SWITCH 26 // output = output[(a1 % v3) + v2] +#define UDI_GFX_OPERATOR_BUFFER 27 // output = buffer[a1][a2] (buffer is v3 bits per entry) +#define UDI_GFX_OPERATOR_X 28 // output = output x pixel +#define UDI_GFX_OPERATOR_Y 29 // output = output y pixel +#define UDI_GFX_OPERATOR_TX 30 // output = horizontal tile index belonging to output pixel +#define UDI_GFX_OPERATOR_TY 31 // output = vertical tile index belonging to output pixel +#define UDI_GFX_OPERATOR_TXOFF 32 // output = horizontal offset from start of tile +#define UDI_GFX_OPERATOR_TYOFF 33 // output = vertical offset from start of tile +#define UDI_GFX_OPERATOR_INPUT 34 // output = input engine[x][y] component v1 +#define UDI_GFX_OPERATOR_DINPUT 35 // output = input engine[a1][a2] component v3 + +/* Enumeration: UDI_GFX_STOCK_FORMAT + * Lists stock configurations + * + * When a stock configuration is used, the device is set to behave as a + * simple framebuffer device. The and + * determine the virtual size of the framebuffer, and + * and indicate the offset into that framebuffer + * that is visible (which are typically restricted to negative values) + */ +#define UDI_GFX_STOCK_FORMAT_UNKNOWN 0 +#define UDI_GFX_STOCK_FORMAT_R8G8B8X8 1 +#define UDI_GFX_STOCK_FORMAT_B8G8R8X8 2 +#define UDI_GFX_STOCK_FORMAT_R8G8B8 3 +#define UDI_GFX_STOCK_FORMAT_B8G8R8 4 +#define UDI_GFX_STOCK_FORMAT_R5G6B5 5 +#define UDI_GFX_STOCK_FORMAT_B5G6R5 6 +#define UDI_GFX_STOCK_FORMAT_R5G5B5X1 7 +#define UDI_GFX_STOCK_FORMAT_B5G5R5X1 8 +#define UDI_GFX_STOCK_FORMAT_N8 9 + +// Enumeration: UDI_GFX_BUFFER_INFO_FLAG +// Lists behavioural patterns for direct buffer accesses. +// +#define UDI_GFX_BUFFER_INFO_FLAG_R 0x0001 // buffer can be read +#define UDI_GFX_BUFFER_INFO_FLAG_W 0x0002 // buffer can be written +#define UDI_GFX_BUFFER_INFO_FLAG_BITALIGN_ENTRY 0x0004 // for non-multiple-of-eight buffer slot sizes, align on byte boundary every unit +#define UDI_GFX_BUFFER_INFO_FLAG_BITALIGN_ROW 0x0008 // for non-multiple-of-eight buffer slot sizes, align only the start of the row + + +// Constant: UDI_GFX_PROVIDER_OPS_NUM +// the ops number used for the graphics driver +#define UDI_GFX_PROVIDER_OPS_NUM 1 + +// Constant: UDI_GFX_CLIENT_OPS_NUM +// the ops number used for the graphics application +#define UDI_GFX_CLIENT_OPS_NUM 2 + +// Structure: udi_gfx_bind_cb_t +// Contains the operations of a driver binding request +typedef struct { + // Variable: gcb + // The main control block + udi_cb_t gcb; +} udi_gfx_bind_cb_t; +#define UDI_GFX_BIND_CB_NUM 1 + +// Function: udi_block_bind_req +// function pointer prototype for connecting to a block device +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_bind_req_op_t (udi_gfx_bind_cb_t *cb ); +udi_gfx_bind_req_op_t udi_gfx_bind_req; + +// Function: udi_gfx_bind_ack +// function pointer prototype for acknowledging a connection request +// +// in: +// cb - A pointer to a +// sockets - The number of addressable socket components +// engines - The number of addressable engine components +// status - The result of the bind operation +// +typedef void udi_gfx_bind_ack_op_t (udi_gfx_bind_cb_t *cb, udi_index_t sockets, udi_index_t engines, udi_status_t status ); +udi_gfx_bind_ack_op_t udi_gfx_bind_ack; + +// Function: udi_gfx_unbind_req +// function pointer prototype for disconnecting a block device +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_unbind_req_op_t (udi_gfx_bind_cb_t *cb ); +udi_gfx_unbind_req_op_t udi_gfx_unbind_req; + +// Function: udi_gfx_unbind_ack +// function pointer prototype for connecting to a block device +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_unbind_ack_op_t (udi_gfx_bind_cb_t *cb ); +udi_gfx_unbind_ack_op_t udi_gfx_unbind_ack; + +// Structure: udi_gfx_state_cb_t +// Contains the operations of a read/write transaction +typedef struct { + // Variable: gcb + // The main control block + udi_cb_t gcb; + udi_ubit32_t subsystem; + udi_ubit32_t attribute; +} udi_gfx_state_cb_t; +#define UDI_GFX_STATE_CB_NUM 2 + +// Function: udi_gfx_set_engine_req +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_set_engine_req_op_t (udi_gfx_state_cb_t *cb, udi_ubit32_t value); +udi_gfx_set_engine_req_op_t udi_gfx_set_engine_req; + +// Function: udi_gfx_set_connector_req +// function pointer prototype for setting an connector state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_set_connector_req_op_t (udi_gfx_state_cb_t *cb, udi_ubit32_t value); +udi_gfx_set_connector_req_op_t udi_gfx_set_connector_req; + +// Function: udi_gfx_set_engine_ack +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_set_engine_ack_op_t (udi_gfx_state_cb_t *cb ); +udi_gfx_set_engine_ack_op_t udi_gfx_set_engine_ack; + +// Function: udi_gfx_set_connector_ack +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_set_connector_ack_op_t (udi_gfx_state_cb_t *cb ); +udi_gfx_set_connector_ack_op_t udi_gfx_set_connector_ack; + +// Function: udi_gfx_get_engine_req +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_get_engine_req_op_t (udi_gfx_state_cb_t *cb ); +udi_gfx_get_engine_req_op_t udi_gfx_get_engine_req; + +// Function: udi_gfx_get_connector_req +// function pointer prototype for setting an connector state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_get_connector_req_op_t (udi_gfx_state_cb_t *cb ); +udi_gfx_get_connector_req_op_t udi_gfx_get_connector_req; + +// Function: udi_gfx_get_engine_ack +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_get_engine_ack_op_t (udi_gfx_state_cb_t *cb, udi_ubit32_t value); +udi_gfx_get_engine_ack_op_t udi_gfx_get_engine_ack; + +// Function: udi_gfx_get_connector_ack +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_get_connector_ack_op_t (udi_gfx_state_cb_t *cb, udi_ubit32_t value); +udi_gfx_get_connector_ack_op_t udi_gfx_get_connector_ack; + +// Function: udi_gfx_set_engine_nak +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// status - An UDI status value indicative of the error +// +typedef void udi_gfx_set_engine_nak_op_t (udi_gfx_state_cb_t *cb, udi_status_t status); +udi_gfx_set_engine_nak_op_t udi_gfx_set_engine_nak; + +// Function: udi_gfx_set_connector_nak +// function pointer prototype for setting an engine state +// +// in: +// cb - A pointer to a +// status - An UDI status value indicative of the error +// +typedef void udi_gfx_set_connector_nak_op_t (udi_gfx_state_cb_t *cb, udi_status_t status); +udi_gfx_set_connector_nak_op_t udi_gfx_get_connector_nak; + +// Structure: udi_gfx_range_cb_t +// Contains the operations of a range request transaction +typedef struct { + // Variable: gcb + // The main control block + udi_cb_t gcb; + udi_ubit32_t subsystem; + udi_ubit32_t attribute; + udi_buf_t * rangedata; +} udi_gfx_range_cb_t; +#define UDI_GFX_RANGE_CB_NUM 3 + +// Function: udi_gfx_range_engine_req +// function pointer prototype for getting an engine property range +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_range_engine_req_op_t (udi_gfx_range_cb_t *cb ); +udi_gfx_range_engine_req_op_t udi_gfx_range_engine_req; + +// Function: udi_gfx_range_connector_req +// function pointer prototype for getting a connector property range +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_range_connector_req_op_t (udi_gfx_range_cb_t *cb ); +udi_gfx_range_connector_req_op_t udi_gfx_range_connector_req; + +// Function: udi_gfx_range_engine_ack +// function pointer prototype for replying an engine property range +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_range_engine_ack_op_t (udi_gfx_range_cb_t *cb ); +udi_gfx_range_engine_ack_op_t udi_gfx_range_engine_ack; + +// Function: udi_gfx_range_connector_ack +// function pointer prototype for replying a connector property range +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_range_connector_ack_op_t (udi_gfx_range_cb_t *cb ); +udi_gfx_range_connector_ack_op_t udi_gfx_range_connector_ack; + +// Function: udi_gfx_get_engine_operator_req +// function pointer prototype for requesting the engine operator layout +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_get_engine_operator_req_op_t (udi_gfx_range_cb_t *cb ); +udi_gfx_get_engine_operator_req_op_t udi_gfx_get_engine_operator_req; + +// Function: udi_gfx_get_engine_operator_ack +// function pointer prototype for replying the engine operator layout +// +// in: +// cb - A pointer to a +// op - The operator performed at this index +// arg1 - the first argument to this operator +// arg2 - the second argument to this operator +// arg3 - the third argument to this operator +// +typedef void udi_gfx_get_engine_operator_ack_op_t (udi_gfx_range_cb_t *cb, udi_ubit32_t op, udi_ubit32_t arg1, udi_ubit32_t arg2, udi_ubit32_t arg3 ); +udi_gfx_get_engine_operator_ack_op_t udi_gfx_get_engine_operator_ack; + + + +// Structure: udi_gfx_command_cb_t +// Contains the operations of a command sequence +typedef struct { + // Variable: gcb + // The main control block + udi_cb_t gcb; + udi_buf_t * commanddata; +} udi_gfx_command_cb_t; +#define UDI_GFX_COMMAND_CB_NUM 4 + +// Function: udi_gfx_connector_command_req +// function pointer prototype for sending command data to the output connector +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_connector_command_req_op_t (udi_gfx_command_cb_t *cb ); +udi_gfx_connector_command_req_op_t udi_gfx_connector_command_req; + +// Function: udi_gfx_engine_command_req +// function pointer prototype for sending command data to the engine +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_engine_command_req_op_t (udi_gfx_command_cb_t *cb ); +udi_gfx_engine_command_req_op_t udi_gfx_engine_command_req; + +// Function: udi_gfx_connector_command_ack +// function pointer prototype for sending command data replies +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_connector_command_ack_op_t (udi_gfx_command_cb_t *cb); +udi_gfx_connector_command_ack_op_t udi_gfx_connector_command_ack; + +// Function: udi_gfx_engine_command_ack +// function pointer prototype for sending engine data replies +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_engine_command_ack_op_t (udi_gfx_command_cb_t *cb); +udi_gfx_engine_command_ack_op_t udi_gfx_engine_command_ack; + +// Structure: udi_gfx_buffer_cb_t +// Contains a description of a buffer, or area thereof +typedef struct { + // Variable: gcb + // The main control block + udi_cb_t gcb; + udi_ubit32_t buffer_index; +} udi_gfx_buffer_info_cb_t; + +// Function: udi_gfx_buffer_info_req +// function pointer prototype for getting buffer configuration information +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_info_req_op_t (udi_gfx_buffer_info_cb_t *cb); +udi_gfx_buffer_info_req_op_t udi_gfx_buffer_info_req; + +// Function: udi_gfx_buffer_info_ack +// function pointer prototype for getting buffer configuration information +// +// in: +// cb - A pointer to a +// width - The width of the buffer +// height - The height of the buffer +// bitsper - The number of bits read from the buffer per pixel unit +// flags - A bitfield of indicating the exposed +// capabilities of this buffer +// +// Note that bitsper might not be a multiple of eight. +// +typedef void udi_gfx_buffer_info_ack_op_t (udi_gfx_buffer_info_cb_t *cb, udi_ubit32_t width, udi_ubit32_t height, udi_ubit32_t bitsper, udi_ubit32_t flags); +udi_gfx_buffer_info_ack_op_t udi_gfx_buffer_info_ack; + +// Structure: udi_gfx_buffer_cb_t +// Contains a description of a buffer, or area thereof +typedef struct { + // Variable: gcb + // The main control block + udi_cb_t gcb; + udi_ubit32_t buffer_index; + udi_ubit32_t x; + udi_ubit32_t y; + udi_ubit32_t width; + udi_ubit32_t height; + udi_buf_t * buffer; +} udi_gfx_buffer_cb_t; + +// Function: udi_gfx_buffer_write_req_op_t +// function pointer prototype for writing raw hardware buffers +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_write_req_op_t (udi_gfx_buffer_cb_t *cb); +udi_gfx_buffer_write_req_op_t udi_gfx_buffer_write_req; + +// Function: udi_gfx_buffer_write_req_op_t +// function pointer prototype for reading raw hardware buffers +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_read_req_op_t (udi_gfx_buffer_cb_t *cb); +udi_gfx_buffer_read_req_op_t udi_gfx_buffer_read_req; + +// Function: udi_gfx_buffer_write_ack_op_t +// function pointer prototype for writing raw hardware buffers +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_write_ack_op_t (udi_gfx_buffer_cb_t *cb); +udi_gfx_buffer_write_ack_op_t udi_gfx_buffer_write_ack; + +// Function: udi_gfx_buffer_write_ack_op_t +// function pointer prototype for reading raw hardware buffers +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_read_ack_op_t (udi_gfx_buffer_cb_t *cb); +udi_gfx_buffer_read_ack_op_t udi_gfx_buffer_read_ack; + +// Function: udi_gfx_buffer_write_nak_op_t +// error handling for buffer writes +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_write_nak_op_t (udi_gfx_buffer_cb_t *cb, udi_status_t status); +udi_gfx_buffer_write_nak_op_t udi_gfx_buffer_write_nak; + +// Function: udi_gfx_buffer_write_nak_op_t +// error handling for buffer reads +// +// in: +// cb - A pointer to a +// +typedef void udi_gfx_buffer_read_nak_op_t (udi_gfx_buffer_cb_t *cb, udi_status_t status); +udi_gfx_buffer_read_nak_op_t udi_gfx_buffer_read_nak; + +/* Structure: udi_gfx_provider_ops_t + * + * The graphics metalanguage entry points (provider side) + */ +typedef const struct { + udi_channel_event_ind_op_t *channel_event_ind_op; + udi_gfx_bind_req_op_t *gfx_bind_req_op; + udi_gfx_unbind_req_op_t *gfx_unbind_req_op; + udi_gfx_set_connector_req_op_t *gfx_set_connector_req_op; + udi_gfx_set_engine_req_op_t *gfx_set_engine_req_op; + udi_gfx_get_connector_req_op_t *gfx_get_connector_req_op; + udi_gfx_get_engine_req_op_t *gfx_get_engine_req_op; + udi_gfx_range_connector_req_op_t *gfx_range_connector_req_op; + udi_gfx_range_engine_req_op_t *gfx_range_engine_req_op; + udi_gfx_get_engine_operator_req_op_t*gfx_get_engine_operator_req_op; + udi_gfx_connector_command_req_op_t *gfx_connector_command_req_op; + udi_gfx_engine_command_req_op_t *gfx_engine_command_req_op; + udi_gfx_buffer_info_req_op_t *gfx_buffer_info_req_op; + udi_gfx_buffer_read_req_op_t *gfx_buffer_read_req_op; + udi_gfx_buffer_write_req_op_t *gfx_buffer_write_req_op; +} udi_gfx_provider_ops_t; + +/* Structure: udi_gfx_client_ops_t + * + * The graphics metalanguage entry points (client side) + */ +typedef const struct { + udi_channel_event_ind_op_t *channel_event_ind_op; + udi_gfx_bind_ack_op_t *gfx_bind_ack_op; + udi_gfx_unbind_ack_op_t *gfx_unbind_ack_op; + udi_gfx_set_connector_ack_op_t *gfx_set_connector_ack_op; + udi_gfx_set_engine_ack_op_t *gfx_set_engine_ack_op; + udi_gfx_set_connector_nak_op_t *gfx_set_connector_nak_op; + udi_gfx_set_engine_nak_op_t *gfx_set_engine_nak_op; + udi_gfx_get_connector_ack_op_t *gfx_get_connector_ack_op; + udi_gfx_get_engine_ack_op_t *gfx_get_engine_ack_op; + udi_gfx_range_connector_ack_op_t *gfx_range_connector_ack_op; + udi_gfx_range_engine_ack_op_t *gfx_range_engine_ack_op; + udi_gfx_get_engine_operator_req_op_t*gfx_get_engine_operator_ack_op; + udi_gfx_connector_command_ack_op_t *gfx_connector_command_ack_op; + udi_gfx_engine_command_ack_op_t *gfx_engine_command_ack_op; + udi_gfx_buffer_info_ack_op_t *gfx_buffer_info_ack_op; + udi_gfx_buffer_read_ack_op_t *gfx_buffer_read_ack_op; + udi_gfx_buffer_write_ack_op_t *gfx_buffer_write_ack_op; + udi_gfx_buffer_read_nak_op_t *gfx_buffer_read_nak_op; + udi_gfx_buffer_write_nak_op_t *gfx_buffer_write_nak_op; +} udi_gfx_client_ops_t; + + +// temporary +#ifndef UDI_ANNOY_ME +void EngineReturnSimpleRange (int source, int index, int prop, int first, int last, int modulus); +void ConnectorReturnSimpleRange (int source, int index, int prop, int first, int last, int modulus); +void EngineReturnConstantRange (int source, int index, int prop, int value); +void ConnectorReturnConstantRange (int source, int index, int prop, int value); +void EngineReturnBooleanRange (int source, int index, int prop, int value1, int value2); +void ConnectorReturnBooleanRange (int source, int index, int prop, int value1, int value2); +#endif + +#endif