1 files changed, 255 insertions, 121 deletions

diff --git a/core/multimedia/opieplayer/libmad/mad.h b/core/multimedia/opieplayer/libmad/mad.h
index 9db9da3..9ef6cc8 100644
--- a/core/multimedia/opieplayer/libmad/mad.h
+++ b/core/multimedia/opieplayer/libmad/mad.h
@@ -1,9 +1,9 @@
 /*
- * mad - MPEG audio decoder
- * Copyright (C) 2000-2001 Robert Leslie
+ * libmad - MPEG audio decoder library
+ * Copyright (C) 2000-2004 Underbit Technologies, Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
@@ -14,49 +14,58 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  * If you would like to negotiate alternate licensing terms, you may do
- * so by contacting the author: Robert Leslie <rob@mars.org>
+ * so by contacting: Underbit Technologies, Inc. <info@underbit.com>
  */
 
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+# define FPM_INTEL
+
+
+
 # define SIZEOF_INT 4
 # define SIZEOF_LONG 4
 # define SIZEOF_LONG_LONG 8
 
-/* Id: version.h,v 1.16 2001/04/05 04:57:11 rob Exp */
+
+/* Id: version.h,v 1.26 2004/01/23 09:41:33 rob Exp */
 
 # ifndef LIBMAD_VERSION_H
 # define LIBMAD_VERSION_H
 
         # define MAD_VERSION_MAJOR0
-        # define MAD_VERSION_MINOR13
-        # define MAD_VERSION_PATCH0
+        # define MAD_VERSION_MINOR15
+        # define MAD_VERSION_PATCH1
         # define MAD_VERSION_EXTRA" (beta)"
 
         # define MAD_VERSION_STRINGIZE(str)#str
         # define MAD_VERSION_STRING(num)MAD_VERSION_STRINGIZE(num)
 
         # define MAD_VERSION    MAD_VERSION_STRING(MAD_VERSION_MAJOR) "."  \
                                 MAD_VERSION_STRING(MAD_VERSION_MINOR) "."  \
                                 MAD_VERSION_STRING(MAD_VERSION_PATCH)  \
                                 MAD_VERSION_EXTRA
 
-        # define MAD_PUBLISHYEAR"2000-2001"
-        # define MAD_AUTHOR     "Robert Leslie"
-        # define MAD_EMAIL      "rob@mars.org"
+        # define MAD_PUBLISHYEAR"2000-2004"
+        # define MAD_AUTHOR     "Underbit Technologies, Inc."
+        # define MAD_EMAIL      "info@underbit.com"
 
 extern char const mad_version[];
 extern char const mad_copyright[];
 extern char const mad_author[];
 extern char const mad_build[];
 
 # endif
 
-/* Id: fixed.h,v 1.23 2001/04/05 04:57:11 rob Exp */
+/* Id: fixed.h,v 1.38 2004/02/17 02:02:03 rob Exp */
 
 # ifndef LIBMAD_FIXED_H
 # define LIBMAD_FIXED_H
 
 # if SIZEOF_INT >= 4
 typedef   signed int mad_fixed_t;
@@ -67,12 +76,24 @@ typedef unsigned int mad_fixed64lo_t;
 typedef   signed long mad_fixed_t;
 
 typedef   signed long mad_fixed64hi_t;
 typedef unsigned long mad_fixed64lo_t;
 # endif
 
+# if defined(_MSC_VER)
+#  define mad_fixed64_t  signed __int64
+# elif 1 || defined(__GNUC__)
+#  define mad_fixed64_t  signed long long
+# endif
+
+# if defined(FPM_FLOAT)
+typedef double mad_sample_t;
+# else
+typedef mad_fixed_t mad_sample_t;
+# endif
+
 /*
  * Fixed-point format: 0xABBBBBBB
  * A == whole part      (sign + 3 bits)
  * B == fractional part (28 bits)
  *
  * Values are signed two's complement, so the effective range is:
@@ -127,65 +148,99 @@ typedef unsigned long mad_fixed64lo_t;
 
         # define mad_f_fromint(x)((x) << MAD_F_FRACBITS)
 
         # define mad_f_add(x, y)((x) + (y))
         # define mad_f_sub(x, y)((x) - (y))
 
-# if defined(FPM_64BIT)
+# if defined(FPM_FLOAT)
+#  error "FPM_FLOAT not yet supported"
+
+#  undef MAD_F
+        #  define MAD_F(x)      mad_f_todouble(x)
+
+        #  define mad_f_mul(x, y)((x) * (y))
+#  define mad_f_scale64
+
+#  undef ASO_ZEROCHECK
+
+# elif defined(FPM_64BIT)
 
 /*
- * This version should be the most accurate if 64-bit (long long) types are
- * supported by the compiler, although it may not be the most efficient.
+ * This version should be the most accurate if 64-bit types are supported by
+ * the compiler, although it may not be the most efficient.
  */
 #  if defined(OPT_ACCURACY)
 #   define mad_f_mul(x, y)  \
     ((mad_fixed_t)  \
-     ((((signed long long) (x) * (y)) +  \
+     ((((mad_fixed64_t) (x) * (y)) +  \
        (1L << (MAD_F_SCALEBITS - 1))) >> MAD_F_SCALEBITS))
 #  else
 #   define mad_f_mul(x, y)  \
-    ((mad_fixed_t) (((signed long long) (x) * (y)) >> MAD_F_SCALEBITS))
+    ((mad_fixed_t) (((mad_fixed64_t) (x) * (y)) >> MAD_F_SCALEBITS))
 #  endif
 
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 
 /* --- Intel --------------------------------------------------------------- */
 
 # elif defined(FPM_INTEL)
 
+#  if defined(_MSC_VER)
+#   pragma warning(push)
+#   pragma warning(disable: 4035)  /* no return value */
+static __forceinline
+mad_fixed_t mad_f_mul_inline(mad_fixed_t x, mad_fixed_t y)
+{
+  enum {
+    fracbits = MAD_F_FRACBITS
+  };
+
+  __asm {
+    mov eax, x
+    imul y
+    shrd eax, edx, fracbits
+  }
+
+  /* implicit return of eax */
+}
+#   pragma warning(pop)
+
+        #   define mad_f_mul    mad_f_mul_inline
+#   define mad_f_scale64
+#  else
 /*
  * This Intel version is fast and accurate; the disposition of the least
  * significant bit depends on OPT_ACCURACY via mad_f_scale64().
  */
-#  define MAD_F_MLX(hi, lo, x, y)  \
+#   define MAD_F_MLX(hi, lo, x, y)  \
     asm ("imull %3"  \
          : "=a" (lo), "=d" (hi)  \
          : "%a" (x), "rm" (y)  \
          : "cc")
 
-#  if defined(OPT_ACCURACY)
+#   if defined(OPT_ACCURACY)
 /*
  * This gives best accuracy but is not very fast.
  */
-#   define MAD_F_MLA(hi, lo, x, y)  \
+#    define MAD_F_MLA(hi, lo, x, y)  \
     ({ mad_fixed64hi_t __hi;  \
        mad_fixed64lo_t __lo;  \
        MAD_F_MLX(__hi, __lo, (x), (y));  \
        asm ("addl %2,%0\n\t"  \
             "adcl %3,%1"  \
             : "=rm" (lo), "=rm" (hi)  \
             : "r" (__lo), "r" (__hi), "0" (lo), "1" (hi)  \
             : "cc");  \
     })
-#  endif  /* OPT_ACCURACY */
+#   endif  /* OPT_ACCURACY */
 
-#  if defined(OPT_ACCURACY)
+#   if defined(OPT_ACCURACY)
 /*
  * Surprisingly, this is faster than SHRD followed by ADC.
  */
-#   define mad_f_scale64(hi, lo)  \
+#    define mad_f_scale64(hi, lo)  \
     ({ mad_fixed64hi_t __hi_;  \
        mad_fixed64lo_t __lo_;  \
        mad_fixed_t __result;  \
        asm ("addl %4,%2\n\t"  \
             "adcl %5,%3"  \
             : "=rm" (__lo_), "=rm" (__hi_)  \
@@ -195,41 +250,53 @@ typedef unsigned long mad_fixed64lo_t;
        asm ("shrdl %3,%2,%1"  \
             : "=rm" (__result)  \
             : "0" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS)  \
             : "cc");  \
        __result;  \
     })
-#  else
-#   define mad_f_scale64(hi, lo)  \
+#   elif defined(OPT_INTEL)
+/*
+ * Alternate Intel scaling that may or may not perform better.
+ */
+#    define mad_f_scale64(hi, lo)  \
+    ({ mad_fixed_t __result;  \
+       asm ("shrl %3,%1\n\t"  \
+            "shll %4,%2\n\t"  \
+            "orl %2,%1"  \
+            : "=rm" (__result)  \
+            : "0" (lo), "r" (hi),  \
+              "I" (MAD_F_SCALEBITS), "I" (32 - MAD_F_SCALEBITS)  \
+            : "cc");  \
+       __result;  \
+    })
+#   else
+#    define mad_f_scale64(hi, lo)  \
     ({ mad_fixed_t __result;  \
        asm ("shrdl %3,%2,%1"  \
             : "=rm" (__result)  \
             : "0" (lo), "r" (hi), "I" (MAD_F_SCALEBITS)  \
             : "cc");  \
        __result;  \
     })
-#  endif  /* OPT_ACCURACY */
+#   endif  /* OPT_ACCURACY */
 
-#  define MAD_F_SCALEBITS  MAD_F_FRACBITS
+#   define MAD_F_SCALEBITS  MAD_F_FRACBITS
+#  endif
 
 /* --- ARM ----------------------------------------------------------------- */
 
 # elif defined(FPM_ARM)
 
 /* 
  * This ARM V4 version is as accurate as FPM_64BIT but much faster. The
  * least significant bit is properly rounded at no CPU cycle cost!
  */
 # if 1
 /*
- * There's a bug somewhere, possibly in the compiler, that sometimes makes
- * this necessary instead of the default implementation via MAD_F_MLX and
- * mad_f_scale64. It may be related to the use (or lack) of
- * -finline-functions and/or -fstrength-reduce.
- *
- * This is also apparently faster than MAD_F_MLX/mad_f_scale64.
+ * This is faster than the default implementation via MAD_F_MLX() and
+ * mad_f_scale64().
  */
 #  define mad_f_mul(x, y)  \
     ({ mad_fixed64hi_t __hi;  \
        mad_fixed64lo_t __lo;  \
        mad_fixed_t __result;  \
                asm ("smull%0, %1, %3, %4\n\t"  \
@@ -250,17 +317,24 @@ typedef unsigned long mad_fixed64lo_t;
 
 #  define MAD_F_MLA(hi, lo, x, y)  \
             asm ("smlal%0, %1, %2, %3"  \
          : "+r" (lo), "+r" (hi)  \
          : "%r" (x), "r" (y))
 
+#  define MAD_F_MLN(hi, lo)  \
+            asm ("rsbs%0, %2, #0\n\t"  \
+                 "rsc%1, %3, #0"  \
+         : "=r" (lo), "=r" (hi)  \
+         : "0" (lo), "1" (hi)  \
+         : "cc")
+
 #  define mad_f_scale64(hi, lo)  \
     ({ mad_fixed_t __result;  \
                asm ("movs%0, %1, lsr %3\n\t"  \
                     "adc%0, %0, %2, lsl %4"  \
-            : "=r" (__result)  \
+            : "=&r" (__result)  \
             : "r" (lo), "r" (hi),  \
               "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  \
             : "cc");  \
        __result;  \
     })
 
@@ -322,64 +396,75 @@ typedef unsigned long mad_fixed64lo_t;
 
 /* --- PowerPC ------------------------------------------------------------- */
 
 # elif defined(FPM_PPC)
 
 /*
- * This PowerPC version is tuned for the 4xx embedded processors. It is
- * effectively a tuned version of FPM_64BIT. It is a little faster and just
- * as accurate. The disposition of the least significant bit depends on
- * OPT_ACCURACY via mad_f_scale64().
+ * This PowerPC version is fast and accurate; the disposition of the least
+ * significant bit depends on OPT_ACCURACY via mad_f_scale64().
  */
 #  define MAD_F_MLX(hi, lo, x, y)  \
-    asm ("mulhw %1, %2, %3\n\t"  \
-         "mullw %0, %2, %3"  \
-         : "=&r" (lo), "=&r" (hi)  \
-         : "%r" (x), "r" (y))
+    do {  \
+      asm ("mullw %0,%1,%2"  \
+           : "=r" (lo)  \
+           : "%r" (x), "r" (y));  \
+      asm ("mulhw %0,%1,%2"  \
+           : "=r" (hi)  \
+           : "%r" (x), "r" (y));  \
+    }  \
+    while (0)
 
-#  define MAD_F_MLA(hi, lo, x, y)  \
+#  if defined(OPT_ACCURACY)
+/*
+ * This gives best accuracy but is not very fast.
+ */
+#   define MAD_F_MLA(hi, lo, x, y)  \
     ({ mad_fixed64hi_t __hi;  \
        mad_fixed64lo_t __lo;  \
        MAD_F_MLX(__hi, __lo, (x), (y));  \
-       asm ("addc %0, %2, %3\n\t"  \
-            "adde %1, %4, %5"  \
+       asm ("addc %0,%2,%3\n\t"  \
+            "adde %1,%4,%5"  \
             : "=r" (lo), "=r" (hi)  \
-            : "%r" (__lo), "0" (lo), "%r" (__hi), "1" (hi));  \
+            : "%r" (lo), "r" (__lo),  \
+              "%r" (hi), "r" (__hi)  \
+            : "xer");  \
     })
+#  endif
 
 #  if defined(OPT_ACCURACY)
 /*
- * This is accurate and ~2 - 2.5 times slower than the unrounded version.
- *
- * The __volatile__ improves the generated code by another 5% (fewer spills
- * to memory); eventually they should be removed.
+ * This is slower than the truncating version below it.
  */
 #   define mad_f_scale64(hi, lo)  \
-    ({ mad_fixed_t __result;  \
-       mad_fixed64hi_t __hi_;  \
-       mad_fixed64lo_t __lo_;  \
-       asm __volatile__ ("addc %0, %2, %4\n\t"  \
-                         "addze %1, %3"  \
-            : "=r" (__lo_), "=r" (__hi_)  \
-            : "r" (lo), "r" (hi), "r" (1 << (MAD_F_SCALEBITS - 1)));  \
-       asm __volatile__ ("rlwinm %0, %2,32-%3,0,%3-1\n\t"  \
-                         "rlwimi %0, %1,32-%3,%3,31"  \
-            : "=&r" (__result)  \
-            : "r" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS));  \
-            __result;  \
+    ({ mad_fixed_t __result, __round;  \
+       asm ("rotrwi %0,%1,%2"  \
+            : "=r" (__result)  \
+            : "r" (lo), "i" (MAD_F_SCALEBITS));  \
+       asm ("extrwi %0,%1,1,0"  \
+            : "=r" (__round)  \
+            : "r" (__result));  \
+       asm ("insrwi %0,%1,%2,0"  \
+            : "+r" (__result)  \
+            : "r" (hi), "i" (MAD_F_SCALEBITS));  \
+       asm ("add %0,%1,%2"  \
+            : "=r" (__result)  \
+            : "%r" (__result), "r" (__round));  \
+       __result;  \
     })
 #  else
 #   define mad_f_scale64(hi, lo)  \
     ({ mad_fixed_t __result;  \
-       asm ("rlwinm %0, %2,32-%3,0,%3-1\n\t"  \
-            "rlwimi %0, %1,32-%3,%3,31"  \
+       asm ("rotrwi %0,%1,%2"  \
             : "=r" (__result)  \
-            : "r" (lo), "r" (hi), "I" (MAD_F_SCALEBITS));  \
-            __result;  \
+            : "r" (lo), "i" (MAD_F_SCALEBITS));  \
+       asm ("insrwi %0,%1,%2,0"  \
+            : "+r" (__result)  \
+            : "r" (hi), "i" (MAD_F_SCALEBITS));  \
+       __result;  \
     })
-#  endif  /* OPT_ACCURACY */
+#  endif
 
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 
 /* --- Default ------------------------------------------------------------- */
 
 # elif defined(FPM_DEFAULT)
@@ -390,42 +475,51 @@ typedef unsigned long mad_fixed64lo_t;
  * should be taken when ordering operands.
  *
  * The scale factors are constant as this is not used with SSO.
  *
  * Pre-rounding is required to stay within the limits of compliance.
  */
-        #  define mad_f_mul(x, y)((((x) + (1L << 11)) >> 12) *  \
+#  if defined(OPT_SPEED)
+        #   define mad_f_mul(x, y)(((x) >> 12) * ((y) >> 16))
+#  else
+        #   define mad_f_mul(x, y)((((x) + (1L << 11)) >> 12) *  \
                                  (((y) + (1L << 15)) >> 16))
+#  endif
 
 /* ------------------------------------------------------------------------- */
 
 # else
 #  error "no FPM selected"
 # endif
 
 /* default implementations */
 
 # if !defined(mad_f_mul)
 #  define mad_f_mul(x, y)  \
-    ({ mad_fixed64hi_t __hi;  \
-       mad_fixed64lo_t __lo;  \
+    ({ register mad_fixed64hi_t __hi;  \
+       register mad_fixed64lo_t __lo;  \
        MAD_F_MLX(__hi, __lo, (x), (y));  \
        mad_f_scale64(__hi, __lo);  \
     })
 # endif
 
 # if !defined(MAD_F_MLA)
         #  define MAD_F_ML0(hi, lo, x, y)((lo)  = mad_f_mul((x), (y)))
         #  define MAD_F_MLA(hi, lo, x, y)((lo) += mad_f_mul((x), (y)))
+        #  define MAD_F_MLN(hi, lo)     ((lo)  = -(lo))
         #  define MAD_F_MLZ(hi, lo)     ((void) (hi), (mad_fixed_t) (lo))
 # endif
 
 # if !defined(MAD_F_ML0)
         #  define MAD_F_ML0(hi, lo, x, y)MAD_F_MLX((hi), (lo), (x), (y))
 # endif
 
+# if !defined(MAD_F_MLN)
+        #  define MAD_F_MLN(hi, lo)     ((hi) = ((lo) = -(lo)) ? ~(hi) : -(hi))
+# endif
+
 # if !defined(MAD_F_MLZ)
         #  define MAD_F_MLZ(hi, lo)     mad_f_scale64((hi), (lo))
 # endif
 
 # if !defined(mad_f_scale64)
 #  if defined(OPT_ACCURACY)
@@ -439,19 +533,20 @@ typedef unsigned long mad_fixed64lo_t;
      (((hi) << (32 - MAD_F_SCALEBITS)) |  \
       ((lo) >> MAD_F_SCALEBITS)))
 #  endif
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 # endif
 
-/* miscellaneous C routines */
+/* C routines */
 
 mad_fixed_t mad_f_abs(mad_fixed_t);
+mad_fixed_t mad_f_div(mad_fixed_t, mad_fixed_t);
 
 # endif
 
-/* Id: bit.h,v 1.7 2001/04/05 04:57:11 rob Exp */
+/* Id: bit.h,v 1.12 2004/01/23 09:41:32 rob Exp */
 
 # ifndef LIBMAD_BIT_H
 # define LIBMAD_BIT_H
 
 struct mad_bitptr {
   unsigned char const *byte;
@@ -474,13 +569,13 @@ unsigned long mad_bit_read(struct mad_bitptr *, unsigned int);
 void mad_bit_write(struct mad_bitptr *, unsigned int, unsigned long);
 
 unsigned short mad_bit_crc(struct mad_bitptr, unsigned int, unsigned short);
 
 # endif
 
-/* Id: timer.h,v 1.10 2001/04/05 04:57:11 rob Exp */
+/* Id: timer.h,v 1.16 2004/01/23 09:41:33 rob Exp */
 
 # ifndef LIBMAD_TIMER_H
 # define LIBMAD_TIMER_H
 
 typedef struct {
           signed long seconds;  /* whole seconds */
@@ -536,13 +631,13 @@ enum mad_units {
           MAD_UNITS_29_97_FPS =   -30,
           MAD_UNITS_47_952_FPS =   -48,
           MAD_UNITS_49_95_FPS =   -50,
           MAD_UNITS_59_94_FPS =   -60
 };
 
-        # define mad_timer_reset(timer)(*(timer) = mad_timer_zero)
+        # define mad_timer_reset(timer)((void) (*(timer) = mad_timer_zero))
 
 int mad_timer_compare(mad_timer_t, mad_timer_t);
 
         # define mad_timer_sign(timer)mad_timer_compare((timer), mad_timer_zero)
 
 void mad_timer_negate(mad_timer_t *);
@@ -556,21 +651,24 @@ signed long mad_timer_count(mad_timer_t, enum mad_units);
 unsigned long mad_timer_fraction(mad_timer_t, unsigned long);
 void mad_timer_string(mad_timer_t, char *, char const *,
                       enum mad_units, enum mad_units, unsigned long);
 
 # endif
 
-/* Id: stream.h,v 1.12 2001/04/10 05:18:21 rob Exp */
+/* Id: stream.h,v 1.20 2004/02/05 09:02:39 rob Exp */
 
 # ifndef LIBMAD_STREAM_H
 # define LIBMAD_STREAM_H
 
+
         # define MAD_BUFFER_GUARD8
         # define MAD_BUFFER_MDLEN(511 + 2048 + MAD_BUFFER_GUARD)
 
 enum mad_error {
+          MAD_ERROR_NONE           = 0x0000,/* no error */
+
           MAD_ERROR_BUFLEN         = 0x0001,/* input buffer too small (or EOF) */
           MAD_ERROR_BUFPTR         = 0x0002,/* invalid (null) buffer pointer */
 
           MAD_ERROR_NOMEM          = 0x0031,/* not enough memory */
 
           MAD_ERROR_LOSTSYNC       = 0x0101,/* lost synchronization */
@@ -579,12 +677,13 @@ enum mad_error {
           MAD_ERROR_BADSAMPLERATE  = 0x0104,/* reserved sample frequency value */
           MAD_ERROR_BADEMPHASIS            = 0x0105,/* reserved emphasis value */
 
           MAD_ERROR_BADCRC         = 0x0201,/* CRC check failed */
           MAD_ERROR_BADBITALLOC            = 0x0211,/* forbidden bit allocation value */
           MAD_ERROR_BADSCALEFACTOR = 0x0221,/* bad scalefactor index */
+          MAD_ERROR_BADMODE        = 0x0222,/* bad bitrate/mode combination */
           MAD_ERROR_BADFRAMELEN            = 0x0231,/* bad frame length */
           MAD_ERROR_BADBIGVALUES   = 0x0232,/* bad big_values count */
           MAD_ERROR_BADBLOCKTYPE   = 0x0233,/* reserved block_type */
           MAD_ERROR_BADSCFSI       = 0x0234,/* bad scalefactor selection info */
           MAD_ERROR_BADDATAPTR     = 0x0235,/* bad main_data_begin pointer */
           MAD_ERROR_BADPART3LEN            = 0x0236,/* bad audio data length */
@@ -617,38 +716,42 @@ struct mad_stream {
           int options;                  /* decoding options (see below) */
           enum mad_error error;                 /* error code (see above) */
 };
 
 enum {
           MAD_OPTION_IGNORECRC      = 0x0001,/* ignore CRC errors */
-          MAD_OPTION_HALFSAMPLERATE = 0x0002,/* generate PCM at 1/2 sample rate */
+          MAD_OPTION_HALFSAMPLERATE = 0x0002/* generate PCM at 1/2 sample rate */
 # if 0  /* not yet implemented */
           MAD_OPTION_LEFTCHANNEL    = 0x0010,/* decode left channel only */
           MAD_OPTION_RIGHTCHANNEL   = 0x0020,/* decode right channel only */
-          MAD_OPTION_SINGLECHANNEL  = 0x0030,/* combine channels */
+          MAD_OPTION_SINGLECHANNEL  = 0x0030/* combine channels */
 # endif
 };
 
 void mad_stream_init(struct mad_stream *);
 void mad_stream_finish(struct mad_stream *);
 
-# define mad_stream_options(stream, opts)  ((stream)->options = (opts))
+# define mad_stream_options(stream, opts)  \
+    ((void) ((stream)->options = (opts)))
 
 void mad_stream_buffer(struct mad_stream *,
                        unsigned char const *, unsigned long);
 void mad_stream_skip(struct mad_stream *, unsigned long);
 
 int mad_stream_sync(struct mad_stream *);
 
+char const *mad_stream_errorstr(struct mad_stream const *);
+
 # endif
 
-/* Id: frame.h,v 1.13 2001/04/05 04:57:11 rob Exp */
+/* Id: frame.h,v 1.20 2004/01/23 09:41:32 rob Exp */
 
 # ifndef LIBMAD_FRAME_H
 # define LIBMAD_FRAME_H
 
+
 enum mad_layer {
           MAD_LAYER_I   = 1,            /* Layer I */
           MAD_LAYER_II  = 2,            /* Layer II */
           MAD_LAYER_III = 3             /* Layer III */
 };
 
@@ -659,33 +762,36 @@ enum mad_mode {
           MAD_MODE_STEREO         = 3   /* normal LR stereo */
 };
 
 enum mad_emphasis {
           MAD_EMPHASIS_NONE       = 0,  /* no emphasis */
           MAD_EMPHASIS_50_15_US           = 1,  /* 50/15 microseconds emphasis */
-          MAD_EMPHASIS_CCITT_J_17 = 3   /* CCITT J.17 emphasis */
+          MAD_EMPHASIS_CCITT_J_17 = 3,  /* CCITT J.17 emphasis */
+          MAD_EMPHASIS_RESERVED   = 2   /* unknown emphasis */
 };
 
-struct mad_frame {
-  struct mad_header {
-            enum mad_layer layer;       /* audio layer (1, 2, or 3) */
-            enum mad_mode mode;                 /* channel mode (see above) */
-            int mode_extension;                 /* additional mode info */
-            enum mad_emphasis emphasis;         /* de-emphasis to use (see above) */
+struct mad_header {
+          enum mad_layer layer;                 /* audio layer (1, 2, or 3) */
+          enum mad_mode mode;           /* channel mode (see above) */
+          int mode_extension;           /* additional mode info */
+          enum mad_emphasis emphasis;   /* de-emphasis to use (see above) */
+
+          unsigned long bitrate;        /* stream bitrate (bps) */
+          unsigned int samplerate;      /* sampling frequency (Hz) */
 
-            unsigned long bitrate;      /* stream bitrate (bps) */
-            unsigned int samplerate;    /* sampling frequency (Hz) */
+          unsigned short crc_check;     /* frame CRC accumulator */
+          unsigned short crc_target;    /* final target CRC checksum */
 
-            unsigned short crc_check;   /* frame CRC accumulator */
-            unsigned short crc_target;  /* final target CRC checksum */
+          int flags;                    /* flags (see below) */
+          int private_bits;             /* private bits (see below) */
 
-            int flags;                  /* flags (see below) */
-            int private_bits;           /* private bits (see below) */
+          mad_timer_t duration;                 /* audio playing time of frame */
+};
 
-            mad_timer_t duration;       /* audio playing time of frame */
-  } header;
+struct mad_frame {
+          struct mad_header header;     /* MPEG audio header */
 
           int options;                  /* decoding options (from stream) */
 
           mad_fixed_t sbsample[2][36][32];/* synthesis subband filter samples */
           mad_fixed_t (*overlap)[2][32][18];/* Layer III block overlap data */
 };
@@ -694,32 +800,32 @@ struct mad_frame {
 # define MAD_NSBSAMPLES(header)  \
   ((header)->layer == MAD_LAYER_I ? 12 :  \
    (((header)->layer == MAD_LAYER_III &&  \
      ((header)->flags & MAD_FLAG_LSF_EXT)) ? 18 : 36))
 
 enum {
-          MAD_FLAG_NPRIVATE_III           = 0x0007,/* number of Layer III private bits */
-          MAD_FLAG_INCOMPLETE     = 0x0008,/* header but not data is decoded */
+          MAD_FLAG_NPRIVATE_III         = 0x0007,/* number of Layer III private bits */
+          MAD_FLAG_INCOMPLETE   = 0x0008,/* header but not data is decoded */
 
-          MAD_FLAG_PROTECTION     = 0x0010,/* frame has CRC protection */
-          MAD_FLAG_COPYRIGHT      = 0x0020,/* frame is copyright */
-          MAD_FLAG_ORIGINAL       = 0x0040,/* frame is original (else copy) */
-          MAD_FLAG_PADDING        = 0x0080,/* frame has additional slot */
+          MAD_FLAG_PROTECTION   = 0x0010,/* frame has CRC protection */
+          MAD_FLAG_COPYRIGHT    = 0x0020,/* frame is copyright */
+          MAD_FLAG_ORIGINAL     = 0x0040,/* frame is original (else copy) */
+          MAD_FLAG_PADDING      = 0x0080,/* frame has additional slot */
 
-          MAD_FLAG_I_STEREO       = 0x0100,/* uses intensity joint stereo */
-          MAD_FLAG_MS_STEREO      = 0x0200,/* uses middle/side joint stereo */
-          MAD_FLAG_FREEFORMAT     = 0x0400,/* uses free format bitrate */
+          MAD_FLAG_I_STEREO     = 0x0100,/* uses intensity joint stereo */
+          MAD_FLAG_MS_STEREO    = 0x0200,/* uses middle/side joint stereo */
+          MAD_FLAG_FREEFORMAT   = 0x0400,/* uses free format bitrate */
 
-          MAD_FLAG_LSF_EXT        = 0x1000,/* lower sampling freq. extension */
-          MAD_FLAG_MC_EXT         = 0x2000,/* multichannel audio extension */
-          MAD_FLAG_MPEG_2_5_EXT           = 0x4000/* MPEG 2.5 (unofficial) extension */
+          MAD_FLAG_LSF_EXT      = 0x1000,/* lower sampling freq. extension */
+          MAD_FLAG_MC_EXT       = 0x2000,/* multichannel audio extension */
+          MAD_FLAG_MPEG_2_5_EXT         = 0x4000/* MPEG 2.5 (unofficial) extension */
 };
 
 enum {
-          MAD_PRIVATE_HEADER      = 0x0100,/* header private bit */
-          MAD_PRIVATE_III         = 0x001f/* Layer III private bits (up to 5) */
+          MAD_PRIVATE_HEADER    = 0x0100,/* header private bit */
+          MAD_PRIVATE_III       = 0x001f/* Layer III private bits (up to 5) */
 };
 
 void mad_header_init(struct mad_header *);
 
 # define mad_header_finish(header)  /* nothing */
 
@@ -731,56 +837,77 @@ void mad_frame_finish(struct mad_frame *);
 int mad_frame_decode(struct mad_frame *, struct mad_stream *);
 
 void mad_frame_mute(struct mad_frame *);
 
 # endif
 
-/* Id: synth.h,v 1.8 2001/04/05 04:57:11 rob Exp */
+/* Id: synth.h,v 1.15 2004/01/23 09:41:33 rob Exp */
 
 # ifndef LIBMAD_SYNTH_H
 # define LIBMAD_SYNTH_H
 
+
+struct mad_pcm {
+          unsigned int samplerate;      /* sampling frequency (Hz) */
+          unsigned short channels;      /* number of channels */
+          unsigned short length;        /* number of samples per channel */
+          mad_fixed_t samples[2][1152];         /* PCM output samples [ch][sample] */
+};
+
 struct mad_synth {
           mad_fixed_t filter[2][2][2][16][8];/* polyphase filterbank outputs */
                                         /* [ch][eo][peo][s][v] */
 
           unsigned int phase;           /* current processing phase */
 
-  struct mad_pcm {
-            unsigned int samplerate;    /* sampling frequency (Hz) */
-            unsigned short channels;    /* number of channels */
-            unsigned short length;      /* number of samples per channel */
-            mad_fixed_t samples[2][1152];/* PCM output samples */
-  } pcm;
+          struct mad_pcm pcm;           /* PCM output */
+};
+
+/* single channel PCM selector */
+enum {
+  MAD_PCM_CHANNEL_SINGLE = 0
+};
+
+/* dual channel PCM selector */
+enum {
+  MAD_PCM_CHANNEL_DUAL_1 = 0,
+  MAD_PCM_CHANNEL_DUAL_2 = 1
+};
+
+/* stereo PCM selector */
+enum {
+  MAD_PCM_CHANNEL_STEREO_LEFT  = 0,
+  MAD_PCM_CHANNEL_STEREO_RIGHT = 1
 };
 
 void mad_synth_init(struct mad_synth *);
 
 # define mad_synth_finish(synth)  /* nothing */
 
 void mad_synth_mute(struct mad_synth *);
 
 void mad_synth_frame(struct mad_synth *, struct mad_frame const *);
 
 # endif
 
-/* Id: decoder.h,v 1.9 2001/04/05 04:57:11 rob Exp */
+/* Id: decoder.h,v 1.17 2004/01/23 09:41:32 rob Exp */
 
 # ifndef LIBMAD_DECODER_H
 # define LIBMAD_DECODER_H
 
+
 enum mad_decoder_mode {
   MAD_DECODER_MODE_SYNC  = 0,
   MAD_DECODER_MODE_ASYNC
 };
 
 enum mad_flow {
-  MAD_FLOW_CONTINUE = 0x0000,
-  MAD_FLOW_STOP     = 0x0010,
-  MAD_FLOW_BREAK    = 0x0011,
-  MAD_FLOW_IGNORE   = 0x0020
+          MAD_FLOW_CONTINUE = 0x0000,/* continue normally */
+          MAD_FLOW_STOP     = 0x0010,/* stop decoding normally */
+          MAD_FLOW_BREAK    = 0x0011,/* stop decoding and signal an error */
+          MAD_FLOW_IGNORE   = 0x0020/* ignore the current frame */
 };
 
 struct mad_decoder {
   enum mad_decoder_mode mode;
 
   int options;
@@ -798,33 +925,40 @@ struct mad_decoder {
   } *sync;
 
   void *cb_data;
 
   enum mad_flow (*input_func)(void *, struct mad_stream *);
   enum mad_flow (*header_func)(void *, struct mad_header const *);
-  enum mad_flow (*filter_func)(void *, struct mad_frame *);
+  enum mad_flow (*filter_func)(void *,
+                               struct mad_stream const *, struct mad_frame *);
   enum mad_flow (*output_func)(void *,
                                struct mad_header const *, struct mad_pcm *);
   enum mad_flow (*error_func)(void *, struct mad_stream *, struct mad_frame *);
   enum mad_flow (*message_func)(void *, void *, unsigned int *);
 };
 
 void mad_decoder_init(struct mad_decoder *, void *,
                       enum mad_flow (*)(void *, struct mad_stream *),
                       enum mad_flow (*)(void *, struct mad_header const *),
-                      enum mad_flow (*)(void *, struct mad_frame *),
+                      enum mad_flow (*)(void *,
+                                        struct mad_stream const *,
+                                        struct mad_frame *),
                       enum mad_flow (*)(void *,
                                         struct mad_header const *,
                                         struct mad_pcm *),
                       enum mad_flow (*)(void *,
                                         struct mad_stream *,
                                         struct mad_frame *),
                       enum mad_flow (*)(void *, void *, unsigned int *));
 int mad_decoder_finish(struct mad_decoder *);
 
-# define mad_decoder_options(decoder, opts)  ((decoder)->options = (opts))
+# define mad_decoder_options(decoder, opts)  \
+    ((void) ((decoder)->options = (opts)))
 
 int mad_decoder_run(struct mad_decoder *, enum mad_decoder_mode);
 int mad_decoder_message(struct mad_decoder *, void *, unsigned int *);
 
 # endif
 
+# ifdef __cplusplus
+}
+# endif