vorbis-tools/ogg123/ogg123.c

   1 /* ogg123.c by Kenneth Arnold <kcarnold-xiph@arnoldnet.net> */
   2 /* Maintained by Stan Seibert <volsung@xiph.org>, Monty <monty@xiph.org> */
   3
   4 /********************************************************************
   5  *                                                                  *
   6  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
   7  * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
   8  * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
   9  * PLEASE READ THESE TERMS BEFORE DISTRIBUTING.                     *
  10  *                                                                  *
  11  * THE Ogg123 SOURCE CODE IS (C) COPYRIGHT 2000-2005                *
  12  * by Stan Seibert <volsung@xiph.org> AND OTHER CONTRIBUTORS        *
  13  * http://www.xiph.org/                                             *
  14  *                                                                  *
  15  ********************************************************************
  16
  17  last mod: $Id$
  18
  19  ********************************************************************/
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <sys/types.h>
  26 #include <string.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <errno.h>
  30 #include <time.h>
  31 #include <getopt.h>
  32 #include <signal.h>
  33 #include <unistd.h>
  34 #include <sys/time.h>
  35 #include <sys/stat.h>
  36 #include <unistd.h>
  37 #include <locale.h>
  38
  39 #include "audio.h"
  40 #include "buffer.h"
  41 #include "callbacks.h"
  42 #include "cfgfile_options.h"
  43 #include "cmdline_options.h"
  44 #include "format.h"
  45 #include "transport.h"
  46 #include "status.h"
  47 #include "playlist.h"
  48 #include "compat.h"
  49 #include "remote.h"
  50
  51 #include "ogg123.h"
  52 #include "i18n.h"
  53
  54 extern int exit_status; /* from status.c */
  55
  56 void play (char *source_string);
  57
  58 #define PRIMAGIC (2*2*2*2*3*3*3*5*7)
  59 /* take buffer out of the data segment, not the stack */
  60 #define AUDIO_CHUNK_SIZE ((16384 + PRIMAGIC - 1)/ PRIMAGIC * PRIMAGIC)
  61 unsigned char convbuffer[AUDIO_CHUNK_SIZE];
  62 int convsize = AUDIO_CHUNK_SIZE;
  63
  64 ogg123_options_t options;
  65 stat_format_t *stat_format;
  66 buf_t *audio_buffer=NULL;
  67
  68 audio_play_arg_t audio_play_arg;
  69
  70
  71 /* ------------------------- config file options -------------------------- */
  72
  73 /* This macro is used to create some dummy variables to hold default values
  74    for the options. */
  75 #define INIT(type, value) type type##_##value = value
  76 INIT(int, 1);
  77 INIT(int, 0);
  78
  79 file_option_t file_opts[] = {
  80   /* found, name, description, type, ptr, default */
  81   {0, "default_device", N_("default output device"), opt_type_string,
  82    &options.default_device, NULL},
  83   {0, "shuffle",        N_("shuffle playlist"),      opt_type_bool,
  84    &options.shuffle,        &int_0},
  85   {0, "repeat",         N_("repeat playlist forever"),   opt_type_bool,
  86    &options.repeat,         &int_0},
  87   {0, NULL,             NULL,                    0,               NULL,                NULL}
  88 };
  89
  90
  91 /* Flags set by the signal handler to control the threads */
  92 signal_request_t sig_request = {0, 0, 0, 0, 0};
  93
  94
  95 /* ------------------------------- signal handler ------------------------- */
  96
  97
  98 void signal_handler (int signo)
  99 {
 100   struct timeval tv;
 101   ogg_int64_t now;
 102   switch (signo) {
 103   case SIGINT:
 104
 105     gettimeofday(&tv, 0);
 106
 107     /* Units of milliseconds (need the cast to force 64 arithmetics) */
 108     now = (ogg_int64_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 109
 110     if ( (now - sig_request.last_ctrl_c) <= options.delay)
 111       sig_request.exit = 1;
 112     else
 113       sig_request.skipfile = 1;
 114
 115     sig_request.cancel = 1;
 116     sig_request.last_ctrl_c = now;
 117     break;
 118
 119   case SIGTERM:
 120     sig_request.exit = 1;
 121     break;
 122
 123   case SIGTSTP:
 124     sig_request.pause = 1;
 125     /* buffer_Pause (Options.outputOpts.buffer);
 126        buffer_WaitForPaused (Options.outputOpts.buffer);
 127        }
 128        if (Options.outputOpts.devicesOpen == 0) {
 129        close_audio_devices (Options.outputOpts.devices);
 130        Options.outputOpts.devicesOpen = 0;
 131        }
 132     */
 133     /* open_audio_devices();
 134        if (Options.outputOpts.buffer) {
 135        buffer_Unpause (Options.outputOpts.buffer);
 136        }
 137     */
 138     break;
 139
 140   case SIGCONT:
 141     break;  /* Don't need to do anything special to resume */
 142   }
 143 }
 144
 145 /* -------------------------- util functions ---------------------------- */
 146
 147 void options_init (ogg123_options_t *opts)
 148 {
 149   opts->verbosity = 2;
 150   opts->shuffle = 0;
 151   opts->delay = 500;
 152   opts->nth = 1;
 153   opts->ntimes = 1;
 154   opts->seekoff = 0.0;
 155   opts->endpos = -1.0; /* Mark as unset */
 156   opts->seekmode = DECODER_SEEK_NONE;
 157   opts->buffer_size = 128 * 1024;
 158   opts->prebuffer = 0.0f;
 159   opts->input_buffer_size = 64 * 1024;
 160   opts->input_prebuffer = 50.0f;
 161   opts->default_device = NULL;
 162
 163   opts->status_freq = 10.0;
 164   opts->playlist = NULL;
 165   opts->remote = 0;
 166   opts->repeat = 0;
 167
 168 }
 169
 170 double strtotime(char *s)
 171 {
 172         double time;
 173
 174         time = strtod(s, &s);
 175
 176         while (*s == ':')
 177                 time = 60 * time + strtod(s + 1, &s);
 178
 179         return time;
 180 }
 181
 182 void set_seek_opt(ogg123_options_t *ogg123_opts, char *buf) {
 183
 184   char *b = buf;
 185
 186   /* skip spaces */
 187   while (*b && (*b == ' ')) b++;
 188
 189   if (*b == '-') {
 190   /* relative seek back */
 191     ogg123_opts->seekoff = -1 * strtotime(b+1);
 192     ogg123_opts->seekmode = DECODER_SEEK_CUR;
 193   } else
 194   if (*b == '+') {
 195   /* relative seek forward */
 196     ogg123_opts->seekoff = strtotime(b+1);
 197     ogg123_opts->seekmode = DECODER_SEEK_CUR;
 198   } else {
 199   /* absolute seek */
 200     ogg123_opts->seekoff = strtotime(b);
 201     ogg123_opts->seekmode = DECODER_SEEK_START;
 202   }
 203 }
 204
 205 int handle_seek_opt(ogg123_options_t *options, decoder_t *decoder, format_t *format) {
 206
 207   float pos=decoder->format->statistics(decoder)->current_time;
 208
 209   /* this functions handles a seek request. It prevents seeking out
 210      of band, i.e. before the beginning or after the end. Instead,
 211          it seeks to the start or near-end resp. */
 212
 213   if (options->seekmode != DECODER_SEEK_NONE) {
 214
 215     if (options->seekmode == DECODER_SEEK_START) {
 216       pos = options->seekoff;
 217     } else {
 218       pos += options->seekoff;
 219     }
 220
 221     if (pos < 0) {
 222       pos = 0;
 223     }
 224
 225     if (pos > decoder->format->statistics(decoder)->total_time) {
 226       /* seek to almost the end of the stream */
 227       pos = decoder->format->statistics(decoder)->total_time - 0.01;
 228     }
 229
 230     if (!format->seek(decoder, pos, DECODER_SEEK_START)) {
 231       status_error(_("Could not skip to %f in audio stream."), options->seekoff);
 232 #if 0
 233       /* Handle this fatally -- kill the audio thread */
 234       if (audio_buffer != NULL)
 235         buffer_thread_kill(audio_buffer);
 236 #endif
 237     }
 238   }
 239
 240   options->seekmode = DECODER_SEEK_NONE;
 241
 242   return 1;
 243 }
 244
 245 /* This function selects which statistics to display for our
 246    particular configuration.  This does not have anything to do with
 247    verbosity, but rather with which stats make sense to display. */
 248 void select_stats (stat_format_t *stats, ogg123_options_t *opts,
 249                    data_source_t *source, decoder_t *decoder,
 250                    buf_t *audio_buffer)
 251 {
 252   data_source_stats_t *data_source_stats;
 253
 254   if (audio_buffer != NULL) {
 255     /* Turn on output buffer stats */
 256     stats[8].enabled = 1; /* Fill */
 257     stats[9].enabled = 1; /* State */
 258   } else {
 259     stats[8].enabled = 0;
 260     stats[9].enabled = 0;
 261   }
 262
 263   data_source_stats = source->transport->statistics(source);
 264   if (data_source_stats->input_buffer_used) {
 265     /* Turn on input buffer stats */
 266     stats[6].enabled = 1; /* Fill */
 267     stats[7].enabled = 1; /* State */
 268   } else {
 269     stats[6].enabled = 0;
 270     stats[7].enabled = 0;
 271   }
 272   free(data_source_stats);
 273
 274   /* Assume we need total time display, and let display_statistics()
 275      determine at what point it should be turned off during playback */
 276   stats[2].enabled = 1;  /* Remaining playback time */
 277   stats[3].enabled = 1;  /* Total playback time */
 278 }
 279
 280
 281 /* Handles printing statistics depending upon whether or not we have
 282    buffering going on */
 283 void display_statistics (stat_format_t *stat_format,
 284                          buf_t *audio_buffer,
 285                          data_source_t *source,
 286                          decoder_t *decoder)
 287 {
 288   print_statistics_arg_t *pstats_arg;
 289   buffer_stats_t *buffer_stats;
 290
 291   pstats_arg = new_print_statistics_arg(stat_format,
 292                                         source->transport->statistics(source),
 293                                         decoder->format->statistics(decoder));
 294
 295   if (options.remote) {
 296
 297     /* Display statistics via the remote interface */
 298     remote_time(pstats_arg->decoder_statistics->current_time,
 299                 pstats_arg->decoder_statistics->total_time);
 300
 301   } else {
 302
 303         /* Disable/Enable statistics as needed */
 304
 305         if (pstats_arg->decoder_statistics->total_time <
 306         pstats_arg->decoder_statistics->current_time) {
 307       stat_format[2].enabled = 0;  /* Remaining playback time */
 308       stat_format[3].enabled = 0;  /* Total playback time */
 309         }
 310
 311         if (pstats_arg->data_source_statistics->input_buffer_used) {
 312       stat_format[6].enabled = 1;  /* Input buffer fill % */
 313       stat_format[7].enabled = 1;  /* Input buffer state  */
 314         }
 315
 316         if (audio_buffer) {
 317       /* Place a status update into the buffer */
 318       buffer_append_action_at_end(audio_buffer,
 319                                   &print_statistics_action,
 320                                   pstats_arg);
 321
 322       /* And if we are not playing right now, do an immediate
 323          update just the output buffer */
 324       buffer_stats = buffer_statistics(audio_buffer);
 325       if (buffer_stats->paused || buffer_stats->prebuffering) {
 326         pstats_arg = new_print_statistics_arg(stat_format,
 327                                               NULL,
 328                                               NULL);
 329         print_statistics_action(audio_buffer, pstats_arg);
 330       }
 331       free(buffer_stats);
 332
 333         } else
 334       print_statistics_action(NULL, pstats_arg);
 335   }
 336 }
 337
 338
 339 void display_statistics_quick (stat_format_t *stat_format,
 340                                buf_t *audio_buffer,
 341                                data_source_t *source,
 342                                decoder_t *decoder)
 343 {
 344   print_statistics_arg_t *pstats_arg;
 345
 346   pstats_arg = new_print_statistics_arg(stat_format,
 347                                         source->transport->statistics(source),
 348                                         decoder->format->statistics(decoder));
 349
 350   if (audio_buffer) {
 351     print_statistics_action(audio_buffer, pstats_arg);
 352   } else
 353     print_statistics_action(NULL, pstats_arg);
 354 }
 355
 356 double current_time (decoder_t *decoder)
 357 {
 358   decoder_stats_t *stats;
 359   double ret;
 360
 361   stats = decoder->format->statistics(decoder);
 362   ret = stats->current_time;
 363
 364   free(stats);
 365
 366   return ret;
 367 }
 368
 369 void print_audio_devices_info(audio_device_t *d)
 370 {
 371   ao_info *info;
 372
 373   while (d != NULL) {
 374     info = ao_driver_info(d->driver_id);
 375
 376     status_message(2, _("\nAudio Device:   %s"), info->name);
 377     status_message(3, _("Author:   %s"), info->author);
 378     status_message(3, _("Comments: %s"), info->comment);
 379     status_message(2, "");
 380
 381     d = d->next_device;
 382   }
 383
 384 }
 385
 386
 387 /* --------------------------- main code -------------------------------- */
 388
 389
 390
 391 int main(int argc, char **argv)
 392 {
 393   int optind;
 394   char **playlist_array;
 395   int items;
 396   struct stat stat_buf;
 397   int i;
 398
 399   setlocale(LC_ALL, "");
 400   bindtextdomain(PACKAGE, LOCALEDIR);
 401   textdomain(PACKAGE);
 402
 403   ao_initialize();
 404   stat_format = stat_format_create();
 405   options_init(&options);
 406   file_options_init(file_opts);
 407
 408   parse_std_configs(file_opts);
 409   options.playlist = playlist_create();
 410   optind = parse_cmdline_options(argc, argv, &options, file_opts);
 411
 412   audio_play_arg.devices = options.devices;
 413   audio_play_arg.stat_format = stat_format;
 414
 415   /* Add remaining arguments to playlist */
 416   for (i = optind; i < argc; i++) {
 417     if (stat(argv[i], &stat_buf) == 0) {
 418
 419       if (S_ISDIR(stat_buf.st_mode)) {
 420         if (playlist_append_directory(options.playlist, argv[i]) == 0)
 421           fprintf(stderr,
 422                   _("WARNING: Could not read directory %s.\n"), argv[i]);
 423       } else {
 424         playlist_append_file(options.playlist, argv[i]);
 425       }
 426     } else /* If we can't stat it, it might be a non-disk source */
 427       playlist_append_file(options.playlist, argv[i]);
 428
 429
 430   }
 431
 432
 433   /* Do we have anything left to play? */
 434   if (playlist_length(options.playlist) == 0) {
 435     cmdline_usage();
 436     exit(1);
 437   } else {
 438     playlist_array = playlist_to_array(options.playlist, &items);
 439     playlist_destroy(options.playlist);
 440     options.playlist = NULL;
 441   }
 442
 443   /* Don't use status_message until after this point! */
 444   status_init(options.verbosity);
 445
 446   print_audio_devices_info(options.devices);
 447
 448
 449   /* Setup buffer */
 450   if (options.buffer_size > 0) {
 451     /* Keep sample size alignment for surround sound with up to 10 channels */
 452     options.buffer_size = (options.buffer_size + PRIMAGIC - 1) / PRIMAGIC * PRIMAGIC;
 453     audio_buffer = buffer_create(options.buffer_size,
 454                                  options.buffer_size * options.prebuffer / 100,
 455                                  audio_play_callback, &audio_play_arg,
 456                                  AUDIO_CHUNK_SIZE);
 457     if (audio_buffer == NULL) {
 458       status_error(_("Error: Could not create audio buffer.\n"));
 459       exit(1);
 460     }
 461   } else
 462     audio_buffer = NULL;
 463
 464
 465   /* Setup signal handlers and callbacks */
 466
 467   signal (SIGINT, signal_handler);
 468   signal (SIGTSTP, signal_handler);
 469   signal (SIGCONT, signal_handler);
 470   signal (SIGTERM, signal_handler);
 471
 472   if (options.remote) {
 473     /* run the mainloop for the remote interface */
 474     remote_mainloop();
 475
 476   } else {
 477
 478     do {
 479       /* Shuffle playlist */
 480       if (options.shuffle) {
 481         int i;
 482
 483         srandom(time(NULL));
 484
 485         for (i = 0; i < items; i++) {
 486           int j = i + random() % (items - i);
 487           char *temp = playlist_array[i];
 488           playlist_array[i] = playlist_array[j];
 489           playlist_array[j] = temp;
 490         }
 491       }
 492
 493       /* Play the files/streams */
 494       i = 0;
 495       while (i < items && !sig_request.exit) {
 496         play(playlist_array[i]);
 497         i++;
 498       }
 499     } while (options.repeat);
 500
 501   }
 502   playlist_array_destroy(playlist_array, items);
 503   status_deinit();
 504
 505   if (audio_buffer != NULL) {
 506     buffer_destroy (audio_buffer);
 507     audio_buffer = NULL;
 508   }
 509
 510   ao_onexit (options.devices);
 511
 512   exit (exit_status);
 513 }
 514
 515 void play (char *source_string)
 516 {
 517   transport_t *transport;
 518   format_t *format;
 519   data_source_t *source;
 520   decoder_t *decoder;
 521
 522   decoder_callbacks_t decoder_callbacks;
 523   void *decoder_callbacks_arg;
 524
 525   /* Preserve between calls so we only open the audio device when we
 526      have to */
 527   static audio_format_t old_audio_fmt = { 0, 0, 0, 0, 0 };
 528   audio_format_t new_audio_fmt;
 529   audio_reopen_arg_t *reopen_arg;
 530
 531   /* Flags and counters galore */
 532   int eof = 0, eos = 0, ret;
 533   int nthc = 0, ntimesc = 0;
 534   int next_status = 0;
 535   static int status_interval = 0;
 536
 537   /* Reset all of the signal flags */
 538   sig_request.cancel   = 0;
 539   sig_request.skipfile = 0;
 540   sig_request.exit     = 0;
 541   sig_request.pause    = 0;
 542
 543   /* Set preferred audio format (used by decoder) */
 544   new_audio_fmt.big_endian = ao_is_big_endian();
 545   new_audio_fmt.signed_sample = 1;
 546   new_audio_fmt.word_size = 2;
 547
 548   /* Select appropriate callbacks */
 549   if (audio_buffer != NULL) {
 550     decoder_callbacks.printf_error = &decoder_buffered_error_callback;
 551     decoder_callbacks.printf_metadata = &decoder_buffered_metadata_callback;
 552     decoder_callbacks_arg = audio_buffer;
 553   } else {
 554     decoder_callbacks.printf_error = &decoder_error_callback;
 555     decoder_callbacks.printf_metadata = &decoder_metadata_callback;
 556     decoder_callbacks_arg = NULL;
 557   }
 558
 559   /* Locate and use transport for this data source */
 560   if ( (transport = select_transport(source_string)) == NULL ) {
 561     status_error(_("No module could be found to read from %s.\n"), source_string);
 562     return;
 563   }
 564
 565   if ( (source = transport->open(source_string, &options)) == NULL ) {
 566     status_error(_("Cannot open %s.\n"), source_string);
 567     return;
 568   }
 569
 570   /* Detect the file format and initialize a decoder */
 571   if ( (format = select_format(source)) == NULL ) {
 572     status_error(_("The file format of %s is not supported.\n"), source_string);
 573     return;
 574   }
 575
 576   if ( (decoder = format->init(source, &options, &new_audio_fmt,
 577                                &decoder_callbacks,
 578                                decoder_callbacks_arg)) == NULL ) {
 579
 580     /* We may have failed because of user command */
 581     if (!sig_request.cancel)
 582       status_error(_("Error opening %s using the %s module."
 583                      "  The file may be corrupted.\n"), source_string,
 584                    format->name);
 585     return;
 586   }
 587
 588   /* Decide which statistics are valid */
 589   select_stats(stat_format, &options, source, decoder, audio_buffer);
 590
 591   /* Start the audio playback thread before we begin sending data */
 592   if (audio_buffer != NULL) {
 593
 594     /* First reset mutexes and other synchronization variables */
 595     buffer_reset (audio_buffer);
 596     buffer_thread_start (audio_buffer);
 597   }
 598
 599   /* Show which file we are playing */
 600   decoder_callbacks.printf_metadata(decoder_callbacks_arg, 1,
 601                                     _("Playing: %s"), source_string);
 602
 603   /* Skip over audio */
 604   if (options.seekoff > 0.0) {
 605     /* Note: it may be simpler to handle this condition by just calling:
 606      *   handle_seek_opt(&options, decoder, format);
 607      * which was introduced with the remote control interface. However, that
 608      * function does not call buffer_thread_kill() on error, which is
 609      * necessary in this situation.
 610      */
 611     if (!format->seek(decoder, options.seekoff, DECODER_SEEK_START)) {
 612       status_error(_("Could not skip %f seconds of audio."), options.seekoff);
 613       if (audio_buffer != NULL)
 614         buffer_thread_kill(audio_buffer);
 615       return;
 616     }
 617   }
 618
 619   /* Main loop:  Iterates over all of the logical bitstreams in the file */
 620   while (!eof && !sig_request.exit) {
 621
 622     /* Loop through data within a logical bitstream */
 623     eos = 0;
 624     while (!eos && !sig_request.exit) {
 625
 626       /* Check signals */
 627       if (sig_request.skipfile) {
 628         eof = eos = 1;
 629         break;
 630       }
 631
 632         if (options.remote) {
 633
 634                 /* run the playloop for the remote interface */
 635                 if (remote_playloop()) {
 636                         /* end song requested */
 637                         eof = eos = 1;
 638                         break;
 639                 }
 640
 641                 /* Skip over audio */
 642                 handle_seek_opt(&options, decoder, format);
 643         }
 644
 645         if (sig_request.pause) {
 646         if (audio_buffer)
 647           buffer_thread_pause (audio_buffer);
 648
 649         kill (getpid(), SIGSTOP); /* We block here until we unpause */
 650
 651         /* Done pausing */
 652         if (audio_buffer)
 653           buffer_thread_unpause (audio_buffer);
 654
 655         sig_request.pause = 0;
 656       }
 657
 658
 659       /* Read another block of audio data */
 660       ret = format->read(decoder, convbuffer, convsize, &eos, &new_audio_fmt);
 661
 662       /* Bail if we need to */
 663       if (ret == 0) {
 664         eof = eos = 1;
 665         break;
 666       } else if (ret < 0) {
 667         status_error(_("ERROR: Decoding failure.\n"));
 668         break;
 669       }
 670
 671       /* Check to see if the audio format has changed */
 672       if (!audio_format_equal(&new_audio_fmt, &old_audio_fmt)) {
 673         old_audio_fmt = new_audio_fmt;
 674
 675         /* Update our status printing interval */
 676         status_interval = new_audio_fmt.word_size * new_audio_fmt.channels *
 677           new_audio_fmt.rate / options.status_freq;
 678         next_status = 0;
 679
 680         reopen_arg = new_audio_reopen_arg(options.devices, &new_audio_fmt);
 681
 682         if (audio_buffer)
 683           buffer_insert_action_at_end(audio_buffer, &audio_reopen_action,
 684                                       reopen_arg);
 685         else
 686           audio_reopen_action(NULL, reopen_arg);
 687       }
 688
 689
 690       /* Update statistics display if needed */
 691       if (next_status <= 0) {
 692         display_statistics(stat_format, audio_buffer, source, decoder);
 693         next_status = status_interval;
 694       } else
 695         next_status -= ret;
 696
 697       if (options.endpos > 0.0 && options.endpos <= current_time(decoder)) {
 698         eof = eos = 1;
 699         break;
 700       }
 701
 702
 703       /* Write audio data block to output, skipping or repeating chunks
 704          as needed */
 705       do {
 706
 707         if (nthc-- == 0) {
 708           if (audio_buffer) {
 709             if (!buffer_submit_data(audio_buffer, convbuffer, ret)) {
 710               status_error(_("ERROR: buffer write failed.\n"));
 711               eof = eos = 1;
 712               break;
 713             }
 714           } else
 715             audio_play_callback(convbuffer, ret, eos, &audio_play_arg);
 716
 717           nthc = options.nth - 1;
 718         }
 719
 720       } while (!sig_request.exit && !sig_request.skipfile &&
 721                ++ntimesc < options.ntimes);
 722
 723       ntimesc = 0;
 724
 725     } /* End of data loop */
 726
 727   } /* End of logical bitstream loop */
 728
 729   /* Done playing this logical bitstream.  Clean up house. */
 730
 731   if (audio_buffer) {
 732
 733     if (!sig_request.exit && !sig_request.skipfile) {
 734       buffer_mark_eos(audio_buffer);
 735       buffer_wait_for_empty(audio_buffer);
 736     }
 737
 738     buffer_thread_kill(audio_buffer);
 739   }
 740
 741   /* Print final stats */
 742   display_statistics_quick(stat_format, audio_buffer, source, decoder);
 743
 744   format->cleanup(decoder);
 745   transport->close(source);
 746   status_reset_output_lock();  /* In case we were killed mid-output */
 747
 748   status_message(1, _("Done."));
 749
 750   if (sig_request.exit)
 751     exit (exit_status);
 752 }
 753