pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Date: Mon, 23 Mar 2009 09:17:24 +0200

Browse source 
From: "Mike Gorchak"
Subject: New QNX patches

Please apply patch qnx4.diff, which is attached. What has been done:
1)Added back OpenGL ES renderer for QNX target. Added few corrections to
OpenGL ES renderer to let it work under QNX. OpenGL ES renderer do not
support textures under QNX, so I think some additional work must be done.
2) Added GL_OES_query_matrix extension to SDL_opengles.h header file, which
required by OpenGL ES 1.1 specification.
3) Added attribute clearing at the entrance of function
SDL_GL_GetAttribure(). Added error checking into the function
SDL_GL_GetAttribure(), because some attributes can't be obtained in OpenGL
ES 1.0.
4) Porting testdyngles to OpenGL ES 1.0 (1.1 has glColor4ub() and
glColor4f() functions, but 1.0 has glColor4f() only).
5) Added error checking after obtaining attributes using
SDL_GL_GetAttribute() function to the testgl2 and testgles.
6) Small correction to testmultiaudio with printing errors.
7) Added software and accelerated OpenGL ES 1.0 support into the QNX GF
driver.

Please remove ./src/audio/nto directory - it will not be used anymore.
Please create ./src/audio/qsa directory and add content of the archive
qsa.tar.gz into this directory. I rewrote some sound code, added support for
multiple audio cards, enumeration, etc. Added initial support for capture.

As far as I can understand SDL 1.3 is not supporting audio capture right now
? Sam, Am I right ? Or audio capture must be supported through the
PlayDevice routine ?

And last, please put file SDL_gf_opengles.c to  the ./src/video/qnxgf
directory. It is OpenGL ES 1.1 emulation layer for some functions, which are
not supported by OpenGL ES 1.0.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%403566
This commit is contained in:
Sam Lantinga 2009-03-24 10:33:12 +00:00
parent 0543b444ac
commit fd618abec1
18 changed files with 1816 additions and 639 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/audio/SDL_audio.c
View file

@ -49,7 +49,7 @@ extern AudioBootStrap DSP_bootstrap;
extern AudioBootStrap DMA_bootstrap;
extern AudioBootStrap ALSA_bootstrap;
extern AudioBootStrap PULSEAUDIO_bootstrap;
extern AudioBootStrap QNXNTOAUDIO_bootstrap;
extern AudioBootStrap QSAAUDIO_bootstrap;
extern AudioBootStrap SUNAUDIO_bootstrap;
extern AudioBootStrap DMEDIA_bootstrap;
extern AudioBootStrap ARTS_bootstrap;
@ -91,8 +91,8 @@ static AudioBootStrap *bootstrap[] = {
&DSP_bootstrap,
&DMA_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_QNXNTO
&QNXNTOAUDIO_bootstrap,
#if SDL_AUDIO_DRIVER_QSA
&QSAAUDIO_bootstrap,
#endif
#if SDL_AUDIO_DRIVER_SUNAUDIO
&SUNAUDIO_bootstrap,

467
src/audio/nto/SDL_nto_audio.c
View file

@ -1,467 +0,0 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#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 "SDL_timer.h"
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "SDL_nto_audio.h"
/* The tag name used by NTO audio */
#define DRIVER_NAME "qsa-nto"
/* default channel communication parameters */
#define DEFAULT_CPARAMS_RATE 22050
#define DEFAULT_CPARAMS_VOICES 1
/* FIXME: need to add in the near future flexible logic with frag_size and frags count */
#define DEFAULT_CPARAMS_FRAG_SIZE 4096
#define DEFAULT_CPARAMS_FRAGS_MIN 1
#define DEFAULT_CPARAMS_FRAGS_MAX 1
/* Open the audio device for playback, and don't block if busy */
#define OPEN_FLAGS SND_PCM_OPEN_PLAYBACK
#define QSA_NO_WORKAROUNDS 0x00000000
#define QSA_MMAP_WORKAROUND 0x00000001
struct BuggyCards
{
char *cardname;
unsigned long bugtype;
};
#define QSA_WA_CARDS 3
struct BuggyCards buggycards[QSA_WA_CARDS] = {
{"Sound Blaster Live!", QSA_MMAP_WORKAROUND},
{"Vortex 8820", QSA_MMAP_WORKAROUND},
{"Vortex 8830", QSA_MMAP_WORKAROUND},
};
static inline void
NTO_SetError(const char *fn, int rval)
{
SDL_SetError("NTO: %s failed: %s", fn, snd_strerror(rval));
}
/* card names check to apply the workarounds */
static int
NTO_CheckBuggyCards(_THIS, unsigned long checkfor)
{
char scardname[33];
int it;
if (snd_card_get_name(this->hidden->cardno, scardname, 32) < 0) {
return 0;
}
for (it = 0; it < QSA_WA_CARDS; it++) {
if (SDL_strcmp(buggycards[it].cardname, scardname) == 0) {
if (buggycards[it].bugtype == checkfor) {
return 1;
}
}
}
return 0;
}
static void
NTO_ThreadInit(_THIS)
{
struct sched_param param;
int status = SchedGet(0, 0, &param);
/* increasing default 10 priority to 25 to avoid jerky sound */
param.sched_priority = param.sched_curpriority + 15;
status = SchedSet(0, 0, SCHED_NOCHANGE, &param);
}
/* PCM transfer channel parameters initialize function */
static void
NTO_InitAudioParams(snd_pcm_channel_params_t * cpars)
{
SDL_memset(cpars, 0, sizeof(snd_pcm_channel_params_t));
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
NTO_WaitDevice(_THIS)
{
fd_set wfds;
int selectret;
FD_ZERO(&wfds);
FD_SET(this->hidden->audio_fd, &wfds);
do {
selectret =
select(this->hidden->audio_fd + 1, NULL, &wfds, NULL, NULL);
switch (selectret) {
case -1:
case 0:
SDL_SetError("NTO: select() failed: %s\n", strerror(errno));
return;
default:
if (FD_ISSET(this->hidden->audio_fd, &wfds)) {
return;
}
break;
}
} while (1);
}
static void
NTO_PlayDevice(_THIS)
{
snd_pcm_channel_status_t cstatus;
int written, rval;
int towrite;
void *pcmbuffer;
if ((!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) {
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_memset(&cstatus, 0, sizeof(cstatus));
cstatus.channel = SND_PCM_CHANNEL_PLAYBACK;
rval = snd_pcm_plugin_status(this->hidden->audio_handle,
&cstatus);
if (rval < 0) {
NTO_SetError("snd_pcm_plugin_status", rval);
return;
}
if ((cstatus.status == SND_PCM_STATUS_UNDERRUN) ||
(cstatus.status == SND_PCM_STATUS_READY)) {
rval = snd_pcm_plugin_prepare(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
if (rval < 0) {
NTO_SetError("snd_pcm_plugin_prepare", rval);
return;
}
}
continue;
} else {
return;
}
} else {
/* we wrote all remaining data */
towrite -= written;
pcmbuffer += written * this->spec.channels;
}
} while ((towrite > 0) && (this->enabled));
/* If we couldn't write, assume fatal error for now */
if (towrite != 0) {
this->enabled = 0;
}
}
static Uint8 *
NTO_GetDeviceBuf(_THIS)
{
return this->hidden->pcm_buf;
}
static void
NTO_CloseDevice(_THIS)
{
if (this->hidden != NULL) {
if (this->hidden->audio_handle != NULL) {
snd_pcm_plugin_flush(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
snd_pcm_close(this->hidden->audio_handle);
this->hidden->audio_handle = NULL;
}
if (this->hidden->pcm_buf != NULL) {
SDL_FreeAudioMem(this->hidden->pcm_buf);
this->hidden->pcm_buf = NULL;
}
SDL_free(this->hidden);
this->hidden = NULL;
}
}
static int
NTO_OpenDevice(_THIS, const char *devname, int iscapture)
{
int rval = 0;
int format = 0;
SDL_AudioFormat test_format = 0;
int found = 0;
snd_pcm_channel_setup_t csetup;
snd_pcm_channel_params_t cparams;
/* Initialize all variables that we clean on shutdown */
this->hidden = (struct SDL_PrivateAudioData *)
SDL_malloc((sizeof *this->hidden));
if (this->hidden == NULL) {
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, (sizeof *this->hidden));
/* initialize channel transfer parameters to default */
NTO_InitAudioParams(&cparams);
/* Open the audio device */
rval = snd_pcm_open_preferred(&this->hidden->audio_handle,
&this->hidden->cardno,
&this->hidden->deviceno, OPEN_FLAGS);
if (rval < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_open", rval);
return 0;
}
if (!NTO_CheckBuggyCards(this, QSA_MMAP_WORKAROUND)) {
/* enable count status parameter */
rval = snd_pcm_plugin_set_disable(this->hidden->audio_handle,
PLUGIN_DISABLE_MMAP);
if (rval < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_plugin_set_disable", rval);
return 0;
}
}
/* Try for a closest match on audio format */
format = 0;
/* can't use format as SND_PCM_SFMT_U8 = 0 in nto */
found = 0;
for (test_format = SDL_FirstAudioFormat(this->spec.format); !found;) {
/* if match found set format to equivalent ALSA 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) {
NTO_CloseDevice(this);
SDL_SetError("NTO: Couldn't find any hardware audio formats");
return 0;
}
this->spec.format = test_format;
/* Set the audio format */
cparams.format.format = format;
/* Set mono or stereo audio (currently only two channels supported) */
cparams.format.voices = this->spec.channels;
/* Set rate */
cparams.format.rate = this->spec.freq;
/* Setup the transfer parameters according to cparams */
rval = snd_pcm_plugin_params(this->hidden->audio_handle, &cparams);
if (rval < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_channel_params", rval);
return 0;
}
/* Make sure channel is setup right one last time */
SDL_memset(&csetup, '\0', sizeof(csetup));
csetup.channel = SND_PCM_CHANNEL_PLAYBACK;
if (snd_pcm_plugin_setup(this->hidden->audio_handle, &csetup) < 0) {
NTO_CloseDevice(this);
SDL_SetError("NTO: Unable to setup playback channel\n");
return 0;
}
/* 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_AllocAudioMem(this->hidden->pcm_len);
if (this->hidden->pcm_buf == NULL) {
NTO_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden->pcm_buf, this->spec.silence,
this->hidden->pcm_len);
/* get the file descriptor */
this->hidden->audio_fd =
snd_pcm_file_descriptor(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
if (this->hidden->audio_fd < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_file_descriptor", rval);
return 0;
}
/* Trigger audio playback */
rval = snd_pcm_plugin_prepare(this->hidden->audio_handle,
SND_PCM_CHANNEL_PLAYBACK);
if (rval < 0) {
NTO_CloseDevice(this);
NTO_SetError("snd_pcm_plugin_prepare", rval);
return 0;
}
/* We're really ready to rock and roll. :-) */
return 1;
}
static int
NTO_Init(SDL_AudioDriverImpl * impl)
{
/* !!! FIXME: not right for device enum? */
/* See if we can open a nonblocking channel. */
snd_pcm_t *handle = NULL;
int rval = snd_pcm_open_preferred(&handle, NULL, NULL, OPEN_FLAGS);
if (rval < 0) {
SDL_SetError("NTO: couldn't open preferred audio device");
return 0;
}
if ((rval = snd_pcm_close(handle)) < 0) {
SDL_SetError("NTO: couldn't close test audio device");
return 0;
}
/* Set the function pointers */
impl->OpenDevice = NTO_OpenDevice;
impl->ThreadInit = NTO_ThreadInit;
impl->WaitDevice = NTO_WaitDevice;
impl->PlayDevice = NTO_PlayDevice;
impl->GetDeviceBuf = NTO_GetDeviceBuf;
impl->CloseDevice = NTO_CloseDevice;
impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME: add device enum! */
/* !!! FIXME: device enum might make this 1. */
return 2; /* 2 == definitely has an audio device. */
}
AudioBootStrap QNXNTOAUDIO_bootstrap = {
DRIVER_NAME, "QNX6 QSA-NTO Audio", NTO_Init, 0
};
/* vi: set ts=4 sw=4 expandtab: */

945
src/audio/qsa/SDL_qsa_audio.c Normal file
View file

@ -0,0 +1,945 @@
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2009 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
QNX Sound Architecture (QSA) SDL driver
Copyright (C) 2009 Mike Gorchak
(mike@malva.ua, lestat@i.com.ua)
*/
#include "SDL_config.h"
#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 "SDL_timer.h"
#include "SDL_audio.h"
#include "../SDL_audiomem.h"
#include "../SDL_audio_c.h"
#include "SDL_qsa_audio.h"
/* The tag name used by QSA audio framework */
#define DRIVER_NAME "qsa"
/* 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
#define QSA_NO_WORKAROUNDS 0x00000000
#define QSA_MMAP_WORKAROUND 0x00000001
struct BuggyCards
{
char* cardname;
unsigned long bugtype;
};
#define QSA_WA_CARDS 3
#define QSA_MAX_CARD_NAME_LENGTH 33
struct BuggyCards buggycards[QSA_WA_CARDS]=
{
{"Sound Blaster Live!", QSA_MMAP_WORKAROUND},
{"Vortex 8820", QSA_MMAP_WORKAROUND},
{"Vortex 8830", QSA_MMAP_WORKAROUND},
};
/* 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 inline void QSA_SetError(const char* fn, int status)
{
SDL_SetError("QSA: %s failed: %s", fn, snd_strerror(status));
}
/* card names check to apply the workarounds */
static int QSA_CheckBuggyCards(_THIS, unsigned long checkfor)
{
char scardname[QSA_MAX_CARD_NAME_LENGTH];
int it;
if (snd_card_get_name(this->hidden->cardno, scardname, QSA_MAX_CARD_NAME_LENGTH-1)<0)
{
return 0;
}
for (it=0; it<QSA_WA_CARDS; it++)
{
if (SDL_strcmp(buggycards[it].cardname, scardname)==0)
{
if (buggycards[it].bugtype==checkfor)
{
return 1;
}
}
}
return 0;
}
static void QSA_ThreadInit(_THIS)
{
struct sched_param param;
int status;
/* Increase default 10 priority to 25 to avoid jerky sound */
status=SchedGet(0, 0, &param);
param.sched_priority=param.sched_curpriority + 15;
status=SchedSet(0, 0, SCHED_NOCHANGE, &param);
}
/* PCM channel parameters initialize function */
static void QSA_InitAudioParams(snd_pcm_channel_params_t* cpars)
{
SDL_memset(cpars, 0, sizeof(snd_pcm_channel_params_t));
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)
{
fd_set wfds;
fd_set rfds;
int selectret;
struct timeval timeout;
if (!this->hidden->iscapture)
{
FD_ZERO(&wfds);
FD_SET(this->hidden->audio_fd, &wfds);
}
else
{
FD_ZERO(&rfds);
FD_SET(this->hidden->audio_fd, &rfds);
}
do {
/* 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 ! */
timeout.tv_sec=2;
timeout.tv_usec=0;
this->hidden->timeout_on_wait=0;
if (!this->hidden->iscapture)
{
selectret=select(this->hidden->audio_fd+1, NULL, &wfds, NULL, &timeout);
}
else
{
selectret=select(this->hidden->audio_fd+1, &rfds, NULL, NULL, &timeout);
}
switch(selectret)
{
case -1:
{
SDL_SetError("QSA: select() failed: %s\n", strerror(errno));
return;
}
break;
case 0:
{
SDL_SetError("QSA: timeout on buffer waiting occured\n");
this->hidden->timeout_on_wait=1;
return;
}
break;
default:
{
if (!this->hidden->iscapture)
{
if (FD_ISSET(this->hidden->audio_fd, &wfds))
{
return;
}
}
else
{
if (FD_ISSET(this->hidden->audio_fd, &rfds))
{
return;
}
}
}
break;
}
} while (1);
}
static void QSA_PlayDevice(_THIS)
{
snd_pcm_channel_status_t cstatus;
int written;
int status;
int towrite;
void* pcmbuffer;
if ((!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\n");
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_memset(&cstatus, 0, sizeof(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) && (this->enabled));
/* If we couldn't write, assume fatal error for now */
if (towrite!=0)
{
this->enabled=0;
}
}
static Uint8* QSA_GetDeviceBuf(_THIS)
{
return this->hidden->pcm_buf;
}
static void QSA_CloseDevice(_THIS)
{
if (this->hidden!=NULL)
{
if (this->hidden->audio_handle!=NULL)
{
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);
}
snd_pcm_close(this->hidden->audio_handle);
this->hidden->audio_handle=NULL;
}
if (this->hidden->pcm_buf!=NULL)
{
SDL_FreeAudioMem(this->hidden->pcm_buf);
this->hidden->pcm_buf=NULL;
}
SDL_free(this->hidden);
this->hidden=NULL;
}
}
static int QSA_OpenDevice(_THIS, const char* devname, int iscapture)
{
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;
/* Initialize all variables that we clean on shutdown */
this->hidden=(struct SDL_PrivateAudioData*)SDL_calloc(1, (sizeof(struct SDL_PrivateAudioData)));
if (this->hidden==NULL)
{
SDL_OutOfMemory();
return 0;
}
SDL_memset(this->hidden, 0, sizeof(struct SDL_PrivateAudioData));
/* Initialize channel transfer parameters to default */
QSA_InitAudioParams(&cparams);
/* Initialize channel direction: capture or playback */
this->hidden->iscapture=iscapture;
/* Find deviceid and cardid by device name for playback */
if ((!this->hidden->iscapture) && (devname!=NULL))
{
uint32_t device;
int32_t status;
/* Search in the playback devices */
device=0;
do {
status=SDL_strcmp(qsa_playback_device[device].name, devname);
if (status==0)
{
/* Found requested device */
this->hidden->deviceno=qsa_playback_device[device].deviceno;
this->hidden->cardno=qsa_playback_device[device].cardno;
break;
}
device++;
if (device>=qsa_playback_devices)
{
QSA_CloseDevice(this);
SDL_SetError("No such playback device");
return 0;
}
} while(1);
}
/* Find deviceid and cardid by device name for capture */
if ((this->hidden->iscapture) && (devname!=NULL))
{
/* Search in the capture devices */
uint32_t device;
int32_t status;
/* Searching in the playback devices */
device=0;
do {
status=SDL_strcmp(qsa_capture_device[device].name, devname);
if (status==0)
{
/* Found requested device */
this->hidden->deviceno=qsa_capture_device[device].deviceno;
this->hidden->cardno=qsa_capture_device[device].cardno;
break;
}
device++;
if (device>=qsa_capture_devices)
{
QSA_CloseDevice(this);
SDL_SetError("No such capture device");
return 0;
}
} while(1);
}
/* Check if SDL requested default audio device */
if (devname==NULL)
{
/* Open system default audio device */
if (!this->hidden->iscapture)
{
status=snd_pcm_open_preferred(&this->hidden->audio_handle,
&this->hidden->cardno,
&this->hidden->deviceno, SND_PCM_OPEN_PLAYBACK);
}
else
{
status=snd_pcm_open_preferred(&this->hidden->audio_handle,
&this->hidden->cardno,
&this->hidden->deviceno, SND_PCM_OPEN_CAPTURE);
}
}
else
{
/* Open requested audio device */
if (!this->hidden->iscapture)
{
status=snd_pcm_open(&this->hidden->audio_handle, this->hidden->cardno,
this->hidden->deviceno, SND_PCM_OPEN_PLAYBACK);
}
else
{
status=snd_pcm_open(&this->hidden->audio_handle, this->hidden->cardno,
this->hidden->deviceno, SND_PCM_OPEN_CAPTURE);
}
}
/* Check if requested device is opened */
if (status<0)
{
QSA_CloseDevice(this);
QSA_SetError("snd_pcm_open", status);
return 0;
}
if (!QSA_CheckBuggyCards(this, QSA_MMAP_WORKAROUND))
{
/* Disable QSA MMAP plugin for buggy audio drivers */
status=snd_pcm_plugin_set_disable(this->hidden->audio_handle, PLUGIN_DISABLE_MMAP);
if (status<0)
{
QSA_CloseDevice(this);
QSA_SetError("snd_pcm_plugin_set_disable", status);
return 0;
}
}
/* 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)
{
QSA_CloseDevice(this);
SDL_SetError("QSA: Couldn't find any hardware audio formats");
return 0;
}
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)
{
QSA_CloseDevice(this);
QSA_SetError("snd_pcm_channel_params", status);
return 0;
}
/* Make sure channel is setup right one last time */
SDL_memset(&csetup, '\0', sizeof(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)
{
QSA_CloseDevice(this);
SDL_SetError("QSA: Unable to setup channel\n");
return 0;
}
/* 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_AllocAudioMem(this->hidden->pcm_len);
if (this->hidden->pcm_buf==NULL)
{
QSA_CloseDevice(this);
SDL_OutOfMemory();
return 0;
}
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)
{
QSA_CloseDevice(this);
QSA_SetError("snd_pcm_file_descriptor", status);
return 0;
}
/* 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)
{
QSA_CloseDevice(this);
QSA_SetError("snd_pcm_plugin_prepare", status);
return 0;
}
/* We're really ready to rock and roll. :-) */
return 1;
}
int QSA_DetectDevices(int iscapture)
{
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 0;
}
/* Find requested devices by type */
if (!iscapture)
{
/* 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)
{
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;
}
}
}
else
{
/* 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)
{
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;
}
}
}
/* Return amount of available playback or capture devices */
if (!iscapture)
{
return qsa_playback_devices;
}
else
{
return qsa_capture_devices;
}
}
const char* QSA_GetDeviceName(int index, int iscapture)
{
if (!iscapture)
{
if (index>=qsa_playback_devices)
{
return "No such playback device";
}
return qsa_playback_device[index].name;
}
else
{
if (index>=qsa_capture_devices)
{
return "No such capture device";
}
return qsa_capture_device[index].name;
}
}
void QSA_WaitDone(_THIS)
{
if (!this->hidden->iscapture)
{
if (this->hidden->audio_handle!=NULL)
{
/* Wait till last fragment is played and stop channel */
snd_pcm_plugin_flush(this->hidden->audio_handle, SND_PCM_CHANNEL_PLAYBACK);
}
}
else
{
if (this->hidden->audio_handle!=NULL)
{
/* Discard all unread data and stop channel */
snd_pcm_plugin_flush(this->hidden->audio_handle, SND_PCM_CHANNEL_CAPTURE);
}
}
}
void QSA_Deinitialize(void)
{
/* Clear devices array on shutdown */
SDL_memset(qsa_playback_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
SDL_memset(qsa_capture_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
qsa_playback_devices=0;
qsa_capture_devices=0;
}
static int QSA_Init(SDL_AudioDriverImpl* impl)
{
snd_pcm_t* handle=NULL;
int32_t status=0;
/* Clear devices array */
SDL_memset(qsa_playback_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
SDL_memset(qsa_capture_device, 0x00, sizeof(QSA_Device)*QSA_MAX_DEVICES);
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->GetDeviceName=QSA_GetDeviceName;
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->WaitDone=QSA_WaitDone;
impl->Deinitialize=QSA_Deinitialize;
impl->LockDevice=NULL;
impl->UnlockDevice=NULL;
impl->OnlyHasDefaultOutputDevice=0;
impl->ProvidesOwnCallbackThread=0;
impl->SkipMixerLock=0;
impl->HasCaptureSupport=1;
impl->OnlyHasDefaultOutputDevice=0;
impl->OnlyHasDefaultInputDevice=0;
/* Check if io-audio manager is running or not */
status=snd_cards();
if (status==0)
{
/* if no, return immediately */
return 1;
}
/* At this point we are definitely has an audio device */
return 2;
}
AudioBootStrap QSAAUDIO_bootstrap=
{
DRIVER_NAME, "QNX QSA Audio", QSA_Init, 0
};
/* vi: set ts=4 sw=4 expandtab: */

25
src/audio/nto/SDL_nto_audio.h → src/audio/qsa/SDL_qsa_audio.h
View file

@ -18,36 +18,45 @@
Sam Lantinga
slouken@libsdl.org
QNX Sound Architecture (QSA) SDL driver
Copyright (C) 2009 Mike Gorchak
(mike@malva.ua, lestat@i.com.ua)
*/
#include "SDL_config.h"
#ifndef __SDL_NTO_AUDIO_H__
#define __SDL_NTO_AUDIO_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
#define _THIS SDL_AudioDevice* this
struct SDL_PrivateAudioData
{
/* SDL capture state */
int iscapture;
/* The audio device handle */
int cardno;
int deviceno;
snd_pcm_t *audio_handle;
snd_pcm_t* audio_handle;
/* The audio file descriptor */
int audio_fd;
/* The parent process id, to detect when application quits */
pid_t parent;
/* Select timeout status */
uint32_t timeout_on_wait;
/* Raw mixing buffer */
Uint8 *pcm_buf;
Uint8* pcm_buf;
Uint32 pcm_len;
};
#endif /* __SDL_NTO_AUDIO_H__ */
#endif /* __SDL_QSA_AUDIO_H__ */
/* vi: set ts=4 sw=4 expandtab: */