From 4374645738fc1112a6eefc5f6e3b0e1da384da3f Mon Sep 17 00:00:00 2001 From: Elad Lahav Date: Sat, 7 Jan 2023 06:29:03 -0500 Subject: [PATCH] Add QNX video and audio modules --- CMakeLists.txt | 7 + cmake/sdlchecks.cmake | 16 + include/build_config/SDL_build_config.h.cmake | 2 + src/audio/SDL_audio.c | 3 + src/audio/SDL_sysaudio.h | 1 + src/audio/qnx/SDL_qsa_audio.c | 682 ++++++++++++++++++ src/audio/qnx/SDL_qsa_audio.h | 57 ++ src/video/SDL_sysvideo.h | 1 + src/video/SDL_video.c | 3 + src/video/qnx/gl.c | 286 ++++++++ src/video/qnx/keyboard.c | 133 ++++ src/video/qnx/sdl_qnx.h | 48 ++ src/video/qnx/video.c | 357 +++++++++ 13 files changed, 1596 insertions(+) create mode 100644 src/audio/qnx/SDL_qsa_audio.c create mode 100644 src/audio/qnx/SDL_qsa_audio.h create mode 100644 src/video/qnx/gl.c create mode 100644 src/video/qnx/keyboard.c create mode 100644 src/video/qnx/sdl_qnx.h create mode 100644 src/video/qnx/video.c diff --git a/CMakeLists.txt b/CMakeLists.txt index bd8cc234d..c28e14910 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1534,6 +1534,12 @@ elseif(UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU) file(GLOB NETBSD_AUDIO_SOURCES ${SDL3_SOURCE_DIR}/src/audio/netbsd/*.c) list(APPEND SOURCE_FILES ${NETBSD_AUDIO_SOURCES}) set(HAVE_SDL_AUDIO TRUE) + elseif(QNX) + set(SDL_AUDIO_DRIVER_QNX 1) + file(GLOB QNX_AUDIO_SOURCES ${SDL3_SOURCE_DIR}/src/audio/qnx/*.c) + list(APPEND SOURCE_FILES ${QNX_AUDIO_SOURCES}) + list(APPEND EXTRA_LIBS asound) + set(HAVE_SDL_AUDIO TRUE) endif() CheckOSS() CheckALSA() @@ -1562,6 +1568,7 @@ elseif(UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU) set(SDL_VIDEO_VULKAN 1) set(HAVE_VULKAN TRUE) endif() + CheckQNXScreen() endif() if(UNIX) diff --git a/cmake/sdlchecks.cmake b/cmake/sdlchecks.cmake index 784eb8e6e..4e7ac1e58 100644 --- a/cmake/sdlchecks.cmake +++ b/cmake/sdlchecks.cmake @@ -756,6 +756,22 @@ macro(CheckOpenGLES) endif() endmacro() +# Requires: +# - EGL +macro(CheckQNXScreen) + if(QNX AND HAVE_OPENGL_EGL) + check_c_source_compiles(" + #include + int main (int argc, char** argv) { return 0; }" HAVE_QNX_SCREEN) + if(HAVE_QNX_SCREEN) + set(SDL_VIDEO_DRIVER_QNX 1) + file(GLOB QNX_VIDEO_SOURCES ${SDL3_SOURCE_DIR}/src/video/qnx/*.c) + list(APPEND SOURCE_FILES ${QNX_VIDEO_SOURCES}) + list(APPEND EXTRA_LIBS screen EGL) + endif() + endif() +endmacro() + # Requires: # - nada # Optional: diff --git a/include/build_config/SDL_build_config.h.cmake b/include/build_config/SDL_build_config.h.cmake index 3b7814ba4..3320b5cd5 100644 --- a/include/build_config/SDL_build_config.h.cmake +++ b/include/build_config/SDL_build_config.h.cmake @@ -303,6 +303,7 @@ #cmakedefine SDL_AUDIO_DRIVER_PSP @SDL_AUDIO_DRIVER_PSP@ #cmakedefine SDL_AUDIO_DRIVER_PS2 @SDL_AUDIO_DRIVER_PS2@ #cmakedefine SDL_AUDIO_DRIVER_N3DS @SDL_AUDIO_DRIVER_N3DS@ +#cmakedefine SDL_AUDIO_DRIVER_QNX @SDL_AUDIO_DRIVER_QNX@ /* Enable various input drivers */ #cmakedefine SDL_INPUT_LINUXEV @SDL_INPUT_LINUXEV@ @@ -419,6 +420,7 @@ #cmakedefine SDL_VIDEO_DRIVER_X11_XRANDR @SDL_VIDEO_DRIVER_X11_XRANDR@ #cmakedefine SDL_VIDEO_DRIVER_X11_XSCRNSAVER @SDL_VIDEO_DRIVER_X11_XSCRNSAVER@ #cmakedefine SDL_VIDEO_DRIVER_X11_XSHAPE @SDL_VIDEO_DRIVER_X11_XSHAPE@ +#cmakedefine SDL_VIDEO_DRIVER_QNX @SDL_VIDEO_DRIVER_QNX@ #ifdef SDL_VIDEO_DRIVER_ANDROID #define SDL_ENABLE_SYSWM_ANDROID diff --git a/src/audio/SDL_audio.c b/src/audio/SDL_audio.c index e8dd7f5c7..282b1a7ae 100644 --- a/src/audio/SDL_audio.c +++ b/src/audio/SDL_audio.c @@ -91,6 +91,9 @@ static const AudioBootStrap *const bootstrap[] = { #if SDL_AUDIO_DRIVER_OSS &DSP_bootstrap, #endif +#if SDL_AUDIO_DRIVER_QNX + &QSAAUDIO_bootstrap, +#endif #if SDL_AUDIO_DRIVER_DISK &DISKAUDIO_bootstrap, #endif diff --git a/src/audio/SDL_sysaudio.h b/src/audio/SDL_sysaudio.h index 29e1d00c8..7fb7ac591 100644 --- a/src/audio/SDL_sysaudio.h +++ b/src/audio/SDL_sysaudio.h @@ -198,5 +198,6 @@ extern AudioBootStrap PSPAUDIO_bootstrap; extern AudioBootStrap VITAAUD_bootstrap; extern AudioBootStrap N3DSAUDIO_bootstrap; extern AudioBootStrap EMSCRIPTENAUDIO_bootstrap; +extern AudioBootStrap QSAAUDIO_bootstrap; #endif /* SDL_sysaudio_h_ */ diff --git a/src/audio/qnx/SDL_qsa_audio.c b/src/audio/qnx/SDL_qsa_audio.c new file mode 100644 index 000000000..d94ba4877 --- /dev/null +++ b/src/audio/qnx/SDL_qsa_audio.c @@ -0,0 +1,682 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2021 Sam Lantinga + + 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. +*/ + +/* + * !!! FIXME: streamline this a little by removing all the + * !!! FIXME: if (capture) {} else {} sections that are identical + * !!! FIXME: except for one flag. + */ + +/* !!! FIXME: can this target support hotplugging? */ + +#include "../../SDL_internal.h" + +#if SDL_AUDIO_DRIVER_QNX + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "SDL3/SDL_timer.h" +#include "SDL3/SDL_audio.h" +#include "../../core/unix/SDL_poll.h" +#include "../SDL_audio_c.h" +#include "SDL_qsa_audio.h" + +/* default channel communication parameters */ +#define DEFAULT_CPARAMS_RATE 44100 +#define DEFAULT_CPARAMS_VOICES 1 + +#define DEFAULT_CPARAMS_FRAG_SIZE 4096 +#define DEFAULT_CPARAMS_FRAGS_MIN 1 +#define DEFAULT_CPARAMS_FRAGS_MAX 1 + +/* List of found devices */ +#define QSA_MAX_DEVICES 32 +#define QSA_MAX_NAME_LENGTH 81+16 /* Hardcoded in QSA, can't be changed */ + +typedef struct _QSA_Device +{ + char name[QSA_MAX_NAME_LENGTH]; /* Long audio device name for SDL */ + int cardno; + int deviceno; +} QSA_Device; + +QSA_Device qsa_playback_device[QSA_MAX_DEVICES]; +uint32_t qsa_playback_devices; + +QSA_Device qsa_capture_device[QSA_MAX_DEVICES]; +uint32_t qsa_capture_devices; + +static SDL_INLINE int +QSA_SetError(const char *fn, int status) +{ + return SDL_SetError("QSA: %s() failed: %s", fn, snd_strerror(status)); +} + +/* !!! FIXME: does this need to be here? Does the SDL version not work? */ +static void +QSA_ThreadInit(_THIS) +{ + /* Increase default 10 priority to 25 to avoid jerky sound */ + struct sched_param param; + if (SchedGet(0, 0, ¶m) != -1) { + param.sched_priority = param.sched_curpriority + 15; + SchedSet(0, 0, SCHED_NOCHANGE, ¶m); + } +} + +/* PCM channel parameters initialize function */ +static void +QSA_InitAudioParams(snd_pcm_channel_params_t * cpars) +{ + SDL_zerop(cpars); + cpars->channel = SND_PCM_CHANNEL_PLAYBACK; + cpars->mode = SND_PCM_MODE_BLOCK; + cpars->start_mode = SND_PCM_START_DATA; + cpars->stop_mode = SND_PCM_STOP_STOP; + cpars->format.format = SND_PCM_SFMT_S16_LE; + cpars->format.interleave = 1; + cpars->format.rate = DEFAULT_CPARAMS_RATE; + cpars->format.voices = DEFAULT_CPARAMS_VOICES; + cpars->buf.block.frag_size = DEFAULT_CPARAMS_FRAG_SIZE; + cpars->buf.block.frags_min = DEFAULT_CPARAMS_FRAGS_MIN; + cpars->buf.block.frags_max = DEFAULT_CPARAMS_FRAGS_MAX; +} + +/* This function waits until it is possible to write a full sound buffer */ +static void +QSA_WaitDevice(_THIS) +{ + int result; + + /* Setup timeout for playing one fragment equal to 2 seconds */ + /* If timeout occured than something wrong with hardware or driver */ + /* For example, Vortex 8820 audio driver stucks on second DAC because */ + /* it doesn't exist ! */ + result = SDL_IOReady(this->hidden->audio_fd, + this->hidden->iscapture ? SDL_IOR_READ : SDL_IOR_WRITE, + 2 * 1000); + switch (result) { + case -1: + SDL_SetError("QSA: SDL_IOReady() failed: %s", strerror(errno)); + break; + case 0: + SDL_SetError("QSA: timeout on buffer waiting occured"); + this->hidden->timeout_on_wait = 1; + break; + default: + this->hidden->timeout_on_wait = 0; + break; + } +} + +static void +QSA_PlayDevice(_THIS) +{ + snd_pcm_channel_status_t cstatus; + int written; + int status; + int towrite; + void *pcmbuffer; + + if (!SDL_AtomicGet(&this->enabled) || !this->hidden) { + return; + } + + towrite = this->spec.size; + pcmbuffer = this->hidden->pcm_buf; + + /* Write the audio data, checking for EAGAIN (buffer full) and underrun */ + do { + written = + snd_pcm_plugin_write(this->hidden->audio_handle, pcmbuffer, + towrite); + if (written != towrite) { + /* Check if samples playback got stuck somewhere in hardware or in */ + /* the audio device driver */ + if ((errno == EAGAIN) && (written == 0)) { + if (this->hidden->timeout_on_wait != 0) { + SDL_SetError("QSA: buffer playback timeout"); + return; + } + } + + /* Check for errors or conditions */ + if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { + /* Let a little CPU time go by and try to write again */ + SDL_Delay(1); + + /* if we wrote some data */ + towrite -= written; + pcmbuffer += written * this->spec.channels; + continue; + } else { + if ((errno == EINVAL) || (errno == EIO)) { + SDL_zero(cstatus); + if (!this->hidden->iscapture) { + cstatus.channel = SND_PCM_CHANNEL_PLAYBACK; + } else { + cstatus.channel = SND_PCM_CHANNEL_CAPTURE; + } + + status = + snd_pcm_plugin_status(this->hidden->audio_handle, + &cstatus); + if (status < 0) { + QSA_SetError("snd_pcm_plugin_status", status); + return; + } + + if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) || + (cstatus.status == SND_PCM_STATUS_READY)) { + if (!this->hidden->iscapture) { + status = + snd_pcm_plugin_prepare(this->hidden-> + audio_handle, + SND_PCM_CHANNEL_PLAYBACK); + } else { + status = + snd_pcm_plugin_prepare(this->hidden-> + audio_handle, + SND_PCM_CHANNEL_CAPTURE); + } + if (status < 0) { + QSA_SetError("snd_pcm_plugin_prepare", status); + return; + } + } + continue; + } else { + return; + } + } + } else { + /* we wrote all remaining data */ + towrite -= written; + pcmbuffer += written * this->spec.channels; + } + } while ((towrite > 0) && SDL_AtomicGet(&this->enabled)); + + /* If we couldn't write, assume fatal error for now */ + if (towrite != 0) { + SDL_OpenedAudioDeviceDisconnected(this); + } +} + +static Uint8 * +QSA_GetDeviceBuf(_THIS) +{ + return this->hidden->pcm_buf; +} + +static void +QSA_CloseDevice(_THIS) +{ + if (this->hidden->audio_handle != NULL) { +#if _NTO_VERSION < 710 + if (!this->hidden->iscapture) { + /* Finish playing available samples */ + snd_pcm_plugin_flush(this->hidden->audio_handle, + SND_PCM_CHANNEL_PLAYBACK); + } else { + /* Cancel unread samples during capture */ + snd_pcm_plugin_flush(this->hidden->audio_handle, + SND_PCM_CHANNEL_CAPTURE); + } +#endif + snd_pcm_close(this->hidden->audio_handle); + } + + SDL_free(this->hidden->pcm_buf); + SDL_free(this->hidden); +} + +static int +QSA_OpenDevice(_THIS, const char *devname) +{ +#if 0 + /* !!! FIXME: SDL2 used to pass this handle. What's the alternative? */ + const QSA_Device *device = (const QSA_Device *) handle; +#else + const QSA_Device *device = NULL; +#endif + int status = 0; + int format = 0; + SDL_AudioFormat test_format = 0; + int found = 0; + snd_pcm_channel_setup_t csetup; + snd_pcm_channel_params_t cparams; + SDL_bool iscapture = this->iscapture; + + /* Initialize all variables that we clean on shutdown */ + this->hidden = + (struct SDL_PrivateAudioData *) SDL_calloc(1, + (sizeof + (struct + SDL_PrivateAudioData))); + if (this->hidden == NULL) { + return SDL_OutOfMemory(); + } + + /* Initialize channel transfer parameters to default */ + QSA_InitAudioParams(&cparams); + + /* Initialize channel direction: capture or playback */ + this->hidden->iscapture = iscapture ? SDL_TRUE : SDL_FALSE; + + if (device != NULL) { + /* Open requested audio device */ + this->hidden->deviceno = device->deviceno; + this->hidden->cardno = device->cardno; + status = snd_pcm_open(&this->hidden->audio_handle, + device->cardno, device->deviceno, + iscapture ? SND_PCM_OPEN_CAPTURE : SND_PCM_OPEN_PLAYBACK); + } else { + /* Open system default audio device */ + status = snd_pcm_open_preferred(&this->hidden->audio_handle, + &this->hidden->cardno, + &this->hidden->deviceno, + iscapture ? SND_PCM_OPEN_CAPTURE : SND_PCM_OPEN_PLAYBACK); + } + + /* Check if requested device is opened */ + if (status < 0) { + this->hidden->audio_handle = NULL; + return QSA_SetError("snd_pcm_open", status); + } + + /* Try for a closest match on audio format */ + format = 0; + /* can't use format as SND_PCM_SFMT_U8 = 0 in qsa */ + found = 0; + + for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;) { + /* if match found set format to equivalent QSA format */ + switch (test_format) { + case AUDIO_U8: + { + format = SND_PCM_SFMT_U8; + found = 1; + } + break; + case AUDIO_S8: + { + format = SND_PCM_SFMT_S8; + found = 1; + } + break; + case AUDIO_S16LSB: + { + format = SND_PCM_SFMT_S16_LE; + found = 1; + } + break; + case AUDIO_S16MSB: + { + format = SND_PCM_SFMT_S16_BE; + found = 1; + } + break; + case AUDIO_U16LSB: + { + format = SND_PCM_SFMT_U16_LE; + found = 1; + } + break; + case AUDIO_U16MSB: + { + format = SND_PCM_SFMT_U16_BE; + found = 1; + } + break; + case AUDIO_S32LSB: + { + format = SND_PCM_SFMT_S32_LE; + found = 1; + } + break; + case AUDIO_S32MSB: + { + format = SND_PCM_SFMT_S32_BE; + found = 1; + } + break; + case AUDIO_F32LSB: + { + format = SND_PCM_SFMT_FLOAT_LE; + found = 1; + } + break; + case AUDIO_F32MSB: + { + format = SND_PCM_SFMT_FLOAT_BE; + found = 1; + } + break; + default: + { + break; + } + } + + if (!found) { + test_format = SDL_NextAudioFormat(); + } + } + + /* assumes test_format not 0 on success */ + if (test_format == 0) { + return SDL_SetError("QSA: Couldn't find any hardware audio formats"); + } + + this->spec.format = test_format; + + /* Set the audio format */ + cparams.format.format = format; + + /* Set mono/stereo/4ch/6ch/8ch audio */ + cparams.format.voices = this->spec.channels; + + /* Set rate */ + cparams.format.rate = this->spec.freq; + + /* Setup the transfer parameters according to cparams */ + status = snd_pcm_plugin_params(this->hidden->audio_handle, &cparams); + if (status < 0) { + return QSA_SetError("snd_pcm_plugin_params", status); + } + + /* Make sure channel is setup right one last time */ + SDL_zero(csetup); + if (!this->hidden->iscapture) { + csetup.channel = SND_PCM_CHANNEL_PLAYBACK; + } else { + csetup.channel = SND_PCM_CHANNEL_CAPTURE; + } + + /* Setup an audio channel */ + if (snd_pcm_plugin_setup(this->hidden->audio_handle, &csetup) < 0) { + return SDL_SetError("QSA: Unable to setup channel"); + } + + /* Calculate the final parameters for this audio specification */ + SDL_CalculateAudioSpec(&this->spec); + + this->hidden->pcm_len = this->spec.size; + + if (this->hidden->pcm_len == 0) { + this->hidden->pcm_len = + csetup.buf.block.frag_size * this->spec.channels * + (snd_pcm_format_width(format) / 8); + } + + /* + * Allocate memory to the audio buffer and initialize with silence + * (Note that buffer size must be a multiple of fragment size, so find + * closest multiple) + */ + this->hidden->pcm_buf = + (Uint8 *) SDL_malloc(this->hidden->pcm_len); + if (this->hidden->pcm_buf == NULL) { + return SDL_OutOfMemory(); + } + SDL_memset(this->hidden->pcm_buf, this->spec.silence, + this->hidden->pcm_len); + + /* get the file descriptor */ + if (!this->hidden->iscapture) { + this->hidden->audio_fd = + snd_pcm_file_descriptor(this->hidden->audio_handle, + SND_PCM_CHANNEL_PLAYBACK); + } else { + this->hidden->audio_fd = + snd_pcm_file_descriptor(this->hidden->audio_handle, + SND_PCM_CHANNEL_CAPTURE); + } + + if (this->hidden->audio_fd < 0) { + return QSA_SetError("snd_pcm_file_descriptor", status); + } + + /* Prepare an audio channel */ + if (!this->hidden->iscapture) { + /* Prepare audio playback */ + status = + snd_pcm_plugin_prepare(this->hidden->audio_handle, + SND_PCM_CHANNEL_PLAYBACK); + } else { + /* Prepare audio capture */ + status = + snd_pcm_plugin_prepare(this->hidden->audio_handle, + SND_PCM_CHANNEL_CAPTURE); + } + + if (status < 0) { + return QSA_SetError("snd_pcm_plugin_prepare", status); + } + + /* We're really ready to rock and roll. :-) */ + return 0; +} + +static void +QSA_DetectDevices(void) +{ + uint32_t it; + uint32_t cards; + uint32_t devices; + int32_t status; + + /* Detect amount of available devices */ + /* this value can be changed in the runtime */ + cards = snd_cards(); + + /* If io-audio manager is not running we will get 0 as number */ + /* of available audio devices */ + if (cards == 0) { + /* We have no any available audio devices */ + return; + } + + /* !!! FIXME: code duplication */ + /* Find requested devices by type */ + { /* output devices */ + /* Playback devices enumeration requested */ + for (it = 0; it < cards; it++) { + devices = 0; + do { + status = + snd_card_get_longname(it, + qsa_playback_device + [qsa_playback_devices].name, + QSA_MAX_NAME_LENGTH); + if (status == EOK) { + snd_pcm_t *handle; + + /* Add device number to device name */ + sprintf(qsa_playback_device[qsa_playback_devices].name + + SDL_strlen(qsa_playback_device + [qsa_playback_devices].name), " d%d", + devices); + + /* Store associated card number id */ + qsa_playback_device[qsa_playback_devices].cardno = it; + + /* Check if this device id could play anything */ + status = + snd_pcm_open(&handle, it, devices, + SND_PCM_OPEN_PLAYBACK); + if (status == EOK) { + qsa_playback_device[qsa_playback_devices].deviceno = + devices; + status = snd_pcm_close(handle); + if (status == EOK) { + /* Note that spec is NULL, because we are required to open the device before + * acquiring the mix format, making this information inaccessible at + * enumeration time + */ + SDL_AddAudioDevice(SDL_FALSE, qsa_playback_device[qsa_playback_devices].name, NULL, &qsa_playback_device[qsa_playback_devices]); + qsa_playback_devices++; + } + } else { + /* Check if we got end of devices list */ + if (status == -ENOENT) { + break; + } + } + } else { + break; + } + + /* Check if we reached maximum devices count */ + if (qsa_playback_devices >= QSA_MAX_DEVICES) { + break; + } + devices++; + } while (1); + + /* Check if we reached maximum devices count */ + if (qsa_playback_devices >= QSA_MAX_DEVICES) { + break; + } + } + } + + { /* capture devices */ + /* Capture devices enumeration requested */ + for (it = 0; it < cards; it++) { + devices = 0; + do { + status = + snd_card_get_longname(it, + qsa_capture_device + [qsa_capture_devices].name, + QSA_MAX_NAME_LENGTH); + if (status == EOK) { + snd_pcm_t *handle; + + /* Add device number to device name */ + sprintf(qsa_capture_device[qsa_capture_devices].name + + SDL_strlen(qsa_capture_device + [qsa_capture_devices].name), " d%d", + devices); + + /* Store associated card number id */ + qsa_capture_device[qsa_capture_devices].cardno = it; + + /* Check if this device id could play anything */ + status = + snd_pcm_open(&handle, it, devices, + SND_PCM_OPEN_CAPTURE); + if (status == EOK) { + qsa_capture_device[qsa_capture_devices].deviceno = + devices; + status = snd_pcm_close(handle); + if (status == EOK) { + /* Note that spec is NULL, because we are required to open the device before + * acquiring the mix format, making this information inaccessible at + * enumeration time + */ + SDL_AddAudioDevice(SDL_TRUE, qsa_capture_device[qsa_capture_devices].name, NULL, &qsa_capture_device[qsa_capture_devices]); + qsa_capture_devices++; + } + } else { + /* Check if we got end of devices list */ + if (status == -ENOENT) { + break; + } + } + + /* Check if we reached maximum devices count */ + if (qsa_capture_devices >= QSA_MAX_DEVICES) { + break; + } + } else { + break; + } + devices++; + } while (1); + + /* Check if we reached maximum devices count */ + if (qsa_capture_devices >= QSA_MAX_DEVICES) { + break; + } + } + } +} + +static void +QSA_Deinitialize(void) +{ + /* Clear devices array on shutdown */ + /* !!! FIXME: we zero these on init...any reason to do it here? */ + SDL_zeroa(qsa_playback_device); + SDL_zeroa(qsa_capture_device); + qsa_playback_devices = 0; + qsa_capture_devices = 0; +} + +static SDL_bool +QSA_Init(SDL_AudioDriverImpl * impl) +{ + /* Clear devices array */ + SDL_zeroa(qsa_playback_device); + SDL_zeroa(qsa_capture_device); + qsa_playback_devices = 0; + qsa_capture_devices = 0; + + /* Set function pointers */ + /* DeviceLock and DeviceUnlock functions are used default, */ + /* provided by SDL, which uses pthread_mutex for lock/unlock */ + impl->DetectDevices = QSA_DetectDevices; + impl->OpenDevice = QSA_OpenDevice; + impl->ThreadInit = QSA_ThreadInit; + impl->WaitDevice = QSA_WaitDevice; + impl->PlayDevice = QSA_PlayDevice; + impl->GetDeviceBuf = QSA_GetDeviceBuf; + impl->CloseDevice = QSA_CloseDevice; + impl->Deinitialize = QSA_Deinitialize; + impl->LockDevice = NULL; + impl->UnlockDevice = NULL; + + impl->ProvidesOwnCallbackThread = 0; + impl->HasCaptureSupport = 1; + impl->OnlyHasDefaultOutputDevice = 0; + impl->OnlyHasDefaultCaptureDevice = 0; + + return SDL_TRUE; /* this audio target is available. */ +} + +AudioBootStrap QSAAUDIO_bootstrap = { + "qsa", "QNX QSA Audio", QSA_Init, 0 +}; + +#endif /* SDL_AUDIO_DRIVER_QNX */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/audio/qnx/SDL_qsa_audio.h b/src/audio/qnx/SDL_qsa_audio.h new file mode 100644 index 000000000..ea46be687 --- /dev/null +++ b/src/audio/qnx/SDL_qsa_audio.h @@ -0,0 +1,57 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2021 Sam Lantinga + + 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" + +#ifndef __SDL_QSA_AUDIO_H__ +#define __SDL_QSA_AUDIO_H__ + +#include + +#include "../SDL_sysaudio.h" + +/* Hidden "this" pointer for the audio functions */ +#define _THIS SDL_AudioDevice* this + +struct SDL_PrivateAudioData +{ + /* SDL capture state */ + SDL_bool iscapture; + + /* The audio device handle */ + int cardno; + int deviceno; + snd_pcm_t *audio_handle; + + /* The audio file descriptor */ + int audio_fd; + + /* Select timeout status */ + uint32_t timeout_on_wait; + + /* Raw mixing buffer */ + Uint8 *pcm_buf; + Uint32 pcm_len; +}; + +#endif /* __SDL_QSA_AUDIO_H__ */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/video/SDL_sysvideo.h b/src/video/SDL_sysvideo.h index b256f2744..8e90d3a4f 100644 --- a/src/video/SDL_sysvideo.h +++ b/src/video/SDL_sysvideo.h @@ -483,6 +483,7 @@ extern VideoBootStrap VIVANTE_bootstrap; extern VideoBootStrap Emscripten_bootstrap; extern VideoBootStrap OFFSCREEN_bootstrap; extern VideoBootStrap NGAGE_bootstrap; +extern VideoBootStrap QNX_bootstrap; /* Use SDL_OnVideoThread() sparingly, to avoid regressions in use cases that currently happen to work */ extern SDL_bool SDL_OnVideoThread(void); diff --git a/src/video/SDL_video.c b/src/video/SDL_video.c index dd3bcdeef..3f8b50dda 100644 --- a/src/video/SDL_video.c +++ b/src/video/SDL_video.c @@ -115,6 +115,9 @@ static VideoBootStrap *bootstrap[] = { #if SDL_VIDEO_DRIVER_EMSCRIPTEN &Emscripten_bootstrap, #endif +#if SDL_VIDEO_DRIVER_QNX + &QNX_bootstrap, +#endif #if SDL_VIDEO_DRIVER_OFFSCREEN &OFFSCREEN_bootstrap, #endif diff --git a/src/video/qnx/gl.c b/src/video/qnx/gl.c new file mode 100644 index 000000000..29393fbaa --- /dev/null +++ b/src/video/qnx/gl.c @@ -0,0 +1,286 @@ +/* + Simple DirectMedia Layer + Copyright (C) 2017 BlackBerry Limited + + 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" +#include "sdl_qnx.h" + +static EGLDisplay egl_disp; + +/** + * Detertmines the pixel format to use based on the current display and EGL + * configuration. + * @param egl_conf EGL configuration to use + * @return A SCREEN_FORMAT* constant for the pixel format to use + */ +static int +chooseFormat(EGLConfig egl_conf) +{ + EGLint buffer_bit_depth; + EGLint alpha_bit_depth; + + eglGetConfigAttrib(egl_disp, egl_conf, EGL_BUFFER_SIZE, &buffer_bit_depth); + eglGetConfigAttrib(egl_disp, egl_conf, EGL_ALPHA_SIZE, &alpha_bit_depth); + + switch (buffer_bit_depth) { + case 32: + return SCREEN_FORMAT_RGBX8888; + case 24: + return SCREEN_FORMAT_RGB888; + case 16: + switch (alpha_bit_depth) { + case 4: + return SCREEN_FORMAT_RGBX4444; + case 1: + return SCREEN_FORMAT_RGBA5551; + default: + return SCREEN_FORMAT_RGB565; + } + default: + return 0; + } +} + +/** + * Enumerates the supported EGL configurations and chooses a suitable one. + * @param[out] pconf The chosen configuration + * @param[out] pformat The chosen pixel format + * @return 0 if successful, -1 on error + */ +int +glGetConfig(EGLConfig *pconf, int *pformat) +{ + EGLConfig egl_conf = (EGLConfig)0; + EGLConfig *egl_configs; + EGLint egl_num_configs; + EGLint val; + EGLBoolean rc; + EGLint i; + + // Determine the numbfer of configurations. + rc = eglGetConfigs(egl_disp, NULL, 0, &egl_num_configs); + if (rc != EGL_TRUE) { + return -1; + } + + if (egl_num_configs == 0) { + return -1; + } + + // Allocate enough memory for all configurations. + egl_configs = SDL_malloc(egl_num_configs * sizeof(*egl_configs)); + if (egl_configs == NULL) { + return -1; + } + + // Get the list of configurations. + rc = eglGetConfigs(egl_disp, egl_configs, egl_num_configs, + &egl_num_configs); + if (rc != EGL_TRUE) { + SDL_free(egl_configs); + return -1; + } + + // Find a good configuration. + for (i = 0; i < egl_num_configs; i++) { + eglGetConfigAttrib(egl_disp, egl_configs[i], EGL_SURFACE_TYPE, &val); + if (!(val & EGL_WINDOW_BIT)) { + continue; + } + + eglGetConfigAttrib(egl_disp, egl_configs[i], EGL_RENDERABLE_TYPE, &val); + if (!(val & EGL_OPENGL_ES2_BIT)) { + continue; + } + + eglGetConfigAttrib(egl_disp, egl_configs[i], EGL_DEPTH_SIZE, &val); + if (val == 0) { + continue; + } + + egl_conf = egl_configs[i]; + break; + } + + SDL_free(egl_configs); + *pconf = egl_conf; + *pformat = chooseFormat(egl_conf); + + return 0; +} + +/** + * Initializes the EGL library. + * @param _THIS + * @param name unused + * @return 0 if successful, -1 on error + */ +int +glLoadLibrary(_THIS, const char *name) +{ + EGLNativeDisplayType disp_id = EGL_DEFAULT_DISPLAY; + + egl_disp = eglGetDisplay(disp_id); + if (egl_disp == EGL_NO_DISPLAY) { + return -1; + } + + if (eglInitialize(egl_disp, NULL, NULL) == EGL_FALSE) { + return -1; + } + + return 0; +} + +/** + * Finds the address of an EGL extension function. + * @param proc Function name + * @return Function address + */ +void * +glGetProcAddress(_THIS, const char *proc) +{ + return eglGetProcAddress(proc); +} + +/** + * Associates the given window with the necessary EGL structures for drawing and + * displaying content. + * @param _THIS + * @param window The SDL window to create the context for + * @return A pointer to the created context, if successful, NULL on error + */ +SDL_GLContext +glCreateContext(_THIS, SDL_Window *window) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + EGLContext context; + EGLSurface surface; + + struct { + EGLint client_version[2]; + EGLint none; + } egl_ctx_attr = { + .client_version = { EGL_CONTEXT_CLIENT_VERSION, 2 }, + .none = EGL_NONE + }; + + struct { + EGLint render_buffer[2]; + EGLint none; + } egl_surf_attr = { + .render_buffer = { EGL_RENDER_BUFFER, EGL_BACK_BUFFER }, + .none = EGL_NONE + }; + + context = eglCreateContext(egl_disp, impl->conf, EGL_NO_CONTEXT, + (EGLint *)&egl_ctx_attr); + if (context == EGL_NO_CONTEXT) { + return NULL; + } + + surface = eglCreateWindowSurface(egl_disp, impl->conf, + (EGLNativeWindowType)impl->window, + (EGLint *)&egl_surf_attr); + if (surface == EGL_NO_SURFACE) { + return NULL; + } + + eglMakeCurrent(egl_disp, surface, surface, context); + + impl->surface = surface; + return context; +} + +/** + * Sets a new value for the number of frames to display before swapping buffers. + * @param _THIS + * @param interval New interval value + * @return 0 if successful, -1 on error + */ +int +glSetSwapInterval(_THIS, int interval) +{ + if (eglSwapInterval(egl_disp, interval) != EGL_TRUE) { + return -1; + } + + return 0; +} + +/** + * Swaps the EGL buffers associated with the given window + * @param _THIS + * @param window Window to swap buffers for + * @return 0 if successful, -1 on error + */ +int +glSwapWindow(_THIS, SDL_Window *window) +{ + /* !!! FIXME: should we migrate this all over to use SDL_egl.c? */ + window_impl_t *impl = (window_impl_t *)window->driverdata; + return eglSwapBuffers(egl_disp, impl->surface) == EGL_TRUE ? 0 : -1; +} + +/** + * Makes the given context the current one for drawing operations. + * @param _THIS + * @param window SDL window associated with the context (maybe NULL) + * @param context The context to activate + * @return 0 if successful, -1 on error + */ +int +glMakeCurrent(_THIS, SDL_Window *window, SDL_GLContext context) +{ + window_impl_t *impl; + EGLSurface surface = NULL; + + if (window) { + impl = (window_impl_t *)window->driverdata; + surface = impl->surface; + } + + if (eglMakeCurrent(egl_disp, surface, surface, context) != EGL_TRUE) { + return -1; + } + + return 0; +} + +/** + * Destroys a context. + * @param _THIS + * @param context The context to destroy + */ +void +glDeleteContext(_THIS, SDL_GLContext context) +{ + eglDestroyContext(egl_disp, context); +} + +/** + * Terminates access to the EGL library. + * @param _THIS + */ +void +glUnloadLibrary(_THIS) +{ + eglTerminate(egl_disp); +} diff --git a/src/video/qnx/keyboard.c b/src/video/qnx/keyboard.c new file mode 100644 index 000000000..485a5c70c --- /dev/null +++ b/src/video/qnx/keyboard.c @@ -0,0 +1,133 @@ +/* + Simple DirectMedia Layer + Copyright (C) 2017 BlackBerry Limited + + 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" +#include "../../events/SDL_keyboard_c.h" +#include "SDL3/SDL_scancode.h" +#include "SDL3/SDL_events.h" +#include "sdl_qnx.h" +#include + +/** + * A map thta translates Screen key names to SDL scan codes. + * This map is incomplete, but should include most major keys. + */ +static int key_to_sdl[] = { + [KEYCODE_SPACE] = SDL_SCANCODE_SPACE, + [KEYCODE_APOSTROPHE] = SDL_SCANCODE_APOSTROPHE, + [KEYCODE_COMMA] = SDL_SCANCODE_COMMA, + [KEYCODE_MINUS] = SDL_SCANCODE_MINUS, + [KEYCODE_PERIOD] = SDL_SCANCODE_PERIOD, + [KEYCODE_SLASH] = SDL_SCANCODE_SLASH, + [KEYCODE_ZERO] = SDL_SCANCODE_0, + [KEYCODE_ONE] = SDL_SCANCODE_1, + [KEYCODE_TWO] = SDL_SCANCODE_2, + [KEYCODE_THREE] = SDL_SCANCODE_3, + [KEYCODE_FOUR] = SDL_SCANCODE_4, + [KEYCODE_FIVE] = SDL_SCANCODE_5, + [KEYCODE_SIX] = SDL_SCANCODE_6, + [KEYCODE_SEVEN] = SDL_SCANCODE_7, + [KEYCODE_EIGHT] = SDL_SCANCODE_8, + [KEYCODE_NINE] = SDL_SCANCODE_9, + [KEYCODE_SEMICOLON] = SDL_SCANCODE_SEMICOLON, + [KEYCODE_EQUAL] = SDL_SCANCODE_EQUALS, + [KEYCODE_LEFT_BRACKET] = SDL_SCANCODE_LEFTBRACKET, + [KEYCODE_BACK_SLASH] = SDL_SCANCODE_BACKSLASH, + [KEYCODE_RIGHT_BRACKET] = SDL_SCANCODE_RIGHTBRACKET, + [KEYCODE_GRAVE] = SDL_SCANCODE_GRAVE, + [KEYCODE_A] = SDL_SCANCODE_A, + [KEYCODE_B] = SDL_SCANCODE_B, + [KEYCODE_C] = SDL_SCANCODE_C, + [KEYCODE_D] = SDL_SCANCODE_D, + [KEYCODE_E] = SDL_SCANCODE_E, + [KEYCODE_F] = SDL_SCANCODE_F, + [KEYCODE_G] = SDL_SCANCODE_G, + [KEYCODE_H] = SDL_SCANCODE_H, + [KEYCODE_I] = SDL_SCANCODE_I, + [KEYCODE_J] = SDL_SCANCODE_J, + [KEYCODE_K] = SDL_SCANCODE_K, + [KEYCODE_L] = SDL_SCANCODE_L, + [KEYCODE_M] = SDL_SCANCODE_M, + [KEYCODE_N] = SDL_SCANCODE_N, + [KEYCODE_O] = SDL_SCANCODE_O, + [KEYCODE_P] = SDL_SCANCODE_P, + [KEYCODE_Q] = SDL_SCANCODE_Q, + [KEYCODE_R] = SDL_SCANCODE_R, + [KEYCODE_S] = SDL_SCANCODE_S, + [KEYCODE_T] = SDL_SCANCODE_T, + [KEYCODE_U] = SDL_SCANCODE_U, + [KEYCODE_V] = SDL_SCANCODE_V, + [KEYCODE_W] = SDL_SCANCODE_W, + [KEYCODE_X] = SDL_SCANCODE_X, + [KEYCODE_Y] = SDL_SCANCODE_Y, + [KEYCODE_Z] = SDL_SCANCODE_Z, + [KEYCODE_UP] = SDL_SCANCODE_UP, + [KEYCODE_DOWN] = SDL_SCANCODE_DOWN, + [KEYCODE_LEFT] = SDL_SCANCODE_LEFT, + [KEYCODE_PG_UP] = SDL_SCANCODE_PAGEUP, + [KEYCODE_PG_DOWN] = SDL_SCANCODE_PAGEDOWN, + [KEYCODE_RIGHT] = SDL_SCANCODE_RIGHT, + [KEYCODE_RETURN] = SDL_SCANCODE_RETURN, + [KEYCODE_TAB] = SDL_SCANCODE_TAB, + [KEYCODE_ESCAPE] = SDL_SCANCODE_ESCAPE, +}; + +/** + * Called from the event dispatcher when a keyboard event is encountered. + * Translates the event such that it can be handled by SDL. + * @param event Screen keyboard event + */ +void +handleKeyboardEvent(screen_event_t event) +{ + int val; + SDL_Scancode scancode; + + // Get the key value. + if (screen_get_event_property_iv(event, SCREEN_PROPERTY_SYM, &val) < 0) { + return; + } + + // Skip unrecognized keys. + if ((val < 0) || (val >= SDL_TABLESIZE(key_to_sdl))) { + return; + } + + // Translate to an SDL scan code. + scancode = key_to_sdl[val]; + if (scancode == 0) { + return; + } + + // Get event flags (key state). + if (screen_get_event_property_iv(event, SCREEN_PROPERTY_FLAGS, &val) < 0) { + return; + } + + // Propagate the event to SDL. + // FIXME: + // Need to handle more key states (such as key combinations). + if (val & KEY_DOWN) { + SDL_SendKeyboardKey(0, SDL_PRESSED, scancode); + } else { + SDL_SendKeyboardKey(0, SDL_RELEASED, scancode); + } +} diff --git a/src/video/qnx/sdl_qnx.h b/src/video/qnx/sdl_qnx.h new file mode 100644 index 000000000..65e07988e --- /dev/null +++ b/src/video/qnx/sdl_qnx.h @@ -0,0 +1,48 @@ +/* + Simple DirectMedia Layer + Copyright (C) 2017 BlackBerry Limited + + 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. +*/ + +#ifndef __SDL_QNX_H__ +#define __SDL_QNX_H__ + +#include "../SDL_sysvideo.h" +#include +#include + +typedef struct +{ + screen_window_t window; + EGLSurface surface; + EGLConfig conf; +} window_impl_t; + +extern void handleKeyboardEvent(screen_event_t event); + +extern int glGetConfig(EGLConfig *pconf, int *pformat); +extern int glLoadLibrary(_THIS, const char *name); +void *glGetProcAddress(_THIS, const char *proc); +extern SDL_GLContext glCreateContext(_THIS, SDL_Window *window); +extern int glSetSwapInterval(_THIS, int interval); +extern int glSwapWindow(_THIS, SDL_Window *window); +extern int glMakeCurrent(_THIS, SDL_Window * window, SDL_GLContext context); +extern void glDeleteContext(_THIS, SDL_GLContext context); +extern void glUnloadLibrary(_THIS); + +#endif diff --git a/src/video/qnx/video.c b/src/video/qnx/video.c new file mode 100644 index 000000000..270606fd3 --- /dev/null +++ b/src/video/qnx/video.c @@ -0,0 +1,357 @@ +/* + Simple DirectMedia Layer + Copyright (C) 2017 BlackBerry Limited + + 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" +#include "../SDL_sysvideo.h" +#include "sdl_qnx.h" + +static screen_context_t context; +static screen_event_t event; + +/** + * Initializes the QNX video plugin. + * Creates the Screen context and event handles used for all window operations + * by the plugin. + * @param _THIS + * @return 0 if successful, -1 on error + */ +static int +videoInit(_THIS) +{ + SDL_VideoDisplay display; + + if (screen_create_context(&context, 0) < 0) { + return -1; + } + + if (screen_create_event(&event) < 0) { + return -1; + } + + SDL_zero(display); + + if (SDL_AddVideoDisplay(&display, SDL_FALSE) < 0) { + return -1; + } + + _this->num_displays = 1; + return 0; +} + +static void +videoQuit(_THIS) +{ +} + +/** + * Creates a new native Screen window and associates it with the given SDL + * window. + * @param _THIS + * @param window SDL window to initialize + * @return 0 if successful, -1 on error + */ +static int +createWindow(_THIS, SDL_Window *window) +{ + window_impl_t *impl; + int size[2]; + int numbufs; + int format; + int usage; + + impl = SDL_calloc(1, sizeof(*impl)); + if (impl == NULL) { + return -1; + } + + // Create a native window. + if (screen_create_window(&impl->window, context) < 0) { + goto fail; + } + + // Set the native window's size to match the SDL window. + size[0] = window->w; + size[1] = window->h; + + if (screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_SIZE, + size) < 0) { + goto fail; + } + + if (screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_SOURCE_SIZE, + size) < 0) { + goto fail; + } + + // Create window buffer(s). + if (window->flags & SDL_WINDOW_OPENGL) { + if (glGetConfig(&impl->conf, &format) < 0) { + goto fail; + } + numbufs = 2; + + usage = SCREEN_USAGE_OPENGL_ES2; + if (screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_USAGE, + &usage) < 0) { + return -1; + } + } else { + format = SCREEN_FORMAT_RGBX8888; + numbufs = 1; + } + + // Set pixel format. + if (screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_FORMAT, + &format) < 0) { + goto fail; + } + + // Create buffer(s). + if (screen_create_window_buffers(impl->window, numbufs) < 0) { + goto fail; + } + + window->driverdata = impl; + return 0; + +fail: + if (impl->window) { + screen_destroy_window(impl->window); + } + + SDL_free(impl); + return -1; +} + +/** + * Gets a pointer to the Screen buffer associated with the given window. Note + * that the buffer is actually created in createWindow(). + * @param _THIS + * @param window SDL window to get the buffer for + * @param[out] pixles Holds a pointer to the window's buffer + * @param[out] format Holds the pixel format for the buffer + * @param[out] pitch Holds the number of bytes per line + * @return 0 if successful, -1 on error + */ +static int +createWindowFramebuffer(_THIS, SDL_Window * window, Uint32 * format, + void ** pixels, int *pitch) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + screen_buffer_t buffer; + + // Get a pointer to the buffer's memory. + if (screen_get_window_property_pv(impl->window, SCREEN_PROPERTY_BUFFERS, + (void **)&buffer) < 0) { + return -1; + } + + if (screen_get_buffer_property_pv(buffer, SCREEN_PROPERTY_POINTER, + pixels) < 0) { + return -1; + } + + // Set format and pitch. + if (screen_get_buffer_property_iv(buffer, SCREEN_PROPERTY_STRIDE, + pitch) < 0) { + return -1; + } + + *format = SDL_PIXELFORMAT_RGB888; + return 0; +} + +/** + * Informs the window manager that the window needs to be updated. + * @param _THIS + * @param window The window to update + * @param rects An array of reectangular areas to update + * @param numrects Rect array length + * @return 0 if successful, -1 on error + */ +static int +updateWindowFramebuffer(_THIS, SDL_Window *window, const SDL_Rect *rects, + int numrects) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + screen_buffer_t buffer; + + if (screen_get_window_property_pv(impl->window, SCREEN_PROPERTY_BUFFERS, + (void **)&buffer) < 0) { + return -1; + } + + screen_post_window(impl->window, buffer, numrects, (int *)rects, 0); + screen_flush_context(context, 0); + return 0; +} + +/** + * Runs the main event loop. + * @param _THIS + */ +static void +pumpEvents(_THIS) +{ + int type; + + for (;;) { + if (screen_get_event(context, event, 0) < 0) { + break; + } + + if (screen_get_event_property_iv(event, SCREEN_PROPERTY_TYPE, &type) + < 0) { + break; + } + + if (type == SCREEN_EVENT_NONE) { + break; + } + + switch (type) { + case SCREEN_EVENT_KEYBOARD: + handleKeyboardEvent(event); + break; + + default: + break; + } + } +} + +/** + * Updates the size of the native window using the geometry of the SDL window. + * @param _THIS + * @param window SDL window to update + */ +static void +setWindowSize(_THIS, SDL_Window *window) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + int size[2]; + + size[0] = window->w; + size[1] = window->h; + + screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_SIZE, size); + screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_SOURCE_SIZE, + size); +} + +/** + * Makes the native window associated with the given SDL window visible. + * @param _THIS + * @param window SDL window to update + */ +static void +showWindow(_THIS, SDL_Window *window) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + const int visible = 1; + + screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_VISIBLE, + &visible); +} + +/** + * Makes the native window associated with the given SDL window invisible. + * @param _THIS + * @param window SDL window to update + */ +static void +hideWindow(_THIS, SDL_Window *window) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + const int visible = 0; + + screen_set_window_property_iv(impl->window, SCREEN_PROPERTY_VISIBLE, + &visible); +} + +/** + * Destroys the native window associated with the given SDL window. + * @param _THIS + * @param window SDL window that is being destroyed + */ +static void +destroyWindow(_THIS, SDL_Window *window) +{ + window_impl_t *impl = (window_impl_t *)window->driverdata; + + if (impl) { + screen_destroy_window(impl->window); + window->driverdata = NULL; + } +} + +/** + * Frees the plugin object created by createDevice(). + * @param device Plugin object to free + */ +static void +deleteDevice(SDL_VideoDevice *device) +{ + SDL_free(device); +} + +/** + * Creates the QNX video plugin used by SDL. + * @return Initialized device if successful, NULL otherwise + */ +static SDL_VideoDevice * +createDevice() +{ + SDL_VideoDevice *device; + + device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice)); + if (device == NULL) { + return NULL; + } + + device->driverdata = NULL; + device->VideoInit = videoInit; + device->VideoQuit = videoQuit; + device->CreateSDLWindow = createWindow; + device->CreateWindowFramebuffer = createWindowFramebuffer; + device->UpdateWindowFramebuffer = updateWindowFramebuffer; + device->SetWindowSize = setWindowSize; + device->ShowWindow = showWindow; + device->HideWindow = hideWindow; + device->PumpEvents = pumpEvents; + device->DestroyWindow = destroyWindow; + + device->GL_LoadLibrary = glLoadLibrary; + device->GL_GetProcAddress = glGetProcAddress; + device->GL_CreateContext = glCreateContext; + device->GL_SetSwapInterval = glSetSwapInterval; + device->GL_SwapWindow = glSwapWindow; + device->GL_MakeCurrent = glMakeCurrent; + device->GL_DeleteContext = glDeleteContext; + device->GL_UnloadLibrary = glUnloadLibrary; + + device->free = deleteDevice; + return device; +} + +VideoBootStrap QNX_bootstrap = { + "qnx", "QNX Screen", + createDevice +};