147 lines
2.9 KiB
C
147 lines
2.9 KiB
C
#include "ao_playasync.h"
|
|
#include <ao/ao.h>
|
|
#include <pthread.h>
|
|
#include <unistd.h>
|
|
#include <assert.h>
|
|
#include <malloc.h>
|
|
#include <string.h>
|
|
|
|
typedef enum {
|
|
PLAY = 1,
|
|
STOP = 2
|
|
} Command_t;
|
|
|
|
typedef struct _queue_ {
|
|
Command_t command;
|
|
void *buf;
|
|
int buflen;
|
|
struct _queue_ *next;
|
|
struct _queue_ *prev;
|
|
} Queue_t;
|
|
|
|
typedef struct {
|
|
Queue_t *play_queue;
|
|
Queue_t *last_frame;
|
|
ao_device *ao_device;
|
|
pthread_mutex_t mutex;
|
|
pthread_t thread;
|
|
} AO_Handle;
|
|
|
|
static Queue_t *front(AO_Handle *h)
|
|
{
|
|
assert(h->play_queue != NULL);
|
|
return h->play_queue;
|
|
}
|
|
|
|
static Queue_t *get(AO_Handle *h)
|
|
{
|
|
assert(h->play_queue != NULL);
|
|
Queue_t *q = h->play_queue;
|
|
h->play_queue = h->play_queue->next;
|
|
h->play_queue->prev = NULL;
|
|
if (h->play_queue == NULL) {
|
|
h->last_frame = NULL;
|
|
}
|
|
return q;
|
|
}
|
|
|
|
static void add(AO_Handle *h, Queue_t *elem)
|
|
{
|
|
if (h->last_frame == NULL) {
|
|
h->play_queue = elem;
|
|
elem->next = NULL;
|
|
elem->prev = NULL;
|
|
h->last_frame = h->play_queue;
|
|
} else {
|
|
h->last_frame->next = elem;
|
|
elem->prev = h->last_frame;
|
|
elem->next = NULL;
|
|
h->last_frame = elem;
|
|
}
|
|
}
|
|
|
|
static Queue_t *new_elem(int command, int buf_len, void *buf)
|
|
{
|
|
Queue_t *q = (Queue_t *) malloc(sizeof(Queue_t));
|
|
void *new_buf;
|
|
|
|
if (buf_len != 0) {
|
|
new_buf = (void *) malloc(buf_len);
|
|
memcpy(new_buf, buf, buf_len);
|
|
} else {
|
|
new_buf = NULL;
|
|
}
|
|
q->buf = new_buf;
|
|
q->buflen = buf_len;
|
|
q->command = command;
|
|
q->next = NULL;
|
|
q->prev = NULL;
|
|
return q;
|
|
}
|
|
|
|
static void clear(AO_Handle *h)
|
|
{
|
|
while (h->play_queue != NULL) {
|
|
Queue_t *q = get(h);
|
|
if (q->buflen != 0) {
|
|
free(q->buf);
|
|
}
|
|
free(q);
|
|
}
|
|
}
|
|
|
|
static void *run(void *arg)
|
|
{
|
|
AO_Handle *handle = (AO_Handle *) arg;
|
|
|
|
int go_on = (1 == 1);
|
|
|
|
while(go_on) {
|
|
pthread_mutex_lock(&handle->mutex);
|
|
int has_frames = (handle->play_queue != NULL);
|
|
|
|
if (has_frames) {
|
|
|
|
pthread_mutex_unlock(&handle->mutex);
|
|
|
|
} else {
|
|
pthread_mutex_unlock(&handle->mutex);
|
|
usleep(5000); // sleep for 5ms
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void *ao_create_async(void *ao_device_yeah)
|
|
{
|
|
AO_Handle *handle = (AO_Handle *) malloc(sizeof(AO_Handle));
|
|
|
|
handle->ao_device = (ao_device *) ao_device_yeah;
|
|
handle->play_queue = NULL;
|
|
handle->last_frame = NULL;
|
|
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
|
|
handle->mutex = m;
|
|
|
|
pthread_create(&handle->thread, NULL, run, handle);
|
|
|
|
return (void *) handle;
|
|
}
|
|
|
|
void ao_stop_async(void *ao_handle)
|
|
{
|
|
AO_Handle *h = (AO_Handle *) ao_handle;
|
|
clear(h);
|
|
Queue_t *q = new_elem(STOP, 0, NULL);
|
|
add(h, q);
|
|
}
|
|
|
|
void ao_play_async(void *ao_handle, int buf_size, void *mem)
|
|
{
|
|
AO_Handle *h = (AO_Handle *) ao_handle;
|
|
Queue_t *q = new_elem(PLAY, buf_size, mem);
|
|
add(h, q);
|
|
}
|
|
|
|
|