vorbis-tools-1.2.0/ogg123/buffer.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
   5  * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
   6  * PLEASE READ THESE TERMS BEFORE DISTRIBUTING.                     *
   7  *                                                                  *
   8  * THE Ogg123 SOURCE CODE IS (C) COPYRIGHT 2000-2001                *
   9  * by Stan Seibert <volsung@xiph.org> AND OTHER CONTRIBUTORS        *
  10  * http://www.xiph.org/                                             *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  last mod: $Id: buffer.c,v 1.22 2003/09/01 20:15:19 volsung Exp $
  15
  16  ********************************************************************/
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include <sys/types.h>
  23 #include <sys/wait.h>
  24 #include <sys/time.h>
  25 #include <string.h>
  26 #include <fcntl.h>
  27 #include <signal.h>
  28 #include <unistd.h>
  29 #include <stdio.h>
  30
  31 #include "compat.h"
  32 #include "buffer.h"
  33 #include "i18n.h"
  34 #include "ogg123.h"
  35
  36 #define MIN(x,y)       ( (x) < (y) ? (x) : (y) )
  37 #define MIN3(x,y,z)    MIN(x,MIN(y,z))
  38 #define MIN4(w,x,y,z)  MIN( MIN(w,x), MIN(y,z) )
  39
  40 #ifdef DEBUG_BUFFER
  41 FILE *debugfile;
  42 #define DEBUG(x) { fprintf (debugfile, "%d: " x "\n", getpid()); }
  43 #define DEBUG1(x, y) { fprintf (debugfile, "%d: " x "\n", getpid(), y); }
  44 #define DEBUG2(x, y, z) { fprintf (debugfile, "%d: " x "\n", getpid(), y, z); }
  45 #else
  46 #define DEBUG(x)
  47 #define DEBUG1(x, y)
  48 #define DEBUG2(x, y, z)
  49 #endif
  50
  51 /* Macros that support debugging of threading structures */
  52
  53 #define LOCK_MUTEX(mutex) { DEBUG1("Locking mutex %s.", #mutex); pthread_mutex_lock (&(mutex)); }
  54 #define UNLOCK_MUTEX(mutex) { DEBUG1("Unlocking mutex %s", #mutex); pthread_mutex_unlock(&(mutex)); }
  55 #define COND_WAIT(cond, mutex) { DEBUG2("Unlocking %s and waiting on %s", #mutex, #cond); pthread_cond_wait(&(cond), &(mutex)); }
  56 #define COND_SIGNAL(cond) { DEBUG1("Signalling %s", #cond); pthread_cond_signal(&(cond)); }
  57
  58 extern signal_request_t sig_request;  /* Need access to global cancel flag */
  59
  60
  61 /* -------------------- Private Functions ------------------ */
  62
  63 void buffer_init_vars (buf_t *buf)
  64 {
  65   /* Initialize buffer flags */
  66   buf->prebuffering = buf->prebuffer_size > 0;
  67   buf->paused = 0;
  68   buf->eos = 0;
  69   buf->abort_write = 0;
  70   buf->cancel_flag = 0;
  71
  72   buf->curfill = 0;
  73   buf->start = 0;
  74   buf->position = 0;
  75   buf->position_end = 0;
  76 }
  77
  78 void buffer_thread_init (buf_t *buf)
  79 {
  80   sigset_t set;
  81
  82   DEBUG("Enter buffer_thread_init");
  83
  84   /* Block signals to this thread */
  85   sigfillset(&set);
  86   sigaddset(&set, SIGINT);
  87   sigaddset(&set, SIGTSTP);
  88   sigaddset(&set, SIGCONT);
  89   if (pthread_sigmask(SIG_BLOCK, &set, NULL) != 0)
  90     DEBUG("pthread_sigmask failed");
  91 }
  92
  93
  94 void buffer_thread_cleanup (void *arg)
  95 {
  96   buf_t *buf = (buf_t *)arg;
  97
  98   DEBUG("Enter buffer_thread_cleanup");
  99 }
 100
 101
 102 void buffer_mutex_unlock (void *arg)
 103 {
 104   buf_t *buf = (buf_t *)arg;
 105
 106   UNLOCK_MUTEX(buf->mutex);
 107 }
 108
 109
 110 action_t *malloc_action (action_func_t action_func, void *action_arg)
 111 {
 112   action_t *action;
 113
 114   action = malloc(sizeof(action_t));
 115
 116   if (action == NULL) {
 117     fprintf(stderr, _("Error: Out of memory in malloc_action().\n"));
 118     exit(1);
 119   }
 120
 121   action->position = 0;
 122   action->action_func = action_func;
 123   action->arg = action_arg;
 124   action->next = NULL;
 125
 126   return action;
 127 }
 128
 129
 130 /* insert = 1:  Make this action the first action associated with this position
 131    insert = 0:  Make this action the last action associated with this position
 132 */
 133 #define INSERT 1
 134 #define APPEND 0
 135 void in_order_add_action (action_t **action_list, action_t *action, int insert)
 136 {
 137   insert = insert > 0 ? 1 : 0;  /* Clamp in case caller messed up */
 138
 139   while (*action_list != NULL &&
 140          (*action_list)->position <= (action->position + insert))
 141     action_list = &((*action_list)->next);
 142
 143   action->next = *action_list;
 144   *action_list = action;
 145 }
 146
 147
 148 void execute_actions (buf_t *buf, action_t **action_list, ogg_int64_t position)
 149 {
 150   action_t *action;
 151
 152   while (*action_list != NULL && (*action_list)->position <= position) {
 153     action = *action_list;
 154     action->action_func(buf, action->arg);
 155
 156     *action_list = (*action_list)->next;
 157     free(action);
 158   }
 159 }
 160
 161
 162 void free_action (action_t *action)
 163 {
 164   free(action);
 165 }
 166
 167
 168
 169 int compute_dequeue_size (buf_t *buf, int request_size)
 170 {
 171   ogg_int64_t next_action_pos;
 172
 173   /*
 174      For simplicity, the number of bytes played must satisfy the following
 175      requirements:
 176      1. Do not extract more bytes than are stored in the buffer.
 177      2. Do not extract more bytes than the requested number of bytes.
 178      3. Do not run off the end of the buffer.
 179      4. Do not go past the next action.
 180   */
 181
 182   if (buf->actions != NULL) {
 183
 184     next_action_pos = buf->actions->position;
 185
 186     return MIN4((ogg_int64_t)buf->curfill, (ogg_int64_t)request_size,
 187                (ogg_int64_t)(buf->size - buf->start),
 188                next_action_pos - buf->position);
 189   } else
 190     return MIN3(buf->curfill, (long)request_size, buf->size - buf->start);
 191
 192 }
 193
 194
 195 void *buffer_thread_func (void *arg)
 196 {
 197   buf_t *buf = (buf_t*) arg;
 198   size_t write_amount;
 199
 200   DEBUG("Enter buffer_thread_func");
 201
 202   buffer_thread_init(buf);
 203
 204   pthread_cleanup_push(buffer_thread_cleanup, buf);
 205
 206   DEBUG("Start main play loop");
 207
 208   /* This test is safe since curfill will never decrease and eos will
 209      never be unset. */
 210   while ( !(buf->eos && buf->curfill == 0)) {
 211
 212     if (buf->cancel_flag || sig_request.cancel)
 213       break;
 214
 215     DEBUG("Check for something to play");
 216     /* Block until we can play something */
 217     LOCK_MUTEX (buf->mutex);
 218     if (buf->prebuffering ||
 219         buf->paused ||
 220         (buf->curfill < buf->audio_chunk_size && !buf->eos)) {
 221
 222       DEBUG("Waiting for more data to play.");
 223       COND_WAIT(buf->playback_cond, buf->mutex);
 224     }
 225
 226     DEBUG("Ready to play");
 227
 228     UNLOCK_MUTEX(buf->mutex);
 229
 230     if (buf->cancel_flag || sig_request.cancel)
 231       break;
 232
 233     /* Don't need to lock buffer while running actions since position
 234        won't change.  We clear out any actions before we compute the
 235        dequeue size so we don't consider actions that need to
 236        run right now.  */
 237     execute_actions(buf, &buf->actions, buf->position);
 238
 239     LOCK_MUTEX(buf->mutex);
 240
 241     /* Need to be locked while we check things. */
 242     write_amount = compute_dequeue_size(buf, buf->audio_chunk_size);
 243
 244     UNLOCK_MUTEX(buf->mutex);
 245
 246     /* No need to lock mutex here because the other thread will
 247        NEVER reduce the number of bytes stored in the buffer */
 248     DEBUG1("Sending %d bytes to the audio device", write_amount);
 249     write_amount = buf->write_func(buf->buffer + buf->start, write_amount,
 250                     /* Only set EOS if this is the last chunk */
 251                     write_amount == buf->curfill ? buf->eos : 0,
 252                     buf->write_arg);
 253
 254     LOCK_MUTEX(buf->mutex);
 255
 256     buf->curfill -= write_amount;
 257     buf->position += write_amount;
 258     buf->start = (buf->start + write_amount) % buf->size;
 259     DEBUG1("Updated buffer fill, curfill = %ld", buf->curfill);
 260
 261     /* If we've essentially emptied the buffer and prebuffering is enabled,
 262        we need to do another prebuffering session */
 263     if (!buf->eos && (buf->curfill < buf->audio_chunk_size))
 264       buf->prebuffering = buf->prebuffer_size > 0;
 265
 266     /* Signal a waiting decoder thread that they can put more audio into the
 267        buffer */
 268     DEBUG("Signal decoder thread that buffer space is available");
 269     COND_SIGNAL(buf->write_cond);
 270
 271     UNLOCK_MUTEX(buf->mutex);
 272   }
 273
 274   pthread_cleanup_pop(1);
 275   DEBUG("exiting buffer_thread_func");
 276
 277   return 0;
 278 }
 279
 280
 281 void submit_data_chunk (buf_t *buf, char *data, size_t size)
 282 {
 283   long   buf_write_pos; /* offset of first available write location */
 284   size_t write_size;
 285
 286   DEBUG1("Enter submit_data_chunk, size %d", size);
 287
 288   pthread_cleanup_push(buffer_mutex_unlock, buf);
 289
 290   /* Put the data into the buffer as space is made available */
 291   while (size > 0 && !buf->abort_write) {
 292
 293     /* Section 1: Write a chunk of data */
 294     DEBUG("Obtaining lock on buffer");
 295     LOCK_MUTEX(buf->mutex);
 296     if (buf->size - buf->curfill > 0) {
 297
 298       /* Figure how much we can write into the buffer.  Requirements:
 299          1. Don't write more data than we have.
 300          2. Don't write more data than we have room for.
 301          3. Don't write past the end of the buffer. */
 302       buf_write_pos = (buf->start + buf->curfill) % buf->size;
 303       write_size = MIN3(size, buf->size - buf->curfill,
 304                         buf->size - buf_write_pos);
 305
 306       memcpy(buf->buffer + buf_write_pos, data, write_size);
 307       buf->curfill += write_size;
 308       data += write_size;
 309       size -= write_size;
 310       buf->position_end += write_size;
 311       DEBUG1("writing chunk into buffer, curfill = %ld", buf->curfill);
 312     }
 313     else {
 314
 315       if (buf->cancel_flag || sig_request.cancel) {
 316         UNLOCK_MUTEX(buf->mutex);
 317         break;
 318       }
 319       /* No room for more data, wait until there is */
 320       DEBUG("No room for data in buffer.  Waiting.");
 321       COND_WAIT(buf->write_cond, buf->mutex);
 322     }
 323     /* Section 2: signal if we are not prebuffering, done
 324        prebuffering, or paused */
 325     if (buf->prebuffering && (buf->prebuffer_size <= buf->curfill)) {
 326
 327       DEBUG("prebuffering done")
 328         buf->prebuffering = 0; /* done prebuffering */
 329     }
 330
 331     if (!buf->prebuffering && !buf->paused) {
 332
 333       DEBUG("Signalling playback thread that more data is available.");
 334       COND_SIGNAL(buf->playback_cond);
 335     } else
 336       DEBUG("Not signalling playback thread since prebuffering or paused.");
 337
 338     UNLOCK_MUTEX(buf->mutex);
 339   }
 340
 341   pthread_cleanup_pop(0);
 342
 343   DEBUG("Exit submit_data_chunk");
 344 }
 345
 346
 347 buffer_stats_t *malloc_buffer_stats ()
 348 {
 349   buffer_stats_t *new_stats;
 350
 351   new_stats = malloc(sizeof(buffer_stats_t));
 352
 353   if (new_stats == NULL) {
 354     fprintf(stderr, _("Error: Could not allocate memory in malloc_buffer_stats()\n"));
 355     exit(1);
 356   }
 357
 358   return new_stats;
 359 }
 360
 361
 362 /* ------------------ Begin public interface ------------------ */
 363
 364 /* --- Buffer allocation --- */
 365
 366 buf_t *buffer_create (long size, long prebuffer,
 367                       buffer_write_func_t write_func, void *arg,
 368                       int audio_chunk_size)
 369 {
 370   buf_t *buf = malloc (sizeof(buf_t) + sizeof (char) * (size - 1));
 371
 372   if (buf == NULL) {
 373       perror ("malloc");
 374       exit(1);
 375   }
 376
 377 #ifdef DEBUG_BUFFER
 378   debugfile = fopen ("/tmp/bufferdebug", "w");
 379   setvbuf (debugfile, NULL, _IONBF, 0);
 380 #endif
 381
 382   /* Initialize the buffer structure. */
 383   DEBUG1("buffer_create, size = %ld", size);
 384
 385   memset (buf, 0, sizeof(*buf));
 386
 387   buf->write_func = write_func;
 388   buf->write_arg = arg;
 389
 390   /* Setup pthread variables */
 391   pthread_mutex_init(&buf->mutex, NULL);
 392   pthread_cond_init(&buf->write_cond, NULL);
 393   pthread_cond_init(&buf->playback_cond, NULL);
 394
 395   /* Correct for impossible prebuffer and chunk sizes */
 396   if (audio_chunk_size > size || audio_chunk_size == 0)
 397     audio_chunk_size = size / 2;
 398
 399   if (prebuffer > size)
 400     prebuffer = prebuffer / 2;
 401
 402   buf->audio_chunk_size = audio_chunk_size;
 403
 404   buf->prebuffer_size = prebuffer;
 405   buf->size = size;
 406
 407   buf->actions = 0;
 408
 409   /* Initialize flags */
 410   buffer_init_vars(buf);
 411
 412   return buf;
 413 }
 414
 415
 416 void buffer_reset (buf_t *buf)
 417 {
 418   action_t *action;
 419
 420   /* Cleanup pthread variables */
 421   pthread_mutex_destroy(&buf->mutex);
 422   pthread_cond_destroy(&buf->write_cond);
 423   pthread_cond_destroy(&buf->playback_cond);
 424
 425   /* Reinit pthread variables */
 426   pthread_mutex_init(&buf->mutex, NULL);
 427   pthread_cond_init(&buf->write_cond, NULL);
 428   pthread_cond_init(&buf->playback_cond, NULL);
 429
 430   /* Clear old actions */
 431   while (buf->actions != NULL) {
 432     action = buf->actions;
 433     buf->actions = buf->actions->next;
 434     free(action);
 435   }
 436
 437   buffer_init_vars(buf);
 438 }
 439
 440
 441 void buffer_destroy (buf_t *buf)
 442 {
 443   DEBUG("buffer_destroy");
 444
 445   /* Cleanup pthread variables */
 446   pthread_mutex_destroy(&buf->mutex);
 447   COND_SIGNAL(buf->write_cond);
 448   pthread_cond_destroy(&buf->write_cond);
 449   COND_SIGNAL(buf->playback_cond);
 450   pthread_cond_destroy(&buf->playback_cond);
 451
 452   free(buf);
 453 }
 454
 455
 456 /* --- Buffer thread control --- */
 457
 458 int buffer_thread_start (buf_t *buf)
 459 {
 460   DEBUG("Starting new thread.");
 461
 462   return pthread_create(&buf->thread, NULL, buffer_thread_func, buf);
 463 }
 464
 465
 466 /* WARNING: DO NOT call buffer_submit_data after you pause the
 467    playback thread, or you run the risk of deadlocking.  Call
 468    buffer_thread_unpause first. */
 469 void buffer_thread_pause (buf_t *buf)
 470 {
 471   DEBUG("Pausing playback thread");
 472
 473   pthread_cleanup_push(buffer_mutex_unlock, buf);
 474
 475   LOCK_MUTEX(buf->mutex);
 476   buf->paused = 1;
 477   UNLOCK_MUTEX(buf->mutex);
 478
 479   pthread_cleanup_pop(0);
 480 }
 481
 482
 483 void buffer_thread_unpause (buf_t *buf)
 484 {
 485   DEBUG("Unpausing playback thread");
 486
 487   pthread_cleanup_push(buffer_mutex_unlock, buf);
 488
 489   LOCK_MUTEX(buf->mutex);
 490   buf->paused = 0;
 491   COND_SIGNAL(buf->playback_cond);
 492   UNLOCK_MUTEX(buf->mutex);
 493
 494   pthread_cleanup_pop(0);
 495 }
 496
 497
 498 void buffer_thread_kill (buf_t *buf)
 499 {
 500   DEBUG("Attempting to kill playback thread.");
 501
 502   /* Flag the cancellation */
 503   buf->cancel_flag = 1;
 504
 505   /* Signal the playback condition to wake stuff up */
 506   COND_SIGNAL(buf->playback_cond);
 507
 508   pthread_join(buf->thread, NULL);
 509
 510   buffer_thread_cleanup(buf);
 511
 512   DEBUG("Playback thread killed.");
 513 }
 514
 515
 516 /* --- Data buffering functions --- */
 517
 518 void buffer_submit_data (buf_t *buf, char *data, long nbytes) {
 519   submit_data_chunk (buf, data, nbytes);
 520 }
 521
 522 size_t buffer_get_data (buf_t *buf, char *data, long nbytes)
 523 {
 524   int write_amount;
 525   int orig_size;
 526
 527   orig_size = nbytes;
 528
 529   DEBUG("Enter buffer_get_data");
 530
 531   pthread_cleanup_push(buffer_mutex_unlock, buf);
 532
 533   LOCK_MUTEX(buf->mutex);
 534
 535   /* Put the data into the buffer as space is made available */
 536   while (nbytes > 0) {
 537
 538     if (buf->abort_write)
 539       break;
 540
 541     DEBUG("Obtaining lock on buffer");
 542     /* Block until we can read something */
 543     if (buf->curfill == 0 && buf->eos)
 544       break; /* No more data to read */
 545
 546     if (buf->curfill == 0 || (buf->prebuffering && !buf->eos)) {
 547       DEBUG("Waiting for more data to copy.");
 548       COND_WAIT(buf->playback_cond, buf->mutex);
 549     }
 550
 551     if (buf->abort_write)
 552       break;
 553
 554     /* Note: Even if curfill is still 0, nothing bad will happen here */
 555
 556     /* For simplicity, the number of bytes played must satisfy
 557        the following three requirements:
 558
 559        1. Do not copy more bytes than are stored in the buffer.
 560        2. Do not copy more bytes than the reqested data size.
 561        3. Do not run off the end of the buffer. */
 562     write_amount = compute_dequeue_size(buf, nbytes);
 563
 564     UNLOCK_MUTEX(buf->mutex);
 565     execute_actions(buf, &buf->actions, buf->position);
 566
 567     /* No need to lock mutex here because the other thread will
 568        NEVER reduce the number of bytes stored in the buffer */
 569     DEBUG1("Copying %d bytes from the buffer", write_amount);
 570     memcpy(data, buf->buffer + buf->start, write_amount);
 571     LOCK_MUTEX(buf->mutex);
 572
 573     buf->curfill -= write_amount;
 574     data += write_amount;
 575     nbytes -= write_amount;
 576     buf->start = (buf->start + write_amount) % buf->size;
 577     DEBUG1("Updated buffer fill, curfill = %ld", buf->curfill);
 578
 579     /* Signal a waiting decoder thread that they can put more
 580        audio into the buffer */
 581     DEBUG("Signal decoder thread that buffer space is available");
 582     COND_SIGNAL(buf->write_cond);
 583   }
 584
 585   UNLOCK_MUTEX(buf->mutex);
 586
 587   pthread_cleanup_pop(0);
 588
 589   pthread_testcancel();
 590
 591   DEBUG("Exit buffer_get_data");
 592
 593   return orig_size - nbytes;
 594 }
 595
 596 void buffer_mark_eos (buf_t *buf)
 597 {
 598   DEBUG("buffer_mark_eos");
 599
 600   pthread_cleanup_push(buffer_mutex_unlock, buf);
 601
 602   LOCK_MUTEX(buf->mutex);
 603   buf->eos = 1;
 604   buf->prebuffering = 0;
 605   COND_SIGNAL(buf->playback_cond);
 606   UNLOCK_MUTEX(buf->mutex);
 607
 608   pthread_cleanup_pop(0);
 609 }
 610
 611 void buffer_abort_write (buf_t *buf)
 612 {
 613   DEBUG("buffer_abort_write");
 614
 615   pthread_cleanup_push(buffer_mutex_unlock, buf);
 616
 617   LOCK_MUTEX(buf->mutex);
 618   buf->abort_write = 1;
 619   COND_SIGNAL(buf->write_cond);
 620   COND_SIGNAL(buf->playback_cond);
 621   UNLOCK_MUTEX(buf->mutex);
 622
 623   pthread_cleanup_pop(0);
 624 }
 625
 626
 627 /* --- Action buffering functions --- */
 628
 629 void buffer_action_now (buf_t *buf, action_func_t action_func,
 630                         void *action_arg)
 631 {
 632   action_t *action;
 633
 634   action = malloc_action(action_func, action_arg);
 635
 636   pthread_cleanup_push(buffer_mutex_unlock, buf);
 637
 638   LOCK_MUTEX(buf->mutex);
 639
 640   action->position = buf->position;
 641
 642   /* Insert this action right at the front */
 643   action->next = buf->actions;
 644   buf->actions = action;
 645
 646   UNLOCK_MUTEX(buf->mutex);
 647
 648   pthread_cleanup_pop(0);
 649 }
 650
 651
 652 void buffer_insert_action_at_end (buf_t *buf, action_func_t action_func,
 653                                   void *action_arg)
 654 {
 655   action_t *action;
 656
 657   action = malloc_action(action_func, action_arg);
 658
 659   pthread_cleanup_push(buffer_mutex_unlock, buf);
 660
 661   LOCK_MUTEX(buf->mutex);
 662
 663   /* Stick after the last item in the buffer */
 664   action->position = buf->position_end;
 665
 666   in_order_add_action(&buf->actions, action, INSERT);
 667
 668   UNLOCK_MUTEX(buf->mutex);
 669
 670   pthread_cleanup_pop(0);
 671 }
 672
 673
 674 void buffer_append_action_at_end (buf_t *buf, action_func_t action_func,
 675                                   void *action_arg)
 676 {
 677   action_t *action;
 678
 679   action = malloc_action(action_func, action_arg);
 680
 681   pthread_cleanup_push(buffer_mutex_unlock, buf);
 682
 683   LOCK_MUTEX(buf->mutex);
 684
 685   /* Stick after the last item in the buffer */
 686   action->position = buf->position_end;
 687
 688   in_order_add_action(&buf->actions, action, APPEND);
 689
 690   UNLOCK_MUTEX(buf->mutex);
 691
 692   pthread_cleanup_pop(0);
 693 }
 694
 695
 696 void buffer_insert_action_at (buf_t *buf, action_func_t action_func,
 697                               void *action_arg, ogg_int64_t position)
 698 {
 699   action_t *action;
 700
 701   action = malloc_action(action_func, action_arg);
 702
 703   pthread_cleanup_push(buffer_mutex_unlock, buf);
 704
 705   LOCK_MUTEX(buf->mutex);
 706
 707   action->position = position;
 708
 709   in_order_add_action(&buf->actions, action, INSERT);
 710
 711   UNLOCK_MUTEX(buf->mutex);
 712
 713   pthread_cleanup_pop(0);
 714 }
 715
 716
 717 void buffer_append_action_at (buf_t *buf, action_func_t action_func,
 718                               void *action_arg, ogg_int64_t position)
 719 {
 720   action_t *action;
 721
 722   action = malloc_action(action_func, action_arg);
 723
 724   pthread_cleanup_push(buffer_mutex_unlock, buf);
 725
 726   LOCK_MUTEX(buf->mutex);
 727
 728   action->position = position;
 729
 730   in_order_add_action(&buf->actions, action, APPEND);
 731
 732   UNLOCK_MUTEX(buf->mutex);
 733
 734   pthread_cleanup_pop(0);
 735 }
 736
 737
 738 /* --- Buffer status functions --- */
 739
 740 void buffer_wait_for_empty (buf_t *buf)
 741 {
 742   int empty = 0;
 743
 744   DEBUG("Enter buffer_wait_for_empty");
 745
 746   pthread_cleanup_push(buffer_mutex_unlock, buf);
 747
 748   LOCK_MUTEX(buf->mutex);
 749   while (!empty) {
 750
 751     if (buf->curfill > 0) {
 752       DEBUG1("Buffer curfill = %ld, going back to sleep.", buf->curfill);
 753       COND_WAIT(buf->write_cond, buf->mutex);
 754     } else
 755       empty = 1;
 756   }
 757   UNLOCK_MUTEX(buf->mutex);
 758
 759   pthread_cleanup_pop(0);
 760
 761   DEBUG("Exit buffer_wait_for_empty");
 762 }
 763
 764
 765 long buffer_full (buf_t *buf)
 766 {
 767   return buf->curfill;
 768 }
 769
 770
 771 buffer_stats_t *buffer_statistics (buf_t *buf)
 772 {
 773   buffer_stats_t *stats;
 774
 775   pthread_cleanup_push(buffer_mutex_unlock, buf);
 776
 777   LOCK_MUTEX(buf->mutex);
 778
 779   stats = malloc_buffer_stats();
 780
 781   stats->size = buf->size;
 782   stats->fill = (double) buf->curfill / (double) buf->size * 100.0;
 783   stats->prebuffer_fill = (double) buf->prebuffer_size / (double) buf->size;
 784   stats->prebuffering = buf->prebuffering;
 785   stats->paused = buf->paused;
 786   stats->eos = buf->eos;
 787
 788   UNLOCK_MUTEX(buf->mutex);
 789
 790   pthread_cleanup_pop(0);
 791
 792   return stats;
 793 }