chiark - git - mdw - disorder/blob - lib/uaudio-thread.c

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2009, 2013 Richard Kettlewell
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 /** @file lib/uaudio-thread.c
  19  * @brief Background thread for audio processing */
  20 #include "common.h"
  21
  22 #include <pthread.h>
  23 #include <unistd.h>
  24
  25 #include "uaudio.h"
  26 #include "log.h"
  27 #include "mem.h"
  28 #include "syscalls.h"
  29 #include "timeval.h"
  30
  31 /** @brief Number of buffers
  32  *
  33  * Must be at least 2 and should normally be at least 3.  We maintain multiple
  34  * buffers so that we can read new data into one while the previous is being
  35  * played.
  36  */
  37 #define UAUDIO_THREAD_BUFFERS 4
  38
  39 /** @brief Buffer data structure */
  40 struct uaudio_buffer {
  41   /** @brief Pointer to sample data */
  42   void *samples;
  43
  44   /** @brief Count of samples */
  45   size_t nsamples;
  46 };
  47
  48 /** @brief Input buffers
  49  *
  50  * This is actually a ring buffer, managed by @ref uaudio_collect_buffer and
  51  * @ref uaudio_play_buffer.
  52  *
  53  * Initially both pointers are 0.  Whenever the pointers are equal, we
  54  * interpreted this as meaning that there is no data stored at all.  A
  55  * consequence of this is that maximal occupancy is when the collect point is
  56  * just before the play point, so at least one buffer is always empty (hence it
  57  * being good for @ref UAUDIO_THREAD_BUFFERS to be at least 3).
  58  */
  59 static struct uaudio_buffer uaudio_buffers[UAUDIO_THREAD_BUFFERS];
  60
  61 /** @brief Buffer to read into */
  62 static unsigned uaudio_collect_buffer;
  63
  64 /** @brief Buffer to play from */
  65 static unsigned uaudio_play_buffer;
  66
  67 /** @brief Collection thread ID */
  68 static pthread_t uaudio_collect_thread;
  69
  70 /** @brief Playing thread ID */
  71 static pthread_t uaudio_play_thread;
  72
  73 /** @brief Flags */
  74 static unsigned uaudio_thread_flags;
  75
  76 static uaudio_callback *uaudio_thread_collect_callback;
  77 static uaudio_playcallback *uaudio_thread_play_callback;
  78 static void *uaudio_thread_userdata;
  79 static int uaudio_thread_started;
  80 static int uaudio_thread_collecting;
  81 static pthread_mutex_t uaudio_thread_lock = PTHREAD_MUTEX_INITIALIZER;
  82 static pthread_cond_t uaudio_thread_cond = PTHREAD_COND_INITIALIZER;
  83
  84 /** @brief Minimum number of samples per chunk */
  85 static size_t uaudio_thread_min;
  86
  87 /** @brief Maximum number of samples per chunk */
  88 static size_t uaudio_thread_max;
  89
  90 /** @brief Set when activated, clear when paused */
  91 static int uaudio_thread_activated;
  92
  93 /** @brief Return number of buffers currently in use */
  94 static int uaudio_buffers_used(void) {
  95   return (uaudio_collect_buffer - uaudio_play_buffer) % UAUDIO_THREAD_BUFFERS;
  96 }
  97
  98 /** @brief Background thread for audio collection
  99  *
 100  * Collects data while activated and communicates its status via @ref
 101  * uaudio_thread_collecting.
 102  */
 103 static void *uaudio_collect_thread_fn(void attribute((unused)) *arg) {
 104   pthread_mutex_lock(&uaudio_thread_lock);
 105   while(uaudio_thread_started) {
 106     /* Wait until we're activatd */
 107     if(!uaudio_thread_activated) {
 108       pthread_cond_wait(&uaudio_thread_cond, &uaudio_thread_lock);
 109       continue;
 110     }
 111     /* We are definitely active now */
 112     uaudio_thread_collecting = 1;
 113     pthread_cond_broadcast(&uaudio_thread_cond);
 114     while(uaudio_thread_activated) {
 115       if(uaudio_buffers_used() < UAUDIO_THREAD_BUFFERS - 1) {
 116         /* At least one buffer is available.  We release the lock while
 117          * collecting data so that other already-filled buffers can be played
 118          * without delay.  */
 119         struct uaudio_buffer *const b = &uaudio_buffers[uaudio_collect_buffer];
 120         pthread_mutex_unlock(&uaudio_thread_lock);
 121         //fprintf(stderr, "C%d.", uaudio_collect_buffer);
 122
 123         /* Keep on trying until we get the minimum required amount of data */
 124         b->nsamples = 0;
 125         if(uaudio_thread_activated) {
 126           while(b->nsamples < uaudio_thread_min) {
 127             b->nsamples += uaudio_thread_collect_callback
 128               ((char *)b->samples
 129                + b->nsamples * uaudio_sample_size,
 130                uaudio_thread_max - b->nsamples,
 131                uaudio_thread_userdata);
 132           }
 133         }
 134         pthread_mutex_lock(&uaudio_thread_lock);
 135         /* Advance to next buffer */
 136         uaudio_collect_buffer = (1 + uaudio_collect_buffer) % UAUDIO_THREAD_BUFFERS;
 137         /* Awaken player */
 138         pthread_cond_broadcast(&uaudio_thread_cond);
 139       } else
 140         /* No space, wait for player */
 141         pthread_cond_wait(&uaudio_thread_cond, &uaudio_thread_lock);
 142     }
 143     uaudio_thread_collecting = 0;
 144     pthread_cond_broadcast(&uaudio_thread_cond);
 145   }
 146   pthread_mutex_unlock(&uaudio_thread_lock);
 147   return NULL;
 148 }
 149
 150 static size_t uaudio_play_samples(void *buffer, size_t samples, unsigned flags) {
 151   static struct timespec base;
 152   static int64_t frames_supplied;
 153   struct timespec now;
 154   struct timespec delay_ts;
 155   double target, delay;
 156
 157   if(!base.tv_sec)
 158     xgettime(CLOCK_MONOTONIC, &base);
 159   samples = uaudio_thread_play_callback(buffer, samples, flags);
 160   frames_supplied += samples / uaudio_channels;
 161   /* Set target to the approximate point at which we run out of buffered audio.
 162    * If no buffer size has been specified, use 1/16th of a second. */
 163   target = (frames_supplied - (uaudio_buffer ? uaudio_buffer : uaudio_rate / 16))
 164     / (double)uaudio_rate + ts_to_double(base);
 165   for(;;) {
 166     xgettime(CLOCK_MONOTONIC, &now);
 167     delay = target - ts_to_double(now);
 168     if(delay <= 0) {
 169       //putc('.', stderr);
 170       break;
 171     }
 172     //putc('!', stderr);
 173     /*
 174     fprintf(stderr, "frames supplied %ld (%lds) base %f target %f now %f want delay %g\n",
 175             frames_supplied,
 176             frames_supplied / uaudio_rate,
 177             ts_to_double(base),
 178             target,
 179             ts_to_double(now),
 180             delay);
 181     */
 182     delay_ts = double_to_ts(delay);
 183     xnanosleep(&delay_ts, NULL);
 184   }
 185   return samples;
 186 }
 187
 188 /** @brief Background thread for audio playing
 189  *
 190  * This thread plays data as long as there is something to play.  So the
 191  * buffers will drain to empty before deactivation completes.
 192  */
 193 static void *uaudio_play_thread_fn(void attribute((unused)) *arg) {
 194   int resync = 1;
 195   unsigned last_flags = 0;
 196   unsigned char zero[uaudio_thread_max * uaudio_sample_size];
 197   memset(zero, 0, sizeof zero);
 198
 199   while(uaudio_thread_started) {
 200     // If we're paused then just play silence
 201     if(!uaudio_thread_activated) {
 202       pthread_mutex_unlock(&uaudio_thread_lock);
 203       unsigned flags = UAUDIO_PAUSED;
 204       if(last_flags & UAUDIO_PLAYING)
 205         flags |= UAUDIO_PAUSE;
 206       uaudio_play_samples(zero, uaudio_thread_max, last_flags = flags);
 207       /* We expect the play callback to block for a reasonable period */
 208       pthread_mutex_lock(&uaudio_thread_lock);
 209       continue;
 210     }
 211     const int used = uaudio_buffers_used();
 212     int go;
 213
 214     if(resync)
 215       go = (used == UAUDIO_THREAD_BUFFERS - 1);
 216     else
 217       go = (used > 0);
 218     if(go) {
 219       /* At least one buffer is filled.  We release the lock while playing so
 220        * that more collection can go on. */
 221       struct uaudio_buffer *const b = &uaudio_buffers[uaudio_play_buffer];
 222       pthread_mutex_unlock(&uaudio_thread_lock);
 223       //fprintf(stderr, "P%d.", uaudio_play_buffer);
 224       size_t played = 0;
 225       while(played < b->nsamples) {
 226         unsigned flags = UAUDIO_PLAYING;
 227         if(last_flags & UAUDIO_PAUSED)
 228           flags |= UAUDIO_RESUME;
 229         played += uaudio_play_samples((char *)b->samples
 230                                       + played * uaudio_sample_size,
 231                                       b->nsamples - played,
 232                                       last_flags = flags);
 233       }
 234       pthread_mutex_lock(&uaudio_thread_lock);
 235       /* Move to next buffer */
 236       uaudio_play_buffer = (1 + uaudio_play_buffer) % UAUDIO_THREAD_BUFFERS;
 237       /* Awaken collector */
 238       pthread_cond_broadcast(&uaudio_thread_cond);
 239       resync = 0;
 240     } else {
 241       /* Insufficient data to play, wait for collector */
 242       pthread_cond_wait(&uaudio_thread_cond, &uaudio_thread_lock);
 243       /* (Still) re-synchronizing */
 244       resync = 1;
 245     }
 246   }
 247   pthread_mutex_unlock(&uaudio_thread_lock);
 248   return NULL;
 249 }
 250
 251 /** @brief Create background threads for audio processing
 252  * @param callback Callback to collect audio data
 253  * @param userdata Passed to @p callback
 254  * @param playcallback Callback to play audio data
 255  * @param min Minimum number of samples to play in a chunk
 256  * @param max Maximum number of samples to play in a chunk
 257  * @param flags Flags (not currently used)
 258  *
 259  * @p callback will be called multiple times in quick succession if necessary
 260  * to gather at least @p min samples.  Equally @p playcallback may be called
 261  * repeatedly in quick succession to play however much was received in a single
 262  * chunk.
 263  */
 264 void uaudio_thread_start(uaudio_callback *callback,
 265                          void *userdata,
 266                          uaudio_playcallback *playcallback,
 267                          size_t min,
 268                          size_t max,
 269                          unsigned flags) {
 270   int e;
 271   uaudio_thread_collect_callback = callback;
 272   uaudio_thread_userdata = userdata;
 273   uaudio_thread_play_callback = playcallback;
 274   uaudio_thread_min = min;
 275   uaudio_thread_max = max;
 276   uaudio_thread_flags = flags;
 277   uaudio_thread_started = 1;
 278   uaudio_thread_activated = 0;
 279   for(int n = 0; n < UAUDIO_THREAD_BUFFERS; ++n)
 280     uaudio_buffers[n].samples = xcalloc_noptr(uaudio_thread_max,
 281                                               uaudio_sample_size);
 282   uaudio_collect_buffer = uaudio_play_buffer = 0;
 283   if((e = pthread_create(&uaudio_collect_thread,
 284                          NULL,
 285                          uaudio_collect_thread_fn,
 286                          NULL)))
 287     disorder_fatal(e, "pthread_create");
 288   if((e = pthread_create(&uaudio_play_thread,
 289                          NULL,
 290                          uaudio_play_thread_fn,
 291                          NULL)))
 292     disorder_fatal(e, "pthread_create");
 293 }
 294
 295 /** @brief Shut down background threads for audio processing */
 296 void uaudio_thread_stop(void) {
 297   void *result;
 298
 299   pthread_mutex_lock(&uaudio_thread_lock);
 300   uaudio_thread_activated = 0;
 301   uaudio_thread_started = 0;
 302   pthread_cond_broadcast(&uaudio_thread_cond);
 303   pthread_mutex_unlock(&uaudio_thread_lock);
 304   pthread_join(uaudio_collect_thread, &result);
 305   pthread_join(uaudio_play_thread, &result);
 306   for(int n = 0; n < UAUDIO_THREAD_BUFFERS; ++n)
 307     xfree(uaudio_buffers[n].samples);
 308 }
 309
 310 /** @brief Activate audio output */
 311 void uaudio_thread_activate(void) {
 312   pthread_mutex_lock(&uaudio_thread_lock);
 313   uaudio_thread_activated = 1;
 314   pthread_cond_broadcast(&uaudio_thread_cond);
 315   pthread_mutex_unlock(&uaudio_thread_lock);
 316 }
 317
 318 /** @brief Deactivate audio output */
 319 void uaudio_thread_deactivate(void) {
 320   pthread_mutex_lock(&uaudio_thread_lock);
 321   uaudio_thread_activated = 0;
 322   pthread_cond_broadcast(&uaudio_thread_cond);
 323   pthread_mutex_unlock(&uaudio_thread_lock);
 324 }
 325
 326 /*
 327 Local Variables:
 328 c-basic-offset:2
 329 comment-column:40
 330 fill-column:79
 331 indent-tabs-mode:nil
 332 End:
 333 */