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;
}
