-

libao/c/ao-play-async/ao_playasync.c

@@ -1,20 +1,26 @@
 #include "ao_playasync.h"
-#include <ao/ao.h>
 #include <pthread.h>
 #include <unistd.h>
 #include <assert.h>
 #include <malloc.h>
 #include <string.h>
+#include <dlfcn.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
 
 typedef enum {
     PLAY = 1,
     STOP = 2
 } Command_t;
 
+typedef void * ao_device;
+
 typedef struct _queue_ {
     Command_t command;
     void *buf;
     int buflen;
+    double at_second;
     struct _queue_ *next;
     struct _queue_ *prev;
 } Queue_t;
@@ -25,8 +31,12 @@ typedef struct {
     ao_device   *ao_device;
     pthread_mutex_t mutex;
     pthread_t    thread;
+    double       at_second;
 } AO_Handle;
 
+static int(*ao_play)(void *device, char *samples, uint32_t n) = NULL;
+
+
 static Queue_t *front(AO_Handle *h)
 {
     assert(h->play_queue != NULL);
@@ -38,9 +48,10 @@ 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;
+    } else {
+        h->play_queue->prev = NULL;
     }
     return q;
 }
@@ -60,7 +71,7 @@ static void add(AO_Handle *h, Queue_t *elem)
     }
 }
 
-static Queue_t *new_elem(int command, int buf_len, void *buf)
+static Queue_t *new_elem(int command, double at_second, int buf_len, void *buf)
 {
     Queue_t *q = (Queue_t *) malloc(sizeof(Queue_t));
     void *new_buf;
@@ -71,6 +82,7 @@ static Queue_t *new_elem(int command, int buf_len, void *buf)
     } else {
         new_buf = NULL;
     }
+    q->at_second = at_second;
     q->buf = new_buf;
     q->buflen = buf_len;
     q->command = command;
@@ -79,14 +91,19 @@ static Queue_t *new_elem(int command, int buf_len, void *buf)
     return q;
 }
 
+static void del_elem(Queue_t *q)
+{
+    if (q->buflen != 0) {
+        free(q->buf);
+    }
+    free(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);
+        del_elem(q);
     }
 }
 
@@ -101,9 +118,17 @@ static void *run(void *arg)
         int has_frames = (handle->play_queue != NULL);
 
         if (has_frames) {
-
+            Queue_t *q = get(handle);
+            handle->at_second = q->at_second;
             pthread_mutex_unlock(&handle->mutex);
 
+            if (q->command == STOP) {
+                go_on = (1 == 0);
+            } else {
+                ao_play(handle->ao_device, q->buf, q->buflen);
+            }
+
+            del_elem(q);
         } else {
             pthread_mutex_unlock(&handle->mutex);
             usleep(5000);   // sleep for 5ms
@@ -113,13 +138,35 @@ static void *run(void *arg)
     return NULL;
 }
 
+static void get_ao_play(void)
+{
+    char *lib = "libao.so";
+    void *handle = dlopen(lib, RTLD_LAZY);
+    if (!handle) {
+        fprintf(stderr, "Cannot open library %s: %s\n", lib, dlerror());
+        exit(EXIT_FAILURE);
+    }
+
+    ao_play = dlsym(handle, "ao_play");
+    char *err;
+    err = dlerror();
+    if (err != NULL) {
+        fprintf(stderr, "Cannot get function ao_play: %s\n", err);
+        exit(EXIT_FAILURE);
+    }
+}
+
+
 void *ao_create_async(void *ao_device_yeah)
 {
+    if (ao_play == NULL) { get_ao_play(); }
+
     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;
+    handle->at_second = -1;
     pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
     handle->mutex = m;
 
@@ -131,16 +178,32 @@ void *ao_create_async(void *ao_device_yeah)
 void ao_stop_async(void *ao_handle)
 {
     AO_Handle *h = (AO_Handle *) ao_handle;
+
+    pthread_mutex_lock(&h->mutex);
     clear(h);
-    Queue_t *q = new_elem(STOP, 0, NULL);
+    Queue_t *q = new_elem(STOP, 0.0, 0, NULL);
     add(h, q);
+    pthread_mutex_unlock(&h->mutex);
+
+    void *retval;
+    pthread_join(h->thread, &retval);
+    free(h);
 }
 
-void ao_play_async(void *ao_handle, int buf_size, void *mem)
+void ao_play_async(void *ao_handle, double at_second, int buf_size, void *mem)
 {
     AO_Handle *h = (AO_Handle *) ao_handle;
-    Queue_t *q = new_elem(PLAY, buf_size, mem);
+    Queue_t *q = new_elem(PLAY, at_second, buf_size, mem);
+    pthread_mutex_lock(&h->mutex);
     add(h, q);
+    pthread_mutex_unlock(&h->mutex);
+}
+
+double ao_is_at_second_async(void *ao_handle)
+{
+    AO_Handle *h = (AO_Handle *) ao_handle;
+    return h->at_second;
 }
 
 
+