/**
* Initialize SDL screen surface / set resolution.
*/
static void Screen_SetResolution(void)
{
int Width, Height, nZoom, SBarHeight, BitCount, maxW, maxH;
bool bDoubleLowRes = false;
BitCount = 0; /* host native */
nBorderPixelsTop = nBorderPixelsBottom = 0;
nBorderPixelsLeft = nBorderPixelsRight = 0;
nScreenZoomX = 1;
nScreenZoomY = 1;
Width = 1120;
Height = 832;
nZoom = 1;
/* Statusbar height for doubled screen size */
SBarHeight = Statusbar_GetHeightForSize(1120, 832);
Resolution_GetLimits(&maxW, &maxH, &BitCount);
Screen_SetSTScreenOffsets();
Height += Statusbar_SetHeight(Width, Height);
/* Check if we really have to change the video mode: */
if (!sdlscrn || sdlscrn->w != Width || sdlscrn->h != Height
|| (BitCount && sdlscrn->format->BitsPerPixel != BitCount))
{
#ifdef _MUDFLAP
if (sdlscrn) {
__mf_unregister(sdlscrn->pixels, sdlscrn->pitch*sdlscrn->h, __MF_TYPE_GUESS);
}
#endif
if (bInFullScreen)
{
/* unhide the Hatari WM window for fullscreen */
Control_ReparentWindow(Width, Height, bInFullScreen);
}
/* Set new video mode */
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");
fprintf(stderr, "SDL screen request: %d x %d @ %d (%s)\n", Width, Height, BitCount, bInFullScreen?"fullscreen":"windowed");
sdlWindow = SDL_CreateWindow(PROG_NAME,
SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
Width, Height, 0);
sdlRenderer = SDL_CreateRenderer(sdlWindow, -1, 0);
if (!sdlWindow || !sdlRenderer)
{
fprintf(stderr,"Failed to create window or renderer!\n");
exit(-1);
}
SDL_RenderSetLogicalSize(sdlRenderer, Width, Height);
sdlscrn = SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, 32,
0x00FF0000, 0x0000FF00,
0x000000FF, 0x00000000);
sdlTexture = SDL_CreateTexture(sdlRenderer,
SDL_PIXELFORMAT_RGB888,
SDL_TEXTUREACCESS_STREAMING,
Width, Height);
fprintf(stderr, "SDL screen granted: %d x %d @ %d\n", sdlscrn->w, sdlscrn->h, sdlscrn->format->BitsPerPixel);
/* Exit if we can not open a screen */
if (!sdlscrn)
{
fprintf(stderr, "Could not set video mode:\n %s\n", SDL_GetError() );
SDL_Quit();
exit(-2);
}
#ifdef _MUDFLAP
__mf_register(sdlscrn->pixels, sdlscrn->pitch*sdlscrn->h, __MF_TYPE_GUESS, "SDL pixels");
#endif
if (!bInFullScreen)
{
/* re-embed the new Hatari SDL window */
Control_ReparentWindow(Width, Height, bInFullScreen);
}
/* Re-init screen palette: */
if (sdlscrn->format->BitsPerPixel == 8)
Screen_Handle8BitPalettes(); /* Initialize new 8 bit palette */
else
Screen_SetupRGBTable(); /* Create color convertion table */
Statusbar_Init(sdlscrn);
/* screen area without the statusbar */
NEXTScreenRect.x = 0;
NEXTScreenRect.y = 0;
NEXTScreenRect.w = sdlscrn->w;
NEXTScreenRect.h = sdlscrn->h - Statusbar_GetHeight();
}
/* Set drawing functions */
Screen_SetDrawFunctions(sdlscrn->format->BitsPerPixel, bDoubleLowRes);
Screen_SetFullUpdate(); /* Cause full update of screen */
}
void HostScreen_setWindowSize(int width, int height, int bpp)
{
int screenwidth, screenheight, maxw, maxh;
int scalex, scaley, sbarheight;
if (bpp == 24)
bpp = 32;
/* constrain size request to user's desktop size */
Resolution_GetDesktopSize(&maxw, &maxh);
scalex = scaley = 1;
while (width > maxw*scalex) {
scalex *= 2;
}
while (height > maxh*scalex) {
scalex *= 2;
}
if (scalex * scaley > 1) {
fprintf(stderr, "WARNING: too large screen size %dx%d -> divided by %dx%d!\n",
width, height, scalex, scaley);
width /= scalex;
height /= scaley;
}
Resolution_GetLimits(&maxw, &maxh, &bpp);
nScreenZoomX = nScreenZoomY = 1;
if (ConfigureParams.Screen.bAspectCorrect) {
/* Falcon (and TT) pixel scaling factors seem to 2^x
* (quarter/half pixel, interlace/double line), so
* do aspect correction as 2's exponent.
*/
while (nScreenZoomX*width < height &&
2*nScreenZoomX*width < maxw) {
nScreenZoomX *= 2;
}
while (2*nScreenZoomY*height < width &&
2*nScreenZoomY*height < maxh) {
nScreenZoomY *= 2;
}
if (nScreenZoomX*nScreenZoomY > 2) {
fprintf(stderr, "WARNING: strange screen size %dx%d -> aspect corrected by %dx%d!\n",
width, height, nScreenZoomX, nScreenZoomY);
}
}
/* then select scale as close to target size as possible
* without having larger size than it
*/
scalex = maxw/(nScreenZoomX*width);
scaley = maxh/(nScreenZoomY*height);
if (scalex > 1 && scaley > 1) {
/* keep aspect ratio */
if (scalex < scaley) {
nScreenZoomX *= scalex;
nScreenZoomY *= scalex;
} else {
nScreenZoomX *= scaley;
nScreenZoomY *= scaley;
}
}
hs_width_req = width;
hs_height_req = height;
width *= nScreenZoomX;
height *= nScreenZoomY;
/* get statusbar size for this screen size */
sbarheight = Statusbar_GetHeightForSize(width, height);
screenheight = height + sbarheight;
screenwidth = width;
/* get resolution corresponding to these */
Resolution_Search(&screenwidth, &screenheight, &bpp);
/* re-calculate statusbar height for this resolution */
sbarheight = Statusbar_SetHeight(screenwidth, screenheight-sbarheight);
hs_bpp = bpp;
/* videl.c might scale things differently in fullscreen than
* in windowed mode because this uses screensize instead of using
* the aspect scaled sizes directly, but it works better this way.
*/
hs_width = screenwidth;
hs_height = screenheight - sbarheight;
if (sdlscrn && (!bpp || sdlscrn->format->BitsPerPixel == bpp) &&
sdlscrn->w == (signed)screenwidth && sdlscrn->h == (signed)screenheight &&
(sdlscrn->flags&SDL_FULLSCREEN) == (sdl_videoparams&SDL_FULLSCREEN))
{
/* same host screen size despite Atari resolution change,
* -> no time consuming host video mode change needed
*/
if (screenwidth > width || screenheight > height+sbarheight) {
/* Atari screen smaller than host -> clear screen */
SDL_Rect rect;
rect.x = 0;
rect.y = 0;
rect.w = sdlscrn->w;
rect.h = sdlscrn->h - sbarheight;
SDL_FillRect(sdlscrn, &rect, SDL_MapRGB(sdlscrn->format, 0, 0, 0));
/* re-calculate variables in case height + statusbar height
* don't anymore match SDL surface size (there's an assert
* for that)
*/
Statusbar_Init(sdlscrn);
}
// check in case switched from VDI to Hostscreen
doUpdate = ( sdlscrn->flags & SDL_HWSURFACE ) == 0;
return;
}
if (bInFullScreen) {
/* un-embed the Hatari WM window for fullscreen */
Control_ReparentWindow(screenwidth, screenheight, bInFullScreen);
sdl_videoparams = SDL_SWSURFACE|SDL_HWPALETTE|SDL_FULLSCREEN;
} else {
sdl_videoparams = SDL_SWSURFACE|SDL_HWPALETTE;
}
#ifdef _MUDFLAP
if (sdlscrn) {
__mf_unregister(sdlscrn->pixels, sdlscrn->pitch*sdlscrn->h, __MF_TYPE_GUESS);
}
#endif
sdlscrn = SDL_SetVideoMode(screenwidth, screenheight, bpp, sdl_videoparams);
#ifdef _MUDFLAP
__mf_register(sdlscrn->pixels, sdlscrn->pitch*sdlscrn->h, __MF_TYPE_GUESS, "SDL pixels");
#endif
if (!bInFullScreen) {
/* re-embed the new Hatari SDL window */
Control_ReparentWindow(screenwidth, screenheight, bInFullScreen);
}
// In case surface format changed, update SDL palette & remap the native palette
HostScreen_updatePalette(256);
HostScreen_remapPalette();
// redraw statusbar
Statusbar_Init(sdlscrn);
Dprintf(("Surface Pitch = %d, width = %d, height = %d\n", sdlscrn->pitch, sdlscrn->w, sdlscrn->h));
Dprintf(("Must Lock? %s\n", SDL_MUSTLOCK(sdlscrn) ? "YES" : "NO"));
// is the SDL_update needed?
doUpdate = ( sdlscrn->flags & SDL_HWSURFACE ) == 0;
Dprintf(("Pixel format:bitspp=%d, tmasks r=%04x g=%04x b=%04x"
", tshifts r=%d g=%d b=%d"
", tlosses r=%d g=%d b=%d\n",
sdlscrn->format->BitsPerPixel,
sdlscrn->format->Rmask, sdlscrn->format->Gmask, sdlscrn->format->Bmask,
sdlscrn->format->Rshift, sdlscrn->format->Gshift, sdlscrn->format->Bshift,
sdlscrn->format->Rloss, sdlscrn->format->Gloss, sdlscrn->format->Bloss));
Main_WarpMouse(sdlscrn->w/2,sdlscrn->h/2);
}
/**
* Set screen height used for statusbar height calculation.
*
* Return height of statusbar that should be added to the screen
* height when screen is (re-)created, or zero if statusbar will
* not be shown
*/
int Statusbar_SetHeight(int width, int height)
{
ScreenHeight = height;
StatusbarHeight = Statusbar_GetHeightForSize(width, height);
return StatusbarHeight;
}