aboutsummaryrefslogtreecommitdiff
path: root/backends
diff options
context:
space:
mode:
Diffstat (limited to 'backends')
-rw-r--r--backends/graphics/dispmanxsdl/dispmanxsdl-graphics.cpp445
-rw-r--r--backends/graphics/dispmanxsdl/dispmanxsdl-graphics.h4
2 files changed, 245 insertions, 204 deletions
diff --git a/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.cpp b/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.cpp
index f2df0e0086..af48fce935 100644
--- a/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.cpp
+++ b/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.cpp
@@ -34,180 +34,277 @@
#include <bcm_host.h>
-#define NUMPAGES 2
-
struct dispvarsStruct {
DISPMANX_DISPLAY_HANDLE_T display;
- DISPMANX_MODEINFO_T amode;
DISPMANX_UPDATE_HANDLE_T update;
DISPMANX_ELEMENT_HANDLE_T element;
VC_IMAGE_TYPE_T pixFormat;
- VC_DISPMANX_ALPHA_T *alpha;
- VC_RECT_T srcRect;
- VC_RECT_T dstRect;
+ VC_DISPMANX_ALPHA_T alpha;
+
VC_RECT_T bmpRect;
- uint vcImagePtr;
- uint screen;
- uint pitch;
+ VC_RECT_T srcRect;
+ VC_RECT_T dstRect;
+ uint32_t vcImagePtr;
+ int screen;
+ int pitch;
+ unsigned int dispmanxWidth;
+ unsigned int dispmanxHeight;
bool aspectRatioCorrection;
void *pixmem;
-
+
+ int numpages;
struct dispmanxPage *pages;
- struct dispmanxPage *nextPage;
- bool pageflipPending;
+ struct dispmanxPage *currentPage;
+ int pageflipPending;
pthread_cond_t vsyncCondition;
+ pthread_mutex_t vsyncCondMutex;
pthread_mutex_t pendingMutex;
+
+ SDL_Surface *fscreen;
};
struct dispmanxPage {
- DISPMANX_RESOURCE_HANDLE_T resource;
+ DISPMANX_RESOURCE_HANDLE_T resource;
+ bool used;
+ // Each page has it's own mutex for
+ // isolating the access to it's "used" flag.
+ pthread_mutex_t pageUsedMutex;
+
+ // This field will allow us to access the
+ // main dispvars struct, for the vsync cb.
+ struct dispvarsStruct *dispvars;
};
DispmanXSdlGraphicsManager::DispmanXSdlGraphicsManager(SdlEventSource *sdlEventSource)
: SurfaceSdlGraphicsManager(sdlEventSource) {
- _dispvars = new dispvarsStruct;
+ _dispvars = new(dispvarsStruct);
DispmanXInit();
}
DispmanXSdlGraphicsManager::~DispmanXSdlGraphicsManager() {
DispmanXVideoQuit();
- delete _dispvars;
+ delete(_dispvars);
}
void DispmanXSdlGraphicsManager::DispmanXInit() {
_dispvars->screen = 0;
_dispvars->vcImagePtr = 0;
- _dispvars->pages = (struct dispmanxPage *)calloc(NUMPAGES, sizeof(struct dispmanxPage));
+ _dispvars->numpages = 3;
+ _dispvars->pages = (struct dispmanxPage *)calloc(_dispvars->numpages, sizeof(struct dispmanxPage));
_dispvars->pageflipPending = 0;
- _dispvars->nextPage = &_dispvars->pages[0];
+ _dispvars->currentPage = NULL;
+ _dispvars->pixFormat = VC_IMAGE_RGB565;
+
+ /* Transparency disabled */
+ _dispvars->alpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS;
+ _dispvars->alpha.opacity = 255;
+ _dispvars->alpha.mask = 0;
+ _dispvars->element = 0;
+
+ // Init each page's variables
+ for (int i = 0; i < _dispvars->numpages; i++) {
+ _dispvars->pages[i].used = false;
+ _dispvars->pages[i].dispvars = _dispvars;
+ _dispvars->pages[i].resource = 0;
+ pthread_mutex_init(&_dispvars->pages[i].pageUsedMutex, NULL);
+ }
- // Initialize mutex and condition variable objects
- pthread_mutex_init(&_dispvars->pendingMutex, NULL);
+ // Initialize the other mutex and condition variables
pthread_cond_init(&_dispvars->vsyncCondition, NULL);
+ pthread_mutex_init(&_dispvars->pendingMutex, NULL);
+ pthread_mutex_init(&_dispvars->vsyncCondMutex, NULL);
// Before we call any vc_* function, we need to call this one.
bcm_host_init();
_dispvars->display = vc_dispmanx_display_open(_dispvars->screen);
-}
+ graphics_get_display_size(_dispvars->display, &_dispvars->dispmanxWidth, &_dispvars->dispmanxHeight);
-void DispmanXSdlGraphicsManager::DispmanXSetup(int width, int height, int bpp) {
- DispmanXFreeResources();
- vc_dispmanx_display_get_info(_dispvars->display, &_dispvars->amode);
+ // We need this so SDL_SetVideoMode() is called once.
+ _dispvars->fscreen = NULL;
+}
- _dispvars->pitch = width * (bpp / 8);
- _dispvars->pixFormat = VC_IMAGE_RGB565;
+void DispmanXSdlGraphicsManager::DispmanXSetup(int srcWidth, int srcHeight) {
+ unsigned int dstWidth, dstHeight, dstXpos, dstYpos;
- // Transparency disabled
- VC_DISPMANX_ALPHA_T layerAlpha;
- layerAlpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS;
- layerAlpha.opacity = 255;
- layerAlpha.mask = 0;
- _dispvars->alpha = &layerAlpha;
+ // If we have an element, we have to free it along with it's resources.
+ if (_dispvars->element) {
+ DispmanXFreeResources();
+ }
+ // We do this for 2 bytes per pixel which is default on the Rpi.
+ _dispvars->pitch = srcWidth * 2;
if (_dispvars->aspectRatioCorrection) {
- float orig_ratio = ((float)width / (float)height);
- int dst_width = _dispvars->amode.height * orig_ratio;
-
- // If we obtain an 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->amode.width)
- dst_width = _dispvars->amode.width;
- int dst_ypos = (_dispvars->amode.width - dst_width) / 2;
- vc_dispmanx_rect_set(&(_dispvars->dstRect), dst_ypos, 0,
- dst_width, _dispvars->amode.height);
+ float aspect = ((float)srcWidth / (float)srcHeight);
+ dstWidth = _dispvars->dispmanxHeight * aspect;
} else {
- vc_dispmanx_rect_set(&(_dispvars->dstRect), 0, 0,
- _dispvars->amode.width, _dispvars->amode.height);
+ dstWidth = _dispvars->dispmanxWidth;
+ }
+ dstHeight = _dispvars->dispmanxHeight;
+
+ // 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 (dstWidth > _dispvars->dispmanxWidth) {
+ dstWidth = _dispvars->dispmanxWidth;
}
- // We configure the rects now
- vc_dispmanx_rect_set(&(_dispvars->bmpRect), 0, 0, width, height);
- vc_dispmanx_rect_set(&(_dispvars->srcRect), 0, 0, width << 16, height << 16);
+ dstXpos = (_dispvars->dispmanxWidth - dstWidth) / 2;
+ dstYpos = (_dispvars->dispmanxHeight - dstHeight) / 2;
- for (int i = 0; i < NUMPAGES; i++)
- _dispvars->pages[i].resource = vc_dispmanx_resource_create(_dispvars->pixFormat, width, height,
- &(_dispvars->vcImagePtr));
-
- // Add element
+ // Remember we have to transfer the whole bitmap even if we would have
+ // interest in a part of it! Blitting is done by the GPU.
+ vc_dispmanx_rect_set(&_dispvars->dstRect, dstXpos, dstYpos, dstWidth, dstHeight);
+ vc_dispmanx_rect_set(&_dispvars->bmpRect, 0, 0, srcWidth, srcHeight);
+ vc_dispmanx_rect_set(&_dispvars->srcRect, 0, 0, srcWidth << 16, srcHeight << 16);
+
+ for (int i = 0; i < _dispvars->numpages; i++) {
+ _dispvars->pages[i].resource = vc_dispmanx_resource_create(_dispvars->pixFormat,
+ srcWidth, srcHeight, &(_dispvars->vcImagePtr));
+ }
+
+ // Add the element. Has to be removed before getting here again.
_dispvars->update = vc_dispmanx_update_start(0);
-
- _dispvars->element = vc_dispmanx_element_add(_dispvars->update, _dispvars->display, 0,
- &(_dispvars->dstRect), _dispvars->pages[0].resource, &(_dispvars->srcRect),
- DISPMANX_PROTECTION_NONE, _dispvars->alpha, 0, (DISPMANX_TRANSFORM_T)0);
-
- vc_dispmanx_update_submit_sync(_dispvars->update);
+
+ _dispvars->element = vc_dispmanx_element_add(
+ _dispvars->update,_dispvars->display, 0,
+ &_dispvars->dstRect, 0,
+ &_dispvars->srcRect, DISPMANX_PROTECTION_NONE,
+ &_dispvars->alpha, 0, (DISPMANX_TRANSFORM_T)0);
+
+ vc_dispmanx_update_submit_sync(_dispvars->update);
}
void DispmanXVSyncCallback (DISPMANX_UPDATE_HANDLE_T u, void *arg) {
- struct dispvarsStruct *_dispvars = (struct dispvarsStruct*)arg;
+ struct dispmanxPage *page = (struct dispmanxPage*)arg;
+ struct dispvarsStruct *dispvars = page->dispvars;
+
+ // Marking the page as free must be done before the signaling
+ // so when the update function continues (it won't continue until we signal)
+ // we can chose this page as free.
+ if (dispvars->currentPage) {
+ pthread_mutex_lock(&dispvars->currentPage->pageUsedMutex);
+
+ // We mark as free the page that was visible until now.
+ page->dispvars->currentPage->used = false;
+
+ pthread_mutex_unlock(&dispvars->currentPage->pageUsedMutex);
+ }
- // Changing the page to write must be done before the signaling
- // so we have the right page in nextPage when update_main continues
- if (_dispvars->nextPage == &_dispvars->pages[0])
- _dispvars->nextPage = &_dispvars->pages[1];
- else
- _dispvars->nextPage = &_dispvars->pages[0];
+ // The page on which we issued the flip that
+ // caused this callback becomes the visible one
+ dispvars->currentPage = page;
// These two things must be isolated "atomically" to avoid getting
- // a false positive in the pending_mutex test in update_main.
- pthread_mutex_lock(&_dispvars->pendingMutex);
-
- pthread_cond_signal(&_dispvars->vsyncCondition);
- _dispvars->pageflipPending = false;
-
- pthread_mutex_unlock(&_dispvars->pendingMutex);
-
+ // a false positive in the pending_mutex test in update function.
+ pthread_mutex_lock(&dispvars->pendingMutex);
+
+ dispvars->pageflipPending--;
+ pthread_cond_signal(&dispvars->vsyncCondition);
+
+ pthread_mutex_unlock(&dispvars->pendingMutex);
}
void DispmanXSdlGraphicsManager::DispmanXUpdate() {
+ // Wait until last issued flip completes to get a free page. Also,
+ // dispmanx doesn't support issuing more than one pageflip.
pthread_mutex_lock(&_dispvars->pendingMutex);
- if (_dispvars->pageflipPending) {
+ if (_dispvars->pageflipPending > 0) {
pthread_cond_wait(&_dispvars->vsyncCondition, &_dispvars->pendingMutex);
}
pthread_mutex_unlock(&_dispvars->pendingMutex);
+ struct dispmanxPage *page = DispmanXGetFreePage();
+
// Frame blitting
- vc_dispmanx_resource_write_data(_dispvars->nextPage->resource, _dispvars->pixFormat,
- _dispvars->pitch, _dispvars->pixmem, &(_dispvars->bmpRect));
+ vc_dispmanx_resource_write_data(page->resource, _dispvars->pixFormat,
+ _dispvars->pitch, _dispvars->pixmem, &_dispvars->bmpRect);
// Issue a page flip at the next vblank interval (will be done at vsync anyway).
_dispvars->update = vc_dispmanx_update_start(0);
vc_dispmanx_element_change_source(_dispvars->update, _dispvars->element,
- _dispvars->nextPage->resource);
- vc_dispmanx_update_submit(_dispvars->update, &DispmanXVSyncCallback, _dispvars);
+ page->resource);
+ vc_dispmanx_update_submit(_dispvars->update, &DispmanXVSyncCallback, page);
pthread_mutex_lock(&_dispvars->pendingMutex);
- _dispvars->pageflipPending = true;
+ _dispvars->pageflipPending++;
pthread_mutex_unlock(&_dispvars->pendingMutex);
}
+struct dispmanxPage *DispmanXSdlGraphicsManager::DispmanXGetFreePage(void) {
+ struct dispmanxPage *page = NULL;
+
+ while (!page)
+ {
+ // Try to find a free page
+ for (int i = 0; i < _dispvars->numpages; ++i) {
+ if (!_dispvars->pages[i].used)
+ {
+ page = (_dispvars->pages) + i;
+ break;
+ }
+ }
+
+ // If no page is free at the moment,
+ // wait until a free page is freed by vsync CB.
+ if (!page) {
+ pthread_mutex_lock(&_dispvars->vsyncCondMutex);
+ pthread_cond_wait(&_dispvars->vsyncCondition, &_dispvars->vsyncCondMutex);
+ pthread_mutex_unlock(&_dispvars->vsyncCondMutex);
+ }
+ }
+
+ // We mark the choosen page as used
+ pthread_mutex_lock(&page->pageUsedMutex);
+ page->used = true;
+ pthread_mutex_unlock(&page->pageUsedMutex);
+
+ return page;
+}
+
void DispmanXSdlGraphicsManager::DispmanXFreeResources(void) {
- _dispvars->update = vc_dispmanx_update_start(0);
-
- for (int i = 0; i < NUMPAGES; i++)
+ // What if we run into the vsync cb code after freeing the resources?
+ pthread_mutex_lock(&_dispvars->pendingMutex);
+ if (_dispvars->pageflipPending > 0)
+ {
+ pthread_cond_wait(&_dispvars->vsyncCondition, &_dispvars->pendingMutex);
+ }
+ pthread_mutex_unlock(&_dispvars->pendingMutex);
+
+ for (int i = 0; i < _dispvars->numpages; i++) {
vc_dispmanx_resource_delete(_dispvars->pages[i].resource);
-
+ _dispvars->pages[i].resource = 0;
+ _dispvars->pages[i].used = false;
+ }
+
+ _dispvars->update = vc_dispmanx_update_start(0);
vc_dispmanx_element_remove(_dispvars->update, _dispvars->element);
-
vc_dispmanx_update_submit_sync(_dispvars->update);
+ // We use this on the setup function to know if we have to free resources and element.
+ _dispvars->element = 0;
}
void DispmanXSdlGraphicsManager::DispmanXVideoQuit() {
+ // This also waits for pending flips to complete, that's needed before
+ // we destroy the mutexes and condition.
DispmanXFreeResources();
- // Close display and deinit
- vc_dispmanx_display_close(_dispvars->display);
- bcm_host_deinit();
-
- // Destroy mutexes and conditions
+
+ // Destroy the mutexes and conditions
+ for (int i = 0; i < _dispvars->numpages; i++) {
+ pthread_mutex_destroy(&_dispvars->pages[i].pageUsedMutex);
+ }
pthread_mutex_destroy(&_dispvars->pendingMutex);
+ pthread_mutex_destroy(&_dispvars->vsyncCondMutex);
pthread_cond_destroy(&_dispvars->vsyncCondition);
free(_dispvars->pages);
+
+ // Close display and deinit
+ vc_dispmanx_display_close(_dispvars->display);
+ bcm_host_deinit();
}
bool DispmanXSdlGraphicsManager::loadGFXMode() {
@@ -216,10 +313,10 @@ bool DispmanXSdlGraphicsManager::loadGFXMode() {
// In DispmanX, we manage aspect ratio correction, so for scummvm it's always disabled.
_videoMode.aspectRatioCorrection = false;
- _videoMode.overlayWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
- _videoMode.overlayHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
- _videoMode.hardwareWidth = _videoMode.screenWidth * _videoMode.scaleFactor;
- _videoMode.hardwareHeight = _videoMode.screenHeight * _videoMode.scaleFactor;
+ _videoMode.overlayWidth = _videoMode.screenWidth;
+ _videoMode.overlayHeight = _videoMode.screenHeight;
+ _videoMode.hardwareWidth = _videoMode.screenWidth;
+ _videoMode.hardwareHeight = _videoMode.screenHeight;
//
// Create the surface that contains the 8 bit game data
@@ -236,59 +333,30 @@ bool DispmanXSdlGraphicsManager::loadGFXMode() {
// Avoid having SDL_SRCALPHA set even if we supplied an alpha-channel in the format.
SDL_SetAlpha(_screen, 0, 255);
- // SDL 1.2 palettes default to all black,
- // SDL 1.3 palettes default to all white,
- // Thus set our own default palette to all black.
- // SDL_SetColors does nothing for non indexed surfaces.
+ // We set our own default palette to all black.
SDL_SetColors(_screen, _currentPalette, 0, 256);
//
// Create the surface that contains the scaled graphics in 16 bit mode
//
- // We call DispmanXSetup() before SDL_SetVideoMode() because we use _hwscreen == null
- // to know inside DispmanXSetup() if we've been there before and need to free resources.
- DispmanXSetup(_videoMode.screenWidth, _videoMode.screenHeight, 16);
- // _hwscreen = SDL_SetVideoMode(_videoMode.hardwareWidth, _videoMode.hardwareHeight, 16, SDL_FULLSCREEN);
+ DispmanXSetup(_videoMode.screenWidth, _videoMode.screenHeight);
+
_hwscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.hardwareWidth, _videoMode.hardwareHeight, 16,
0, 0, 0, 0);
-
- _dispvars->pixmem = _hwscreen->pixels;
-
- // We draw on a RAM surface, but we make this call just to get SDL input initialized.
- // Even if we don't use the returned SDL_Surface *, we still need to use the right dimensions
- // for mouse pointer adjustment to work correctly.
- SDL_SetVideoMode(_videoMode.screenWidth, _videoMode.screenHeight, 16, SDL_FULLSCREEN);
-
- detectSupportedFormats();
+ // This is just so SDL 1.x input is initialized. Only once!
+ if (_dispvars->fscreen == NULL)
+ _dispvars->fscreen = SDL_SetVideoMode(_videoMode.hardwareWidth, _videoMode.hardwareHeight, 16, SDL_FULLSCREEN);
if (_hwscreen == NULL) {
- // DON'T use error(), as this tries to bring up the debug
- // console, which WON'T WORK now that _hwscreen is hosed.
-
- if (!_oldVideoMode.setup) {
- warning("SDL_SetVideoMode says we can't switch to that mode (%s)", SDL_GetError());
- g_system->quit();
- } else {
- return false;
- }
+ // Don't use error here because we don't have access to the debug console
+ warning("Allocating surface for DispmanX rendering _hwscreen failed");
+ g_system->quit();
}
- //
- // Create the surface used for the graphics in 16 bit before scaling, and also the overlay
- //
-
- // Need some extra bytes around when using 2xSaI
- _tmpscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.screenWidth + 3, _videoMode.screenHeight + 3,
- 16,
- _hwscreen->format->Rmask,
- _hwscreen->format->Gmask,
- _hwscreen->format->Bmask,
- _hwscreen->format->Amask);
-
- if (_tmpscreen == NULL)
- error("allocating _tmpscreen failed");
-
+ // We render to dispmanx resources from _hwscreen pixels array
+ _dispvars->pixmem = _hwscreen->pixels;
+
_overlayscreen = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.overlayWidth, _videoMode.overlayHeight,
16,
_hwscreen->format->Rmask,
@@ -311,16 +379,6 @@ bool DispmanXSdlGraphicsManager::loadGFXMode() {
_overlayFormat.bShift = _overlayscreen->format->Bshift;
_overlayFormat.aShift = _overlayscreen->format->Ashift;
- _tmpscreen2 = SDL_CreateRGBSurface(SDL_SWSURFACE, _videoMode.overlayWidth + 3, _videoMode.overlayHeight + 3,
- 16,
- _hwscreen->format->Rmask,
- _hwscreen->format->Gmask,
- _hwscreen->format->Bmask,
- _hwscreen->format->Amask);
-
- if (_tmpscreen2 == NULL)
- error("allocating _tmpscreen2 failed");
-
#ifdef USE_OSD
_osdSurface = SDL_CreateRGBSurface(SDL_SWSURFACE | SDL_RLEACCEL | SDL_SRCCOLORKEY | SDL_SRCALPHA,
_hwscreen->w,
@@ -336,29 +394,51 @@ bool DispmanXSdlGraphicsManager::loadGFXMode() {
#endif
_eventSource->resetKeyboadEmulation(
- _videoMode.screenWidth * _videoMode.scaleFactor - 1,
- effectiveScreenHeight() - 1);
-
- // Distinguish 555 and 565 mode
- if (_hwscreen->format->Rmask == 0x7C00)
- InitScalers(555);
- else
- InitScalers(565);
+ _videoMode.screenWidth, effectiveScreenHeight());
return true;
}
+void DispmanXSdlGraphicsManager::clearOverlay() {
+ //assert(_transactionMode == kTransactionNone);
+
+ Common::StackLock lock(_graphicsMutex); // Lock the mutex until this function ends
+
+ if (!_overlayVisible)
+ return;
+
+ // Clear the overlay by making the game screen "look through" everywhere.
+ SDL_Rect src, dst;
+ src.x = src.y = 0;
+ dst.x = dst.y = 0;
+ src.w = dst.w = _videoMode.screenWidth;
+ src.h = dst.h = _videoMode.screenHeight;
+ if (SDL_BlitSurface(_screen, &src, _hwscreen, &dst) != 0)
+ error("SDL_BlitSurface failed: %s", SDL_GetError());
+
+ SDL_LockSurface(_hwscreen);
+ SDL_LockSurface(_overlayscreen);
+ Normal1x((byte *)(_hwscreen->pixels), _hwscreen->pitch,
+ (byte *)_overlayscreen->pixels, _overlayscreen->pitch, _videoMode.screenWidth, _videoMode.screenHeight);
+
+ SDL_UnlockSurface(_hwscreen);
+ SDL_UnlockSurface(_overlayscreen);
+
+ _forceFull = true;
+}
+
void DispmanXSdlGraphicsManager::internUpdateScreen() {
SDL_Surface *srcSurf, *origSurf;
int height, width;
- ScalerProc *scalerProc;
- int scale1;
// If the shake position changed, fill the dirty area with blackness
if (_currentShakePos != _newShakePos ||
(_mouseNeedsRedraw && _mouseBackup.y <= _currentShakePos)) {
SDL_Rect blackrect = {0, 0, (Uint16)(_videoMode.screenWidth * _videoMode.scaleFactor), (Uint16)(_newShakePos * _videoMode.scaleFactor)};
+ if (_videoMode.aspectRatioCorrection && !_overlayVisible)
+ blackrect.h = real2Aspect(blackrect.h - 1) + 1;
+
SDL_FillRect(_hwscreen, &blackrect, 0);
_currentShakePos = _newShakePos;
@@ -400,19 +480,14 @@ void DispmanXSdlGraphicsManager::internUpdateScreen() {
if (!_overlayVisible) {
origSurf = _screen;
- srcSurf = _tmpscreen;
+ srcSurf = _hwscreen;
width = _videoMode.screenWidth;
height = _videoMode.screenHeight;
- scalerProc = _scalerProc;
- scale1 = _videoMode.scaleFactor;
} else {
origSurf = _overlayscreen;
- srcSurf = _tmpscreen2;
+ srcSurf = _hwscreen;
width = _videoMode.overlayWidth;
height = _videoMode.overlayHeight;
- scalerProc = Normal1x;
-
- scale1 = 1;
}
// Add the area covered by the mouse cursor to the list of dirty rects if
@@ -433,50 +508,15 @@ void DispmanXSdlGraphicsManager::internUpdateScreen() {
if (_numDirtyRects > 0 || _mouseNeedsRedraw) {
SDL_Rect *r;
SDL_Rect dst;
- uint32 srcPitch, dstPitch;
SDL_Rect *lastRect = _dirtyRectList + _numDirtyRects;
for (r = _dirtyRectList; r != lastRect; ++r) {
dst = *r;
- dst.x++; // Shift rect by one since 2xSai needs to access the data around
- dst.y++; // any pixel to scale it, and we want to avoid mem access crashes.
if (SDL_BlitSurface(origSurf, r, srcSurf, &dst) != 0)
error("SDL_BlitSurface failed: %s", SDL_GetError());
}
- SDL_LockSurface(srcSurf);
- SDL_LockSurface(_hwscreen);
-
- srcPitch = srcSurf->pitch;
- dstPitch = _hwscreen->pitch;
-
- for (r = _dirtyRectList; r != lastRect; ++r) {
- register int dst_y = r->y + _currentShakePos;
- register int dst_h = 0;
- register int rx1 = r->x * scale1;
-
- if (dst_y < height) {
- dst_h = r->h;
- if (dst_h > height - dst_y)
- dst_h = height - dst_y;
-
- dst_y = dst_y * scale1;
-
- assert(scalerProc != NULL);
- scalerProc((byte *)srcSurf->pixels + (r->x * 2 + 2) + (r->y + 1) * srcPitch, srcPitch,
- (byte *)_hwscreen->pixels + rx1 * 2 + dst_y * dstPitch, dstPitch, r->w, dst_h);
- }
-
- r->x = rx1;
- r->y = dst_y;
- r->w = r->w * scale1;
- r->h = dst_h * scale1;
-
- }
- SDL_UnlockSurface(srcSurf);
- SDL_UnlockSurface(_hwscreen);
-
// Readjust the dirty rect list in case we are doing a full update.
// This is necessary if shaking is active.
if (_forceFull) {
@@ -491,6 +531,7 @@ void DispmanXSdlGraphicsManager::internUpdateScreen() {
SDL_BlitSurface(_osdSurface, 0, _hwscreen, 0);
}
#endif
+
// Finally, blit all our changes to the screen
if (!_displayDisabled) {
SDL_UpdateRects(_hwscreen, _numDirtyRects, _dirtyRectList);
@@ -531,15 +572,13 @@ void DispmanXSdlGraphicsManager::setFullscreenMode(bool enable) {
void DispmanXSdlGraphicsManager::setAspectRatioCorrection(bool enable) {
Common::StackLock lock(_graphicsMutex);
- // Ratio correction is managed externally by dispmanx, so we disable it at the SDL level but take note,
- // so it's effectively taken into account at the dispmanx level in DispmanXSetup().
- if (_oldVideoMode.setup && _dispvars->aspectRatioCorrection == enable)
- return;
+ // We simply take note on what's the aspect ratio correction activation state.
+ _dispvars->aspectRatioCorrection = enable;
- if (_transactionMode == kTransactionActive) {
- _dispvars->aspectRatioCorrection = enable;
- _transactionDetails.needHotswap = false;
- DispmanXSetup(_videoMode.screenWidth, _videoMode.screenHeight, 16);
+ // If we have a videomode setup already, call DispmanXSetup() again so aspect ratio
+ // correction activation/deactivation works from the menu.
+ if (_oldVideoMode.setup && _dispvars->aspectRatioCorrection == enable) {
+ DispmanXSetup(_videoMode.screenWidth, _videoMode.screenHeight);
}
}
diff --git a/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.h b/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.h
index a5abb8618a..c41f84ef7a 100644
--- a/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.h
+++ b/backends/graphics/dispmanxsdl/dispmanxsdl-graphics.h
@@ -37,11 +37,13 @@ public:
bool handleScalerHotkeys(Common::KeyCode key);
void setFullscreenMode(bool enable);
void setAspectRatioCorrection(bool enable);
+ void clearOverlay();
protected:
// Raspberry Pi Dispmanx API
- void DispmanXSetup(int dwidth, int dheight, int dbpp);
+ void DispmanXSetup(int width, int height);
void DispmanXInit();
void DispmanXUpdate();
+ struct dispmanxPage *DispmanXGetFreePage();
void DispmanXFreeResources();
void DispmanXVideoQuit();
struct dispvarsStruct *_dispvars;