mirror of https://github.com/encounter/SDL.git
Removed the broken audio streaming code, other small cleanups.
This commit is contained in:
Ryan C. Gordon
parent
5cbb32ef57
commit
1e78ef2155
|
|
@ -286,67 +286,6 @@ finalize_audio_entry_points(void)
|
||||||
#undef FILL_STUB
|
#undef FILL_STUB
|
||||||
}
|
}
|
||||||
|
|
||||||
#if 0 /* !!! FIXME: rewrite/remove this streamer code. */
|
|
||||||
/* Streaming functions (for when the input and output buffer sizes are different) */
|
|
||||||
/* Write [length] bytes from buf into the streamer */
|
|
||||||
static void
|
|
||||||
SDL_StreamWrite(SDL_AudioStreamer * stream, Uint8 * buf, int length)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < length; ++i) {
|
|
||||||
stream->buffer[stream->write_pos] = buf[i];
|
|
||||||
++stream->write_pos;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Read [length] bytes out of the streamer into buf */
|
|
||||||
static void
|
|
||||||
SDL_StreamRead(SDL_AudioStreamer * stream, Uint8 * buf, int length)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
|
|
||||||
for (i = 0; i < length; ++i) {
|
|
||||||
buf[i] = stream->buffer[stream->read_pos];
|
|
||||||
++stream->read_pos;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
static int
|
|
||||||
SDL_StreamLength(SDL_AudioStreamer * stream)
|
|
||||||
{
|
|
||||||
return (stream->write_pos - stream->read_pos) % stream->max_len;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Initialize the stream by allocating the buffer and setting the read/write heads to the beginning */
|
|
||||||
#if 0
|
|
||||||
static int
|
|
||||||
SDL_StreamInit(SDL_AudioStreamer * stream, int max_len, Uint8 silence)
|
|
||||||
{
|
|
||||||
/* First try to allocate the buffer */
|
|
||||||
stream->buffer = (Uint8 *) SDL_malloc(max_len);
|
|
||||||
if (stream->buffer == NULL) {
|
|
||||||
return -1;
|
|
||||||
}
|
|
||||||
|
|
||||||
stream->max_len = max_len;
|
|
||||||
stream->read_pos = 0;
|
|
||||||
stream->write_pos = 0;
|
|
||||||
|
|
||||||
/* Zero out the buffer */
|
|
||||||
SDL_memset(stream->buffer, silence, max_len);
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Deinitialize the stream simply by freeing the buffer */
|
|
||||||
static void
|
|
||||||
SDL_StreamDeinit(SDL_AudioStreamer * stream)
|
|
||||||
{
|
|
||||||
SDL_free(stream->buffer);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* device hotplug support... */
|
/* device hotplug support... */
|
||||||
|
|
||||||
|
|
@ -655,17 +594,12 @@ int SDLCALL
|
||||||
SDL_RunAudio(void *devicep)
|
SDL_RunAudio(void *devicep)
|
||||||
{
|
{
|
||||||
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
|
SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
|
||||||
|
const int silence = (int) device->spec.silence;
|
||||||
|
const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
|
||||||
|
const int stream_len = (device->convert.needed) ? device->convert.len : device->spec.size;
|
||||||
Uint8 *stream;
|
Uint8 *stream;
|
||||||
int stream_len;
|
void *udata = device->spec.userdata;
|
||||||
void *udata;
|
void (SDLCALL *fill) (void *, Uint8 *, int) = device->spec.callback;
|
||||||
void (SDLCALL * fill) (void *userdata, Uint8 * stream, int len);
|
|
||||||
Uint32 delay;
|
|
||||||
|
|
||||||
#if 0 /* !!! FIXME: rewrite/remove this streamer code. */
|
|
||||||
/* For streaming when the buffer sizes don't match up */
|
|
||||||
Uint8 *istream;
|
|
||||||
int istream_len = 0;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* The audio mixing is always a high priority thread */
|
/* The audio mixing is always a high priority thread */
|
||||||
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
|
SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
|
||||||
|
|
@ -674,202 +608,59 @@ SDL_RunAudio(void *devicep)
|
||||||
device->threadid = SDL_ThreadID();
|
device->threadid = SDL_ThreadID();
|
||||||
current_audio.impl.ThreadInit(device);
|
current_audio.impl.ThreadInit(device);
|
||||||
|
|
||||||
/* Set up the mixing function */
|
/* Loop, filling the audio buffers */
|
||||||
fill = device->spec.callback;
|
while (!device->shutdown) {
|
||||||
udata = device->spec.userdata;
|
/* Fill the current buffer with sound */
|
||||||
|
if (device->convert.needed) {
|
||||||
/* By default do not stream */
|
stream = device->convert.buf;
|
||||||
device->use_streamer = 0;
|
} else if (device->enabled) {
|
||||||
|
stream = current_audio.impl.GetDeviceBuf(device);
|
||||||
if (device->convert.needed) {
|
} else {
|
||||||
#if 0 /* !!! FIXME: I took len_div out of the structure. Use rate_incr instead? */
|
/* if the device isn't enabled, we still write to the
|
||||||
/* If the result of the conversion alters the length, i.e. resampling is being used, use the streamer */
|
fake_stream, so the app's callback will fire with
|
||||||
if (device->convert.len_mult != 1 || device->convert.len_div != 1) {
|
a regular frequency, in case they depend on that
|
||||||
/* The streamer's maximum length should be twice whichever is larger: spec.size or len_cvt */
|
for timing or progress. They can use hotplug
|
||||||
stream_max_len = 2 * device->spec.size;
|
now to know if the device failed. */
|
||||||
if (device->convert.len_mult > device->convert.len_div) {
|
stream = NULL;
|
||||||
stream_max_len *= device->convert.len_mult;
|
|
||||||
stream_max_len /= device->convert.len_div;
|
|
||||||
}
|
|
||||||
if (SDL_StreamInit(&device->streamer, stream_max_len, silence) <
|
|
||||||
0)
|
|
||||||
return -1;
|
|
||||||
device->use_streamer = 1;
|
|
||||||
|
|
||||||
/* istream_len should be the length of what we grab from the callback and feed to conversion,
|
|
||||||
so that we get close to spec_size. I.e. we want device.spec_size = istream_len * u / d
|
|
||||||
*/
|
|
||||||
istream_len =
|
|
||||||
device->spec.size * device->convert.len_div /
|
|
||||||
device->convert.len_mult;
|
|
||||||
}
|
}
|
||||||
#endif
|
|
||||||
stream_len = device->convert.len;
|
|
||||||
} else {
|
|
||||||
stream_len = device->spec.size;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Calculate the delay while paused */
|
|
||||||
delay = ((device->spec.samples * 1000) / device->spec.freq);
|
|
||||||
|
|
||||||
/* Determine if the streamer is necessary here */
|
|
||||||
#if 0 /* !!! FIXME: rewrite/remove this streamer code. */
|
|
||||||
if (device->use_streamer == 1) {
|
|
||||||
/* This code is almost the same as the old code. The difference is, instead of reading
|
|
||||||
directly from the callback into "stream", then converting and sending the audio off,
|
|
||||||
we go: callback -> "istream" -> (conversion) -> streamer -> stream -> device.
|
|
||||||
However, reading and writing with streamer are done separately:
|
|
||||||
- We only call the callback and write to the streamer when the streamer does not
|
|
||||||
contain enough samples to output to the device.
|
|
||||||
- We only read from the streamer and tell the device to play when the streamer
|
|
||||||
does have enough samples to output.
|
|
||||||
This allows us to perform resampling in the conversion step, where the output of the
|
|
||||||
resampling process can be any number. We will have to see what a good size for the
|
|
||||||
stream's maximum length is, but I suspect 2*max(len_cvt, stream_len) is a good figure.
|
|
||||||
*/
|
|
||||||
while (!device->shutdown) {
|
|
||||||
|
|
||||||
if (device->paused) {
|
|
||||||
SDL_Delay(delay);
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Only read in audio if the streamer doesn't have enough already (if it does not have enough samples to output) */
|
|
||||||
if (SDL_StreamLength(&device->streamer) < stream_len) {
|
|
||||||
/* Set up istream */
|
|
||||||
if (device->convert.needed) {
|
|
||||||
if (device->convert.buf) {
|
|
||||||
istream = device->convert.buf;
|
|
||||||
} else {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
/* FIXME: Ryan, this is probably wrong. I imagine we don't want to get
|
|
||||||
* a device buffer both here and below in the stream output.
|
|
||||||
*/
|
|
||||||
istream = current_audio.impl.GetDeviceBuf(device);
|
|
||||||
if (istream == NULL) {
|
|
||||||
istream = device->fake_stream;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Read from the callback into the _input_ stream */
|
|
||||||
// !!! FIXME: this should be LockDevice.
|
|
||||||
SDL_LockMutex(device->mixer_lock);
|
|
||||||
(*fill) (udata, istream, istream_len);
|
|
||||||
SDL_UnlockMutex(device->mixer_lock);
|
|
||||||
|
|
||||||
/* Convert the audio if necessary and write to the streamer */
|
|
||||||
if (device->convert.needed) {
|
|
||||||
SDL_ConvertAudio(&device->convert);
|
|
||||||
if (istream == NULL) {
|
|
||||||
istream = device->fake_stream;
|
|
||||||
}
|
|
||||||
/* SDL_memcpy(istream, device->convert.buf, device->convert.len_cvt); */
|
|
||||||
SDL_StreamWrite(&device->streamer, device->convert.buf,
|
|
||||||
device->convert.len_cvt);
|
|
||||||
} else {
|
|
||||||
SDL_StreamWrite(&device->streamer, istream, istream_len);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Only output audio if the streamer has enough to output */
|
|
||||||
if (SDL_StreamLength(&device->streamer) >= stream_len) {
|
|
||||||
/* Set up the output stream */
|
|
||||||
if (device->convert.needed) {
|
|
||||||
if (device->convert.buf) {
|
|
||||||
stream = device->convert.buf;
|
|
||||||
} else {
|
|
||||||
continue;
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
stream = current_audio.impl.GetDeviceBuf(device);
|
|
||||||
if (stream == NULL) {
|
|
||||||
stream = device->fake_stream;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Now read from the streamer */
|
|
||||||
SDL_StreamRead(&device->streamer, stream, stream_len);
|
|
||||||
|
|
||||||
/* Ready current buffer for play and change current buffer */
|
|
||||||
if (stream != device->fake_stream) {
|
|
||||||
current_audio.impl.PlayDevice(device);
|
|
||||||
/* Wait for an audio buffer to become available */
|
|
||||||
current_audio.impl.WaitDevice(device);
|
|
||||||
} else {
|
|
||||||
SDL_Delay(delay);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
if (stream == NULL) {
|
||||||
|
stream = device->fake_stream;
|
||||||
}
|
}
|
||||||
} else
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
/* Otherwise, do not use the streamer. This is the old code. */
|
|
||||||
const int silence = (int) device->spec.silence;
|
|
||||||
|
|
||||||
/* Loop, filling the audio buffers */
|
/* !!! FIXME: this should be LockDevice. */
|
||||||
while (!device->shutdown) {
|
SDL_LockMutex(device->mixer_lock);
|
||||||
/* Fill the current buffer with sound */
|
if (device->paused) {
|
||||||
if (device->convert.needed) {
|
SDL_memset(stream, silence, stream_len);
|
||||||
stream = device->convert.buf;
|
} else {
|
||||||
} else if (device->enabled) {
|
(*fill) (udata, stream, stream_len);
|
||||||
stream = current_audio.impl.GetDeviceBuf(device);
|
}
|
||||||
} else {
|
SDL_UnlockMutex(device->mixer_lock);
|
||||||
/* if the device isn't enabled, we still write to the
|
|
||||||
fake_stream, so the app's callback will fire with
|
|
||||||
a regular frequency, in case they depend on that
|
|
||||||
for timing or progress. They can use hotplug
|
|
||||||
now to know if the device failed. */
|
|
||||||
stream = NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
/* Convert the audio if necessary */
|
||||||
|
if (device->enabled && device->convert.needed) {
|
||||||
|
SDL_ConvertAudio(&device->convert);
|
||||||
|
stream = current_audio.impl.GetDeviceBuf(device);
|
||||||
if (stream == NULL) {
|
if (stream == NULL) {
|
||||||
stream = device->fake_stream;
|
stream = device->fake_stream;
|
||||||
}
|
|
||||||
|
|
||||||
/* !!! FIXME: this should be LockDevice. */
|
|
||||||
SDL_LockMutex(device->mixer_lock);
|
|
||||||
if (device->paused) {
|
|
||||||
SDL_memset(stream, silence, stream_len);
|
|
||||||
} else {
|
} else {
|
||||||
(*fill) (udata, stream, stream_len);
|
SDL_memcpy(stream, device->convert.buf,
|
||||||
|
device->convert.len_cvt);
|
||||||
}
|
}
|
||||||
SDL_UnlockMutex(device->mixer_lock);
|
}
|
||||||
|
|
||||||
/* Convert the audio if necessary */
|
/* Ready current buffer for play and change current buffer */
|
||||||
if (device->enabled && device->convert.needed) {
|
if (stream == device->fake_stream) {
|
||||||
SDL_ConvertAudio(&device->convert);
|
SDL_Delay(delay);
|
||||||
stream = current_audio.impl.GetDeviceBuf(device);
|
} else {
|
||||||
if (stream == NULL) {
|
current_audio.impl.PlayDevice(device);
|
||||||
stream = device->fake_stream;
|
current_audio.impl.WaitDevice(device);
|
||||||
} else {
|
|
||||||
SDL_memcpy(stream, device->convert.buf,
|
|
||||||
device->convert.len_cvt);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Ready current buffer for play and change current buffer */
|
|
||||||
if (stream != device->fake_stream) {
|
|
||||||
current_audio.impl.PlayDevice(device);
|
|
||||||
/* Wait for an audio buffer to become available */
|
|
||||||
current_audio.impl.WaitDevice(device);
|
|
||||||
} else {
|
|
||||||
SDL_Delay(delay);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Wait for the audio to drain.. */
|
/* Wait for the audio to drain. */
|
||||||
current_audio.impl.WaitDone(device);
|
current_audio.impl.WaitDone(device);
|
||||||
|
|
||||||
/* If necessary, deinit the streamer */
|
|
||||||
#if 0 /* !!! FIXME: rewrite/remove this streamer code. */
|
|
||||||
if (device->use_streamer == 1)
|
|
||||||
SDL_StreamDeinit(&device->streamer);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue