libmad/timer.c

   1 /*
   2  * libmad - MPEG audio decoder library
   3  * Copyright (C) 2000-2003 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  */
  20
  21 # ifdef HAVE_CONFIG_H
  22 #  include "config.h"
  23 # endif
  24
  25 # include "global.h"
  26
  27 # include <stdlib.h>
  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 s32 mad_timer_compare(mad_timer_t timer1, mad_timer_t timer2)
  43 {
  44   s32 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 u32 gcd(u32 num1, u32 num2)
 104 {
 105   u32 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(u32 *numer, u32 *denom)
 122 {
 123   u32 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 u32 scale_rational(u32 numer, u32 denom,
 139                              u32 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, u32 seconds,
 159                    u32 numer, u32 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, s32 scalar)
 244 {
 245   mad_timer_t addend;
 246   u32 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 s32 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 * (s32) units +
 304       (s32) 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 u32 mad_timer_fraction(mad_timer_t timer, u32 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, u32 subparts)
 348 {
 349   u32 hours, minutes, seconds, sub;
 350   u32 frac;
 351
 352   timer = mad_timer_abs(timer);
 353
 354   seconds = timer.seconds;
 355   frac = sub = 0;
 356
 357   switch (fracunits) {
 358   case MAD_UNITS_HOURS:
 359   case MAD_UNITS_MINUTES:
 360   case MAD_UNITS_SECONDS:
 361     break;
 362
 363   case MAD_UNITS_DECISECONDS:
 364   case MAD_UNITS_CENTISECONDS:
 365   case MAD_UNITS_MILLISECONDS:
 366
 367   case MAD_UNITS_8000_HZ:
 368   case MAD_UNITS_11025_HZ:
 369   case MAD_UNITS_12000_HZ:
 370   case MAD_UNITS_16000_HZ:
 371   case MAD_UNITS_22050_HZ:
 372   case MAD_UNITS_24000_HZ:
 373   case MAD_UNITS_32000_HZ:
 374   case MAD_UNITS_44100_HZ:
 375   case MAD_UNITS_48000_HZ:
 376
 377   case MAD_UNITS_24_FPS:
 378   case MAD_UNITS_25_FPS:
 379   case MAD_UNITS_30_FPS:
 380   case MAD_UNITS_48_FPS:
 381   case MAD_UNITS_50_FPS:
 382   case MAD_UNITS_60_FPS:
 383   case MAD_UNITS_75_FPS:
 384     {
 385       u32 denom;
 386
 387       denom = MAD_TIMER_RESOLUTION / fracunits;
 388
 389       frac = timer.fraction / denom;
 390       sub  = scale_rational(timer.fraction % denom, denom, subparts);
 391     }
 392     break;
 393
 394   case MAD_UNITS_23_976_FPS:
 395   case MAD_UNITS_24_975_FPS:
 396   case MAD_UNITS_29_97_FPS:
 397   case MAD_UNITS_47_952_FPS:
 398   case MAD_UNITS_49_95_FPS:
 399   case MAD_UNITS_59_94_FPS:
 400     /* drop-frame encoding */
 401     /* N.B. this is only well-defined for MAD_UNITS_29_97_FPS */
 402     {
 403       u32 frame, cycle, d, m;
 404
 405       frame = mad_timer_count(timer, fracunits);
 406
 407       cycle = -fracunits * 60 * 10 - (10 - 1) * 2;
 408
 409       d = frame / cycle;
 410       m = frame % cycle;
 411       frame += (10 - 1) * 2 * d;
 412       if (m > 2)
 413         frame += 2 * ((m - 2) / (cycle / 10));
 414
 415       frac    = frame % -fracunits;
 416       seconds = frame / -fracunits;
 417     }
 418     break;
 419   }
 420
 421   switch (units) {
 422   case MAD_UNITS_HOURS:
 423     minutes = seconds / 60;
 424     hours   = minutes / 60;
 425
 426     sprintf(dest, format,
 427             hours,
 428             (u32) (minutes % 60),
 429             (u32) (seconds % 60),
 430             frac, sub);
 431     break;
 432
 433   case MAD_UNITS_MINUTES:
 434     minutes = seconds / 60;
 435
 436     sprintf(dest, format,
 437             minutes,
 438             (u32) (seconds % 60),
 439             frac, sub);
 440     break;
 441
 442   case MAD_UNITS_SECONDS:
 443     sprintf(dest, format,
 444             seconds,
 445             frac, sub);
 446     break;
 447
 448   case MAD_UNITS_23_976_FPS:
 449   case MAD_UNITS_24_975_FPS:
 450   case MAD_UNITS_29_97_FPS:
 451   case MAD_UNITS_47_952_FPS:
 452   case MAD_UNITS_49_95_FPS:
 453   case MAD_UNITS_59_94_FPS:
 454     if (fracunits < 0) {
 455       /* not yet implemented */
 456       sub = 0;
 457     }
 458
 459     /* fall through */
 460
 461   case MAD_UNITS_DECISECONDS:
 462   case MAD_UNITS_CENTISECONDS:
 463   case MAD_UNITS_MILLISECONDS:
 464
 465   case MAD_UNITS_8000_HZ:
 466   case MAD_UNITS_11025_HZ:
 467   case MAD_UNITS_12000_HZ:
 468   case MAD_UNITS_16000_HZ:
 469   case MAD_UNITS_22050_HZ:
 470   case MAD_UNITS_24000_HZ:
 471   case MAD_UNITS_32000_HZ:
 472   case MAD_UNITS_44100_HZ:
 473   case MAD_UNITS_48000_HZ:
 474
 475   case MAD_UNITS_24_FPS:
 476   case MAD_UNITS_25_FPS:
 477   case MAD_UNITS_30_FPS:
 478   case MAD_UNITS_48_FPS:
 479   case MAD_UNITS_50_FPS:
 480   case MAD_UNITS_60_FPS:
 481   case MAD_UNITS_75_FPS:
 482     sprintf(dest, format, mad_timer_count(timer, units), sub);
 483     break;
 484   }
 485 }