geemili
/
SDL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add full high DPI information to SDL_DisplayMode 

SDL_DisplayMode now includes the pixel size, the screen size and the relationship between the two. For example, a 4K display at 200% scale could have a pixel size of 3840x2160, a screen size of 1920x1080, and a display scale of 2.0.
main
Sam Lantinga 2023-01-27 10:46:51 -08:00
parent b23d20cd4d
commit 24fec13ac1
31 changed files with 370 additions and 345 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/README-migration.md
View File

@ -954,6 +954,8 @@ The SDL_WINDOW_SHOWN flag has been removed. Windows are shown by default and can
The SDL_WINDOW_ALLOW_HIGHDPI flag has been removed. Windows are automatically high DPI aware and their coordinates are in screen space, which may differ from physical pixels on displays using display scaling. The SDL_WINDOW_ALLOW_HIGHDPI flag has been removed. Windows are automatically high DPI aware and their coordinates are in screen space, which may differ from physical pixels on displays using display scaling.
SDL_DisplayMode now includes the pixel size, the screen size and the relationship between the two. For example, a 4K display at 200% scale could have a pixel size of 3840x2160, a screen size of 1920x1080, and a display scale of 2.0.
The refresh rate in SDL_DisplayMode is now a float. The refresh rate in SDL_DisplayMode is now a float.
SDL_SetWindowBrightness and SDL_SetWindowGammaRamp have been removed from the API, because they interact poorly with modern operating systems and aren't able to limit their effects to the SDL window. SDL_SetWindowBrightness and SDL_SetWindowGammaRamp have been removed from the API, because they interact poorly with modern operating systems and aren't able to limit their effects to the SDL window.

8
include/SDL3/SDL_video.h
View File

@ -56,9 +56,11 @@ typedef Uint32 SDL_WindowID;
typedef struct typedef struct
{ {
Uint32 format; /**< pixel format */ Uint32 format; /**< pixel format */
int w; /**< width in pixels */ int pixel_w; /**< width in pixels (used for creating back buffers) */
int h; /**< height in pixels */ int pixel_h; /**< height in pixels (used for creating back buffers) */
float display_scale; /**< scale converting screen coordinates to pixels (e.g. a 3840x2160 mode with 1.5 scale would have a screen size of 2560x1440) */ int screen_w; /**< width in screen coordinates (used for creating windows) */
int screen_h; /**< height in screen coordinates (used for creating windows) */
float display_scale; /**< scale converting screen coordinates to pixels (e.g. a 2560x1440 screen size mode with 1.5 scale would have 3840x2160 pixels) */
float refresh_rate; /**< refresh rate (or zero for unspecified) */ float refresh_rate; /**< refresh rate (or zero for unspecified) */
void *driverdata; /**< driver-specific data, initialize to 0 */ void *driverdata; /**< driver-specific data, initialize to 0 */
} SDL_DisplayMode; } SDL_DisplayMode;

12
src/core/winrt/SDL_winrtapp_direct3d.cpp
View File

@ -116,10 +116,10 @@ static void WINRT_ProcessWindowSizeChange() // TODO: Pass an SDL_Window-identify
SDL_Window *window = WINRT_GlobalSDLWindow; SDL_Window *window = WINRT_GlobalSDLWindow;
SDL_WindowData *data = (SDL_WindowData *)window->driverdata; SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
int x = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Left); int x = (int)SDL_lroundf(data->coreWindow->Bounds.Left);
int y = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Top); int y = (int)SDL_lroundf(data->coreWindow->Bounds.Top);
int w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); int w = (int)SDL_floorf(data->coreWindow->Bounds.Width);
int h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); int h = (int)SDL_floorf(data->coreWindow->Bounds.Height);
#if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) && (NTDDI_VERSION == NTDDI_WIN8) #if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) && (NTDDI_VERSION == NTDDI_WIN8)
/* WinPhone 8.0 always keeps its native window size in portrait, /* WinPhone 8.0 always keeps its native window size in portrait,
@ -235,8 +235,8 @@ void SDL_WinRTApp::OnOrientationChanged(Object ^ sender)
SDL_Window *window = WINRT_GlobalSDLWindow; SDL_Window *window = WINRT_GlobalSDLWindow;
if (window) { if (window) {
SDL_WindowData *data = (SDL_WindowData *)window->driverdata; SDL_WindowData *data = (SDL_WindowData *)window->driverdata;
int w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); int w = (int)SDL_floorf(data->coreWindow->Bounds.Width);
int h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); int h = (int)SDL_floorf(data->coreWindow->Bounds.Height);
SDL_SendWindowEvent(WINRT_GlobalSDLWindow, SDL_EVENT_WINDOW_SIZE_CHANGED, w, h); SDL_SendWindowEvent(WINRT_GlobalSDLWindow, SDL_EVENT_WINDOW_SIZE_CHANGED, w, h);
} }
#endif #endif

10
src/test/SDL_test_common.c
View File

@ -1130,7 +1130,7 @@ SDLTest_CommonInit(SDLTest_CommonState *state)
SDL_GetMasksForPixelFormatEnum(mode.format, &bpp, &Rmask, &Gmask, SDL_GetMasksForPixelFormatEnum(mode.format, &bpp, &Rmask, &Gmask,
&Bmask, &Amask); &Bmask, &Amask);
SDL_Log(" Current mode: %dx%d@%gHz, %d%% scale, %d bits-per-pixel (%s)\n", SDL_Log(" Current mode: %dx%d@%gHz, %d%% scale, %d bits-per-pixel (%s)\n",
mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp, mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp,
SDL_GetPixelFormatName(mode.format)); SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) { if (Rmask || Gmask || Bmask) {
SDL_Log(" Red Mask = 0x%.8" SDL_PRIx32 "\n", Rmask); SDL_Log(" Red Mask = 0x%.8" SDL_PRIx32 "\n", Rmask);
@ -1152,7 +1152,7 @@ SDLTest_CommonInit(SDLTest_CommonState *state)
SDL_GetMasksForPixelFormatEnum(mode.format, &bpp, &Rmask, SDL_GetMasksForPixelFormatEnum(mode.format, &bpp, &Rmask,
&Gmask, &Bmask, &Amask); &Gmask, &Bmask, &Amask);
SDL_Log(" Mode %d: %dx%d@%gHz, %d%% scale, %d bits-per-pixel (%s)\n", SDL_Log(" Mode %d: %dx%d@%gHz, %d%% scale, %d bits-per-pixel (%s)\n",
j, mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp, j, mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), bpp,
SDL_GetPixelFormatName(mode.format)); SDL_GetPixelFormatName(mode.format));
if (Rmask || Gmask || Bmask) { if (Rmask || Gmask || Bmask) {
SDL_Log(" Red Mask = 0x%.8" SDL_PRIx32 "\n", SDL_Log(" Red Mask = 0x%.8" SDL_PRIx32 "\n",
@ -2246,7 +2246,7 @@ void SDLTest_CommonDrawWindowInfo(SDL_Renderer *renderer, SDL_Window *window, fl
if (0 == SDL_GetWindowDisplayMode(window, &mode)) { if (0 == SDL_GetWindowDisplayMode(window, &mode)) {
(void)SDL_snprintf(text, sizeof text, "SDL_GetWindowDisplayMode: %dx%d@%gHz %d%% scale, (%s)", (void)SDL_snprintf(text, sizeof text, "SDL_GetWindowDisplayMode: %dx%d@%gHz %d%% scale, (%s)",
mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format));
SDLTest_DrawString(renderer, 0.0f, textY, text); SDLTest_DrawString(renderer, 0.0f, textY, text);
textY += lineHeight; textY += lineHeight;
} }
@ -2276,14 +2276,14 @@ void SDLTest_CommonDrawWindowInfo(SDL_Renderer *renderer, SDL_Window *window, fl
if (0 == SDL_GetCurrentDisplayMode(windowDisplayIndex, &mode)) { if (0 == SDL_GetCurrentDisplayMode(windowDisplayIndex, &mode)) {
(void)SDL_snprintf(text, sizeof text, "SDL_GetCurrentDisplayMode: %dx%d@%gHz %d%% scale, (%s)", (void)SDL_snprintf(text, sizeof text, "SDL_GetCurrentDisplayMode: %dx%d@%gHz %d%% scale, (%s)",
mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format));
SDLTest_DrawString(renderer, 0.0f, textY, text); SDLTest_DrawString(renderer, 0.0f, textY, text);
textY += lineHeight; textY += lineHeight;
} }
if (0 == SDL_GetDesktopDisplayMode(windowDisplayIndex, &mode)) { if (0 == SDL_GetDesktopDisplayMode(windowDisplayIndex, &mode)) {
(void)SDL_snprintf(text, sizeof text, "SDL_GetDesktopDisplayMode: %dx%d@%gHz %d%% scale, (%s)", (void)SDL_snprintf(text, sizeof text, "SDL_GetDesktopDisplayMode: %dx%d@%gHz %d%% scale, (%s)",
mode.w, mode.h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format)); mode.pixel_w, mode.pixel_h, mode.refresh_rate, (int)(mode.display_scale * 100.0f), SDL_GetPixelFormatName(mode.format));
SDLTest_DrawString(renderer, 0.0f, textY, text); SDLTest_DrawString(renderer, 0.0f, textY, text);
textY += lineHeight; textY += lineHeight;
} }

212
src/video/SDL_video.c
View File

@ -382,16 +382,16 @@ static int SDLCALL cmpmodes(const void *A, const void *B)
{ {
const SDL_DisplayMode *a = (const SDL_DisplayMode *)A; const SDL_DisplayMode *a = (const SDL_DisplayMode *)A;
const SDL_DisplayMode *b = (const SDL_DisplayMode *)B; const SDL_DisplayMode *b = (const SDL_DisplayMode *)B;
float a_display_scale = (a->display_scale == 0.0f) ? 1.0f : a->display_scale;
float b_display_scale = (b->display_scale == 0.0f) ? 1.0f : b->display_scale;
if (a == b) { if (a == b) {
return 0; return 0;
} else if (a->w != b->w) { } else if (a->screen_w != b->screen_w) {
return b->w - a->w; return b->screen_w - a->screen_w;
} else if (a->h != b->h) { } else if (a->screen_h != b->screen_h) {
return b->h - a->h; return b->screen_h - a->screen_h;
} else if (a_display_scale != b_display_scale) { } else if (a->pixel_w != b->pixel_w) {
return (int)(a_display_scale * 100) - (int)(b_display_scale * 100); return b->pixel_w - a->pixel_w;
} else if (a->pixel_h != b->pixel_h) {
return b->pixel_h - a->pixel_h;
} else if (SDL_BITSPERPIXEL(a->format) != SDL_BITSPERPIXEL(b->format)) { } else if (SDL_BITSPERPIXEL(a->format) != SDL_BITSPERPIXEL(b->format)) {
return SDL_BITSPERPIXEL(b->format) - SDL_BITSPERPIXEL(a->format); return SDL_BITSPERPIXEL(b->format) - SDL_BITSPERPIXEL(a->format);
} else if (SDL_PIXELLAYOUT(a->format) != SDL_PIXELLAYOUT(b->format)) { } else if (SDL_PIXELLAYOUT(a->format) != SDL_PIXELLAYOUT(b->format)) {
@ -585,6 +585,40 @@ SDL_bool SDL_OnVideoThread()
return (_this && SDL_ThreadID() == _this->thread) ? SDL_TRUE : SDL_FALSE; return (_this && SDL_ThreadID() == _this->thread) ? SDL_TRUE : SDL_FALSE;
} }
static void SDL_FinalizeDisplayMode(SDL_DisplayMode *mode)
{
/* Make sure all the fields are set up correctly */
if (mode->display_scale <= 0.0f) {
if (mode->screen_w == 0 && mode->screen_h == 0) {
mode->screen_w = mode->pixel_w;
mode->screen_h = mode->pixel_h;
}
if (mode->pixel_w == 0 && mode->pixel_h == 0) {
mode->pixel_w = mode->screen_w;
mode->pixel_h = mode->screen_h;
}
if (mode->screen_w > 0) {
mode->display_scale = (float)mode->pixel_w / mode->screen_w;
}
} else {
if (mode->screen_w == 0 && mode->screen_h == 0) {
mode->screen_w = (int)SDL_floorf(mode->pixel_w / mode->display_scale);
mode->screen_h = (int)SDL_floorf(mode->pixel_h / mode->display_scale);
}
if (mode->pixel_w == 0 && mode->pixel_h == 0) {
mode->pixel_w = (int)SDL_ceilf(mode->screen_w * mode->display_scale);
mode->pixel_h = (int)SDL_ceilf(mode->screen_h * mode->display_scale);
}
}
/* Make sure the screen width, pixel width, and display scale all match */
if (mode->display_scale != 0.0f) {
SDL_assert(mode->display_scale > 0.0f);
SDL_assert(SDL_fabsf(mode->screen_w - (mode->pixel_w / mode->display_scale)) < 1.0f);
SDL_assert(SDL_fabsf(mode->screen_h - (mode->pixel_h / mode->display_scale)) < 1.0f);
}
}
int SDL_AddBasicVideoDisplay(const SDL_DisplayMode *desktop_mode) int SDL_AddBasicVideoDisplay(const SDL_DisplayMode *desktop_mode)
{ {
SDL_VideoDisplay display; SDL_VideoDisplay display;
@ -592,9 +626,7 @@ int SDL_AddBasicVideoDisplay(const SDL_DisplayMode *desktop_mode)
SDL_zero(display); SDL_zero(display);
if (desktop_mode) { if (desktop_mode) {
display.desktop_mode = *desktop_mode; display.desktop_mode = *desktop_mode;
if (display.desktop_mode.display_scale == 0.0f) { SDL_FinalizeDisplayMode(&display.desktop_mode);
display.desktop_mode.display_scale = 1.0f;
}
} }
display.current_mode = display.desktop_mode; display.current_mode = display.desktop_mode;
@ -624,12 +656,9 @@ int SDL_AddVideoDisplay(const SDL_VideoDisplay *display, SDL_bool send_event)
displays[index].name = SDL_strdup(name); displays[index].name = SDL_strdup(name);
} }
if (displays[index].desktop_mode.display_scale == 0.0f) { SDL_FinalizeDisplayMode(&displays[index].desktop_mode);
displays[index].desktop_mode.display_scale = 1.0f; SDL_FinalizeDisplayMode(&displays[index].current_mode);
}
if (displays[index].current_mode.display_scale == 0.0f) {
displays[index].current_mode.display_scale = 1.0f;
}
if (send_event) { if (send_event) {
SDL_SendDisplayEvent(&_this->displays[index], SDL_EVENT_DISPLAY_CONNECTED, 0); SDL_SendDisplayEvent(&_this->displays[index], SDL_EVENT_DISPLAY_CONNECTED, 0);
} }
@ -722,8 +751,8 @@ int SDL_GetDisplayBounds(int displayIndex, SDL_Rect *rect)
SDL_GetDisplayBounds(displayIndex - 1, rect); SDL_GetDisplayBounds(displayIndex - 1, rect);
rect->x += rect->w; rect->x += rect->w;
} }
rect->w = (int)(display->current_mode.w / display->current_mode.display_scale); rect->w = display->current_mode.screen_w;
rect->h = (int)(display->current_mode.h / display->current_mode.display_scale); rect->h = display->current_mode.screen_h;
return 0; return 0;
} }
@ -812,9 +841,7 @@ SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mo
display->max_display_modes += 32; display->max_display_modes += 32;
} }
modes[nmodes] = *mode; modes[nmodes] = *mode;
if (modes[nmodes].display_scale == 0.0f) { SDL_FinalizeDisplayMode(&modes[nmodes]);
modes[nmodes].display_scale = 1.0f;
}
display->num_display_modes++; display->num_display_modes++;
/* Re-sort video modes */ /* Re-sort video modes */
@ -827,17 +854,13 @@ SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mo
void SDL_SetCurrentDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode) void SDL_SetCurrentDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)
{ {
SDL_memcpy(&display->current_mode, mode, sizeof(*mode)); SDL_memcpy(&display->current_mode, mode, sizeof(*mode));
if (display->current_mode.display_scale == 0.0f) { SDL_FinalizeDisplayMode(&display->current_mode);
display->current_mode.display_scale = 1.0f;
}
} }
void SDL_SetDesktopDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode) void SDL_SetDesktopDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)
{ {
SDL_memcpy(&display->desktop_mode, mode, sizeof(*mode)); SDL_memcpy(&display->desktop_mode, mode, sizeof(*mode));
if (display->desktop_mode.display_scale == 0.0f) { SDL_FinalizeDisplayMode(&display->desktop_mode);
display->desktop_mode.display_scale = 1.0f;
}
} }
static int SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay *display) static int SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay *display)
@ -922,9 +945,9 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
SDL_DisplayMode *closest) SDL_DisplayMode *closest)
{ {
Uint32 target_format; Uint32 target_format;
float target_display_scale;
float target_refresh_rate; float target_refresh_rate;
int i; int i;
SDL_DisplayMode requested_mode;
SDL_DisplayMode *current, *match; SDL_DisplayMode *current, *match;
if (mode == NULL || closest == NULL) { if (mode == NULL || closest == NULL) {
@ -932,6 +955,11 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
return NULL; return NULL;
} }
/* Make sure all the fields are filled out in the requested mode */
requested_mode = *mode;
SDL_FinalizeDisplayMode(&requested_mode);
mode = &requested_mode;
/* Default to the desktop format */ /* Default to the desktop format */
if (mode->format) { if (mode->format) {
target_format = mode->format; target_format = mode->format;
@ -939,13 +967,6 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
target_format = display->desktop_mode.format; target_format = display->desktop_mode.format;
} }
/* Default to 1.0 scale */
if (mode->display_scale > 0.0f) {
target_display_scale = mode->display_scale;
} else {
target_display_scale = 1.0f;
}
/* Default to the desktop refresh rate */ /* Default to the desktop refresh rate */
if (mode->refresh_rate > 0.0f) { if (mode->refresh_rate > 0.0f) {
target_refresh_rate = mode->refresh_rate; target_refresh_rate = mode->refresh_rate;
@ -957,12 +978,12 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
for (i = 0; i < SDL_GetNumDisplayModesForDisplay(display); ++i) { for (i = 0; i < SDL_GetNumDisplayModesForDisplay(display); ++i) {
current = &display->display_modes[i]; current = &display->display_modes[i];
if (current->w && (current->w < mode->w)) { if (current->pixel_w && (current->pixel_w < mode->pixel_w)) {
/* Out of sorted modes large enough here */ /* Out of sorted modes large enough here */
break; break;
} }
if (current->h && (current->h < mode->h)) { if (current->pixel_h && (current->pixel_h < mode->pixel_h)) {
if (current->w && (current->w == mode->w)) { if (current->pixel_w && (current->pixel_w == mode->pixel_w)) {
/* Out of sorted modes large enough here */ /* Out of sorted modes large enough here */
break; break;
} }
@ -971,7 +992,7 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
modes may still follow. */ modes may still follow. */
continue; continue;
} }
if (match == NULL || current->w < match->w || current->h < match->h) { if (match == NULL || current->pixel_w < match->pixel_w || current->pixel_h < match->pixel_h) {
match = current; match = current;
continue; continue;
} }
@ -993,35 +1014,29 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
continue; continue;
} }
} }
if (current->display_scale != match->display_scale) {
/* Sorted lowest display scale to highest */
if (current->display_scale <= target_display_scale) {
match = current;
continue;
}
}
} }
if (match) { if (match) {
SDL_zerop(closest);
if (match->format) { if (match->format) {
closest->format = match->format; closest->format = match->format;
} else { } else {
closest->format = mode->format; closest->format = mode->format;
} }
if (match->w && match->h) { if (match->screen_w && match->screen_h) {
closest->w = match->w; closest->screen_w = match->screen_w;
closest->h = match->h; closest->screen_h = match->screen_h;
} else { } else {
closest->w = mode->w; closest->screen_w = mode->screen_w;
closest->h = mode->h; closest->screen_h = mode->screen_h;
} }
if (match->display_scale > 0.0f) { if (match->pixel_w && match->pixel_h) {
closest->display_scale = match->display_scale; closest->pixel_w = match->pixel_w;
} else if (mode->display_scale > 0.0f) { closest->pixel_h = match->pixel_h;
closest->display_scale = mode->display_scale;
} else { } else {
closest->display_scale = 1.0f; closest->pixel_w = mode->pixel_w;
closest->pixel_h = mode->pixel_h;
} }
if (match->refresh_rate > 0.0f) { if (match->refresh_rate > 0.0f) {
closest->refresh_rate = match->refresh_rate; closest->refresh_rate = match->refresh_rate;
} else { } else {
@ -1029,19 +1044,17 @@ static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *di
} }
closest->driverdata = match->driverdata; closest->driverdata = match->driverdata;
/* /* Pick some reasonable defaults if the app and driver don't care */
* Pick some reasonable defaults if the app and driver don't
* care
*/
if (!closest->format) { if (!closest->format) {
closest->format = SDL_PIXELFORMAT_RGB888; closest->format = SDL_PIXELFORMAT_RGB888;
} }
if (!closest->w) { if (!closest->screen_w) {
closest->w = 640; closest->screen_w = 640;
} }
if (!closest->h) { if (!closest->screen_h) {
closest->h = 480; closest->screen_h = 480;
} }
SDL_FinalizeDisplayMode(closest);
return closest; return closest;
} }
return NULL; return NULL;
@ -1075,11 +1088,17 @@ static int SDL_SetDisplayModeForDisplay(SDL_VideoDisplay *display, const SDL_Dis
if (!display_mode.format) { if (!display_mode.format) {
display_mode.format = display->current_mode.format; display_mode.format = display->current_mode.format;
} }
if (!display_mode.w) { if (!display_mode.pixel_w) {
display_mode.w = display->current_mode.w; display_mode.pixel_w = display->current_mode.pixel_w;
} }
if (!display_mode.h) { if (!display_mode.pixel_h) {
display_mode.h = display->current_mode.h; display_mode.pixel_h = display->current_mode.pixel_h;
}
if (!display_mode.screen_w) {
display_mode.screen_w = display->current_mode.screen_w;
}
if (!display_mode.screen_h) {
display_mode.screen_h = display->current_mode.screen_h;
} }
if (display_mode.refresh_rate == 0.0f) { if (display_mode.refresh_rate == 0.0f) {
display_mode.refresh_rate = display->current_mode.refresh_rate; display_mode.refresh_rate = display->current_mode.refresh_rate;
@ -1087,7 +1106,9 @@ static int SDL_SetDisplayModeForDisplay(SDL_VideoDisplay *display, const SDL_Dis
/* Get a good video mode, the closest one possible */ /* Get a good video mode, the closest one possible */
if (!SDL_GetClosestDisplayModeForDisplay(display, &display_mode, &display_mode)) { if (!SDL_GetClosestDisplayModeForDisplay(display, &display_mode, &display_mode)) {
return SDL_SetError("No video mode large enough for %dx%d", display_mode.w, display_mode.h); return SDL_SetError("No video mode large enough for %dx%d (%dx%d)",
display_mode.pixel_w, display_mode.pixel_h,
display_mode.screen_w, display_mode.screen_h);
} }
} else { } else {
display_mode = display->desktop_mode; display_mode = display->desktop_mode;
@ -1284,11 +1305,11 @@ int SDL_SetWindowDisplayMode(SDL_Window *window, const SDL_DisplayMode *mode)
#ifndef __ANDROID__ #ifndef __ANDROID__
/* Android may not resize the window to exactly what our fullscreen mode is, especially on /* Android may not resize the window to exactly what our fullscreen mode is, especially on
* windowed Android environments like the Chromebook or Samsung DeX. Given this, we shouldn't * windowed Android environments like the Chromebook or Samsung DeX. Given this, we shouldn't
* use fullscreen_mode.w and fullscreen_mode.h, but rather get our current native size. As such, * use fullscreen_mode.screen_w and fullscreen_mode.screen_h, but rather get our current native size. As such,
* Android's SetWindowFullscreen will generate the window event for us with the proper final size. * Android's SetWindowFullscreen will generate the window event for us with the proper final size.
*/ */
SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, fullscreen_mode.w, fullscreen_mode.h); SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, fullscreen_mode.screen_w, fullscreen_mode.screen_h);
#endif #endif /* !__ANDROID__ */
} }
} }
} }
@ -1307,11 +1328,11 @@ int SDL_GetWindowDisplayMode(SDL_Window *window, SDL_DisplayMode *mode)
} }
fullscreen_mode = window->fullscreen_mode; fullscreen_mode = window->fullscreen_mode;
if (!fullscreen_mode.w) { if (!fullscreen_mode.screen_w) {
fullscreen_mode.w = window->windowed.w; fullscreen_mode.screen_w = window->windowed.w;
} }
if (!fullscreen_mode.h) { if (!fullscreen_mode.screen_h) {
fullscreen_mode.h = window->windowed.h; fullscreen_mode.screen_h = window->windowed.h;
} }
display = SDL_GetDisplayForWindow(window); display = SDL_GetDisplayForWindow(window);
@ -1469,7 +1490,7 @@ static int SDL_UpdateFullscreenMode(SDL_Window *window, SDL_bool fullscreen)
if (SDL_GetWindowDisplayMode(other, &fullscreen_mode) == 0) { if (SDL_GetWindowDisplayMode(other, &fullscreen_mode) == 0) {
SDL_bool resized = SDL_TRUE; SDL_bool resized = SDL_TRUE;
if (other->w == fullscreen_mode.w && other->h == fullscreen_mode.h) { if (other->w == fullscreen_mode.screen_w && other->h == fullscreen_mode.screen_h) {
resized = SDL_FALSE; resized = SDL_FALSE;
} }
@ -1501,11 +1522,8 @@ static int SDL_UpdateFullscreenMode(SDL_Window *window, SDL_bool fullscreen)
/* This is also unnecessary on Win32 (WIN_SetWindowFullscreen calls SetWindowPos, /* This is also unnecessary on Win32 (WIN_SetWindowFullscreen calls SetWindowPos,
* WM_WINDOWPOSCHANGED will send SDL_EVENT_WINDOW_RESIZED). * WM_WINDOWPOSCHANGED will send SDL_EVENT_WINDOW_RESIZED).
*/ */
/* The new fullscreen window size must be sent in screen coordinates, not pixels. */
SDL_SendWindowEvent(other, SDL_EVENT_WINDOW_RESIZED, SDL_SendWindowEvent(other, SDL_EVENT_WINDOW_RESIZED,
(int)(fullscreen_mode.w / fullscreen_mode.display_scale), fullscreen_mode.screen_w, fullscreen_mode.screen_h);
(int)(fullscreen_mode.h / fullscreen_mode.display_scale));
#endif #endif
} else { } else {
SDL_OnWindowResized(other); SDL_OnWindowResized(other);
@ -1745,15 +1763,15 @@ SDL_Window *SDL_CreateWindow(const char *title, int x, int y, int w, int h, Uint
if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP && (bounds.w != w || bounds.h != h)) { if ((flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != SDL_WINDOW_FULLSCREEN_DESKTOP && (bounds.w != w || bounds.h != h)) {
SDL_DisplayMode fullscreen_mode, closest_mode; SDL_DisplayMode fullscreen_mode, closest_mode;
SDL_zero(fullscreen_mode); SDL_zero(fullscreen_mode);
fullscreen_mode.w = w; fullscreen_mode.screen_w = w;
fullscreen_mode.h = h; fullscreen_mode.screen_h = h;
if (SDL_GetClosestDisplayModeForDisplay(display, &fullscreen_mode, &closest_mode) != NULL) { if (SDL_GetClosestDisplayModeForDisplay(display, &fullscreen_mode, &closest_mode) != NULL) {
bounds.w = closest_mode.w; bounds.w = closest_mode.screen_w;
bounds.h = closest_mode.h; bounds.h = closest_mode.screen_h;
} }
} }
window->fullscreen_mode.w = bounds.w; window->fullscreen_mode.screen_w = bounds.w;
window->fullscreen_mode.h = bounds.h; window->fullscreen_mode.screen_h = bounds.h;
window->x = bounds.x; window->x = bounds.x;
window->y = bounds.y; window->y = bounds.y;
window->w = bounds.w; window->w = bounds.w;
@ -2409,8 +2427,16 @@ void SDL_GetWindowSizeInPixels(SDL_Window *window, int *w, int *h)
if (display) if (display)
{ {
*w = (int)SDL_ceilf(*w * display->current_mode.display_scale); if (*w == display->current_mode.screen_w) {
*h = (int)SDL_ceilf(*h * display->current_mode.display_scale); *w = display->current_mode.pixel_w;
} else {
*w = (int)SDL_ceilf(*w * display->current_mode.display_scale);
}
if (*h == display->current_mode.screen_h) {
*h = display->current_mode.pixel_h;
} else {
*h = (int)SDL_ceilf(*h * display->current_mode.display_scale);
}
} }
} }
} }
@ -2999,8 +3025,8 @@ void SDL_OnWindowDisplayChanged(SDL_Window *window)
window->y = rect.y; window->y = rect.y;
window->w = rect.w; window->w = rect.w;
window->h = rect.h; window->h = rect.h;
window->fullscreen_mode.w = rect.w; window->fullscreen_mode.screen_w = rect.w;
window->fullscreen_mode.h = rect.h; window->fullscreen_mode.screen_h = rect.h;
if (_this->SetWindowSize) { if (_this->SetWindowSize) {
_this->SetWindowSize(_this, window); _this->SetWindowSize(_this, window);
} }

36
src/video/android/SDL_androidvideo.c
View File

@ -180,8 +180,8 @@ int Android_VideoInit(_THIS)
SDL_zero(mode); SDL_zero(mode);
mode.format = Android_ScreenFormat; mode.format = Android_ScreenFormat;
mode.w = Android_DeviceWidth; mode.pixel_w = Android_DeviceWidth;
mode.h = Android_DeviceHeight; mode.pixel_h = Android_DeviceHeight;
mode.display_scale = Android_ScreenDensity; mode.display_scale = Android_ScreenDensity;
mode.refresh_rate = Android_ScreenRate; mode.refresh_rate = Android_ScreenRate;
mode.driverdata = NULL; mode.driverdata = NULL;
@ -276,11 +276,15 @@ void Android_SendResize(SDL_Window *window)
SDL_VideoDevice *device = SDL_GetVideoDevice(); SDL_VideoDevice *device = SDL_GetVideoDevice();
if (device && device->num_displays > 0) { if (device && device->num_displays > 0) {
SDL_VideoDisplay *display = &device->displays[0]; SDL_VideoDisplay *display = &device->displays[0];
display->desktop_mode.format = Android_ScreenFormat; SDL_DisplayMode desktop_mode;
display->desktop_mode.w = Android_DeviceWidth;
display->desktop_mode.h = Android_DeviceHeight; SDL_zero(desktop_mode);
display->desktop_mode.display_scale = Android_ScreenDensity; desktop_mode.format = Android_ScreenFormat;
display->desktop_mode.refresh_rate = Android_ScreenRate; desktop_mode.pixel_w = Android_DeviceWidth;
desktop_mode.pixel_h = Android_DeviceHeight;
desktop_mode.display_scale = Android_ScreenDensity;
desktop_mode.refresh_rate = Android_ScreenRate;
SDL_SetDesktopDisplayMode(display, &desktop_mode);
} }
if (window) { if (window) {
@ -288,15 +292,17 @@ void Android_SendResize(SDL_Window *window)
* will fall back to the old mode */ * will fall back to the old mode */
int w, h; int w, h;
SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
display->display_modes[0].format = Android_ScreenFormat; SDL_DisplayMode current_mode;
display->display_modes[0].w = Android_DeviceWidth;
display->display_modes[0].h = Android_DeviceHeight;
display->display_modes[0].display_scale = Android_ScreenDensity;
display->display_modes[0].refresh_rate = Android_ScreenRate;
display->current_mode = display->display_modes[0];
w = (int)SDL_ceilf(Android_SurfaceWidth / Android_ScreenDensity); current_mode.format = Android_ScreenFormat;
h = (int)SDL_ceilf(Android_SurfaceHeight / Android_ScreenDensity); current_mode.pixel_w = Android_DeviceWidth;
current_mode.pixel_h = Android_DeviceHeight;
current_mode.display_scale = Android_ScreenDensity;
current_mode.refresh_rate = Android_ScreenRate;
SDL_SetCurrentDisplayMode(display, &current_mode);
w = (int)SDL_floorf(Android_SurfaceWidth / Android_ScreenDensity);
h = (int)SDL_floorf(Android_SurfaceHeight / Android_ScreenDensity);
SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, w, h); SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, w, h);
} }
} }

29
src/video/cocoa/SDL_cocoamodes.m
View File

@ -143,10 +143,10 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode
{ {
SDL_DisplayModeData *data; SDL_DisplayModeData *data;
bool usableForGUI = CGDisplayModeIsUsableForDesktopGUI(vidmode); bool usableForGUI = CGDisplayModeIsUsableForDesktopGUI(vidmode);
int width = (int)CGDisplayModeGetWidth(vidmode); size_t width = CGDisplayModeGetWidth(vidmode);
int height = (int)CGDisplayModeGetHeight(vidmode); size_t height = CGDisplayModeGetHeight(vidmode);
int pixelW = width; size_t pixelW = width;
int pixelH = height; size_t pixelH = height;
uint32_t ioflags = CGDisplayModeGetIOFlags(vidmode); uint32_t ioflags = CGDisplayModeGetIOFlags(vidmode);
float refreshrate = GetDisplayModeRefreshRate(vidmode, link); float refreshrate = GetDisplayModeRefreshRate(vidmode, link);
Uint32 format = GetDisplayModePixelFormat(vidmode); Uint32 format = GetDisplayModePixelFormat(vidmode);
@ -173,15 +173,15 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode
* modes to try (see comment below for why that's necessary). * modes to try (see comment below for why that's necessary).
* CGDisplayModeGetPixelWidth and friends are only available in 10.8+. */ * CGDisplayModeGetPixelWidth and friends are only available in 10.8+. */
#ifdef MAC_OS_X_VERSION_10_8 #ifdef MAC_OS_X_VERSION_10_8
pixelW = (int)CGDisplayModeGetPixelWidth(vidmode); pixelW = CGDisplayModeGetPixelWidth(vidmode);
pixelH = (int)CGDisplayModeGetPixelHeight(vidmode); pixelH = CGDisplayModeGetPixelHeight(vidmode);
if (modelist != NULL && floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_7) { if (modelist != NULL && floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_7) {
CFIndex modescount = CFArrayGetCount(modelist); CFIndex modescount = CFArrayGetCount(modelist);
int i; int i;
for (i = 0; i < modescount; i++) { for (i = 0; i < modescount; i++) {
int otherW, otherH, otherpixelW, otherpixelH; size_t otherW, otherH, otherpixelW, otherpixelH;
float otherrefresh; float otherrefresh;
Uint32 otherformat; Uint32 otherformat;
bool otherGUI; bool otherGUI;
@ -196,10 +196,10 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode
continue; continue;
} }
otherW = (int)CGDisplayModeGetWidth(othermode); otherW = CGDisplayModeGetWidth(othermode);
otherH = (int)CGDisplayModeGetHeight(othermode); otherH = CGDisplayModeGetHeight(othermode);
otherpixelW = (int)CGDisplayModeGetPixelWidth(othermode); otherpixelW = CGDisplayModeGetPixelWidth(othermode);
otherpixelH = (int)CGDisplayModeGetPixelHeight(othermode); otherpixelH = CGDisplayModeGetPixelHeight(othermode);
otherrefresh = GetDisplayModeRefreshRate(othermode, link); otherrefresh = GetDisplayModeRefreshRate(othermode, link);
otherformat = GetDisplayModePixelFormat(othermode); otherformat = GetDisplayModePixelFormat(othermode);
otherGUI = CGDisplayModeIsUsableForDesktopGUI(othermode); otherGUI = CGDisplayModeIsUsableForDesktopGUI(othermode);
@ -264,9 +264,10 @@ static SDL_bool GetDisplayMode(_THIS, CGDisplayModeRef vidmode, SDL_bool vidmode
} }
data->modes = modes; data->modes = modes;
mode->format = format; mode->format = format;
mode->w = pixelW; mode->pixel_w = (int)pixelW;
mode->h = pixelH; mode->pixel_h = (int)pixelH;
mode->display_scale = (float)pixelW / width; mode->screen_w = (int)width;
mode->screen_h = (int)height;
mode->refresh_rate = refreshrate; mode->refresh_rate = refreshrate;
mode->driverdata = data; mode->driverdata = data;
return SDL_TRUE; return SDL_TRUE;

4
src/video/dummy/SDL_nullvideo.c
View File

@ -144,8 +144,8 @@ int DUMMY_VideoInit(_THIS)
/* Use a fake 32-bpp desktop mode */ /* Use a fake 32-bpp desktop mode */
SDL_zero(mode); SDL_zero(mode);
mode.format = SDL_PIXELFORMAT_RGB888; mode.format = SDL_PIXELFORMAT_RGB888;
mode.w = 1024; mode.pixel_w = 1024;
mode.h = 768; mode.pixel_h = 768;
if (SDL_AddBasicVideoDisplay(&mode) < 0) { if (SDL_AddBasicVideoDisplay(&mode) < 0) {
return -1; return -1;
} }

3
src/video/emscripten/SDL_emscriptenvideo.c
View File

@ -129,7 +129,8 @@ int Emscripten_VideoInit(_THIS)
/* Use a fake 32-bpp desktop mode */ /* Use a fake 32-bpp desktop mode */
SDL_zero(mode); SDL_zero(mode);
mode.format = SDL_PIXELFORMAT_RGB888; mode.format = SDL_PIXELFORMAT_RGB888;
emscripten_get_screen_size(&mode.w, &mode.h); emscripten_get_screen_size(&mode.screen_w, &mode.screen_h);
mode.display_scale = emscripten_get_device_pixel_ratio();
if (SDL_AddBasicVideoDisplay(&mode) < 0) { if (SDL_AddBasicVideoDisplay(&mode) < 0) {
return -1; return -1;

40
src/video/haiku/SDL_bmodes.cc
View File

@ -78,7 +78,7 @@ static float get_refresh_rate(display_mode &mode) {
void _SpoutModeData(display_mode *bmode) { void _SpoutModeData(display_mode *bmode) {
printf("BMode:\n"); printf("BMode:\n");
printf("\tw,h = (%i,%i)\n", bmode->virtual_width, bmode->virtual_height); printf("\tw,h = (%i,%i)\n", bmode->virtual_width, bmode->virtual_height);
printf("\th,v = (%i,%i)\n", bmode->h_display_start, printf("\th,v = (%i,%i)\n", bmode->h_display_start,
bmode->v_display_start); bmode->v_display_start);
if (bmode->flags) { if (bmode->flags) {
printf("\tFlags:\n"); printf("\tFlags:\n");
@ -162,25 +162,23 @@ int32 HAIKU_ColorSpaceToSDLPxFormat(uint32 colorspace)
/* May never get here, but safer and needed to shut up compiler */ /* May never get here, but safer and needed to shut up compiler */
SDL_SetError("Invalid color space"); SDL_SetError("Invalid color space");
return 0; return 0;
} }
static void _BDisplayModeToSdlDisplayMode(display_mode *bmode, static void _BDisplayModeToSdlDisplayMode(display_mode *bmode, SDL_DisplayMode *mode) {
SDL_DisplayMode *mode) {
SDL_zerop(mode); SDL_zerop(mode);
mode->w = bmode->virtual_width; mode->pixel_w = bmode->virtual_width;
mode->h = bmode->virtual_height; mode->pixel_h = bmode->virtual_height;
mode->refresh_rate = get_refresh_rate(*bmode); mode->refresh_rate = get_refresh_rate(*bmode);
#if WRAP_BMODE #if WRAP_BMODE
SDL_DisplayModeData *data = (SDL_DisplayModeData*)SDL_calloc(1, SDL_DisplayModeData *data = (SDL_DisplayModeData*)SDL_calloc(1,
sizeof(SDL_DisplayModeData)); sizeof(SDL_DisplayModeData));
data->bmode = bmode; data->bmode = bmode;
mode->driverdata = data; mode->driverdata = data;
#else #else
mode->driverdata = bmode; mode->driverdata = bmode;
#endif #endif
@ -190,19 +188,13 @@ static void _BDisplayModeToSdlDisplayMode(display_mode *bmode,
/* Later, there may be more than one monitor available */ /* Later, there may be more than one monitor available */
static void _AddDisplay(BScreen *screen) { static void _AddDisplay(BScreen *screen) {
SDL_VideoDisplay display; SDL_DisplayMode mode;
SDL_DisplayMode *mode = (SDL_DisplayMode*)SDL_calloc(1, display_mode bmode;
sizeof(SDL_DisplayMode)); screen->GetMode(&bmode);
display_mode *bmode = (display_mode*)SDL_calloc(1, sizeof(display_mode));
screen->GetMode(bmode);
_BDisplayModeToSdlDisplayMode(bmode, mode); _BDisplayModeToSdlDisplayMode(&bmode, &mode);
SDL_zero(display); SDL_AddBasicVideoDisplay(&mode);
display.desktop_mode = *mode;
display.current_mode = *mode;
SDL_AddVideoDisplay(&display, SDL_FALSE);
} }
/* /*
@ -243,11 +235,11 @@ void HAIKU_GetDisplayModes(_THIS, SDL_VideoDisplay *display) {
display_mode this_bmode; display_mode this_bmode;
display_mode *bmodes; display_mode *bmodes;
uint32 count, i; uint32 count, i;
/* Get graphics-hardware supported modes */ /* Get graphics-hardware supported modes */
bscreen.GetModeList(&bmodes, &count); bscreen.GetModeList(&bmodes, &count);
bscreen.GetMode(&this_bmode); bscreen.GetMode(&this_bmode);
for (i = 0; i < count; ++i) { for (i = 0; i < count; ++i) {
// FIXME: Apparently there are errors with colorspace changes // FIXME: Apparently there are errors with colorspace changes
if (bmodes[i].space == this_bmode.space) { if (bmodes[i].space == this_bmode.space) {
@ -286,9 +278,9 @@ int HAIKU_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode
if (bscreen.SetMode(bmode) != B_OK) { if (bscreen.SetMode(bmode) != B_OK) {
return SDL_SetError("Bad video mode"); return SDL_SetError("Bad video mode");
} }
free(bmode_list); /* This should not be SDL_free() */ free(bmode_list); /* This should not be SDL_free() */
#if SDL_VIDEO_OPENGL #if SDL_VIDEO_OPENGL
/* FIXME: Is there some way to reboot the OpenGL context? This doesn't /* FIXME: Is there some way to reboot the OpenGL context? This doesn't
help */ help */

24
src/video/kmsdrm/SDL_kmsdrmvideo.c
View File

@ -501,11 +501,10 @@ static drmModeModeInfo *KMSDRM_GetClosestDisplayMode(SDL_VideoDisplay *display,
SDL_DisplayMode target, closest; SDL_DisplayMode target, closest;
drmModeModeInfo *drm_mode; drmModeModeInfo *drm_mode;
target.w = width; SDL_zero(target);
target.h = height; target.pixel_w = (int)width;
target.format = 0; /* Will use the default mode format. */ target.pixel_h = (int)height;
target.refresh_rate = refresh_rate; target.refresh_rate = (int)refresh_rate;
target.driverdata = 0; /* Initialize to 0 */
if (!SDL_GetClosestDisplayMode(SDL_atoi(display->name), &target, &closest)) { if (!SDL_GetClosestDisplayMode(SDL_atoi(display->name), &target, &closest)) {
return NULL; return NULL;
@ -871,8 +870,8 @@ static void KMSDRM_AddDisplay(_THIS, drmModeConnector *connector, drmModeRes *re
modedata->mode_index = mode_index; modedata->mode_index = mode_index;
display.driverdata = dispdata; display.driverdata = dispdata;
display.desktop_mode.w = dispdata->mode.hdisplay; display.desktop_mode.pixel_w = dispdata->mode.hdisplay;
display.desktop_mode.h = dispdata->mode.vdisplay; display.desktop_mode.pixel_h = dispdata->mode.vdisplay;
display.desktop_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode); display.desktop_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode);
display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888; display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888;
display.desktop_mode.driverdata = modedata; display.desktop_mode.driverdata = modedata;
@ -1158,6 +1157,7 @@ int KMSDRM_CreateSurfaces(_THIS, SDL_Window *window)
SDL_WindowData *windata = (SDL_WindowData *)window->driverdata; SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata; SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
SDL_DisplayMode current_mode;
uint32_t surface_fmt = GBM_FORMAT_ARGB8888; uint32_t surface_fmt = GBM_FORMAT_ARGB8888;
uint32_t surface_flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING; uint32_t surface_flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;
@ -1182,10 +1182,12 @@ int KMSDRM_CreateSurfaces(_THIS, SDL_Window *window)
mode that's set in sync with what SDL_video.c thinks is set */ mode that's set in sync with what SDL_video.c thinks is set */
KMSDRM_GetModeToSet(window, &dispdata->mode); KMSDRM_GetModeToSet(window, &dispdata->mode);
display->current_mode.w = dispdata->mode.hdisplay; SDL_zero(current_mode);
display->current_mode.h = dispdata->mode.vdisplay; current_mode.pixel_w = dispdata->mode.hdisplay;
display->current_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode); current_mode.pixel_h = dispdata->mode.vdisplay;
display->current_mode.format = SDL_PIXELFORMAT_ARGB8888; current_mode.refresh_rate = CalculateRefreshRate(&dispdata->mode);
current_mode.format = SDL_PIXELFORMAT_ARGB8888;
SDL_SetCurrentDisplayMode(display, &current_mode);
windata->gs = KMSDRM_gbm_surface_create(viddata->gbm_dev, windata->gs = KMSDRM_gbm_surface_create(viddata->gbm_dev,
dispdata->mode.hdisplay, dispdata->mode.vdisplay, dispdata->mode.hdisplay, dispdata->mode.vdisplay,

8
src/video/n3ds/SDL_n3dsvideo.c
View File

@ -118,8 +118,8 @@ AddN3DSDisplay(gfxScreen_t screen)
display_driver_data->screen = screen; display_driver_data->screen = screen;
mode.w = (screen == GFX_TOP) ? GSP_SCREEN_HEIGHT_TOP : GSP_SCREEN_HEIGHT_BOTTOM; mode.pixel_w = (screen == GFX_TOP) ? GSP_SCREEN_HEIGHT_TOP : GSP_SCREEN_HEIGHT_BOTTOM;
mode.h = GSP_SCREEN_WIDTH; mode.pixel_h = GSP_SCREEN_WIDTH;
mode.refresh_rate = 60.0f; mode.refresh_rate = 60.0f;
mode.format = FRAMEBUFFER_FORMAT; mode.format = FRAMEBUFFER_FORMAT;
@ -154,8 +154,8 @@ static int N3DS_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect *rec
} }
rect->x = 0; rect->x = 0;
rect->y = (driver_data->screen == GFX_TOP) ? 0 : GSP_SCREEN_WIDTH; rect->y = (driver_data->screen == GFX_TOP) ? 0 : GSP_SCREEN_WIDTH;
rect->w = display->current_mode.w; rect->w = display->current_mode.screen_w;
rect->h = display->current_mode.h; rect->h = display->current_mode.screen_h;
return 0; return 0;
} }

4
src/video/ngage/SDL_ngagevideo.cpp
View File

@ -150,8 +150,8 @@ int NGAGE_VideoInit(_THIS)
/* Use 12-bpp desktop mode */ /* Use 12-bpp desktop mode */
SDL_zero(mode); SDL_zero(mode);
mode.format = SDL_PIXELFORMAT_RGB444; mode.format = SDL_PIXELFORMAT_RGB444;
mode.w = 176; mode.pixel_w = 176;
mode.h = 208; mode.pixel_h = 208;
if (SDL_AddBasicVideoDisplay(&mode) < 0) { if (SDL_AddBasicVideoDisplay(&mode) < 0) {
return -1; return -1;
} }

4
src/video/offscreen/SDL_offscreenvideo.c
View File

@ -103,8 +103,8 @@ int OFFSCREEN_VideoInit(_THIS)
/* Use a fake 32-bpp desktop mode */ /* Use a fake 32-bpp desktop mode */
SDL_zero(mode); SDL_zero(mode);
mode.format = SDL_PIXELFORMAT_RGB888; mode.format = SDL_PIXELFORMAT_RGB888;
mode.w = 1024; mode.pixel_w = 1024;
mode.h = 768; mode.pixel_h = 768;
if (SDL_AddBasicVideoDisplay(&mode) < 0) { if (SDL_AddBasicVideoDisplay(&mode) < 0) {
return -1; return -1;
} }

20
src/video/ps2/SDL_ps2video.c
View File

@ -65,23 +65,17 @@ static int PS2_CreateWindow(_THIS, SDL_Window *window)
static int PS2_VideoInit(_THIS) static int PS2_VideoInit(_THIS)
{ {
SDL_VideoDisplay display; SDL_DisplayMode mode;
SDL_DisplayMode current_mode;
SDL_zero(current_mode); SDL_zero(mode);
current_mode.w = 640; mode.pixel_w = 640;
current_mode.h = 480; mode.pixel_h = 480;
current_mode.refresh_rate = 60.0f; mode.refresh_rate = 60.0f;
/* 32 bpp for default */ /* 32 bpp for default */
current_mode.format = SDL_PIXELFORMAT_ABGR8888; mode.format = SDL_PIXELFORMAT_ABGR8888;
SDL_zero(display); SDL_AddBasicVideoDisplay(&mode);
display.desktop_mode = current_mode;
display.current_mode = current_mode;
SDL_AddDisplayMode(&display, &current_mode);
SDL_AddVideoDisplay(&display, SDL_FALSE);
return 1; return 1;
} }

25
src/video/psp/SDL_pspvideo.c
View File

@ -137,29 +137,28 @@ VideoBootStrap PSP_bootstrap = {
int PSP_VideoInit(_THIS) int PSP_VideoInit(_THIS)
{ {
SDL_VideoDisplay display; SDL_VideoDisplay display;
SDL_DisplayMode current_mode; SDL_DisplayMode mode;
SDL_zero(current_mode); SDL_zero(mode);
current_mode.w = 480; mode.pixel_w = 480;
current_mode.h = 272; mode.pixel_h = 272;
current_mode.refresh_rate = 60.0f; mode.refresh_rate = 60.0f;
/* 32 bpp for default */ /* 32 bpp for default */
current_mode.format = SDL_PIXELFORMAT_ABGR8888; mode.format = SDL_PIXELFORMAT_ABGR8888;
SDL_zero(display); SDL_zero(display);
display.desktop_mode = current_mode; display.desktop_mode = mode;
display.current_mode = current_mode; display.current_mode = mode;
SDL_AddDisplayMode(&display, &current_mode); SDL_AddDisplayMode(&display, &mode);
/* 16 bpp secondary mode */ /* 16 bpp secondary mode */
current_mode.format = SDL_PIXELFORMAT_BGR565; mode.format = SDL_PIXELFORMAT_BGR565;
display.desktop_mode = current_mode; SDL_AddDisplayMode(&display, &mode);
display.current_mode = current_mode;
SDL_AddDisplayMode(&display, &current_mode);
SDL_AddVideoDisplay(&display, SDL_FALSE); SDL_AddVideoDisplay(&display, SDL_FALSE);
return 1; return 1;
} }

16
src/video/raspberry/SDL_rpivideo.c
View File

@ -148,7 +148,7 @@ static void AddDispManXDisplay(const int display_id)
DISPMANX_MODEINFO_T modeinfo; DISPMANX_MODEINFO_T modeinfo;
DISPMANX_DISPLAY_HANDLE_T handle; DISPMANX_DISPLAY_HANDLE_T handle;
SDL_VideoDisplay display; SDL_VideoDisplay display;
SDL_DisplayMode current_mode; SDL_DisplayMode mode;
SDL_DisplayData *data; SDL_DisplayData *data;
handle = vc_dispmanx_display_open(display_id); handle = vc_dispmanx_display_open(display_id);
@ -162,17 +162,17 @@ static void AddDispManXDisplay(const int display_id)
} }
/* RPI_GetRefreshRate() doesn't distinguish between displays. I'm not sure the hardware distinguishes either */ /* RPI_GetRefreshRate() doesn't distinguish between displays. I'm not sure the hardware distinguishes either */
SDL_zero(current_mode); SDL_zero(mode);
current_mode.w = modeinfo.width; mode.pixel_w = modeinfo.width;
current_mode.h = modeinfo.height; mode.pixel_h = modeinfo.height;
current_mode.refresh_rate = RPI_GetRefreshRate(); mode.refresh_rate = RPI_GetRefreshRate();
/* 32 bpp for default */ /* 32 bpp for default */
current_mode.format = SDL_PIXELFORMAT_ABGR8888; mode.format = SDL_PIXELFORMAT_ABGR8888;
SDL_zero(display); SDL_zero(display);
display.desktop_mode = current_mode; display.desktop_mode = mode;
display.current_mode = current_mode; display.current_mode = mode;
/* Allocate display internal data */ /* Allocate display internal data */
data = (SDL_DisplayData *)SDL_calloc(1, sizeof(SDL_DisplayData)); data = (SDL_DisplayData *)SDL_calloc(1, sizeof(SDL_DisplayData));

4
src/video/riscos/SDL_riscosmodes.c
View File

@ -137,8 +137,8 @@ static SDL_bool read_mode_block(int *block, SDL_DisplayMode *mode, SDL_bool exte
} }
SDL_zerop(mode); SDL_zerop(mode);
mode->w = xres; mode->pixel_w = xres;
mode->h = yres; mode->pixel_h = yres;
mode->format = RISCOS_ModeToPixelFormat(ncolour, modeflags, log2bpp); mode->format = RISCOS_ModeToPixelFormat(ncolour, modeflags, log2bpp);
mode->refresh_rate = (float)rate; mode->refresh_rate = (float)rate;

34
src/video/uikit/SDL_uikitmodes.m
View File

@ -269,8 +269,8 @@ static int UIKit_AddSingleDisplayMode(SDL_VideoDisplay *display, int w, int h,
return -1; return -1;
} }
mode.w = w; mode.pixel_w = w;
mode.h = h; mode.pixel_h = h;
mode.display_scale = uiscreen.scale; mode.display_scale = uiscreen.scale;
mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen); mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen);
mode.format = SDL_PIXELFORMAT_ABGR8888; mode.format = SDL_PIXELFORMAT_ABGR8888;
@ -315,8 +315,8 @@ int UIKit_AddDisplay(UIScreen *uiscreen, SDL_bool send_event)
} }
SDL_zero(mode); SDL_zero(mode);
mode.w = (int)size.width; mode.pixel_w = (int)size.width;
mode.h = (int)size.height; mode.pixel_h = (int)size.height;
mode.display_scale = uiscreen.scale; mode.display_scale = uiscreen.scale;
mode.format = SDL_PIXELFORMAT_ABGR8888; mode.format = SDL_PIXELFORMAT_ABGR8888;
mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen); mode.refresh_rate = UIKit_GetDisplayModeRefreshRate(uiscreen);
@ -455,11 +455,11 @@ int UIKit_SetDisplayMode(_THIS, SDL_VideoDisplay *display, SDL_DisplayMode *mode
/* [UIApplication setStatusBarOrientation:] no longer works reliably /* [UIApplication setStatusBarOrientation:] no longer works reliably
* in recent iOS versions, so we can't rotate the screen when setting * in recent iOS versions, so we can't rotate the screen when setting
* the display mode. */ * the display mode. */
if (mode->w > mode->h) { if (mode->pixel_w > mode->pixel_h) {
if (!UIKit_IsDisplayLandscape(data.uiscreen)) { if (!UIKit_IsDisplayLandscape(data.uiscreen)) {
return SDL_SetError("Screen orientation does not match display mode size"); return SDL_SetError("Screen orientation does not match display mode size");
} }
} else if (mode->w < mode->h) { } else if (mode->pixel_w < mode->pixel_h) {
if (UIKit_IsDisplayLandscape(data.uiscreen)) { if (UIKit_IsDisplayLandscape(data.uiscreen)) {
return SDL_SetError("Screen orientation does not match display mode size"); return SDL_SetError("Screen orientation does not match display mode size");
} }
@ -531,17 +531,23 @@ void SDL_OnApplicationDidChangeStatusBarOrientation()
* orientation so that updating a window's fullscreen state to * orientation so that updating a window's fullscreen state to
* SDL_WINDOW_FULLSCREEN_DESKTOP keeps the window dimensions in the * SDL_WINDOW_FULLSCREEN_DESKTOP keeps the window dimensions in the
* correct orientation. */ * correct orientation. */
if (isLandscape != (desktopmode->w > desktopmode->h)) { if (isLandscape != (desktopmode->pixel_w > desktopmode->pixel_h)) {
int height = desktopmode->w; int height = desktopmode->pixel_w;
desktopmode->w = desktopmode->h; desktopmode->pixel_w = desktopmode->pixel_h;
desktopmode->h = height; desktopmode->pixel_h = height;
height = desktopmode->screen_w;
desktopmode->screen_w = desktopmode->screen_h;
desktopmode->screen_h = height;
} }
/* Same deal with the current mode + SDL_GetCurrentDisplayMode. */ /* Same deal with the current mode + SDL_GetCurrentDisplayMode. */
if (isLandscape != (currentmode->w > currentmode->h)) { if (isLandscape != (currentmode->pixel_w > currentmode->pixel_h)) {
int height = currentmode->w; int height = currentmode->pixel_w;
currentmode->w = currentmode->h; currentmode->pixel_w = currentmode->pixel_h;
currentmode->h = height; currentmode->pixel_h = height;
height = currentmode->screen_w;
currentmode->screen_w = currentmode->screen_h;
currentmode->screen_h = height;
} }
switch ([UIApplication sharedApplication].statusBarOrientation) { switch ([UIApplication sharedApplication].statusBarOrientation) {

2
src/video/uikit/SDL_uikitwindow.m
View File

@ -177,7 +177,7 @@ int UIKit_CreateWindow(_THIS, SDL_Window *window)
const SDL_DisplayMode *bestmode = NULL; const SDL_DisplayMode *bestmode = NULL;
for (i = display->num_display_modes; i >= 0; i--) { for (i = display->num_display_modes; i >= 0; i--) {
const SDL_DisplayMode *mode = &display->display_modes[i]; const SDL_DisplayMode *mode = &display->display_modes[i];
if ((mode->w >= window->w) && (mode->h >= window->h)) { if ((mode->screen_w >= window->w) && (mode->screen_h >= window->h)) {
bestmode = mode; bestmode = mode;
} }
} }

26
src/video/vita/SDL_vitavideo.c
View File

@ -180,45 +180,41 @@ VideoBootStrap VITA_bootstrap = {
/*****************************************************************************/ /*****************************************************************************/
int VITA_VideoInit(_THIS) int VITA_VideoInit(_THIS)
{ {
SDL_VideoDisplay display; SDL_DisplayMode mode;
SDL_DisplayMode current_mode;
#if defined(SDL_VIDEO_VITA_PVR) #if defined(SDL_VIDEO_VITA_PVR)
char *res = SDL_getenv("VITA_RESOLUTION"); char *res = SDL_getenv("VITA_RESOLUTION");
#endif #endif
SDL_zero(current_mode); SDL_zero(mode);
#if defined(SDL_VIDEO_VITA_PVR) #if defined(SDL_VIDEO_VITA_PVR)
if (res) { if (res) {
/* 1088i for PSTV (Or Sharpscale) */ /* 1088i for PSTV (Or Sharpscale) */
if (!SDL_strncmp(res, "1080", 4)) { if (!SDL_strncmp(res, "1080", 4)) {
current_mode.w = 1920; mode.pixel_w = 1920;
current_mode.h = 1088; mode.pixel_h = 1088;
} }
/* 725p for PSTV (Or Sharpscale) */ /* 725p for PSTV (Or Sharpscale) */
else if (!SDL_strncmp(res, "720", 3)) { else if (!SDL_strncmp(res, "720", 3)) {
current_mode.w = 1280; mode.pixel_w = 1280;
current_mode.h = 725; mode.pixel_h = 725;
} }
} }
/* 544p */ /* 544p */
else { else {
#endif #endif
current_mode.w = 960; mode.pixel_w = 960;
current_mode.h = 544; mode.pixel_h = 544;
#if defined(SDL_VIDEO_VITA_PVR) #if defined(SDL_VIDEO_VITA_PVR)
} }
#endif #endif
current_mode.refresh_rate = 60.0f; mode.refresh_rate = 60.0f;
/* 32 bpp for default */ /* 32 bpp for default */
current_mode.format = SDL_PIXELFORMAT_ABGR8888; mode.format = SDL_PIXELFORMAT_ABGR8888;
SDL_zero(display); SDL_AddBasicVideoDisplay(&mode);
display.desktop_mode = current_mode;
display.current_mode = current_mode;
SDL_AddVideoDisplay(&display, SDL_FALSE);
VITA_InitTouch(); VITA_InitTouch();
VITA_InitKeyboard(); VITA_InitKeyboard();
VITA_InitMouse(); VITA_InitMouse();

18
src/video/vivante/SDL_vivantevideo.c
View File

@ -125,7 +125,7 @@ static int VIVANTE_AddVideoDisplays(_THIS)
{ {
SDL_VideoData *videodata = _this->driverdata; SDL_VideoData *videodata = _this->driverdata;
SDL_VideoDisplay display; SDL_VideoDisplay display;
SDL_DisplayMode current_mode; SDL_DisplayMode mode;
SDL_DisplayData *data; SDL_DisplayData *data;
int pitch = 0, bpp = 0; int pitch = 0, bpp = 0;
unsigned long pixels = 0; unsigned long pixels = 0;
@ -135,33 +135,33 @@ static int VIVANTE_AddVideoDisplays(_THIS)
return SDL_OutOfMemory(); return SDL_OutOfMemory();
} }
SDL_zero(current_mode); SDL_zero(mode);
#if SDL_VIDEO_DRIVER_VIVANTE_VDK #if SDL_VIDEO_DRIVER_VIVANTE_VDK
data->native_display = vdkGetDisplay(videodata->vdk_private); data->native_display = vdkGetDisplay(videodata->vdk_private);
vdkGetDisplayInfo(data->native_display, &current_mode.w, &current_mode.h, &pixels, &pitch, &bpp); vdkGetDisplayInfo(data->native_display, &mode.pixel_w, &mode.pixel_h, &pixels, &pitch, &bpp);
#else #else
data->native_display = videodata->fbGetDisplayByIndex(0); data->native_display = videodata->fbGetDisplayByIndex(0);
videodata->fbGetDisplayInfo(data->native_display, &current_mode.w, &current_mode.h, &pixels, &pitch, &bpp); videodata->fbGetDisplayInfo(data->native_display, &mode.pixel_w, &mode.pixel_h, &pixels, &pitch, &bpp);
#endif /* SDL_VIDEO_DRIVER_VIVANTE_VDK */ #endif /* SDL_VIDEO_DRIVER_VIVANTE_VDK */
switch (bpp) { switch (bpp) {
default: /* Is another format used? */ default: /* Is another format used? */
case 32: case 32:
current_mode.format = SDL_PIXELFORMAT_ARGB8888; mode.format = SDL_PIXELFORMAT_ARGB8888;
break; break;
case 16: case 16:
current_mode.format = SDL_PIXELFORMAT_RGB565; mode.format = SDL_PIXELFORMAT_RGB565;
break; break;
} }
/* FIXME: How do we query refresh rate? */ /* FIXME: How do we query refresh rate? */
current_mode.refresh_rate = 60.0f; mode.refresh_rate = 60.0f;
SDL_zero(display); SDL_zero(display);
display.name = VIVANTE_GetDisplayName(_this); display.name = VIVANTE_GetDisplayName(_this);
display.desktop_mode = current_mode; display.desktop_mode = mode;
display.current_mode = current_mode; display.current_mode = mode;
display.driverdata = data; display.driverdata = data;
SDL_AddVideoDisplay(&display, SDL_FALSE); SDL_AddVideoDisplay(&display, SDL_FALSE);
return 0; return 0;

34
src/video/wayland/SDL_waylandvideo.c
View File

@ -422,17 +422,17 @@ static void AddEmulatedModes(SDL_VideoDisplay *dpy, SDL_bool rot_90)
mode.display_scale = 1.0f; mode.display_scale = 1.0f;
if (rot_90) { if (rot_90) {
mode.w = mode_list[i].h; mode.pixel_w = mode_list[i].h;
mode.h = mode_list[i].w; mode.pixel_h = mode_list[i].w;
} else { } else {
mode.w = mode_list[i].w; mode.pixel_w = mode_list[i].w;
mode.h = mode_list[i].h; mode.pixel_h = mode_list[i].h;
} }
/* Only add modes that are smaller than the native mode. */ /* Only add modes that are smaller than the native mode. */
if ((mode.w < native_width && mode.h < native_height) || if ((mode.pixel_w < native_width && mode.pixel_h < native_height) ||
(mode.w < native_width && mode.h == native_height) || (mode.pixel_w < native_width && mode.pixel_h == native_height) ||
(mode.w == native_width && mode.h < native_height)) { (mode.pixel_w == native_width && mode.pixel_h < native_height)) {
SDL_AddDisplayMode(dpy, &mode); SDL_AddDisplayMode(dpy, &mode);
} }
} }
@ -565,11 +565,11 @@ static void display_handle_done(void *data,
native_mode.format = SDL_PIXELFORMAT_RGB888; native_mode.format = SDL_PIXELFORMAT_RGB888;
if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) { if (driverdata->transform & WL_OUTPUT_TRANSFORM_90) {
native_mode.w = driverdata->native_height; native_mode.pixel_w = driverdata->native_height;
native_mode.h = driverdata->native_width; native_mode.pixel_h = driverdata->native_width;
} else { } else {
native_mode.w = driverdata->native_width; native_mode.pixel_w = driverdata->native_width;
native_mode.h = driverdata->native_height; native_mode.pixel_h = driverdata->native_height;
} }
native_mode.display_scale = 1.0f; native_mode.display_scale = 1.0f;
native_mode.refresh_rate = ((100 * driverdata->refresh) / 1000) / 100.0f; /* mHz to Hz */ native_mode.refresh_rate = ((100 * driverdata->refresh) / 1000) / 100.0f; /* mHz to Hz */
@ -590,11 +590,11 @@ static void display_handle_done(void *data,
/* xdg-output dimensions are already transformed, so no need to rotate. */ /* xdg-output dimensions are already transformed, so no need to rotate. */
if (driverdata->has_logical_size || !(driverdata->transform & WL_OUTPUT_TRANSFORM_90)) { if (driverdata->has_logical_size || !(driverdata->transform & WL_OUTPUT_TRANSFORM_90)) {
desktop_mode.w = driverdata->width; desktop_mode.pixel_w = driverdata->width;
desktop_mode.h = driverdata->height; desktop_mode.pixel_h = driverdata->height;
} else { } else {
desktop_mode.w = driverdata->height; desktop_mode.pixel_w = driverdata->height;
desktop_mode.h = driverdata->width; desktop_mode.pixel_h = driverdata->width;
} }
desktop_mode.display_scale = driverdata->scale_factor; desktop_mode.display_scale = driverdata->scale_factor;
desktop_mode.refresh_rate = ((100 * driverdata->refresh) / 1000) / 100.0f; /* mHz to Hz */ desktop_mode.refresh_rate = ((100 * driverdata->refresh) / 1000) / 100.0f; /* mHz to Hz */
@ -976,8 +976,8 @@ static int Wayland_GetDisplayBounds(_THIS, SDL_VideoDisplay *display, SDL_Rect *
SDL_WaylandOutputData *driverdata = (SDL_WaylandOutputData *)display->driverdata; SDL_WaylandOutputData *driverdata = (SDL_WaylandOutputData *)display->driverdata;
rect->x = driverdata->x; rect->x = driverdata->x;
rect->y = driverdata->y; rect->y = driverdata->y;
rect->w = display->current_mode.w; rect->w = display->current_mode.screen_w;
rect->h = display->current_mode.h; rect->h = display->current_mode.screen_h;
return 0; return 0;
} }

10
src/video/windows/SDL_windowsmodes.c
View File

@ -38,9 +38,7 @@ static void WIN_UpdateDisplayMode(_THIS, LPCWSTR deviceName, DWORD index, SDL_Di
SDL_DisplayModeData *data = (SDL_DisplayModeData *)mode->driverdata; SDL_DisplayModeData *data = (SDL_DisplayModeData *)mode->driverdata;
HDC hdc; HDC hdc;
data->DeviceMode.dmFields = data->DeviceMode.dmFields = (DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS);
(DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY |
DM_DISPLAYFLAGS);
/* NOLINTNEXTLINE(bugprone-assignment-in-if-condition): No simple way to extract the assignment */ /* NOLINTNEXTLINE(bugprone-assignment-in-if-condition): No simple way to extract the assignment */
if (index == ENUM_CURRENT_SETTINGS && (hdc = CreateDC(deviceName, NULL, NULL, NULL)) != NULL) { if (index == ENUM_CURRENT_SETTINGS && (hdc = CreateDC(deviceName, NULL, NULL, NULL)) != NULL) {
@ -180,14 +178,14 @@ static SDL_bool WIN_GetDisplayMode(_THIS, HMONITOR hMonitor, LPCWSTR deviceName,
data->DeviceMode = devmode; data->DeviceMode = devmode;
mode->format = SDL_PIXELFORMAT_UNKNOWN; mode->format = SDL_PIXELFORMAT_UNKNOWN;
mode->w = data->DeviceMode.dmPelsWidth; mode->pixel_w = data->DeviceMode.dmPelsWidth;
mode->h = data->DeviceMode.dmPelsHeight; mode->pixel_h = data->DeviceMode.dmPelsHeight;
mode->refresh_rate = WIN_GetRefreshRate(&data->DeviceMode); mode->refresh_rate = WIN_GetRefreshRate(&data->DeviceMode);
if (index == ENUM_CURRENT_SETTINGS && videodata->GetDpiForMonitor) { if (index == ENUM_CURRENT_SETTINGS && videodata->GetDpiForMonitor) {
UINT hdpi_uint, vdpi_uint; UINT hdpi_uint, vdpi_uint;
if (videodata->GetDpiForMonitor(hMonitor, MDT_EFFECTIVE_DPI, &hdpi_uint, &vdpi_uint) == S_OK) { if (videodata->GetDpiForMonitor(hMonitor, MDT_EFFECTIVE_DPI, &hdpi_uint, &vdpi_uint) == S_OK) {
mode->display_scale = (float)hdpi_uint / 96; mode->display_scale = hdpi_uint / 96.0f;
} }
} }

17
src/video/windows/SDL_windowsvideo.c
View File

@ -423,19 +423,14 @@ int WIN_VideoInit(_THIS)
#if defined(__XBOXONE__) || defined(__XBOXSERIES__) #if defined(__XBOXONE__) || defined(__XBOXSERIES__)
/* For Xbox, we just need to create the single display */ /* For Xbox, we just need to create the single display */
{ {
SDL_VideoDisplay display; SDL_DisplayMode mode;
SDL_DisplayMode current_mode;
SDL_zero(current_mode); SDL_zero(mode);
D3D12_XBOX_GetResolution(&current_mode.w, &current_mode.h); D3D12_XBOX_GetResolution(&mode.pixel_w, &mode.pixel_h);
current_mode.refresh_rate = 60.0f; mode.refresh_rate = 60.0f;
current_mode.format = SDL_PIXELFORMAT_ARGB8888; mode.format = SDL_PIXELFORMAT_ARGB8888;
SDL_zero(display); SDL_AddBasicVideoDisplay(&mode);
display.desktop_mode = current_mode;
display.current_mode = current_mode;
SDL_AddVideoDisplay(&display, SDL_FALSE);
} }
#else /*!defined(__XBOXONE__) && !defined(__XBOXSERIES__)*/ #else /*!defined(__XBOXONE__) && !defined(__XBOXSERIES__)*/
if (WIN_InitModes(_this) < 0) { if (WIN_InitModes(_this) < 0) {

38
src/video/winrt/SDL_winrtvideo.cpp
View File

@ -253,8 +253,8 @@ extern "C" Uint32 D3D11_DXGIFormatToSDLPixelFormat(DXGI_FORMAT dxgiFormat);
static void WINRT_DXGIModeToSDLDisplayMode(const DXGI_MODE_DESC *dxgiMode, SDL_DisplayMode *sdlMode) static void WINRT_DXGIModeToSDLDisplayMode(const DXGI_MODE_DESC *dxgiMode, SDL_DisplayMode *sdlMode)
{ {
SDL_zerop(sdlMode); SDL_zerop(sdlMode);
sdlMode->w = dxgiMode->Width; sdlMode->pixel_w = dxgiMode->Width;
sdlMode->h = dxgiMode->Height; sdlMode->pixel_h = dxgiMode->Height;
sdlMode->refresh_rate = (((100 * dxgiMode->RefreshRate.Numerator) / dxgiMode->RefreshRate.Denominator) / 100.0f); sdlMode->refresh_rate = (((100 * dxgiMode->RefreshRate.Numerator) / dxgiMode->RefreshRate.Denominator) / 100.0f);
sdlMode->format = D3D11_DXGIFormatToSDLPixelFormat(dxgiMode->Format); sdlMode->format = D3D11_DXGIFormatToSDLPixelFormat(dxgiMode->Format);
} }
@ -303,10 +303,9 @@ static int WINRT_AddDisplaysForOutput(_THIS, IDXGIAdapter1 *dxgiAdapter1, int ou
SDL_DisplayMode mode; SDL_DisplayMode mode;
SDL_zero(mode); SDL_zero(mode);
display.name = SDL_strdup("Windows Simulator / Terminal Services Display"); display.name = SDL_strdup("Windows Simulator / Terminal Services Display");
mode.w = (dxgiOutputDesc.DesktopCoordinates.right - dxgiOutputDesc.DesktopCoordinates.left); mode.pixel_w = (dxgiOutputDesc.DesktopCoordinates.right - dxgiOutputDesc.DesktopCoordinates.left);
mode.h = (dxgiOutputDesc.DesktopCoordinates.bottom - dxgiOutputDesc.DesktopCoordinates.top); mode.pixel_h = (dxgiOutputDesc.DesktopCoordinates.bottom - dxgiOutputDesc.DesktopCoordinates.top);
mode.format = DXGI_FORMAT_B8G8R8A8_UNORM; mode.format = DXGI_FORMAT_B8G8R8A8_UNORM;
mode.refresh_rate = 0.0f; /* Display mode is unknown, so just fill in zero, as specified by SDL's header files */
display.desktop_mode = mode; display.desktop_mode = mode;
display.current_mode = mode; display.current_mode = mode;
if (!SDL_AddDisplayMode(&display, &mode)) { if (!SDL_AddDisplayMode(&display, &mode)) {
@ -415,18 +414,23 @@ static int WINRT_AddDisplaysForAdapter(_THIS, IDXGIFactory2 *dxgiFactory2, int a
*/ */
#if (NTDDI_VERSION >= NTDDI_WIN10) || (SDL_WINRT_USE_APPLICATIONVIEW && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) #if (NTDDI_VERSION >= NTDDI_WIN10) || (SDL_WINRT_USE_APPLICATIONVIEW && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
mode.w = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Width); mode.pixel_w = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Width);
mode.h = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Height); mode.pixel_h = WINRT_DIPS_TO_PHYSICAL_PIXELS(appView->VisibleBounds.Height);
mode.screen_w = appView->VisibleBounds.Width;
mode.screen_h = appView->VisibleBounds.Height;
mode.display_scale = WINRT_DISPLAY_PROPERTY(LogicalDpi) / 96.0f;
#else #else
/* On platform(s) that do not support VisibleBounds, such as Windows 8.1, /* On platform(s) that do not support VisibleBounds, such as Windows 8.1,
fall back to CoreWindow's Bounds property. fall back to CoreWindow's Bounds property.
*/ */
mode.w = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Width); mode.pixel_w = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Width);
mode.h = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Height); mode.pixel_h = WINRT_DIPS_TO_PHYSICAL_PIXELS(coreWin->Bounds.Height);
mode.screen_w = coreWin->Bounds.Width;
mode.screen_h = coreWin->Bounds.Height;
mode.display_scale = WINRT_DISPLAY_PROPERTY(LogicalDpi) / 96.0f;
#endif #endif
mode.format = DXGI_FORMAT_B8G8R8A8_UNORM; mode.format = DXGI_FORMAT_B8G8R8A8_UNORM;
mode.refresh_rate = 0.0f; /* Display mode is unknown, so just fill in zero, as specified by SDL's header files */
display.desktop_mode = mode; display.desktop_mode = mode;
display.current_mode = mode; display.current_mode = mode;
bool error = SDL_AddDisplayMode(&display, &mode) < 0 || bool error = SDL_AddDisplayMode(&display, &mode) < 0 ||
@ -532,7 +536,7 @@ WINRT_DetectWindowFlags(SDL_Window *window)
} }
#endif #endif
if (display->desktop_mode.w != w || display->desktop_mode.h != h) { if (display->desktop_mode.pixel_w != w || display->desktop_mode.pixel_h != h) {
latestFlags |= SDL_WINDOW_MAXIMIZED; latestFlags |= SDL_WINDOW_MAXIMIZED;
} else { } else {
latestFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP; latestFlags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
@ -701,12 +705,12 @@ int WINRT_CreateWindow(_THIS, SDL_Window *window)
user choice of various things. For now, just adapt the SDL_Window to user choice of various things. For now, just adapt the SDL_Window to
whatever Windows set-up as the native-window's geometry. whatever Windows set-up as the native-window's geometry.
*/ */
window->x = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Left); window->x = (int)SDL_lroundf(data->coreWindow->Bounds.Left);
window->y = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Top); window->y = (int)SDL_lroundf(data->coreWindow->Bounds.Top);
#if NTDDI_VERSION < NTDDI_WIN10 #if NTDDI_VERSION < NTDDI_WIN10
/* On WinRT 8.x / pre-Win10, just use the size we were given. */ /* On WinRT 8.x / pre-Win10, just use the size we were given. */
window->w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); window->w = (int)SDL_floorf(data->coreWindow->Bounds.Width);
window->h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); window->h = (int)SDL_floorf(data->coreWindow->Bounds.Height);
#else #else
/* On Windows 10, we occasionally get control over window size. For windowed /* On Windows 10, we occasionally get control over window size. For windowed
mode apps, try this. mode apps, try this.
@ -721,8 +725,8 @@ int WINRT_CreateWindow(_THIS, SDL_Window *window)
/* We either weren't able to set the window size, or a request for /* We either weren't able to set the window size, or a request for
fullscreen was made. Get window-size info from the OS. fullscreen was made. Get window-size info from the OS.
*/ */
window->w = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Width); window->w = (int)SDL_floorf(data->coreWindow->Bounds.Width);
window->h = WINRT_DIPS_TO_PHYSICAL_PIXELS(data->coreWindow->Bounds.Height); window->h = (int)SDL_floorf(data->coreWindow->Bounds.Height);
} }
#endif #endif

4
src/video/x11/SDL_x11messagebox.c
View File

@ -471,8 +471,8 @@ static int X11_MessageBoxCreateWindow(SDL_MessageBoxDataX11 *data)
if ((dev) && (dev->displays) && (dev->num_displays > 0)) { if ((dev) && (dev->displays) && (dev->num_displays > 0)) {
const SDL_VideoDisplay *dpy = &dev->displays[0]; const SDL_VideoDisplay *dpy = &dev->displays[0];
const SDL_DisplayData *dpydata = (SDL_DisplayData *)dpy->driverdata; const SDL_DisplayData *dpydata = (SDL_DisplayData *)dpy->driverdata;
x = dpydata->x + ((dpy->current_mode.w - data->dialog_width) / 2); x = dpydata->x + ((dpy->current_mode.pixel_w - data->dialog_width) / 2);
y = dpydata->y + ((dpy->current_mode.h - data->dialog_height) / 3); y = dpydata->y + ((dpy->current_mode.pixel_h - data->dialog_height) / 3);
} else { /* oh well. This will misposition on a multi-head setup. Init first next time. */ } else { /* oh well. This will misposition on a multi-head setup. Init first next time. */
x = (DisplayWidth(display, data->screen) - data->dialog_width) / 2; x = (DisplayWidth(display, data->screen) - data->dialog_width) / 2;
y = (DisplayHeight(display, data->screen) - data->dialog_height) / 3; y = (DisplayHeight(display, data->screen) - data->dialog_height) / 3;

38
src/video/x11/SDL_x11modes.c
View File

@ -217,11 +217,11 @@ static SDL_bool SetXRandRModeInfo(Display *display, XRRScreenResources *res, RRC
} }
if (rotation & (XRANDR_ROTATION_LEFT | XRANDR_ROTATION_RIGHT)) { if (rotation & (XRANDR_ROTATION_LEFT | XRANDR_ROTATION_RIGHT)) {
mode->w = info->height; mode->pixel_w = info->height;
mode->h = info->width; mode->pixel_h = info->width;
} else { } else {
mode->w = info->width; mode->pixel_w = info->width;
mode->h = info->height; mode->pixel_h = info->height;
} }
mode->refresh_rate = CalculateXRandRRefreshRate(info); mode->refresh_rate = CalculateXRandRRefreshRate(info);
((SDL_DisplayModeData *)mode->driverdata)->xrandr_mode = modeID; ((SDL_DisplayModeData *)mode->driverdata)->xrandr_mode = modeID;
@ -343,8 +343,8 @@ static int X11_AddXRandRDisplay(_THIS, Display *dpy, int screen, RROutput output
SDL_zero(mode); SDL_zero(mode);
modeID = crtc->mode; modeID = crtc->mode;
mode.w = crtc->width; mode.pixel_w = crtc->width;
mode.h = crtc->height; mode.pixel_h = crtc->height;
mode.format = pixelformat; mode.format = pixelformat;
display_x = crtc->x; display_x = crtc->x;
@ -369,9 +369,9 @@ static int X11_AddXRandRDisplay(_THIS, Display *dpy, int screen, RROutput output
displaydata->screen = screen; displaydata->screen = screen;
displaydata->visual = vinfo.visual; displaydata->visual = vinfo.visual;
displaydata->depth = vinfo.depth; displaydata->depth = vinfo.depth;
displaydata->hdpi = display_mm_width ? (((float)mode.w) * 25.4f / display_mm_width) : 0.0f; displaydata->hdpi = display_mm_width ? (((float)mode.pixel_w) * 25.4f / display_mm_width) : 0.0f;
displaydata->vdpi = display_mm_height ? (((float)mode.h) * 25.4f / display_mm_height) : 0.0f; displaydata->vdpi = display_mm_height ? (((float)mode.pixel_h) * 25.4f / display_mm_height) : 0.0f;
displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.w, mode.h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f); displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.pixel_w, mode.pixel_h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f);
displaydata->scanline_pad = scanline_pad; displaydata->scanline_pad = scanline_pad;
displaydata->x = display_x; displaydata->x = display_x;
displaydata->y = display_y; displaydata->y = display_y;
@ -574,8 +574,8 @@ static int X11_InitModes_StdXlib(_THIS)
} }
SDL_zero(mode); SDL_zero(mode);
mode.w = WidthOfScreen(screen); mode.pixel_w = WidthOfScreen(screen);
mode.h = HeightOfScreen(screen); mode.pixel_h = HeightOfScreen(screen);
mode.format = pixelformat; mode.format = pixelformat;
displaydata = (SDL_DisplayData *)SDL_calloc(1, sizeof(*displaydata)); displaydata = (SDL_DisplayData *)SDL_calloc(1, sizeof(*displaydata));
@ -596,9 +596,9 @@ static int X11_InitModes_StdXlib(_THIS)
displaydata->screen = default_screen; displaydata->screen = default_screen;
displaydata->visual = vinfo.visual; displaydata->visual = vinfo.visual;
displaydata->depth = vinfo.depth; displaydata->depth = vinfo.depth;
displaydata->hdpi = display_mm_width ? (((float)mode.w) * 25.4f / display_mm_width) : 0.0f; displaydata->hdpi = display_mm_width ? (((float)mode.pixel_w) * 25.4f / display_mm_width) : 0.0f;
displaydata->vdpi = display_mm_height ? (((float)mode.h) * 25.4f / display_mm_height) : 0.0f; displaydata->vdpi = display_mm_height ? (((float)mode.pixel_h) * 25.4f / display_mm_height) : 0.0f;
displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.w, mode.h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f); displaydata->ddpi = SDL_ComputeDiagonalDPI(mode.pixel_w, mode.pixel_h, ((float)display_mm_width) / 25.4f, ((float)display_mm_height) / 25.4f);
xft_dpi = GetXftDPI(dpy); xft_dpi = GetXftDPI(dpy);
if (xft_dpi > 0) { if (xft_dpi > 0) {
@ -783,8 +783,8 @@ int X11_SetDisplayMode(_THIS, SDL_VideoDisplay *sdl_display, SDL_DisplayMode *mo
goto ungrabServer; goto ungrabServer;
} }
mm_width = mode->w * DisplayWidthMM(display, data->screen) / DisplayWidth(display, data->screen); mm_width = mode->pixel_w * DisplayWidthMM(display, data->screen) / DisplayWidth(display, data->screen);
mm_height = mode->h * DisplayHeightMM(display, data->screen) / DisplayHeight(display, data->screen); mm_height = mode->pixel_h * DisplayHeightMM(display, data->screen) / DisplayHeight(display, data->screen);
/* !!! FIXME: this can get into a problem scenario when a window is /* !!! FIXME: this can get into a problem scenario when a window is
bigger than a physical monitor in a configuration where one screen bigger than a physical monitor in a configuration where one screen
@ -795,7 +795,7 @@ int X11_SetDisplayMode(_THIS, SDL_VideoDisplay *sdl_display, SDL_DisplayMode *mo
crashing */ crashing */
X11_XSync(display, False); X11_XSync(display, False);
PreXRRSetScreenSizeErrorHandler = X11_XSetErrorHandler(SDL_XRRSetScreenSizeErrHandler); PreXRRSetScreenSizeErrorHandler = X11_XSetErrorHandler(SDL_XRRSetScreenSizeErrHandler);
X11_XRRSetScreenSize(display, RootWindow(display, data->screen), mode->w, mode->h, mm_width, mm_height); X11_XRRSetScreenSize(display, RootWindow(display, data->screen), mode->pixel_w, mode->pixel_h, mm_width, mm_height);
X11_XSync(display, False); X11_XSync(display, False);
X11_XSetErrorHandler(PreXRRSetScreenSizeErrorHandler); X11_XSetErrorHandler(PreXRRSetScreenSizeErrorHandler);
@ -831,8 +831,8 @@ int X11_GetDisplayBounds(_THIS, SDL_VideoDisplay *sdl_display, SDL_Rect *rect)
rect->x = data->x; rect->x = data->x;
rect->y = data->y; rect->y = data->y;
rect->w = sdl_display->current_mode.w; rect->w = sdl_display->current_mode.screen_w;
rect->h = sdl_display->current_mode.h; rect->h = sdl_display->current_mode.screen_h;
return 0; return 0;
} }

27
test/testautomation_video.c
View File

@ -425,8 +425,9 @@ int video_getClosestDisplayModeCurrentResolution(void *arg)
} }
/* Set the desired resolution equals to current resolution */ /* Set the desired resolution equals to current resolution */
target.w = current.w; SDL_zero(target);
target.h = current.h; target.pixel_w = current.pixel_w;
target.pixel_h = current.pixel_h;
for (variation = 0; variation < 8; variation++) { for (variation = 0; variation < 8; variation++) {
/* Vary constraints on other query parameters */ /* Vary constraints on other query parameters */
target.format = (variation & 1) ? current.format : 0; target.format = (variation & 1) ? current.format : 0;
@ -439,11 +440,11 @@ int video_getClosestDisplayModeCurrentResolution(void *arg)
SDLTest_Assert(dResult != NULL, "Verify returned value is not NULL"); SDLTest_Assert(dResult != NULL, "Verify returned value is not NULL");
/* Check that one gets the current resolution back again */ /* Check that one gets the current resolution back again */
SDLTest_AssertCheck(closest.w == current.w, "Verify returned width matches current width; expected: %d, got: %d", current.w, closest.w); SDLTest_AssertCheck(closest.pixel_w == current.pixel_w, "Verify returned width matches current width; expected: %d, got: %d", current.pixel_w, closest.pixel_w);
SDLTest_AssertCheck(closest.h == current.h, "Verify returned height matches current height; expected: %d, got: %d", current.h, closest.h); SDLTest_AssertCheck(closest.pixel_h == current.pixel_h, "Verify returned height matches current height; expected: %d, got: %d", current.pixel_h, closest.pixel_h);
/* NOLINTBEGIN(clang-analyzer-core.NullDereference): Checked earlier for NULL */ /* NOLINTBEGIN(clang-analyzer-core.NullDereference): Checked earlier for NULL */
SDLTest_AssertCheck(closest.w == dResult->w, "Verify return value matches assigned value; expected: %d, got: %d", closest.w, dResult->w); SDLTest_AssertCheck(closest.pixel_w == dResult->pixel_w, "Verify return value matches assigned value; expected: %d, got: %d", closest.pixel_w, dResult->pixel_w);
SDLTest_AssertCheck(closest.h == dResult->h, "Verify return value matches assigned value; expected: %d, got: %d", closest.h, dResult->h); SDLTest_AssertCheck(closest.pixel_h == dResult->pixel_h, "Verify return value matches assigned value; expected: %d, got: %d", closest.pixel_h, dResult->pixel_h);
/* NOLINTEND(clang-analyzer-core.NullDereference) */ /* NOLINTEND(clang-analyzer-core.NullDereference) */
} }
} }
@ -473,11 +474,11 @@ int video_getClosestDisplayModeRandomResolution(void *arg)
for (variation = 0; variation < 16; variation++) { for (variation = 0; variation < 16; variation++) {
/* Set random constraints */ /* Set random constraints */
target.w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; SDL_zero(target);
target.h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0; target.pixel_w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;
target.pixel_h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;
target.format = (variation & 4) ? SDLTest_RandomIntegerInRange(1, 10) : 0; target.format = (variation & 4) ? SDLTest_RandomIntegerInRange(1, 10) : 0;
target.refresh_rate = (variation & 8) ? (float)SDLTest_RandomIntegerInRange(25, 120) : 0.0f; target.refresh_rate = (variation & 8) ? (float)SDLTest_RandomIntegerInRange(25, 120) : 0.0f;
target.driverdata = 0;
/* Make call; may or may not find anything, so don't validate any further */ /* Make call; may or may not find anything, so don't validate any further */
SDL_GetClosestDisplayMode(i, &target, &closest); SDL_GetClosestDisplayMode(i, &target, &closest);
@ -501,8 +502,8 @@ int video_getWindowDisplayMode(void *arg)
int result; int result;
/* Invalidate part of the mode content so we can check values later */ /* Invalidate part of the mode content so we can check values later */
mode.w = -1; mode.pixel_w = -1;
mode.h = -1; mode.pixel_h = -1;
mode.refresh_rate = -1.0f; mode.refresh_rate = -1.0f;
/* Call against new test window */ /* Call against new test window */
@ -511,8 +512,8 @@ int video_getWindowDisplayMode(void *arg)
result = SDL_GetWindowDisplayMode(window, &mode); result = SDL_GetWindowDisplayMode(window, &mode);
SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode()"); SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode()");
SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result); SDLTest_AssertCheck(result == 0, "Validate result value; expected: 0, got: %d", result);
SDLTest_AssertCheck(mode.w > 0, "Validate mode.w content; expected: >0, got: %d", mode.w); SDLTest_AssertCheck(mode.pixel_w > 0, "Validate mode.w content; expected: >0, got: %d", mode.pixel_w);
SDLTest_AssertCheck(mode.h > 0, "Validate mode.h content; expected: >0, got: %d", mode.h); SDLTest_AssertCheck(mode.pixel_h > 0, "Validate mode.h content; expected: >0, got: %d", mode.pixel_h);
SDLTest_AssertCheck(mode.refresh_rate > 0.0f, "Validate mode.refresh_rate content; expected: >0, got: %g", mode.refresh_rate); SDLTest_AssertCheck(mode.refresh_rate > 0.0f, "Validate mode.refresh_rate content; expected: >0, got: %g", mode.refresh_rate);
} }

4
test/testdisplayinfo.c
View File

@ -24,9 +24,9 @@ print_mode(const char *prefix, const SDL_DisplayMode *mode)
return; return;
} }
SDL_Log("%s: fmt=%s w=%d h=%d refresh=%gHz\n", SDL_Log("%s: fmt=%s w=%d h=%d scale=%d%% refresh=%gHz\n",
prefix, SDL_GetPixelFormatName(mode->format), prefix, SDL_GetPixelFormatName(mode->format),
mode->w, mode->h, mode->refresh_rate); mode->pixel_w, mode->pixel_h, (int)(mode->display_scale * 100.0f), mode->refresh_rate);
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])

2
test/testwm.c
View File

@ -108,7 +108,7 @@ draw_modes_menu(SDL_Window *window, SDL_Renderer *renderer, SDL_FRect viewport)
} }
(void)SDL_snprintf(text, sizeof text, "%d: %dx%d@%gHz", (void)SDL_snprintf(text, sizeof text, "%d: %dx%d@%gHz",
i, mode.w, mode.h, mode.refresh_rate); i, mode.pixel_w, mode.pixel_h, mode.refresh_rate);
/* Update column width */ /* Update column width */
text_length = (int)SDL_strlen(text); text_length = (int)SDL_strlen(text);