rtoss - Diff between revs 14 and 26

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