自学教程：C++ vc_dispmanx_element_add函数代码示例

static void dispmanx_surface_setup(void *data, int width, int height, int pitch, float aspect,   struct dispmanx_surface *surface){   struct dispmanx_video *_dispvars = data;   int i, dst_width, dst_height, dst_xpos, dst_ypos;   /* Allocate memory for all the pages in each surface    * and initialize variables inside each page's struct. */   surface->pages = calloc(surface->numpages, sizeof(struct dispmanx_page));   for (i = 0; i < surface->numpages; i++) {      surface->pages[i].used = false;         surface->pages[i].dispvars = _dispvars;         surface->pages[i].page_used_mutex = slock_new();    }   /* Internal frame dimensions. Pitch is total pitch including info     * between scanlines */   surface->width = width;   surface->height = height;   surface->pitch = pitch;   surface->aspect = aspect;      /* The "visible" width obtained from the core pitch. We blit based on     * the "visible" width, for cores with things between scanlines. */   int visible_width = pitch / surface->bpp;    dst_width  = _dispvars->dispmanx_height * aspect;	   dst_height = _dispvars->dispmanx_height;      /* If we obtain a scaled image width that is bigger than the physical screen width,   * then we keep the physical screen width as our maximun width. */   if (dst_width > _dispvars->dispmanx_width)       dst_width = _dispvars->dispmanx_width;      dst_xpos = (_dispvars->dispmanx_width - dst_width) / 2;   dst_ypos = (_dispvars->dispmanx_height - dst_height) / 2;   /* We configure the rects now. */   vc_dispmanx_rect_set(&surface->dst_rect, dst_xpos, dst_ypos, dst_width, dst_height);   vc_dispmanx_rect_set(&surface->bmp_rect, 0, 0, width, height);	   vc_dispmanx_rect_set(&surface->src_rect, 0, 0, width << 16, height << 16);	   for (i = 0; i < surface->numpages; i++) {      surface->pages[i].resource =          vc_dispmanx_resource_create(surface->pixformat, 	 visible_width, height, &(_dispvars->vc_image_ptr));   }   /* Add element. */   _dispvars->update = vc_dispmanx_update_start(0);   surface->element = vc_dispmanx_element_add(      _dispvars->update,_dispvars->display, surface->layer,       &surface->dst_rect, surface->pages[0].resource,       &surface->src_rect, DISPMANX_PROTECTION_NONE,      &surface->alpha, 0, (DISPMANX_TRANSFORM_T)0);   vc_dispmanx_update_submit_sync(_dispvars->update);		   surface->setup = true;}

static EGLNativeWindowType createDispmanxLayer(const QPoint &pos, const QSize &size, int z, DISPMANX_FLAGS_ALPHA_T flags){    VC_RECT_T dst_rect;    dst_rect.x = pos.x();    dst_rect.y = pos.y();    dst_rect.width = size.width();    dst_rect.height = size.height();    VC_RECT_T src_rect;    src_rect.x = 0;    src_rect.y = 0;    src_rect.width = size.width() << 16;    src_rect.height = size.height() << 16;    DISPMANX_UPDATE_HANDLE_T dispman_update = vc_dispmanx_update_start(0);    VC_DISPMANX_ALPHA_T alpha;    alpha.flags = flags;    alpha.opacity = 0xFF;    alpha.mask = 0;    DISPMANX_ELEMENT_HANDLE_T dispman_element = vc_dispmanx_element_add(            dispman_update, dispman_display, z, &dst_rect, 0, &src_rect,            DISPMANX_PROTECTION_NONE, &alpha, (DISPMANX_CLAMP_T *)NULL, (DISPMANX_TRANSFORM_T)0);    vc_dispmanx_update_submit_sync(dispman_update);    EGL_DISPMANX_WINDOW_T *eglWindow = new EGL_DISPMANX_WINDOW_T;    eglWindow->element = dispman_element;    eglWindow->width = size.width();    eglWindow->height = size.height();    return eglWindow;}

static void DISPMANX_BlankBackground(void){  //MAC: Funcion que simplemente pone un element nuevo cuyo resource es de un solo pixel de color negro,  //se escala a pantalla completa y listo.    // we create a 1x1 black pixel image that is added to display just behind video  VC_IMAGE_TYPE_T type = VC_IMAGE_RGB565;  uint32_t vc_image_ptr;  uint16_t image = 0x0000; // black  VC_RECT_T dst_rect, src_rect;  dispvars->b_resource = vc_dispmanx_resource_create( type, 1 /*width*/, 1 /*height*/, &vc_image_ptr );  vc_dispmanx_rect_set( &dst_rect, 0, 0, 1, 1);  vc_dispmanx_resource_write_data( dispvars->b_resource, type, sizeof(image), &image, &dst_rect );  vc_dispmanx_rect_set( &src_rect, 0, 0, 1<<16, 1<<16);  vc_dispmanx_rect_set( &dst_rect, 0, 0, 0, 0);  dispvars->b_update = vc_dispmanx_update_start(0);  dispvars->b_element = vc_dispmanx_element_add(dispvars->b_update, dispvars->display, -1 /*layer*/, &dst_rect, 	dispvars->b_resource, &src_rect, DISPMANX_PROTECTION_NONE, NULL, NULL, (DISPMANX_TRANSFORM_T)0 );    vc_dispmanx_update_submit_sync( dispvars->b_update );}

ViewBackend::Cursor::Cursor(WPE::LibinputServer::Client& targetClient, DISPMANX_DISPLAY_HANDLE_T displayHandle, uint32_t displayWidth, uint32_t displayHeight)    : targetClient(targetClient)    , position({ 0, 0 })    , displaySize({ displayWidth, displayHeight }){    static VC_DISPMANX_ALPHA_T alpha = {        static_cast<DISPMANX_FLAGS_ALPHA_T>(DISPMANX_FLAGS_ALPHA_FROM_SOURCE),        255, 0    };    DISPMANX_UPDATE_HANDLE_T updateHandle = vc_dispmanx_update_start(0);    uint32_t imagePtr;    VC_RECT_T rect;    vc_dispmanx_rect_set(&rect, 0, 0, CursorData::width, CursorData::height);    DISPMANX_RESOURCE_HANDLE_T pointerResource = vc_dispmanx_resource_create(VC_IMAGE_RGBA32, CursorData::width, CursorData::height, &imagePtr);    vc_dispmanx_resource_write_data(pointerResource, VC_IMAGE_RGBA32, CursorData::width * 4, CursorData::data, &rect);    VC_RECT_T srcRect, destRect;    vc_dispmanx_rect_set(&srcRect, 0, 0, CursorData::width << 16, CursorData::height << 16);    vc_dispmanx_rect_set(&destRect, position.first, position.second, cursorWidth, cursorHeight);    cursorHandle = vc_dispmanx_element_add(updateHandle, displayHandle, 10,        &destRect, pointerResource, &srcRect, DISPMANX_PROTECTION_NONE, &alpha,        nullptr, DISPMANX_NO_ROTATE);    vc_dispmanx_resource_delete(pointerResource);    vc_dispmanx_update_submit_sync(updateHandle);}

static void frontend_init(void){  uint32_t display_width=0, display_height=0;  VC_RECT_T dst_rect;  VC_RECT_T src_rect;  bcm_host_init();  //initialise dispmanx display and resources  fe_screen=(unsigned short *) calloc(1, 640*480*2);  graphics_get_display_size(0 /* LCD */, &display_width, &display_height);  fe_display = vc_dispmanx_display_open( 0 );  //Create two surfaces for flipping between  //Make sure bitmap type matches the source for better performance  uint32_t crap;  fe_resource = vc_dispmanx_resource_create(VC_IMAGE_RGB565, 640, 480, &crap);  vc_dispmanx_rect_set( &dst_rect, 0, 0, display_width, display_height);  vc_dispmanx_rect_set( &src_rect, 0, 0, 640 << 16, 480 << 16);  //Make sure mame and background overlay the menu program  fe_update = vc_dispmanx_update_start( 0 );  // create the 'window' element - based on the first buffer resource (resource0)  fe_element = vc_dispmanx_element_add(  fe_update,      fe_display, 1, &dst_rect, fe_resource, &src_rect,      DISPMANX_PROTECTION_NONE, 0, 0, (DISPMANX_TRANSFORM_T) 0 );  vc_dispmanx_update_submit_sync( fe_update );}

booladdElementBackgroundLayer(    BACKGROUND_LAYER_T *bg,    DISPMANX_DISPLAY_HANDLE_T display,    DISPMANX_UPDATE_HANDLE_T update){    VC_DISPMANX_ALPHA_T alpha =    {        DISPMANX_FLAGS_ALPHA_FROM_SOURCE,         255,        0    };    //---------------------------------------------------------------------    VC_RECT_T src_rect;    vc_dispmanx_rect_set(&src_rect, 0, 0, 1, 1);    VC_RECT_T dst_rect;    vc_dispmanx_rect_set(&dst_rect, 0, 0, 0, 0);    bg->element =        vc_dispmanx_element_add(update,                                display,                                bg->layer,                                &dst_rect,                                bg->resource,                                &src_rect,                                DISPMANX_PROTECTION_NONE,                                &alpha,                                NULL,                                DISPMANX_NO_ROTATE);    return bg->element;}

voidaddElementWorms(    WORMS_T *worms,    DISPMANX_DISPLAY_HANDLE_T display,    DISPMANX_UPDATE_HANDLE_T update){    VC_DISPMANX_ALPHA_T alpha = { DISPMANX_FLAGS_ALPHA_FROM_SOURCE, 0, 0 };    VC_RECT_T src_rect;    vc_dispmanx_rect_set(&src_rect,                         0,                         0,                         worms->image.width << 16,                         worms->image.height << 16);    VC_RECT_T dst_rect;    vc_dispmanx_rect_set(&dst_rect,                         0,                         0,                         worms->image.width,                         worms->image.height);    worms->element =        vc_dispmanx_element_add(update,                                display,                                2000,                                &dst_rect,                                worms->frontResource,                                &src_rect,                                DISPMANX_PROTECTION_NONE,                                &alpha,                                NULL,                                DISPMANX_NO_ROTATE);    assert(worms->element != 0);}

uint32_t ViewBackendBCMRPi::createBCMElement(int32_t width, int32_t height){    static VC_DISPMANX_ALPHA_T alpha = {        static_cast<DISPMANX_FLAGS_ALPHA_T>(DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS),        255, 0    };    if (m_elementHandle != DISPMANX_NO_HANDLE)        return 0;    m_width = std::max(width, 0);    m_height = std::max(height, 0);    DISPMANX_UPDATE_HANDLE_T updateHandle = vc_dispmanx_update_start(0);    VC_RECT_T srcRect, destRect;    vc_dispmanx_rect_set(&srcRect, 0, 0, m_width << 16, m_height << 16);    vc_dispmanx_rect_set(&destRect, 0, 0, m_width, m_height);    m_elementHandle = vc_dispmanx_element_add(updateHandle, m_displayHandle, 0,        &destRect, DISPMANX_NO_HANDLE, &srcRect, DISPMANX_PROTECTION_NONE,        &alpha, nullptr, DISPMANX_NO_ROTATE);    vc_dispmanx_update_submit_sync(updateHandle);    return m_elementHandle;}

void vo_display_frame (RECT_VARS_T* vars, int width, int height,                      int chroma_width, int chroma_height,                      uint8_t * const * buf, int num){  int ret;  static VC_RECT_T       src_rect;  static VC_RECT_T       dst_rect;  static VC_DISPMANX_ALPHA_T alpha = { DISPMANX_FLAGS_ALPHA_FROM_SOURCE | DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS,                                 255, /*alpha 0->255*/			        0 };  int pitch = VO_ALIGN_UP(width,32);  assert((height % 16) == 0);  assert((chroma_height % 16) == 0);  if (num == 0) {    vars->resource = vc_dispmanx_resource_create( VC_IMAGE_YUV420,                                                  width,                                                  height,                                                  &vars->vc_image_ptr );    assert( vars->resource );    vars->update = vc_dispmanx_update_start( 10 );    assert( vars->update );    vc_dispmanx_rect_set( &src_rect, 0, 0, width << 16, height << 16 );    vc_dispmanx_rect_set( &dst_rect, 0, 0, vars->info.width, vars->info.height);    vars->element = vc_dispmanx_element_add(    vars->update,                                                vars->display,                                                2000,               // layer                                                &dst_rect,                                                vars->resource,                                                &src_rect,                                                DISPMANX_PROTECTION_NONE,                                                &alpha,                                                NULL,             // clamp                                                VC_IMAGE_ROT0 );    ret = vc_dispmanx_update_submit( vars->update, NULL, NULL);    vc_dispmanx_rect_set( &dst_rect, 0, 0, width, (3*height)/2);  }  ret = vc_dispmanx_resource_write_data(  vars->resource,                                          VC_IMAGE_YUV420,                                          pitch,                                          buf[0],                                          &dst_rect );  assert( ret == 0 );  vars->update = vc_dispmanx_update_start( 10 );  assert( vars->update );  //ret = vc_dispmanx_update_submit_sync( vars->update );    ret = vc_dispmanx_update_submit( vars->update, NULL, NULL);    assert( ret == 0 );}

qboolean RPI_Init (rendererstate_t *info, unsigned char *palette){	static EGL_DISPMANX_WINDOW_T nativewindow;	DISPMANX_ELEMENT_HANDLE_T dispman_element;	DISPMANX_DISPLAY_HANDLE_T dispman_display;	DISPMANX_UPDATE_HANDLE_T dispman_update;	VC_RECT_T dst_rect;	VC_RECT_T src_rect;	int rw, rh;	if (!EGL_LoadLibrary(info->subrenderer))	{		Con_Printf("couldn't load EGL library/n");		return false;	}	bcm_host_init();	graphics_get_display_size(0 /* LCD */, &rw, &rh);	Con_Printf("Screen size is actually %i*%i/n", rw, rh);	if (info->width < 64 || info->height < 64)	{		info->width = rw;		info->height = rh;	}	dispman_display = vc_dispmanx_display_open(0 /* LCD */);	dispman_update = vc_dispmanx_update_start(0);	dst_rect.x = 0;	dst_rect.y = 0;	dst_rect.width = info->width;	dst_rect.height = info->height;	  	src_rect.x = 0;	src_rect.y = 0;	src_rect.width = info->width << 16;	src_rect.height = info->height << 16; 	vid.pixelwidth = info->width;	vid.pixelheight = info->height;	 	dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display, 0/*layer*/, &dst_rect, 0/*src*/, &src_rect, DISPMANX_PROTECTION_NONE, 0 /*alpha*/, 0/*clamp*/, 0/*transform*/);  	nativewindow.element = dispman_element;	nativewindow.width = info->width;	nativewindow.height = info->height;	vc_dispmanx_update_submit_sync(dispman_update);	if (!EGL_Init(info, palette, &nativewindow, EGL_DEFAULT_DISPLAY))	{		Con_Printf("couldn't initialise EGL context/n");		return false;	}	GL_Init(&EGL_Proc);	return true;}

EGLNativeWindowTypeplatform_create_native_window (gint width, gint height, gpointer * window_data){  DISPMANX_ELEMENT_HANDLE_T dispman_element;  DISPMANX_DISPLAY_HANDLE_T dispman_display;  DISPMANX_UPDATE_HANDLE_T dispman_update;  RPIWindowData *data;  VC_RECT_T dst_rect;  VC_RECT_T src_rect;  GstVideoRectangle src, dst, res;  uint32_t dp_height;  uint32_t dp_width;  int ret;  ret = graphics_get_display_size (0, &dp_width, &dp_height);  if (ret < 0) {    GST_ERROR ("Can't open display");    return (EGLNativeWindowType) 0;  }  GST_DEBUG ("Got display size: %dx%d/n", dp_width, dp_height);  GST_DEBUG ("Source size: %dx%d/n", width, height);  /* Center width*height frame inside dp_width*dp_height */  src.w = width;  src.h = height;  src.x = src.y = 0;  dst.w = dp_width;  dst.h = dp_height;  dst.x = dst.y = 0;  gst_video_sink_center_rect (src, dst, &res, TRUE);  dst_rect.x = res.x;  dst_rect.y = res.y;  dst_rect.width = res.w;  dst_rect.height = res.h;  src_rect.x = 0;  src_rect.y = 0;  src_rect.width = width << 16;  src_rect.height = height << 16;  dispman_display = vc_dispmanx_display_open (0);  dispman_update = vc_dispmanx_update_start (0);  dispman_element = vc_dispmanx_element_add (dispman_update,      dispman_display, 0, &dst_rect, 0, &src_rect,      DISPMANX_PROTECTION_NONE, 0, 0, 0);  *window_data = data = g_slice_new0 (RPIWindowData);  data->d = dispman_display;  data->w.element = dispman_element;  data->w.width = width;  data->w.height = height;  vc_dispmanx_update_submit_sync (dispman_update);  return (EGLNativeWindowType) data;}

/////  WinCreate() - RaspberryPi, direct surface (No X, Xlib)////      This function initialized the display and window for EGL//EGLBoolean WinCreate(ESContext *esContext, const char *title) {   int32_t success = 0;   static EGL_DISPMANX_WINDOW_T nativewindow;   DISPMANX_ELEMENT_HANDLE_T dispman_element;   DISPMANX_DISPLAY_HANDLE_T dispman_display;   DISPMANX_UPDATE_HANDLE_T dispman_update;   VC_RECT_T dst_rect;   VC_RECT_T src_rect;      int display_width;   int display_height;   // create an EGL window surface, passing context width/height   success = graphics_get_display_size(0 /* LCD */, &display_width, &display_height);   if ( success < 0 )   {      return EGL_FALSE;   }      // You can hardcode the resolution here:   // <JJW> : But I don't want to hardcode resolution!   // display_width = 640;   // display_height = 480;   dst_rect.x = 0;   dst_rect.y = 0;   dst_rect.width = display_width;   dst_rect.height = display_height;         src_rect.x = 0;   src_rect.y = 0;   src_rect.width = display_width << 16;   src_rect.height = display_height << 16;      dispman_display = vc_dispmanx_display_open( 0 /* LCD */);   dispman_update = vc_dispmanx_update_start( 0 );            dispman_element = vc_dispmanx_element_add ( dispman_update, dispman_display,      0/*layer*/, &dst_rect, 0/*src*/,      &src_rect, DISPMANX_PROTECTION_NONE, 0 /*alpha*/, 0/*clamp*/, 0/*transform*/);         nativewindow.element = dispman_element;   nativewindow.width = display_width;   nativewindow.height = display_height;   vc_dispmanx_update_submit_sync( dispman_update );   //JJW : save window resolution of LCD moniter in esContext   esContext->width = display_width;   esContext->height = display_height;      esContext->hWnd = &nativewindow;	return EGL_TRUE;}

/** Creates a native window for the GL surface using dispmanx * @param raspitex_state A pointer to the GL preview state. * @return Zero if successful, otherwise, -1 is returned. */int raspitexutil_create_native_window(RASPITEX_STATE *raspitex_state){   VC_DISPMANX_ALPHA_T alpha = {DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS, 255, 0};   VC_RECT_T src_rect = {0};   VC_RECT_T dest_rect = {0};   uint32_t disp_num = 0; // Primary   uint32_t layer_num = 0;   DISPMANX_ELEMENT_HANDLE_T elem;   DISPMANX_UPDATE_HANDLE_T update;   alpha.opacity = raspitex_state->opacity;   dest_rect.x = raspitex_state->x;   dest_rect.y = raspitex_state->y;   dest_rect.width = raspitex_state->width;   dest_rect.height = raspitex_state->height;   vcos_log_trace("%s: %d,%d,%d,%d %d,%d,0x%x,0x%x", VCOS_FUNCTION,         src_rect.x, src_rect.y, src_rect.width, src_rect.height,         dest_rect.x, dest_rect.y, dest_rect.width, dest_rect.height);   src_rect.width = dest_rect.width << 16;   src_rect.height = dest_rect.height << 16;   raspitex_state->disp = vc_dispmanx_display_open(disp_num);   if (raspitex_state->disp == DISPMANX_NO_HANDLE)   {      vcos_log_error("Failed to open display handle");      goto error;   }   update = vc_dispmanx_update_start(0);   if (update == DISPMANX_NO_HANDLE)   {      vcos_log_error("Failed to open update handle");      goto error;   }   elem = vc_dispmanx_element_add(update, raspitex_state->disp, layer_num,         &dest_rect, 0, &src_rect, DISPMANX_PROTECTION_NONE, &alpha, NULL,         DISPMANX_NO_ROTATE);   if (elem == DISPMANX_NO_HANDLE)   {      vcos_log_error("Failed to create element handle");      goto error;   }   raspitex_state->win.element = elem;   raspitex_state->win.width = raspitex_state->width;   raspitex_state->win.height = raspitex_state->height;   vc_dispmanx_update_submit_sync(update);   raspitex_state->native_window = (EGLNativeWindowType*) &raspitex_state->win;   return 0;error:   return -1;}

boolNativeStateDispmanx::create_window(WindowProperties const& properties){    int dispmanx_output = 0; /* LCD */    if (!properties.fullscreen) {        Log::error("Error: Dispmanx only supports full screen rendering./n");	return false;    }    unsigned screen_width, screen_height;    if (graphics_get_display_size(dispmanx_output,				  &screen_width, &screen_height) < 0) {        Log::error("Error: Couldn't get screen width/height./n");	return false;    }    properties_.fullscreen = properties.fullscreen;    properties_.visual_id = properties.visual_id;    properties_.width = screen_width;    properties_.height = screen_height;    dispmanx_display = vc_dispmanx_display_open(dispmanx_output);    VC_RECT_T dst_rect;    VC_RECT_T src_rect;    dst_rect.x = 0;    dst_rect.y = 0;    dst_rect.width = screen_width;    dst_rect.height = screen_height;    src_rect.x = 0;    src_rect.y = 0;    src_rect.width = screen_width << 16;    src_rect.height = screen_height << 16;    dispmanx_update = vc_dispmanx_update_start(0);    dispmanx_element = vc_dispmanx_element_add(dispmanx_update,					       dispmanx_display,					       0 /*layer*/,					       &dst_rect,					       0 /*src*/,					       &src_rect,					       DISPMANX_PROTECTION_NONE,					       0 /*alpha*/,					       0 /*clamp*/,					       DISPMANX_NO_ROTATE);    egl_dispmanx_window.element = dispmanx_element;    egl_dispmanx_window.width = dst_rect.width;    egl_dispmanx_window.height = dst_rect.height;    vc_dispmanx_update_submit_sync(dispmanx_update);    return true;}

BBEGLContext *createDisplayContext(){	EGLContext context;	EGLSurface surface;	static const EGLint contextAttribs[]={		EGL_CONTEXT_CLIENT_VERSION,2,		EGL_NONE};	context=eglCreateContext(display,config,EGL_NO_CONTEXT,contextAttribs);	assert(eglGetError()==EGL_SUCCESS);	unsigned int width,height;	graphics_get_display_size(0,&width,&height);	printf("display size is %dx%d/n",width,height);	VC_RECT_T dst={0};	dst.width=width;	dst.height=height;	VC_RECT_T src={0};	src.width=width<<16;	src.height=height<<16;	static EGL_DISPMANX_WINDOW_T nativewindow;	DISPMANX_ELEMENT_HANDLE_T dispman_element;	DISPMANX_DISPLAY_HANDLE_T dispman_display;	DISPMANX_UPDATE_HANDLE_T dispman_update;	dispman_display = vc_dispmanx_display_open( 0 /* LCD */);	dispman_update = vc_dispmanx_update_start( 0 );	dispman_element = vc_dispmanx_element_add ( dispman_update,                                             dispman_display, 0/*layer*/, &dst, 0/*src*/,                                             &src, DISPMANX_PROTECTION_NONE, 0 /*alpha*/,                                             0/*clamp*/, DISPMANX_NO_ROTATE/*transform*/);	nativewindow.element = dispman_element; 	nativewindow.width = width;	nativewindow.height = height;	vc_dispmanx_update_submit_sync( dispman_update );	surface=eglCreateWindowSurface(display,config,&nativewindow,NULL);	eglMakeCurrent(display,surface,surface,context);	DeviceContext.width=width;	DeviceContext.height=height;	DeviceContext.depth=32;	DeviceContext.hertz=60;	DeviceContext.context=context;	DeviceContext.surface=surface;	return &DeviceContext;}

void gp2x_frontend_init(void){	int ret;        	uint32_t display_width, display_height;    	VC_RECT_T dst_rect;	VC_RECT_T src_rect;    	surface_width = 640;	surface_height = 480;    	gp2x_screen8=0;	gp2x_screen15=(unsigned short *) calloc(1, 640*480*2);		graphics_get_display_size(0 /* LCD */, &display_width, &display_height);    	dispman_display = vc_dispmanx_display_open( 0 );	assert( dispman_display != 0 );        	// Add border around bitmap for TV	display_width -= options.display_border * 2;	display_height -= options.display_border * 2;    	//Create two surfaces for flipping between	//Make sure bitmap type matches the source for better performance	uint32_t crap;	resource0 = vc_dispmanx_resource_create(VC_IMAGE_RGB565, 640, 480, &crap);	resource1 = vc_dispmanx_resource_create(VC_IMAGE_RGB565, 640, 480, &crap);    	vc_dispmanx_rect_set( &dst_rect, options.display_border, options.display_border,                         display_width, display_height);	vc_dispmanx_rect_set( &src_rect, 0, 0, 640 << 16, 480 << 16);    	//Make sure mame and background overlay the menu program	dispman_update = vc_dispmanx_update_start( 0 );    	// create the 'window' element - based on the first buffer resource (resource0)	dispman_element = vc_dispmanx_element_add(  dispman_update,                                              dispman_display,                                              1,                                              &dst_rect,                                              resource0,                                              &src_rect,                                              DISPMANX_PROTECTION_NONE,                                              0,                                              0,                                              (DISPMANX_TRANSFORM_T) 0 );    	ret = vc_dispmanx_update_submit_sync( dispman_update );    	// setup swapping of double buffers	cur_res = resource1;	prev_res = resource0;    }

static void show_cursor(ALLEGRO_DISPLAY_RASPBERRYPI *d){    if (d->cursor_data == NULL || cursor_added) {        return;    }    int width = d->cursor_width;    int height = d->cursor_height;    uint32_t unused;    cursor_resource = vc_dispmanx_resource_create(VC_IMAGE_ARGB8888, width, height, &unused);    VC_RECT_T r;    r.x = 0;    r.y = 0;    r.width = width;    r.height = height;    int dpitch = pot(sizeof(uint32_t) * width);    dispman_update = vc_dispmanx_update_start(0);    vc_dispmanx_resource_write_data(cursor_resource, VC_IMAGE_ARGB8888, dpitch, d->cursor_data, &r);    vc_dispmanx_update_submit_sync(dispman_update);    ALLEGRO_MOUSE_STATE state;    al_get_mouse_state(&state);    dst_rect.x = state.x+d->cursor_offset_x;    dst_rect.y = state.y+d->cursor_offset_y;    dst_rect.width = width;    dst_rect.height = height;    src_rect.x = 0;    src_rect.y = 0;    src_rect.width = width << 16;    src_rect.height = height << 16;    dispman_update = vc_dispmanx_update_start(0);    cursor_element = vc_dispmanx_element_add(                         dispman_update,                         dispman_display,                         0/*layer*/,                         &dst_rect,                         cursor_resource,                         &src_rect,                         DISPMANX_PROTECTION_NONE,                         0 /*alpha*/,                         0/*clamp*/,                         0/*transform*/                     );    vc_dispmanx_update_submit_sync(dispman_update);    cursor_added = true;}

JNIEXPORT jlong JNICALL Java_org_lwjgl_opengles_EGL_neglCreateWindowSurface(JNIEnv *env, jclass clazz, jlong dpy_ptr, jlong config_ptr, jlong win, jlong attrib_list) {    EGLDisplay dpy = (EGLDisplay)(intptr_t)dpy_ptr;    EGLConfig config = (EGLConfig)(intptr_t)config_ptr;    const EGLint *attrib_list_address = (EGLint *)(intptr_t)attrib_list;	//@@spsn	int32_t success = 0;	EGLBoolean result;	EGLint num_config;	EGLint screen_width;	EGLint screen_height;	static EGL_DISPMANX_WINDOW_T nativewindow;	DISPMANX_ELEMENT_HANDLE_T dispman_element;	DISPMANX_DISPLAY_HANDLE_T dispman_display;	DISPMANX_UPDATE_HANDLE_T dispman_update;	VC_RECT_T dst_rect;	VC_RECT_T src_rect;	bcm_host_init();	// create an EGL window surface	success = graphics_get_display_size(0 /* LCD */, &screen_width, &screen_height);	dst_rect.x = 0;	dst_rect.y = 0;	dst_rect.width = screen_width;	dst_rect.height = screen_height;      	src_rect.x = 0;	src_rect.y = 0;	src_rect.width = screen_width << 16;	src_rect.height = screen_height << 16;        	VC_DISPMANX_ALPHA_T alpha;	alpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS;	alpha.opacity = 255;	alpha.mask = 0;	dispman_display = vc_dispmanx_display_open( 0 /* LCD */);	dispman_update = vc_dispmanx_update_start( 0 );         	dispman_element = vc_dispmanx_element_add ( dispman_update, dispman_display,      0/*layer*/, &dst_rect, 0/*src*/,      &src_rect, DISPMANX_PROTECTION_NONE, &alpha/*alpha*/, 0/*clamp*/, 0/*transform*/);      	nativewindow.element = dispman_element;	nativewindow.width = screen_width;	nativewindow.height = screen_height;	vc_dispmanx_update_submit_sync( dispman_update );      //    return (intptr_t)eglCreateWindowSurface(dpy, config, (EGLNativeWindowType)(intptr_t)win, attrib_list_address);    return (intptr_t)eglCreateWindowSurface(dpy, config, (EGLNativeWindowType)(intptr_t)&nativewindow, attrib_list_address);}

static voidwindow_resize (GstGLWindowDispmanxEGL * window_egl, guint width, guint height){  GST_DEBUG ("resizing window from %ux%u to %ux%u",      window_egl->native.width, window_egl->native.height, width, height);  if (window_egl->display) {    VC_RECT_T dst_rect;    VC_RECT_T src_rect;    GstVideoRectangle src, dst, res;    DISPMANX_UPDATE_HANDLE_T dispman_update;    VC_DISPMANX_ALPHA_T alpha =        { DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS, 255, 0 };    /* Center width*height frame inside dp_width*dp_height */    src.w = width;    src.h = height;    src.x = src.y = 0;    dst.w = window_egl->dp_width;    dst.h = window_egl->dp_height;    dst.x = dst.y = 0;    gst_video_sink_center_rect (src, dst, &res, FALSE);    dst_rect.x = res.x;    dst_rect.y = res.y;    dst_rect.width = res.w;    dst_rect.height = res.h;    src_rect.x = 0;    src_rect.y = 0;    src_rect.width = width << 16;    src_rect.height = height << 16;    dispman_update = vc_dispmanx_update_start (0);    if (window_egl->native.element) {      vc_dispmanx_element_change_attributes (dispman_update,          window_egl->native.element, 0x00000110, 0, 0, &dst_rect, &src_rect, 0,          0);    } else {      window_egl->native.element = vc_dispmanx_element_add (dispman_update,          window_egl->display, 0, &dst_rect, 0, &src_rect,          DISPMANX_PROTECTION_NONE, &alpha, 0, 0);    }    vc_dispmanx_update_submit_sync (dispman_update);    if (GST_GL_WINDOW (window_egl)->resize)      GST_GL_WINDOW (window_egl)->          resize (GST_GL_WINDOW (window_egl)->resize_data, width, height);  }  window_egl->native.width = width;  window_egl->native.height = height;}

void EGLInitializeSubsystemWindow(int requested_width, int requested_height,int& width, int& height, void *&window) {    bcm_host_init();    int success = graphics_get_display_size(0 /* LCD */,        (uint32_t *)&width, (uint32_t *)&height);    assert(success >= 0);    static EGL_DISPMANX_WINDOW_T native_window;    DISPMANX_ELEMENT_HANDLE_T dispman_element;    DISPMANX_DISPLAY_HANDLE_T dispman_display;    DISPMANX_UPDATE_HANDLE_T dispman_update;    VC_RECT_T dst_rect;    VC_RECT_T src_rect;    dst_rect.x = 0;    dst_rect.y = 0;    dst_rect.width = width;    dst_rect.height = height;    src_rect.x = 0;    src_rect.y = 0;    src_rect.width = width << 16;    src_rect.height = height << 16;    dispman_display = vc_dispmanx_display_open(0 /* LCD */);    dispman_update = vc_dispmanx_update_start(0);    VC_DISPMANX_ALPHA_T alpha;    alpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS;    alpha.opacity = 0xFF;    alpha.mask = DISPMANX_NO_HANDLE;    dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display,        0/*layer*/, &dst_rect, 0/*src*/,        &src_rect, DISPMANX_PROTECTION_NONE, &alpha /*alpha*/, 0/*clamp*/,        (DISPMANX_TRANSFORM_T)0/*transform*/);//    nativewindow.element = dispman_element;//    nativewindow.width = width;//    nativewindow.height = height;    vc_dispmanx_update_submit_sync(dispman_update);    check();    LinuxFBInitializeUI(width, height);    native_window.element = dispman_element;    native_window.width = width;    native_window.height = height;    window = &native_window;}

int pf_re_native_init (EGLNativeDisplayType *display_out, 		   EGLNativeWindowType *window_out,		   int w, int h){bcm_host_init();   DISPMANX_ELEMENT_HANDLE_T dispman_element;   DISPMANX_DISPLAY_HANDLE_T dispman_display;   DISPMANX_UPDATE_HANDLE_T dispman_update;   VC_RECT_T dst_rect;   VC_RECT_T src_rect;int success;int screen_width = 800, screen_height = 600;#if 1   // create an EGL window surface   success = graphics_get_display_size(0 /* LCD */, &screen_width, &screen_height);   if ( success < 0 ) 		{	fprintf (stderr, "Cannot get display size/n");	exit (1);}#endif   dst_rect.x = 0;   dst_rect.y = 0;   dst_rect.width = screen_width;   dst_rect.height = screen_height;   src_rect.x = 0;   src_rect.y = 0;   src_rect.width = screen_width << 16;   src_rect.height = screen_height << 16;   dispman_display = vc_dispmanx_display_open( 0 /* LCD */);   dispman_update = vc_dispmanx_update_start( 0 );   dispman_element = vc_dispmanx_element_add ( dispman_update, dispman_display,      0/*layer*/, &dst_rect, 0/*src*/,      &src_rect, DISPMANX_PROTECTION_NONE, 0 /*alpha*/, 0/*clamp*/, 0/*transform*/);   nativewindow.element = dispman_element;   nativewindow.width = screen_width;   nativewindow.height = screen_height;   vc_dispmanx_update_submit_sync( dispman_update );  *display_out = EGL_DEFAULT_DISPLAY;  *window_out = &nativewindow;}

int main(void){   uint32_t width, height;   bcm_host_init();   int s;   static EGL_DISPMANX_WINDOW_T nativewindow;   DISPMANX_ELEMENT_HANDLE_T dispman_element;   DISPMANX_DISPLAY_HANDLE_T dispman_display;   DISPMANX_UPDATE_HANDLE_T dispman_update;   VC_RECT_T dst_rect;   VC_RECT_T src_rect;   s = graphics_get_display_size(0 /* LCD */, &width, &height);   assert( s >= 0 );   dst_rect.x = 0;   dst_rect.y = 0;   dst_rect.width = width;   dst_rect.height = height;         src_rect.x = 0;   src_rect.y = 0;   src_rect.width = width << 16;   src_rect.height = height << 16;           dispman_display = vc_dispmanx_display_open( 0 /* LCD */);   dispman_update = vc_dispmanx_update_start( 0 );            dispman_element = vc_dispmanx_element_add ( dispman_update, dispman_display,      1/*layer*/, &dst_rect, 0/*src*/,      &src_rect, DISPMANX_PROTECTION_NONE, 0 /*alpha*/, 0/*clamp*/, 0/*transform*/);         nativewindow.element = dispman_element;   nativewindow.width = width;   nativewindow.height = height;   vc_dispmanx_update_submit_sync( dispman_update );   init(&nativewindow);   while (1) {      render(width, height);      rotateN += 1.0f;   }   deinit();   return 0;}

static void LoadOpenGLESWindow(uint32_t width, uint32_t height){    bcm_host_init();        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);    eglInitialize(display, NULL, NULL);        static const EGLint attribute_list[] =	{	    EGL_RED_SIZE, 8,	    EGL_GREEN_SIZE, 8,	    EGL_BLUE_SIZE, 8,	    EGL_ALPHA_SIZE, 8,	    EGL_SURFACE_TYPE, EGL_WINDOW_BIT,	    EGL_NONE	};    EGLint num_config;    eglChooseConfig(display, attribute_list, &config, 1, &num_config);        eglBindAPI(EGL_OPENGL_ES_API);    static const EGLint context_attributes[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };    context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes);    dst_rect.x = 0;    dst_rect.y = 0;    dst_rect.width = width;    dst_rect.height = height;        src_rect.x = 0;    src_rect.y = 0;    src_rect.width = width << 16;    src_rect.height = height << 16;    dispman_display = vc_dispmanx_display_open( 0 /* LCD */);    dispman_update = vc_dispmanx_update_start( 0 );    dispman_element = vc_dispmanx_element_add(    	dispman_update, dispman_display,		0/*layer*/, &dst_rect, 0/*src*/,		&src_rect, DISPMANX_PROTECTION_NONE, 		0 /*alpha*/, 0/*clamp*/, 0/*transform*/);    nativewindow.element = dispman_element;    nativewindow.width = width;    nativewindow.height = height;    vc_dispmanx_update_submit_sync(dispman_update);    surface = eglCreateWindowSurface(display, config, &nativewindow, NULL);    eglMakeCurrent(display, surface, surface, context);}

JNIEXPORT jlong JNICALL Java_jogamp_newt_driver_bcm_vc_iv_WindowDriver_CreateWindow  (JNIEnv *env, jobject obj, jint width, jint height, jboolean opaque, jint alphaBits){   int32_t success = 0;   VC_RECT_T dst_rect;   VC_RECT_T src_rect;   dst_rect.x = 0;   dst_rect.y = 0;   dst_rect.width = width;   dst_rect.height = height;         src_rect.x = 0;   src_rect.y = 0;   src_rect.width = width << 16;   src_rect.height = height << 16;      VC_DISPMANX_ALPHA_T dispman_alpha;   memset(&dispman_alpha, 0x0, sizeof(VC_DISPMANX_ALPHA_T));   if( JNI_TRUE == opaque ) {       dispman_alpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS ;       dispman_alpha.opacity = 0xFF;       dispman_alpha.mask = 0;   } else {       dispman_alpha.flags = DISPMANX_FLAGS_ALPHA_FROM_SOURCE ;       dispman_alpha.opacity = 0xFF;       dispman_alpha.mask = 0xFF;   }   DISPMANX_DISPLAY_HANDLE_T dispman_display = vc_dispmanx_display_open( 0 /* LCD */);   DISPMANX_UPDATE_HANDLE_T dispman_update = vc_dispmanx_update_start( 0 );   DISPMANX_ELEMENT_HANDLE_T dispman_element = vc_dispmanx_element_add ( dispman_update, dispman_display,                                                                         0/*layer*/, &dst_rect, 0/*src*/,                                                                         &src_rect, DISPMANX_PROTECTION_NONE,                                                                          &dispman_alpha /*alpha */, 0/*clamp*/, 0/*transform*/);   EGL_DISPMANX_WINDOW_T * nativeWindowPtr = calloc(1, sizeof(EGL_DISPMANX_WINDOW_T));     nativeWindowPtr->element = dispman_element;   nativeWindowPtr->width = width;   nativeWindowPtr->height = height;   vc_dispmanx_update_submit_sync( dispman_update );   (*env)->CallVoidMethod(env, obj, visibleChangedID, JNI_FALSE, JNI_TRUE); // FIXME: or defer=true ?   return (jlong) (intptr_t) nativeWindowPtr;}

void dispmanxtest() {	DISPMANX_DISPLAY_HANDLE_T display;	int ret;	DISPMANX_MODEINFO_T displayinfo;	DISPMANX_RESOURCE_HANDLE_T res;	int width = 1024;	int height = 576;	uint32_t vc_image_ptr;	DISPMANX_UPDATE_HANDLE_T update;	VC_RECT_T dst_rect,src_rect;	DISPMANX_ELEMENT_HANDLE_T element;		bcm_host_init();	display = vc_dispmanx_display_open(0);	ret = vc_dispmanx_display_get_info( display, &displayinfo);	assert(ret==0);	printf("display is %dx%d/n",displayinfo.width,displayinfo.height);	res = vc_dispmanx_resource_create(VC_IMAGE_YUV420,width,height,&vc_image_ptr);	vc_image_ptr = vc_dispmanx_resource_get_image_handle(res);	printf("vc_image_ptr %x/n",vc_image_ptr);	assert(res);	update = vc_dispmanx_update_start(10);	assert(update);	vc_dispmanx_rect_set(&src_rect,0,0,width<<16,height<<16);	vc_dispmanx_rect_set(&dst_rect,0,(displayinfo.height - height)/2,width-32,height);	element = vc_dispmanx_element_add(update,display,2000,&dst_rect,res,&src_rect,DISPMANX_PROTECTION_NONE,NULL,NULL,DISPMANX_NO_ROTATE);	ret = vc_dispmanx_update_submit_sync(update);	assert(ret==0);	uint8_t *rawfb = (uint8_t*)mapmem(vc_image_ptr,0x1000);	for (int i=0; i<0x100; i++) {		printf("%02x ",rawfb[i]);	}	printf("/n");	unmapmem(rawfb,0x1000);	puts("sleeping");	sleep(10);	update = vc_dispmanx_update_start(10);	assert(update);	ret = vc_dispmanx_element_remove(update,element);	assert(ret==0);	ret = vc_dispmanx_update_submit_sync(update);	assert(ret==0);	ret = vc_dispmanx_resource_delete(res);	assert(ret==0);	ret = vc_dispmanx_display_close(display);	assert(ret==0);}

voidaddElementLife(    LIFE_T *life,    DISPMANX_MODEINFO_T *info,    DISPMANX_DISPLAY_HANDLE_T display,    DISPMANX_UPDATE_HANDLE_T update){    VC_DISPMANX_ALPHA_T alpha =    {        DISPMANX_FLAGS_ALPHA_FROM_SOURCE,         255, /*alpha 0->255*/        0    };    int32_t dst_size = life->height;    if (dst_size < info->height)    {        dst_size = info->height - (info->height % life->height);    }    //---------------------------------------------------------------------    vc_dispmanx_rect_set(&(life->srcRect),                         0,                         0,                         life->width << 16,                         life->height << 16);    vc_dispmanx_rect_set(&(life->dstRect),                         (info->width - dst_size) / 2,                         (info->height - dst_size) / 2,                         dst_size,                         dst_size);    life->element =        vc_dispmanx_element_add(update,                                display,                                1,                                &(life->dstRect),                                life->frontResource,                                &(life->srcRect),                                DISPMANX_PROTECTION_NONE,                                &alpha,                                NULL,                                DISPMANX_NO_ROTATE);    assert(life->element != 0);}

/*!*********************************************************************** @Function		OsGetNativeWindowType @Return		The 'NativeWindowType' for EGL @description	Called from InitAPI() to get the NativeWindowType*************************************************************************/void *PVRShellInit::OsGetNativeWindowType(){	unsigned int iWidth, iHeight;	if(graphics_get_display_size(0 /* LCD */, &iWidth, &iHeight) < 0)	{		m_pShell->PVRShellOutputDebug("ERROR: graphics_get_display_size() failed./n");		return 0;	}	m_pShell->PVRShellOutputDebug("Creating Pi display with size: %dx%d/n", iWidth, iHeight);	VC_RECT_T dst_rect;	VC_RECT_T src_rect;	DISPMANX_ELEMENT_HANDLE_T dispman_element;	DISPMANX_DISPLAY_HANDLE_T dispman_display;	DISPMANX_UPDATE_HANDLE_T dispman_update;	static EGL_DISPMANX_WINDOW_T nativeWindow;	dst_rect.x = 0;	dst_rect.y = 0;	dst_rect.width 	= iWidth;	dst_rect.height = iHeight;	src_rect.x = 0;	src_rect.y = 0;	src_rect.width 	= iWidth  << 16;	src_rect.height = iHeight << 16;	dispman_display = vc_dispmanx_display_open(0);	dispman_update  = vc_dispmanx_update_start(0);	dispman_element = vc_dispmanx_element_add(	dispman_update, 							dispman_display,							0, // layer							&dst_rect,							0, // src							&src_rect,							DISPMANX_PROTECTION_NONE,							0, // alpha							0, // clamp							DISPMANX_NO_ROTATE);	nativeWindow.element = dispman_element;	nativeWindow.width   = iWidth;	nativeWindow.height  = iHeight;	vc_dispmanx_update_submit_sync(dispman_update);	return (void*)&nativeWindow;}

void InitializeSurface(DisplaySurface *surface, unsigned int xOrigin, unsigned int yOrigin, unsigned int width, unsigned int height) {	//VC	VC_RECT_T destinationRect;	VC_RECT_T sourceRect;	if (xOrigin > displayWidth) xOrigin = 0;	if (yOrigin > displayHeight) yOrigin = 0;	if (width == 0 || xOrigin + width > displayWidth) width = displayWidth - xOrigin;	if (height == 0 || yOrigin + height > displayHeight) height = displayHeight - yOrigin;	surface->xOrigin = xOrigin;	surface->yOrigin = yOrigin;	surface->width = width;	surface->height = height;	// create an EGL window surface	destinationRect.x = xOrigin;	destinationRect.y = displayHeight - yOrigin - height;	destinationRect.width = width;	destinationRect.height = height;	sourceRect.x = 0;	sourceRect.y = 0;	sourceRect.width = width << 16;	sourceRect.height = height << 16;	dispmanDisplay = vc_dispmanx_display_open( 0 /* LCD */);	dispmanUpdate = vc_dispmanx_update_start( 0 );	surface->dispmanWindow.element = vc_dispmanx_element_add (dispmanUpdate, dispmanDisplay, 0/*layer*/, &destinationRect, 0/*src*/, &sourceRect, DISPMANX_PROTECTION_NONE, 0 /*alpha*/, 0/*clamp*/, 0/*transform*/);	surface->dispmanWindow.width = width;	surface->dispmanWindow.height = height;	vc_dispmanx_update_submit_sync(dispmanUpdate);	// create the surfrace	surface->eglSurface = eglCreateWindowSurface(eglDisplay, eglConfig, &surface->dispmanWindow, NULL );	// connect the context to the surface	eglMakeCurrent(eglDisplay, surface->eglSurface, surface->eglSurface, eglContext);	// JDO: preserve buffer https://www.khronos.org/registry/egl/sdk/docs/man/html/eglSwapBuffers.xhtml	// Slower eglSwapBuffers but allows for partial screen update	eglSurfaceAttrib(eglDisplay, surface->eglSurface, EGL_SWAP_BEHAVIOR, EGL_BUFFER_PRESERVED);}

voidaddElementLife(    LIFE_T *life,    int32_t xOffset,    int32_t yOffset,    int32_t dstSize,    DISPMANX_DISPLAY_HANDLE_T display,    DISPMANX_UPDATE_HANDLE_T update){    VC_DISPMANX_ALPHA_T alpha =    {        DISPMANX_FLAGS_ALPHA_FROM_SOURCE,         255, /*alpha 0->255*/        0    };    //---------------------------------------------------------------------    vc_dispmanx_rect_set(&(life->srcRect),                         0,                         0,                         life->width << 16,                         life->height << 16);    vc_dispmanx_rect_set(&(life->dstRect),                         xOffset,                         yOffset,                         dstSize,                         dstSize);    life->element =        vc_dispmanx_element_add(update,                                display,                                1,                                &(life->dstRect),                                life->frontResource,                                &(life->srcRect),                                DISPMANX_PROTECTION_NONE,                                &alpha,                                NULL,                                DISPMANX_NO_ROTATE);    assert(life->element != 0);}

void SubtitleRenderer::initialize_window(int display, int layer,                                         unsigned int x,                                         unsigned int y,                                         unsigned int width,                                         unsigned int height) {  VC_RECT_T dst_rect;  dst_rect.x = x;  dst_rect.y = y;  dst_rect.width = width;  dst_rect.height = height;  VC_RECT_T src_rect;  src_rect.x = 0;  src_rect.y = 0;  src_rect.width = dst_rect.width << 16;  src_rect.height = dst_rect.height << 16;          dispman_display_ = vc_dispmanx_display_open(display);  ENFORCE(dispman_display_);  {    auto dispman_update = vc_dispmanx_update_start(0);    ENFORCE(dispman_update);    SCOPE_EXIT {      ENFORCE(!vc_dispmanx_update_submit_sync(dispman_update));    };    dispman_element_ =        vc_dispmanx_element_add(dispman_update,                                dispman_display_,                                layer,                                &dst_rect,                                0 /*src*/,                                &src_rect,                                DISPMANX_PROTECTION_NONE,                                0 /*alpha*/,                                0 /*clamp*/,                                (DISPMANX_TRANSFORM_T) 0 /*transform*/);    ENFORCE(dispman_element_);  }}