From 0b75671c21ec1e891779031b6435ad18debe3e60 Mon Sep 17 00:00:00 2001 From: vanfanel Date: Sun, 12 Feb 2017 19:27:59 +0100 Subject: [PATCH] DISPMANX: Disable triple buffering for now, for stability reasons. --- gfx/drivers/dispmanx_gfx.c | 147 +++---------------------------------- 1 file changed, 12 insertions(+), 135 deletions(-) diff --git a/gfx/drivers/dispmanx_gfx.c b/gfx/drivers/dispmanx_gfx.c index 96abb92971..090a76ad1b 100644 --- a/gfx/drivers/dispmanx_gfx.c +++ b/gfx/drivers/dispmanx_gfx.c @@ -16,8 +16,6 @@ #include -#include - #ifdef HAVE_CONFIG_H #include "../../config.h" #endif @@ -36,10 +34,6 @@ struct dispmanx_page /* Each page contains it's own resource handler * instead of pointing to in by page number */ DISPMANX_RESOURCE_HANDLE_T resource; - bool used; - /* Each page has it's own mutex for - * isolating it's used flag access. */ - slock_t *page_used_mutex; /* This field will allow us to access the * main _dispvars struct from the vsync CB function */ @@ -57,10 +51,7 @@ 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; + bool flip_page; unsigned int bpp; VC_RECT_T src_rect; @@ -102,12 +93,6 @@ struct dispmanx_video unsigned int dispmanx_width; unsigned int dispmanx_height; - /* For threading */ - scond_t *vsync_condition; - slock_t *vsync_cond_mutex; - slock_t *pending_mutex; - unsigned int pageflip_pending; - /* Menu */ bool menu_active; @@ -129,94 +114,15 @@ struct dispmanx_video float aspect_ratio; }; -/* If no free page is available when called, wait for a page flip. */ -static struct dispmanx_page *dispmanx_get_free_page(void *data, struct dispmanx_surface *surface) -{ - unsigned i; - struct dispmanx_video *_dispvars = data; - struct dispmanx_page *page = NULL; - - while (!page) - { - /* Try to find a free page */ - for (i = 0; i < surface->numpages; ++i) - { - if (!surface->pages[i].used) - { - page = (surface->pages) + i; - break; - } - } - - /* If no page is free at the moment, - * wait until a free page is freed by vsync CB. */ - if (!page) - { - slock_lock(_dispvars->vsync_cond_mutex); - scond_wait(_dispvars->vsync_condition, _dispvars->vsync_cond_mutex); - slock_unlock(_dispvars->vsync_cond_mutex); - } - } - - /* We mark the choosen page as used */ - slock_lock(page->page_used_mutex); - page->used = true; - slock_unlock(page->page_used_mutex); - - return page; -} - -static void dispmanx_vsync_callback(DISPMANX_UPDATE_HANDLE_T u, void *data) -{ - struct dispmanx_page *page = data; - struct dispmanx_surface *surface = page->surface; - - /* Marking the page as free must be done before the signaling - * so when update_main continues (it won't continue until we signal) - * we can chose this page as free */ - if (surface->current_page) - { - slock_lock(surface->current_page->page_used_mutex); - - /* 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; - - /* These two things must be isolated "atomically" to avoid getting - * a false positive in the pending_mutex test in update_main. */ - slock_lock(page->dispvars->pending_mutex); - - page->dispvars->pageflip_pending--; - scond_signal(page->dispvars->vsync_condition); - - slock_unlock(page->dispvars->pending_mutex); -} - static void dispmanx_surface_free(void *data, struct dispmanx_surface **sp) { int i; struct dispmanx_video *_dispvars = data; struct dispmanx_surface *surface = *sp; - /* What if we run into the vsync cb code after freeing the surface? - * We could be trying to get non-existant lock, signal non-existant condition.. - * So we wait for any pending flips to complete before freeing any surface. */ - slock_lock(_dispvars->pending_mutex); - if (_dispvars->pageflip_pending > 0) - scond_wait(_dispvars->vsync_condition, _dispvars->pending_mutex); - - slock_unlock(_dispvars->pending_mutex); - for (i = 0; i < surface->numpages; i++) { vc_dispmanx_resource_delete(surface->pages[i].resource); - surface->pages[i].used = false; - slock_free(surface->pages[i].page_used_mutex); } free(surface->pages); @@ -260,16 +166,12 @@ static void dispmanx_surface_setup(void *data, int src_width, int src_height, for (i = 0; i < surface->numpages; i++) { - surface->pages[i].used = false; surface->pages[i].surface = surface; surface->pages[i].dispvars = _dispvars; - 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; + /* We blit to page 0 first */ + surface->flip_page = 0; /* The "visible" width obtained from the core pitch. We blit based on * the "visible" width, for cores with things between scanlines. */ @@ -325,40 +227,24 @@ 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) { - /* 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; - + struct dispmanx_page *page = NULL; + + page = &surface->pages[surface->flip_page]; + /* Frame blitting */ - vc_dispmanx_resource_write_data(surface->next_page->resource, surface->pixformat, + vc_dispmanx_resource_write_data(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); - /* 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, - surface->next_page->resource); + page->resource); - vc_dispmanx_update_submit(_dispvars->update, - dispmanx_vsync_callback, (void*)(surface->next_page)); + vc_dispmanx_update_submit_sync(_dispvars->update); - 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); + surface->flip_page = !surface->flip_page; } /* Enable/disable bilinear filtering. */ @@ -414,7 +300,6 @@ static void *dispmanx_gfx_init(const video_info_t *video, /* Setup surface parameters */ _dispvars->vc_image_ptr = 0; - _dispvars->pageflip_pending = 0; _dispvars->menu_active = false; _dispvars->rgb32 = video->rgb32; @@ -424,10 +309,7 @@ static void *dispmanx_gfx_init(const video_info_t *video, * before we get to gfx_frame(). */ _dispvars->aspect_ratio = video_driver_get_aspect_ratio(); - /* Initialize the rest of the mutexes and conditions. */ - _dispvars->vsync_condition = scond_new(); - _dispvars->vsync_cond_mutex = slock_new(); - _dispvars->pending_mutex = slock_new(); + /* Initialize the rest of video variables. */ _dispvars->core_width = 0; _dispvars->core_height = 0; _dispvars->menu_width = 0; @@ -695,11 +577,6 @@ static void dispmanx_gfx_free(void *data) vc_dispmanx_display_close(_dispvars->display); bcm_host_deinit(); - /* Destroy mutexes and conditions. */ - slock_free(_dispvars->pending_mutex); - slock_free(_dispvars->vsync_cond_mutex); - scond_free(_dispvars->vsync_condition); - free(_dispvars); }