VCHPRE_ int VCHPOST_ vc_dispmanx_resource_write_data_handle( DISPMANX_RESOURCE_HANDLE_T handle, VC_IMAGE_TYPE_T src_type /* not used */,
int src_pitch, VCHI_MEM_HANDLE_T mem_handle, uint32_t offset,
const VC_RECT_T * rect ) {
int32_t bulk_len;
uint32_t param[3];
uint32_t success = 0;
//Note that x coordinate of the rect is NOT used
//Address of data in host
offset += src_pitch * rect->y;
bulk_len = src_pitch * rect->height;
//Now send the bulk transfer across
//command parameters: resource handle, destination y, bulk length
param[0] = VC_HTOV32(handle);
param[1] = VC_HTOV32(rect->y);
param[2] = VC_HTOV32(bulk_len);
success = dispmanx_send_command( EDispmanBulkWrite | DISPMANX_NO_REPLY_MASK, param, sizeof(param));
if(success == 0)
{
lock_obtain();
success = vchi_bulk_queue_transmit_reloc( dispmanx_client.client_handle[0],
mem_handle, offset,
bulk_len,
VCHI_FLAGS_BLOCK_UNTIL_DATA_READ,
NULL );
lock_release();
}
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_resource_write_data
*
* Arguments:
* DISPMANX_RESOURCE_HANDLE_T res
* int src_pitch
* void * src_address
* const VC_RECT_T * rect
*
* Description: Copy the bitmap data to VideoCore memory
*
* Returns: 0 or failure
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_resource_write_data( DISPMANX_RESOURCE_HANDLE_T handle, VC_IMAGE_TYPE_T src_type /* not used */,
int src_pitch, void * src_address, const VC_RECT_T * rect ) {
(void)src_type;
//Note that x coordinate of the rect is NOT used
//Address of data in host
uint8_t *host_start = (uint8_t *)src_address + src_pitch * rect->y;
int32_t bulk_len = src_pitch * rect->height, success = 0;
//Now send the bulk transfer across
//command parameters: resource handle, destination y, bulk length
uint32_t param[] = {VC_HTOV32(handle), VC_HTOV32(rect->y), VC_HTOV32(bulk_len)};
success = dispmanx_send_command( EDispmanBulkWrite | DISPMANX_NO_REPLY_MASK, param, sizeof(param));
if(success == 0)
{
lock_obtain();
success = vchi_bulk_queue_transmit( dispmanx_client.client_handle[0],
host_start,
bulk_len,
VCHI_FLAGS_BLOCK_UNTIL_DATA_READ,
NULL );
lock_release();
}
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_resource_read_data
*
* Arguments:
* DISPMANX_RESOURCE_HANDLE_T res
* int src_pitch
* void * src_address
* const VC_RECT_T * rect
*
* Description: Copy the bitmap data to VideoCore memory
*
* Returns: 0 or failure
*
***********************************************************/
VCHPRE_ int VCHPOST_
vc_dispmanx_resource_read_data(
DISPMANX_RESOURCE_HANDLE_T handle,
const VC_RECT_T* p_rect,
void * dst_address,
uint32_t dst_pitch )
{
uint8_t* host_start;
int32_t bulk_len;
int32_t success = 0;
if ( p_rect == 0 || dst_address == 0 || dst_pitch == 0 )
{
return -1;
}
host_start = (uint8_t *)dst_address + (dst_pitch * p_rect->y);
bulk_len = (int32_t)dst_pitch * (p_rect->height-p_rect->y);
// Now send the bulk transfer across
// command parameters: resource handle, destination y, bulk length
uint32_t param[] = { VC_HTOV32(handle), VC_HTOV32(p_rect->y), VC_HTOV32(bulk_len) };
success = dispmanx_send_command( EDispmanBulkRead | DISPMANX_NO_REPLY_MASK, param, sizeof(param));
if (success == 0)
{
lock_obtain();
success = vchi_bulk_queue_receive( dispmanx_client.client_handle[0],
host_start,
bulk_len,
VCHI_FLAGS_BLOCK_UNTIL_OP_COMPLETE,
0 );
lock_release();
}
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_display_set_background
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_DISPLAY_HANDLE_T display
* uint8_t red
* uint8_t green
* uint8_t blue
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_display_set_background( DISPMANX_UPDATE_HANDLE_T update, DISPMANX_DISPLAY_HANDLE_T display,
uint8_t red, uint8_t green, uint8_t blue ) {
uint32_t display_param[] = {(uint32_t)VC_HTOV32(update), (uint32_t) VC_HTOV32(display), VC_HTOV32(red), VC_HTOV32(green), VC_HTOV32(blue)};
int success = (int) dispmanx_send_command( EDispmanDisplaySetBackground | DISPMANX_NO_REPLY_MASK,
display_param, sizeof(display_param));
return success;
}
/***********************************************************
* Name: vc_dispmanx_display_open_offscreen
*
* Arguments:
* DISPMANX_RESOURCE_HANDLE_T dest
* VC_IMAGE_TRANSFORM_T orientation
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ DISPMANX_DISPLAY_HANDLE_T VCHPOST_ vc_dispmanx_display_open_offscreen( DISPMANX_RESOURCE_HANDLE_T dest, VC_IMAGE_TRANSFORM_T orientation ) {
uint32_t display_open_param[] = {(uint32_t)VC_HTOV32(dest), (uint32_t)VC_HTOV32(orientation)};
uint32_t display_handle = dispmanx_get_handle(EDispmanDisplayOpenOffscreen,
&display_open_param, sizeof(display_open_param));
return (DISPMANX_DISPLAY_HANDLE_T) display_handle;
}
/***********************************************************
* Name: vc_dispmanx_display_open_mode
*
* Arguments:
* uint32_t device
* uint32_t mode
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ DISPMANX_DISPLAY_HANDLE_T VCHPOST_ vc_dispmanx_display_open_mode( uint32_t device, uint32_t mode ) {
uint32_t display_open_param[] = {VC_HTOV32(device), VC_HTOV32(mode)};
uint32_t display_handle = dispmanx_get_handle(EDispmanDisplayOpenMode,
&display_open_param, sizeof(display_open_param));
return (DISPMANX_DISPLAY_HANDLE_T) display_handle;
}
/***********************************************************
* Name: vc_dispmanx_vsync_callback
*
* Arguments:
* DISPMANX_DISPLAY_HANDLE_T display
* DISPMANX_CALLBACK_FUNC_T cb_func
* void *cb_arg
*
* Description: start sending callbacks on vsync events
* Use a NULL cb_func to stop the callbacks
* Returns: 0 or failure
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_vsync_callback( DISPMANX_DISPLAY_HANDLE_T display, DISPMANX_CALLBACK_FUNC_T cb_func, void *cb_arg )
{
// Steal the invalid 0 handle to indicate this is a vsync request
DISPMANX_UPDATE_HANDLE_T update = 0;
int enable = (cb_func != NULL);
uint32_t update_param[] = {(uint32_t) VC_HTOV32(display), VC_HTOV32(update), (int32_t)enable};
int success;
// Set the callback
dispmanx_client.vsync_callback = cb_func;
dispmanx_client.vsync_callback_param = cb_arg;
if (!dispmanx_client.vsync_enabled && enable) {
// An extra "use" is required while a vsync callback is registered.
// The corresponding "release" is below.
vchi_service_use(dispmanx_client.notify_handle[0]);
}
success = (int) dispmanx_send_command( EDispmanVsyncCallback | DISPMANX_NO_REPLY_MASK,
update_param, sizeof(update_param));
if (dispmanx_client.vsync_enabled && !enable) {
// The extra "use" added above is no longer required.
vchi_service_release(dispmanx_client.notify_handle[0]);
}
dispmanx_client.vsync_enabled = enable;
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_element_change_source
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_ELEMENT_HANDLE_T element
* DISPMANX_RESOURCE_HANDLE_T src
*
* Description:
*
* Returns: VCHI error code
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_element_change_source( DISPMANX_UPDATE_HANDLE_T update, DISPMANX_ELEMENT_HANDLE_T element,
DISPMANX_RESOURCE_HANDLE_T src ) {
uint32_t element_param[] = { (uint32_t) VC_HTOV32(update),
(uint32_t) VC_HTOV32(element),
(uint32_t) VC_HTOV32(src) };
int success = (int) dispmanx_send_command( EDispmanElementChangeSource | DISPMANX_NO_REPLY_MASK,
element_param, sizeof(element_param));
return success;
}
/***********************************************************
* Name: vc_dispmanx_update_submit
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_CALLBACK_FUNC_T cb_func
* void *cb_arg
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_update_submit( DISPMANX_UPDATE_HANDLE_T update, DISPMANX_CALLBACK_FUNC_T cb_func, void *cb_arg ) {
uint32_t update_param[] = {(uint32_t) VC_HTOV32(update), (uint32_t) ((cb_func)? VC_HTOV32(1) : 0)};
int success;
//Set the callback
dispmanx_client.update_callback = cb_func;
dispmanx_client.update_callback_param = cb_arg;
dispmanx_client.pending_update_handle = update;
vchi_service_use(dispmanx_client.notify_handle[0]); // corresponding release is in dispmanx_notify_func
success = (int) dispmanx_send_command( EDispmanUpdateSubmit | DISPMANX_NO_REPLY_MASK,
update_param, sizeof(update_param));
return success;
}
/***********************************************************
* Name: vc_dispmanx_resource_create
*
* Arguments:
* VC_IMAGE_TYPE_T type
* uint32_t width
* uint32_t height
*
* Description: Create a new resource (in Videocore memory)
*
* Returns: resource handle
*
***********************************************************/
VCHPRE_ DISPMANX_RESOURCE_HANDLE_T VCHPOST_ vc_dispmanx_resource_create( VC_IMAGE_TYPE_T type, uint32_t width, uint32_t height, uint32_t *native_image_handle ) {
uint32_t resourceCreateParams[] = { (uint32_t)VC_HTOV32(type), VC_HTOV32(width), VC_HTOV32(height) };
uint32_t resource = 0;
resource = dispmanx_get_handle(EDispmanResourceCreate, resourceCreateParams, sizeof(resourceCreateParams));
//We don't get an image handle back, so explicitly set this to zero to let the caller know
*native_image_handle = 0;
//The caller should call vc_dispmanx_resource_get_image_handle below to get the VC_IMAGE_T *
//This will be deprecated soon, however
return (DISPMANX_RESOURCE_HANDLE_T) resource;
}
/***********************************************************
* Name: vc_dispmanx_snapshot
*
* Arguments:
* DISPMANX_DISPLAY_HANDLE_T display
* DISPMANX_RESOURCE_HANDLE_T snapshot_resource
* VC_IMAGE_TRANSFORM_T transform
*
* Description: Take a snapshot of a display in its current state
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_snapshot( DISPMANX_DISPLAY_HANDLE_T display,
DISPMANX_RESOURCE_HANDLE_T snapshot_resource,
VC_IMAGE_TRANSFORM_T transform )
{
uint32_t display_snapshot_param[] = {
VC_HTOV32(display),
VC_HTOV32(snapshot_resource),
VC_HTOV32(transform)};
int success = (int) dispmanx_send_command( EDispmanSnapshot,
display_snapshot_param,
sizeof(display_snapshot_param));
return success;
}
/***********************************************************
* Name: vc_dispmanx_update_submit_sync
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
*
* Description:
*
* Returns: VCHI error code
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_update_submit_sync( DISPMANX_UPDATE_HANDLE_T update ) {
int success;
update = VC_HTOV32(update);
success = (int) dispmanx_send_command( EDispmanUpdateSubmitSync,
&update, sizeof(update));
return success;
}
/***********************************************************
* Name: vc_dispmanx_display_close
*
* Arguments:
* DISPMANX_DISPLAY_HANDLE_T display
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_display_close( DISPMANX_DISPLAY_HANDLE_T display ) {
int success;
display = VC_HTOV32(display);
success = (int) dispmanx_send_command( EDispmanDisplayClose | DISPMANX_NO_REPLY_MASK,
&display, sizeof(display));
return success;
}
/***********************************************************
* Name: vc_cec_send_message
*
* Arguments:
* Follower's logical address
* Message payload WITHOUT the header byte (can be NULL)
* Payload length WITHOUT the header byte (can be zero)
* VC_TRUE if the message is a reply to an incoming message
* (For poll message set payload to NULL and length to zero)
*
* Description
* Remove all commands to be forwarded. This does not affect
* the button presses which are always forwarded
*
* Returns: if the command is successful (zero) or not (non-zero)
* If the command is successful, there will be a Tx callback
* in due course to indicate whether the message has been
* acknowledged by the recipient or not
***********************************************************/
VCHPRE_ int VCHPOST_ vc_cec_send_message(uint32_t follower,
const uint8_t *payload,
uint32_t length,
bool_t is_reply) {
int success = -1;
CEC_SEND_MSG_PARAM_T param;
vcos_assert(length <= CEC_MAX_XMIT_LENGTH);
param.follower = VC_HTOV32(follower);
param.length = VC_HTOV32(length);
param.is_reply = VC_HTOV32(is_reply);
memset(param.payload, 0, sizeof(param.payload));
if(length > 0 && vcos_verify(payload)) {
memcpy(param.payload, payload, _min(length, CEC_MAX_XMIT_LENGTH));
}
success = cecservice_send_command( VC_CEC_SEND_MSG, ¶m, sizeof(param), 1);
return success;
}
/***********************************************************
* Name: vc_dispmanx_update_start
*
* Arguments:
* int32_t priority
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ DISPMANX_UPDATE_HANDLE_T VCHPOST_ vc_dispmanx_update_start( int32_t priority ) {
uint32_t handle;
priority = VC_HTOV32(priority);
handle = dispmanx_get_handle(EDispmanUpdateStart,
&priority, sizeof(priority));
return (DISPMANX_UPDATE_HANDLE_T) handle;
}
/***********************************************************
* Name: vc_dispmanx_resource_delete
*
* Arguments:
* DISPMANX_RESOURCE_HANDLE_T res
*
* Description:
*
* Returns: 0 or failure
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_resource_delete( DISPMANX_RESOURCE_HANDLE_T res ) {
int status;
res = VC_HTOV32(res);
//We block to make sure the memory is freed after the call
status = (int) dispmanx_send_command(EDispmanResourceDelete, &res, sizeof(res));
return status;
}
/***********************************************************
* Name: vc_dispmanx_display_open
*
* Arguments:
* uint32_t device
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ DISPMANX_DISPLAY_HANDLE_T VCHPOST_ vc_dispmanx_display_open( uint32_t device ) {
uint32_t display_handle;
device = VC_HTOV32(device);
display_handle = dispmanx_get_handle(EDispmanDisplayOpen,
&device, sizeof(device));
return (DISPMANX_DISPLAY_HANDLE_T) display_handle;
}
/***********************************************************
* Name: vc_dispmanx_resource_set_palette
*
* Arguments:
* DISPMANX_RESOURCE_HANDLE_T res
* void * src_address
* int offset
* int size
*
* Description: Set the resource palette (for VC_IMAGE_4BPP and VC_IMAGE_8BPP)
* offset should be 0
* size is 16*2 for 4BPP and 256*2 for 8BPP
* Returns: 0 or failure
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_resource_set_palette( DISPMANX_RESOURCE_HANDLE_T handle,
void * src_address, int offset, int size) {
//Note that x coordinate of the rect is NOT used
//Address of data in host
uint8_t *host_start = src_address;
int32_t bulk_len = size, success = 0;
//Now send the bulk transfer across
//command parameters: resource size
uint32_t param[] = {VC_HTOV32(handle), VC_HTOV32(offset), VC_HTOV32(bulk_len) };
success = dispmanx_send_command( EDispmanSetPalette | DISPMANX_NO_REPLY_MASK, param, sizeof(param));
if(success == 0)
{
lock_obtain();
success = vchi_bulk_queue_transmit( dispmanx_client.client_handle[0],
host_start,
bulk_len,
VCHI_FLAGS_BLOCK_UNTIL_DATA_READ,
NULL );
lock_release();
}
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_display_get_info
*
* Arguments:
* DISPMANX_DISPLAY_HANDLE_T display
* DISPMANX_MODEINFO_T * pinfo
*
* Description:
*
* Returns: VCHI error
*
***********************************************************/
VCHPRE_ int VCHPOST_
vc_dispmanx_display_get_info (DISPMANX_DISPLAY_HANDLE_T display,
DISPMANX_MODEINFO_T *pinfo)
{
GET_INFO_DATA_T info;
int32_t success;
display = VC_HTOV32(display);
success = dispmanx_send_command_reply (EDispmanDisplayGetInfo,
&display, sizeof(display),
&info, sizeof(info));
if(success == 0) {
pinfo->width = VC_VTOH32(info.width);
pinfo->height = VC_VTOH32(info.height);
pinfo->transform = (VC_IMAGE_TRANSFORM_T)VC_VTOH32(info.transform);
pinfo->input_format = (DISPLAY_INPUT_FORMAT_T)VC_VTOH32(info.input_format);
}
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_element_modified
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_ELEMENT_HANDLE_T element
* const VC_RECT_T * rect
*
* Description:
*
* Returns: VCHI error code
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_element_modified( DISPMANX_UPDATE_HANDLE_T update, DISPMANX_ELEMENT_HANDLE_T element, const VC_RECT_T * rect ) {
uint32_t element_param[6] = { (uint32_t) VC_HTOV32(update),
(uint32_t) VC_HTOV32(element), 0, 0, 0, 0};
uint32_t param_length = 2*sizeof(uint32_t);
int success;
if(rect) {
element_param[2] = VC_HTOV32(rect->x);
element_param[3] = VC_HTOV32(rect->y);
element_param[4] = VC_HTOV32(rect->width);
element_param[5] = VC_HTOV32(rect->height);
param_length = 6*sizeof(uint32_t);
}
success = (int) dispmanx_send_command( EDispmanElementModified | DISPMANX_NO_REPLY_MASK,
element_param, param_length);
return success;
}
/***********************************************************
* Name: vc_dispmanx_display_reconfigure
*
* Arguments:
* DISPMANX_DISPLAY_HANDLE_T display
* uint32_t mode
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_display_reconfigure( DISPMANX_DISPLAY_HANDLE_T device, uint32_t mode ) {
uint32_t display_param[] = {(uint32_t)VC_HTOV32(device), VC_HTOV32(mode)};
int32_t success = dispmanx_send_command( EDispmanDisplayReconfigure | DISPMANX_NO_REPLY_MASK,
display_param, sizeof(display_param));
return (int) success;
}
/***********************************************************
* Name: vc_dispmanx_element_change_attributes
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_ELEMENT_HANDLE_T element
* uint32_t change flags (bit 0 layer, bit 1 opacity, bit 2 dest rect, bit 3 src rect, bit 4 mask, bit 5 transform
* uint32_t layer
* uint8_t opacity
* const VC_RECT_T *dest rect
* const VC_RECT_T *src rect
* DISPMANX_RESOURCE_HANDLE_T mask
* VC_IMAGE_TRANSFORM_T transform
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_element_change_attributes( DISPMANX_UPDATE_HANDLE_T update,
DISPMANX_ELEMENT_HANDLE_T element,
uint32_t change_flags,
int32_t layer,
uint8_t opacity,
const VC_RECT_T *dest_rect,
const VC_RECT_T *src_rect,
DISPMANX_RESOURCE_HANDLE_T mask,
VC_IMAGE_TRANSFORM_T transform ) {
uint32_t element_param[15] = { (uint32_t) VC_HTOV32(update),
(uint32_t) VC_HTOV32(element),
VC_HTOV32(change_flags),
VC_HTOV32(layer),
VC_HTOV32(opacity),
(uint32_t) VC_HTOV32(mask),
(uint32_t) VC_HTOV32(transform), 0, 0, 0, 0, 0, 0, 0, 0};
uint32_t param_length = 7*sizeof(uint32_t);
int success;
if(dest_rect) {
element_param[7] = VC_HTOV32(dest_rect->x);
element_param[8] = VC_HTOV32(dest_rect->y);
element_param[9] = VC_HTOV32(dest_rect->width);
element_param[10] = VC_HTOV32(dest_rect->height);
element_param[2] |= ELEMENT_CHANGE_DEST_RECT;
param_length += 4*sizeof(uint32_t);
}
if(src_rect) {
element_param[11] = VC_HTOV32(src_rect->x);
element_param[12] = VC_HTOV32(src_rect->y);
element_param[13] = VC_HTOV32(src_rect->width);
element_param[14] = VC_HTOV32(src_rect->height);
element_param[2] |= ELEMENT_CHANGE_SRC_RECT;
param_length += 4*sizeof(uint32_t);
}
success = (int) dispmanx_send_command( EDispmanElementChangeAttributes | DISPMANX_NO_REPLY_MASK,
element_param, param_length);
return success;
}
/***********************************************************
* Name: vc_dispmanx_element_remove
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_ELEMENT_HANDLE_T element
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_element_remove( DISPMANX_UPDATE_HANDLE_T update, DISPMANX_ELEMENT_HANDLE_T element ) {
uint32_t element_param[] = {(uint32_t) VC_HTOV32(update), (uint32_t) VC_HTOV32(element)};
int success = (int) dispmanx_send_command( EDispmanElementRemove | DISPMANX_NO_REPLY_MASK,
element_param, sizeof(element_param));
return success;
}
/***********************************************************
* Name: vc_cec_deregister_command
*
* Arguments:
* opcode to be deregistered
*
* Description
* Deregister an opcode to be forwarded as VC_CEC_RX notification
* The following opcode cannot be deregistered:
* <User Control Pressed>, <User Control Released>,
* <Vendor Remote Button Down>, <Vendor Remote Button Up>,
* <Feature Abort>, <Abort>
*
* Returns: if the command is successful (zero) or not (non-zero)
***********************************************************/
VCHPRE_ int VCHPOST_ vc_cec_deregister_command(CEC_OPCODE_T opcode) {
int success = -1;
uint32_t param = VC_HTOV32(opcode);
success = cecservice_send_command( VC_CEC_DEREGISTER_CMD, ¶m, sizeof(param), 0);
return success;
}
/***********************************************************
* Name: vc_dispmanx_element_add
*
* Arguments:
* DISPMANX_UPDATE_HANDLE_T update
* DISPMANX_DISPLAY_HANDLE_T display
* int32_t layer
* const VC_RECT_T *dest_rect
* DISPMANX_RESOURCE_HANDLE_T src
* const VC_RECT_T *src_rect
* DISPMANX_FLAGS_T flags
* uint8_t opacity
* DISPMANX_RESOURCE_HANDLE_T mask
* VC_IMAGE_TRANSFORM_T transform
*
* Description:
*
* Returns: VCHI error code
*
***********************************************************/
VCHPRE_ DISPMANX_ELEMENT_HANDLE_T VCHPOST_ vc_dispmanx_element_add ( DISPMANX_UPDATE_HANDLE_T update,
DISPMANX_DISPLAY_HANDLE_T display,
int32_t layer,
const VC_RECT_T *dest_rect,
DISPMANX_RESOURCE_HANDLE_T src,
const VC_RECT_T *src_rect,
DISPMANX_PROTECTION_T protection,
VC_DISPMANX_ALPHA_T *alpha,
DISPMANX_CLAMP_T *clamp,
DISPMANX_TRANSFORM_T transform ) {
int32_t element_param[] = {
(int32_t) VC_HTOV32(update),
(int32_t) VC_HTOV32(display),
(int32_t) VC_HTOV32(layer),
(int32_t) VC_HTOV32(dest_rect->x),
(int32_t) VC_HTOV32(dest_rect->y),
(int32_t) VC_HTOV32(dest_rect->width),
(int32_t) VC_HTOV32(dest_rect->height),
(int32_t) VC_HTOV32(src),
(int32_t) VC_HTOV32(src_rect->x),
(int32_t) VC_HTOV32(src_rect->y),
(int32_t) VC_HTOV32(src_rect->width),
(int32_t) VC_HTOV32(src_rect->height),
(int32_t) VC_HTOV32(protection),
alpha ? (int32_t) VC_HTOV32(alpha->flags) : 0,
alpha ? (int32_t) VC_HTOV32(alpha->opacity) : 0,
alpha ? (int32_t) VC_HTOV32(alpha->mask) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->mode) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_mask) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_value.yuv.yy_upper) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_value.yuv.yy_lower) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_value.yuv.cr_upper) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_value.yuv.cr_lower) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_value.yuv.cb_upper) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->key_value.yuv.cb_lower) : 0,
clamp ? (int32_t) VC_HTOV32(clamp->replace_value) : 0,
(int32_t) VC_HTOV32(transform)
};
uint32_t handle = dispmanx_get_handle(EDispmanElementAdd,
element_param, sizeof(element_param));
return (DISPMANX_ELEMENT_HANDLE_T) handle;
}
/***********************************************************
* Name: vc_cec_set_vendor_id
*
* Arguments:
* 24-bit IEEE vendor id
*
* Description
* Set the response to <Give Device Vendor ID>
*
* Returns: if the command is successful (zero) or not (non-zero)
***********************************************************/
VCHPRE_ int VCHPOST_ vc_cec_set_vendor_id( uint32_t id ) {
uint32_t vendor_id = VC_HTOV32(id);
return cecservice_send_command( VC_CEC_SET_VENDOR_ID, &vendor_id, sizeof(vendor_id), 0);
}
/***********************************************************
* Name: vc_dispmanx_display_set_destination
*
* Arguments:
* DISPMANX_DISPLAY_HANDLE_T display
* DISPMANX_RESOURCE_HANDLE_T dest
*
* Description:
*
* Returns:
*
***********************************************************/
VCHPRE_ int VCHPOST_ vc_dispmanx_display_set_destination( DISPMANX_DISPLAY_HANDLE_T display, DISPMANX_RESOURCE_HANDLE_T dest ) {
uint32_t display_param[] = {(uint32_t)VC_HTOV32(display), (uint32_t)VC_HTOV32(dest)};
int32_t success = dispmanx_send_command( EDispmanDisplaySetDestination | DISPMANX_NO_REPLY_MASK,
display_param, sizeof(display_param));
return (int) success;
}
