summaryrefslogtreecommitdiff
path: root/apps/codecs/libmad/mad.h
diff options
context:
space:
mode:
authorAndree Buschmann <AndreeBuschmann@t-online.de>2010-06-14 05:57:20 +0000
committerAndree Buschmann <AndreeBuschmann@t-online.de>2010-06-14 05:57:20 +0000
commit4b0c1cf23bdd3c54296b05ce52f8fec3f29c408e (patch)
tree16e89a4fc0c0ff2ddfdf80b3795d676ae1e71092 /apps/codecs/libmad/mad.h
parent3f5851f41f089696c91ba84259884513ee92d65c (diff)
downloadrockbox-4b0c1cf23bdd3c54296b05ce52f8fec3f29c408e.tar.gz
rockbox-4b0c1cf23bdd3c54296b05ce52f8fec3f29c408e.zip
Clean up libmad/mad.h to avoid double or inconsistent definitions of types, functions and structs.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@26838 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'apps/codecs/libmad/mad.h')
-rw-r--r--apps/codecs/libmad/mad.h941
1 files changed, 10 insertions, 931 deletions
diff --git a/apps/codecs/libmad/mad.h b/apps/codecs/libmad/mad.h
index 81ac20c373..551f2d8e08 100644
--- a/apps/codecs/libmad/mad.h
+++ b/apps/codecs/libmad/mad.h
@@ -22,934 +22,13 @@
22 22
23#include <inttypes.h> 23#include <inttypes.h>
24 24
25# ifdef __cplusplus 25#define FPM_DEFAULT
26extern "C" { 26
27# endif 27#include "version.h"
28 28#include "fixed.h"
29# define FPM_DEFAULT 29#include "bit.h"
30 30#include "timer.h"
31/* Id: version.h,v 1.26 2004/01/23 09:41:33 rob Exp */ 31#include "stream.h"
32 32#include "frame.h"
33# ifndef LIBMAD_VERSION_H 33#include "synth.h"
34# define LIBMAD_VERSION_H 34#include "decoder.h"
35
36# define MAD_VERSION_MAJOR 0
37# define MAD_VERSION_MINOR 15
38# define MAD_VERSION_PATCH 1
39# define MAD_VERSION_EXTRA " (beta)"
40
41# define MAD_VERSION_STRINGIZE(str) #str
42# define MAD_VERSION_STRING(num) MAD_VERSION_STRINGIZE(num)
43
44# define MAD_VERSION MAD_VERSION_STRING(MAD_VERSION_MAJOR) "." \
45 MAD_VERSION_STRING(MAD_VERSION_MINOR) "." \
46 MAD_VERSION_STRING(MAD_VERSION_PATCH) \
47 MAD_VERSION_EXTRA
48
49# define MAD_PUBLISHYEAR "2000-2004"
50# define MAD_AUTHOR "Underbit Technologies, Inc."
51# define MAD_EMAIL "info@underbit.com"
52
53extern char const mad_version[];
54extern char const mad_copyright[];
55extern char const mad_author[];
56extern char const mad_build[];
57
58# endif
59
60/* Id: fixed.h,v 1.38 2004/02/17 02:02:03 rob Exp */
61
62# ifndef LIBMAD_FIXED_H
63# define LIBMAD_FIXED_H
64
65typedef int32_t mad_fixed_t;
66
67typedef int32_t mad_fixed64hi_t;
68typedef uint32_t mad_fixed64lo_t;
69
70# if defined(_MSC_VER)
71# define mad_fixed64_t signed __int64
72# elif 1 || defined(__GNUC__)
73# define mad_fixed64_t signed long long
74# endif
75
76# if defined(FPM_FLOAT)
77typedef double mad_sample_t;
78# else
79typedef mad_fixed_t mad_sample_t;
80# endif
81
82/*
83 * Fixed-point format: 0xABBBBBBB
84 * A == whole part (sign + 3 bits)
85 * B == fractional part (28 bits)
86 *
87 * Values are signed two's complement, so the effective range is:
88 * 0x80000000 to 0x7fffffff
89 * -8.0 to +7.9999999962747097015380859375
90 *
91 * The smallest representable value is:
92 * 0x00000001 == 0.0000000037252902984619140625 (i.e. about 3.725e-9)
93 *
94 * 28 bits of fractional accuracy represent about
95 * 8.6 digits of decimal accuracy.
96 *
97 * Fixed-point numbers can be added or subtracted as normal
98 * integers, but multiplication requires shifting the 64-bit result
99 * from 56 fractional bits back to 28 (and rounding.)
100 *
101 * Changing the definition of MAD_F_FRACBITS is only partially
102 * supported, and must be done with care.
103 */
104
105# define MAD_F_FRACBITS 28
106
107# if MAD_F_FRACBITS == 28
108# define MAD_F(x) ((mad_fixed_t) (x##L))
109# else
110# if MAD_F_FRACBITS < 28
111# warning "MAD_F_FRACBITS < 28"
112# define MAD_F(x) ((mad_fixed_t) \
113 (((x##L) + \
114 (1L << (28 - MAD_F_FRACBITS - 1))) >> \
115 (28 - MAD_F_FRACBITS)))
116# elif MAD_F_FRACBITS > 28
117# error "MAD_F_FRACBITS > 28 not currently supported"
118# define MAD_F(x) ((mad_fixed_t) \
119 ((x##L) << (MAD_F_FRACBITS - 28)))
120# endif
121# endif
122
123# define MAD_F_MIN ((mad_fixed_t) -0x80000000L)
124# define MAD_F_MAX ((mad_fixed_t) +0x7fffffffL)
125
126# define MAD_F_ONE MAD_F(0x10000000)
127
128# define mad_f_tofixed(x) ((mad_fixed_t) \
129 ((x) * (double) (1L << MAD_F_FRACBITS) + 0.5))
130# define mad_f_todouble(x) ((double) \
131 ((x) / (double) (1L << MAD_F_FRACBITS)))
132
133# define mad_f_intpart(x) ((x) >> MAD_F_FRACBITS)
134# define mad_f_fracpart(x) ((x) & ((1L << MAD_F_FRACBITS) - 1))
135 /* (x should be positive) */
136
137# define mad_f_fromint(x) ((x) << MAD_F_FRACBITS)
138
139# define mad_f_add(x, y) ((x) + (y))
140# define mad_f_sub(x, y) ((x) - (y))
141
142# if defined(FPM_FLOAT)
143# error "FPM_FLOAT not yet supported"
144
145# undef MAD_F
146# define MAD_F(x) mad_f_todouble(x)
147
148# define mad_f_mul(x, y) ((x) * (y))
149# define mad_f_scale64
150
151# undef ASO_ZEROCHECK
152
153# elif defined(FPM_64BIT)
154
155/*
156 * This version should be the most accurate if 64-bit types are supported by
157 * the compiler, although it may not be the most efficient.
158 */
159# if defined(OPT_ACCURACY)
160# define mad_f_mul(x, y) \
161 ((mad_fixed_t) \
162 ((((mad_fixed64_t) (x) * (y)) + \
163 (1L << (MAD_F_SCALEBITS - 1))) >> MAD_F_SCALEBITS))
164# else
165# define mad_f_mul(x, y) \
166 ((mad_fixed_t) (((mad_fixed64_t) (x) * (y)) >> MAD_F_SCALEBITS))
167# endif
168
169# define MAD_F_SCALEBITS MAD_F_FRACBITS
170
171/* --- Intel --------------------------------------------------------------- */
172
173# elif defined(FPM_INTEL)
174
175# if defined(_MSC_VER)
176# pragma warning(push)
177# pragma warning(disable: 4035) /* no return value */
178static __forceinline
179mad_fixed_t mad_f_mul_inline(mad_fixed_t x, mad_fixed_t y)
180{
181 enum {
182 fracbits = MAD_F_FRACBITS
183 };
184
185 __asm {
186 mov eax, x
187 imul y
188 shrd eax, edx, fracbits
189 }
190
191 /* implicit return of eax */
192}
193# pragma warning(pop)
194
195# define mad_f_mul mad_f_mul_inline
196# define mad_f_scale64
197# else
198/*
199 * This Intel version is fast and accurate; the disposition of the least
200 * significant bit depends on OPT_ACCURACY via mad_f_scale64().
201 */
202# define MAD_F_MLX(hi, lo, x, y) \
203 asm ("imull %3" \
204 : "=a" (lo), "=d" (hi) \
205 : "%a" (x), "rm" (y) \
206 : "cc")
207
208# if defined(OPT_ACCURACY)
209/*
210 * This gives best accuracy but is not very fast.
211 */
212# define MAD_F_MLA(hi, lo, x, y) \
213 ({ mad_fixed64hi_t __hi; \
214 mad_fixed64lo_t __lo; \
215 MAD_F_MLX(__hi, __lo, (x), (y)); \
216 asm ("addl %2,%0\n\t" \
217 "adcl %3,%1" \
218 : "=rm" (lo), "=rm" (hi) \
219 : "r" (__lo), "r" (__hi), "0" (lo), "1" (hi) \
220 : "cc"); \
221 })
222# endif /* OPT_ACCURACY */
223
224# if defined(OPT_ACCURACY)
225/*
226 * Surprisingly, this is faster than SHRD followed by ADC.
227 */
228# define mad_f_scale64(hi, lo) \
229 ({ mad_fixed64hi_t __hi_; \
230 mad_fixed64lo_t __lo_; \
231 mad_fixed_t __result; \
232 asm ("addl %4,%2\n\t" \
233 "adcl %5,%3" \
234 : "=rm" (__lo_), "=rm" (__hi_) \
235 : "0" (lo), "1" (hi), \
236 "ir" (1L << (MAD_F_SCALEBITS - 1)), "ir" (0) \
237 : "cc"); \
238 asm ("shrdl %3,%2,%1" \
239 : "=rm" (__result) \
240 : "0" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS) \
241 : "cc"); \
242 __result; \
243 })
244# elif defined(OPT_INTEL)
245/*
246 * Alternate Intel scaling that may or may not perform better.
247 */
248# define mad_f_scale64(hi, lo) \
249 ({ mad_fixed_t __result; \
250 asm ("shrl %3,%1\n\t" \
251 "shll %4,%2\n\t" \
252 "orl %2,%1" \
253 : "=rm" (__result) \
254 : "0" (lo), "r" (hi), \
255 "I" (MAD_F_SCALEBITS), "I" (32 - MAD_F_SCALEBITS) \
256 : "cc"); \
257 __result; \
258 })
259# else
260# define mad_f_scale64(hi, lo) \
261 ({ mad_fixed_t __result; \
262 asm ("shrdl %3,%2,%1" \
263 : "=rm" (__result) \
264 : "0" (lo), "r" (hi), "I" (MAD_F_SCALEBITS) \
265 : "cc"); \
266 __result; \
267 })
268# endif /* OPT_ACCURACY */
269
270# define MAD_F_SCALEBITS MAD_F_FRACBITS
271# endif
272
273/* --- ARM ----------------------------------------------------------------- */
274
275# elif defined(FPM_ARM)
276
277/*
278 * This ARM V4 version is as accurate as FPM_64BIT but much faster. The
279 * least significant bit is properly rounded at no CPU cycle cost!
280 */
281# if 1
282/*
283 * This is faster than the default implementation via MAD_F_MLX() and
284 * mad_f_scale64().
285 */
286# define mad_f_mul(x, y) \
287 ({ mad_fixed64hi_t __hi; \
288 mad_fixed64lo_t __lo; \
289 mad_fixed_t __result; \
290 asm ("smull %0, %1, %3, %4\n\t" \
291 "movs %0, %0, lsr %5\n\t" \
292 "adc %2, %0, %1, lsl %6" \
293 : "=&r" (__lo), "=&r" (__hi), "=r" (__result) \
294 : "%r" (x), "r" (y), \
295 "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS) \
296 : "cc"); \
297 __result; \
298 })
299# endif
300
301# define MAD_F_MLX(hi, lo, x, y) \
302 asm ("smull %0, %1, %2, %3" \
303 : "=&r" (lo), "=&r" (hi) \
304 : "%r" (x), "r" (y))
305
306# define MAD_F_MLA(hi, lo, x, y) \
307 asm ("smlal %0, %1, %2, %3" \
308 : "+r" (lo), "+r" (hi) \
309 : "%r" (x), "r" (y))
310
311# define MAD_F_MLN(hi, lo) \
312 asm ("rsbs %0, %2, #0\n\t" \
313 "rsc %1, %3, #0" \
314 : "=r" (lo), "=r" (hi) \
315 : "0" (lo), "1" (hi) \
316 : "cc")
317
318# define mad_f_scale64(hi, lo) \
319 ({ mad_fixed_t __result; \
320 asm ("movs %0, %1, lsr %3\n\t" \
321 "adc %0, %0, %2, lsl %4" \
322 : "=&r" (__result) \
323 : "r" (lo), "r" (hi), \
324 "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS) \
325 : "cc"); \
326 __result; \
327 })
328
329# define MAD_F_SCALEBITS MAD_F_FRACBITS
330
331/* --- MIPS ---------------------------------------------------------------- */
332
333# elif defined(FPM_MIPS)
334
335/*
336 * This MIPS version is fast and accurate; the disposition of the least
337 * significant bit depends on OPT_ACCURACY via mad_f_scale64().
338 */
339# define MAD_F_MLX(hi, lo, x, y) \
340 asm ("mult %2,%3" \
341 : "=l" (lo), "=h" (hi) \
342 : "%r" (x), "r" (y))
343
344# if defined(HAVE_MADD_ASM)
345# define MAD_F_MLA(hi, lo, x, y) \
346 asm ("madd %2,%3" \
347 : "+l" (lo), "+h" (hi) \
348 : "%r" (x), "r" (y))
349# elif defined(HAVE_MADD16_ASM)
350/*
351 * This loses significant accuracy due to the 16-bit integer limit in the
352 * multiply/accumulate instruction.
353 */
354# define MAD_F_ML0(hi, lo, x, y) \
355 asm ("mult %2,%3" \
356 : "=l" (lo), "=h" (hi) \
357 : "%r" ((x) >> 12), "r" ((y) >> 16))
358# define MAD_F_MLA(hi, lo, x, y) \
359 asm ("madd16 %2,%3" \
360 : "+l" (lo), "+h" (hi) \
361 : "%r" ((x) >> 12), "r" ((y) >> 16))
362# define MAD_F_MLZ(hi, lo) ((mad_fixed_t) (lo))
363# endif
364
365# if defined(OPT_SPEED)
366# define mad_f_scale64(hi, lo) \
367 ((mad_fixed_t) ((hi) << (32 - MAD_F_SCALEBITS)))
368# define MAD_F_SCALEBITS MAD_F_FRACBITS
369# endif
370
371/* --- SPARC --------------------------------------------------------------- */
372
373# elif defined(FPM_SPARC)
374
375/*
376 * This SPARC V8 version is fast and accurate; the disposition of the least
377 * significant bit depends on OPT_ACCURACY via mad_f_scale64().
378 */
379# define MAD_F_MLX(hi, lo, x, y) \
380 asm ("smul %2, %3, %0\n\t" \
381 "rd %%y, %1" \
382 : "=r" (lo), "=r" (hi) \
383 : "%r" (x), "rI" (y))
384
385/* --- PowerPC ------------------------------------------------------------- */
386
387# elif defined(FPM_PPC)
388
389/*
390 * This PowerPC version is fast and accurate; the disposition of the least
391 * significant bit depends on OPT_ACCURACY via mad_f_scale64().
392 */
393# define MAD_F_MLX(hi, lo, x, y) \
394 do { \
395 asm ("mullw %0,%1,%2" \
396 : "=r" (lo) \
397 : "%r" (x), "r" (y)); \
398 asm ("mulhw %0,%1,%2" \
399 : "=r" (hi) \
400 : "%r" (x), "r" (y)); \
401 } \
402 while (0)
403
404# if defined(OPT_ACCURACY)
405/*
406 * This gives best accuracy but is not very fast.
407 */
408# define MAD_F_MLA(hi, lo, x, y) \
409 ({ mad_fixed64hi_t __hi; \
410 mad_fixed64lo_t __lo; \
411 MAD_F_MLX(__hi, __lo, (x), (y)); \
412 asm ("addc %0,%2,%3\n\t" \
413 "adde %1,%4,%5" \
414 : "=r" (lo), "=r" (hi) \
415 : "%r" (lo), "r" (__lo), \
416 "%r" (hi), "r" (__hi) \
417 : "xer"); \
418 })
419# endif
420
421# if defined(OPT_ACCURACY)
422/*
423 * This is slower than the truncating version below it.
424 */
425# define mad_f_scale64(hi, lo) \
426 ({ mad_fixed_t __result, __round; \
427 asm ("rotrwi %0,%1,%2" \
428 : "=r" (__result) \
429 : "r" (lo), "i" (MAD_F_SCALEBITS)); \
430 asm ("extrwi %0,%1,1,0" \
431 : "=r" (__round) \
432 : "r" (__result)); \
433 asm ("insrwi %0,%1,%2,0" \
434 : "+r" (__result) \
435 : "r" (hi), "i" (MAD_F_SCALEBITS)); \
436 asm ("add %0,%1,%2" \
437 : "=r" (__result) \
438 : "%r" (__result), "r" (__round)); \
439 __result; \
440 })
441# else
442# define mad_f_scale64(hi, lo) \
443 ({ mad_fixed_t __result; \
444 asm ("rotrwi %0,%1,%2" \
445 : "=r" (__result) \
446 : "r" (lo), "i" (MAD_F_SCALEBITS)); \
447 asm ("insrwi %0,%1,%2,0" \
448 : "+r" (__result) \
449 : "r" (hi), "i" (MAD_F_SCALEBITS)); \
450 __result; \
451 })
452# endif
453
454# define MAD_F_SCALEBITS MAD_F_FRACBITS
455
456/* --- Default ------------------------------------------------------------- */
457
458# elif defined(FPM_DEFAULT)
459
460/*
461 * This version is the most portable but it loses significant accuracy.
462 * Furthermore, accuracy is biased against the second argument, so care
463 * should be taken when ordering operands.
464 *
465 * The scale factors are constant as this is not used with SSO.
466 *
467 * Pre-rounding is required to stay within the limits of compliance.
468 */
469# if defined(OPT_SPEED)
470# define mad_f_mul(x, y) (((x) >> 12) * ((y) >> 16))
471# else
472# define mad_f_mul(x, y) ((((x) + (1L << 11)) >> 12) * \
473 (((y) + (1L << 15)) >> 16))
474# endif
475
476/* ------------------------------------------------------------------------- */
477
478# else
479# error "no FPM selected"
480# endif
481
482/* default implementations */
483
484# if !defined(mad_f_mul)
485# define mad_f_mul(x, y) \
486 ({ register mad_fixed64hi_t __hi; \
487 register mad_fixed64lo_t __lo; \
488 MAD_F_MLX(__hi, __lo, (x), (y)); \
489 mad_f_scale64(__hi, __lo); \
490 })
491# endif
492
493# if !defined(MAD_F_MLA)
494# define MAD_F_ML0(hi, lo, x, y) ((lo) = mad_f_mul((x), (y)))
495# define MAD_F_MLA(hi, lo, x, y) ((lo) += mad_f_mul((x), (y)))
496# define MAD_F_MLN(hi, lo) ((lo) = -(lo))
497# define MAD_F_MLZ(hi, lo) ((void) (hi), (mad_fixed_t) (lo))
498# endif
499
500# if !defined(MAD_F_ML0)
501# define MAD_F_ML0(hi, lo, x, y) MAD_F_MLX((hi), (lo), (x), (y))
502# endif
503
504# if !defined(MAD_F_MLN)
505# define MAD_F_MLN(hi, lo) ((hi) = ((lo) = -(lo)) ? ~(hi) : -(hi))
506# endif
507
508# if !defined(MAD_F_MLZ)
509# define MAD_F_MLZ(hi, lo) mad_f_scale64((hi), (lo))
510# endif
511
512# if !defined(mad_f_scale64)
513# if defined(OPT_ACCURACY)
514# define mad_f_scale64(hi, lo) \
515 ((((mad_fixed_t) \
516 (((hi) << (32 - (MAD_F_SCALEBITS - 1))) | \
517 ((lo) >> (MAD_F_SCALEBITS - 1)))) + 1) >> 1)
518# else
519# define mad_f_scale64(hi, lo) \
520 ((mad_fixed_t) \
521 (((hi) << (32 - MAD_F_SCALEBITS)) | \
522 ((lo) >> MAD_F_SCALEBITS)))
523# endif
524# define MAD_F_SCALEBITS MAD_F_FRACBITS
525# endif
526
527/* C routines */
528
529mad_fixed_t mad_f_abs(mad_fixed_t);
530mad_fixed_t mad_f_div(mad_fixed_t, mad_fixed_t);
531
532# endif
533
534/* Id: bit.h,v 1.12 2004/01/23 09:41:32 rob Exp */
535
536# ifndef LIBMAD_BIT_H
537# define LIBMAD_BIT_H
538
539struct mad_bitptr {
540 unsigned char const *byte;
541 unsigned short cache;
542 unsigned short left;
543};
544
545void mad_bit_init(struct mad_bitptr *, unsigned char const *);
546
547# define mad_bit_finish(bitptr) /* nothing */
548
549unsigned int mad_bit_length(struct mad_bitptr const *,
550 struct mad_bitptr const *);
551
552# define mad_bit_bitsleft(bitptr) ((bitptr)->left)
553unsigned char const *mad_bit_nextbyte(struct mad_bitptr const *);
554
555void mad_bit_skip(struct mad_bitptr *, unsigned int);
556unsigned long mad_bit_read(struct mad_bitptr *, unsigned int);
557void mad_bit_write(struct mad_bitptr *, unsigned int, unsigned long);
558
559unsigned short mad_bit_crc(struct mad_bitptr, unsigned int, unsigned short);
560
561# endif
562
563/* Id: timer.h,v 1.16 2004/01/23 09:41:33 rob Exp */
564
565# ifndef LIBMAD_TIMER_H
566# define LIBMAD_TIMER_H
567
568typedef struct {
569 signed long seconds; /* whole seconds */
570 unsigned long fraction; /* 1/MAD_TIMER_RESOLUTION seconds */
571} mad_timer_t;
572
573extern mad_timer_t const mad_timer_zero;
574
575# define MAD_TIMER_RESOLUTION 352800000UL
576
577enum mad_units {
578 MAD_UNITS_HOURS = -2,
579 MAD_UNITS_MINUTES = -1,
580 MAD_UNITS_SECONDS = 0,
581
582 /* metric units */
583
584 MAD_UNITS_DECISECONDS = 10,
585 MAD_UNITS_CENTISECONDS = 100,
586 MAD_UNITS_MILLISECONDS = 1000,
587
588 /* audio sample units */
589
590 MAD_UNITS_8000_HZ = 8000,
591 MAD_UNITS_11025_HZ = 11025,
592 MAD_UNITS_12000_HZ = 12000,
593
594 MAD_UNITS_16000_HZ = 16000,
595 MAD_UNITS_22050_HZ = 22050,
596 MAD_UNITS_24000_HZ = 24000,
597
598 MAD_UNITS_32000_HZ = 32000,
599 MAD_UNITS_44100_HZ = 44100,
600 MAD_UNITS_48000_HZ = 48000,
601
602 /* video frame/field units */
603
604 MAD_UNITS_24_FPS = 24,
605 MAD_UNITS_25_FPS = 25,
606 MAD_UNITS_30_FPS = 30,
607 MAD_UNITS_48_FPS = 48,
608 MAD_UNITS_50_FPS = 50,
609 MAD_UNITS_60_FPS = 60,
610
611 /* CD audio frames */
612
613 MAD_UNITS_75_FPS = 75,
614
615 /* video drop-frame units */
616
617 MAD_UNITS_23_976_FPS = -24,
618 MAD_UNITS_24_975_FPS = -25,
619 MAD_UNITS_29_97_FPS = -30,
620 MAD_UNITS_47_952_FPS = -48,
621 MAD_UNITS_49_95_FPS = -50,
622 MAD_UNITS_59_94_FPS = -60
623};
624
625# define mad_timer_reset(timer) ((void) (*(timer) = mad_timer_zero))
626
627int mad_timer_compare(mad_timer_t, mad_timer_t);
628
629# define mad_timer_sign(timer) mad_timer_compare((timer), mad_timer_zero)
630
631void mad_timer_negate(mad_timer_t *);
632mad_timer_t mad_timer_abs(mad_timer_t);
633
634void mad_timer_set(mad_timer_t *, unsigned long, unsigned long, unsigned long);
635void mad_timer_add(mad_timer_t *, mad_timer_t);
636void mad_timer_multiply(mad_timer_t *, signed long);
637
638signed long mad_timer_count(mad_timer_t, enum mad_units);
639unsigned long mad_timer_fraction(mad_timer_t, unsigned long);
640void mad_timer_string(mad_timer_t, char *, char const *,
641 enum mad_units, enum mad_units, unsigned long);
642
643# endif
644
645/* Id: stream.h,v 1.20 2004/02/05 09:02:39 rob Exp */
646
647# ifndef LIBMAD_STREAM_H
648# define LIBMAD_STREAM_H
649
650
651# define MAD_BUFFER_GUARD 8
652# define MAD_BUFFER_MDLEN (511 + 2048 + MAD_BUFFER_GUARD)
653
654enum mad_error {
655 MAD_ERROR_NONE = 0x0000, /* no error */
656
657 MAD_ERROR_BUFLEN = 0x0001, /* input buffer too small (or EOF) */
658 MAD_ERROR_BUFPTR = 0x0002, /* invalid (null) buffer pointer */
659
660 MAD_ERROR_NOMEM = 0x0031, /* not enough memory */
661
662 MAD_ERROR_LOSTSYNC = 0x0101, /* lost synchronization */
663 MAD_ERROR_BADLAYER = 0x0102, /* reserved header layer value */
664 MAD_ERROR_BADBITRATE = 0x0103, /* forbidden bitrate value */
665 MAD_ERROR_BADSAMPLERATE = 0x0104, /* reserved sample frequency value */
666 MAD_ERROR_BADEMPHASIS = 0x0105, /* reserved emphasis value */
667
668 MAD_ERROR_BADCRC = 0x0201, /* CRC check failed */
669 MAD_ERROR_BADBITALLOC = 0x0211, /* forbidden bit allocation value */
670 MAD_ERROR_BADSCALEFACTOR = 0x0221, /* bad scalefactor index */
671 MAD_ERROR_BADMODE = 0x0222, /* bad bitrate/mode combination */
672 MAD_ERROR_BADFRAMELEN = 0x0231, /* bad frame length */
673 MAD_ERROR_BADBIGVALUES = 0x0232, /* bad big_values count */
674 MAD_ERROR_BADBLOCKTYPE = 0x0233, /* reserved block_type */
675 MAD_ERROR_BADSCFSI = 0x0234, /* bad scalefactor selection info */
676 MAD_ERROR_BADDATAPTR = 0x0235, /* bad main_data_begin pointer */
677 MAD_ERROR_BADPART3LEN = 0x0236, /* bad audio data length */
678 MAD_ERROR_BADHUFFTABLE = 0x0237, /* bad Huffman table select */
679 MAD_ERROR_BADHUFFDATA = 0x0238, /* Huffman data overrun */
680 MAD_ERROR_BADSTEREO = 0x0239 /* incompatible block_type for JS */
681};
682
683# define MAD_RECOVERABLE(error) ((error) & 0xff00)
684
685struct mad_stream {
686 unsigned char const *buffer; /* input bitstream buffer */
687 unsigned char const *bufend; /* end of buffer */
688 unsigned long skiplen; /* bytes to skip before next frame */
689
690 int sync; /* stream sync found */
691 unsigned long freerate; /* free bitrate (fixed) */
692
693 unsigned char const *this_frame; /* start of current frame */
694 unsigned char const *next_frame; /* start of next frame */
695 struct mad_bitptr ptr; /* current processing bit pointer */
696
697 struct mad_bitptr anc_ptr; /* ancillary bits pointer */
698 unsigned int anc_bitlen; /* number of ancillary bits */
699
700 unsigned char (*main_data)[MAD_BUFFER_MDLEN];
701 /* Layer III main_data() */
702 unsigned int md_len; /* bytes in main_data */
703
704 int options; /* decoding options (see below) */
705 enum mad_error error; /* error code (see above) */
706};
707
708enum {
709 MAD_OPTION_IGNORECRC = 0x0001, /* ignore CRC errors */
710 MAD_OPTION_HALFSAMPLERATE = 0x0002 /* generate PCM at 1/2 sample rate */
711# if 0 /* not yet implemented */
712 MAD_OPTION_LEFTCHANNEL = 0x0010, /* decode left channel only */
713 MAD_OPTION_RIGHTCHANNEL = 0x0020, /* decode right channel only */
714 MAD_OPTION_SINGLECHANNEL = 0x0030 /* combine channels */
715# endif
716};
717
718void mad_stream_init(struct mad_stream *);
719void mad_stream_finish(struct mad_stream *);
720
721# define mad_stream_options(stream, opts) \
722 ((void) ((stream)->options = (opts)))
723
724void mad_stream_buffer(struct mad_stream *,
725 unsigned char const *, unsigned long);
726void mad_stream_skip(struct mad_stream *, unsigned long);
727
728int mad_stream_sync(struct mad_stream *);
729
730char const *mad_stream_errorstr(struct mad_stream const *);
731
732# endif
733
734/* Id: frame.h,v 1.20 2004/01/23 09:41:32 rob Exp */
735
736# ifndef LIBMAD_FRAME_H
737# define LIBMAD_FRAME_H
738
739
740enum mad_layer {
741 MAD_LAYER_I = 1, /* Layer I */
742 MAD_LAYER_II = 2, /* Layer II */
743 MAD_LAYER_III = 3 /* Layer III */
744};
745
746enum mad_mode {
747 MAD_MODE_SINGLE_CHANNEL = 0, /* single channel */
748 MAD_MODE_DUAL_CHANNEL = 1, /* dual channel */
749 MAD_MODE_JOINT_STEREO = 2, /* joint (MS/intensity) stereo */
750 MAD_MODE_STEREO = 3 /* normal LR stereo */
751};
752
753enum mad_emphasis {
754 MAD_EMPHASIS_NONE = 0, /* no emphasis */
755 MAD_EMPHASIS_50_15_US = 1, /* 50/15 microseconds emphasis */
756 MAD_EMPHASIS_CCITT_J_17 = 3, /* CCITT J.17 emphasis */
757 MAD_EMPHASIS_RESERVED = 2 /* unknown emphasis */
758};
759
760struct mad_header {
761 enum mad_layer layer; /* audio layer (1, 2, or 3) */
762 enum mad_mode mode; /* channel mode (see above) */
763 int mode_extension; /* additional mode info */
764 enum mad_emphasis emphasis; /* de-emphasis to use (see above) */
765
766 unsigned long bitrate; /* stream bitrate (bps) */
767 unsigned int samplerate; /* sampling frequency (Hz) */
768
769 unsigned short crc_check; /* frame CRC accumulator */
770 unsigned short crc_target; /* final target CRC checksum */
771
772 int flags; /* flags (see below) */
773 int private_bits; /* private bits (see below) */
774
775 mad_timer_t duration; /* audio playing time of frame */
776};
777
778struct mad_frame {
779 struct mad_header header; /* MPEG audio header */
780 int options; /* decoding options (from stream) */
781
782 mad_fixed_t (*sbsample)[2][36][32]; /* synthesis subband filter samples */
783 mad_fixed_t (*sbsample_prev)[2][36][32]; /* synthesis subband filter samples
784 from previous frame only needed
785 when synthesis is on cop */
786
787 mad_fixed_t (*overlap)[2][32][18]; /* Layer III block overlap data */
788};
789
790# define MAD_NCHANNELS(header) ((header)->mode ? 2 : 1)
791# define MAD_NSBSAMPLES(header) \
792 ((header)->layer == MAD_LAYER_I ? 12 : \
793 (((header)->layer == MAD_LAYER_III && \
794 ((header)->flags & MAD_FLAG_LSF_EXT)) ? 18 : 36))
795
796enum {
797 MAD_FLAG_NPRIVATE_III = 0x0007, /* number of Layer III private bits */
798 MAD_FLAG_INCOMPLETE = 0x0008, /* header but not data is decoded */
799
800 MAD_FLAG_PROTECTION = 0x0010, /* frame has CRC protection */
801 MAD_FLAG_COPYRIGHT = 0x0020, /* frame is copyright */
802 MAD_FLAG_ORIGINAL = 0x0040, /* frame is original (else copy) */
803 MAD_FLAG_PADDING = 0x0080, /* frame has additional slot */
804
805 MAD_FLAG_I_STEREO = 0x0100, /* uses intensity joint stereo */
806 MAD_FLAG_MS_STEREO = 0x0200, /* uses middle/side joint stereo */
807 MAD_FLAG_FREEFORMAT = 0x0400, /* uses free format bitrate */
808
809 MAD_FLAG_LSF_EXT = 0x1000, /* lower sampling freq. extension */
810 MAD_FLAG_MC_EXT = 0x2000, /* multichannel audio extension */
811 MAD_FLAG_MPEG_2_5_EXT = 0x4000 /* MPEG 2.5 (unofficial) extension */
812};
813
814enum {
815 MAD_PRIVATE_HEADER = 0x0100, /* header private bit */
816 MAD_PRIVATE_III = 0x001f /* Layer III private bits (up to 5) */
817};
818
819void mad_header_init(struct mad_header *);
820
821# define mad_header_finish(header) /* nothing */
822
823int mad_header_decode(struct mad_header *, struct mad_stream *);
824
825void mad_frame_init(struct mad_frame *);
826void mad_frame_finish(struct mad_frame *);
827
828int mad_frame_decode(struct mad_frame *, struct mad_stream *);
829
830void mad_frame_mute(struct mad_frame *);
831
832# endif
833
834/* Id: synth.h,v 1.15 2004/01/23 09:41:33 rob Exp */
835
836# ifndef LIBMAD_SYNTH_H
837# define LIBMAD_SYNTH_H
838
839
840struct mad_pcm {
841 unsigned int samplerate; /* sampling frequency (Hz) */
842 unsigned short channels; /* number of channels */
843 unsigned short length; /* number of samples per channel */
844 mad_fixed_t samples[2][1152]; /* PCM output samples [ch][sample] */
845};
846
847struct mad_synth {
848 mad_fixed_t filter[2][2][2][16][8]; /* polyphase filterbank outputs */
849 /* [ch][eo][peo][s][v] */
850
851 unsigned int phase; /* current processing phase */
852
853 struct mad_pcm pcm; /* PCM output */
854};
855
856/* single channel PCM selector */
857enum {
858 MAD_PCM_CHANNEL_SINGLE = 0
859};
860
861/* dual channel PCM selector */
862enum {
863 MAD_PCM_CHANNEL_DUAL_1 = 0,
864 MAD_PCM_CHANNEL_DUAL_2 = 1
865};
866
867/* stereo PCM selector */
868enum {
869 MAD_PCM_CHANNEL_STEREO_LEFT = 0,
870 MAD_PCM_CHANNEL_STEREO_RIGHT = 1
871};
872
873void mad_synth_init(struct mad_synth *);
874
875# define mad_synth_finish(synth) /* nothing */
876
877void mad_synth_mute(struct mad_synth *);
878
879void mad_synth_frame(struct mad_synth *, struct mad_frame const *);
880
881# endif
882
883/* Id: decoder.h,v 1.17 2004/01/23 09:41:32 rob Exp */
884
885# ifndef LIBMAD_DECODER_H
886# define LIBMAD_DECODER_H
887
888
889enum mad_decoder_mode {
890 MAD_DECODER_MODE_SYNC = 0,
891 MAD_DECODER_MODE_ASYNC
892};
893
894enum mad_flow {
895 MAD_FLOW_CONTINUE = 0x0000, /* continue normally */
896 MAD_FLOW_STOP = 0x0010, /* stop decoding normally */
897 MAD_FLOW_BREAK = 0x0011, /* stop decoding and signal an error */
898 MAD_FLOW_IGNORE = 0x0020 /* ignore the current frame */
899};
900
901struct mad_decoder {
902 enum mad_decoder_mode mode;
903
904 int options;
905
906 struct {
907 long pid;
908 int in;
909 int out;
910 } async;
911
912 struct {
913 struct mad_stream stream;
914 struct mad_frame frame;
915 struct mad_synth synth;
916 } *sync;
917
918 void *cb_data;
919
920 enum mad_flow (*input_func)(void *, struct mad_stream *);
921 enum mad_flow (*header_func)(void *, struct mad_header const *);
922 enum mad_flow (*filter_func)(void *,
923 struct mad_stream const *, struct mad_frame *);
924 enum mad_flow (*output_func)(void *,
925 struct mad_header const *, struct mad_pcm *);
926 enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
927 enum mad_flow (*message_func)(void *, void *, unsigned int *);
928};
929
930void mad_decoder_init(struct mad_decoder *, void *,
931 enum mad_flow (*)(void *, struct mad_stream *),
932 enum mad_flow (*)(void *, struct mad_header const *),
933 enum mad_flow (*)(void *,
934 struct mad_stream const *,
935 struct mad_frame *),
936 enum mad_flow (*)(void *,
937 struct mad_header const *,
938 struct mad_pcm *),
939 enum mad_flow (*)(void *,
940 struct mad_stream *,
941 struct mad_frame *),
942 enum mad_flow (*)(void *, void *, unsigned int *));
943int mad_decoder_finish(struct mad_decoder *);
944
945# define mad_decoder_options(decoder, opts) \
946 ((void) ((decoder)->options = (opts)))
947
948int mad_decoder_run(struct mad_decoder *, enum mad_decoder_mode);
949int mad_decoder_message(struct mad_decoder *, void *, unsigned int *);
950
951# endif
952
953# ifdef __cplusplus
954}
955# endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-01 17:29:46 +0000