зеркало из https://github.com/mozilla/pjs.git
Bug 461135 - Update libsydneyaudio to fix PulseAudio playback issues
This commit is contained in:
Chris Double
Родитель
43f2bbd40c
Коммит
4a488d5aa8
|
|
@ -5,4 +5,4 @@ the Mozilla build system.
|
|||
|
||||
http://svn.annodex.net/libsydneyaudio/trunk
|
||||
|
||||
The svn revision number used was r3730.
|
||||
The svn revision number used was r3731.
|
||||
|
|
|
|||
|
|
@ -34,75 +34,27 @@
|
|||
* ***** END LICENSE BLOCK ***** *
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <pthread.h>
|
||||
#include <alsa/asoundlib.h>
|
||||
#include "sydney_audio.h"
|
||||
|
||||
/* ALSA implementation based heavily on sydney_audio_mac.c */
|
||||
|
||||
/*
|
||||
* The audio interface is based on a "pull" I/O model, which means you
|
||||
* can't just provide a data buffer and tell the audio device to play; you must
|
||||
* register a callback and provide data as the device asks for it. To support
|
||||
* sydney audio's "write-to-play" style interface, we have to buffer up the
|
||||
* data as it arrives and feed it to the callback as required.
|
||||
*
|
||||
* This is handled by a simple linked list of buffers; data is always written
|
||||
* to the tail and read from the head. Each buffer tracks the start and end
|
||||
* positions of its contained data. Buffers are allocated when the tail buffer
|
||||
* fills, and freed when the head buffer empties. There is always at least one
|
||||
* buffer allocated.
|
||||
*
|
||||
* s e s e s e + data read
|
||||
* +++##### -> ######## -> ####---- # data written
|
||||
* ^ ^ - empty
|
||||
* bl_head bl_tail
|
||||
*/
|
||||
|
||||
typedef struct sa_buf sa_buf;
|
||||
struct sa_buf {
|
||||
unsigned int size;
|
||||
unsigned int start;
|
||||
unsigned int end;
|
||||
sa_buf * next;
|
||||
unsigned char data[0];
|
||||
};
|
||||
|
||||
struct sa_stream {
|
||||
snd_pcm_t* output_unit;
|
||||
pthread_t thread_id;
|
||||
pthread_mutex_t mutex;
|
||||
char playing;
|
||||
int64_t bytes_played;
|
||||
int64_t bytes_written;
|
||||
|
||||
/* audio format info */
|
||||
unsigned int rate;
|
||||
unsigned int n_channels;
|
||||
unsigned int bytes_per_ch;
|
||||
|
||||
/* buffer list */
|
||||
sa_buf * bl_head;
|
||||
sa_buf * bl_tail;
|
||||
int n_bufs;
|
||||
snd_pcm_uframes_t buffer_size;
|
||||
snd_pcm_uframes_t period_size;
|
||||
unsigned int buffer_bytes;
|
||||
unsigned int period_bytes;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Use a default buffer size with enough room for one second of audio,
|
||||
* assuming stereo data at 44.1kHz with 32 bits per channel, and impose
|
||||
* a generous limit on the number of buffers.
|
||||
*/
|
||||
#define BUF_SIZE (2 * 44100 * 4)
|
||||
#define BUF_LIMIT 5
|
||||
|
||||
#if BUF_LIMIT < 2
|
||||
#error BUF_LIMIT must be at least 2!
|
||||
#endif
|
||||
|
||||
static void audio_callback(void* s);
|
||||
static sa_buf *new_buffer(void);
|
||||
|
||||
|
||||
/*
|
||||
* -----------------------------------------------------------------------------
|
||||
* Startup and shutdown functions
|
||||
|
|
@ -141,25 +93,13 @@ sa_stream_create_pcm(
|
|||
if ((s = malloc(sizeof(sa_stream_t))) == NULL) {
|
||||
return SA_ERROR_OOM;
|
||||
}
|
||||
if ((s->bl_head = new_buffer()) == NULL) {
|
||||
free(s);
|
||||
return SA_ERROR_OOM;
|
||||
}
|
||||
if (pthread_mutex_init(&s->mutex, NULL) != 0) {
|
||||
free(s->bl_head);
|
||||
free(s);
|
||||
return SA_ERROR_SYSTEM;
|
||||
}
|
||||
|
||||
s->output_unit = NULL;
|
||||
s->thread_id = 0;
|
||||
s->playing = 0;
|
||||
s->bytes_played = 0;
|
||||
s->bytes_written = 0;
|
||||
s->rate = rate;
|
||||
s->n_channels = n_channels;
|
||||
s->bytes_per_ch = 2;
|
||||
s->bl_tail = s->bl_head;
|
||||
s->n_bufs = 1;
|
||||
|
||||
*_s = s;
|
||||
return SA_SUCCESS;
|
||||
|
|
@ -189,11 +129,19 @@ sa_stream_open(sa_stream_t *s) {
|
|||
s->n_channels,
|
||||
s->rate,
|
||||
1,
|
||||
0) < 0) {
|
||||
500000) < 0) {
|
||||
snd_pcm_close(s->output_unit);
|
||||
s->output_unit = NULL;
|
||||
return SA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
if (snd_pcm_get_params(s->output_unit, &s->buffer_size, &s->period_size) < 0) {
|
||||
snd_pcm_close(s->output_unit);
|
||||
s->output_unit = NULL;
|
||||
return SA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
s->period_bytes = (unsigned int)snd_pcm_frames_to_bytes(s->output_unit, s->period_size);
|
||||
s->buffer_bytes = (unsigned int)snd_pcm_frames_to_bytes(s->output_unit, s->buffer_size);
|
||||
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
|
@ -206,14 +154,6 @@ sa_stream_destroy(sa_stream_t *s) {
|
|||
if (s == NULL) {
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
|
||||
/*
|
||||
* This causes the thread sending data to ALSA to stop
|
||||
*/
|
||||
s->thread_id = 0;
|
||||
|
||||
/*
|
||||
* Shut down the audio output device.
|
||||
*/
|
||||
|
|
@ -222,22 +162,6 @@ sa_stream_destroy(sa_stream_t *s) {
|
|||
result = SA_ERROR_SYSTEM;
|
||||
}
|
||||
}
|
||||
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
|
||||
/*
|
||||
* Release resources.
|
||||
*/
|
||||
if (pthread_mutex_destroy(&s->mutex) != 0) {
|
||||
result = SA_ERROR_SYSTEM;
|
||||
}
|
||||
while (s->bl_head != NULL) {
|
||||
sa_buf * next = s->bl_head->next;
|
||||
free(s->bl_head);
|
||||
s->bl_head = next;
|
||||
}
|
||||
free(s);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
|
@ -252,6 +176,7 @@ sa_stream_destroy(sa_stream_t *s) {
|
|||
int
|
||||
sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes) {
|
||||
int result = SA_SUCCESS;
|
||||
snd_pcm_sframes_t frames, nframes;
|
||||
|
||||
if (s == NULL || s->output_unit == NULL) {
|
||||
return SA_ERROR_NO_INIT;
|
||||
|
|
@ -260,186 +185,35 @@ sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes) {
|
|||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
nframes = snd_pcm_bytes_to_frames(s->output_unit, nbytes);
|
||||
|
||||
/*
|
||||
* Append the new data to the end of our buffer list.
|
||||
*/
|
||||
while (1) {
|
||||
unsigned int avail = s->bl_tail->size - s->bl_tail->end;
|
||||
|
||||
if (nbytes <= avail) {
|
||||
|
||||
/*
|
||||
* The new data will fit into the current tail buffer, so
|
||||
* just copy it in and we're done.
|
||||
*/
|
||||
memcpy(s->bl_tail->data + s->bl_tail->end, data, nbytes);
|
||||
s->bl_tail->end += nbytes;
|
||||
break;
|
||||
|
||||
} else {
|
||||
|
||||
/*
|
||||
* Copy what we can into the tail and allocate a new buffer
|
||||
* for the rest.
|
||||
*/
|
||||
memcpy(s->bl_tail->data + s->bl_tail->end, data, avail);
|
||||
s->bl_tail->end += avail;
|
||||
data = ((unsigned char *)data) + avail;
|
||||
nbytes -= avail;
|
||||
|
||||
/*
|
||||
* If we still have data left to copy but we've hit the limit of
|
||||
* allowable buffer allocations, we need to spin for a bit to allow
|
||||
* the audio callback function to slurp some more data up.
|
||||
*/
|
||||
if (nbytes > 0 && s->n_bufs == BUF_LIMIT) {
|
||||
#ifdef TIMING_TRACE
|
||||
printf("#"); /* too much audio data */
|
||||
#endif
|
||||
if (!s->playing) {
|
||||
/*
|
||||
* We haven't even started playing yet! That means the
|
||||
* BUF_SIZE/BUF_LIMIT values are too low... Not much we can
|
||||
* do here; spinning won't help because the audio callback
|
||||
* hasn't been enabled yet. Oh well, error time.
|
||||
*/
|
||||
printf("Too much audio data received before audio device enabled!\n");
|
||||
result = SA_ERROR_SYSTEM;
|
||||
break;
|
||||
}
|
||||
while (s->n_bufs == BUF_LIMIT) {
|
||||
struct timespec ts = {0, 1000000};
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
nanosleep(&ts, NULL);
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Allocate a new tail buffer, and go 'round again to fill it up.
|
||||
*/
|
||||
if ((s->bl_tail->next = new_buffer()) == NULL) {
|
||||
result = SA_ERROR_OOM;
|
||||
break;
|
||||
}
|
||||
s->n_bufs++;
|
||||
s->bl_tail = s->bl_tail->next;
|
||||
|
||||
} /* if (nbytes <= avail), else */
|
||||
|
||||
} /* while (1) */
|
||||
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
|
||||
/*
|
||||
* Once we have our first block of audio data, enable the audio callback
|
||||
* function. This doesn't need to be protected by the mutex, because
|
||||
* s->playing is not used in the audio callback thread, and it's probably
|
||||
* better not to be inside the lock when we enable the audio callback.
|
||||
*/
|
||||
if (!s->playing) {
|
||||
s->playing = 1;
|
||||
if (pthread_create(&s->thread_id, NULL, (void *)audio_callback, s) != 0) {
|
||||
result = SA_ERROR_SYSTEM;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
static void audio_callback(void* data)
|
||||
{
|
||||
sa_stream_t* s = (sa_stream_t*)data;
|
||||
snd_pcm_uframes_t buffer_size;
|
||||
snd_pcm_uframes_t period_size;
|
||||
unsigned int bytes_per_frame = s->n_channels * s->bytes_per_ch;
|
||||
char* buffer = 0;
|
||||
|
||||
#ifdef TIMING_TRACE
|
||||
printf("."); /* audio read 'tick' */
|
||||
#endif
|
||||
|
||||
snd_pcm_get_params(s->output_unit, &buffer_size, &period_size);
|
||||
|
||||
buffer = malloc(period_size * bytes_per_frame);
|
||||
|
||||
while(1) {
|
||||
char* dst = buffer;
|
||||
unsigned int bytes_to_copy = period_size * bytes_per_frame;
|
||||
snd_pcm_sframes_t frames;
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
if (!s->thread_id)
|
||||
break;
|
||||
|
||||
/*
|
||||
* Consume data from the start of the buffer list.
|
||||
*/
|
||||
while (1) {
|
||||
unsigned int avail = s->bl_head->end - s->bl_head->start;
|
||||
assert(s->bl_head->start <= s->bl_head->end);
|
||||
|
||||
if (avail >= bytes_to_copy) {
|
||||
/*
|
||||
* We have all we need in the head buffer, so just grab it and go.
|
||||
*/
|
||||
memcpy(dst, s->bl_head->data + s->bl_head->start, bytes_to_copy);
|
||||
s->bl_head->start += bytes_to_copy;
|
||||
s->bytes_played += bytes_to_copy;
|
||||
break;
|
||||
|
||||
} else {
|
||||
sa_buf* next = 0;
|
||||
/*
|
||||
* Copy what we can from the head and move on to the next buffer.
|
||||
*/
|
||||
memcpy(dst, s->bl_head->data + s->bl_head->start, avail);
|
||||
s->bl_head->start += avail;
|
||||
dst += avail;
|
||||
bytes_to_copy -= avail;
|
||||
s->bytes_played += avail;
|
||||
|
||||
/*
|
||||
* We want to free the now-empty buffer, but not if it's also the
|
||||
* current tail. If it is the tail, we don't have enough data to fill
|
||||
* the destination buffer, so we'll just zero it out and give up.
|
||||
*/
|
||||
next = s->bl_head->next;
|
||||
if (next == NULL) {
|
||||
#ifdef TIMING_TRACE
|
||||
printf("!"); /* not enough audio data */
|
||||
#endif
|
||||
memset(dst, 0, bytes_to_copy);
|
||||
break;
|
||||
}
|
||||
free(s->bl_head);
|
||||
s->bl_head = next;
|
||||
s->n_bufs--;
|
||||
|
||||
} /* if (avail >= bytes_to_copy), else */
|
||||
|
||||
} /* while (1) */
|
||||
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
|
||||
frames = snd_pcm_writei(s->output_unit, buffer, period_size);
|
||||
while(nframes>0) {
|
||||
snd_pcm_sframes_t len = s->period_size;
|
||||
if(nframes < s->period_size)
|
||||
len = nframes;
|
||||
frames = snd_pcm_writei(s->output_unit, data, len);
|
||||
if (frames < 0) {
|
||||
frames = snd_pcm_recover(s->output_unit, frames, 1);
|
||||
if (frames < 0) {
|
||||
printf("snc_pcm_recover error: %s\n", snd_strerror(frames));
|
||||
return SA_ERROR_SYSTEM;
|
||||
}
|
||||
if(frames > 0 && frames < period_size)
|
||||
printf("short write (expected %d, wrote %d)\n", (int)period_size, (int)frames);;
|
||||
if(frames > 0 && frames < len)
|
||||
printf("short write (expected %d, wrote %d)\n", (int)len, (int)frames);
|
||||
}
|
||||
nframes -= s->period_size;
|
||||
data = ((unsigned char *)data) + s->period_bytes;
|
||||
}
|
||||
free(buffer);
|
||||
|
||||
s->bytes_written += nbytes;
|
||||
|
||||
if (!s->playing) {
|
||||
s->playing = 1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* -----------------------------------------------------------------------------
|
||||
* General query and support functions
|
||||
|
|
@ -448,41 +222,51 @@ static void audio_callback(void* data)
|
|||
|
||||
int
|
||||
sa_stream_get_write_size(sa_stream_t *s, size_t *size) {
|
||||
sa_buf * b;
|
||||
size_t used = 0;
|
||||
snd_pcm_sframes_t avail;
|
||||
|
||||
if (s == NULL || s->output_unit == NULL) {
|
||||
return SA_ERROR_NO_INIT;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
avail = snd_pcm_avail_update(s->output_unit);
|
||||
|
||||
/*
|
||||
* The sum of the free space in the tail buffer plus the size of any new
|
||||
* buffers represents the write space available before blocking.
|
||||
*/
|
||||
unsigned int avail = s->bl_tail->size - s->bl_tail->end;
|
||||
avail += (BUF_LIMIT - s->n_bufs) * BUF_SIZE;
|
||||
*size = avail;
|
||||
*size = snd_pcm_frames_to_bytes(s->output_unit, avail);
|
||||
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
|
||||
|
||||
int err;
|
||||
snd_pcm_sframes_t delay;
|
||||
|
||||
if (s == NULL || s->output_unit == NULL) {
|
||||
return SA_ERROR_NO_INIT;
|
||||
}
|
||||
|
||||
if (position != SA_POSITION_WRITE_SOFTWARE) {
|
||||
return SA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
if (snd_pcm_state(s->output_unit) != SND_PCM_STATE_RUNNING) {
|
||||
delay = 0;
|
||||
}
|
||||
else if (snd_pcm_delay (s->output_unit, &delay) != 0) {
|
||||
printf("snd_pcm_delay failed\n");
|
||||
delay = 0;
|
||||
}
|
||||
if (delay < 0) {
|
||||
delay = 0;
|
||||
}
|
||||
if (delay > s->buffer_size) {
|
||||
printf("delay just wrong %d vs %d\n", delay, s->buffer_size);
|
||||
delay = s->buffer_size;
|
||||
}
|
||||
|
||||
s->bytes_played = s->bytes_written - snd_pcm_frames_to_bytes(s->output_unit, delay);
|
||||
|
||||
*pos = s->bytes_played;
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
@ -493,12 +277,10 @@ sa_stream_pause(sa_stream_t *s) {
|
|||
if (s == NULL || s->output_unit == NULL) {
|
||||
return SA_ERROR_NO_INIT;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
#if 0 /* TODO */
|
||||
AudioOutputUnitStop(s->output_unit);
|
||||
#endif
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
@ -510,57 +292,23 @@ sa_stream_resume(sa_stream_t *s) {
|
|||
return SA_ERROR_NO_INIT;
|
||||
}
|
||||
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
|
||||
/*
|
||||
* The audio device resets its mSampleTime counter after pausing,
|
||||
* so we need to clear our tracking value to keep that in sync.
|
||||
*/
|
||||
s->bytes_played = 0;
|
||||
#if 0 /* TODO */
|
||||
AudioOutputUnitStart(s->output_unit);
|
||||
#endif
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
s->bytes_played = s->bytes_written = 0;
|
||||
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
static sa_buf *
|
||||
new_buffer(void) {
|
||||
sa_buf * b = malloc(sizeof(sa_buf) + BUF_SIZE);
|
||||
if (b != NULL) {
|
||||
b->size = BUF_SIZE;
|
||||
b->start = 0;
|
||||
b->end = 0;
|
||||
b->next = NULL;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
sa_stream_drain(sa_stream_t *s)
|
||||
{
|
||||
if (s == NULL || s->output_unit == NULL) {
|
||||
return SA_ERROR_NO_INIT;
|
||||
}
|
||||
|
||||
while (1) {
|
||||
pthread_mutex_lock(&s->mutex);
|
||||
sa_buf * b;
|
||||
size_t used = 0;
|
||||
for (b = s->bl_head; b != NULL; b = b->next) {
|
||||
used += b->end - b->start;
|
||||
}
|
||||
pthread_mutex_unlock(&s->mutex);
|
||||
|
||||
if (used == 0) {
|
||||
break;
|
||||
}
|
||||
|
||||
struct timespec ts = {0, 1000000};
|
||||
nanosleep(&ts, NULL);
|
||||
}
|
||||
snd_pcm_drain(s->output_unit);
|
||||
return SA_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче