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 ); }
void ViewBackend::commitBuffer(uint32_t handle, uint32_t width, uint32_t height) { if (handle != elementHandle || width != this->width || height != this->height) return; DISPMANX_UPDATE_HANDLE_T updateHandle = vc_dispmanx_update_start(0); VC_RECT_T srcRect, destRect; vc_dispmanx_rect_set(&srcRect, 0, 0, width << 16, height << 16); vc_dispmanx_rect_set(&destRect, 0, 0, width, height); vc_dispmanx_element_change_attributes(updateHandle, elementHandle, 1 << 3 | 1 << 2, 0, 0, &destRect, &srcRect, 0, DISPMANX_NO_ROTATE); vc_dispmanx_update_submit(updateHandle, [](DISPMANX_UPDATE_HANDLE_T, void* data) { auto& backend = *static_cast<ViewBackend*>(data); struct timeval tv; gettimeofday(&tv, nullptr); uint64_t time = tv.tv_sec * 1000 + tv.tv_usec / 1000; ssize_t ret = write(backend.updateFd, &time, sizeof(time)); if (ret != sizeof(time)) fprintf(stderr, "ViewBackend: failed to write to the update eventfd\n"); }, this); }
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 ); }
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; }
bool addElementBackgroundLayer( 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; }
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 addElementWorms( 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); }
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); }
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 ); }
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; }
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); }
void addElementLife( 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); }
bool initBackgroundLayer( BACKGROUND_LAYER_T *bg, uint16_t colour, int32_t layer) { int result = 0; VC_IMAGE_TYPE_T type = VC_IMAGE_RGBA16; uint32_t vc_image_ptr; bg->resource = vc_dispmanx_resource_create(type, 1, 1, &vc_image_ptr); if(!bg->resource) return false; //--------------------------------------------------------------------- VC_RECT_T dst_rect; vc_dispmanx_rect_set(&dst_rect, 0, 0, 1, 1); bg->layer = layer; result = vc_dispmanx_resource_write_data(bg->resource, type, sizeof(colour), &colour, &dst_rect); if(result != DISPMANX_SUCCESS){ result = vc_dispmanx_resource_delete(bg->resource); return false; } return true; }
/* Warp the mouse to (x,y) */ static void RPI_WarpMouseGlobal(int x, int y) { RPI_CursorData *curdata; DISPMANX_UPDATE_HANDLE_T update; int ret; VC_RECT_T dst_rect; SDL_Mouse *mouse = SDL_GetMouse(); if (mouse != NULL && mouse->cur_cursor != NULL && mouse->cur_cursor->driverdata != NULL) { curdata = (RPI_CursorData *) mouse->cur_cursor->driverdata; if (curdata->element != DISPMANX_NO_HANDLE) { update = vc_dispmanx_update_start( 10 ); SDL_assert( update ); vc_dispmanx_rect_set( &dst_rect, x, y, curdata->w, curdata->h); ret = vc_dispmanx_element_change_attributes( update, curdata->element, ELEMENT_CHANGE_DEST_RECT, 0, 0, &dst_rect, NULL, DISPMANX_NO_HANDLE, DISPMANX_NO_ROTATE); SDL_assert( ret == DISPMANX_SUCCESS ); /* Submit asynchronously, otherwise the peformance suffers a lot */ ret = vc_dispmanx_update_submit( update, 0, NULL ); SDL_assert( ret == DISPMANX_SUCCESS ); } } }
int Initialize() { fbfd = 0; fbp = 0; setlogmask(LOG_UPTO(LOG_DEBUG)); openlog("fbcp", LOG_NDELAY | LOG_PID, LOG_USER); bcm_host_init(); display = vc_dispmanx_display_open(0); if (!display) { syslog(LOG_ERR, "Unable to open primary display"); return -1; } ret = vc_dispmanx_display_get_info(display, &display_info); if (ret) { syslog(LOG_ERR, "Unable to get primary display information"); return -1; } syslog(LOG_INFO, "Primary display is %d x %d", display_info.width, display_info.height); fbfd = open("/dev/fb1", O_RDWR); if (!fbfd) { syslog(LOG_ERR, "Unable to open secondary display"); return -1; } if (ioctl(fbfd, FBIOGET_FSCREENINFO, &finfo)) { syslog(LOG_ERR, "Unable to get secondary display information"); return -1; } if (ioctl(fbfd, FBIOGET_VSCREENINFO, &vinfo)) { syslog(LOG_ERR, "Unable to get secondary display information"); return -1; } syslog(LOG_INFO, "Second display is %d x %d %dbps\n", vinfo.xres, vinfo.yres, vinfo.bits_per_pixel); screen_resource = vc_dispmanx_resource_create(VC_IMAGE_RGB565, vinfo.xres, vinfo.yres, &image_prt); if (!screen_resource) { syslog(LOG_ERR, "Unable to create screen buffer"); close(fbfd); vc_dispmanx_display_close(display); return -1; } fbp = (char*) mmap(0, finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fbfd, 0); if (fbp <= 0) { syslog(LOG_ERR, "Unable to create mamory mapping"); close(fbfd); ret = vc_dispmanx_resource_delete(screen_resource); vc_dispmanx_display_close(display); return -1; } vc_dispmanx_rect_set(&rect1, 0, 0, vinfo.xres, vinfo.yres); return 1; }
void ViewBackendBCMRPi::commitBCMBuffer(uint32_t elementHandle, uint32_t width, uint32_t height) { DISPMANX_UPDATE_HANDLE_T updateHandle = vc_dispmanx_update_start(0); m_width = width; m_height = height; 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); vc_dispmanx_element_change_attributes(updateHandle, m_elementHandle, 1 << 3 | 1 << 2, 0, 0, &destRect, &srcRect, 0, DISPMANX_NO_ROTATE); vc_dispmanx_update_submit_sync(updateHandle); if (m_client) m_client->frameComplete(); }
void addElementLife( 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); }
unsigned char *CRBP::CaptureDisplay(int width, int height, int *pstride, bool swap_red_blue) { DISPMANX_DISPLAY_HANDLE_T display; DISPMANX_RESOURCE_HANDLE_T resource; VC_RECT_T rect; unsigned char *image = NULL; uint32_t vc_image_ptr; int stride; display = vc_dispmanx_display_open( 0 /*screen*/ ); stride = ((width + 15) & ~15) * 4; image = new unsigned char [height * stride]; if (image) { resource = vc_dispmanx_resource_create( VC_IMAGE_RGBA32, width, height, &vc_image_ptr ); vc_dispmanx_snapshot(display, resource, (DISPMANX_TRANSFORM_T)0); vc_dispmanx_rect_set(&rect, 0, 0, width, height); vc_dispmanx_resource_read_data(resource, &rect, image, stride); vc_dispmanx_resource_delete( resource ); vc_dispmanx_display_close(display ); // we need to save in BGRA order so Swap RGBA -> BGRA if (swap_red_blue) { for (int y = 0; y < height; y++) { unsigned char *p = image + y * stride; for (int x = 0; x < width; x++, p+=4) { unsigned char t = p[0]; p[0] = p[2]; p[2] = t; } } } // assume we need to pack image if caller doesn't want stride if (!pstride && stride > width*4) { for (int y = 0; y < height; y++) { unsigned char *in = image + y * stride; unsigned char *out = image + y * width * 4; memmove(out, in, width*4); } } } if (pstride) *pstride = stride; return image; }
SliceMngr::SliceMngr(){ int result; uint16_t background = 0x000F; DISPMANX_UPDATE_HANDLE_T update; mState = 0; bcm_host_init(); mDisplay = vc_dispmanx_display_open(0); if(mDisplay == 0){ return; } result = vc_dispmanx_display_get_info(mDisplay, &mInfo); if(result != 0){ return; } initBackgroundLayer(&mBackground, background, 1); initImage(&(mImage.image), VC_IMAGE_RGBA32, mInfo.width, mInfo.height, false); createResourceImageLayer(&mImage, 0); vc_dispmanx_rect_set(&(mImage.srcRect), 0 << 16, 0 << 16, mImage.image.width << 16, mImage.image.height << 16); vc_dispmanx_rect_set(&(mImage.dstRect), (mInfo.width - mImage.image.width) / 2, (mInfo.height - mImage.image.height) / 2, mImage.image.width, mImage.image.height); update = vc_dispmanx_update_start(0); if(update == 0){ return; } addElementBackgroundLayer(&mBackground, mDisplay, update); addElementImageLayerCentered(&mImage, &mInfo, mDisplay, update); result = vc_dispmanx_update_submit_sync(update); if(result != 0){ return; } mState = 1; }
void save_snapshot(void) { DISPMANX_DISPLAY_HANDLE_T display; DISPMANX_MODEINFO_T info; DISPMANX_RESOURCE_HANDLE_T resource; VC_IMAGE_TYPE_T type = VC_IMAGE_RGB888; VC_IMAGE_TRANSFORM_T transform = 0; VC_RECT_T rect; void *image; uint32_t vc_image_ptr; int ret; uint32_t screen = 0; fprintf(stderr,"\nWriting snapshot...\n"); //fprintf(stderr,"Open display[%i]...\n", screen ); display = vc_dispmanx_display_open( screen ); ret = vc_dispmanx_display_get_info(display, &info); assert(ret == 0); //fprintf(stderr,"Display is %d x %d\n", info.width, info.height ); image = calloc( 1, info.width * 3 * info.height ); assert(image); resource = vc_dispmanx_resource_create(type, info.width, info.height,&vc_image_ptr); vc_dispmanx_snapshot(display, resource, transform); vc_dispmanx_rect_set(&rect, 0, 0, info.width, info.height); vc_dispmanx_resource_read_data(resource, &rect, image, info.width*3); char* home = getenv("HOME"); char filename[1024]; if (!home) home = "/tmp"; snprintf(filename,sizeof(filename),"%s/pidvbip-%u.ppm",home,(unsigned int)time(NULL)); FILE *fp = fopen(filename, "wb"); fprintf(fp, "P6\n%d %d\n255\n", info.width, info.height); fwrite(image, info.width*3*info.height, 1, fp); fclose(fp); fprintf(stderr,"\nSnapshot written to %s\n",filename); ret = vc_dispmanx_resource_delete( resource ); assert( ret == 0 ); ret = vc_dispmanx_display_close(display ); assert( ret == 0 ); free(image); }
EGLBoolean WinCreate(ScreenSettings *sc) { uint32_t success = 0; uint32_t width; uint32_t height; 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; VC_DISPMANX_ALPHA_T alpha = {DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS, 255, 0}; success = graphics_get_display_size(0, &width, &height); if (success < 0) return EGL_FALSE; if( width > _screen_max_size_ ) width = _screen_max_size_; if( height > _screen_max_size_ ) height = _screen_max_size_; sc->width = width; sc->height = height; vc_dispmanx_rect_set(&dst_rect, 0, 0, sc->width, sc->height); vc_dispmanx_rect_set(&src_rect, 0, 0, sc->width << 16, sc->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, &alpha, 0, ( DISPMANX_TRANSFORM_T )0); vc_dispmanx_update_submit_sync(dispman_update); nativewindow.element = dispman_element; nativewindow.width = width; nativewindow.height = height; sc->nativeWin = &nativewindow; return EGL_TRUE; }
static struct dmx_region_t *dmx_region_new(vout_display_t *vd, DISPMANX_UPDATE_HANDLE_T update, subpicture_region_t *region) { vout_display_sys_t *sys = vd->sys; video_format_t *fmt = ®ion->fmt; struct dmx_region_t *dmx_region = malloc(sizeof(struct dmx_region_t)); uint32_t image_handle; dmx_region->pos_x = region->i_x; dmx_region->pos_y = region->i_y; vc_dispmanx_rect_set(&dmx_region->bmp_rect, 0, 0, fmt->i_visible_width, fmt->i_visible_height); vc_dispmanx_rect_set(&dmx_region->src_rect, 0, 0, fmt->i_visible_width << 16, fmt->i_visible_height << 16); vc_dispmanx_rect_set(&dmx_region->dst_rect, region->i_x, region->i_y, fmt->i_visible_width, fmt->i_visible_height); dmx_region->resource = vc_dispmanx_resource_create(VC_IMAGE_RGBA32, dmx_region->bmp_rect.width | (region->p_picture->p[0].i_pitch << 16), dmx_region->bmp_rect.height | (dmx_region->bmp_rect.height << 16), &image_handle); vc_dispmanx_resource_write_data(dmx_region->resource, VC_IMAGE_RGBA32, region->p_picture->p[0].i_pitch, region->p_picture->p[0].p_pixels, &dmx_region->bmp_rect); dmx_region->alpha.flags = DISPMANX_FLAGS_ALPHA_FROM_SOURCE | DISPMANX_FLAGS_ALPHA_MIX; dmx_region->alpha.opacity = region->i_alpha; dmx_region->alpha.mask = DISPMANX_NO_HANDLE; dmx_region->element = vc_dispmanx_element_add(update, sys->dmx_handle, sys->layer + 1, &dmx_region->dst_rect, dmx_region->resource, &dmx_region->src_rect, DISPMANX_PROTECTION_NONE, &dmx_region->alpha, NULL, VC_IMAGE_ROT0); dmx_region->next = NULL; dmx_region->picture = region->p_picture; return dmx_region; }
int main(void) { DISPMANX_DISPLAY_HANDLE_T display; DISPMANX_MODEINFO_T info; DISPMANX_RESOURCE_HANDLE_T resource; VC_IMAGE_TYPE_T type = VC_IMAGE_RGB888; VC_IMAGE_TRANSFORM_T transform = 0; VC_RECT_T rect; void *image; uint32_t vc_image_ptr; int ret; uint32_t screen = 0; bcm_host_init(); printf("Open display[%i]...\n", screen ); display = vc_dispmanx_display_open( screen ); ret = vc_dispmanx_display_get_info(display, &info); assert(ret == 0); printf( "Display is %d x %d\n", info.width, info.height ); image = calloc( 1, info.width * 3 * info.height ); assert(image); resource = vc_dispmanx_resource_create( type, info.width, info.height, &vc_image_ptr ); vc_dispmanx_snapshot(display, resource, transform); vc_dispmanx_rect_set(&rect, 0, 0, info.width, info.height); vc_dispmanx_resource_read_data(resource, &rect, image, info.width*3); FILE *fp = fopen("out.ppm", "wb"); fprintf(fp, "P6\n%d %d\n255\n", info.width, info.height); fwrite(image, info.width*3*info.height, 1, fp); fclose(fp); ret = vc_dispmanx_resource_delete( resource ); assert( ret == 0 ); ret = vc_dispmanx_display_close(display ); assert( ret == 0 ); return 0; }
static void frontend_display(void) { VC_RECT_T dst_rect; vc_dispmanx_rect_set( &dst_rect, 0, 0, 640, 480 ); // begin display update fe_update = vc_dispmanx_update_start( 0 ); // blit image to the current resource vc_dispmanx_resource_write_data( fe_resource, VC_IMAGE_RGB565, 640*2, fe_screen, &dst_rect ); vc_dispmanx_update_submit_sync( fe_update ); }
void ViewBackend::initializeRenderingTarget() { static VC_DISPMANX_ALPHA_T alpha = { static_cast<DISPMANX_FLAGS_ALPHA_T>(DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS), 255, 0 }; if (elementHandle != DISPMANX_NO_HANDLE) return; DISPMANX_UPDATE_HANDLE_T updateHandle = vc_dispmanx_update_start(0); VC_RECT_T srcRect, destRect; vc_dispmanx_rect_set(&srcRect, 0, 0, width << 16, height << 16); vc_dispmanx_rect_set(&destRect, 0, 0, width, height); elementHandle = vc_dispmanx_element_add(updateHandle, displayHandle, 0, &destRect, DISPMANX_NO_HANDLE, &srcRect, DISPMANX_PROTECTION_NONE, &alpha, nullptr, DISPMANX_NO_ROTATE); vc_dispmanx_update_submit_sync(updateHandle); wpe_view_backend_dispatch_set_size(backend, width, height); }
void FE_DisplayScreen(void) { VC_RECT_T dst_rect; vc_dispmanx_rect_set( &dst_rect, 0, 0, surface_width, surface_height ); vc_dispmanx_resource_write_data( cur_res, VC_IMAGE_RGB565, surface_width*2, gp2x_screen15, &dst_rect ); dispman_update = vc_dispmanx_update_start( 0 ); vc_dispmanx_element_change_source( dispman_update, dispman_element, cur_res ); vc_dispmanx_update_submit( dispman_update, 0, 0 ); // swap current resource tmp_res = cur_res; cur_res = prev_res; prev_res = tmp_res; }
void ViewBackend::Cursor::handlePointerEvent(struct wpe_input_pointer_event* event) { targetClient.handlePointerEvent(event); DISPMANX_UPDATE_HANDLE_T updateHandle = vc_dispmanx_update_start(0); VC_RECT_T destRect; vc_dispmanx_rect_set(&destRect, event->x, event->y, std::min<uint32_t>(cursorWidth, std::max<uint32_t>(0, displaySize.first - event->x)), std::min<uint32_t>(cursorHeight, std::max<uint32_t>(0, displaySize.second - event->y))); vc_dispmanx_element_change_attributes(updateHandle, cursorHandle, 1 << 2, 0, 0, &destRect, nullptr, DISPMANX_NO_HANDLE, DISPMANX_NO_ROTATE); vc_dispmanx_update_submit_sync(updateHandle); }
/* Create a cursor from a surface */ static SDL_Cursor * RPI_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y) { RPI_CursorData *curdata; SDL_Cursor *cursor; int ret; VC_RECT_T dst_rect; Uint32 dummy; SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888); SDL_assert(surface->pitch == surface->w * 4); cursor = (SDL_Cursor *) SDL_calloc(1, sizeof(*cursor)); if (cursor == NULL) { SDL_OutOfMemory(); return NULL; } curdata = (RPI_CursorData *) SDL_calloc(1, sizeof(*curdata)); if (curdata == NULL) { SDL_OutOfMemory(); SDL_free(cursor); return NULL; } curdata->hot_x = hot_x; curdata->hot_y = hot_y; curdata->w = surface->w; curdata->h = surface->h; /* This usage is inspired by Wayland/Weston RPI code, how they figured this out is anyone's guess */ curdata->resource = vc_dispmanx_resource_create( VC_IMAGE_ARGB8888, surface->w | (surface->pitch << 16), surface->h | (surface->h << 16), &dummy ); SDL_assert(curdata->resource); vc_dispmanx_rect_set( &dst_rect, 0, 0, curdata->w, curdata->h); /* A note from Weston: * vc_dispmanx_resource_write_data() ignores ifmt, * rect.x, rect.width, and uses stride only for computing * the size of the transfer as rect.height * stride. * Therefore we can only write rows starting at x=0. */ ret = vc_dispmanx_resource_write_data( curdata->resource, VC_IMAGE_ARGB8888, surface->pitch, surface->pixels, &dst_rect ); SDL_assert ( ret == DISPMANX_SUCCESS ); cursor->driverdata = curdata; return cursor; }
void writeDataWorms( WORMS_T *worms) { VC_RECT_T dst_rect; vc_dispmanx_rect_set(&dst_rect, 0, 0, worms->image.width, worms->image.height); int result = vc_dispmanx_resource_write_data(worms->backResource, worms->image.type, worms->image.pitch, worms->image.buffer, &dst_rect); assert(result == 0); }
unsigned char *CRBP::CaptureDisplay(int width, int height, int *pstride, bool swap_red_blue, bool video_only) { DISPMANX_DISPLAY_HANDLE_T display; DISPMANX_RESOURCE_HANDLE_T resource; VC_RECT_T rect; unsigned char *image = NULL; uint32_t vc_image_ptr; int stride; uint32_t flags = 0; if (video_only) flags |= DISPMANX_SNAPSHOT_NO_RGB|DISPMANX_SNAPSHOT_FILL; if (swap_red_blue) flags |= DISPMANX_SNAPSHOT_SWAP_RED_BLUE; if (!pstride) flags |= DISPMANX_SNAPSHOT_PACK; display = vc_dispmanx_display_open( 0 /*screen*/ ); stride = ((width + 15) & ~15) * 4; image = new unsigned char [height * stride]; if (image) { resource = vc_dispmanx_resource_create( VC_IMAGE_RGBA32, width, height, &vc_image_ptr ); vc_dispmanx_snapshot(display, resource, (DISPMANX_TRANSFORM_T)flags); vc_dispmanx_rect_set(&rect, 0, 0, width, height); vc_dispmanx_resource_read_data(resource, &rect, image, stride); vc_dispmanx_resource_delete( resource ); vc_dispmanx_display_close(display ); } if (pstride) *pstride = stride; return image; }