vorbis-tools/ogg123/status.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$
  15
  16  ********************************************************************/
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <pthread.h>
  25
  26 #ifdef HAVE_UNISTD_H
  27 #include <unistd.h>
  28 #endif
  29
  30 #ifdef HAVE_FCNTL_H
  31 #include <fcntl.h>
  32 #endif
  33
  34 #include "status.h"
  35 #include "i18n.h"
  36
  37 char temp_buffer[200];
  38 int last_line_len = 0;
  39 int max_verbosity = 0;
  40 int exit_status = EXIT_SUCCESS;
  41
  42 pthread_mutex_t output_lock = PTHREAD_MUTEX_INITIALIZER;
  43
  44
  45 /* ------------------- Private functions ------------------ */
  46
  47 void unlock_output_lock (void *arg)
  48 {
  49   pthread_mutex_unlock(&output_lock);
  50 }
  51
  52
  53 void write_buffer_state_string (char *dest, buffer_stats_t *buf_stats)
  54 {
  55   char *cur = dest;
  56   char *comma = ", ";
  57   char *sep = "(";
  58
  59   if (buf_stats->prebuffering) {
  60     cur += sprintf (cur, _("%sPrebuf to %.1f%%"), sep,
  61                     100.0f * buf_stats->prebuffer_fill);
  62     sep = comma;
  63   }
  64   if (buf_stats->paused) {
  65     cur += sprintf (cur, _("%sPaused"), sep);
  66     sep = comma;
  67   }
  68   if (buf_stats->eos) {
  69     cur += sprintf (cur, _("%sEOS"), sep);
  70     sep = comma;
  71   }
  72   if (cur != dest)
  73     cur += sprintf (cur, ")");
  74   else
  75     *cur = '\0';
  76 }
  77
  78
  79 /* Write a min:sec.msec style string to dest corresponding to time.
  80    The time parameter is in seconds.  Returns the number of characters
  81    written */
  82 int write_time_string (char *dest, double time)
  83 {
  84   long min = (long) time / (long) 60;
  85   double sec = time - 60.0f * min;
  86
  87   return sprintf (dest, "%02li:%05.2f", min, sec);
  88 }
  89
  90
  91 void clear_line (int len)
  92 {
  93   fputc('\r', stderr);
  94
  95   while (len > 0) {
  96     fputc (' ', stderr);
  97     len--;
  98   }
  99
 100   fputc ('\r', stderr);
 101 }
 102
 103
 104 int sprintf_clear_line(int len, char *buf)
 105 {
 106   int i = 0;
 107
 108   buf[i] = '\r';
 109   i++;
 110
 111   while (len > 0) {
 112     buf[i] = ' ';
 113     len--;
 114     i++;
 115   }
 116
 117   buf[i] = '\r';
 118   i++;
 119
 120   /* Null terminate just in case */
 121   buf[i] = '\0';
 122
 123   return i;
 124 }
 125
 126 int print_statistics_line (stat_format_t stats[])
 127 {
 128   int len = 0;
 129   char *str = temp_buffer;
 130
 131   if (max_verbosity == 0)
 132     return 0;
 133
 134   /* Put the clear line text into the same string buffer so that the
 135      line is cleared and redrawn all at once.  This reduces
 136      flickering.  Don't count characters used to clear line in len */
 137   str += sprintf_clear_line(last_line_len, str);
 138
 139   while (stats->formatstr != NULL) {
 140
 141     if (stats->verbosity > max_verbosity || !stats->enabled) {
 142       stats++;
 143       continue;
 144     }
 145
 146     if (len != 0)
 147       len += sprintf(str+len, " ");
 148
 149     switch (stats->type) {
 150     case stat_noarg:
 151       len += sprintf(str+len, "%s", stats->formatstr);
 152       break;
 153     case stat_intarg:
 154       len += sprintf(str+len, stats->formatstr, stats->arg.intarg);
 155       break;
 156     case stat_stringarg:
 157       len += sprintf(str+len, stats->formatstr, stats->arg.stringarg);
 158       break;
 159     case stat_floatarg:
 160       len += sprintf(str+len, stats->formatstr, stats->arg.floatarg);
 161       break;
 162     case stat_doublearg:
 163       len += sprintf(str+len, stats->formatstr, stats->arg.doublearg);
 164       break;
 165     }
 166
 167     stats++;
 168   }
 169
 170   len += sprintf(str+len, "\r");
 171
 172   fprintf(stderr, "%s", temp_buffer);
 173
 174   return len;
 175 }
 176
 177
 178 void vstatus_print_nolock (const char *fmt, va_list ap)
 179 {
 180   if (last_line_len != 0)
 181     fputc ('\n', stderr);
 182
 183   vfprintf (stderr, fmt, ap);
 184
 185   fputc ('\n', stderr);
 186
 187   last_line_len = 0;
 188 }
 189
 190
 191 /* ------------------- Public interface -------------------- */
 192
 193 #define TIME_STR_SIZE 20
 194 #define STATE_STR_SIZE 25
 195 #define NUM_STATS 10
 196
 197 stat_format_t *stat_format_create ()
 198 {
 199   stat_format_t *stats;
 200   stat_format_t *cur;
 201
 202   stats = calloc(NUM_STATS + 1, sizeof(stat_format_t));  /* One extra for end flag */
 203   if (stats == NULL) {
 204     fprintf(stderr, _("Memory allocation error in stats_init()\n"));
 205     exit(1);
 206   }
 207
 208   cur = stats + 0; /* currently playing file / stream */
 209   cur->verbosity = 3;
 210   cur->enabled = 0;
 211   cur->formatstr = _("File: %s");
 212   cur->type = stat_stringarg;
 213
 214   cur = stats + 1; /* current playback time (preformatted) */
 215   cur->verbosity = 1;
 216   cur->enabled = 1;
 217   cur->formatstr = _("Time: %s");
 218   cur->type = stat_stringarg;
 219   cur->arg.stringarg = calloc(TIME_STR_SIZE, sizeof(char));
 220
 221   if (cur->arg.stringarg == NULL) {
 222     fprintf(stderr, _("Memory allocation error in stats_init()\n"));
 223     exit(1);
 224   }
 225   write_time_string(cur->arg.stringarg, 0.0);
 226
 227
 228   cur = stats + 2; /* remaining playback time (preformatted) */
 229   cur->verbosity = 1;
 230   cur->enabled = 1;
 231   cur->formatstr = "[%s]";
 232   cur->type = stat_stringarg;
 233   cur->arg.stringarg = calloc(TIME_STR_SIZE, sizeof(char));
 234
 235   if (cur->arg.stringarg == NULL) {
 236     fprintf(stderr, _("Memory allocation error in stats_init()\n"));
 237     exit(1);
 238   }
 239   write_time_string(cur->arg.stringarg, 0.0);
 240
 241
 242   cur = stats + 3; /* total playback time (preformatted) */
 243   cur->verbosity = 1;
 244   cur->enabled = 1;
 245   cur->formatstr = _("of %s");
 246   cur->type = stat_stringarg;
 247   cur->arg.stringarg = calloc(TIME_STR_SIZE, sizeof(char));
 248
 249   if (cur->arg.stringarg == NULL) {
 250     fprintf(stderr, _("Memory allocation error in stats_init()\n"));
 251     exit(1);
 252   }
 253   write_time_string(cur->arg.stringarg, 0.0);
 254
 255
 256   cur = stats + 4; /* instantaneous bitrate */
 257   cur->verbosity = 2;
 258   cur->enabled = 1;
 259   cur->formatstr = " (%5.1f kbps)";
 260   cur->type = stat_doublearg;
 261
 262   cur = stats + 5; /* average bitrate (not yet implemented) */
 263   cur->verbosity = 2;
 264   cur->enabled = 0;
 265   cur->formatstr = _("Avg bitrate: %5.1f");
 266   cur->type = stat_doublearg;
 267
 268   cur = stats + 6; /* input buffer fill % */
 269   cur->verbosity = 2;
 270   cur->enabled = 0;
 271   cur->formatstr = _(" Input Buffer %5.1f%%");
 272   cur->type = stat_doublearg;
 273
 274   cur = stats + 7; /* input buffer status */
 275   cur->verbosity = 2;
 276   cur->enabled = 0;
 277   cur->formatstr = "%s";
 278   cur->type = stat_stringarg;
 279   cur->arg.stringarg = calloc(STATE_STR_SIZE, sizeof(char));
 280
 281   if (cur->arg.stringarg == NULL) {
 282     fprintf(stderr, _("Memory allocation error in stats_init()\n"));
 283     exit(1);
 284   }
 285
 286
 287   cur = stats + 8; /* output buffer fill % */
 288   cur->verbosity = 2;
 289   cur->enabled = 0;
 290   cur->formatstr = _(" Output Buffer %5.1f%%");
 291   cur->type = stat_doublearg;
 292
 293   cur = stats + 9; /* output buffer status */
 294   cur->verbosity = 1;
 295   cur->enabled = 0;
 296   cur->formatstr = "%s";
 297   cur->type = stat_stringarg;
 298   cur->arg.stringarg = calloc(STATE_STR_SIZE, sizeof(char));
 299
 300   if (cur->arg.stringarg == NULL) {
 301     fprintf(stderr, _("Memory allocation error in stats_init()\n"));
 302     exit(1);
 303   }
 304
 305
 306   cur = stats + 10; /* End flag */
 307   cur->formatstr = NULL;
 308
 309   return stats;
 310 }
 311
 312
 313 void stat_format_cleanup (stat_format_t *stats)
 314 {
 315   free(stats[1].arg.stringarg);
 316   free(stats[2].arg.stringarg);
 317   free(stats[3].arg.stringarg);
 318   free(stats[7].arg.stringarg);
 319   free(stats[9].arg.stringarg);
 320   free(stats);
 321 }
 322
 323
 324 void status_init (int verbosity)
 325 {
 326 #if defined(HAVE_FCNTL) && defined(HAVE_UNISTD_H)
 327   fcntl (STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) | O_NONBLOCK);
 328 #endif
 329
 330   max_verbosity = verbosity;
 331 }
 332
 333 void status_deinit ()
 334 {
 335 #if defined(HAVE_FCNTL) && defined(HAVE_UNISTD_H)
 336   fcntl (STDERR_FILENO, F_SETFL, fcntl(STDERR_FILENO, F_GETFL) & ~O_NONBLOCK);
 337 #endif
 338 }
 339
 340 void status_reset_output_lock ()
 341 {
 342   pthread_mutex_unlock(&output_lock);
 343 }
 344
 345
 346 void status_clear_line ()
 347 {
 348   pthread_cleanup_push(unlock_output_lock, NULL);
 349
 350   pthread_mutex_lock(&output_lock);
 351   clear_line(last_line_len);
 352   pthread_mutex_unlock(&output_lock);
 353
 354   pthread_cleanup_pop(0);
 355 }
 356
 357 void status_print_statistics (stat_format_t *stats,
 358                               buffer_stats_t *audio_statistics,
 359                               data_source_stats_t *transport_statistics,
 360                               decoder_stats_t *decoder_statistics)
 361 {
 362   pthread_cleanup_push(unlock_output_lock, NULL);
 363
 364   /* Updating statistics is not critical.  If another thread is
 365      already doing output, we skip it. */
 366   if (pthread_mutex_trylock(&output_lock) == 0) {
 367
 368     if (decoder_statistics != NULL) {
 369       /* Current playback time */
 370       write_time_string(stats[1].arg.stringarg,
 371                         decoder_statistics->current_time);
 372
 373       /* Remaining playback time */
 374       write_time_string(stats[2].arg.stringarg,
 375                         decoder_statistics->total_time -
 376                         decoder_statistics->current_time);
 377
 378       /* Total playback time */
 379       write_time_string(stats[3].arg.stringarg,
 380                         decoder_statistics->total_time);
 381
 382       /* Instantaneous bitrate */
 383       stats[4].arg.doublearg = decoder_statistics->instant_bitrate / 1000.0f;
 384
 385       /* Instantaneous bitrate */
 386       stats[5].arg.doublearg = decoder_statistics->avg_bitrate / 1000.0f;
 387     }
 388
 389
 390     if (transport_statistics != NULL &&
 391         transport_statistics->input_buffer_used) {
 392
 393       /* Input buffer fill % */
 394       stats[6].arg.doublearg = transport_statistics->input_buffer.fill;
 395
 396       /* Input buffer state */
 397       write_buffer_state_string(stats[7].arg.stringarg,
 398                                 &transport_statistics->input_buffer);
 399     }
 400
 401
 402     if (audio_statistics != NULL) {
 403
 404       /* Output buffer fill % */
 405       stats[8].arg.doublearg = audio_statistics->fill;
 406
 407       /* Output buffer state */
 408       write_buffer_state_string(stats[9].arg.stringarg, audio_statistics);
 409     }
 410
 411     last_line_len = print_statistics_line(stats);
 412
 413     pthread_mutex_unlock(&output_lock);
 414   }
 415
 416   pthread_cleanup_pop(0);
 417 }
 418
 419
 420 void status_message (int verbosity, const char *fmt, ...)
 421 {
 422   va_list ap;
 423
 424   if (verbosity > max_verbosity)
 425     return;
 426
 427   pthread_cleanup_push(unlock_output_lock, NULL);
 428
 429   pthread_mutex_lock(&output_lock);
 430
 431   clear_line(last_line_len);
 432
 433   va_start (ap, fmt);
 434   vstatus_print_nolock(fmt, ap);
 435   va_end (ap);
 436
 437   pthread_mutex_unlock(&output_lock);
 438
 439   pthread_cleanup_pop(0);
 440 }
 441
 442
 443 void vstatus_message (int verbosity, const char *fmt, va_list ap)
 444 {
 445   if (verbosity > max_verbosity)
 446     return;
 447
 448   pthread_cleanup_push(unlock_output_lock, NULL);
 449
 450   pthread_mutex_lock(&output_lock);
 451
 452   clear_line(last_line_len);
 453   vstatus_print_nolock(fmt, ap);
 454
 455   pthread_mutex_unlock(&output_lock);
 456
 457   pthread_cleanup_pop(0);
 458 }
 459
 460
 461 void status_error (const char *fmt, ...)
 462 {
 463   va_list ap;
 464
 465   pthread_cleanup_push(unlock_output_lock, NULL);
 466
 467   pthread_mutex_lock(&output_lock);
 468   va_start (ap, fmt);
 469   clear_line(last_line_len);
 470   vstatus_print_nolock (fmt, ap);
 471   va_end (ap);
 472   pthread_mutex_unlock(&output_lock);
 473
 474   pthread_cleanup_pop(0);
 475
 476   exit_status = EXIT_FAILURE;
 477 }
 478
 479
 480 void vstatus_error (const char *fmt, va_list ap)
 481 {
 482   pthread_cleanup_push(unlock_output_lock, NULL);
 483
 484   pthread_mutex_lock(&output_lock);
 485   clear_line(last_line_len);
 486   vstatus_print_nolock (fmt, ap);
 487   pthread_mutex_unlock(&output_lock);
 488
 489   pthread_cleanup_pop(0);
 490
 491   exit_status = EXIT_FAILURE;
 492 }