/*

Simple DirectMedia Layer

Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "../SDL_internal.h"

/* The high-level video driver subsystem */

#include "SDL.h"

#include "SDL_video.h"

#include "SDL_sysvideo.h"

#include "SDL_blit.h"

#include "SDL_pixels_c.h"

#include "SDL_rect_c.h"

#include "../events/SDL_events_c.h"

#include "../timer/SDL_timer_c.h"

#include "SDL_syswm.h"

#ifdef SDL_VIDEO_OPENGL

#include "SDL_opengl.h"

#endif /* SDL_VIDEO_OPENGL */

#if defined(SDL_VIDEO_OPENGL_ES) && !defined(SDL_VIDEO_OPENGL)

#include "SDL_opengles.h"

#endif /* SDL_VIDEO_OPENGL_ES && !SDL_VIDEO_OPENGL */

/* GL and GLES2 headers conflict on Linux 32 bits */

#if defined(SDL_VIDEO_OPENGL_ES2) && !defined(SDL_VIDEO_OPENGL)

#include "SDL_opengles2.h"

#endif /* SDL_VIDEO_OPENGL_ES2 && !SDL_VIDEO_OPENGL */

#ifndef SDL_VIDEO_OPENGL

#ifndef GL_CONTEXT_RELEASE_BEHAVIOR_KHR

#define GL_CONTEXT_RELEASE_BEHAVIOR_KHR 0x82FB

#endif

#endif

#ifdef __EMSCRIPTEN__

#include <emscripten.h>

#endif

#ifdef __LINUX__

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <dlfcn.h>

#endif

/* Available video drivers */

static VideoBootStrap *bootstrap[] = {

#ifdef SDL_VIDEO_DRIVER_COCOA

&COCOA_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_X11

&X11_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_WAYLAND

&Wayland_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_VIVANTE

&VIVANTE_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_DIRECTFB

&DirectFB_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_WINDOWS

&WINDOWS_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_WINRT

&WINRT_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_HAIKU

&HAIKU_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_PANDORA

&PND_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_UIKIT

&UIKIT_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_ANDROID

&Android_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_PS2

&PS2_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_PSP

&PSP_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_VITA

&VITA_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_N3DS

&N3DS_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_KMSDRM

&KMSDRM_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_RISCOS

&RISCOS_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_RPI

&RPI_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_NACL

&NACL_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_EMSCRIPTEN

&Emscripten_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_QNX

&QNX_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_OS2

&OS2DIVE_bootstrap,

&OS2VMAN_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_NGAGE

&NGAGE_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_OFFSCREEN

&OFFSCREEN_bootstrap,

#endif

#ifdef SDL_VIDEO_DRIVER_DUMMY

&DUMMY_bootstrap,

#ifdef SDL_INPUT_LINUXEV

&DUMMY_evdev_bootstrap,

#endif

#endif

NULL

};

#define CHECK_WINDOW_MAGIC(window, retval) \

if (!_this) { \

SDL_UninitializedVideo(); \

return retval; \

} \

if (!window || window->magic != &_this->window_magic) { \

SDL_SetError("Invalid window"); \

return retval; \

}

#define CHECK_DISPLAY_INDEX(displayIndex, retval) \

if (!_this) { \

SDL_UninitializedVideo(); \

return retval; \

} \

if (displayIndex < 0 || displayIndex >= _this->num_displays) { \

SDL_SetError("displayIndex must be in the range 0 - %d", \

_this->num_displays - 1); \

return retval; \

}

#define FULLSCREEN_MASK (SDL_WINDOW_FULLSCREEN_DESKTOP | SDL_WINDOW_FULLSCREEN)

#if defined(__MACOSX__) && defined(SDL_VIDEO_DRIVER_COCOA)

/* Support for Mac OS X fullscreen spaces */

extern SDL_bool Cocoa_IsWindowInFullscreenSpace(SDL_Window * window);

extern SDL_bool Cocoa_SetWindowFullscreenSpace(SDL_Window * window, SDL_bool state);

#endif

/* Convenience functions for reading driver flags */

static SDL_bool DisableDisplayModeSwitching(_THIS)

{

return !!(_this->quirk_flags & VIDEO_DEVICE_QUIRK_DISABLE_DISPLAY_MODE_SWITCHING);

}

static SDL_bool DisableUnsetFullscreenOnMinimize(_THIS)

{

return !!(_this->quirk_flags & VIDEO_DEVICE_QUIRK_DISABLE_UNSET_FULLSCREEN_ON_MINIMIZE);

}

/* Support for framebuffer emulation using an accelerated renderer */

#define SDL_WINDOWTEXTUREDATA "_SDL_WindowTextureData"

typedef struct

{

SDL_Renderer *renderer;

SDL_Texture *texture;

void *pixels;

int pitch;

int bytes_per_pixel;

} SDL_WindowTextureData;

static Uint32 SDL_DefaultGraphicsBackends(SDL_VideoDevice *_this)

{

#if (defined(SDL_VIDEO_OPENGL) && defined(__MACOSX__)) || (defined(__IPHONEOS__) && !TARGET_OS_MACCATALYST) || defined(__ANDROID__) || defined(__NACL__)

if (_this->GL_CreateContext) {

return SDL_WINDOW_OPENGL;

}

#endif

#if defined(SDL_VIDEO_METAL) && (TARGET_OS_MACCATALYST || defined(__MACOSX__) || defined(__IPHONEOS__))

if (_this->Metal_CreateView) {

return SDL_WINDOW_METAL;

}

#endif

return 0;

}

static int SDL_CreateWindowTexture(SDL_VideoDevice *_this, SDL_Window *window, Uint32 *format, void **pixels, int *pitch)

{

SDL_RendererInfo info;

SDL_WindowTextureData *data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);

int i;

int w, h;

SDL_GetWindowSizeInPixels(window, &w, &h);

if (!data) {

SDL_Renderer *renderer = NULL;

const char *hint = SDL_GetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION);

const SDL_bool specific_accelerated_renderer = (hint && *hint != '0' && *hint != '1' &&

SDL_strcasecmp(hint, "true") != 0 &&

SDL_strcasecmp(hint, "false") != 0 &&

SDL_strcasecmp(hint, "software") != 0);

/* Check to see if there's a specific driver requested */

if (specific_accelerated_renderer) {

for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {

SDL_GetRenderDriverInfo(i, &info);

if (SDL_strcasecmp(info.name, hint) == 0) {

renderer = SDL_CreateRenderer(window, i, 0);

break;

}

}

if (!renderer || (SDL_GetRendererInfo(renderer, &info) == -1)) {

if (renderer) {

SDL_DestroyRenderer(renderer);

}

return SDL_SetError("Requested renderer for " SDL_HINT_FRAMEBUFFER_ACCELERATION " is not available");

}

/* if it was specifically requested, even if SDL_RENDERER_ACCELERATED isn't set, we'll accept this renderer. */

} else {

for (i = 0; i < SDL_GetNumRenderDrivers(); ++i) {

SDL_GetRenderDriverInfo(i, &info);

if (SDL_strcmp(info.name, "software") != 0) {

renderer = SDL_CreateRenderer(window, i, 0);

if (renderer && (SDL_GetRendererInfo(renderer, &info) == 0) && (info.flags & SDL_RENDERER_ACCELERATED)) {

break; /* this will work. */

}

if (renderer) { /* wasn't accelerated, etc, skip it. */

SDL_DestroyRenderer(renderer);

renderer = NULL;

}

}

}

if (!renderer) {

return SDL_SetError("No hardware accelerated renderers available");

}

}

SDL_assert(renderer != NULL); /* should have explicitly checked this above. */

/* Create the data after we successfully create the renderer (bug #1116) */

data = (SDL_WindowTextureData *)SDL_calloc(1, sizeof(*data));

if (!data) {

SDL_DestroyRenderer(renderer);

return SDL_OutOfMemory();

}

SDL_SetWindowData(window, SDL_WINDOWTEXTUREDATA, data);

data->renderer = renderer;

} else {

if (SDL_GetRendererInfo(data->renderer, &info) == -1) {

return -1;

}

}

/* Free any old texture and pixel data */

if (data->texture) {

SDL_DestroyTexture(data->texture);

data->texture = NULL;

}

SDL_free(data->pixels);

data->pixels = NULL;

/* Find the first format without an alpha channel */

*format = info.texture_formats[0];

for (i = 0; i < (int)info.num_texture_formats; ++i) {

if (!SDL_ISPIXELFORMAT_FOURCC(info.texture_formats[i]) &&

!SDL_ISPIXELFORMAT_ALPHA(info.texture_formats[i])) {

*format = info.texture_formats[i];

break;

}

}

data->texture = SDL_CreateTexture(data->renderer, *format,

SDL_TEXTUREACCESS_STREAMING,

w, h);

if (!data->texture) {

/* codechecker_false_positive [Malloc] Static analyzer doesn't realize allocated `data` is saved to SDL_WINDOWTEXTUREDATA and not leaked here. */

return -1; /* NOLINT(clang-analyzer-unix.Malloc) */

}

/* Create framebuffer data */

data->bytes_per_pixel = SDL_BYTESPERPIXEL(*format);

data->pitch = (((w * data->bytes_per_pixel) + 3) & ~3);

{

/* Make static analysis happy about potential SDL_malloc(0) calls. */

const size_t allocsize = (size_t)h * data->pitch;

data->pixels = SDL_malloc((allocsize > 0) ? allocsize : 1);

if (!data->pixels) {

return SDL_OutOfMemory();

}

}

*pixels = data->pixels;

*pitch = data->pitch;

/* Make sure we're not double-scaling the viewport */

SDL_RenderSetViewport(data->renderer, NULL);

return 0;

}

static SDL_VideoDevice *_this = NULL;

static SDL_atomic_t SDL_messagebox_count;

static int SDL_UpdateWindowTexture(SDL_VideoDevice *unused, SDL_Window *window, const SDL_Rect *rects, int numrects)

{

SDL_WindowTextureData *data;

SDL_Rect rect;

void *src;

int w, h;

SDL_GetWindowSizeInPixels(window, &w, &h);

data = SDL_GetWindowData(window, SDL_WINDOWTEXTUREDATA);

if (!data || !data->texture) {

return SDL_SetError("No window texture data");

}

/* Update a single rect that contains subrects for best DMA performance */

if (SDL_GetSpanEnclosingRect(w, h, numrects, rects, &rect)) {

src = (void *)((Uint8 *)data->pixels +

rect.y * data->pitch +

rect.x * data->bytes_per_pixel);

if (SDL_UpdateTexture(data->texture, &rect, src, data->pitch) < 0) {

return -1;

}

if (SDL_RenderCopy(data->renderer, data->texture, NULL, NULL) < 0) {

return -1;

}

SDL_RenderPresent(data->renderer);

}

return 0;

}

static void SDL_DestroyWindowTexture(SDL_VideoDevice *unused, SDL_Window *window)

{

SDL_WindowTextureData *data;

data = SDL_SetWindowData(window, SDL_WINDOWTEXTUREDATA, NULL);

if (!data) {

return;

}

if (data->texture) {

SDL_DestroyTexture(data->texture);

}

if (data->renderer) {

SDL_DestroyRenderer(data->renderer);

}

SDL_free(data->pixels);

SDL_free(data);

}

static int SDLCALL cmpmodes(const void *A, const void *B)

{

const SDL_DisplayMode *a = (const SDL_DisplayMode *)A;

const SDL_DisplayMode *b = (const SDL_DisplayMode *)B;

if (a == b) {

return 0;

} else if (a->w != b->w) {

return b->w - a->w;

} else if (a->h != b->h) {

return b->h - a->h;

} else if (SDL_BITSPERPIXEL(a->format) != SDL_BITSPERPIXEL(b->format)) {

return SDL_BITSPERPIXEL(b->format) - SDL_BITSPERPIXEL(a->format);

} else if (SDL_PIXELLAYOUT(a->format) != SDL_PIXELLAYOUT(b->format)) {

return SDL_PIXELLAYOUT(b->format) - SDL_PIXELLAYOUT(a->format);

} else if (a->refresh_rate != b->refresh_rate) {

return b->refresh_rate - a->refresh_rate;

}

return 0;

}

static int SDL_UninitializedVideo(void)

{

return SDL_SetError("Video subsystem has not been initialized");

}

int SDL_GetNumVideoDrivers(void)

{

return SDL_arraysize(bootstrap) - 1;

}

const char *SDL_GetVideoDriver(int index)

{

if (index >= 0 && index < SDL_GetNumVideoDrivers()) {

return bootstrap[index]->name;

}

return NULL;

}

/*

* Initialize the video and event subsystems -- determine native pixel format

*/

int SDL_VideoInit(const char *driver_name)

{

SDL_VideoDevice *video;

SDL_bool init_events = SDL_FALSE;

SDL_bool init_keyboard = SDL_FALSE;

SDL_bool init_mouse = SDL_FALSE;

SDL_bool init_touch = SDL_FALSE;

int i = 0;

/* Check to make sure we don't overwrite '_this' */

if (_this) {

SDL_VideoQuit();

}

#ifndef SDL_TIMERS_DISABLED

SDL_TicksInit();

#endif

/* Start the event loop */

if (SDL_InitSubSystem(SDL_INIT_EVENTS) < 0) {

goto pre_driver_error;

}

init_events = SDL_TRUE;

if (SDL_KeyboardInit() < 0) {

goto pre_driver_error;

}

init_keyboard = SDL_TRUE;

if (SDL_MousePreInit() < 0) {

goto pre_driver_error;

}

init_mouse = SDL_TRUE;

if (SDL_TouchInit() < 0) {

goto pre_driver_error;

}

init_touch = SDL_TRUE;

/* Select the proper video driver */

video = NULL;

if (!driver_name) {

driver_name = SDL_GetHint(SDL_HINT_VIDEODRIVER);

}

#if defined(__LINUX__) && defined(SDL_VIDEO_DRIVER_X11)

if (!driver_name) {

/* See if it looks like we need X11 */

SDL_bool force_x11 = SDL_FALSE;

void *global_symbols = dlopen(NULL, RTLD_LOCAL|RTLD_NOW);

/* Use linked libraries to detect what quirks we are likely to need */

if (global_symbols != NULL) {

if (dlsym(global_symbols, "glxewInit") != NULL) { /* GLEW (e.g. Frogatto, SLUDGE) */

force_x11 = SDL_TRUE;

} else if (dlsym(global_symbols, "cgGLEnableProgramProfiles") != NULL) { /* NVIDIA Cg (e.g. Awesomenauts, Braid) */

force_x11 = SDL_TRUE;

} else if (dlsym(global_symbols, "_Z7ssgInitv") != NULL) { /* ::ssgInit(void) in plib (e.g. crrcsim) */

force_x11 = SDL_TRUE;

}

dlclose(global_symbols);

}

if (force_x11) {

driver_name = "x11";

}

}

#endif

if (driver_name && *driver_name != 0) {

const char *driver_attempt = driver_name;

while (driver_attempt && *driver_attempt != 0 && !video) {

const char *driver_attempt_end = SDL_strchr(driver_attempt, ',');

size_t driver_attempt_len = (driver_attempt_end) ? (driver_attempt_end - driver_attempt)

: SDL_strlen(driver_attempt);

for (i = 0; bootstrap[i]; ++i) {

if ((driver_attempt_len == SDL_strlen(bootstrap[i]->name)) &&

(SDL_strncasecmp(bootstrap[i]->name, driver_attempt, driver_attempt_len) == 0)) {

video = bootstrap[i]->create();

break;

}

}

driver_attempt = (driver_attempt_end) ? (driver_attempt_end + 1) : NULL;

}

} else {

for (i = 0; bootstrap[i]; ++i) {

video = bootstrap[i]->create();

if (video) {

break;

}

}

}

if (!video) {

if (driver_name) {

SDL_SetError("%s not available", driver_name);

goto pre_driver_error;

}

SDL_SetError("No available video device");

goto pre_driver_error;

}

/* From this point on, use SDL_VideoQuit to cleanup on error, rather than

pre_driver_error. */

_this = video;

_this->name = bootstrap[i]->name;

_this->next_object_id = 1;

_this->thread = SDL_ThreadID();

/* Set some very sane GL defaults */

_this->gl_config.driver_loaded = 0;

_this->gl_config.dll_handle = NULL;

SDL_GL_ResetAttributes();

_this->current_glwin_tls = SDL_TLSCreate();

_this->current_glctx_tls = SDL_TLSCreate();

/* Initialize the video subsystem */

if (_this->VideoInit(_this) < 0) {

SDL_VideoQuit();

return -1;

}

/* Make sure some displays were added */

if (_this->num_displays == 0) {

SDL_VideoQuit();

return SDL_SetError("The video driver did not add any displays");

}

/* Disable the screen saver by default. This is a change from <= 2.0.1,

but most things using SDL are games or media players; you wouldn't

want a screensaver to trigger if you're playing exclusively with a

joystick, or passively watching a movie. Things that use SDL but

function more like a normal desktop app should explicitly reenable the

screensaver. */

if (!SDL_GetHintBoolean(SDL_HINT_VIDEO_ALLOW_SCREENSAVER, SDL_FALSE)) {

SDL_DisableScreenSaver();

}

#if !defined(SDL_VIDEO_DRIVER_N3DS)

/* In the initial state we don't want to pop up an on-screen keyboard,

* but we do want to allow text input from other mechanisms.

*/

{

const char *hint = SDL_GetHint(SDL_HINT_ENABLE_SCREEN_KEYBOARD);

if (!hint) {

SDL_SetHint(SDL_HINT_ENABLE_SCREEN_KEYBOARD, "0");

}

SDL_StartTextInput();

if (!hint) {

SDL_SetHint(SDL_HINT_ENABLE_SCREEN_KEYBOARD, NULL);

}

}

#endif /* !SDL_VIDEO_DRIVER_N3DS */

SDL_MousePostInit();

/* We're ready to go! */

return 0;

pre_driver_error:

SDL_assert(_this == NULL);

if (init_touch) {

SDL_TouchQuit();

}

if (init_mouse) {

SDL_MouseQuit();

}

if (init_keyboard) {

SDL_KeyboardQuit();

}

if (init_events) {

SDL_QuitSubSystem(SDL_INIT_EVENTS);

}

return -1;

}

const char *SDL_GetCurrentVideoDriver(void)

{

if (!_this) {

SDL_UninitializedVideo();

return NULL;

}

return _this->name;

}

SDL_VideoDevice *SDL_GetVideoDevice(void)

{

return _this;

}

SDL_bool SDL_OnVideoThread(void)

{

return (_this && SDL_ThreadID() == _this->thread) ? SDL_TRUE : SDL_FALSE;

}

int SDL_AddBasicVideoDisplay(const SDL_DisplayMode *desktop_mode)

{

SDL_VideoDisplay display;

SDL_zero(display);

if (desktop_mode) {

display.desktop_mode = *desktop_mode;

}

display.current_mode = display.desktop_mode;

return SDL_AddVideoDisplay(&display, SDL_FALSE);

}

int SDL_AddVideoDisplay(const SDL_VideoDisplay *display, SDL_bool send_event)

{

SDL_VideoDisplay *displays;

int index = -1;

displays =

SDL_realloc(_this->displays,

(_this->num_displays + 1) * sizeof(*displays));

if (displays) {

index = _this->num_displays++;

displays[index] = *display;

displays[index].device = _this;

_this->displays = displays;

if (display->name) {

displays[index].name = SDL_strdup(display->name);

} else {

char name[32];

SDL_itoa(index, name, 10);

displays[index].name = SDL_strdup(name);

}

if (send_event) {

SDL_SendDisplayEvent(&_this->displays[index], SDL_DISPLAYEVENT_CONNECTED, 0);

}

} else {

SDL_OutOfMemory();

}

return index;

}

void SDL_DelVideoDisplay(int index)

{

if (index < 0 || index >= _this->num_displays) {

return;

}

SDL_SendDisplayEvent(&_this->displays[index], SDL_DISPLAYEVENT_DISCONNECTED, 0);

if (index < (_this->num_displays - 1)) {

SDL_free(_this->displays[index].driverdata);

SDL_free(_this->displays[index].name);

SDL_memmove(&_this->displays[index], &_this->displays[index + 1], (_this->num_displays - index - 1) * sizeof(_this->displays[index]));

}

--_this->num_displays;

}

int SDL_GetNumVideoDisplays(void)

{

if (!_this) {

SDL_UninitializedVideo();

return 0;

}

return _this->num_displays;

}

int SDL_GetIndexOfDisplay(SDL_VideoDisplay *display)

{

int displayIndex;

for (displayIndex = 0; displayIndex < _this->num_displays; ++displayIndex) {

if (display == &_this->displays[displayIndex]) {

return displayIndex;

}

}

/* Couldn't find the display, just use index 0 */

return 0;

}

void *SDL_GetDisplayDriverData(int displayIndex)

{

CHECK_DISPLAY_INDEX(displayIndex, NULL);

return _this->displays[displayIndex].driverdata;

}

SDL_bool SDL_IsVideoContextExternal(void)

{

return SDL_GetHintBoolean(SDL_HINT_VIDEO_EXTERNAL_CONTEXT, SDL_FALSE);

}

const char *SDL_GetDisplayName(int displayIndex)

{

CHECK_DISPLAY_INDEX(displayIndex, NULL);

return _this->displays[displayIndex].name;

}

int SDL_GetDisplayBounds(int displayIndex, SDL_Rect *rect)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, -1);

if (!rect) {

return SDL_InvalidParamError("rect");

}

display = &_this->displays[displayIndex];

if (_this->GetDisplayBounds) {

if (_this->GetDisplayBounds(_this, display, rect) == 0) {

return 0;

}

}

/* Assume that the displays are left to right */

if (displayIndex == 0) {

rect->x = 0;

rect->y = 0;

} else {

SDL_GetDisplayBounds(displayIndex - 1, rect);

rect->x += rect->w;

}

rect->w = display->current_mode.w;

rect->h = display->current_mode.h;

return 0;

}

static int ParseDisplayUsableBoundsHint(SDL_Rect *rect)

{

const char *hint = SDL_GetHint(SDL_HINT_DISPLAY_USABLE_BOUNDS);

return hint && (SDL_sscanf(hint, "%d,%d,%d,%d", &rect->x, &rect->y, &rect->w, &rect->h) == 4);

}

int SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rect *rect)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, -1);

if (!rect) {

return SDL_InvalidParamError("rect");

}

display = &_this->displays[displayIndex];

if ((displayIndex == 0) && ParseDisplayUsableBoundsHint(rect)) {

return 0;

}

if (_this->GetDisplayUsableBounds) {

if (_this->GetDisplayUsableBounds(_this, display, rect) == 0) {

return 0;

}

}

/* Oh well, just give the entire display bounds. */

return SDL_GetDisplayBounds(displayIndex, rect);

}

int SDL_GetDisplayDPI(int displayIndex, float *ddpi, float *hdpi, float *vdpi)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, -1);

display = &_this->displays[displayIndex];

if (_this->GetDisplayDPI) {

if (_this->GetDisplayDPI(_this, display, ddpi, hdpi, vdpi) == 0) {

return 0;

}

} else {

return SDL_Unsupported();

}

return -1;

}

SDL_DisplayOrientation SDL_GetDisplayOrientation(int displayIndex)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, SDL_ORIENTATION_UNKNOWN);

display = &_this->displays[displayIndex];

return display->orientation;

}

SDL_bool SDL_AddDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)

{

SDL_DisplayMode *modes;

int i, nmodes;

/* Make sure we don't already have the mode in the list */

modes = display->display_modes;

nmodes = display->num_display_modes;

for (i = 0; i < nmodes; ++i) {

if (cmpmodes(mode, &modes[i]) == 0) {

return SDL_FALSE;

}

}

/* Go ahead and add the new mode */

if (nmodes == display->max_display_modes) {

modes =

SDL_realloc(modes,

(display->max_display_modes + 32) * sizeof(*modes));

if (!modes) {

return SDL_FALSE;

}

display->display_modes = modes;

display->max_display_modes += 32;

}

modes[nmodes] = *mode;

display->num_display_modes++;

/* Re-sort video modes */

SDL_qsort(display->display_modes, display->num_display_modes,

sizeof(SDL_DisplayMode), cmpmodes);

return SDL_TRUE;

}

void SDL_SetCurrentDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)

{

SDL_memcpy(&display->current_mode, mode, sizeof(*mode));

}

void SDL_SetDesktopDisplayMode(SDL_VideoDisplay *display, const SDL_DisplayMode *mode)

{

if (display->desktop_mode.driverdata) {

SDL_free(display->desktop_mode.driverdata);

}

SDL_memcpy(&display->desktop_mode, mode, sizeof(*mode));

}

static int SDL_GetNumDisplayModesForDisplay(SDL_VideoDisplay *display)

{

if (!display->num_display_modes && _this->GetDisplayModes) {

_this->GetDisplayModes(_this, display);

SDL_qsort(display->display_modes, display->num_display_modes,

sizeof(SDL_DisplayMode), cmpmodes);

}

return display->num_display_modes;

}

int SDL_GetNumDisplayModes(int displayIndex)

{

CHECK_DISPLAY_INDEX(displayIndex, -1);

return SDL_GetNumDisplayModesForDisplay(&_this->displays[displayIndex]);

}

void SDL_ResetDisplayModes(int displayIndex)

{

SDL_VideoDisplay *display;

int i;

CHECK_DISPLAY_INDEX(displayIndex, );

display = &_this->displays[displayIndex];

for (i = display->num_display_modes; i--;) {

SDL_free(display->display_modes[i].driverdata);

display->display_modes[i].driverdata = NULL;

}

SDL_free(display->display_modes);

display->display_modes = NULL;

display->num_display_modes = 0;

display->max_display_modes = 0;

}

int SDL_GetDisplayMode(int displayIndex, int index, SDL_DisplayMode *mode)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, -1);

display = &_this->displays[displayIndex];

if (index < 0 || index >= SDL_GetNumDisplayModesForDisplay(display)) {

return SDL_SetError("index must be in the range of 0 - %d", SDL_GetNumDisplayModesForDisplay(display) - 1);

}

if (mode) {

*mode = display->display_modes[index];

}

return 0;

}

int SDL_GetDesktopDisplayMode(int displayIndex, SDL_DisplayMode *mode)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, -1);

display = &_this->displays[displayIndex];

if (mode) {

*mode = display->desktop_mode;

}

return 0;

}

int SDL_GetCurrentDisplayMode(int displayIndex, SDL_DisplayMode *mode)

{

SDL_VideoDisplay *display;

CHECK_DISPLAY_INDEX(displayIndex, -1);

display = &_this->displays[displayIndex];

if (mode) {

*mode = display->current_mode;

}

return 0;

}

static SDL_DisplayMode *SDL_GetClosestDisplayModeForDisplay(SDL_VideoDisplay *display,

const SDL_DisplayMode *mode,

SDL_DisplayMode *closest)

{

Uint32 target_format;

int target_refresh_rate;

int i;

SDL_DisplayMode *current, *match;

if (!mode || !closest) {

SDL_InvalidParamError("mode/closest");

return NULL;

}

/* Default to the desktop format */

if (mode->format) {

target_format = mode->format;

} else {

target_format = display->desktop_mode.format;

}

/* Default to the desktop refresh rate */

if (mode->refresh_rate) {

target_refresh_rate = mode->refresh_rate;

} else {

target_refresh_rate = display->desktop_mode.refresh_rate;

}

match = NULL;

for (i = 0; i < SDL_GetNumDisplayModesForDisplay(display); ++i) {

current = &display->display_modes[i];

if (current->w && (current->w < mode->w)) {

/* Out of sorted modes large enough here */

break;

}

if (current->h && (current->h < mode->h)) {

if (current->w && (current->w == mode->w)) {

/* Out of sorted modes large enough here */

break;

}

/* Wider, but not tall enough, due to a different

aspect ratio. This mode must be skipped, but closer

modes may still follow. */

continue;

}

if (!match || current->w < match->w || current->h < match->h) {

match = current;

continue;

}

if (current->format != match->format) {

/* Sorted highest depth to lowest */

if (current->format == target_format ||

(SDL_BITSPERPIXEL(current->format) >=

SDL_BITSPERPIXEL(target_format) &&

SDL_PIXELTYPE(current->format) ==

SDL_PIXELTYPE(target_format))) {

match = current;

}