Das SDL Soundbackend komplett reimplementiert.

This commit is contained in:
Yamagi Burmeister 2010-10-13 21:04:59 +00:00
parent dc930150cf
commit 86e7ecb0f4

View file

@ -1,185 +1,198 @@
/* #include <SDL.h>
snd_sdl.c
Sound code taken from SDLQuake and modified to work with Quake2
Robert Bäuml 2001-12-25
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to:
Free Software Foundation, Inc.
59 Temple Place - Suite 330
Boston, MA 02111-1307, USA
$Id: snd_sdl.c,v 1.2 2002/02/09 20:29:38 relnev Exp $
*/
#include "SDL.h"
#include "../client/header/client.h" #include "../client/header/client.h"
#include "../client/sound/header/local.h" #include "../client/sound/header/local.h"
static int snd_inited; /* Global stuff */
static dma_t *shm; int snd_inited = 0;
static int dmapos = 0;
static int dmasize = 0;
static dma_t *dmabackend;
static void /* The callback */
paint_audio (void *unused, Uint8 * stream, int len) static void
sdl_audio_callback(void *data, Uint8 *stream, int length)
{ {
if (shm) { int length1;
shm->buffer = stream; int length2;
shm->samplepos += len / (shm->samplebits / 4); int pos = (dmapos * (dmabackend->samplebits / 8));
// Check for samplepos overflow?
S_PaintChannels (shm->samplepos); if (pos >= dmasize)
{
dmapos = pos = 0;
}
/* This can't happen! */
if (!snd_inited)
{
memset(stream, '\0', length);
return;
}
int tobufferend = dmasize - pos;
if (length > tobufferend)
{
length1 = tobufferend;
length2 = length - length1;
}
else
{
length1= length;
length2 = 0;
}
memcpy(stream, dmabackend->buffer + pos, length1);
/* Set new position */
if (length2 <= 0)
{
dmapos += (length1 / (dmabackend->samplebits / 8));
}
else
{
memcpy(stream + length1, dmabackend->buffer, length2);
dmapos = (length2 / (dmabackend->samplebits / 8));
}
if (dmapos >= dmasize)
{
dmapos = 0;
} }
} }
qboolean qboolean
SNDDMA_Init (void) SNDDMA_Init(void)
{ {
SDL_AudioSpec desired, obtained; char drivername[128];
int desired_bits, freq; SDL_AudioSpec desired;
SDL_AudioSpec optained;
if (SDL_WasInit(SDL_INIT_EVERYTHING) == 0) {
if (SDL_Init(SDL_INIT_AUDIO) < 0) {
Com_Printf ("Couldn't init SDL audio: %s\n", SDL_GetError ());
return 0;
}
} else if (SDL_WasInit(SDL_INIT_AUDIO) == 0) {
if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
Com_Printf ("Couldn't init SDL audio: %s\n", SDL_GetError ());
return 0;
}
}
snd_inited = 0;
desired_bits = (Cvar_Get("sndbits", "16", CVAR_ARCHIVE))->value;
/* Set up the desired format */ /* This should never happen,
freq = (Cvar_Get("s_khz", "0", CVAR_ARCHIVE))->value; but this is Quake 2 ... */
if (freq == 44) if (snd_inited)
desired.freq = 44100; {
else if (freq == 22) return 1;
desired.freq = 22050; }
else
desired.freq = 11025; int sndbits = (Cvar_Get("sndbits", "16", CVAR_ARCHIVE))->value;
int sndfreq = (Cvar_Get("s_khz", "0", CVAR_ARCHIVE))->value;
switch (desired_bits) { int sndchans = (Cvar_Get("sndchannels", "2", CVAR_ARCHIVE))->value;
case 8:
desired.format = AUDIO_U8; if (!SDL_WasInit(SDL_INIT_AUDIO))
break; {
case 16: if (SDL_Init(SDL_INIT_AUDIO) == -1)
if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
desired.format = AUDIO_S16MSB; Com_Printf ("Couldn't init SDL audio: %s\n", SDL_GetError ());
else return 0;
desired.format = AUDIO_S16LSB; }
break;
default:
Com_Printf ("Unknown number of audio bits: %d\n", desired_bits);
return 0;
} }
desired.channels = (Cvar_Get("sndchannels", "2", CVAR_ARCHIVE))->value;
if (desired.freq == 44100) if (SDL_AudioDriverName(drivername, sizeof(drivername)) == NULL)
desired.samples = 2048; {
else if (desired.freq == 22050) strcpy(drivername, "(UNKNOW)");
desired.samples = 1024; }
else
Com_Printf("SDL audio driver is \"%s\"\n", drivername);
memset(&desired, '\0', sizeof(desired));
memset(&optained, '\0', sizeof(optained));
/* Users are stupid */
if ((sndbits != 16) && (sndbits != 8))
{
sndbits = 16;
}
if (sndfreq == 22)
{
desired.freq = 22050;
}
else if (sndfreq == 11)
{
desired.freq = 11025;
}
desired.format = ((sndbits == 16) ? AUDIO_S16SYS : AUDIO_U8);
if (desired.freq <= 11025)
{
desired.samples = 256;
}
else if (desired.freq <= 22050)
{
desired.samples = 512; desired.samples = 512;
}
desired.callback = paint_audio; else
{
/* Open the audio device */ desired.samples = 2048;
if (SDL_OpenAudio (&desired, &obtained) < 0) { }
Com_Printf ("Couldn't open SDL audio: %s\n", SDL_GetError ());
desired.channels = sndchans;
desired.callback = sdl_audio_callback;
/* Okay, let's try our luck */
if (SDL_OpenAudio(&desired, &optained) == -1)
{
Com_Printf("SDL_OpenAudio() failed: %s\n", SDL_GetError());
SDL_QuitSubSystem(SDL_INIT_AUDIO);
return 0; return 0;
} }
/* Make sure we can support the audio format */ /* Don't pollute the frontend dma_t */
switch (obtained.format) { dmabackend = &dma;
case AUDIO_U8:
/* Supported */ dmapos = 0;
break; dmabackend->samplebits = optained.format & 0xFF;
case AUDIO_S16LSB: dmabackend->channels = optained.channels;
case AUDIO_S16MSB: dmabackend->samples = 32768;
if (((obtained.format == AUDIO_S16LSB) && dmabackend->submission_chunk = 1;
(SDL_BYTEORDER == SDL_LIL_ENDIAN)) || dmabackend->speed = optained.freq;
((obtained.format == AUDIO_S16MSB) && dmasize = (dmabackend->samples * (dmabackend->samplebits / 8));
(SDL_BYTEORDER == SDL_BIG_ENDIAN))) { dmabackend->buffer = calloc(1, dmasize);
/* Supported */
break;
}
/* Unsupported, fall through */ ;
default:
/* Not supported -- force SDL to do our bidding */
SDL_CloseAudio ();
if (SDL_OpenAudio (&desired, NULL) < 0) {
Com_Printf ("Couldn't open SDL audio: %s\n", SDL_GetError ());
return 0;
}
memcpy (&obtained, &desired, sizeof (desired));
break;
}
SDL_PauseAudio (0);
/* Fill the audio DMA information block */ Com_Printf("Starting SDL audio callback...\n");
shm = &dma; SDL_PauseAudio(0);
shm->samplebits = (obtained.format & 0xFF);
shm->speed = obtained.freq;
shm->channels = obtained.channels;
shm->samples = obtained.samples * shm->channels;
shm->samplepos = 0;
shm->submission_chunk = 1;
shm->buffer = NULL;
snd_inited = 1; Com_Printf("SDL audio initialized.\n");
return 1; snd_inited = 1;
return 1;
} }
int int
SNDDMA_GetDMAPos (void) SNDDMA_GetDMAPos(void)
{ {
return shm->samplepos; return dmapos;
} }
void void
SNDDMA_Shutdown (void) SNDDMA_Shutdown(void)
{ {
if (snd_inited) { Com_Printf("Closing SDL audio device...\n");
SDL_CloseAudio (); SDL_PauseAudio(1);
snd_inited = 0; SDL_CloseAudio();
} SDL_QuitSubSystem(SDL_INIT_AUDIO);
free(dmabackend->buffer);
if (SDL_WasInit(SDL_INIT_EVERYTHING) == SDL_INIT_AUDIO) dmabackend->buffer = NULL;
SDL_Quit(); dmapos = dmasize = 0;
else snd_inited = 0;
SDL_QuitSubSystem(SDL_INIT_AUDIO); Com_Printf("SDL audio device shut down.\n");
} }
/* /*
* This sends the sound to the device,
SNDDMA_Submit * if the DMA isn't the device itself.
* This shouldn't be the case on all PCI
Send sound to device if buffer isn't really the dma buffer * and PCIe soundcards
*/
*/
void void
SNDDMA_Submit (void) SNDDMA_Submit(void)
{ {
SDL_UnlockAudio();
} }
void
void SNDDMA_BeginPainting(void) SNDDMA_BeginPainting(void)
{ {
SDL_LockAudio();
} }