mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-23 19:21:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

DISPMANX: now waiting for free pages after issuing flip, instead of before, to avoid input lag.

Browse Source
This commit is contained in:
vanfanel 2017-01-20 14:59:14 +01:00
parent 5a1e8d55fb
commit 7ae7e2eaee
1 changed files with 36 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
gfx/drivers/dispmanx_gfx.c
View File

@ -54,6 +54,10 @@ struct dispmanx_surface
struct dispmanx_page *pages;
/* the page that's currently on screen */
struct dispmanx_page *current_page;
/*The page to wich we will dump the render. We need to know this
* already when we enter the surface update function. No time to wait
* for free pages before blitting and showing the just rendered frame! */
struct dispmanx_page *next_page;
unsigned int bpp;
VC_RECT_T src_rect;
@ -140,7 +144,7 @@ static struct dispmanx_page *dispmanx_get_free_page(void *data, struct dispmanx_
break;
}
}
/* If no page is free at the moment,
* wait until a free page is freed by vsync CB. */
if (!page)
@ -173,10 +177,9 @@ static void dispmanx_vsync_callback(DISPMANX_UPDATE_HANDLE_T u, void *data)
/* We mark as free the page that was visible until now */
surface->current_page->used = false;
slock_unlock(surface->current_page->page_used_mutex);
}
/* The page on which we issued the flip that
* caused this callback becomes the visible one */
surface->current_page = page;
@ -260,6 +263,11 @@ static void dispmanx_surface_setup(void *data, int src_width, int src_height,
surface->pages[i].page_used_mutex = slock_new();
}
/* No need to mutex this access to the "used" member because
* the flipping/callbacks are not still running */
surface->next_page = &(surface->pages[0]);
surface->next_page->used = true;
/* The "visible" width obtained from the core pitch. We blit based on
* the "visible" width, for cores with things between scanlines. */
int visible_width = visible_pitch / (bpp / 8);
@ -302,7 +310,7 @@ static void dispmanx_surface_update_async(void *data, const void *frame,
{
struct dispmanx_video *_dispvars = data;
struct dispmanx_page *page = NULL;
/* Since it's an async update, there's no need for multiple pages */
page = &(surface->pages[0]);
@ -314,35 +322,42 @@ static void dispmanx_surface_update_async(void *data, const void *frame,
static void dispmanx_surface_update(void *data, const void *frame,
struct dispmanx_surface *surface)
{
struct dispmanx_video *_dispvars = data;
struct dispmanx_page *page = NULL;
/* Updating is very delicate: we REALLY want to show the just rendered frame ASAP,
* so we dump and issue flip, and then we can wait for free pages, but we don't
* want to wait for free pages at the beggining of the update or we will be
* adding lag! */
struct dispmanx_video *_dispvars = data;
settings_t *settings = config_get_ptr();
/* Dispmanx doesn't support more than one pending pageflip.
* It causes lockups. */
/* Frame blitting */
vc_dispmanx_resource_write_data(surface->next_page->resource, surface->pixformat,
surface->pitch, (void*)frame, &(surface->bmp_rect));
/* Dispmanx doesn't support more than one pending pageflip. Doing so would overwrite
* the page in the callback function, so we would be always freeing the same page. */
slock_lock(_dispvars->pending_mutex);
if (_dispvars->pageflip_pending > 0)
scond_wait(_dispvars->vsync_condition, _dispvars->pending_mutex);
slock_unlock(_dispvars->pending_mutex);
page = dispmanx_get_free_page(_dispvars, surface);
/* Frame blitting */
vc_dispmanx_resource_write_data(page->resource, surface->pixformat,
surface->pitch, (void*)frame, &(surface->bmp_rect));
/* Issue a page flip that will be done at the next vsync. */
_dispvars->update = vc_dispmanx_update_start(0);
vc_dispmanx_element_change_source(_dispvars->update, surface->element,
page->resource);
surface->next_page->resource);
vc_dispmanx_update_submit(_dispvars->update, dispmanx_vsync_callback, (void*)page);
vc_dispmanx_update_submit(_dispvars->update,
dispmanx_vsync_callback, (void*)(surface->next_page));
slock_lock(_dispvars->pending_mutex);
_dispvars->pageflip_pending++;
slock_unlock(_dispvars->pending_mutex);
/* Get the next page ready for our next surface_update re-entry.
* It's OK to wait now that we've issued the flip to the last produced frame! */
surface->next_page = dispmanx_get_free_page(_dispvars, surface);
}
/* Enable/disable bilinear filtering. */
@ -373,8 +388,10 @@ static void dispmanx_blank_console (void *data)
1,
-1,
&_dispvars->back_surface);
dispmanx_surface_update(_dispvars, image, _dispvars->back_surface);
/* Updating 1-page surface synchronously asks for truble, since the 1st CB will
* signal but not free because the only page is on screen, so get_free will wait forever. */
dispmanx_surface_update_async(_dispvars, image, _dispvars->back_surface);
}
static void *dispmanx_gfx_init(const video_info_t *video,