apps/codecs/libmad/timer.c

   1 /*
   2  * libmad - MPEG audio decoder library
   3  * Copyright (C) 2000-2004 Underbit Technologies, Inc.
   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 2 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, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  * $Id$
  20  */
  21
  22 # ifdef HAVE_CONFIG_H
  23 #  include "config.h"
  24 # endif
  25
  26 # include "global.h"
  27
  28 # include <stdio.h>
  29
  30 # ifdef HAVE_ASSERT_H
  31 #  include <assert.h>
  32 # endif
  33
  34 # include "timer.h"
  35
  36 mad_timer_t const mad_timer_zero = { 0, 0 };
  37
  38 /*
  39  * NAME:        timer->compare()
  40  * DESCRIPTION: indicate relative order of two timers
  41  */
  42 int mad_timer_compare(mad_timer_t timer1, mad_timer_t timer2)
  43 {
  44   signed long diff;
  45
  46   diff = timer1.seconds - timer2.seconds;
  47   if (diff < 0)
  48     return -1;
  49   else if (diff > 0)
  50     return +1;
  51
  52   diff = timer1.fraction - timer2.fraction;
  53   if (diff < 0)
  54     return -1;
  55   else if (diff > 0)
  56     return +1;
  57
  58   return 0;
  59 }
  60
  61 /*
  62  * NAME:        timer->negate()
  63  * DESCRIPTION: invert the sign of a timer
  64  */
  65 void mad_timer_negate(mad_timer_t *timer)
  66 {
  67   timer->seconds = -timer->seconds;
  68
  69   if (timer->fraction) {
  70     timer->seconds -= 1;
  71     timer->fraction = MAD_TIMER_RESOLUTION - timer->fraction;
  72   }
  73 }
  74
  75 /*
  76  * NAME:        timer->abs()
  77  * DESCRIPTION: return the absolute value of a timer
  78  */
  79 mad_timer_t mad_timer_abs(mad_timer_t timer)
  80 {
  81   if (timer.seconds < 0)
  82     mad_timer_negate(&timer);
  83
  84   return timer;
  85 }
  86
  87 /*
  88  * NAME:        reduce_timer()
  89  * DESCRIPTION: carry timer fraction into seconds
  90  */
  91 static
  92 void reduce_timer(mad_timer_t *timer)
  93 {
  94   timer->seconds  += timer->fraction / MAD_TIMER_RESOLUTION;
  95   timer->fraction %= MAD_TIMER_RESOLUTION;
  96 }
  97
  98 /*
  99  * NAME:        gcd()
 100  * DESCRIPTION: compute greatest common denominator
 101  */
 102 static
 103 unsigned long gcd(unsigned long num1, unsigned long num2)
 104 {
 105   unsigned long tmp;
 106
 107   while (num2) {
 108     tmp  = num2;
 109     num2 = num1 % num2;
 110     num1 = tmp;
 111   }
 112
 113   return num1;
 114 }
 115
 116 /*
 117  * NAME:        reduce_rational()
 118  * DESCRIPTION: convert rational expression to lowest terms
 119  */
 120 static
 121 void reduce_rational(unsigned long *numer, unsigned long *denom)
 122 {
 123   unsigned long factor;
 124
 125   factor = gcd(*numer, *denom);
 126
 127   assert(factor != 0);
 128
 129   *numer /= factor;
 130   *denom /= factor;
 131 }
 132
 133 /*
 134  * NAME:        scale_rational()
 135  * DESCRIPTION: solve numer/denom == ?/scale avoiding overflowing
 136  */
 137 static
 138 unsigned long scale_rational(unsigned long numer, unsigned long denom,
 139                              unsigned long scale)
 140 {
 141   reduce_rational(&numer, &denom);
 142   reduce_rational(&scale, &denom);
 143
 144   assert(denom != 0);
 145
 146   if (denom < scale)
 147     return numer * (scale / denom) + numer * (scale % denom) / denom;
 148   if (denom < numer)
 149     return scale * (numer / denom) + scale * (numer % denom) / denom;
 150
 151   return numer * scale / denom;
 152 }
 153
 154 /*
 155  * NAME:        timer->set()
 156  * DESCRIPTION: set timer to specific (positive) value
 157  */
 158 void mad_timer_set(mad_timer_t *timer, unsigned long seconds,
 159                    unsigned long numer, unsigned long denom)
 160 {
 161   timer->seconds = seconds;
 162   if (numer >= denom && denom > 0) {
 163     timer->seconds += numer / denom;
 164     numer %= denom;
 165   }
 166
 167   switch (denom) {
 168   case 0:
 169   case 1:
 170     timer->fraction = 0;
 171     break;
 172
 173   case MAD_TIMER_RESOLUTION:
 174     timer->fraction = numer;
 175     break;
 176
 177   case 1000:
 178     timer->fraction = numer * (MAD_TIMER_RESOLUTION /  1000);
 179     break;
 180
 181   case 8000:
 182     timer->fraction = numer * (MAD_TIMER_RESOLUTION /  8000);
 183     break;
 184
 185   case 11025:
 186     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 11025);
 187     break;
 188
 189   case 12000:
 190     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 12000);
 191     break;
 192
 193   case 16000:
 194     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 16000);
 195     break;
 196
 197   case 22050:
 198     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 22050);
 199     break;
 200
 201   case 24000:
 202     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 24000);
 203     break;
 204
 205   case 32000:
 206     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 32000);
 207     break;
 208
 209   case 44100:
 210     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 44100);
 211     break;
 212
 213   case 48000:
 214     timer->fraction = numer * (MAD_TIMER_RESOLUTION / 48000);
 215     break;
 216
 217   default:
 218     timer->fraction = scale_rational(numer, denom, MAD_TIMER_RESOLUTION);
 219     break;
 220   }
 221
 222   if (timer->fraction >= MAD_TIMER_RESOLUTION)
 223     reduce_timer(timer);
 224 }
 225
 226 /*
 227  * NAME:        timer->add()
 228  * DESCRIPTION: add one timer to another
 229  */
 230 void mad_timer_add(mad_timer_t *timer, mad_timer_t incr)
 231 {
 232   timer->seconds  += incr.seconds;
 233   timer->fraction += incr.fraction;
 234
 235   if (timer->fraction >= MAD_TIMER_RESOLUTION)
 236     reduce_timer(timer);
 237 }
 238
 239 /*
 240  * NAME:        timer->multiply()
 241  * DESCRIPTION: multiply a timer by a scalar value
 242  */
 243 void mad_timer_multiply(mad_timer_t *timer, signed long scalar)
 244 {
 245   mad_timer_t addend;
 246   unsigned long factor;
 247
 248   factor = scalar;
 249   if (scalar < 0) {
 250     factor = -scalar;
 251     mad_timer_negate(timer);
 252   }
 253
 254   addend = *timer;
 255   *timer = mad_timer_zero;
 256
 257   while (factor) {
 258     if (factor & 1)
 259       mad_timer_add(timer, addend);
 260
 261     mad_timer_add(&addend, addend);
 262     factor >>= 1;
 263   }
 264 }
 265
 266 /*
 267  * NAME:        timer->count()
 268  * DESCRIPTION: return timer value in selected units
 269  */
 270 signed long mad_timer_count(mad_timer_t timer, enum mad_units units)
 271 {
 272   switch (units) {
 273   case MAD_UNITS_HOURS:
 274     return timer.seconds / 60 / 60;
 275
 276   case MAD_UNITS_MINUTES:
 277     return timer.seconds / 60;
 278
 279   case MAD_UNITS_SECONDS:
 280     return timer.seconds;
 281
 282   case MAD_UNITS_DECISECONDS:
 283   case MAD_UNITS_CENTISECONDS:
 284   case MAD_UNITS_MILLISECONDS:
 285
 286   case MAD_UNITS_8000_HZ:
 287   case MAD_UNITS_11025_HZ:
 288   case MAD_UNITS_12000_HZ:
 289   case MAD_UNITS_16000_HZ:
 290   case MAD_UNITS_22050_HZ:
 291   case MAD_UNITS_24000_HZ:
 292   case MAD_UNITS_32000_HZ:
 293   case MAD_UNITS_44100_HZ:
 294   case MAD_UNITS_48000_HZ:
 295
 296   case MAD_UNITS_24_FPS:
 297   case MAD_UNITS_25_FPS:
 298   case MAD_UNITS_30_FPS:
 299   case MAD_UNITS_48_FPS:
 300   case MAD_UNITS_50_FPS:
 301   case MAD_UNITS_60_FPS:
 302   case MAD_UNITS_75_FPS:
 303     return timer.seconds * (signed long) units +
 304       (signed long) scale_rational(timer.fraction, MAD_TIMER_RESOLUTION,
 305                                    units);
 306
 307   case MAD_UNITS_23_976_FPS:
 308   case MAD_UNITS_24_975_FPS:
 309   case MAD_UNITS_29_97_FPS:
 310   case MAD_UNITS_47_952_FPS:
 311   case MAD_UNITS_49_95_FPS:
 312   case MAD_UNITS_59_94_FPS:
 313     return (mad_timer_count(timer, -units) + 1) * 1000 / 1001;
 314   }
 315
 316   /* unsupported units */
 317   return 0;
 318 }
 319
 320 /*
 321  * NAME:        timer->fraction()
 322  * DESCRIPTION: return fractional part of timer in arbitrary terms
 323  */
 324 unsigned long mad_timer_fraction(mad_timer_t timer, unsigned long denom)
 325 {
 326   timer = mad_timer_abs(timer);
 327
 328   switch (denom) {
 329   case 0:
 330     return timer.fraction ?
 331       MAD_TIMER_RESOLUTION / timer.fraction : MAD_TIMER_RESOLUTION + 1;
 332
 333   case MAD_TIMER_RESOLUTION:
 334     return timer.fraction;
 335
 336   default:
 337     return scale_rational(timer.fraction, MAD_TIMER_RESOLUTION, denom);
 338   }
 339 }
 340
 341 /*
 342  * NAME:        timer->string()
 343  * DESCRIPTION: write a string representation of a timer using a template
 344  */
 345 void mad_timer_string(mad_timer_t timer,
 346                       char *dest, char const *format, enum mad_units units,
 347                       enum mad_units fracunits, unsigned long subparts)
 348 {
 349   unsigned long hours, minutes, seconds, sub;
 350   unsigned int frac;
 351
 352   timer = mad_timer_abs(timer);
 353
 354   seconds = timer.seconds;
 355   frac = sub = 0;
 356
 357   dest[0]=0;
 358   (void)format;
 359
 360   switch (fracunits) {
 361   case MAD_UNITS_HOURS:
 362   case MAD_UNITS_MINUTES:
 363   case MAD_UNITS_SECONDS:
 364     break;
 365
 366   case MAD_UNITS_DECISECONDS:
 367   case MAD_UNITS_CENTISECONDS:
 368   case MAD_UNITS_MILLISECONDS:
 369
 370   case MAD_UNITS_8000_HZ:
 371   case MAD_UNITS_11025_HZ:
 372   case MAD_UNITS_12000_HZ:
 373   case MAD_UNITS_16000_HZ:
 374   case MAD_UNITS_22050_HZ:
 375   case MAD_UNITS_24000_HZ:
 376   case MAD_UNITS_32000_HZ:
 377   case MAD_UNITS_44100_HZ:
 378   case MAD_UNITS_48000_HZ:
 379
 380   case MAD_UNITS_24_FPS:
 381   case MAD_UNITS_25_FPS:
 382   case MAD_UNITS_30_FPS:
 383   case MAD_UNITS_48_FPS:
 384   case MAD_UNITS_50_FPS:
 385   case MAD_UNITS_60_FPS:
 386   case MAD_UNITS_75_FPS:
 387     {
 388       unsigned long denom;
 389
 390       denom = MAD_TIMER_RESOLUTION / fracunits;
 391
 392       frac = timer.fraction / denom;
 393       sub  = scale_rational(timer.fraction % denom, denom, subparts);
 394     }
 395     break;
 396
 397   case MAD_UNITS_23_976_FPS:
 398   case MAD_UNITS_24_975_FPS:
 399   case MAD_UNITS_29_97_FPS:
 400   case MAD_UNITS_47_952_FPS:
 401   case MAD_UNITS_49_95_FPS:
 402   case MAD_UNITS_59_94_FPS:
 403     /* drop-frame encoding */
 404     /* N.B. this is only well-defined for MAD_UNITS_29_97_FPS */
 405     {
 406       unsigned long frame, cycle, d, m;
 407
 408       frame = mad_timer_count(timer, fracunits);
 409
 410       cycle = -fracunits * 60 * 10 - (10 - 1) * 2;
 411
 412       d = frame / cycle;
 413       m = frame % cycle;
 414       frame += (10 - 1) * 2 * d;
 415       if (m > 2)
 416         frame += 2 * ((m - 2) / (cycle / 10));
 417
 418       frac    = frame % -fracunits;
 419       seconds = frame / -fracunits;
 420     }
 421     break;
 422   }
 423
 424   switch (units) {
 425   case MAD_UNITS_HOURS:
 426     minutes = seconds / 60;
 427     hours   = minutes / 60;
 428
 429 //    sprintf(dest, format,
 430 //          hours,
 431 //          (unsigned int) (minutes % 60),
 432 //          (unsigned int) (seconds % 60),
 433 //          frac, sub);
 434     break;
 435
 436   case MAD_UNITS_MINUTES:
 437     minutes = seconds / 60;
 438
 439 //    sprintf(dest, format,
 440 //          minutes,
 441 //          (unsigned int) (seconds % 60),
 442 //          frac, sub);
 443     break;
 444
 445   case MAD_UNITS_SECONDS:
 446 //    sprintf(dest, format,
 447 //          seconds,
 448 //          frac, sub);
 449     break;
 450
 451   case MAD_UNITS_23_976_FPS:
 452   case MAD_UNITS_24_975_FPS:
 453   case MAD_UNITS_29_97_FPS:
 454   case MAD_UNITS_47_952_FPS:
 455   case MAD_UNITS_49_95_FPS:
 456   case MAD_UNITS_59_94_FPS:
 457     if (fracunits < 0) {
 458       /* not yet implemented */
 459       sub = 0;
 460     }
 461
 462     /* fall through */
 463
 464   case MAD_UNITS_DECISECONDS:
 465   case MAD_UNITS_CENTISECONDS:
 466   case MAD_UNITS_MILLISECONDS:
 467
 468   case MAD_UNITS_8000_HZ:
 469   case MAD_UNITS_11025_HZ:
 470   case MAD_UNITS_12000_HZ:
 471   case MAD_UNITS_16000_HZ:
 472   case MAD_UNITS_22050_HZ:
 473   case MAD_UNITS_24000_HZ:
 474   case MAD_UNITS_32000_HZ:
 475   case MAD_UNITS_44100_HZ:
 476   case MAD_UNITS_48000_HZ:
 477
 478   case MAD_UNITS_24_FPS:
 479   case MAD_UNITS_25_FPS:
 480   case MAD_UNITS_30_FPS:
 481   case MAD_UNITS_48_FPS:
 482   case MAD_UNITS_50_FPS:
 483   case MAD_UNITS_60_FPS:
 484   case MAD_UNITS_75_FPS:
 485 //    sprintf(dest, format, mad_timer_count(timer, units), sub);
 486     break;
 487   }
 488 }