From 4374645738fc1112a6eefc5f6e3b0e1da384da3f Mon Sep 17 00:00:00 2001
From: Elad Lahav <[EMAIL REDACTED]>
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 bd8cc234df29..c28e14910f79 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 784eb8e6e208..4e7ac1e5869c 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 <screen/screen.h>
+ 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 3b7814ba4074..3320b5cd53bb 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 e8dd7f5c75fd..282b1a7aeff0 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 29e1d00c86e8..7fb7ac591ff2 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 000000000000..d94ba4877e5a
--- /dev/null
+++ b/src/audio/qnx/SDL_qsa_audio.c
@@ -0,0 +1,682 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2021 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.
+*/
+
+/*
+ * !!! 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 <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sched.h>
+#include <sys/select.h>
+#include <sys/neutrino.h>
+#include <sys/asoundlib.h>
+
+#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 000000000000..ea46be687051
--- /dev/null
+++ b/src/audio/qnx/SDL_qsa_audio.h
@@ -0,0 +1,57 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2021 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"
+
+#ifndef __SDL_QSA_AUDIO_H__
+#define __SDL_QSA_AUDIO_H__
+
+#include <sys/asoundlib.h>
+
+#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 b256f2744728..8e90d3a4f86e 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 dd3bcdeefb1d..3f8b50dda6d1 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 000000000000..29393fbaa6e0
--- /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 redistrib
(Patch may be truncated, please check the link at the top of this post.)