rtoss - Blame information for rev 26

Subversion Repositories:
Rev:
Rev Author Line No. Line
14 roytam 1 /*
2  * libmad - MPEG audio decoder library
26 roytam 3  * Copyright (C) 2000-2004 Underbit Technologies, Inc.
14 roytam 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  *
26 roytam 19  * $Id: timer.c,v 1.18 2004/01/23 09:41:33 rob Exp $
14 roytam 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   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       unsigned long 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       unsigned long 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             (unsigned int) (minutes % 60),
429             (unsigned int) (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             (unsigned int) (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 }