update libmad and add 64bit define

33 files changed, 799 insertions, 342 deletions

diff --git a/core/multimedia/opieplayer/libmad/D.dat b/core/multimedia/opieplayer/libmad/D.dat
index c3ee74c..89b01da 100644
--- a/core/multimedia/opieplayer/libmad/D.dat
+++ b/core/multimedia/opieplayer/libmad/D.dat
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 /*
  * These are the coefficients for the subband synthesis window. This is a
  * reordered version of Table B.3 from ISO/IEC 11172-3.
  *
  * Every value is parameterized so that shift optimizations can be made at
  * compile-time. For example, every value can be right-shifted 12 bits to
  * minimize multiply instruction times without any loss of accuracy.
  */
 
           {  PRESHIFT(0x00000000) /*  0.000000000 */,/*  0 */
     -PRESHIFT(0x0001d000) /* -0.000442505 */,
      PRESHIFT(0x000d5000) /*  0.003250122 */,
     -PRESHIFT(0x001cb000) /* -0.007003784 */,
      PRESHIFT(0x007f5000) /*  0.031082153 */,
     -PRESHIFT(0x01421000) /* -0.078628540 */,
      PRESHIFT(0x019ae000) /*  0.100311279 */,
     -PRESHIFT(0x09271000) /* -0.572036743 */,
      PRESHIFT(0x1251e000) /*  1.144989014 */,
      PRESHIFT(0x09271000) /*  0.572036743 */,
      PRESHIFT(0x019ae000) /*  0.100311279 */,
      PRESHIFT(0x01421000) /*  0.078628540 */,
      PRESHIFT(0x007f5000) /*  0.031082153 */,
      PRESHIFT(0x001cb000) /*  0.007003784 */,
      PRESHIFT(0x000d5000) /*  0.003250122 */,
      PRESHIFT(0x0001d000) /*  0.000442505 */,
 
      PRESHIFT(0x00000000) /*  0.000000000 */,
     -PRESHIFT(0x0001d000) /* -0.000442505 */,
      PRESHIFT(0x000d5000) /*  0.003250122 */,
     -PRESHIFT(0x001cb000) /* -0.007003784 */,
      PRESHIFT(0x007f5000) /*  0.031082153 */,
     -PRESHIFT(0x01421000) /* -0.078628540 */,
      PRESHIFT(0x019ae000) /*  0.100311279 */,
     -PRESHIFT(0x09271000) /* -0.572036743 */,
      PRESHIFT(0x1251e000) /*  1.144989014 */,
      PRESHIFT(0x09271000) /*  0.572036743 */,
      PRESHIFT(0x019ae000) /*  0.100311279 */,
      PRESHIFT(0x01421000) /*  0.078628540 */,
      PRESHIFT(0x007f5000) /*  0.031082153 */,
      PRESHIFT(0x001cb000) /*  0.007003784 */,
      PRESHIFT(0x000d5000) /*  0.003250122 */,
      PRESHIFT(0x0001d000) /*  0.000442505 */ },
 
           { -PRESHIFT(0x00001000) /* -0.000015259 */,/*  1 */
     -PRESHIFT(0x0001f000) /* -0.000473022 */,
      PRESHIFT(0x000da000) /*  0.003326416 */,
     -PRESHIFT(0x00207000) /* -0.007919312 */,
      PRESHIFT(0x007d0000) /*  0.030517578 */,
     -PRESHIFT(0x0158d000) /* -0.084182739 */,
      PRESHIFT(0x01747000) /*  0.090927124 */,
     -PRESHIFT(0x099a8000) /* -0.600219727 */,
      PRESHIFT(0x124f0000) /*  1.144287109 */,
      PRESHIFT(0x08b38000) /*  0.543823242 */,
      PRESHIFT(0x01bde000) /*  0.108856201 */,
      PRESHIFT(0x012b4000) /*  0.073059082 */,
      PRESHIFT(0x0080f000) /*  0.031478882 */,
      PRESHIFT(0x00191000) /*  0.006118774 */,
      PRESHIFT(0x000d0000) /*  0.003173828 */,
      PRESHIFT(0x0001a000) /*  0.000396729 */,
 
     -PRESHIFT(0x00001000) /* -0.000015259 */,
     -PRESHIFT(0x0001f000) /* -0.000473022 */,
      PRESHIFT(0x000da000) /*  0.003326416 */,
     -PRESHIFT(0x00207000) /* -0.007919312 */,
      PRESHIFT(0x007d0000) /*  0.030517578 */,
     -PRESHIFT(0x0158d000) /* -0.084182739 */,
      PRESHIFT(0x01747000) /*  0.090927124 */,
     -PRESHIFT(0x099a8000) /* -0.600219727 */,
      PRESHIFT(0x124f0000) /*  1.144287109 */,
      PRESHIFT(0x08b38000) /*  0.543823242 */,
      PRESHIFT(0x01bde000) /*  0.108856201 */,
      PRESHIFT(0x012b4000) /*  0.073059082 */,
      PRESHIFT(0x0080f000) /*  0.031478882 */,
      PRESHIFT(0x00191000) /*  0.006118774 */,
      PRESHIFT(0x000d0000) /*  0.003173828 */,
      PRESHIFT(0x0001a000) /*  0.000396729 */ },
 
           { -PRESHIFT(0x00001000) /* -0.000015259 */,/*  2 */
diff --git a/core/multimedia/opieplayer/libmad/bit.c b/core/multimedia/opieplayer/libmad/bit.c
index 4a4661b..568d204 100644
--- a/core/multimedia/opieplayer/libmad/bit.c
+++ b/core/multimedia/opieplayer/libmad/bit.c
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # ifdef HAVE_LIMITS_H
 #  include <limits.h>
 # else
 #  define CHAR_BIT  8
 # endif
 
 # include "bit.h"
 
 /*
  * This is the lookup table for computing the CRC-check word.
  * As described in section 2.4.3.1 and depicted in Figure A.9
  * of ISO/IEC 11172-3, the generator polynomial is:
  *
  * G(X) = X^16 + X^15 + X^2 + 1
  */
 static
 unsigned short const crc_table[256] = {
   0x0000, 0x8005, 0x800f, 0x000a, 0x801b, 0x001e, 0x0014, 0x8011,
   0x8033, 0x0036, 0x003c, 0x8039, 0x0028, 0x802d, 0x8027, 0x0022,
   0x8063, 0x0066, 0x006c, 0x8069, 0x0078, 0x807d, 0x8077, 0x0072,
   0x0050, 0x8055, 0x805f, 0x005a, 0x804b, 0x004e, 0x0044, 0x8041,
   0x80c3, 0x00c6, 0x00cc, 0x80c9, 0x00d8, 0x80dd, 0x80d7, 0x00d2,
   0x00f0, 0x80f5, 0x80ff, 0x00fa, 0x80eb, 0x00ee, 0x00e4, 0x80e1,
   0x00a0, 0x80a5, 0x80af, 0x00aa, 0x80bb, 0x00be, 0x00b4, 0x80b1,
   0x8093, 0x0096, 0x009c, 0x8099, 0x0088, 0x808d, 0x8087, 0x0082,
 
   0x8183, 0x0186, 0x018c, 0x8189, 0x0198, 0x819d, 0x8197, 0x0192,
   0x01b0, 0x81b5, 0x81bf, 0x01ba, 0x81ab, 0x01ae, 0x01a4, 0x81a1,
   0x01e0, 0x81e5, 0x81ef, 0x01ea, 0x81fb, 0x01fe, 0x01f4, 0x81f1,
   0x81d3, 0x01d6, 0x01dc, 0x81d9, 0x01c8, 0x81cd, 0x81c7, 0x01c2,
   0x0140, 0x8145, 0x814f, 0x014a, 0x815b, 0x015e, 0x0154, 0x8151,
   0x8173, 0x0176, 0x017c, 0x8179, 0x0168, 0x816d, 0x8167, 0x0162,
   0x8123, 0x0126, 0x012c, 0x8129, 0x0138, 0x813d, 0x8137, 0x0132,
   0x0110, 0x8115, 0x811f, 0x011a, 0x810b, 0x010e, 0x0104, 0x8101,
 
   0x8303, 0x0306, 0x030c, 0x8309, 0x0318, 0x831d, 0x8317, 0x0312,
   0x0330, 0x8335, 0x833f, 0x033a, 0x832b, 0x032e, 0x0324, 0x8321,
   0x0360, 0x8365, 0x836f, 0x036a, 0x837b, 0x037e, 0x0374, 0x8371,
   0x8353, 0x0356, 0x035c, 0x8359, 0x0348, 0x834d, 0x8347, 0x0342,
   0x03c0, 0x83c5, 0x83cf, 0x03ca, 0x83db, 0x03de, 0x03d4, 0x83d1,
   0x83f3, 0x03f6, 0x03fc, 0x83f9, 0x03e8, 0x83ed, 0x83e7, 0x03e2,
   0x83a3, 0x03a6, 0x03ac, 0x83a9, 0x03b8, 0x83bd, 0x83b7, 0x03b2,
   0x0390, 0x8395, 0x839f, 0x039a, 0x838b, 0x038e, 0x0384, 0x8381,
 
   0x0280, 0x8285, 0x828f, 0x028a, 0x829b, 0x029e, 0x0294, 0x8291,
   0x82b3, 0x02b6, 0x02bc, 0x82b9, 0x02a8, 0x82ad, 0x82a7, 0x02a2,
   0x82e3, 0x02e6, 0x02ec, 0x82e9, 0x02f8, 0x82fd, 0x82f7, 0x02f2,
   0x02d0, 0x82d5, 0x82df, 0x02da, 0x82cb, 0x02ce, 0x02c4, 0x82c1,
   0x8243, 0x0246, 0x024c, 0x8249, 0x0258, 0x825d, 0x8257, 0x0252,
   0x0270, 0x8275, 0x827f, 0x027a, 0x826b, 0x026e, 0x0264, 0x8261,
   0x0220, 0x8225, 0x822f, 0x022a, 0x823b, 0x023e, 0x0234, 0x8231,
   0x8213, 0x0216, 0x021c, 0x8219, 0x0208, 0x820d, 0x8207, 0x0202
 };
 
 # define CRC_POLY  0x8005
 
 /*
          * NAME:bit->init()
          * DESCRIPTION:initialize bit pointer struct
  */
 void mad_bit_init(struct mad_bitptr *bitptr, unsigned char const *byte)
 {
   bitptr->byte  = byte;
   bitptr->cache = 0;
   bitptr->left  = CHAR_BIT;
 }
 
 /*
          * NAME:bit->length()
          * DESCRIPTION:return number of bits between start and end points
  */
 unsigned int mad_bit_length(struct mad_bitptr const *begin,
diff --git a/core/multimedia/opieplayer/libmad/bit.h b/core/multimedia/opieplayer/libmad/bit.h
index 3448d40..22ae66c 100644
--- a/core/multimedia/opieplayer/libmad/bit.h
+++ b/core/multimedia/opieplayer/libmad/bit.h
@@ -1,47 +1,47 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_BIT_H
 # define LIBMAD_BIT_H
 
 struct mad_bitptr {
   unsigned char const *byte;
   unsigned short cache;
   unsigned short left;
 };
 
 void mad_bit_init(struct mad_bitptr *, unsigned char const *);
 
         # define mad_bit_finish(bitptr)         /* nothing */
 
 unsigned int mad_bit_length(struct mad_bitptr const *,
                             struct mad_bitptr const *);
 
 # define mad_bit_bitsleft(bitptr)  ((bitptr)->left)
 unsigned char const *mad_bit_nextbyte(struct mad_bitptr const *);
 
 void mad_bit_skip(struct mad_bitptr *, unsigned int);
 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
diff --git a/core/multimedia/opieplayer/libmad/decoder.c b/core/multimedia/opieplayer/libmad/decoder.c
index b2b6cbb..d039bfb 100644
--- a/core/multimedia/opieplayer/libmad/decoder.c
+++ b/core/multimedia/opieplayer/libmad/decoder.c
@@ -1,150 +1,154 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # ifdef HAVE_SYS_TYPES_H
 #  include <sys/types.h>
 # endif
 
 # ifdef HAVE_SYS_WAIT_H
 #  include <sys/wait.h>
 # endif
 
 # ifdef HAVE_UNISTD_H
 #  include <unistd.h>
 # endif
 
 # ifdef HAVE_FCNTL_H
 #  include <fcntl.h>
 # endif
 
 # include <stdlib.h>
 
 # ifdef HAVE_ERRNO_H
 #  include <errno.h>
 # endif
 
 # include "stream.h"
 # include "frame.h"
 # include "synth.h"
 # include "decoder.h"
 
+/*
+         * NAME:decoder->init()
+         * DESCRIPTION:initialize a decoder object with callback routines
+ */
 void mad_decoder_init(struct mad_decoder *decoder, void *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_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 *))
 {
   decoder->mode         = -1;
 
   decoder->options      = 0;
 
   decoder->async.pid    = 0;
   decoder->async.in     = -1;
   decoder->async.out    = -1;
 
   decoder->sync         = 0;
 
   decoder->cb_data      = data;
 
   decoder->input_func   = input_func;
   decoder->header_func  = header_func;
   decoder->filter_func  = filter_func;
   decoder->output_func  = output_func;
   decoder->error_func   = error_func;
   decoder->message_func = message_func;
 }
 
 int mad_decoder_finish(struct mad_decoder *decoder)
 {
 # if defined(USE_ASYNC)
   if (decoder->mode == MAD_DECODER_MODE_ASYNC && decoder->async.pid) {
     pid_t pid;
     int status;
 
     close(decoder->async.in);
 
     do
       pid = waitpid(decoder->async.pid, &status, 0);
     while (pid == -1 && errno == EINTR);
 
     decoder->mode = -1;
 
     close(decoder->async.out);
 
     decoder->async.pid = 0;
     decoder->async.in  = -1;
     decoder->async.out = -1;
 
     if (pid == -1)
       return -1;
 
     return (!WIFEXITED(status) || WEXITSTATUS(status)) ? -1 : 0;
   }
 # endif
 
   return 0;
 }
 
 # if defined(USE_ASYNC)
 static
 enum mad_flow send_io(int fd, void const *data, size_t len)
 {
   char const *ptr = data;
   ssize_t count;
 
   while (len) {
     do
       count = write(fd, ptr, len);
     while (count == -1 && errno == EINTR);
 
     if (count == -1)
       return MAD_FLOW_BREAK;
 
     len -= count;
     ptr += count;
   }
 
   return MAD_FLOW_CONTINUE;
 }
 
 static
 enum mad_flow receive_io(int fd, void *buffer, size_t len)
 {
   char *ptr = buffer;
   ssize_t count;
 
@@ -429,142 +433,150 @@ int run_sync(struct mad_decoder *decoder)
         }
       }
 
       mad_synth_frame(synth, frame);
 
       if (decoder->output_func) {
         switch (decoder->output_func(decoder->cb_data,
                                      &frame->header, &synth->pcm)) {
         case MAD_FLOW_STOP:
           goto done;
         case MAD_FLOW_BREAK:
           goto fail;
         case MAD_FLOW_IGNORE:
         case MAD_FLOW_CONTINUE:
           break;
         }
       }
     }
   }
   while (stream->error == MAD_ERROR_BUFLEN);
 
  fail:
   result = -1;
 
  done:
   mad_synth_finish(synth);
   mad_frame_finish(frame);
   mad_stream_finish(stream);
 
   return result;
 }
 
 # if defined(USE_ASYNC)
 static
 int run_async(struct mad_decoder *decoder)
 {
   pid_t pid;
   int ptoc[2], ctop[2], flags;
 
   if (pipe(ptoc) == -1)
     return -1;
 
   if (pipe(ctop) == -1) {
     close(ptoc[0]);
     close(ptoc[1]);
     return -1;
   }
 
   flags = fcntl(ptoc[0], F_GETFL);
   if (flags == -1 ||
       fcntl(ptoc[0], F_SETFL, flags | O_NONBLOCK) == -1) {
     close(ctop[0]);
     close(ctop[1]);
     close(ptoc[0]);
     close(ptoc[1]);
     return -1;
   }
 
   pid = fork();
   if (pid == -1) {
     close(ctop[0]);
     close(ctop[1]);
     close(ptoc[0]);
     close(ptoc[1]);
     return -1;
   }
 
   decoder->async.pid = pid;
 
   if (pid) {
     /* parent */
 
     close(ptoc[0]);
     close(ctop[1]);
 
     decoder->async.in  = ctop[0];
     decoder->async.out = ptoc[1];
 
     return 0;
   }
 
   /* child */
 
   close(ptoc[1]);
   close(ctop[0]);
 
   decoder->async.in  = ptoc[0];
   decoder->async.out = ctop[1];
 
   _exit(run_sync(decoder));
 
   /* not reached */
   return -1;
 }
 # endif
 
+/*
+         * NAME:decoder->run()
+         * DESCRIPTION:run the decoder thread either synchronously or asynchronously
+ */
 int mad_decoder_run(struct mad_decoder *decoder, enum mad_decoder_mode mode)
 {
   int result;
   int (*run)(struct mad_decoder *) = 0;
 
   switch (decoder->mode = mode) {
   case MAD_DECODER_MODE_SYNC:
     run = run_sync;
     break;
 
   case MAD_DECODER_MODE_ASYNC:
 # if defined(USE_ASYNC)
     run = run_async;
 # endif
     break;
   }
 
   if (run == 0)
     return -1;
 
   decoder->sync = malloc(sizeof(*decoder->sync));
   if (decoder->sync == 0)
     return -1;
 
   result = run(decoder);
 
   free(decoder->sync);
   decoder->sync = 0;
 
   return result;
 }
 
+/*
+         * NAME:decoder->message()
+         * DESCRIPTION:send a message to and receive a reply from the decoder process
+ */
 int mad_decoder_message(struct mad_decoder *decoder,
                         void *message, unsigned int *len)
 {
 # if defined(USE_ASYNC)
   if (decoder->mode != MAD_DECODER_MODE_ASYNC ||
       send(decoder->async.out, message, *len) != MAD_FLOW_CONTINUE ||
       receive(decoder->async.in, &message, len) != MAD_FLOW_CONTINUE)
     return -1;
 
   return 0;
 # else
   return -1;
 # endif
 }
diff --git a/core/multimedia/opieplayer/libmad/decoder.h b/core/multimedia/opieplayer/libmad/decoder.h
index f34150d..714e72c 100644
--- a/core/multimedia/opieplayer/libmad/decoder.h
+++ b/core/multimedia/opieplayer/libmad/decoder.h
@@ -1,91 +1,91 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_DECODER_H
 # define LIBMAD_DECODER_H
 
 # include "stream.h"
 # include "frame.h"
 # include "synth.h"
 
 enum mad_decoder_mode {
   MAD_DECODER_MODE_SYNC  = 0,
   MAD_DECODER_MODE_ASYNC
 };
 
 enum mad_flow {
           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;
 
   struct {
     long pid;
     int in;
     int out;
   } async;
 
   struct {
     struct mad_stream stream;
     struct mad_frame frame;
     struct mad_synth synth;
   } *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_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_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)  \
     ((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
diff --git a/core/multimedia/opieplayer/libmad/fixed.c b/core/multimedia/opieplayer/libmad/fixed.c
index af1e87e..e71418a 100644
--- a/core/multimedia/opieplayer/libmad/fixed.c
+++ b/core/multimedia/opieplayer/libmad/fixed.c
@@ -1,37 +1,81 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include "fixed.h"
 
 /*
          * NAME:fixed->abs()
          * DESCRIPTION:return absolute value of a fixed-point number
  */
 mad_fixed_t mad_f_abs(mad_fixed_t x)
 {
   return x < 0 ? -x : x;
 }
+
+/*
+         * NAME:fixed->div()
+         * DESCRIPTION:perform division using fixed-point math
+ */
+mad_fixed_t mad_f_div(mad_fixed_t x, mad_fixed_t y)
+{
+  mad_fixed_t q, r;
+  unsigned int bits;
+
+  q = mad_f_abs(x / y);
+
+  if (x < 0) {
+    x = -x;
+    y = -y;
+  }
+
+  r = x % y;
+
+  if (y < 0) {
+    x = -x;
+    y = -y;
+  }
+
+  if (q > mad_f_intpart(MAD_F_MAX) &&
+      !(q == -mad_f_intpart(MAD_F_MIN) && r == 0 && (x < 0) != (y < 0)))
+    return 0;
+
+  for (bits = MAD_F_FRACBITS; bits && r; --bits) {
+    q <<= 1, r <<= 1;
+    if (r >= y)
+      r -= y, ++q;
+  }
+
+  /* round */
+  if (2 * r >= y)
+    ++q;
+
+  /* fix sign */
+  if ((x < 0) != (y < 0))
+    q = -q;
+
+  return q << bits;
+}
diff --git a/core/multimedia/opieplayer/libmad/fixed.h b/core/multimedia/opieplayer/libmad/fixed.h
index c9b98ca..baa7dc5 100644
--- a/core/multimedia/opieplayer/libmad/fixed.h
+++ b/core/multimedia/opieplayer/libmad/fixed.h
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_FIXED_H
 # define LIBMAD_FIXED_H
 
 # if SIZEOF_INT >= 4
 typedef   signed int mad_fixed_t;
 
 typedef   signed int mad_fixed64hi_t;
 typedef unsigned int mad_fixed64lo_t;
 # else
 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:
  * 0x80000000 to 0x7fffffff
  *       -8.0 to +7.9999999962747097015380859375
  *
  * The smallest representable value is:
  * 0x00000001 == 0.0000000037252902984619140625 (i.e. about 3.725e-9)
  *
  * 28 bits of fractional accuracy represent about
  * 8.6 digits of decimal accuracy.
  *
  * Fixed-point numbers can be added or subtracted as normal
  * integers, but multiplication requires shifting the 64-bit result
  * from 56 fractional bits back to 28 (and rounding.)
  *
  * Changing the definition of MAD_F_FRACBITS is only partially
  * supported, and must be done with care.
  */
 
         # define MAD_F_FRACBITS         28
 
 # if MAD_F_FRACBITS == 28
         #  define MAD_F(x)      ((mad_fixed_t) (x##L))
 # else
 #  if MAD_F_FRACBITS < 28
 #   warning "MAD_F_FRACBITS < 28"
         #   define MAD_F(x)     ((mad_fixed_t)  \
                                  (((x##L) +  \
                                    (1L << (28 - MAD_F_FRACBITS - 1))) >>  \
                                   (28 - MAD_F_FRACBITS)))
 #  elif MAD_F_FRACBITS > 28
 #   error "MAD_F_FRACBITS > 28 not currently supported"
         #   define MAD_F(x)     ((mad_fixed_t)  \
                                  ((x##L) << (MAD_F_FRACBITS - 28)))
 #  endif
 # endif
 
         # define MAD_F_MIN      ((mad_fixed_t) -0x80000000L)
         # define MAD_F_MAX      ((mad_fixed_t) +0x7fffffffL)
 
         # define MAD_F_ONE      MAD_F(0x10000000)
 
         # define mad_f_tofixed(x)((mad_fixed_t)  \
                                  ((x) * (double) (1L << MAD_F_FRACBITS) + 0.5))
         # define mad_f_todouble(x)((double)  \
                                  ((x) / (double) (1L << MAD_F_FRACBITS)))
 
@@ -115,362 +115,385 @@ typedef mad_fixed_t mad_sample_t;
         #  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 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)  \
      ((((mad_fixed64_t) (x) * (y)) +  \
        (1L << (MAD_F_SCALEBITS - 1))) >> MAD_F_SCALEBITS))
 #  else
 #   define mad_f_mul(x, y)  \
     ((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)  \
     asm ("imull %3"  \
          : "=a" (lo), "=d" (hi)  \
          : "%a" (x), "rm" (y)  \
          : "cc")
 
 #   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 ("addl %2,%0\n\t"  \
             "adcl %3,%1"  \
             : "=rm" (lo), "=rm" (hi)  \
             : "r" (__lo), "r" (__hi), "0" (lo), "1" (hi)  \
             : "cc");  \
     })
 #   endif  /* OPT_ACCURACY */
 
 #   if defined(OPT_ACCURACY)
 /*
  * Surprisingly, this is faster than SHRD followed by ADC.
  */
 #    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_)  \
             : "0" (lo), "1" (hi),  \
               "ir" (1L << (MAD_F_SCALEBITS - 1)), "ir" (0)  \
             : "cc");  \
        asm ("shrdl %3,%2,%1"  \
             : "=rm" (__result)  \
             : "0" (__lo_), "r" (__hi_), "I" (MAD_F_SCALEBITS)  \
             : "cc");  \
        __result;  \
     })
+#   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 */
 
 #   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"  \
                     "movs%0, %0, lsr %5\n\t"  \
                     "adc%2, %0, %1, lsl %6"  \
             : "=&r" (__lo), "=&r" (__hi), "=r" (__result)  \
             : "%r" (x), "r" (y),  \
               "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  \
             : "cc");  \
        __result;  \
     })
 # endif
 
 #  define MAD_F_MLX(hi, lo, x, y)  \
             asm ("smull%0, %1, %2, %3"  \
          : "=&r" (lo), "=&r" (hi)  \
          : "%r" (x), "r" (y))
 
 #  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;  \
     })
 
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 
 /* --- MIPS ---------------------------------------------------------------- */
 
 # elif defined(FPM_MIPS)
 
 /*
  * This MIPS 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 ("mult%2,%3"  \
          : "=l" (lo), "=h" (hi)  \
          : "%r" (x), "r" (y))
 
 # if defined(HAVE_MADD_ASM)
 #  define MAD_F_MLA(hi, lo, x, y)  \
             asm ("madd%2,%3"  \
          : "+l" (lo), "+h" (hi)  \
          : "%r" (x), "r" (y))
 # elif defined(HAVE_MADD16_ASM)
 /*
  * This loses significant accuracy due to the 16-bit integer limit in the
  * multiply/accumulate instruction.
  */
 #  define MAD_F_ML0(hi, lo, x, y)  \
             asm ("mult%2,%3"  \
          : "=l" (lo), "=h" (hi)  \
          : "%r" ((x) >> 12), "r" ((y) >> 16))
 #  define MAD_F_MLA(hi, lo, x, y)  \
             asm ("madd16%2,%3"  \
          : "+l" (lo), "+h" (hi)  \
          : "%r" ((x) >> 12), "r" ((y) >> 16))
 #  define MAD_F_MLZ(hi, lo)  ((mad_fixed_t) (lo))
 # endif
 
 # if defined(OPT_SPEED)
 #  define mad_f_scale64(hi, lo)  \
     ((mad_fixed_t) ((hi) << (32 - MAD_F_SCALEBITS)))
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 # endif
 
 /* --- SPARC --------------------------------------------------------------- */
 
 # elif defined(FPM_SPARC)
 
 /*
  * This SPARC V8 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 ("smul %2, %3, %0\n\t"  \
          "rd %%y, %1"  \
          : "=r" (lo), "=r" (hi)  \
          : "%r" (x), "rI" (y))
 
 /* --- 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)
 
 /*
  * This version is the most portable but it loses significant accuracy.
  * Furthermore, accuracy is biased against the second argument, so care
  * 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.
  */
 #  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)
 #   define mad_f_scale64(hi, lo)  \
     ((((mad_fixed_t)  \
        (((hi) << (32 - (MAD_F_SCALEBITS - 1))) |  \
         ((lo) >> (MAD_F_SCALEBITS - 1)))) + 1) >> 1)
 #  else
 #   define mad_f_scale64(hi, lo)  \
     ((mad_fixed_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
diff --git a/core/multimedia/opieplayer/libmad/frame.c b/core/multimedia/opieplayer/libmad/frame.c
index bf15e7f..3aacb56 100644
--- a/core/multimedia/opieplayer/libmad/frame.c
+++ b/core/multimedia/opieplayer/libmad/frame.c
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include <stdlib.h>
 
 # include "bit.h"
 # include "stream.h"
 # include "frame.h"
 # include "timer.h"
 # include "layer12.h"
 # include "layer3.h"
 
 static
 unsigned long const bitrate_table[5][15] = {
   /* MPEG-1 */
   { 0,  32000,  64000,  96000, 128000, 160000, 192000, 224000,  /* Layer I   */
        256000, 288000, 320000, 352000, 384000, 416000, 448000 },
   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer II  */
        128000, 160000, 192000, 224000, 256000, 320000, 384000 },
   { 0,  32000,  40000,  48000,  56000,  64000,  80000,  96000,  /* Layer III */
        112000, 128000, 160000, 192000, 224000, 256000, 320000 },
 
   /* MPEG-2 LSF */
   { 0,  32000,  48000,  56000,  64000,  80000,  96000, 112000,  /* Layer I   */
        128000, 144000, 160000, 176000, 192000, 224000, 256000 },
   { 0,   8000,  16000,  24000,  32000,  40000,  48000,  56000,  /* Layers    */
         64000,  80000,  96000, 112000, 128000, 144000, 160000 } /* II & III  */
 };
 
 static
 unsigned int const samplerate_table[3] = { 44100, 48000, 32000 };
 
 static
 int (*const decoder_table[3])(struct mad_stream *, struct mad_frame *) = {
   mad_layer_I,
   mad_layer_II,
   mad_layer_III
 };
 
 /*
          * NAME:header->init()
          * DESCRIPTION:initialize header struct
  */
 void mad_header_init(struct mad_header *header)
 {
   header->layer          = 0;
   header->mode           = 0;
   header->mode_extension = 0;
   header->emphasis       = 0;
 
   header->bitrate        = 0;
   header->samplerate     = 0;
 
   header->crc_check      = 0;
   header->crc_target     = 0;
 
   header->flags          = 0;
   header->private_bits   = 0;
 
   header->duration       = mad_timer_zero;
 }
 
 /*
          * NAME:frame->init()
          * DESCRIPTION:initialize frame struct
  */
 void mad_frame_init(struct mad_frame *frame)
 {
   mad_header_init(&frame->header);
 
   frame->options = 0;
 
   frame->overlap = 0;
   mad_frame_mute(frame);
 }
@@ -117,356 +117,360 @@ void mad_frame_finish(struct mad_frame *frame)
          * DESCRIPTION:read header data and following CRC word
  */
 static
 int decode_header(struct mad_header *header, struct mad_stream *stream)
 {
   unsigned int index;
 
   header->flags        = 0;
   header->private_bits = 0;
 
   /* header() */
 
   /* syncword */
   mad_bit_skip(&stream->ptr, 11);
 
   /* MPEG 2.5 indicator (really part of syncword) */
   if (mad_bit_read(&stream->ptr, 1) == 0)
     header->flags |= MAD_FLAG_MPEG_2_5_EXT;
 
   /* ID */
   if (mad_bit_read(&stream->ptr, 1) == 0)
     header->flags |= MAD_FLAG_LSF_EXT;
   else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) {
     stream->error = MAD_ERROR_LOSTSYNC;
     return -1;
   }
 
   /* layer */
   header->layer = 4 - mad_bit_read(&stream->ptr, 2);
 
   if (header->layer == 4) {
     stream->error = MAD_ERROR_BADLAYER;
     return -1;
   }
 
   /* protection_bit */
   if (mad_bit_read(&stream->ptr, 1) == 0) {
     header->flags    |= MAD_FLAG_PROTECTION;
     header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff);
   }
 
   /* bitrate_index */
   index = mad_bit_read(&stream->ptr, 4);
 
   if (index == 15) {
     stream->error = MAD_ERROR_BADBITRATE;
     return -1;
   }
 
   if (header->flags & MAD_FLAG_LSF_EXT)
     header->bitrate = bitrate_table[3 + (header->layer >> 1)][index];
   else
     header->bitrate = bitrate_table[header->layer - 1][index];
 
   /* sampling_frequency */
   index = mad_bit_read(&stream->ptr, 2);
 
   if (index == 3) {
     stream->error = MAD_ERROR_BADSAMPLERATE;
     return -1;
   }
 
   header->samplerate = samplerate_table[index];
 
   if (header->flags & MAD_FLAG_LSF_EXT) {
     header->samplerate /= 2;
 
     if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
       header->samplerate /= 2;
   }
 
   /* padding_bit */
   if (mad_bit_read(&stream->ptr, 1))
     header->flags |= MAD_FLAG_PADDING;
 
   /* private_bit */
   if (mad_bit_read(&stream->ptr, 1))
     header->private_bits |= MAD_PRIVATE_HEADER;
 
   /* mode */
   header->mode = 3 - mad_bit_read(&stream->ptr, 2);
 
   /* mode_extension */
   header->mode_extension = mad_bit_read(&stream->ptr, 2);
 
   /* copyright */
   if (mad_bit_read(&stream->ptr, 1))
     header->flags |= MAD_FLAG_COPYRIGHT;
 
   /* original/copy */
   if (mad_bit_read(&stream->ptr, 1))
     header->flags |= MAD_FLAG_ORIGINAL;
 
   /* emphasis */
   header->emphasis = mad_bit_read(&stream->ptr, 2);
 
-  if (header->emphasis == 2) {
+# if defined(OPT_STRICT)
+  /*
+   * ISO/IEC 11172-3 says this is a reserved emphasis value, but
+   * streams exist which use it anyway. Since the value is not important
+   * to the decoder proper, we allow it unless OPT_STRICT is defined.
+   */
+  if (header->emphasis == MAD_EMPHASIS_RESERVED) {
     stream->error = MAD_ERROR_BADEMPHASIS;
     return -1;
   }
+# endif
 
   /* error_check() */
 
   /* crc_check */
   if (header->flags & MAD_FLAG_PROTECTION)
     header->crc_target = mad_bit_read(&stream->ptr, 16);
 
   return 0;
 }
 
 /*
          * NAME:free_bitrate()
          * DESCRIPTION:attempt to discover the bitstream's free bitrate
  */
 static
 int free_bitrate(struct mad_stream *stream, struct mad_header const *header)
 {
   struct mad_bitptr keep_ptr;
   unsigned long rate = 0;
   unsigned int pad_slot, slots_per_frame;
   unsigned char const *ptr = 0;
 
   keep_ptr = stream->ptr;
 
   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
   slots_per_frame = (header->layer == MAD_LAYER_III &&
                      (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
 
   while (mad_stream_sync(stream) == 0) {
     struct mad_stream peek_stream;
     struct mad_header peek_header;
 
     peek_stream = *stream;
     peek_header = *header;
 
     if (decode_header(&peek_header, &peek_stream) == 0 &&
         peek_header.layer == header->layer &&
         peek_header.samplerate == header->samplerate) {
       unsigned int N;
 
       ptr = mad_bit_nextbyte(&stream->ptr);
 
       N = ptr - stream->this_frame;
 
       if (header->layer == MAD_LAYER_I) {
         rate = (unsigned long) header->samplerate *
           (N - 4 * pad_slot + 4) / 48 / 1000;
       }
       else {
         rate = (unsigned long) header->samplerate *
           (N - pad_slot + 1) / slots_per_frame / 1000;
       }
 
       if (rate >= 8)
         break;
     }
 
     mad_bit_skip(&stream->ptr, 8);
   }
 
   stream->ptr = keep_ptr;
 
   if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) {
     stream->error = MAD_ERROR_LOSTSYNC;
     return -1;
   }
 
   stream->freerate = rate * 1000;
 
-# if 0 && defined(DEBUG)
-  fprintf(stderr, "free bitrate == %lu\n", stream->freerate);
-# endif
-
   return 0;
 }
 
 /*
          * NAME:header->decode()
          * DESCRIPTION:read the next frame header from the stream
  */
 int mad_header_decode(struct mad_header *header, struct mad_stream *stream)
 {
   register unsigned char const *ptr, *end;
   unsigned int pad_slot, N;
 
   ptr = stream->next_frame;
   end = stream->bufend;
 
   if (ptr == 0) {
     stream->error = MAD_ERROR_BUFPTR;
     goto fail;
   }
 
   /* stream skip */
   if (stream->skiplen) {
     if (!stream->sync)
       ptr = stream->this_frame;
 
     if (end - ptr < stream->skiplen) {
       stream->skiplen   -= end - ptr;
       stream->next_frame = end;
 
       stream->error = MAD_ERROR_BUFLEN;
       goto fail;
     }
 
     ptr += stream->skiplen;
     stream->skiplen = 0;
 
     stream->sync = 1;
   }
 
  sync:
   /* synchronize */
   if (stream->sync) {
     if (end - ptr < MAD_BUFFER_GUARD) {
       stream->next_frame = ptr;
 
       stream->error = MAD_ERROR_BUFLEN;
       goto fail;
     }
     else if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
       /* mark point where frame sync word was expected */
       stream->this_frame = ptr;
       stream->next_frame = ptr + 1;
 
       stream->error = MAD_ERROR_LOSTSYNC;
       goto fail;
     }
   }
   else {
     mad_bit_init(&stream->ptr, ptr);
 
     if (mad_stream_sync(stream) == -1) {
       if (end - stream->next_frame >= MAD_BUFFER_GUARD)
         stream->next_frame = end - MAD_BUFFER_GUARD;
 
       stream->error = MAD_ERROR_BUFLEN;
       goto fail;
     }
 
     ptr = mad_bit_nextbyte(&stream->ptr);
   }
 
   /* begin processing */
   stream->this_frame = ptr;
   stream->next_frame = ptr + 1;  /* possibly bogus sync word */
 
   mad_bit_init(&stream->ptr, stream->this_frame);
 
   if (decode_header(header, stream) == -1)
     goto fail;
 
   /* calculate frame duration */
   mad_timer_set(&header->duration, 0,
                 32 * MAD_NSBSAMPLES(header), header->samplerate);
 
   /* calculate free bit rate */
   if (header->bitrate == 0) {
-    if ((stream->freerate == 0 || !stream->sync) &&
+    if ((stream->freerate == 0 || !stream->sync ||
+         (header->layer == MAD_LAYER_III && stream->freerate > 640000)) &&
         free_bitrate(stream, header) == -1)
       goto fail;
 
     header->bitrate = stream->freerate;
     header->flags  |= MAD_FLAG_FREEFORMAT;
   }
 
   /* calculate beginning of next frame */
   pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0;
 
   if (header->layer == MAD_LAYER_I)
     N = ((12 * header->bitrate / header->samplerate) + pad_slot) * 4;
   else {
     unsigned int slots_per_frame;
 
     slots_per_frame = (header->layer == MAD_LAYER_III &&
                        (header->flags & MAD_FLAG_LSF_EXT)) ? 72 : 144;
 
     N = (slots_per_frame * header->bitrate / header->samplerate) + pad_slot;
   }
 
   /* verify there is enough data left in buffer to decode this frame */
   if (N + MAD_BUFFER_GUARD > end - stream->this_frame) {
     stream->next_frame = stream->this_frame;
 
     stream->error = MAD_ERROR_BUFLEN;
     goto fail;
   }
 
   stream->next_frame = stream->this_frame + N;
 
   if (!stream->sync) {
     /* check that a valid frame header follows this frame */
 
     ptr = stream->next_frame;
     if (!(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0)) {
       ptr = stream->next_frame = stream->this_frame + 1;
       goto sync;
     }
 
     stream->sync = 1;
   }
 
   header->flags |= MAD_FLAG_INCOMPLETE;
 
   return 0;
 
  fail:
   stream->sync = 0;
 
   return -1;
 }
 
 /*
          * NAME:frame->decode()
          * DESCRIPTION:decode a single frame from a bitstream
  */
 int mad_frame_decode(struct mad_frame *frame, struct mad_stream *stream)
 {
   frame->options = stream->options;
 
   /* header() */
   /* error_check() */
 
   if (!(frame->header.flags & MAD_FLAG_INCOMPLETE) &&
       mad_header_decode(&frame->header, stream) == -1)
     goto fail;
 
   /* audio_data() */
 
   frame->header.flags &= ~MAD_FLAG_INCOMPLETE;
 
   if (decoder_table[frame->header.layer - 1](stream, frame) == -1) {
     if (!MAD_RECOVERABLE(stream->error))
       stream->next_frame = stream->this_frame;
 
     goto fail;
   }
 
   /* ancillary_data() */
 
   if (frame->header.layer != MAD_LAYER_III) {
     struct mad_bitptr next_frame;
 
     mad_bit_init(&next_frame, stream->next_frame);
 
     stream->anc_ptr    = stream->ptr;
     stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame);
 
     mad_bit_finish(&next_frame);
   }
 
   return 0;
 
  fail:
   stream->anc_bitlen = 0;
diff --git a/core/multimedia/opieplayer/libmad/frame.h b/core/multimedia/opieplayer/libmad/frame.h
index 3b8e454..dce573d 100644
--- a/core/multimedia/opieplayer/libmad/frame.h
+++ b/core/multimedia/opieplayer/libmad/frame.h
@@ -1,117 +1,118 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_FRAME_H
 # define LIBMAD_FRAME_H
 
 # include "fixed.h"
 # include "timer.h"
 # include "stream.h"
 
 enum mad_layer {
           MAD_LAYER_I   = 1,            /* Layer I */
           MAD_LAYER_II  = 2,            /* Layer II */
           MAD_LAYER_III = 3             /* Layer III */
 };
 
 enum mad_mode {
           MAD_MODE_SINGLE_CHANNEL = 0,  /* single channel */
           MAD_MODE_DUAL_CHANNEL           = 1,  /* dual channel */
           MAD_MODE_JOINT_STEREO           = 2,  /* joint (MS/intensity) stereo */
           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_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 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) */
 
           mad_timer_t duration;                 /* audio playing time of frame */
 };
 
 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 */
 };
 
         # define MAD_NCHANNELS(header)  ((header)->mode ? 2 : 1)
 # 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_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_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) */
 };
 
 void mad_header_init(struct mad_header *);
 
 # define mad_header_finish(header)  /* nothing */
 
 int mad_header_decode(struct mad_header *, struct mad_stream *);
 
 void mad_frame_init(struct mad_frame *);
 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
diff --git a/core/multimedia/opieplayer/libmad/huffman.c b/core/multimedia/opieplayer/libmad/huffman.c
index 5ea6547..684409e 100644
--- a/core/multimedia/opieplayer/libmad/huffman.c
+++ b/core/multimedia/opieplayer/libmad/huffman.c
@@ -1,210 +1,221 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include "huffman.h"
 
 /*
  * These are the Huffman code words for Layer III.
  * The data for these tables are derived from Table B.7 of ISO/IEC 11172-3.
  *
  * These tables support decoding up to 4 Huffman code bits at a time.
  */
 
-# if defined(__GNUC__)
-        #  define PTR(offs, bits){ ptr:   { 0, bits, offs       } }
-        #  define V(v, w, x, y, hlen){ value: { 1, hlen, v, w, x, y } }
+# if defined(__GNUC__) ||  \
+    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901)
+        #  define PTR(offs, bits){ .ptr   = { 0, bits, offs       } }
+        #  define V(v, w, x, y, hlen){ .value = { 1, hlen, v, w, x, y } }
 # else
         #  define PTR(offs, bits){ { 0, bits, offs } }
-        #  define V(v, w, x, y, hlen){ { 1, hlen, (v << 0) | (w << 1) |  \
-                                             (x << 2) | (y << 3) } }
+#  if defined(WORDS_BIGENDIAN)
+        #   define V(v, w, x, y, hlen){ { 1, hlen, (v << 11) | (w << 10) |  \
+                                             (x <<  9) | (y <<  8) } }
+#  else
+        #   define V(v, w, x, y, hlen){ { 1, hlen, (v <<  0) | (w <<  1) |  \
+                                             (x <<  2) | (y <<  3) } }
+#  endif
 # endif
 
 static
 union huffquad const hufftabA[] = {
   /* 0000 */ PTR(16, 2),
   /* 0001 */ PTR(20, 2),
   /* 0010 */ PTR(24, 1),
   /* 0011 */ PTR(26, 1),
   /* 0100 */ V(0, 0, 1, 0, 4),
   /* 0101 */ V(0, 0, 0, 1, 4),
   /* 0110 */ V(0, 1, 0, 0, 4),
   /* 0111 */ V(1, 0, 0, 0, 4),
   /* 1000 */ V(0, 0, 0, 0, 1),
   /* 1001 */ V(0, 0, 0, 0, 1),
   /* 1010 */ V(0, 0, 0, 0, 1),
   /* 1011 */ V(0, 0, 0, 0, 1),
   /* 1100 */ V(0, 0, 0, 0, 1),
   /* 1101 */ V(0, 0, 0, 0, 1),
   /* 1110 */ V(0, 0, 0, 0, 1),
   /* 1111 */ V(0, 0, 0, 0, 1),
 
   /* 0000 ... */
           /* 00   */ V(1, 0, 1, 1, 2),/* 16 */
   /* 01   */ V(1, 1, 1, 1, 2),
   /* 10   */ V(1, 1, 0, 1, 2),
   /* 11   */ V(1, 1, 1, 0, 2),
 
   /* 0001 ... */
           /* 00   */ V(0, 1, 1, 1, 2),/* 20 */
   /* 01   */ V(0, 1, 0, 1, 2),
   /* 10   */ V(1, 0, 0, 1, 1),
   /* 11   */ V(1, 0, 0, 1, 1),
 
   /* 0010 ... */
           /* 0    */ V(0, 1, 1, 0, 1),/* 24 */
   /* 1    */ V(0, 0, 1, 1, 1),
 
   /* 0011 ... */
           /* 0    */ V(1, 0, 1, 0, 1),/* 26 */
   /* 1    */ V(1, 1, 0, 0, 1)
 };
 
 static
 union huffquad const hufftabB[] = {
   /* 0000 */ V(1, 1, 1, 1, 4),
   /* 0001 */ V(1, 1, 1, 0, 4),
   /* 0010 */ V(1, 1, 0, 1, 4),
   /* 0011 */ V(1, 1, 0, 0, 4),
   /* 0100 */ V(1, 0, 1, 1, 4),
   /* 0101 */ V(1, 0, 1, 0, 4),
   /* 0110 */ V(1, 0, 0, 1, 4),
   /* 0111 */ V(1, 0, 0, 0, 4),
   /* 1000 */ V(0, 1, 1, 1, 4),
   /* 1001 */ V(0, 1, 1, 0, 4),
   /* 1010 */ V(0, 1, 0, 1, 4),
   /* 1011 */ V(0, 1, 0, 0, 4),
   /* 1100 */ V(0, 0, 1, 1, 4),
   /* 1101 */ V(0, 0, 1, 0, 4),
   /* 1110 */ V(0, 0, 0, 1, 4),
   /* 1111 */ V(0, 0, 0, 0, 4)
 };
 
 # undef V
 # undef PTR
 
-# if defined(__GNUC__)
-        #  define PTR(offs, bits){ ptr:   { 0, bits, offs } }
-        #  define V(x, y, hlen)         { value: { 1, hlen, x, y } }
+# if defined(__GNUC__) ||  \
+    (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901)
+        #  define PTR(offs, bits){ .ptr   = { 0, bits, offs } }
+        #  define V(x, y, hlen)         { .value = { 1, hlen, x, y } }
 # else
         #  define PTR(offs, bits){ { 0, bits, offs } }
-        #  define V(x, y, hlen)         { { 1, hlen, (x << 0) | (y << 4) } }
+#  if defined(WORDS_BIGENDIAN)
+        #   define V(x, y, hlen){ { 1, hlen, (x << 8) | (y << 4) } }
+#  else
+        #   define V(x, y, hlen){ { 1, hlen, (x << 0) | (y << 4) } }
+#  endif
 # endif
 
 static
 union huffpair const hufftab0[] = {
   /*      */ V(0, 0, 0)
 };
 
 static
 union huffpair const hufftab1[] = {
   /* 000  */ V(1, 1, 3),
   /* 001  */ V(0, 1, 3),
   /* 010  */ V(1, 0, 2),
   /* 011  */ V(1, 0, 2),
   /* 100  */ V(0, 0, 1),
   /* 101  */ V(0, 0, 1),
   /* 110  */ V(0, 0, 1),
   /* 111  */ V(0, 0, 1)
 };
 
 static
 union huffpair const hufftab2[] = {
   /* 000  */ PTR(8, 3),
   /* 001  */ V(1, 1, 3),
   /* 010  */ V(0, 1, 3),
   /* 011  */ V(1, 0, 3),
   /* 100  */ V(0, 0, 1),
   /* 101  */ V(0, 0, 1),
   /* 110  */ V(0, 0, 1),
   /* 111  */ V(0, 0, 1),
 
   /* 000 ... */
           /* 000  */ V(2, 2, 3),/* 8 */
   /* 001  */ V(0, 2, 3),
   /* 010  */ V(1, 2, 2),
   /* 011  */ V(1, 2, 2),
   /* 100  */ V(2, 1, 2),
   /* 101  */ V(2, 1, 2),
   /* 110  */ V(2, 0, 2),
   /* 111  */ V(2, 0, 2)
 };
 
 static
 union huffpair const hufftab3[] = {
   /* 000  */ PTR(8, 3),
   /* 001  */ V(1, 0, 3),
   /* 010  */ V(1, 1, 2),
   /* 011  */ V(1, 1, 2),
   /* 100  */ V(0, 1, 2),
   /* 101  */ V(0, 1, 2),
   /* 110  */ V(0, 0, 2),
   /* 111  */ V(0, 0, 2),
 
   /* 000 ... */
           /* 000  */ V(2, 2, 3),/* 8 */
   /* 001  */ V(0, 2, 3),
   /* 010  */ V(1, 2, 2),
   /* 011  */ V(1, 2, 2),
   /* 100  */ V(2, 1, 2),
   /* 101  */ V(2, 1, 2),
   /* 110  */ V(2, 0, 2),
   /* 111  */ V(2, 0, 2)
 };
 
 static
 union huffpair const hufftab5[] = {
   /* 000  */ PTR(8, 4),
   /* 001  */ V(1, 1, 3),
   /* 010  */ V(0, 1, 3),
   /* 011  */ V(1, 0, 3),
   /* 100  */ V(0, 0, 1),
   /* 101  */ V(0, 0, 1),
   /* 110  */ V(0, 0, 1),
   /* 111  */ V(0, 0, 1),
 
   /* 000 ... */
           /* 0000 */ PTR(24, 1),/* 8 */
   /* 0001 */ V(3, 2, 4),
   /* 0010 */ V(3, 1, 3),
   /* 0011 */ V(3, 1, 3),
   /* 0100 */ V(1, 3, 4),
   /* 0101 */ V(0, 3, 4),
   /* 0110 */ V(3, 0, 4),
   /* 0111 */ V(2, 2, 4),
   /* 1000 */ V(1, 2, 3),
   /* 1001 */ V(1, 2, 3),
   /* 1010 */ V(2, 1, 3),
   /* 1011 */ V(2, 1, 3),
   /* 1100 */ V(0, 2, 3),
   /* 1101 */ V(0, 2, 3),
   /* 1110 */ V(2, 0, 3),
   /* 1111 */ V(2, 0, 3),
 
   /* 000 0000 ... */
           /* 0    */ V(3, 3, 1),/* 24 */
   /* 1    */ V(2, 3, 1)
 };
diff --git a/core/multimedia/opieplayer/libmad/huffman.h b/core/multimedia/opieplayer/libmad/huffman.h
index d051949..e4c1b35 100644
--- a/core/multimedia/opieplayer/libmad/huffman.h
+++ b/core/multimedia/opieplayer/libmad/huffman.h
@@ -1,66 +1,66 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_HUFFMAN_H
 # define LIBMAD_HUFFMAN_H
 
 union huffquad {
   struct {
     unsigned short final  :  1;
     unsigned short bits   :  3;
     unsigned short offset : 12;
   } ptr;
   struct {
     unsigned short final  :  1;
     unsigned short hlen   :  3;
     unsigned short v      :  1;
     unsigned short w      :  1;
     unsigned short x      :  1;
     unsigned short y      :  1;
   } value;
   unsigned short final    :  1;
 };
 
 union huffpair {
   struct {
     unsigned short final  :  1;
     unsigned short bits   :  3;
     unsigned short offset : 12;
   } ptr;
   struct {
     unsigned short final  :  1;
     unsigned short hlen   :  3;
     unsigned short x      :  4;
     unsigned short y      :  4;
   } value;
   unsigned short final    :  1;
 };
 
 struct hufftable {
   union huffpair const *table;
   unsigned short linbits;
   unsigned short startbits;
 };
 
 extern union huffquad const *const mad_huff_quad_table[2];
 extern struct hufftable const mad_huff_pair_table[32];
 
 # endif
diff --git a/core/multimedia/opieplayer/libmad/imdct_s.dat b/core/multimedia/opieplayer/libmad/imdct_s.dat
index ed70446..e2d91a0 100644
--- a/core/multimedia/opieplayer/libmad/imdct_s.dat
+++ b/core/multimedia/opieplayer/libmad/imdct_s.dat
@@ -1,62 +1,62 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
   /*  0 */  {  MAD_F(0x09bd7ca0) /*  0.608761429 */,
               -MAD_F(0x0ec835e8) /* -0.923879533 */,
               -MAD_F(0x0216a2a2) /* -0.130526192 */,
                MAD_F(0x0fdcf549) /*  0.991444861 */,
               -MAD_F(0x061f78aa) /* -0.382683432 */,
               -MAD_F(0x0cb19346) /* -0.793353340 */ },
 
   /*  6 */  { -MAD_F(0x0cb19346) /* -0.793353340 */,
                MAD_F(0x061f78aa) /*  0.382683432 */,
                MAD_F(0x0fdcf549) /*  0.991444861 */,
                MAD_F(0x0216a2a2) /*  0.130526192 */,
               -MAD_F(0x0ec835e8) /* -0.923879533 */,
               -MAD_F(0x09bd7ca0) /* -0.608761429 */ },
 
   /*  1 */  {  MAD_F(0x061f78aa) /*  0.382683432 */,
               -MAD_F(0x0ec835e8) /* -0.923879533 */,
                MAD_F(0x0ec835e8) /*  0.923879533 */,
               -MAD_F(0x061f78aa) /* -0.382683432 */,
               -MAD_F(0x061f78aa) /* -0.382683432 */,
                MAD_F(0x0ec835e8) /*  0.923879533 */ },
 
   /*  7 */  { -MAD_F(0x0ec835e8) /* -0.923879533 */,
               -MAD_F(0x061f78aa) /* -0.382683432 */,
                MAD_F(0x061f78aa) /*  0.382683432 */,
                MAD_F(0x0ec835e8) /*  0.923879533 */,
                MAD_F(0x0ec835e8) /*  0.923879533 */,
                MAD_F(0x061f78aa) /*  0.382683432 */ },
 
   /*  2 */  {  MAD_F(0x0216a2a2) /*  0.130526192 */,
               -MAD_F(0x061f78aa) /* -0.382683432 */,
                MAD_F(0x09bd7ca0) /*  0.608761429 */,
               -MAD_F(0x0cb19346) /* -0.793353340 */,
                MAD_F(0x0ec835e8) /*  0.923879533 */,
               -MAD_F(0x0fdcf549) /* -0.991444861 */ },
 
   /*  8 */  { -MAD_F(0x0fdcf549) /* -0.991444861 */,
               -MAD_F(0x0ec835e8) /* -0.923879533 */,
               -MAD_F(0x0cb19346) /* -0.793353340 */,
               -MAD_F(0x09bd7ca0) /* -0.608761429 */,
               -MAD_F(0x061f78aa) /* -0.382683432 */,
               -MAD_F(0x0216a2a2) /* -0.130526192 */ }
diff --git a/core/multimedia/opieplayer/libmad/layer12.c b/core/multimedia/opieplayer/libmad/layer12.c
index d291174..512b6a5 100644
--- a/core/multimedia/opieplayer/libmad/layer12.c
+++ b/core/multimedia/opieplayer/libmad/layer12.c
@@ -1,496 +1,534 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # ifdef HAVE_LIMITS_H
 #  include <limits.h>
 # else
 #  define CHAR_BIT  8
 # endif
 
 # include "fixed.h"
 # include "bit.h"
 # include "stream.h"
 # include "frame.h"
 # include "layer12.h"
 
 /*
  * scalefactor table
  * used in both Layer I and Layer II decoding
  */
 static
-mad_fixed_t const sf_table[63] = {
+mad_fixed_t const sf_table[64] = {
 # include "sf_table.dat"
 };
 
 /* --- Layer I ------------------------------------------------------------- */
 
 /* linear scaling table */
 static
 mad_fixed_t const linear_table[14] = {
   MAD_F(0x15555555),  /* 2^2  / (2^2  - 1) == 1.33333333333333 */
   MAD_F(0x12492492),  /* 2^3  / (2^3  - 1) == 1.14285714285714 */
   MAD_F(0x11111111),  /* 2^4  / (2^4  - 1) == 1.06666666666667 */
   MAD_F(0x10842108),  /* 2^5  / (2^5  - 1) == 1.03225806451613 */
   MAD_F(0x10410410),  /* 2^6  / (2^6  - 1) == 1.01587301587302 */
   MAD_F(0x10204081),  /* 2^7  / (2^7  - 1) == 1.00787401574803 */
   MAD_F(0x10101010),  /* 2^8  / (2^8  - 1) == 1.00392156862745 */
   MAD_F(0x10080402),  /* 2^9  / (2^9  - 1) == 1.00195694716243 */
   MAD_F(0x10040100),  /* 2^10 / (2^10 - 1) == 1.00097751710655 */
   MAD_F(0x10020040),  /* 2^11 / (2^11 - 1) == 1.00048851978505 */
   MAD_F(0x10010010),  /* 2^12 / (2^12 - 1) == 1.00024420024420 */
   MAD_F(0x10008004),  /* 2^13 / (2^13 - 1) == 1.00012208521548 */
   MAD_F(0x10004001),  /* 2^14 / (2^14 - 1) == 1.00006103888177 */
   MAD_F(0x10002000)   /* 2^15 / (2^15 - 1) == 1.00003051850948 */
 };
 
 /*
          * NAME:I_sample()
          * DESCRIPTION:decode one requantized Layer I sample from a bitstream
  */
 static
 mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb)
 {
   mad_fixed_t sample;
 
   sample = mad_bit_read(ptr, nb);
 
   /* invert most significant bit, extend sign, then scale to fixed format */
 
   sample ^= 1 << (nb - 1);
   sample |= -(sample & (1 << (nb - 1)));
 
   sample <<= MAD_F_FRACBITS - (nb - 1);
 
   /* requantize the sample */
 
   /* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */
 
   sample += MAD_F_ONE >> (nb - 1);
 
   return mad_f_mul(sample, linear_table[nb - 2]);
 
   /* s' = factor * s'' */
   /* (to be performed by caller) */
 }
 
 /*
          * NAME:layer->I()
          * DESCRIPTION:decode a single Layer I frame
  */
 int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame)
 {
   struct mad_header *header = &frame->header;
   unsigned int nch, bound, ch, s, sb, nb;
   unsigned char allocation[2][32], scalefactor[2][32];
 
   nch = MAD_NCHANNELS(header);
 
   bound = 32;
   if (header->mode == MAD_MODE_JOINT_STEREO) {
     header->flags |= MAD_FLAG_I_STEREO;
     bound = 4 + header->mode_extension * 4;
   }
 
   /* check CRC word */
 
   if (header->flags & MAD_FLAG_PROTECTION) {
     header->crc_check =
       mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)),
                   header->crc_check);
 
     if (header->crc_check != header->crc_target &&
         !(frame->options & MAD_OPTION_IGNORECRC)) {
       stream->error = MAD_ERROR_BADCRC;
       return -1;
     }
   }
 
   /* decode bit allocations */
 
   for (sb = 0; sb < bound; ++sb) {
     for (ch = 0; ch < nch; ++ch) {
       nb = mad_bit_read(&stream->ptr, 4);
 
       if (nb == 15) {
         stream->error = MAD_ERROR_BADBITALLOC;
         return -1;
       }
 
       allocation[ch][sb] = nb ? nb + 1 : 0;
     }
   }
 
   for (sb = bound; sb < 32; ++sb) {
     nb = mad_bit_read(&stream->ptr, 4);
 
     if (nb == 15) {
       stream->error = MAD_ERROR_BADBITALLOC;
       return -1;
     }
 
     allocation[0][sb] =
     allocation[1][sb] = nb ? nb + 1 : 0;
   }
 
   /* decode scalefactors */
 
   for (sb = 0; sb < 32; ++sb) {
     for (ch = 0; ch < nch; ++ch) {
       if (allocation[ch][sb]) {
         scalefactor[ch][sb] = mad_bit_read(&stream->ptr, 6);
 
+# if defined(OPT_STRICT)
+        /*
+         * Scalefactor index 63 does not appear in Table B.1 of
+         * ISO/IEC 11172-3. Nonetheless, other implementations accept it,
+         * so we only reject it if OPT_STRICT is defined.
+         */
         if (scalefactor[ch][sb] == 63) {
           stream->error = MAD_ERROR_BADSCALEFACTOR;
           return -1;
         }
+# endif
       }
     }
   }
 
   /* decode samples */
 
   for (s = 0; s < 12; ++s) {
     for (sb = 0; sb < bound; ++sb) {
       for (ch = 0; ch < nch; ++ch) {
         nb = allocation[ch][sb];
         frame->sbsample[ch][s][sb] = nb ?
           mad_f_mul(I_sample(&stream->ptr, nb),
                     sf_table[scalefactor[ch][sb]]) : 0;
       }
     }
 
     for (sb = bound; sb < 32; ++sb) {
       if ((nb = allocation[0][sb])) {
         mad_fixed_t sample;
 
         sample = I_sample(&stream->ptr, nb);
 
         for (ch = 0; ch < nch; ++ch) {
           frame->sbsample[ch][s][sb] =
             mad_f_mul(sample, sf_table[scalefactor[ch][sb]]);
         }
       }
       else {
         for (ch = 0; ch < nch; ++ch)
           frame->sbsample[ch][s][sb] = 0;
       }
     }
   }
 
   return 0;
 }
 
 /* --- Layer II ------------------------------------------------------------ */
 
 /* possible quantization per subband table */
 static
 struct {
   unsigned int sblimit;
   unsigned char const offsets[30];
 } const sbquant_table[5] = {
   /* ISO/IEC 11172-3 Table B.2a */
           { 27, { 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3,/* 0 */
           3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 } },
   /* ISO/IEC 11172-3 Table B.2b */
           { 30, { 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3,/* 1 */
           3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0 } },
   /* ISO/IEC 11172-3 Table B.2c */
           {  8, { 5, 5, 2, 2, 2, 2, 2, 2 } },                   /* 2 */
   /* ISO/IEC 11172-3 Table B.2d */
           { 12, { 5, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 } },       /* 3 */
   /* ISO/IEC 13818-3 Table B.1 */
           { 30, { 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,/* 4 */
           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } }
 };
 
 /* bit allocation table */
 static
 struct {
   unsigned short nbal;
   unsigned short offset;
 } const bitalloc_table[8] = {
   { 2, 0 },  /* 0 */
   { 2, 3 },  /* 1 */
   { 3, 3 },  /* 2 */
   { 3, 1 },  /* 3 */
   { 4, 2 },  /* 4 */
   { 4, 3 },  /* 5 */
   { 4, 4 },  /* 6 */
   { 4, 5 }   /* 7 */
 };
 
 /* offsets into quantization class table */
 static
 unsigned char const offset_table[6][15] = {
   { 0, 1, 16                                             },  /* 0 */
   { 0, 1,  2, 3, 4, 5, 16                                },  /* 1 */
   { 0, 1,  2, 3, 4, 5,  6, 7,  8,  9, 10, 11, 12, 13, 14 },  /* 2 */
   { 0, 1,  3, 4, 5, 6,  7, 8,  9, 10, 11, 12, 13, 14, 15 },  /* 3 */
   { 0, 1,  2, 3, 4, 5,  6, 7,  8,  9, 10, 11, 12, 13, 16 },  /* 4 */
   { 0, 2,  4, 5, 6, 7,  8, 9, 10, 11, 12, 13, 14, 15, 16 }   /* 5 */
 };
 
 /* quantization class table */
 static
 struct quantclass {
   unsigned short nlevels;
   unsigned char group;
   unsigned char bits;
   mad_fixed_t C;
   mad_fixed_t D;
 } const qc_table[17] = {
 # include "qc_table.dat"
 };
 
 /*
          * NAME:II_samples()
          * DESCRIPTION:decode three requantized Layer II samples from a bitstream
  */
 static
 void II_samples(struct mad_bitptr *ptr,
                 struct quantclass const *quantclass,
                 mad_fixed_t output[3])
 {
   unsigned int nb, s, sample[3];
 
   if ((nb = quantclass->group)) {
     unsigned int c, nlevels;
 
     /* degrouping */
     c = mad_bit_read(ptr, quantclass->bits);
     nlevels = quantclass->nlevels;
 
     for (s = 0; s < 3; ++s) {
       sample[s] = c % nlevels;
       c /= nlevels;
     }
   }
   else {
     nb = quantclass->bits;
 
     for (s = 0; s < 3; ++s)
       sample[s] = mad_bit_read(ptr, nb);
   }
 
   for (s = 0; s < 3; ++s) {
     mad_fixed_t requantized;
 
     /* invert most significant bit, extend sign, then scale to fixed format */
 
     requantized  = sample[s] ^ (1 << (nb - 1));
     requantized |= -(requantized & (1 << (nb - 1)));
 
     requantized <<= MAD_F_FRACBITS - (nb - 1);
 
     /* requantize the sample */
 
     /* s'' = C * (s''' + D) */
 
     output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C);
 
     /* s' = factor * s'' */
     /* (to be performed by caller) */
   }
 }
 
 /*
          * NAME:layer->II()
          * DESCRIPTION:decode a single Layer II frame
  */
 int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame)
 {
   struct mad_header *header = &frame->header;
   struct mad_bitptr start;
   unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb;
   unsigned char const *offsets;
   unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3];
   mad_fixed_t samples[3];
 
   nch = MAD_NCHANNELS(header);
 
   if (header->flags & MAD_FLAG_LSF_EXT)
     index = 4;
+  else if (header->flags & MAD_FLAG_FREEFORMAT)
+    goto freeformat;
   else {
-    switch (nch == 2 ? header->bitrate / 2 : header->bitrate) {
-    case 32000:
-    case 48000:
-      index = (header->samplerate == 32000) ? 3 : 2;
-      break;
+    unsigned long bitrate_per_channel;
+
+    bitrate_per_channel = header->bitrate;
+    if (nch == 2) {
+      bitrate_per_channel /= 2;
+
+# if defined(OPT_STRICT)
+      /*
+       * ISO/IEC 11172-3 allows only single channel mode for 32, 48, 56, and
+       * 80 kbps bitrates in Layer II, but some encoders ignore this
+       * restriction. We enforce it if OPT_STRICT is defined.
+       */
+      if (bitrate_per_channel <= 28000 || bitrate_per_channel == 40000) {
+        stream->error = MAD_ERROR_BADMODE;
+        return -1;
+      }
+# endif
+    }
+    else {  /* nch == 1 */
+      if (bitrate_per_channel > 192000) {
+        /*
+         * ISO/IEC 11172-3 does not allow single channel mode for 224, 256,
+         * 320, or 384 kbps bitrates in Layer II.
+         */
+        stream->error = MAD_ERROR_BADMODE;
+        return -1;
+      }
+    }
 
-    case 56000:
-    case 64000:
-    case 80000:
+    if (bitrate_per_channel <= 48000)
+      index = (header->samplerate == 32000) ? 3 : 2;
+    else if (bitrate_per_channel <= 80000)
       index = 0;
-      break;
-
-    default:
+    else {
+    freeformat:
       index = (header->samplerate == 48000) ? 0 : 1;
     }
   }
 
   sblimit = sbquant_table[index].sblimit;
   offsets = sbquant_table[index].offsets;
 
   bound = 32;
   if (header->mode == MAD_MODE_JOINT_STEREO) {
     header->flags |= MAD_FLAG_I_STEREO;
     bound = 4 + header->mode_extension * 4;
   }
 
   if (bound > sblimit)
     bound = sblimit;
 
   start = stream->ptr;
 
   /* decode bit allocations */
 
   for (sb = 0; sb < bound; ++sb) {
     nbal = bitalloc_table[offsets[sb]].nbal;
 
     for (ch = 0; ch < nch; ++ch)
       allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal);
   }
 
   for (sb = bound; sb < sblimit; ++sb) {
     nbal = bitalloc_table[offsets[sb]].nbal;
 
     allocation[0][sb] =
     allocation[1][sb] = mad_bit_read(&stream->ptr, nbal);
   }
 
   /* decode scalefactor selection info */
 
   for (sb = 0; sb < sblimit; ++sb) {
     for (ch = 0; ch < nch; ++ch) {
       if (allocation[ch][sb])
         scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2);
     }
   }
 
   /* check CRC word */
 
   if (header->flags & MAD_FLAG_PROTECTION) {
     header->crc_check =
       mad_bit_crc(start, mad_bit_length(&start, &stream->ptr),
                   header->crc_check);
 
     if (header->crc_check != header->crc_target &&
         !(frame->options & MAD_OPTION_IGNORECRC)) {
       stream->error = MAD_ERROR_BADCRC;
       return -1;
     }
   }
 
   /* decode scalefactors */
 
   for (sb = 0; sb < sblimit; ++sb) {
     for (ch = 0; ch < nch; ++ch) {
       if (allocation[ch][sb]) {
         scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6);
 
         switch (scfsi[ch][sb]) {
         case 2:
           scalefactor[ch][sb][2] =
           scalefactor[ch][sb][1] =
           scalefactor[ch][sb][0];
           break;
 
         case 0:
           scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6);
           /* fall through */
 
         case 1:
         case 3:
           scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6);
         }
 
         if (scfsi[ch][sb] & 1)
           scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1];
 
+# if defined(OPT_STRICT)
+        /*
+         * Scalefactor index 63 does not appear in Table B.1 of
+         * ISO/IEC 11172-3. Nonetheless, other implementations accept it,
+         * so we only reject it if OPT_STRICT is defined.
+         */
         if (scalefactor[ch][sb][0] == 63 ||
             scalefactor[ch][sb][1] == 63 ||
             scalefactor[ch][sb][2] == 63) {
           stream->error = MAD_ERROR_BADSCALEFACTOR;
           return -1;
         }
+# endif
       }
     }
   }
 
   /* decode samples */
 
   for (gr = 0; gr < 12; ++gr) {
     for (sb = 0; sb < bound; ++sb) {
       for (ch = 0; ch < nch; ++ch) {
         if ((index = allocation[ch][sb])) {
           index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1];
 
           II_samples(&stream->ptr, &qc_table[index], samples);
 
           for (s = 0; s < 3; ++s) {
             frame->sbsample[ch][3 * gr + s][sb] =
               mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
           }
         }
         else {
           for (s = 0; s < 3; ++s)
             frame->sbsample[ch][3 * gr + s][sb] = 0;
         }
       }
     }
 
     for (sb = bound; sb < sblimit; ++sb) {
       if ((index = allocation[0][sb])) {
         index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1];
 
         II_samples(&stream->ptr, &qc_table[index], samples);
 
         for (ch = 0; ch < nch; ++ch) {
           for (s = 0; s < 3; ++s) {
             frame->sbsample[ch][3 * gr + s][sb] =
               mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]);
           }
         }
       }
       else {
         for (ch = 0; ch < nch; ++ch) {
           for (s = 0; s < 3; ++s)
             frame->sbsample[ch][3 * gr + s][sb] = 0;
         }
       }
     }
 
     for (ch = 0; ch < nch; ++ch) {
       for (s = 0; s < 3; ++s) {
         for (sb = sblimit; sb < 32; ++sb)
           frame->sbsample[ch][3 * gr + s][sb] = 0;
       }
     }
   }
 
   return 0;
 }
diff --git a/core/multimedia/opieplayer/libmad/layer12.h b/core/multimedia/opieplayer/libmad/layer12.h
index c673726..3fe6bd8 100644
--- a/core/multimedia/opieplayer/libmad/layer12.h
+++ b/core/multimedia/opieplayer/libmad/layer12.h
@@ -1,31 +1,31 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_LAYER12_H
 # define LIBMAD_LAYER12_H
 
 # include "stream.h"
 # include "frame.h"
 
 int mad_layer_I(struct mad_stream *, struct mad_frame *);
 int mad_layer_II(struct mad_stream *, struct mad_frame *);
 
 # endif
diff --git a/core/multimedia/opieplayer/libmad/layer3.c b/core/multimedia/opieplayer/libmad/layer3.c
index 03f13fe..3c5dd9e 100644
--- a/core/multimedia/opieplayer/libmad/layer3.c
+++ b/core/multimedia/opieplayer/libmad/layer3.c
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include <stdlib.h>
 # include <string.h>
 
 # ifdef HAVE_ASSERT_H
 #  include <assert.h>
 # endif
 
 # ifdef HAVE_LIMITS_H
 #  include <limits.h>
 # else
 #  define CHAR_BIT  8
 # endif
 
 # include "fixed.h"
 # include "bit.h"
 # include "stream.h"
 # include "frame.h"
 # include "huffman.h"
 # include "layer3.h"
 
 /* --- Layer III ----------------------------------------------------------- */
 
 enum {
   count1table_select = 0x01,
   scalefac_scale     = 0x02,
           preflag     = 0x04,
   mixed_block_flag   = 0x08
 };
 
 enum {
   I_STEREO  = 0x1,
   MS_STEREO = 0x2
 };
 
 struct sideinfo {
   unsigned int main_data_begin;
   unsigned int private_bits;
 
   unsigned char scfsi[2];
 
   struct granule {
     struct channel {
       /* from side info */
       unsigned short part2_3_length;
       unsigned short big_values;
       unsigned short global_gain;
       unsigned short scalefac_compress;
 
       unsigned char flags;
       unsigned char block_type;
       unsigned char table_select[3];
       unsigned char subblock_gain[3];
       unsigned char region0_count;
       unsigned char region1_count;
 
       /* from main_data */
               unsigned char scalefac[39];/* scalefac_l and/or scalefac_s */
     } ch[2];
   } gr[2];
 };
 
 /*
  * scalefactor bit lengths
  * derived from section 2.4.2.7 of ISO/IEC 11172-3
  */
 static
 struct {
   unsigned char slen1;
   unsigned char slen2;
 } const sflen_table[16] = {
   { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
   { 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
@@ -195,366 +195,366 @@ static
 unsigned char const sfb_32000_mixed[] = {
   /* long */   4,  4,  4,  4,  4,  4,  6,  6,
   /* short */  4,  4,  4,  6,  6,  6,  8,  8,  8, 12,
               12, 12, 16, 16, 16, 20, 20, 20, 26, 26,
               26, 34, 34, 34, 42, 42, 42, 12, 12, 12
 };
 
 /*
  * MPEG-2 scalefactor band widths
  * derived from Table B.2 of ISO/IEC 13818-3
  */
 static
 unsigned char const sfb_24000_long[] = {
    6,  6,  6,  6,  6,  6,  8, 10, 12,  14,  16,
   18, 22, 26, 32, 38, 46, 54, 62, 70,  76,  36
 };
 
 static
 unsigned char const sfb_22050_long[] = {
    6,  6,  6,  6,  6,  6,  8, 10, 12,  14,  16,
   20, 24, 28, 32, 38, 46, 52, 60, 68,  58,  54
 };
 
 # define sfb_16000_long  sfb_22050_long
 
 static
 unsigned char const sfb_24000_short[] = {
    4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  8,
    8,  8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
   18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
 };
 
 static
 unsigned char const sfb_22050_short[] = {
    4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  6,
    6,  6,  8,  8,  8, 10, 10, 10, 14, 14, 14, 18, 18,
   18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
 };
 
 static
 unsigned char const sfb_16000_short[] = {
    4,  4,  4,  4,  4,  4,  4,  4,  4,  6,  6,  6,  8,
    8,  8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
   18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
 };
 
 static
 unsigned char const sfb_24000_mixed[] = {
   /* long */   6,  6,  6,  6,  6,  6,
   /* short */  6,  6,  6,  8,  8,  8, 10, 10, 10, 12,
               12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
               24, 32, 32, 32, 44, 44, 44, 12, 12, 12
 };
 
 static
 unsigned char const sfb_22050_mixed[] = {
   /* long */   6,  6,  6,  6,  6,  6,
   /* short */  6,  6,  6,  6,  6,  6,  8,  8,  8, 10,
               10, 10, 14, 14, 14, 18, 18, 18, 26, 26,
               26, 32, 32, 32, 42, 42, 42, 18, 18, 18
 };
 
 static
 unsigned char const sfb_16000_mixed[] = {
   /* long */   6,  6,  6,  6,  6,  6,
   /* short */  6,  6,  6,  8,  8,  8, 10, 10, 10, 12,
               12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
               24, 30, 30, 30, 40, 40, 40, 18, 18, 18
 };
 
 /*
  * MPEG 2.5 scalefactor band widths
  * derived from public sources
  */
 # define sfb_12000_long  sfb_16000_long
 # define sfb_11025_long  sfb_12000_long
 
 static
 unsigned char const sfb_8000_long[] = {
   12, 12, 12, 12, 12, 12, 16, 20, 24,  28,  32,
   40, 48, 56, 64, 76, 90,  2,  2,  2,   2,   2
 };
 
 # define sfb_12000_short  sfb_16000_short
 # define sfb_11025_short  sfb_12000_short
 
 static
 unsigned char const sfb_8000_short[] = {
    8,  8,  8,  8,  8,  8,  8,  8,  8, 12, 12, 12, 16,
   16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36,
   36,  2,  2,  2,  2,  2,  2,  2,  2,  2, 26, 26, 26
 };
 
 # define sfb_12000_mixed  sfb_16000_mixed
 # define sfb_11025_mixed  sfb_12000_mixed
 
-/* the 8000 Hz short block scalefactor bands do not break after the first 36
-   frequency lines, so this is probably wrong */
+/* the 8000 Hz short block scalefactor bands do not break after
+   the first 36 frequency lines, so this is probably wrong */
 static
 unsigned char const sfb_8000_mixed[] = {
   /* long */  12, 12, 12,
   /* short */  4,  4,  4,  8,  8,  8, 12, 12, 12, 16, 16, 16,
               20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36,
                2,  2,  2,  2,  2,  2,  2,  2,  2, 26, 26, 26
 };
 
 static
 struct {
   unsigned char const *l;
   unsigned char const *s;
   unsigned char const *m;
 } const sfbwidth_table[9] = {
   { sfb_48000_long, sfb_48000_short, sfb_48000_mixed },
   { sfb_44100_long, sfb_44100_short, sfb_44100_mixed },
   { sfb_32000_long, sfb_32000_short, sfb_32000_mixed },
   { sfb_24000_long, sfb_24000_short, sfb_24000_mixed },
   { sfb_22050_long, sfb_22050_short, sfb_22050_mixed },
   { sfb_16000_long, sfb_16000_short, sfb_16000_mixed },
   { sfb_12000_long, sfb_12000_short, sfb_12000_mixed },
   { sfb_11025_long, sfb_11025_short, sfb_11025_mixed },
   {  sfb_8000_long,  sfb_8000_short,  sfb_8000_mixed }
 };
 
 /*
  * scalefactor band preemphasis (used only when preflag is set)
  * derived from Table B.6 of ISO/IEC 11172-3
  */
 static
 unsigned char const pretab[22] = {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0
 };
 
 /*
  * table for requantization
  *
  * rq_table[x].mantissa * 2^(rq_table[x].exponent) = x^(4/3)
  */
 static
 struct fixedfloat {
   unsigned long mantissa  : 27;
   unsigned short exponent :  5;
 } const rq_table[8207] = {
 # include "rq_table.dat"
 };
 
 /*
  * fractional powers of two
  * used for requantization and joint stereo decoding
  *
  * root_table[3 + x] = 2^(x/4)
  */
 static
 mad_fixed_t const root_table[7] = {
   MAD_F(0x09837f05) /* 2^(-3/4) == 0.59460355750136 */,
   MAD_F(0x0b504f33) /* 2^(-2/4) == 0.70710678118655 */,
   MAD_F(0x0d744fcd) /* 2^(-1/4) == 0.84089641525371 */,
   MAD_F(0x10000000) /* 2^( 0/4) == 1.00000000000000 */,
   MAD_F(0x1306fe0a) /* 2^(+1/4) == 1.18920711500272 */,
   MAD_F(0x16a09e66) /* 2^(+2/4) == 1.41421356237310 */,
   MAD_F(0x1ae89f99) /* 2^(+3/4) == 1.68179283050743 */
 };
 
 /*
  * coefficients for aliasing reduction
  * derived from Table B.9 of ISO/IEC 11172-3
  *
  *  c[]  = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 }
  * cs[i] =    1 / sqrt(1 + c[i]^2)
  * ca[i] = c[i] / sqrt(1 + c[i]^2)
  */
 static
 mad_fixed_t const cs[8] = {
   +MAD_F(0x0db84a81) /* +0.857492926 */, +MAD_F(0x0e1b9d7f) /* +0.881741997 */,
   +MAD_F(0x0f31adcf) /* +0.949628649 */, +MAD_F(0x0fbba815) /* +0.983314592 */,
   +MAD_F(0x0feda417) /* +0.995517816 */, +MAD_F(0x0ffc8fc8) /* +0.999160558 */,
   +MAD_F(0x0fff964c) /* +0.999899195 */, +MAD_F(0x0ffff8d3) /* +0.999993155 */
 };
 
 static
 mad_fixed_t const ca[8] = {
   -MAD_F(0x083b5fe7) /* -0.514495755 */, -MAD_F(0x078c36d2) /* -0.471731969 */,
   -MAD_F(0x05039814) /* -0.313377454 */, -MAD_F(0x02e91dd1) /* -0.181913200 */,
   -MAD_F(0x0183603a) /* -0.094574193 */, -MAD_F(0x00a7cb87) /* -0.040965583 */,
   -MAD_F(0x003a2847) /* -0.014198569 */, -MAD_F(0x000f27b4) /* -0.003699975 */
 };
 
 /*
  * IMDCT coefficients for short blocks
  * derived from section 2.4.3.4.10.2 of ISO/IEC 11172-3
  *
- * imdct_s[i/even][k] = cos((PI / 24) * (2 * (i / 2) + 7) * (2 * k + 1))
+ * imdct_s[i/even][k] = cos((PI / 24) * (2 *       (i / 2) + 7) * (2 * k + 1))
  * imdct_s[i /odd][k] = cos((PI / 24) * (2 * (6 + (i-1)/2) + 7) * (2 * k + 1))
  */
 static
 mad_fixed_t const imdct_s[6][6] = {
 # include "imdct_s.dat"
 };
 
 # if !defined(ASO_IMDCT)
 /*
  * windowing coefficients for long blocks
  * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
  *
  * window_l[i] = sin((PI / 36) * (i + 1/2))
  */
 static
 mad_fixed_t const window_l[36] = {
   MAD_F(0x00b2aa3e) /* 0.043619387 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
   MAD_F(0x03768962) /* 0.216439614 */, MAD_F(0x04cfb0e2) /* 0.300705800 */,
   MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x07635284) /* 0.461748613 */,
   MAD_F(0x0898c779) /* 0.537299608 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
   MAD_F(0x0acf37ad) /* 0.675590208 */, MAD_F(0x0bcbe352) /* 0.737277337 */,
   MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x0d7e8807) /* 0.843391446 */,
 
   MAD_F(0x0e313245) /* 0.887010833 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
   MAD_F(0x0f426cb5) /* 0.953716951 */, MAD_F(0x0f9ee890) /* 0.976296007 */,
   MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ffc19fd) /* 0.999048222 */,
   MAD_F(0x0ffc19fd) /* 0.999048222 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
   MAD_F(0x0f9ee890) /* 0.976296007 */, MAD_F(0x0f426cb5) /* 0.953716951 */,
   MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0e313245) /* 0.887010833 */,
 
   MAD_F(0x0d7e8807) /* 0.843391446 */, MAD_F(0x0cb19346) /* 0.793353340 */,
   MAD_F(0x0bcbe352) /* 0.737277337 */, MAD_F(0x0acf37ad) /* 0.675590208 */,
   MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0898c779) /* 0.537299608 */,
   MAD_F(0x07635284) /* 0.461748613 */, MAD_F(0x061f78aa) /* 0.382683432 */,
   MAD_F(0x04cfb0e2) /* 0.300705800 */, MAD_F(0x03768962) /* 0.216439614 */,
   MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x00b2aa3e) /* 0.043619387 */,
 };
 # endif  /* ASO_IMDCT */
 
 /*
  * windowing coefficients for short blocks
  * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
  *
  * window_s[i] = sin((PI / 12) * (i + 1/2))
  */
 static
 mad_fixed_t const window_s[12] = {
   MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x061f78aa) /* 0.382683432 */,
   MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0cb19346) /* 0.793353340 */,
   MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
   MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
   MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
   MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
 };
 
 /*
  * coefficients for intensity stereo processing
  * derived from section 2.4.3.4.9.3 of ISO/IEC 11172-3
  *
  * is_ratio[i] = tan(i * (PI / 12))
  * is_table[i] = is_ratio[i] / (1 + is_ratio[i])
  */
 static
 mad_fixed_t const is_table[7] = {
   MAD_F(0x00000000) /* 0.000000000 */,
   MAD_F(0x0361962f) /* 0.211324865 */,
   MAD_F(0x05db3d74) /* 0.366025404 */,
   MAD_F(0x08000000) /* 0.500000000 */,
   MAD_F(0x0a24c28c) /* 0.633974596 */,
   MAD_F(0x0c9e69d1) /* 0.788675135 */,
   MAD_F(0x10000000) /* 1.000000000 */
 };
 
 /*
  * coefficients for LSF intensity stereo processing
  * derived from section 2.4.3.2 of ISO/IEC 13818-3
  *
  * is_lsf_table[0][i] = (1 / sqrt(sqrt(2)))^(i + 1)
- * is_lsf_table[1][i] = (1 / sqrt(2))^(i + 1)
+ * is_lsf_table[1][i] = (1 /      sqrt(2)) ^(i + 1)
  */
 static
 mad_fixed_t const is_lsf_table[2][15] = {
   {
     MAD_F(0x0d744fcd) /* 0.840896415 */,
     MAD_F(0x0b504f33) /* 0.707106781 */,
     MAD_F(0x09837f05) /* 0.594603558 */,
     MAD_F(0x08000000) /* 0.500000000 */,
     MAD_F(0x06ba27e6) /* 0.420448208 */,
     MAD_F(0x05a8279a) /* 0.353553391 */,
     MAD_F(0x04c1bf83) /* 0.297301779 */,
     MAD_F(0x04000000) /* 0.250000000 */,
     MAD_F(0x035d13f3) /* 0.210224104 */,
     MAD_F(0x02d413cd) /* 0.176776695 */,
     MAD_F(0x0260dfc1) /* 0.148650889 */,
     MAD_F(0x02000000) /* 0.125000000 */,
     MAD_F(0x01ae89fa) /* 0.105112052 */,
     MAD_F(0x016a09e6) /* 0.088388348 */,
     MAD_F(0x01306fe1) /* 0.074325445 */
   }, {
     MAD_F(0x0b504f33) /* 0.707106781 */,
     MAD_F(0x08000000) /* 0.500000000 */,
     MAD_F(0x05a8279a) /* 0.353553391 */,
     MAD_F(0x04000000) /* 0.250000000 */,
     MAD_F(0x02d413cd) /* 0.176776695 */,
     MAD_F(0x02000000) /* 0.125000000 */,
     MAD_F(0x016a09e6) /* 0.088388348 */,
     MAD_F(0x01000000) /* 0.062500000 */,
     MAD_F(0x00b504f3) /* 0.044194174 */,
     MAD_F(0x00800000) /* 0.031250000 */,
     MAD_F(0x005a827a) /* 0.022097087 */,
     MAD_F(0x00400000) /* 0.015625000 */,
     MAD_F(0x002d413d) /* 0.011048543 */,
     MAD_F(0x00200000) /* 0.007812500 */,
     MAD_F(0x0016a09e) /* 0.005524272 */
   }
 };
 
 /*
          * NAME:III_sideinfo()
          * DESCRIPTION:decode frame side information from a bitstream
  */
 static
 enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
                             int lsf, struct sideinfo *si,
                             unsigned int *data_bitlen,
                             unsigned int *priv_bitlen)
 {
   unsigned int ngr, gr, ch, i;
   enum mad_error result = MAD_ERROR_NONE;
 
   *data_bitlen = 0;
   *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3);
 
   si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9);
   si->private_bits    = mad_bit_read(ptr, *priv_bitlen);
 
   ngr = 1;
   if (!lsf) {
     ngr = 2;
 
     for (ch = 0; ch < nch; ++ch)
       si->scfsi[ch] = mad_bit_read(ptr, 4);
   }
 
   for (gr = 0; gr < ngr; ++gr) {
     struct granule *granule = &si->gr[gr];
 
     for (ch = 0; ch < nch; ++ch) {
       struct channel *channel = &granule->ch[ch];
 
       channel->part2_3_length    = mad_bit_read(ptr, 12);
       channel->big_values        = mad_bit_read(ptr, 9);
       channel->global_gain       = mad_bit_read(ptr, 8);
       channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4);
 
       *data_bitlen += channel->part2_3_length;
 
       if (channel->big_values > 288 && result == 0)
         result = MAD_ERROR_BADBIGVALUES;
 
       channel->flags = 0;
 
       /* window_switching_flag */
       if (mad_bit_read(ptr, 1)) {
         channel->block_type = mad_bit_read(ptr, 2);
 
         if (channel->block_type == 0 && result == 0)
           result = MAD_ERROR_BADBLOCKTYPE;
 
         if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)
           result = MAD_ERROR_BADSCFSI;
 
         channel->region0_count = 7;
         channel->region1_count = 36;
 
@@ -1482,192 +1482,379 @@ enum mad_error III_stereo(mad_fixed_t xr[2][576],
         n = sfbwidth[sfbi];
 
         if (!(modes[sfbi] & I_STEREO))
           continue;
 
         is_pos = right_ch->scalefac[sfbi];
 
         if (is_pos >= 7) {  /* illegal intensity position */
           modes[sfbi] &= ~I_STEREO;
           continue;
         }
 
         for (i = 0; i < n; ++i) {
           register mad_fixed_t left;
 
           left = xr[0][l + i];
 
           xr[0][l + i] = mad_f_mul(left, is_table[    is_pos]);
           xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
         }
       }
     }
   }
 
   /* middle/side stereo */
 
   if (header->mode_extension & MS_STEREO) {
     register mad_fixed_t invsqrt2;
 
     header->flags |= MAD_FLAG_MS_STEREO;
 
     invsqrt2 = root_table[3 + -2];
 
     for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
       n = sfbwidth[sfbi];
 
       if (modes[sfbi] != MS_STEREO)
         continue;
 
       for (i = 0; i < n; ++i) {
         register mad_fixed_t m, s;
 
         m = xr[0][l + i];
         s = xr[1][l + i];
 
         xr[0][l + i] = mad_f_mul(m + s, invsqrt2);  /* l = (m + s) / sqrt(2) */
         xr[1][l + i] = mad_f_mul(m - s, invsqrt2);  /* r = (m - s) / sqrt(2) */
       }
     }
   }
 
   return MAD_ERROR_NONE;
 }
 
 /*
          * NAME:III_aliasreduce()
          * DESCRIPTION:perform frequency line alias reduction
  */
 static
 void III_aliasreduce(mad_fixed_t xr[576], int lines)
 {
   mad_fixed_t const *bound;
   int i;
 
   bound = &xr[lines];
   for (xr += 18; xr < bound; xr += 18) {
     for (i = 0; i < 8; ++i) {
       register mad_fixed_t a, b;
       register mad_fixed64hi_t hi;
       register mad_fixed64lo_t lo;
 
       a = xr[-1 - i];
       b = xr[     i];
 
 # if defined(ASO_ZEROCHECK)
       if (a | b) {
 # endif
         MAD_F_ML0(hi, lo,  a, cs[i]);
         MAD_F_MLA(hi, lo, -b, ca[i]);
 
         xr[-1 - i] = MAD_F_MLZ(hi, lo);
 
         MAD_F_ML0(hi, lo,  b, cs[i]);
         MAD_F_MLA(hi, lo,  a, ca[i]);
 
         xr[     i] = MAD_F_MLZ(hi, lo);
 # if defined(ASO_ZEROCHECK)
       }
 # endif
     }
   }
 }
 
 # if defined(ASO_IMDCT)
 void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int);
 # else
+#  if 1
+static
+void fastsdct(mad_fixed_t const x[9], mad_fixed_t y[18])
+{
+  mad_fixed_t a0,  a1,  a2,  a3,  a4,  a5,  a6,  a7,  a8,  a9,  a10, a11, a12;
+  mad_fixed_t a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25;
+  mad_fixed_t m0,  m1,  m2,  m3,  m4,  m5,  m6,  m7;
+
+  enum {
+    c0 =  MAD_F(0x1f838b8d),  /* 2 * cos( 1 * PI / 18) */
+    c1 =  MAD_F(0x1bb67ae8),  /* 2 * cos( 3 * PI / 18) */
+    c2 =  MAD_F(0x18836fa3),  /* 2 * cos( 4 * PI / 18) */
+    c3 =  MAD_F(0x1491b752),  /* 2 * cos( 5 * PI / 18) */
+    c4 =  MAD_F(0x0af1d43a),  /* 2 * cos( 7 * PI / 18) */
+    c5 =  MAD_F(0x058e86a0),  /* 2 * cos( 8 * PI / 18) */
+    c6 = -MAD_F(0x1e11f642)   /* 2 * cos(16 * PI / 18) */
+  };
+
+  a0 = x[3] + x[5];
+  a1 = x[3] - x[5];
+  a2 = x[6] + x[2];
+  a3 = x[6] - x[2];
+  a4 = x[1] + x[7];
+  a5 = x[1] - x[7];
+  a6 = x[8] + x[0];
+  a7 = x[8] - x[0];
+
+  a8  = a0  + a2;
+  a9  = a0  - a2;
+  a10 = a0  - a6;
+  a11 = a2  - a6;
+  a12 = a8  + a6;
+  a13 = a1  - a3;
+  a14 = a13 + a7;
+  a15 = a3  + a7;
+  a16 = a1  - a7;
+  a17 = a1  + a3;
+
+  m0 = mad_f_mul(a17, -c3);
+  m1 = mad_f_mul(a16, -c0);
+  m2 = mad_f_mul(a15, -c4);
+  m3 = mad_f_mul(a14, -c1);
+  m4 = mad_f_mul(a5,  -c1);
+  m5 = mad_f_mul(a11, -c6);
+  m6 = mad_f_mul(a10, -c5);
+  m7 = mad_f_mul(a9,  -c2);
+
+  a18 =     x[4] + a4;
+  a19 = 2 * x[4] - a4;
+  a20 = a19 + m5;
+  a21 = a19 - m5;
+  a22 = a19 + m6;
+  a23 = m4  + m2;
+  a24 = m4  - m2;
+  a25 = m4  + m1;
+
+  /* output to every other slot for convenience */
+
+  y[ 0] = a18 + a12;
+  y[ 2] = m0  - a25;
+  y[ 4] = m7  - a20;
+  y[ 6] = m3;
+  y[ 8] = a21 - m6;
+  y[10] = a24 - m1;
+  y[12] = a12 - 2 * a18;
+  y[14] = a23 + m0;
+  y[16] = a22 + m7;
+}
+
+static inline
+void sdctII(mad_fixed_t const x[18], mad_fixed_t X[18])
+{
+  mad_fixed_t tmp[9];
+  int i;
+
+  /* scale[i] = 2 * cos(PI * (2 * i + 1) / (2 * 18)) */
+  static mad_fixed_t const scale[9] = {
+    MAD_F(0x1fe0d3b4), MAD_F(0x1ee8dd47), MAD_F(0x1d007930),
+    MAD_F(0x1a367e59), MAD_F(0x16a09e66), MAD_F(0x125abcf8),
+    MAD_F(0x0d8616bc), MAD_F(0x08483ee1), MAD_F(0x02c9fad7)
+  };
+
+  /* divide the 18-point SDCT-II into two 9-point SDCT-IIs */
+
+  /* even input butterfly */
+
+  for (i = 0; i < 9; i += 3) {
+    tmp[i + 0] = x[i + 0] + x[18 - (i + 0) - 1];
+    tmp[i + 1] = x[i + 1] + x[18 - (i + 1) - 1];
+    tmp[i + 2] = x[i + 2] + x[18 - (i + 2) - 1];
+  }
+
+  fastsdct(tmp, &X[0]);
+
+  /* odd input butterfly and scaling */
+
+  for (i = 0; i < 9; i += 3) {
+    tmp[i + 0] = mad_f_mul(x[i + 0] - x[18 - (i + 0) - 1], scale[i + 0]);
+    tmp[i + 1] = mad_f_mul(x[i + 1] - x[18 - (i + 1) - 1], scale[i + 1]);
+    tmp[i + 2] = mad_f_mul(x[i + 2] - x[18 - (i + 2) - 1], scale[i + 2]);
+  }
+
+  fastsdct(tmp, &X[1]);
+
+  /* output accumulation */
+
+  for (i = 3; i < 18; i += 8) {
+    X[i + 0] -= X[(i + 0) - 2];
+    X[i + 2] -= X[(i + 2) - 2];
+    X[i + 4] -= X[(i + 4) - 2];
+    X[i + 6] -= X[(i + 6) - 2];
+  }
+}
+
+static inline
+void dctIV(mad_fixed_t const y[18], mad_fixed_t X[18])
+{
+  mad_fixed_t tmp[18];
+  int i;
+
+  /* scale[i] = 2 * cos(PI * (2 * i + 1) / (4 * 18)) */
+  static mad_fixed_t const scale[18] = {
+    MAD_F(0x1ff833fa), MAD_F(0x1fb9ea93), MAD_F(0x1f3dd120),
+    MAD_F(0x1e84d969), MAD_F(0x1d906bcf), MAD_F(0x1c62648b),
+    MAD_F(0x1afd100f), MAD_F(0x1963268b), MAD_F(0x1797c6a4),
+    MAD_F(0x159e6f5b), MAD_F(0x137af940), MAD_F(0x11318ef3),
+    MAD_F(0x0ec6a507), MAD_F(0x0c3ef153), MAD_F(0x099f61c5),
+    MAD_F(0x06ed12c5), MAD_F(0x042d4544), MAD_F(0x0165547c)
+  };
+
+  /* scaling */
+
+  for (i = 0; i < 18; i += 3) {
+    tmp[i + 0] = mad_f_mul(y[i + 0], scale[i + 0]);
+    tmp[i + 1] = mad_f_mul(y[i + 1], scale[i + 1]);
+    tmp[i + 2] = mad_f_mul(y[i + 2], scale[i + 2]);
+  }
+
+  /* SDCT-II */
+
+  sdctII(tmp, X);
+
+  /* scale reduction and output accumulation */
+
+  X[0] /= 2;
+  for (i = 1; i < 17; i += 4) {
+    X[i + 0] = X[i + 0] / 2 - X[(i + 0) - 1];
+    X[i + 1] = X[i + 1] / 2 - X[(i + 1) - 1];
+    X[i + 2] = X[i + 2] / 2 - X[(i + 2) - 1];
+    X[i + 3] = X[i + 3] / 2 - X[(i + 3) - 1];
+  }
+  X[17] = X[17] / 2 - X[16];
+}
+
+/*
+         * NAME:imdct36
+         * DESCRIPTION:perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm
+ */
+static inline
+void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36])
+{
+  mad_fixed_t tmp[18];
+  int i;
+
+  /* DCT-IV */
+
+  dctIV(x, tmp);
+
+  /* convert 18-point DCT-IV to 36-point IMDCT */
+
+  for (i =  0; i <  9; i += 3) {
+    y[i + 0] =  tmp[9 + (i + 0)];
+    y[i + 1] =  tmp[9 + (i + 1)];
+    y[i + 2] =  tmp[9 + (i + 2)];
+  }
+  for (i =  9; i < 27; i += 3) {
+    y[i + 0] = -tmp[36 - (9 + (i + 0)) - 1];
+    y[i + 1] = -tmp[36 - (9 + (i + 1)) - 1];
+    y[i + 2] = -tmp[36 - (9 + (i + 2)) - 1];
+  }
+  for (i = 27; i < 36; i += 3) {
+    y[i + 0] = -tmp[(i + 0) - 27];
+    y[i + 1] = -tmp[(i + 1) - 27];
+    y[i + 2] = -tmp[(i + 2) - 27];
+  }
+}
+#  else
 /*
          * NAME:imdct36
          * DESCRIPTION:perform X[18]->x[36] IMDCT
  */
 static inline
 void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
 {
   mad_fixed_t t0, t1, t2,  t3,  t4,  t5,  t6,  t7;
   mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15;
   register mad_fixed64hi_t hi;
   register mad_fixed64lo_t lo;
 
   MAD_F_ML0(hi, lo, X[4],  MAD_F(0x0ec835e8));
   MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa));
 
   t6 = MAD_F_MLZ(hi, lo);
 
   MAD_F_MLA(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x061f78aa));
   MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), -MAD_F(0x0ec835e8));
 
   t0 = MAD_F_MLZ(hi, lo);
 
   MAD_F_MLA(hi, lo, (t8  = X[0] - X[11] - X[12]),  MAD_F(0x0216a2a2));
   MAD_F_MLA(hi, lo, (t9  = X[2] - X[9]  - X[14]),  MAD_F(0x09bd7ca0));
   MAD_F_MLA(hi, lo, (t10 = X[3] - X[8]  - X[15]), -MAD_F(0x0cb19346));
   MAD_F_MLA(hi, lo, (t11 = X[5] - X[6]  - X[17]), -MAD_F(0x0fdcf549));
 
   x[7]  = MAD_F_MLZ(hi, lo);
   x[10] = -x[7];
 
   MAD_F_ML0(hi, lo, t8,  -MAD_F(0x0cb19346));
   MAD_F_MLA(hi, lo, t9,   MAD_F(0x0fdcf549));
   MAD_F_MLA(hi, lo, t10,  MAD_F(0x0216a2a2));
   MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0));
 
   x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0;
 
   t12 = X[0] - X[3] + X[8] - X[11] - X[12] + X[15];
   t13 = X[2] + X[5] - X[6] - X[9]  - X[14] - X[17];
 
   MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8));
   MAD_F_MLA(hi, lo, t13,  MAD_F(0x061f78aa));
 
   x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0;
 
   MAD_F_ML0(hi, lo, X[1],  -MAD_F(0x09bd7ca0));
   MAD_F_MLA(hi, lo, X[7],   MAD_F(0x0216a2a2));
   MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549));
   MAD_F_MLA(hi, lo, X[16],  MAD_F(0x0cb19346));
 
   t1 = MAD_F_MLZ(hi, lo) + t6;
 
   MAD_F_ML0(hi, lo, X[0],   MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[2],   MAD_F(0x0e313245));
   MAD_F_MLA(hi, lo, X[3],  -MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[5],  -MAD_F(0x0acf37ad));
   MAD_F_MLA(hi, lo, X[6],   MAD_F(0x04cfb0e2));
   MAD_F_MLA(hi, lo, X[8],  -MAD_F(0x0898c779));
   MAD_F_MLA(hi, lo, X[9],   MAD_F(0x0d7e8807));
   MAD_F_MLA(hi, lo, X[11],  MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[14],  MAD_F(0x00b2aa3e));
   MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890));
 
   x[6]  = MAD_F_MLZ(hi, lo) + t1;
   x[11] = -x[6];
 
   MAD_F_ML0(hi, lo, X[0],  -MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[2],  -MAD_F(0x00b2aa3e));
   MAD_F_MLA(hi, lo, X[3],   MAD_F(0x0898c779));
   MAD_F_MLA(hi, lo, X[5],   MAD_F(0x0f9ee890));
   MAD_F_MLA(hi, lo, X[6],   MAD_F(0x0acf37ad));
   MAD_F_MLA(hi, lo, X[8],  -MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[9],  -MAD_F(0x0e313245));
   MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[14],  MAD_F(0x0d7e8807));
   MAD_F_MLA(hi, lo, X[15],  MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[17],  MAD_F(0x04cfb0e2));
 
   x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1;
 
   MAD_F_ML0(hi, lo, X[0],  -MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[2],   MAD_F(0x0d7e8807));
   MAD_F_MLA(hi, lo, X[3],  -MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[5],   MAD_F(0x04cfb0e2));
   MAD_F_MLA(hi, lo, X[6],   MAD_F(0x0f9ee890));
   MAD_F_MLA(hi, lo, X[8],  -MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[9],  -MAD_F(0x00b2aa3e));
   MAD_F_MLA(hi, lo, X[11],  MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[14],  MAD_F(0x0e313245));
   MAD_F_MLA(hi, lo, X[15],  MAD_F(0x0898c779));
   MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad));
 
@@ -1772,394 +1959,403 @@ void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
 
   MAD_F_ML0(hi, lo, X[0],  -MAD_F(0x0d7e8807));
   MAD_F_MLA(hi, lo, X[2],   MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[3],   MAD_F(0x0acf37ad));
   MAD_F_MLA(hi, lo, X[5],  -MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[6],  -MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[8],   MAD_F(0x0f9ee890));
   MAD_F_MLA(hi, lo, X[9],   MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245));
   MAD_F_MLA(hi, lo, X[12],  MAD_F(0x00b2aa3e));
   MAD_F_MLA(hi, lo, X[14],  MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2));
   MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779));
 
   x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3;
 
   MAD_F_ML0(hi, lo, t14, -MAD_F(0x0ec835e8));
   MAD_F_MLA(hi, lo, t15,  MAD_F(0x061f78aa));
 
   t4 = MAD_F_MLZ(hi, lo) - t7;
 
   MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa));
   MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8));
 
   x[4]  = MAD_F_MLZ(hi, lo) + t4;
   x[13] = -x[4];
 
   MAD_F_ML0(hi, lo, t8,   MAD_F(0x09bd7ca0));
   MAD_F_MLA(hi, lo, t9,  -MAD_F(0x0216a2a2));
   MAD_F_MLA(hi, lo, t10,  MAD_F(0x0fdcf549));
   MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346));
 
   x[1]  = MAD_F_MLZ(hi, lo) + t4;
   x[16] = -x[1];
 
   MAD_F_ML0(hi, lo, t8,  -MAD_F(0x0fdcf549));
   MAD_F_MLA(hi, lo, t9,  -MAD_F(0x0cb19346));
   MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0));
   MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2));
 
   x[25] = x[28] = MAD_F_MLZ(hi, lo) + t4;
 
   MAD_F_ML0(hi, lo, X[1],  -MAD_F(0x0fdcf549));
   MAD_F_MLA(hi, lo, X[7],  -MAD_F(0x0cb19346));
   MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0));
   MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2));
 
   t5 = MAD_F_MLZ(hi, lo) - t6;
 
   MAD_F_ML0(hi, lo, X[0],   MAD_F(0x0898c779));
   MAD_F_MLA(hi, lo, X[2],   MAD_F(0x04cfb0e2));
   MAD_F_MLA(hi, lo, X[3],   MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[5],   MAD_F(0x00b2aa3e));
   MAD_F_MLA(hi, lo, X[6],   MAD_F(0x0e313245));
   MAD_F_MLA(hi, lo, X[8],  -MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[9],   MAD_F(0x0f9ee890));
   MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[12],  MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad));
   MAD_F_MLA(hi, lo, X[15],  MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807));
 
   x[2]  = MAD_F_MLZ(hi, lo) + t5;
   x[15] = -x[2];
 
   MAD_F_ML0(hi, lo, X[0],   MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[2],   MAD_F(0x0acf37ad));
   MAD_F_MLA(hi, lo, X[3],   MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[5],   MAD_F(0x0d7e8807));
   MAD_F_MLA(hi, lo, X[6],  -MAD_F(0x00b2aa3e));
   MAD_F_MLA(hi, lo, X[8],   MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[9],  -MAD_F(0x04cfb0e2));
   MAD_F_MLA(hi, lo, X[11],  MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779));
   MAD_F_MLA(hi, lo, X[14],  MAD_F(0x0f9ee890));
   MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[17],  MAD_F(0x0e313245));
 
   x[3]  = MAD_F_MLZ(hi, lo) + t5;
   x[14] = -x[3];
 
   MAD_F_ML0(hi, lo, X[0],  -MAD_F(0x0ffc19fd));
   MAD_F_MLA(hi, lo, X[2],  -MAD_F(0x0f9ee890));
   MAD_F_MLA(hi, lo, X[3],  -MAD_F(0x0f426cb5));
   MAD_F_MLA(hi, lo, X[5],  -MAD_F(0x0e313245));
   MAD_F_MLA(hi, lo, X[6],  -MAD_F(0x0d7e8807));
   MAD_F_MLA(hi, lo, X[8],  -MAD_F(0x0bcbe352));
   MAD_F_MLA(hi, lo, X[9],  -MAD_F(0x0acf37ad));
   MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779));
   MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284));
   MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2));
   MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962));
   MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e));
 
   x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5;
 }
+#  endif
 
 /*
          * NAME:III_imdct_l()
          * DESCRIPTION:perform IMDCT and windowing for long blocks
  */
 static
 void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
                  unsigned int block_type)
 {
   unsigned int i;
 
   /* IMDCT */
 
   imdct36(X, z);
 
   /* windowing */
 
   switch (block_type) {
   case 0:  /* normal window */
 # if defined(ASO_INTERLEAVE1)
     {
       register mad_fixed_t tmp1, tmp2;
 
       tmp1 = window_l[0];
       tmp2 = window_l[1];
 
       for (i = 0; i < 34; i += 2) {
         z[i + 0] = mad_f_mul(z[i + 0], tmp1);
         tmp1 = window_l[i + 2];
         z[i + 1] = mad_f_mul(z[i + 1], tmp2);
         tmp2 = window_l[i + 3];
       }
 
       z[34] = mad_f_mul(z[34], tmp1);
       z[35] = mad_f_mul(z[35], tmp2);
     }
 # elif defined(ASO_INTERLEAVE2)
     {
       register mad_fixed_t tmp1, tmp2;
 
       tmp1 = z[0];
       tmp2 = window_l[0];
 
       for (i = 0; i < 35; ++i) {
         z[i] = mad_f_mul(tmp1, tmp2);
         tmp1 = z[i + 1];
         tmp2 = window_l[i + 1];
       }
 
       z[35] = mad_f_mul(tmp1, tmp2);
     }
 # elif 1
     for (i = 0; i < 36; i += 4) {
       z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
       z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
       z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
       z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]);
     }
 # else
     for (i =  0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
 # endif
     break;
 
   case 1:  /* start block */
-    for (i =  0; i < 18; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
+    for (i =  0; i < 18; i += 3) {
+      z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
+      z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
+      z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
+    }
     /*  (i = 18; i < 24; ++i) z[i] unchanged */
     for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]);
     for (i = 30; i < 36; ++i) z[i] = 0;
     break;
 
   case 3:  /* stop block */
     for (i =  0; i <  6; ++i) z[i] = 0;
     for (i =  6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]);
     /*  (i = 12; i < 18; ++i) z[i] unchanged */
-    for (i = 18; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
+    for (i = 18; i < 36; i += 3) {
+      z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
+      z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
+      z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
+    }
     break;
   }
 }
 # endif  /* ASO_IMDCT */
 
 /*
          * NAME:III_imdct_s()
          * DESCRIPTION:perform IMDCT and windowing for short blocks
  */
 static
 void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36])
 {
   mad_fixed_t y[36], *yptr;
   mad_fixed_t const *wptr;
   int w, i;
   register mad_fixed64hi_t hi;
   register mad_fixed64lo_t lo;
 
   /* IMDCT */
 
   yptr = &y[0];
 
   for (w = 0; w < 3; ++w) {
     register mad_fixed_t const (*s)[6];
 
     s = imdct_s;
 
     for (i = 0; i < 3; ++i) {
       MAD_F_ML0(hi, lo, X[0], (*s)[0]);
       MAD_F_MLA(hi, lo, X[1], (*s)[1]);
       MAD_F_MLA(hi, lo, X[2], (*s)[2]);
       MAD_F_MLA(hi, lo, X[3], (*s)[3]);
       MAD_F_MLA(hi, lo, X[4], (*s)[4]);
       MAD_F_MLA(hi, lo, X[5], (*s)[5]);
 
       yptr[i + 0] = MAD_F_MLZ(hi, lo);
       yptr[5 - i] = -yptr[i + 0];
 
       ++s;
 
       MAD_F_ML0(hi, lo, X[0], (*s)[0]);
       MAD_F_MLA(hi, lo, X[1], (*s)[1]);
       MAD_F_MLA(hi, lo, X[2], (*s)[2]);
       MAD_F_MLA(hi, lo, X[3], (*s)[3]);
       MAD_F_MLA(hi, lo, X[4], (*s)[4]);
       MAD_F_MLA(hi, lo, X[5], (*s)[5]);
 
       yptr[ i + 6] = MAD_F_MLZ(hi, lo);
       yptr[11 - i] = yptr[i + 6];
 
       ++s;
     }
 
     yptr += 12;
     X    += 6;
   }
 
   /* windowing, overlapping and concatenation */
 
   yptr = &y[0];
   wptr = &window_s[0];
 
   for (i = 0; i < 6; ++i) {
     z[i +  0] = 0;
     z[i +  6] = mad_f_mul(yptr[ 0 + 0], wptr[0]);
 
     MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]);
     MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]);
 
     z[i + 12] = MAD_F_MLZ(hi, lo);
 
     MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]);
     MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]);
 
     z[i + 18] = MAD_F_MLZ(hi, lo);
 
     z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]);
     z[i + 30] = 0;
 
     ++yptr;
     ++wptr;
   }
 }
 
 /*
          * NAME:III_overlap()
          * DESCRIPTION:perform overlap-add of windowed IMDCT outputs
  */
 static
 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
                  mad_fixed_t sample[18][32], unsigned int sb)
 {
   unsigned int i;
 
 # if defined(ASO_INTERLEAVE2)
   {
     register mad_fixed_t tmp1, tmp2;
 
     tmp1 = overlap[0];
     tmp2 = overlap[1];
 
     for (i = 0; i < 16; i += 2) {
-      sample[i + 0][sb] = output[i + 0] + tmp1;
+      sample[i + 0][sb] = output[i + 0 +  0] + tmp1;
       overlap[i + 0]    = output[i + 0 + 18];
       tmp1 = overlap[i + 2];
 
-      sample[i + 1][sb] = output[i + 1] + tmp2;
+      sample[i + 1][sb] = output[i + 1 +  0] + tmp2;
       overlap[i + 1]    = output[i + 1 + 18];
       tmp2 = overlap[i + 3];
     }
 
-    sample[16][sb] = output[16] + tmp1;
+    sample[16][sb] = output[16 +  0] + tmp1;
     overlap[16]    = output[16 + 18];
-    sample[17][sb] = output[17] + tmp2;
+    sample[17][sb] = output[17 +  0] + tmp2;
     overlap[17]    = output[17 + 18];
   }
 # elif 0
   for (i = 0; i < 18; i += 2) {
-    sample[i + 0][sb] = output[i + 0] + overlap[i + 0];
+    sample[i + 0][sb] = output[i + 0 +  0] + overlap[i + 0];
     overlap[i + 0]    = output[i + 0 + 18];
 
-    sample[i + 1][sb] = output[i + 1] + overlap[i + 1];
+    sample[i + 1][sb] = output[i + 1 +  0] + overlap[i + 1];
     overlap[i + 1]    = output[i + 1 + 18];
   }
 # else
   for (i = 0; i < 18; ++i) {
-    sample[i][sb] = output[i] + overlap[i];
+    sample[i][sb] = output[i +  0] + overlap[i];
     overlap[i]    = output[i + 18];
   }
 # endif
 }
 
 /*
          * NAME:III_overlap_z()
          * DESCRIPTION:perform "overlap-add" of zero IMDCT outputs
  */
 static inline
 void III_overlap_z(mad_fixed_t overlap[18],
                    mad_fixed_t sample[18][32], unsigned int sb)
 {
   unsigned int i;
 
 # if defined(ASO_INTERLEAVE2)
   {
     register mad_fixed_t tmp1, tmp2;
 
     tmp1 = overlap[0];
     tmp2 = overlap[1];
 
     for (i = 0; i < 16; i += 2) {
       sample[i + 0][sb] = tmp1;
       overlap[i + 0]    = 0;
       tmp1 = overlap[i + 2];
 
       sample[i + 1][sb] = tmp2;
       overlap[i + 1]    = 0;
       tmp2 = overlap[i + 3];
     }
 
     sample[16][sb] = tmp1;
     overlap[16]    = 0;
     sample[17][sb] = tmp2;
     overlap[17]    = 0;
   }
 # else
   for (i = 0; i < 18; ++i) {
     sample[i][sb] = overlap[i];
     overlap[i]    = 0;
   }
 # endif
 }
 
 /*
          * NAME:III_freqinver()
          * DESCRIPTION:perform subband frequency inversion for odd sample lines
  */
 static
 void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
 {
   unsigned int i;
 
 # if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2)
   {
     register mad_fixed_t tmp1, tmp2;
 
     tmp1 = sample[1][sb];
     tmp2 = sample[3][sb];
 
     for (i = 1; i < 13; i += 4) {
       sample[i + 0][sb] = -tmp1;
       tmp1 = sample[i + 4][sb];
       sample[i + 2][sb] = -tmp2;
       tmp2 = sample[i + 6][sb];
     }
 
     sample[13][sb] = -tmp1;
     tmp1 = sample[17][sb];
     sample[15][sb] = -tmp2;
     sample[17][sb] = -tmp1;
   }
 # else
   for (i = 1; i < 18; i += 2)
     sample[i][sb] = -sample[i][sb];
 # endif
 }
 
 /*
          * NAME:III_decode()
          * DESCRIPTION:decode frame main_data
  */
 static
 enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
                           struct sideinfo *si, unsigned int nch)
 {
   struct mad_header *header = &frame->header;
   unsigned int sfreqi, ngr, gr;
 
   {
     unsigned int sfreq;
 
     sfreq = header->samplerate;
     if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
       sfreq *= 2;
@@ -2361,142 +2557,142 @@ int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
 
   /* check CRC word */
 
   if (header->flags & MAD_FLAG_PROTECTION) {
     header->crc_check =
       mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check);
 
     if (header->crc_check != header->crc_target &&
         !(frame->options & MAD_OPTION_IGNORECRC)) {
       stream->error = MAD_ERROR_BADCRC;
       result = -1;
     }
   }
 
   /* decode frame side information */
 
   error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT,
                        &si, &data_bitlen, &priv_bitlen);
   if (error && result == 0) {
     stream->error = error;
     result = -1;
   }
 
   header->flags        |= priv_bitlen;
   header->private_bits |= si.private_bits;
 
   /* find main_data of next frame */
 
   {
     struct mad_bitptr peek;
     unsigned long header;
 
     mad_bit_init(&peek, stream->next_frame);
 
     header = mad_bit_read(&peek, 32);
     if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) {
       if (!(header & 0x00010000L))  /* protection_bit */
         mad_bit_skip(&peek, 16);  /* crc_check */
 
       next_md_begin =
         mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8);
     }
 
     mad_bit_finish(&peek);
   }
 
   /* find main_data of this frame */
 
   frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr);
 
   if (next_md_begin > si.main_data_begin + frame_space)
     next_md_begin = 0;
 
   md_len = si.main_data_begin + frame_space - next_md_begin;
 
   frame_used = 0;
 
   if (si.main_data_begin == 0) {
     ptr = stream->ptr;
     stream->md_len = 0;
 
     frame_used = md_len;
   }
   else {
     if (si.main_data_begin > stream->md_len) {
       if (result == 0) {
         stream->error = MAD_ERROR_BADDATAPTR;
         result = -1;
       }
     }
     else {
       mad_bit_init(&ptr,
                    *stream->main_data + stream->md_len - si.main_data_begin);
 
       if (md_len > si.main_data_begin) {
         assert(stream->md_len + md_len -
                si.main_data_begin <= MAD_BUFFER_MDLEN);
 
         memcpy(*stream->main_data + stream->md_len,
                mad_bit_nextbyte(&stream->ptr),
                frame_used = md_len - si.main_data_begin);
         stream->md_len += frame_used;
       }
     }
   }
 
   frame_free = frame_space - frame_used;
 
   /* decode main_data */
 
   if (result == 0) {
     error = III_decode(&ptr, frame, &si, nch);
     if (error) {
       stream->error = error;
       result = -1;
     }
-  }
 
-  /* designate ancillary bits */
+    /* designate ancillary bits */
 
-  stream->anc_ptr    = ptr;
-  stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen;
+    stream->anc_ptr    = ptr;
+    stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen;
+  }
 
 # if 0 && defined(DEBUG)
   fprintf(stderr,
           "main_data_begin:%u, md_len:%u, frame_free:%u, "
           "data_bitlen:%u, anc_bitlen: %u\n",
           si.main_data_begin, md_len, frame_free,
           data_bitlen, stream->anc_bitlen);
 # endif
 
   /* preload main_data buffer with up to 511 bytes for next frame(s) */
 
   if (frame_free >= next_md_begin) {
     memcpy(*stream->main_data,
            stream->next_frame - next_md_begin, next_md_begin);
     stream->md_len = next_md_begin;
   }
   else {
     if (md_len < si.main_data_begin) {
       unsigned int extra;
 
       extra = si.main_data_begin - md_len;
       if (extra + frame_free > next_md_begin)
         extra = next_md_begin - frame_free;
 
       if (extra < stream->md_len) {
         memmove(*stream->main_data,
                 *stream->main_data + stream->md_len - extra, extra);
         stream->md_len = extra;
       }
     }
     else
       stream->md_len = 0;
 
     memcpy(*stream->main_data + stream->md_len,
            stream->next_frame - frame_free, frame_free);
     stream->md_len += frame_free;
   }
 
   return result;
 }
diff --git a/core/multimedia/opieplayer/libmad/layer3.h b/core/multimedia/opieplayer/libmad/layer3.h
index c1a5c69..1594803 100644
--- a/core/multimedia/opieplayer/libmad/layer3.h
+++ b/core/multimedia/opieplayer/libmad/layer3.h
@@ -1,30 +1,30 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_LAYER3_H
 # define LIBMAD_LAYER3_H
 
 # include "stream.h"
 # include "frame.h"
 
 int mad_layer_III(struct mad_stream *, struct mad_frame *);
 
 # endif
diff --git a/core/multimedia/opieplayer/libmad/libmad.pro b/core/multimedia/opieplayer/libmad/libmad.pro
index 46af87f..7c41a8f 100644
--- a/core/multimedia/opieplayer/libmad/libmad.pro
+++ b/core/multimedia/opieplayer/libmad/libmad.pro
@@ -1,53 +1,44 @@
+QMAKE_CFLAGS += $(if $(CONFIG_TARGET_X86),-DFPM_INTEL) \
+                $(if $(CONFIG_TARGET_64BIT),-DFPM_64BIT) \
+                $(if $(CONFIG_TARGET_IPAQ),-DFPM_ARM) \
+                $(if $(CONFIG_TARGET_SHARP),-DFPM_ARM)
+QMAKE_CXXFLAGS += $(if $(CONFIG_TARGET_X86),-DFPM_INTEL) \
+                $(if $(CONFIG_TARGET_64BIT),-DFPM_64BIT) \
+                $(if $(CONFIG_TARGET_IPAQ),-DFPM_ARM) \
+                $(if $(CONFIG_TARGET_SHARP),-DFPM_ARM)
+
+
         TEMPLATE = lib
-        CONFIG   +=  qt warn_on 
+        CONFIG   +=  qt warn_on release
         HEADERS   = libmad_version.h fixed.h bit.h timer.h stream.h frame.h synth.h decoder.h \
                 layer12.h layer3.h huffman.h libmad_global.h mad.h libmadplugin.h libmadpluginimpl.h
         SOURCES   = version.c fixed.c bit.c timer.c stream.c frame.c synth.c decoder.c \
                 layer12.c layer3.c huffman.c libmadplugin.cpp libmadpluginimpl.cpp
         TARGET   = madplugin
         DESTDIR   = $(OPIEDIR)/plugins/codecs
 INCLUDEPATH += $(OPIEDIR)/include ..
-DEPENDPATH      +=  ..
+DEPENDPATH      += ../$(OPIEDIR)/include ..
 LIBS            += -lqpe -lm
 VERSION   =   1.0.0
 
-include( $(OPIEDIR)/include.pro )
-        
-DEFINES += FPM_INTEL
-
-system(echo $QMAKESPEC | grep -s sharp) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_ARM
-}
-
-system(echo $QMAKESPEC | grep -s ipaq) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_ARM
-}
-
-system(echo $QMAKESPEC | grep -s mipsel) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_MIPS
-}
-
-system(echo $QMAKESPEC | grep -s ramses) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_ARM
-}
-
-system(echo $QMAKESPEC | grep -s arm) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_ARM
-}
-
-system(echo $QMAKESPEC | grep -s simpad) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_ARM
-}
-
-system(echo $QMAKESPEC | grep -s yopy) {
-        DEFINES -= FPM_INTEL
-        DEFINES += FPM_ARM
-}
-
-
+TRANSLATIONS = ../../../../i18n/de/libmadplugin.ts \
+         ../../../../i18n/nl/libmadplugin.ts \
+         ../../../../i18n/da/libmadplugin.ts \
+         ../../../../i18n/xx/libmadplugin.ts \
+         ../../../../i18n/en/libmadplugin.ts \
+         ../../../../i18n/es/libmadplugin.ts \
+         ../../../../i18n/fr/libmadplugin.ts \
+         ../../../../i18n/hu/libmadplugin.ts \
+         ../../../../i18n/ja/libmadplugin.ts \
+         ../../../../i18n/ko/libmadplugin.ts \
+         ../../../../i18n/no/libmadplugin.ts \
+         ../../../../i18n/pl/libmadplugin.ts \
+         ../../../../i18n/pt/libmadplugin.ts \
+         ../../../../i18n/pt_BR/libmadplugin.ts \
+         ../../../../i18n/sl/libmadplugin.ts \
+         ../../../../i18n/zh_CN/libmadplugin.ts \
+         ../../../../i18n/zh_TW/libmadplugin.ts
+
+
+
+include ( $(OPIEDIR)/include.pro )
diff --git a/core/multimedia/opieplayer/libmad/libmad_global.h b/core/multimedia/opieplayer/libmad/libmad_global.h
index 2c9c713..a3417b4 100644
--- a/core/multimedia/opieplayer/libmad/libmad_global.h
+++ b/core/multimedia/opieplayer/libmad/libmad_global.h
@@ -1,58 +1,58 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_GLOBAL_H
 # define LIBMAD_GLOBAL_H
 
 /* conditional debugging */
 
 # if defined(DEBUG) && defined(NDEBUG)
 #  error "cannot define both DEBUG and NDEBUG"
 # endif
 
 # if defined(DEBUG)
 #  include <stdio.h>
 # endif
 
 /* conditional features */
 
 # if defined(OPT_SPEED) && defined(OPT_ACCURACY)
 #  error "cannot optimize for both speed and accuracy"
 # endif
 
 # if defined(OPT_SPEED) && !defined(OPT_SSO)
-#  define OPT_SSO 1
+#  define OPT_SSO
 # endif
 
 # if defined(HAVE_UNISTD_H) && defined(HAVE_WAITPID) &&  \
     defined(HAVE_FCNTL) && defined(HAVE_PIPE) && defined(HAVE_FORK)
 #  define USE_ASYNC
 # endif
 
 # if !defined(HAVE_ASSERT_H)
 #  if defined(NDEBUG)
         #   define assert(x)/* nothing */
 #  else
         #   define assert(x)do { if (!(x)) abort(); } while (0)
 #  endif
 # endif
 
 # endif
diff --git a/core/multimedia/opieplayer/libmad/libmad_version.h b/core/multimedia/opieplayer/libmad/libmad_version.h
index 9e684a7..d40e425 100644
--- a/core/multimedia/opieplayer/libmad/libmad_version.h
+++ b/core/multimedia/opieplayer/libmad/libmad_version.h
@@ -1,47 +1,47 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_VERSION_H
 # define LIBMAD_VERSION_H
 
         # define MAD_VERSION_MAJOR0
-        # define MAD_VERSION_MINOR14
-        # define MAD_VERSION_PATCH2
+        # 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
diff --git a/core/multimedia/opieplayer/libmad/libmadplugin.cpp b/core/multimedia/opieplayer/libmad/libmadplugin.cpp
index 7438a45..1989b4a 100644
--- a/core/multimedia/opieplayer/libmad/libmadplugin.cpp
+++ b/core/multimedia/opieplayer/libmad/libmadplugin.cpp
@@ -1,158 +1,153 @@
 /**********************************************************************
 ** Copyright (C) 2001 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 // largly modified by Maximilian Reiss <max.reiss@gmx.de>
 
-#include "libmadplugin.h"
-
-/* OPIE */
-#include <qpe/config.h>
-#include <opie2/odebug.h>
-
-/* QT */
-#include <qapplication.h>
-#include <qmessagebox.h>
-#include <qregexp.h>
-
-/* STD */
 #include <stdio.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
 #include <ctype.h>
 #include <errno.h>
 #include <time.h>
 #include <locale.h>
 #include <math.h>
 #include <assert.h>
 
+#include <qapplication.h>
+#include <qmessagebox.h>
+#include <qregexp.h>
+
+#include <qpe/config.h>
+
 // for network handling
 #include <netinet/in.h>
 #include <netdb.h>
 #include <linux/limits.h>
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 
 
 //#define HAVE_MMAP
 
 #if defined(HAVE_MMAP)
 #   include <sys/mman.h>
 #endif
+#include "libmadplugin.h"
 
 
 extern "C" {
 #include "mad.h"
 }
 
 
 #define MPEG_BUFFER_SIZE    65536
 //#define MPEG_BUFFER_SIZE    32768 //16384 // 8192
 //#define debugMsg(a)     qDebug(a)
 #define debugMsg(a)
 
 
 class Input {
 public:
     char const *path;
     int fd;
 #if defined(HAVE_MMAP)
     void *fdm;
 #endif
     unsigned long fileLength;
    unsigned char *data;
     unsigned long length;
     int eof;
 };
 
 
 class Output {
 public:
     mad_fixed_t attenuate;
     struct filter *filters;
     unsigned int channels_in;
     unsigned int channels_out;
     unsigned int speed_in;
     unsigned int speed_out;
     const char *path;
 };
 
 
 # if defined(HAVE_MMAP)
 static void *map_file(int fd, unsigned long *length)
 {
   void *fdm;
 
   *length += MAD_BUFFER_GUARD;
 
   fdm = mmap(0, *length, PROT_READ, MAP_SHARED, fd, 0);
   if (fdm == MAP_FAILED)
     return 0;
 
 # if defined(HAVE_MADVISE)
   madvise(fdm, *length, MADV_SEQUENTIAL);
 # endif
 
   return fdm;
 }
 
 
 static int unmap_file(void *fdm, unsigned long length)
 {
   if (munmap(fdm, length) == -1)
     return -1;
 
   return 0;
 }
 # endif
 
 
 static inline QString tr( const char *str ) {
     // Apparently this is okay from a plugin as it runs in the process space of the owner of the plugin
     return qApp->translate( "OpiePlayer", str, "libmad strings for mp3 file info" );
 }
 
 
 class LibMadPluginData {
 public:
     Input input;
     Output output;
     int bad_last_frame;
     struct mad_stream stream;
     struct mad_frame frame;
     struct mad_synth synth;
     bool flush;
 };
 
 
 LibMadPlugin::LibMadPlugin() {
     d = new LibMadPluginData;
     d->input.fd = 0;
 #if defined(HAVE_MMAP)
     d->input.fdm = 0;
 #endif
     d->input.data = 0;
     d->flush = TRUE;
     info = tr( "No Song Open" );
 }
@@ -294,580 +289,581 @@ int LibMadPlugin::tcp_open(char *address, int port) {
  * This function read character by character.
  * @param tcp_sock the socket use to read the stream
  * @param buf a buffer to receive the data
  * @param size size of the buffer
  * @return the size of the stream read or -1 if an error occured
  */
 int LibMadPlugin::http_read_line(int tcp_sock, char *buf, int size) {
     int offset = 0;
 
     do {
         if (::read(tcp_sock, buf + offset, 1) < 0)
             return -1;
         if (buf[offset] != '\r')    /* Strip \r from answer */
             offset++;
     } while (offset < size - 1 && buf[offset - 1] != '\n');
 
     buf[offset] = 0;
     return offset;
 }
 
 int LibMadPlugin::http_open(const QString& path ) {
     char *host;
     int port;
     char *request;
     int tcp_sock;
     char http_request[PATH_MAX];
     char filename[PATH_MAX];
     //char c;
     char *arg =strdup(path.latin1());
 
     /* Check for URL syntax */
     if (strncmp(arg, "http://", strlen("http://"))) {
         return (0);
     }
 
     /* Parse URL */
     port = 80;
     host = arg + strlen("http://");
     if ((request = strchr(host, '/')) == NULL) {
         return (0);
     }
 
     *request++ = 0;
 
     if (strchr(host, ':') != NULL) { /* port is specified */
         port = atoi(strchr(host, ':') + 1);
         *strchr(host, ':') = 0;
     }
 
     /* Open a TCP socket */
     if (!(tcp_sock = tcp_open(host, port))) {
         perror("http_open");
         return (0);
     }
 
     snprintf(filename, sizeof(filename) - strlen(host) - 75, "%s", request);
 
     /* Send HTTP GET request */
     /* Please don't use a Agent know by shoutcast (Lynx, Mozilla) seems to be reconized and print
      * a html page and not the stream */
     snprintf(http_request, sizeof(http_request), "GET /%s HTTP/1.0\r\n"
     /*  "User-Agent: Mozilla/2.0 (Win95; I)\r\n" */
         "Pragma: no-cache\r\n" "Host: %s\r\n" "Accept: */*\r\n" "\r\n", filename, host);
 
     send(tcp_sock, http_request, strlen(http_request), 0);
 
     /* Parse server reply */
 #if 0
     do
         read(tcp_sock, &c, sizeof(char));
     while (c != ' ');
     read(tcp_sock, http_request, 4 * sizeof(char));
     http_request[4] = 0;
     if (strcmp(http_request, "200 "))     {
         fprintf(stderr, "http_open: ");
         do {
             read(tcp_sock, &c, sizeof(char));
             fprintf(stderr, "%c", c);
         } while (c != '\r');
         fprintf(stderr, "\n");
         return (0);
     }
 #endif
 
     QString name;
     QString genre;
     QString bitrate;
     QString url;
     QString message = tr("Info: ");
     do {
 
         int len;
 
         len = http_read_line(tcp_sock, http_request, sizeof(http_request));
 
         if (len == -1) {
-           //            odebug << "http_open: "+ QString(strerror(errno)) +"\n" << oendl;
+           //            qDebug( "http_open: "+ QString(strerror(errno)) +"\n");
             return 0;
         }
 
         if (QString(http_request).left(9) == "Location:") {
             /* redirect */
             ::close(tcp_sock);
             http_request[strlen(http_request) - 1] = '\0';
             return http_open(&http_request[10]);
         }
 
         if (QString(http_request).left(4) == "ICY ") {
             /* This is shoutcast/icecast streaming */
             if (strncmp(http_request + 4, "200 ", 4)) {
-               //                odebug << "http_open: " + QString(http_request) + "\n" << oendl;
+               //                qDebug("http_open: " + QString(http_request) + "\n");
                 return 0;
             }
         } else if (QString(http_request).left(4) == "icy-") {
             /* we can have: icy-noticeX, icy-name, icy-genre, icy-url, icy-pub, icy-metaint, icy-br */
             if ( QString( http_request ).left( 8 ) == "icy-name" ) {
                 name = tr("Name: ") + QString(http_request).mid(9, (QString(http_request).length())- 9 );
             } else if ( QString( http_request ).left( 9 ) == "icy-genre" ) {
                 genre = tr("Genre: ") + QString(http_request).mid(10, (QString(http_request).length())-10 );
             } else if ( QString( http_request ).left( 6 ) == "icy-br" ) {
                 bitrate = tr("Bitrate: ") + QString(http_request).mid(7, (QString(http_request).length())- 7 );
             } else if ( QString( http_request ).left( 7 ) == "icy-url" ) {
                 url = tr("URL: ") + QString(http_request).mid(8, (QString(http_request).length())- 8 );
             }  else if ( QString( http_request ).left( 10 ) == "icy-notice" ) {
                 message += QString(http_request).mid(11, QString(http_request).length()-11 ) ;
             }
         }
     } while (strcmp(http_request, "\n") != 0);
 
     info = QString(name + genre + url + bitrate + message).replace( QRegExp("\n"), " : " );
 
-    //    odebug << "Stream info: " + info << oendl;
+    //    qDebug("Stream info: " + info);
 
     return (tcp_sock);
 }
 
 
 
 bool LibMadPlugin::open( const QString& path ) {
     debugMsg( "LibMadPlugin::open" );
     Config cfg("OpiePlayer");
     cfg.setGroup("Options");
     bufferSize = cfg.readNumEntry("MPeg_BufferSize",MPEG_BUFFER_SIZE);
-    //    odebug << "buffer size is " << bufferSize << "" << oendl;
+    //    qDebug("buffer size is %d", bufferSize);
     d->bad_last_frame = 0;
     d->flush = TRUE;
     info = QString( "" );
 
-    //odebug << "Opening " << path << "" << oendl;
+    //qDebug( "Opening %s", path.latin1() );
 
     if (path.left( 4 ) == "http" ) {
         // in case of any error we get 0 here
         if ( !(http_open(path) == 0) ) {
             d->input.fd = http_open(path);
         } else {
             return FALSE;
         }
     } else {
         d->input.path = path.latin1();
         d->input.fd = ::open( d->input.path, O_RDONLY );
         // thats a better place, since it should only seek for ID3 tags on mp3 files, not streams
         printID3Tags();
     }
     if (d->input.fd == -1) {
-       //        odebug << "error opening " << d->input.path << "" << oendl;
+       //        qDebug("error opening %s", d->input.path );
         return FALSE;
     }
 
     struct stat stat;
     if (fstat(d->input.fd, &stat) == -1) {
-       //    odebug << "error calling fstat" << oendl;  return FALSE;
+       //    qDebug("error calling fstat"); return FALSE;
     }
     if (S_ISREG(stat.st_mode) && stat.st_size > 0)
   d->input.fileLength = stat.st_size;
     else
   d->input.fileLength = 0;
-
+    
 #if defined(HAVE_MMAP)
     if (S_ISREG(stat.st_mode) && stat.st_size > 0) {
         d->input.length = stat.st_size;
         d->input.fdm = map_file(d->input.fd, &d->input.length);
         if (d->input.fdm == 0) {
-           //            odebug << "error mmapping file" << oendl;  return FALSE;
+           //            qDebug("error mmapping file"); return FALSE;
         }
         d->input.data = (unsigned char *)d->input.fdm;
     }
 #endif
 
     if (d->input.data == 0) {
         d->input.data = (unsigned char *)malloc( bufferSize /*MPEG_BUFFER_SIZE*/);
         if (d->input.data == 0) {
-           //            odebug << "error allocating input buffer" << oendl;
+           //            qDebug("error allocating input buffer");
             return FALSE;
         }
         d->input.length = 0;
     }
 
     d->input.eof = 0;
 
     mad_stream_init(&d->stream);
     mad_frame_init(&d->frame);
     mad_synth_init(&d->synth);
 
     return TRUE;
 }
 
 
 bool LibMadPlugin::close() {
     debugMsg( "LibMadPlugin::close" );
 
     int result = TRUE;
 
     mad_synth_finish(&d->synth);
     mad_frame_finish(&d->frame);
     mad_stream_finish(&d->stream);
 
 #if defined(HAVE_MMAP)
     if (d->input.fdm) {
         if (unmap_file(d->input.fdm, d->input.length) == -1) {
-           //            odebug << "error munmapping file" << oendl;
+           //            qDebug("error munmapping file");
             result = FALSE;
         }
         d->input.fdm  = 0;
         d->input.data = 0;
     }
 #endif
 
     if (d->input.data) {
         free(d->input.data);
         d->input.data = 0;
     }
 
     if (::close(d->input.fd) == -1) {
-       //        odebug << "error closing file " << d->input.path << "" << oendl;
+       //        qDebug("error closing file %s", d->input.path);
         result = FALSE;
     }
 
     d->input.fd = 0;
 
     return result;
 }
 
 
 bool LibMadPlugin::isOpen() {
     debugMsg( "LibMadPlugin::isOpen" );
     return ( d->input.fd != 0 );
 }
 
 
 int LibMadPlugin::audioStreams() {
     debugMsg( "LibMadPlugin::audioStreams" );
     return 1;
 }
 
 
 int LibMadPlugin::audioChannels( int ) {
     debugMsg( "LibMadPlugin::audioChannels" );
 /*
   long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 );
-  odebug << "LibMadPlugin::audioChannels: " << d->frame.header.mode > 0 ? 2 : 1 << "" << oendl;
+  qDebug( "LibMadPlugin::audioChannels: %i", d->frame.header.mode > 0 ? 2 : 1 );
   return d->frame.header.mode > 0 ? 2 : 1;
 */
     return 2;
 }
 
 
 int LibMadPlugin::audioFrequency( int ) {
     debugMsg( "LibMadPlugin::audioFrequency" );
     long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 );
-    //    odebug << "LibMadPlugin::audioFrequency: " << d->frame.header.samplerate << "" << oendl;
+    //    qDebug( "LibMadPlugin::audioFrequency: %i", d->frame.header.samplerate );
     return d->frame.header.samplerate;
 }
 
 
 int LibMadPlugin::audioSamples( int ) {
    debugMsg( "LibMadPlugin::audioSamples" );
 
    long t; short t1[5]; audioReadSamples( t1, 2, 1, t, 0 );
    mad_header_decode( (struct mad_header *)&d->frame.header, &d->stream );
 /*
-  odebug << "LibMadPlugin::audioSamples: " <<  d->frame.header.duration.seconds << "*" << d->frame.header.samplerate << oendl;
+  qDebug( "LibMadPlugin::audioSamples: %i*%i", d->frame.header.duration.seconds,
+  d->frame.header.samplerate );
   return d->frame.header.duration.seconds * d->frame.header.samplerate;
 */
    if ( d->frame.header.bitrate == 0 )
       return 0;
    int samples = (d->input.fileLength / (d->frame.header.bitrate/8)) * d->frame.header.samplerate;
 
-   //   odebug << "LibMadPlugin::audioSamples: " << (int)d->input.fileLength
-   //          << " * " << (int)d->frame.header.samplerate << " * 8 / " << (int)d->frame.header.bitrate << oendl;
-   //   odebug << "LibMadPlugin::audioSamples: " << samples << "" << oendl;
+   //   qDebug( "LibMadPlugin::audioSamples: %i * %i * 8 / %i", (int)d->input.fileLength,
+   //           (int)d->frame.header.samplerate, (int)d->frame.header.bitrate ); 
+   //   qDebug( "LibMadPlugin::audioSamples: %i", samples );
 
    return samples;
 
 //    return 10000000;
 }
 
 
 bool LibMadPlugin::audioSetSample( long, int ) {
     debugMsg( "LibMadPlugin::audioSetSample" );
 
 //     long totalSamples = audioSamples(0);
 //     if ( totalSamples <= 1 )
 //   return FALSE;
 
 //     // Seek to requested position
-//     odebug << "seek pos: " << (int)((double)pos * d->input.fileLength / totalSamples) << "" << oendl;
+//     qDebug( "seek pos: %i", (int)((double)pos * d->input.fileLength / totalSamples) );
 //     ::lseek( d->input.fd, (long)((double)pos * d->input.fileLength / totalSamples), SEEK_SET );
 //     mad_stream_sync(&d->stream);
 
 //     mad_stream_init(&d->stream);
 //     mad_frame_init(&d->frame);
 //     mad_synth_init(&d->synth);
 
 //     return TRUE;
     debugMsg( "LibMadPlugin::audioSetSample" );
     return FALSE;
 }
 
 
 long LibMadPlugin::audioGetSample( int ) {
     debugMsg( "LibMadPlugin::audioGetSample" );
     return 0;
 }
 
 /*
 bool LibMadPlugin::audioReadSamples( short *, int, long, int ) {
 debugMsg( "LibMadPlugin::audioReadSamples" );
 return FALSE;
 }
 
 
 bool LibMadPlugin::audioReReadSamples( short *, int, long, int ) {
 debugMsg( "LibMadPlugin::audioReReadSamples" );
     return FALSE;
     }
 */
 
 bool LibMadPlugin::read() {
     debugMsg( "LibMadPlugin::read" );
     int len;
 
       if (d->input.eof)
   return FALSE;
 
 #if defined(HAVE_MMAP)
       if (d->input.fdm) {
           unsigned long skip = 0;
 
           if (d->stream.next_frame) {
               struct stat stat;
 
               if (fstat(d->input.fd, &stat) == -1)
                   return FALSE;
 
               if (stat.st_size + MAD_BUFFER_GUARD <= (signed)d->input.length)
                   return FALSE;
 
               // file size changed; update memory map
               skip = d->stream.next_frame - d->input.data;
 
               if (unmap_file(d->input.fdm, d->input.length) == -1) {
                   d->input.fdm  = 0;
                   d->input.data = 0;
                   return FALSE;
               }
 
               d->input.length = stat.st_size;
 
               d->input.fdm = map_file(d->input.fd, &d->input.length);
               if (d->input.fdm == 0) {
                   d->input.data = 0;
                   return FALSE;
               }
 
               d->input.data = (unsigned char *)d->input.fdm;
           }
 
           mad_stream_buffer(&d->stream, d->input.data + skip, d->input.length - skip);
 
       } else
 #endif
       {
           if (d->stream.next_frame) {
               memmove(d->input.data, d->stream.next_frame,
                       d->input.length = &d->input.data[d->input.length] - d->stream.next_frame);
           }
 
           do {
               len = ::read(d->input.fd, d->input.data + d->input.length, bufferSize /* MPEG_BUFFER_SIZE*/ - d->input.length);
           }
           while (len == -1 && errno == EINTR);
 
           if (len == -1) {
-             //              odebug << "error reading audio" << oendl;
+             //              qDebug("error reading audio");
               return FALSE;
           }
           else if (len == 0) {
               d->input.eof = 1;
 
               assert(bufferSize /*MPEG_BUFFER_SIZE*/ - d->input.length >= MAD_BUFFER_GUARD);
 
               while (len < MAD_BUFFER_GUARD)
                   d->input.data[d->input.length + len++] = 0;
           }
 
           mad_stream_buffer(&d->stream, d->input.data, d->input.length += len);
       }
 
       return TRUE;
 }
 
 
 static mad_fixed_t left_err, right_err;
 static const int bits = 16;
 static const int shift = MAD_F_FRACBITS + 1 - bits;
 
 
 inline long audio_linear_dither( mad_fixed_t sample, mad_fixed_t& error ) {
     sample += error;
     mad_fixed_t quantized = (sample >= MAD_F_ONE) ? MAD_F_ONE - 1 : ( (sample < -MAD_F_ONE) ? -MAD_F_ONE : sample );
     quantized &= ~((1L << shift) - 1);
     error = sample - quantized;
     return quantized >> shift;
 }
 
 
 inline void audio_pcm( short *data, unsigned int nsamples, mad_fixed_t *left, mad_fixed_t *right ) {
     if ( right ) {
         while (nsamples--) {
             data[0] = audio_linear_dither( *left++,  left_err );
             data[1] = audio_linear_dither( *right++, right_err );
             data += 2;
         }
     } else {
         while (nsamples--) {
             data[0] = data[1] = audio_linear_dither( *left++,  left_err );
             data += 2;
         }
     }
 }
 
 
 bool LibMadPlugin::decode( short *output, long samples, long& samplesMade ) {
     debugMsg( "LibMadPlugin::decode" );
 
     static int buffered = 0;
     static mad_fixed_t buffer[2][65536 * 2];
     int offset = buffered;
     samplesMade = 0;
 
     static int maxBuffered = 8000; // 65536;
 
     if ( samples > maxBuffered ) {
         samples = maxBuffered;
     }
 
     if ( d->flush ) {
         buffered = 0;
         offset = 0;
         d->flush = FALSE;
     }
 
     while ( buffered < maxBuffered ) {
 
         while (mad_frame_decode(&d->frame, &d->stream) == -1) {
             if (!MAD_RECOVERABLE(d->stream.error)) {
                 debugMsg( "feed me" );
                 return FALSE; // Feed me
             }
             if ( d->stream.error == MAD_ERROR_BADCRC ) {
                 mad_frame_mute(&d->frame);
-                //                odebug << "error decoding, bad crc" << oendl;
+                //                qDebug( "error decoding, bad crc" );
             }
         }
 
         mad_synth_frame(&d->synth, &d->frame);
         int decodedSamples = d->synth.pcm.length;
         memcpy( &(buffer[0][offset]), d->synth.pcm.samples[0], decodedSamples * sizeof(mad_fixed_t) );
         if ( d->synth.pcm.channels == 2 )
             memcpy( &(buffer[1][offset]), d->synth.pcm.samples[1], decodedSamples * sizeof(mad_fixed_t) );
         offset += decodedSamples;
         buffered += decodedSamples;
     }
 
 //qApp->processEvents();
     audio_pcm( output, samples, buffer[0], (d->synth.pcm.channels == 2) ? buffer[1] : 0 );
 //    audio_pcm( output, samples, buffer[1], buffer[0] );
 //    audio_pcm( output, samples, buffer[0], buffer[1] );
     samplesMade = samples;
     memmove( buffer[0], &(buffer[0][samples]), (buffered - samples) * sizeof(mad_fixed_t) );
     if ( d->synth.pcm.channels == 2 ) {
         memmove( buffer[1], &(buffer[1][samples]), (buffered - samples) * sizeof(mad_fixed_t) );
     }
     buffered -= samples;
 
     return TRUE;
 }
 
 /*bool LibMadPlugin::audioReadStereoSamples( short *output, long samples, long& samplesMade, int ) {
 */
 bool LibMadPlugin::audioReadSamples( short *output, int /*channels*/, long samples, long& samplesMade, int ) {
     debugMsg( "LibMadPlugin::audioReadStereoSamples" );
 
     static bool needInput = TRUE;
 
     if ( samples == 0 )
         return FALSE;
 
     do {
         if ( needInput )
             if ( !read() ) {
                 return FALSE;
             }
 
         needInput = FALSE;
 
         if ( decode( output, samples, samplesMade ) )
             return TRUE;
         else
             needInput = TRUE;
     }
     while ( ( samplesMade < samples ) && ( !d->input.eof ) );
 
     return FALSE;
 }
 
 
 double LibMadPlugin::getTime() {
     debugMsg( "LibMadPlugin::getTime" );
     return 0.0;
 }
 
 
 void LibMadPlugin::printID3Tags() {
-   //    odebug << "LibMadPlugin::printID3Tags" << oendl;
+   //    qDebug( "LibMadPlugin::printID3Tags" );
 
     char id3v1[128 + 1];
 
     if ( ::lseek( d->input.fd, -128, SEEK_END ) == -1 ) {
-       //        odebug << "error seeking to id3 tags" << oendl;
+       //        qDebug( "error seeking to id3 tags" );
         return;
     }
 
     if ( ::read( d->input.fd, id3v1, 128 ) != 128 ) {
-       //        odebug << "error reading in id3 tags" << oendl;
+       //        qDebug( "error reading in id3 tags" );
         return;
     }
 
     if ( ::strncmp( (const char *)id3v1, "TAG", 3 ) != 0 ) {
         debugMsg( "sorry, no id3 tags" );
     } else {
         int len[5] = { 30, 30, 30, 4, 30 };
         QString label[5] = { tr( "Title" ), tr( "Artist" ), tr( "Album" ), tr( "Year" ), tr( "Comment" ) };
         char *ptr = id3v1 + 3, *ptr2 = ptr + len[0];
-        //        odebug << "ID3 tags in file:" << oendl;
+        //        qDebug( "ID3 tags in file:" );
         info = "";
         for ( int i = 0; i < 5; ptr += len[i], i++, ptr2 += len[i] ) {
             char push = *ptr2;
             *ptr2 = '\0';
             char *ptr3 = ptr2;
             while ( ptr3-1 >= ptr && isspace(ptr3[-1]) ) ptr3--;
             char push2 = *ptr3; *ptr3 = '\0';
             if ( strcmp( ptr, "" ) ) {
                 if( ((QString)ptr).find("  ") == -1) // don't add anything that has blanks
                 info += ( i != 0 ? ", " : "" ) + label[i] + ": " + ptr;
             }
-//             odebug << info.latin1() << oendl;
+//             qDebug( info.latin1() );
             *ptr3 = push2;
             *ptr2 = push;
         }
         if (id3v1[126] == 0 && id3v1[127] != 0)
             info += tr( ", Track: " ) + id3v1[127];
     }
 
     if ( ::lseek(d->input.fd, 0, SEEK_SET) == -1 ) {
-       //        odebug << "error seeking back to beginning" << oendl;
+       //        qDebug( "error seeking back to beginning" );
         return;
     }
 }
 
diff --git a/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp b/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp
index b3e01e5..67779e8 100644
--- a/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp
+++ b/core/multimedia/opieplayer/libmad/libmadpluginimpl.cpp
@@ -1,72 +1,70 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 #include "libmadplugin.h"
 #include "libmadpluginimpl.h"
 
 
 LibMadPluginImpl::LibMadPluginImpl()
     : libmadplugin(0), ref(0)
 {
 }
 
 
 LibMadPluginImpl::~LibMadPluginImpl()
 {
     if ( libmadplugin )
   delete libmadplugin;
 }
 
 
 MediaPlayerDecoder *LibMadPluginImpl::decoder()
 {
     if ( !libmadplugin )
   libmadplugin = new LibMadPlugin;
     return libmadplugin;
 }
 
 
 MediaPlayerEncoder *LibMadPluginImpl::encoder()
 {
     return NULL;
 }
 
 
 #ifndef QT_NO_COMPONENT
 
 
 QRESULT LibMadPluginImpl::queryInterface( const QUuid &uuid, QUnknownInterface **iface )
 {
     *iface = 0;
     if ( ( uuid == IID_QUnknown ) || ( uuid == IID_MediaPlayerPlugin )  )
   *iface = this, (*iface)->addRef();
-    else
-        return QS_FALSE;
     return QS_OK;
 }
 
 
 Q_EXPORT_INTERFACE()
 {
     Q_CREATE_INSTANCE( LibMadPluginImpl )
 }
 
 
 #endif
 
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,830 +1,964 @@
 /*
- * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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;
 
 typedef   signed int mad_fixed64hi_t;
 typedef unsigned int mad_fixed64lo_t;
 # else
 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:
  * 0x80000000 to 0x7fffffff
  *       -8.0 to +7.9999999962747097015380859375
  *
  * The smallest representable value is:
  * 0x00000001 == 0.0000000037252902984619140625 (i.e. about 3.725e-9)
  *
  * 28 bits of fractional accuracy represent about
  * 8.6 digits of decimal accuracy.
  *
  * Fixed-point numbers can be added or subtracted as normal
  * integers, but multiplication requires shifting the 64-bit result
  * from 56 fractional bits back to 28 (and rounding.)
  *
  * Changing the definition of MAD_F_FRACBITS is only partially
  * supported, and must be done with care.
  */
 
         # define MAD_F_FRACBITS         28
 
 # if MAD_F_FRACBITS == 28
         #  define MAD_F(x)      ((mad_fixed_t) (x##L))
 # else
 #  if MAD_F_FRACBITS < 28
 #   warning "MAD_F_FRACBITS < 28"
         #   define MAD_F(x)     ((mad_fixed_t)  \
                                  (((x##L) +  \
                                    (1L << (28 - MAD_F_FRACBITS - 1))) >>  \
                                   (28 - MAD_F_FRACBITS)))
 #  elif MAD_F_FRACBITS > 28
 #   error "MAD_F_FRACBITS > 28 not currently supported"
         #   define MAD_F(x)     ((mad_fixed_t)  \
                                  ((x##L) << (MAD_F_FRACBITS - 28)))
 #  endif
 # endif
 
         # define MAD_F_MIN      ((mad_fixed_t) -0x80000000L)
         # define MAD_F_MAX      ((mad_fixed_t) +0x7fffffffL)
 
         # define MAD_F_ONE      MAD_F(0x10000000)
 
         # define mad_f_tofixed(x)((mad_fixed_t)  \
                                  ((x) * (double) (1L << MAD_F_FRACBITS) + 0.5))
         # define mad_f_todouble(x)((double)  \
                                  ((x) / (double) (1L << MAD_F_FRACBITS)))
 
         # define mad_f_intpart(x)((x) >> MAD_F_FRACBITS)
         # define mad_f_fracpart(x)((x) & ((1L << MAD_F_FRACBITS) - 1))
                                 /* (x should be positive) */
 
         # 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_)  \
             : "0" (lo), "1" (hi),  \
               "ir" (1L << (MAD_F_SCALEBITS - 1)), "ir" (0)  \
             : "cc");  \
        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"  \
                     "movs%0, %0, lsr %5\n\t"  \
                     "adc%2, %0, %1, lsl %6"  \
             : "=&r" (__lo), "=&r" (__hi), "=r" (__result)  \
             : "%r" (x), "r" (y),  \
               "M" (MAD_F_SCALEBITS), "M" (32 - MAD_F_SCALEBITS)  \
             : "cc");  \
        __result;  \
     })
 # endif
 
 #  define MAD_F_MLX(hi, lo, x, y)  \
             asm ("smull%0, %1, %2, %3"  \
          : "=&r" (lo), "=&r" (hi)  \
          : "%r" (x), "r" (y))
 
 #  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;  \
     })
 
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 
 /* --- MIPS ---------------------------------------------------------------- */
 
 # elif defined(FPM_MIPS)
 
 /*
  * This MIPS 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 ("mult%2,%3"  \
          : "=l" (lo), "=h" (hi)  \
          : "%r" (x), "r" (y))
 
 # if defined(HAVE_MADD_ASM)
 #  define MAD_F_MLA(hi, lo, x, y)  \
             asm ("madd%2,%3"  \
          : "+l" (lo), "+h" (hi)  \
          : "%r" (x), "r" (y))
 # elif defined(HAVE_MADD16_ASM)
 /*
  * This loses significant accuracy due to the 16-bit integer limit in the
  * multiply/accumulate instruction.
  */
 #  define MAD_F_ML0(hi, lo, x, y)  \
             asm ("mult%2,%3"  \
          : "=l" (lo), "=h" (hi)  \
          : "%r" ((x) >> 12), "r" ((y) >> 16))
 #  define MAD_F_MLA(hi, lo, x, y)  \
             asm ("madd16%2,%3"  \
          : "+l" (lo), "+h" (hi)  \
          : "%r" ((x) >> 12), "r" ((y) >> 16))
 #  define MAD_F_MLZ(hi, lo)  ((mad_fixed_t) (lo))
 # endif
 
 # if defined(OPT_SPEED)
 #  define mad_f_scale64(hi, lo)  \
     ((mad_fixed_t) ((hi) << (32 - MAD_F_SCALEBITS)))
 #  define MAD_F_SCALEBITS  MAD_F_FRACBITS
 # endif
 
 /* --- SPARC --------------------------------------------------------------- */
 
 # elif defined(FPM_SPARC)
 
 /*
  * This SPARC V8 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 ("smul %2, %3, %0\n\t"  \
          "rd %%y, %1"  \
          : "=r" (lo), "=r" (hi)  \
          : "%r" (x), "rI" (y))
 
 /* --- 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)
 
 /*
  * This version is the most portable but it loses significant accuracy.
  * Furthermore, accuracy is biased against the second argument, so care
  * 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)
 #   define mad_f_scale64(hi, lo)  \
     ((((mad_fixed_t)  \
        (((hi) << (32 - (MAD_F_SCALEBITS - 1))) |  \
         ((lo) >> (MAD_F_SCALEBITS - 1)))) + 1) >> 1)
 #  else
 #   define mad_f_scale64(hi, lo)  \
     ((mad_fixed_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;
   unsigned short cache;
   unsigned short left;
 };
 
 void mad_bit_init(struct mad_bitptr *, unsigned char const *);
 
         # define mad_bit_finish(bitptr)         /* nothing */
 
 unsigned int mad_bit_length(struct mad_bitptr const *,
                             struct mad_bitptr const *);
 
 # define mad_bit_bitsleft(bitptr)  ((bitptr)->left)
 unsigned char const *mad_bit_nextbyte(struct mad_bitptr const *);
 
 void mad_bit_skip(struct mad_bitptr *, unsigned int);
 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 */
           unsigned long fraction;/* 1/MAD_TIMER_RESOLUTION seconds */
 } mad_timer_t;
 
 extern mad_timer_t const mad_timer_zero;
 
         # define MAD_TIMER_RESOLUTION352800000UL
 
 enum mad_units {
           MAD_UNITS_HOURS =    -2,
           MAD_UNITS_MINUTES =    -1,
           MAD_UNITS_SECONDS =     0,
 
   /* metric units */
 
           MAD_UNITS_DECISECONDS =    10,
   MAD_UNITS_CENTISECONDS =   100,
   MAD_UNITS_MILLISECONDS =  1000,
 
   /* audio sample units */
 
           MAD_UNITS_8000_HZ =  8000,
           MAD_UNITS_11025_HZ = 11025,
           MAD_UNITS_12000_HZ = 12000,
 
           MAD_UNITS_16000_HZ = 16000,
           MAD_UNITS_22050_HZ = 22050,
           MAD_UNITS_24000_HZ = 24000,
 
           MAD_UNITS_32000_HZ = 32000,
           MAD_UNITS_44100_HZ = 44100,
           MAD_UNITS_48000_HZ = 48000,
 
   /* video frame/field units */
 
           MAD_UNITS_24_FPS =    24,
           MAD_UNITS_25_FPS =    25,
           MAD_UNITS_30_FPS =    30,
           MAD_UNITS_48_FPS =    48,
           MAD_UNITS_50_FPS =    50,
           MAD_UNITS_60_FPS =    60,
 
   /* CD audio frames */
 
           MAD_UNITS_75_FPS =    75,
 
   /* video drop-frame units */
 
           MAD_UNITS_23_976_FPS =   -24,
           MAD_UNITS_24_975_FPS =   -25,
           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 *);
 mad_timer_t mad_timer_abs(mad_timer_t);
 
 void mad_timer_set(mad_timer_t *, unsigned long, unsigned long, unsigned long);
 void mad_timer_add(mad_timer_t *, mad_timer_t);
 void mad_timer_multiply(mad_timer_t *, signed long);
 
 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 */
           MAD_ERROR_BADLAYER       = 0x0102,/* reserved header layer value */
           MAD_ERROR_BADBITRATE     = 0x0103,/* forbidden bitrate value */
           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 */
           MAD_ERROR_BADHUFFTABLE   = 0x0237,/* bad Huffman table select */
           MAD_ERROR_BADHUFFDATA            = 0x0238,/* Huffman data overrun */
           MAD_ERROR_BADSTEREO      = 0x0239/* incompatible block_type for JS */
 };
 
         # define MAD_RECOVERABLE(error)((error) & 0xff00)
 
 struct mad_stream {
           unsigned char const *buffer;  /* input bitstream buffer */
           unsigned char const *bufend;  /* end of buffer */
           unsigned long skiplen;        /* bytes to skip before next frame */
 
           int sync;                     /* stream sync found */
           unsigned long freerate;       /* free bitrate (fixed) */
 
           unsigned char const *this_frame;/* start of current frame */
           unsigned char const *next_frame;/* start of next frame */
           struct mad_bitptr ptr;        /* current processing bit pointer */
 
           struct mad_bitptr anc_ptr;    /* ancillary bits pointer */
           unsigned int anc_bitlen;      /* number of ancillary bits */
 
   unsigned char (*main_data)[MAD_BUFFER_MDLEN];
                                         /* Layer III main_data() */
           unsigned int md_len;          /* bytes in main_data */
 
           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 */
 };
 
 enum mad_mode {
           MAD_MODE_SINGLE_CHANNEL = 0,  /* single channel */
           MAD_MODE_DUAL_CHANNEL           = 1,  /* dual channel */
           MAD_MODE_JOINT_STEREO           = 2,  /* joint (MS/intensity) stereo */
           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 */
 };
 
         # define MAD_NCHANNELS(header)  ((header)->mode ? 2 : 1)
 # 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 */
 
 int mad_header_decode(struct mad_header *, struct mad_stream *);
 
 void mad_frame_init(struct mad_frame *);
 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;
 
   struct {
     long pid;
     int in;
     int out;
   } async;
 
   struct {
     struct mad_stream stream;
     struct mad_frame frame;
     struct mad_synth synth;
   } *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
diff --git a/core/multimedia/opieplayer/libmad/opie-libmadplugin.control b/core/multimedia/opieplayer/libmad/opie-libmadplugin.control
index 8de5976..15c083f 100644
--- a/core/multimedia/opieplayer/libmad/opie-libmadplugin.control
+++ b/core/multimedia/opieplayer/libmad/opie-libmadplugin.control
@@ -1,11 +1,11 @@
 Package: opie-libmadplugin
 Files: plugins/codecs/libmadplugin.so.1.0.0 plugins/codecs/libmadplugin.so.1.0 plugins/codecs/libmadplugin.so.1 plugins/codecs/libmadplugin.so
 Priority: optional
-Section: libs
-Maintainer: Maximilian Reiss <max.reiss@gmx.de>, L.J. Potter <lpotter@trolltech.com>
+Section: opie/plugins
+Maintainer: Maximilian Reiss <max.reiss@gmx.de>
 Architecture: arm
 Depends: task-opie-minimal
 Description: MP3 file plugin using libmad
  Plugin to play MP3 files with the mediaplayer in the Opie environment.
- It also has streaming support (Shoutcast/Icecast).
+ It also hast streaming support (Shoutcast/Icecast).
 Version: $QPE_VERSION$EXTRAVERSION
diff --git a/core/multimedia/opieplayer/libmad/qc_table.dat b/core/multimedia/opieplayer/libmad/qc_table.dat
index 5d9ca96..d28a207 100644
--- a/core/multimedia/opieplayer/libmad/qc_table.dat
+++ b/core/multimedia/opieplayer/libmad/qc_table.dat
@@ -1,77 +1,77 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 /*
  * These are the Layer II classes of quantization.
  * The table is derived from Table B.4 of ISO/IEC 11172-3.
  */
 
   {     3, 2,  5,
     MAD_F(0x15555555) /* 1.33333333333 => 1.33333333209, e  0.00000000124 */,
     MAD_F(0x08000000) /* 0.50000000000 => 0.50000000000, e  0.00000000000 */ },
   {     5, 3,  7,
     MAD_F(0x1999999a) /* 1.60000000000 => 1.60000000149, e -0.00000000149 */,
     MAD_F(0x08000000) /* 0.50000000000 => 0.50000000000, e  0.00000000000 */ },
   {     7, 0,  3,
     MAD_F(0x12492492) /* 1.14285714286 => 1.14285714179, e  0.00000000107 */,
     MAD_F(0x04000000) /* 0.25000000000 => 0.25000000000, e  0.00000000000 */ },
   {     9, 4, 10,
     MAD_F(0x1c71c71c) /* 1.77777777777 => 1.77777777612, e  0.00000000165 */,
     MAD_F(0x08000000) /* 0.50000000000 => 0.50000000000, e  0.00000000000 */ },
   {    15, 0,  4,
     MAD_F(0x11111111) /* 1.06666666666 => 1.06666666642, e  0.00000000024 */,
     MAD_F(0x02000000) /* 0.12500000000 => 0.12500000000, e  0.00000000000 */ },
   {    31, 0,  5,
     MAD_F(0x10842108) /* 1.03225806452 => 1.03225806355, e  0.00000000097 */,
     MAD_F(0x01000000) /* 0.06250000000 => 0.06250000000, e  0.00000000000 */ },
   {    63, 0,  6,
     MAD_F(0x10410410) /* 1.01587301587 => 1.01587301493, e  0.00000000094 */,
     MAD_F(0x00800000) /* 0.03125000000 => 0.03125000000, e  0.00000000000 */ },
   {   127, 0,  7,
     MAD_F(0x10204081) /* 1.00787401575 => 1.00787401572, e  0.00000000003 */,
     MAD_F(0x00400000) /* 0.01562500000 => 0.01562500000, e  0.00000000000 */ },
   {   255, 0,  8,
     MAD_F(0x10101010) /* 1.00392156863 => 1.00392156839, e  0.00000000024 */,
     MAD_F(0x00200000) /* 0.00781250000 => 0.00781250000, e  0.00000000000 */ },
   {   511, 0,  9,
     MAD_F(0x10080402) /* 1.00195694716 => 1.00195694715, e  0.00000000001 */,
     MAD_F(0x00100000) /* 0.00390625000 => 0.00390625000, e  0.00000000000 */ },
   {  1023, 0, 10,
     MAD_F(0x10040100) /* 1.00097751711 => 1.00097751617, e  0.00000000094 */,
     MAD_F(0x00080000) /* 0.00195312500 => 0.00195312500, e  0.00000000000 */ },
   {  2047, 0, 11,
     MAD_F(0x10020040) /* 1.00048851979 => 1.00048851967, e  0.00000000012 */,
     MAD_F(0x00040000) /* 0.00097656250 => 0.00097656250, e  0.00000000000 */ },
   {  4095, 0, 12,
     MAD_F(0x10010010) /* 1.00024420024 => 1.00024420023, e  0.00000000001 */,
     MAD_F(0x00020000) /* 0.00048828125 => 0.00048828125, e  0.00000000000 */ },
   {  8191, 0, 13,
     MAD_F(0x10008004) /* 1.00012208522 => 1.00012208521, e  0.00000000001 */,
     MAD_F(0x00010000) /* 0.00024414063 => 0.00024414062, e  0.00000000000 */ },
   { 16383, 0, 14,
     MAD_F(0x10004001) /* 1.00006103888 => 1.00006103888, e -0.00000000000 */,
     MAD_F(0x00008000) /* 0.00012207031 => 0.00012207031, e -0.00000000000 */ },
   { 32767, 0, 15,
     MAD_F(0x10002000) /* 1.00003051851 => 1.00003051758, e  0.00000000093 */,
     MAD_F(0x00004000) /* 0.00006103516 => 0.00006103516, e  0.00000000000 */ },
   { 65535, 0, 16,
     MAD_F(0x10001000) /* 1.00001525902 => 1.00001525879, e  0.00000000023 */,
     MAD_F(0x00002000) /* 0.00003051758 => 0.00003051758, e  0.00000000000 */ }
diff --git a/core/multimedia/opieplayer/libmad/rq_table.dat b/core/multimedia/opieplayer/libmad/rq_table.dat
index 803cf04..518a391 100644
--- a/core/multimedia/opieplayer/libmad/rq_table.dat
+++ b/core/multimedia/opieplayer/libmad/rq_table.dat
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 /*
  * This is the lookup table used to compute x^(4/3) for Layer III
  * requantization. To maintain the best possible accuracy, the value is
  * stored as a normalized mantissa with exponent. The requantization
  * algorithm recombines these parts with appropriate scaling.
  */
 
   /*    0 */  { MAD_F(0x00000000) /* 0.000000000 */,  0 },
   /*    1 */  { MAD_F(0x04000000) /* 0.250000000 */,  2 },
   /*    2 */  { MAD_F(0x050a28be) /* 0.314980262 */,  3 },
   /*    3 */  { MAD_F(0x0453a5cd) /* 0.270421794 */,  4 },
   /*    4 */  { MAD_F(0x06597fa9) /* 0.396850263 */,  4 },
   /*    5 */  { MAD_F(0x04466275) /* 0.267183742 */,  5 },
   /*    6 */  { MAD_F(0x05738c72) /* 0.340710111 */,  5 },
   /*    7 */  { MAD_F(0x06b1fc81) /* 0.418453696 */,  5 },
   /*    8 */  { MAD_F(0x04000000) /* 0.250000000 */,  6 },
   /*    9 */  { MAD_F(0x04ae20d7) /* 0.292511788 */,  6 },
   /*   10 */  { MAD_F(0x0562d694) /* 0.336630420 */,  6 },
   /*   11 */  { MAD_F(0x061dae96) /* 0.382246578 */,  6 },
   /*   12 */  { MAD_F(0x06de47f4) /* 0.429267841 */,  6 },
   /*   13 */  { MAD_F(0x07a44f7a) /* 0.477614858 */,  6 },
   /*   14 */  { MAD_F(0x0437be65) /* 0.263609310 */,  7 },
   /*   15 */  { MAD_F(0x049fc824) /* 0.289009227 */,  7 },
 
   /*   16 */  { MAD_F(0x050a28be) /* 0.314980262 */,  7 },
   /*   17 */  { MAD_F(0x0576c6f5) /* 0.341498336 */,  7 },
   /*   18 */  { MAD_F(0x05e58c0b) /* 0.368541759 */,  7 },
   /*   19 */  { MAD_F(0x06566361) /* 0.396090870 */,  7 },
   /*   20 */  { MAD_F(0x06c93a2e) /* 0.424127753 */,  7 },
   /*   21 */  { MAD_F(0x073dff3e) /* 0.452635998 */,  7 },
   /*   22 */  { MAD_F(0x07b4a2bc) /* 0.481600510 */,  7 },
   /*   23 */  { MAD_F(0x04168b05) /* 0.255503674 */,  8 },
   /*   24 */  { MAD_F(0x0453a5cd) /* 0.270421794 */,  8 },
   /*   25 */  { MAD_F(0x04919b6a) /* 0.285548607 */,  8 },
   /*   26 */  { MAD_F(0x04d065fb) /* 0.300878507 */,  8 },
   /*   27 */  { MAD_F(0x05100000) /* 0.316406250 */,  8 },
   /*   28 */  { MAD_F(0x05506451) /* 0.332126919 */,  8 },
   /*   29 */  { MAD_F(0x05918e15) /* 0.348035890 */,  8 },
   /*   30 */  { MAD_F(0x05d378bb) /* 0.364128809 */,  8 },
   /*   31 */  { MAD_F(0x06161ff3) /* 0.380401563 */,  8 },
 
   /*   32 */  { MAD_F(0x06597fa9) /* 0.396850263 */,  8 },
   /*   33 */  { MAD_F(0x069d9400) /* 0.413471222 */,  8 },
   /*   34 */  { MAD_F(0x06e2594c) /* 0.430260942 */,  8 },
   /*   35 */  { MAD_F(0x0727cc11) /* 0.447216097 */,  8 },
   /*   36 */  { MAD_F(0x076de8fc) /* 0.464333519 */,  8 },
   /*   37 */  { MAD_F(0x07b4ace3) /* 0.481610189 */,  8 },
   /*   38 */  { MAD_F(0x07fc14bf) /* 0.499043224 */,  8 },
   /*   39 */  { MAD_F(0x04220ed7) /* 0.258314934 */,  9 },
   /*   40 */  { MAD_F(0x04466275) /* 0.267183742 */,  9 },
   /*   41 */  { MAD_F(0x046b03e7) /* 0.276126771 */,  9 },
   /*   42 */  { MAD_F(0x048ff1e8) /* 0.285142811 */,  9 },
   /*   43 */  { MAD_F(0x04b52b3f) /* 0.294230696 */,  9 },
   /*   44 */  { MAD_F(0x04daaec0) /* 0.303389310 */,  9 },
   /*   45 */  { MAD_F(0x05007b49) /* 0.312617576 */,  9 },
   /*   46 */  { MAD_F(0x05268fc6) /* 0.321914457 */,  9 },
   /*   47 */  { MAD_F(0x054ceb2a) /* 0.331278957 */,  9 },
 
   /*   48 */  { MAD_F(0x05738c72) /* 0.340710111 */,  9 },
   /*   49 */  { MAD_F(0x059a72a5) /* 0.350206992 */,  9 },
   /*   50 */  { MAD_F(0x05c19cd3) /* 0.359768701 */,  9 },
   /*   51 */  { MAD_F(0x05e90a12) /* 0.369394372 */,  9 },
   /*   52 */  { MAD_F(0x0610b982) /* 0.379083164 */,  9 },
   /*   53 */  { MAD_F(0x0638aa48) /* 0.388834268 */,  9 },
   /*   54 */  { MAD_F(0x0660db91) /* 0.398646895 */,  9 },
   /*   55 */  { MAD_F(0x06894c90) /* 0.408520284 */,  9 },
   /*   56 */  { MAD_F(0x06b1fc81) /* 0.418453696 */,  9 },
   /*   57 */  { MAD_F(0x06daeaa1) /* 0.428446415 */,  9 },
   /*   58 */  { MAD_F(0x07041636) /* 0.438497744 */,  9 },
   /*   59 */  { MAD_F(0x072d7e8b) /* 0.448607009 */,  9 },
   /*   60 */  { MAD_F(0x075722ef) /* 0.458773552 */,  9 },
   /*   61 */  { MAD_F(0x078102b8) /* 0.468996735 */,  9 },
   /*   62 */  { MAD_F(0x07ab1d3e) /* 0.479275937 */,  9 },
   /*   63 */  { MAD_F(0x07d571e0) /* 0.489610555 */,  9 },
 
   /*   64 */  { MAD_F(0x04000000) /* 0.250000000 */, 10 },
   /*   65 */  { MAD_F(0x04156381) /* 0.255221850 */, 10 },
   /*   66 */  { MAD_F(0x042ae32a) /* 0.260470548 */, 10 },
diff --git a/core/multimedia/opieplayer/libmad/sf_table.dat b/core/multimedia/opieplayer/libmad/sf_table.dat
index bc368af..de084d9 100644
--- a/core/multimedia/opieplayer/libmad/sf_table.dat
+++ b/core/multimedia/opieplayer/libmad/sf_table.dat
@@ -1,100 +1,106 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 /*
  * These are the scalefactor values for Layer I and Layer II.
  * The values are from Table B.1 of ISO/IEC 11172-3.
  *
  * There is some error introduced by the 32-bit fixed-point representation;
  * the amount of error is shown. For 16-bit PCM output, this shouldn't be
  * too much of a problem.
+ *
+ * Strictly speaking, Table B.1 has only 63 entries (0-62), thus a strict
+ * interpretation of ISO/IEC 11172-3 would suggest that a scalefactor index of
+ * 63 is invalid. However, for better compatibility with current practices, we
+ * add a 64th entry.
  */
 
   MAD_F(0x20000000),  /* 2.000000000000 => 2.000000000000, e  0.000000000000 */
   MAD_F(0x1965fea5),  /* 1.587401051968 => 1.587401051074, e  0.000000000894 */
   MAD_F(0x1428a2fa),  /* 1.259921049895 => 1.259921051562, e -0.000000001667 */
   MAD_F(0x10000000),  /* 1.000000000000 => 1.000000000000, e  0.000000000000 */
   MAD_F(0x0cb2ff53),  /* 0.793700525984 => 0.793700527400, e -0.000000001416 */
   MAD_F(0x0a14517d),  /* 0.629960524947 => 0.629960525781, e -0.000000000833 */
   MAD_F(0x08000000),  /* 0.500000000000 => 0.500000000000, e  0.000000000000 */
   MAD_F(0x06597fa9),  /* 0.396850262992 => 0.396850261837, e  0.000000001155 */
 
   MAD_F(0x050a28be),  /* 0.314980262474 => 0.314980261028, e  0.000000001446 */
   MAD_F(0x04000000),  /* 0.250000000000 => 0.250000000000, e  0.000000000000 */
   MAD_F(0x032cbfd5),  /* 0.198425131496 => 0.198425132781, e -0.000000001285 */
   MAD_F(0x0285145f),  /* 0.157490131237 => 0.157490130514, e  0.000000000723 */
   MAD_F(0x02000000),  /* 0.125000000000 => 0.125000000000, e  0.000000000000 */
   MAD_F(0x01965fea),  /* 0.099212565748 => 0.099212564528, e  0.000000001220 */
   MAD_F(0x01428a30),  /* 0.078745065618 => 0.078745067120, e -0.000000001501 */
   MAD_F(0x01000000),  /* 0.062500000000 => 0.062500000000, e  0.000000000000 */
 
   MAD_F(0x00cb2ff5),  /* 0.049606282874 => 0.049606282264, e  0.000000000610 */
   MAD_F(0x00a14518),  /* 0.039372532809 => 0.039372533560, e -0.000000000751 */
   MAD_F(0x00800000),  /* 0.031250000000 => 0.031250000000, e  0.000000000000 */
   MAD_F(0x006597fb),  /* 0.024803141437 => 0.024803142995, e -0.000000001558 */
   MAD_F(0x0050a28c),  /* 0.019686266405 => 0.019686266780, e -0.000000000375 */
   MAD_F(0x00400000),  /* 0.015625000000 => 0.015625000000, e  0.000000000000 */
   MAD_F(0x0032cbfd),  /* 0.012401570719 => 0.012401569635, e  0.000000001084 */
   MAD_F(0x00285146),  /* 0.009843133202 => 0.009843133390, e -0.000000000188 */
 
   MAD_F(0x00200000),  /* 0.007812500000 => 0.007812500000, e  0.000000000000 */
   MAD_F(0x001965ff),  /* 0.006200785359 => 0.006200786680, e -0.000000001321 */
   MAD_F(0x001428a3),  /* 0.004921566601 => 0.004921566695, e -0.000000000094 */
   MAD_F(0x00100000),  /* 0.003906250000 => 0.003906250000, e  0.000000000000 */
   MAD_F(0x000cb2ff),  /* 0.003100392680 => 0.003100391477, e  0.000000001202 */
   MAD_F(0x000a1451),  /* 0.002460783301 => 0.002460781485, e  0.000000001816 */
   MAD_F(0x00080000),  /* 0.001953125000 => 0.001953125000, e  0.000000000000 */
   MAD_F(0x00065980),  /* 0.001550196340 => 0.001550197601, e -0.000000001262 */
 
   MAD_F(0x00050a29),  /* 0.001230391650 => 0.001230392605, e -0.000000000955 */
   MAD_F(0x00040000),  /* 0.000976562500 => 0.000976562500, e  0.000000000000 */
   MAD_F(0x00032cc0),  /* 0.000775098170 => 0.000775098801, e -0.000000000631 */
   MAD_F(0x00028514),  /* 0.000615195825 => 0.000615194440, e  0.000000001385 */
   MAD_F(0x00020000),  /* 0.000488281250 => 0.000488281250, e  0.000000000000 */
   MAD_F(0x00019660),  /* 0.000387549085 => 0.000387549400, e -0.000000000315 */
   MAD_F(0x0001428a),  /* 0.000307597913 => 0.000307597220, e  0.000000000693 */
   MAD_F(0x00010000),  /* 0.000244140625 => 0.000244140625, e  0.000000000000 */
 
   MAD_F(0x0000cb30),  /* 0.000193774542 => 0.000193774700, e -0.000000000158 */
   MAD_F(0x0000a145),  /* 0.000153798956 => 0.000153798610, e  0.000000000346 */
   MAD_F(0x00008000),  /* 0.000122070313 => 0.000122070313, e  0.000000000000 */
   MAD_F(0x00006598),  /* 0.000096887271 => 0.000096887350, e -0.000000000079 */
   MAD_F(0x000050a3),  /* 0.000076899478 => 0.000076901168, e -0.000000001689 */
   MAD_F(0x00004000),  /* 0.000061035156 => 0.000061035156, e  0.000000000000 */
   MAD_F(0x000032cc),  /* 0.000048443636 => 0.000048443675, e -0.000000000039 */
   MAD_F(0x00002851),  /* 0.000038449739 => 0.000038448721, e  0.000000001018 */
 
   MAD_F(0x00002000),  /* 0.000030517578 => 0.000030517578, e  0.000000000000 */
   MAD_F(0x00001966),  /* 0.000024221818 => 0.000024221838, e -0.000000000020 */
   MAD_F(0x00001429),  /* 0.000019224870 => 0.000019226223, e -0.000000001354 */
   MAD_F(0x00001000),  /* 0.000015258789 => 0.000015258789, e -0.000000000000 */
   MAD_F(0x00000cb3),  /* 0.000012110909 => 0.000012110919, e -0.000000000010 */
   MAD_F(0x00000a14),  /* 0.000009612435 => 0.000009611249, e  0.000000001186 */
   MAD_F(0x00000800),  /* 0.000007629395 => 0.000007629395, e -0.000000000000 */
   MAD_F(0x00000659),  /* 0.000006055454 => 0.000006053597, e  0.000000001858 */
 
   MAD_F(0x0000050a),  /* 0.000004806217 => 0.000004805624, e  0.000000000593 */
   MAD_F(0x00000400),  /* 0.000003814697 => 0.000003814697, e  0.000000000000 */
   MAD_F(0x0000032d),  /* 0.000003027727 => 0.000003028661, e -0.000000000934 */
   MAD_F(0x00000285),  /* 0.000002403109 => 0.000002402812, e  0.000000000296 */
   MAD_F(0x00000200),  /* 0.000001907349 => 0.000001907349, e -0.000000000000 */
   MAD_F(0x00000196),  /* 0.000001513864 => 0.000001512468, e  0.000000001396 */
-  MAD_F(0x00000143)   /* 0.000001201554 => 0.000001203269, e -0.000000001714 */
+  MAD_F(0x00000143),  /* 0.000001201554 => 0.000001203269, e -0.000000001714 */
+  MAD_F(0x00000000)   /* this compatibility entry is not part of Table B.1 */
diff --git a/core/multimedia/opieplayer/libmad/stream.c b/core/multimedia/opieplayer/libmad/stream.c
index 4374de7..a63d67b 100644
--- a/core/multimedia/opieplayer/libmad/stream.c
+++ b/core/multimedia/opieplayer/libmad/stream.c
@@ -1,160 +1,161 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include <stdlib.h>
 
 # include "bit.h"
 # include "stream.h"
 
 /*
          * NAME:stream->init()
          * DESCRIPTION:initialize stream struct
  */
 void mad_stream_init(struct mad_stream *stream)
 {
   stream->buffer     = 0;
   stream->bufend     = 0;
   stream->skiplen    = 0;
 
   stream->sync       = 0;
   stream->freerate   = 0;
 
   stream->this_frame = 0;
   stream->next_frame = 0;
   mad_bit_init(&stream->ptr, 0);
 
   mad_bit_init(&stream->anc_ptr, 0);
   stream->anc_bitlen = 0;
 
   stream->main_data  = 0;
   stream->md_len     = 0;
 
   stream->options    = 0;
   stream->error      = MAD_ERROR_NONE;
 }
 
 /*
          * NAME:stream->finish()
          * DESCRIPTION:deallocate any dynamic memory associated with stream
  */
 void mad_stream_finish(struct mad_stream *stream)
 {
   if (stream->main_data) {
     free(stream->main_data);
     stream->main_data = 0;
   }
 
   mad_bit_finish(&stream->anc_ptr);
   mad_bit_finish(&stream->ptr);
 }
 
 /*
          * NAME:stream->buffer()
          * DESCRIPTION:set stream buffer pointers
  */
 void mad_stream_buffer(struct mad_stream *stream,
                        unsigned char const *buffer, unsigned long length)
 {
   stream->buffer = buffer;
   stream->bufend = buffer + length;
 
   stream->this_frame = buffer;
   stream->next_frame = buffer;
 
   stream->sync = 1;
 
   mad_bit_init(&stream->ptr, buffer);
 }
 
 /*
          * NAME:stream->skip()
          * DESCRIPTION:arrange to skip bytes before the next frame
  */
 void mad_stream_skip(struct mad_stream *stream, unsigned long length)
 {
   stream->skiplen += length;
 }
 
 /*
          * NAME:stream->sync()
          * DESCRIPTION:locate the next stream sync word
  */
 int mad_stream_sync(struct mad_stream *stream)
 {
   register unsigned char const *ptr, *end;
 
   ptr = mad_bit_nextbyte(&stream->ptr);
   end = stream->bufend;
 
   while (ptr < end - 1 &&
          !(ptr[0] == 0xff && (ptr[1] & 0xe0) == 0xe0))
     ++ptr;
 
   if (end - ptr < MAD_BUFFER_GUARD)
     return -1;
 
   mad_bit_init(&stream->ptr, ptr);
 
   return 0;
 }
 
 /*
          * NAME:stream->errorstr()
          * DESCRIPTION:return a string description of the current error condition
  */
 char const *mad_stream_errorstr(struct mad_stream const *stream)
 {
   switch (stream->error) {
           case MAD_ERROR_NONE:   return "no error";
 
           case MAD_ERROR_BUFLEN: return "input buffer too small (or EOF)";
           case MAD_ERROR_BUFPTR: return "invalid (null) buffer pointer";
 
           case MAD_ERROR_NOMEM:          return "not enough memory";
 
           case MAD_ERROR_LOSTSYNC: return "lost synchronization";
           case MAD_ERROR_BADLAYER: return "reserved header layer value";
           case MAD_ERROR_BADBITRATE: return "forbidden bitrate value";
           case MAD_ERROR_BADSAMPLERATE: return "reserved sample frequency value";
           case MAD_ERROR_BADEMPHASIS: return "reserved emphasis value";
 
           case MAD_ERROR_BADCRC: return "CRC check failed";
           case MAD_ERROR_BADBITALLOC: return "forbidden bit allocation value";
   case MAD_ERROR_BADSCALEFACTOR: return "bad scalefactor index";
+          case MAD_ERROR_BADMODE: return "bad bitrate/mode combination";
           case MAD_ERROR_BADFRAMELEN: return "bad frame length";
           case MAD_ERROR_BADBIGVALUES: return "bad big_values count";
           case MAD_ERROR_BADBLOCKTYPE: return "reserved block_type";
           case MAD_ERROR_BADSCFSI: return "bad scalefactor selection info";
           case MAD_ERROR_BADDATAPTR: return "bad main_data_begin pointer";
           case MAD_ERROR_BADPART3LEN: return "bad audio data length";
           case MAD_ERROR_BADHUFFTABLE: return "bad Huffman table select";
           case MAD_ERROR_BADHUFFDATA: return "Huffman data overrun";
           case MAD_ERROR_BADSTEREO: return "incompatible block_type for JS";
   }
 
   return 0;
 }
diff --git a/core/multimedia/opieplayer/libmad/stream.h b/core/multimedia/opieplayer/libmad/stream.h
index 08e6dc5..5fca48f 100644
--- a/core/multimedia/opieplayer/libmad/stream.h
+++ b/core/multimedia/opieplayer/libmad/stream.h
@@ -1,107 +1,108 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_STREAM_H
 # define LIBMAD_STREAM_H
 
 # include "bit.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 */
           MAD_ERROR_BADLAYER       = 0x0102,/* reserved header layer value */
           MAD_ERROR_BADBITRATE     = 0x0103,/* forbidden bitrate value */
           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 */
           MAD_ERROR_BADHUFFTABLE   = 0x0237,/* bad Huffman table select */
           MAD_ERROR_BADHUFFDATA            = 0x0238,/* Huffman data overrun */
           MAD_ERROR_BADSTEREO      = 0x0239/* incompatible block_type for JS */
 };
 
         # define MAD_RECOVERABLE(error)((error) & 0xff00)
 
 struct mad_stream {
           unsigned char const *buffer;  /* input bitstream buffer */
           unsigned char const *bufend;  /* end of buffer */
           unsigned long skiplen;        /* bytes to skip before next frame */
 
           int sync;                     /* stream sync found */
           unsigned long freerate;       /* free bitrate (fixed) */
 
           unsigned char const *this_frame;/* start of current frame */
           unsigned char const *next_frame;/* start of next frame */
           struct mad_bitptr ptr;        /* current processing bit pointer */
 
           struct mad_bitptr anc_ptr;    /* ancillary bits pointer */
           unsigned int anc_bitlen;      /* number of ancillary bits */
 
   unsigned char (*main_data)[MAD_BUFFER_MDLEN];
                                         /* Layer III main_data() */
           unsigned int md_len;          /* bytes in main_data */
 
           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 */
 # 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 */
 # endif
 };
 
 void mad_stream_init(struct mad_stream *);
 void mad_stream_finish(struct mad_stream *);
 
 # 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
diff --git a/core/multimedia/opieplayer/libmad/synth.c b/core/multimedia/opieplayer/libmad/synth.c
index cf3c1d5..881f85a 100644
--- a/core/multimedia/opieplayer/libmad/synth.c
+++ b/core/multimedia/opieplayer/libmad/synth.c
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include "fixed.h"
 # include "frame.h"
 # include "synth.h"
 
 /*
          * NAME:synth->init()
          * DESCRIPTION:initialize synth struct
  */
 void mad_synth_init(struct mad_synth *synth)
 {
   mad_synth_mute(synth);
 
   synth->phase = 0;
 
   synth->pcm.samplerate = 0;
   synth->pcm.channels   = 0;
   synth->pcm.length     = 0;
 }
 
 /*
          * NAME:synth->mute()
          * DESCRIPTION:zero all polyphase filterbank values, resetting synthesis
  */
 void mad_synth_mute(struct mad_synth *synth)
 {
   unsigned int ch, s, v;
 
   for (ch = 0; ch < 2; ++ch) {
     for (s = 0; s < 16; ++s) {
       for (v = 0; v < 8; ++v) {
         synth->filter[ch][0][0][s][v] = synth->filter[ch][0][1][s][v] =
         synth->filter[ch][1][0][s][v] = synth->filter[ch][1][1][s][v] = 0;
       }
     }
   }
 }
 
 /*
  * An optional optimization called here the Subband Synthesis Optimization
  * (SSO) improves the performance of subband synthesis at the expense of
  * accuracy.
  *
  * The idea is to simplify 32x32->64-bit multiplication to 32x32->32 such
  * that extra scaling and rounding are not necessary. This often allows the
  * compiler to use faster 32-bit multiply-accumulate instructions instead of
  * explicit 64-bit multiply, shift, and add instructions.
  *
  * SSO works like this: a full 32x32->64-bit multiply of two mad_fixed_t
  * values requires the result to be right-shifted 28 bits to be properly
  * scaled to the same fixed-point format. Right shifts can be applied at any
  * time to either operand or to the result, so the optimization involves
  * careful placement of these shifts to minimize the loss of accuracy.
  *
  * First, a 14-bit shift is applied with rounding at compile-time to the D[]
  * table of coefficients for the subband synthesis window. This only loses 2
  * bits of accuracy because the lower 12 bits are always zero. A second
  * 12-bit shift occurs after the DCT calculation. This loses 12 bits of
  * accuracy. Finally, a third 2-bit shift occurs just before the sample is
  * saved in the PCM buffer. 14 + 12 + 2 == 28 bits.
  */
 
 /* FPM_DEFAULT without OPT_SSO will actually lose accuracy and performance */
 
 # if defined(FPM_DEFAULT) && !defined(OPT_SSO)
 #  define OPT_SSO
 # endif
 
 /* second SSO shift, with rounding */
 
 # if defined(OPT_SSO)
 #  define SHIFT(x)  (((x) + (1L << 11)) >> 12)
 # else
diff --git a/core/multimedia/opieplayer/libmad/synth.h b/core/multimedia/opieplayer/libmad/synth.h
index 2c9d5c8..d284d01 100644
--- a/core/multimedia/opieplayer/libmad/synth.h
+++ b/core/multimedia/opieplayer/libmad/synth.h
@@ -1,69 +1,69 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_SYNTH_H
 # define LIBMAD_SYNTH_H
 
 # include "fixed.h"
 # include "frame.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 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
diff --git a/core/multimedia/opieplayer/libmad/timer.c b/core/multimedia/opieplayer/libmad/timer.c
index 299fe0b..fa377d0 100644
--- a/core/multimedia/opieplayer/libmad/timer.c
+++ b/core/multimedia/opieplayer/libmad/timer.c
@@ -1,177 +1,177 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include <stdio.h>
 
 # ifdef HAVE_ASSERT_H
 #  include <assert.h>
 # endif
 
 # include "timer.h"
 
 mad_timer_t const mad_timer_zero = { 0, 0 };
 
 /*
          * NAME:timer->compare()
          * DESCRIPTION:indicate relative order of two timers
  */
 int mad_timer_compare(mad_timer_t timer1, mad_timer_t timer2)
 {
   signed long diff;
 
   diff = timer1.seconds - timer2.seconds;
   if (diff < 0)
     return -1;
   else if (diff > 0)
     return +1;
 
   diff = timer1.fraction - timer2.fraction;
   if (diff < 0)
     return -1;
   else if (diff > 0)
     return +1;
 
   return 0;
 }
 
 /*
          * NAME:timer->negate()
          * DESCRIPTION:invert the sign of a timer
  */
 void mad_timer_negate(mad_timer_t *timer)
 {
   timer->seconds = -timer->seconds;
 
   if (timer->fraction) {
     timer->seconds -= 1;
     timer->fraction = MAD_TIMER_RESOLUTION - timer->fraction;
   }
 }
 
 /*
          * NAME:timer->abs()
          * DESCRIPTION:return the absolute value of a timer
  */
 mad_timer_t mad_timer_abs(mad_timer_t timer)
 {
-  if (mad_timer_sign(timer) < 0)
+  if (timer.seconds < 0)
     mad_timer_negate(&timer);
 
   return timer;
 }
 
 /*
          * NAME:reduce_timer()
          * DESCRIPTION:carry timer fraction into seconds
  */
 static
 void reduce_timer(mad_timer_t *timer)
 {
   timer->seconds  += timer->fraction / MAD_TIMER_RESOLUTION;
   timer->fraction %= MAD_TIMER_RESOLUTION;
 }
 
 /*
          * NAME:gcd()
          * DESCRIPTION:compute greatest common denominator
  */
 static
 unsigned long gcd(unsigned long num1, unsigned long num2)
 {
   unsigned long tmp;
 
   while (num2) {
     tmp  = num2;
     num2 = num1 % num2;
     num1 = tmp;
   }
 
   return num1;
 }
 
 /*
          * NAME:reduce_rational()
          * DESCRIPTION:convert rational expression to lowest terms
  */
 static
 void reduce_rational(unsigned long *numer, unsigned long *denom)
 {
   unsigned long factor;
 
   factor = gcd(*numer, *denom);
 
   assert(factor != 0);
 
   *numer /= factor;
   *denom /= factor;
 }
 
 /*
          * NAME:scale_rational()
          * DESCRIPTION:solve numer/denom == ?/scale avoiding overflowing
  */
 static
 unsigned long scale_rational(unsigned long numer, unsigned long denom,
                              unsigned long scale)
 {
   reduce_rational(&numer, &denom);
   reduce_rational(&scale, &denom);
 
   assert(denom != 0);
 
   if (denom < scale)
     return numer * (scale / denom) + numer * (scale % denom) / denom;
   if (denom < numer)
     return scale * (numer / denom) + scale * (numer % denom) / denom;
 
   return numer * scale / denom;
 }
 
 /*
          * NAME:timer->set()
          * DESCRIPTION:set timer to specific (positive) value
  */
 void mad_timer_set(mad_timer_t *timer, unsigned long seconds,
                    unsigned long numer, unsigned long denom)
 {
   timer->seconds = seconds;
   if (numer >= denom && denom > 0) {
     timer->seconds += numer / denom;
     numer %= denom;
   }
 
   switch (denom) {
   case 0:
   case 1:
     timer->fraction = 0;
     break;
 
   case MAD_TIMER_RESOLUTION:
     timer->fraction = numer;
     break;
 
   case 1000:
@@ -234,193 +234,194 @@ void mad_timer_add(mad_timer_t *timer, mad_timer_t incr)
 
   if (timer->fraction >= MAD_TIMER_RESOLUTION)
     reduce_timer(timer);
 }
 
 /*
          * NAME:timer->multiply()
          * DESCRIPTION:multiply a timer by a scalar value
  */
 void mad_timer_multiply(mad_timer_t *timer, signed long scalar)
 {
   mad_timer_t addend;
   unsigned long factor;
 
   factor = scalar;
   if (scalar < 0) {
     factor = -scalar;
     mad_timer_negate(timer);
   }
 
   addend = *timer;
   *timer = mad_timer_zero;
 
   while (factor) {
     if (factor & 1)
       mad_timer_add(timer, addend);
 
     mad_timer_add(&addend, addend);
     factor >>= 1;
   }
 }
 
 /*
          * NAME:timer->count()
          * DESCRIPTION:return timer value in selected units
  */
 signed long mad_timer_count(mad_timer_t timer, enum mad_units units)
 {
   switch (units) {
   case MAD_UNITS_HOURS:
     return timer.seconds / 60 / 60;
 
   case MAD_UNITS_MINUTES:
     return timer.seconds / 60;
 
   case MAD_UNITS_SECONDS:
     return timer.seconds;
 
   case MAD_UNITS_DECISECONDS:
   case MAD_UNITS_CENTISECONDS:
   case MAD_UNITS_MILLISECONDS:
 
   case MAD_UNITS_8000_HZ:
   case MAD_UNITS_11025_HZ:
   case MAD_UNITS_12000_HZ:
   case MAD_UNITS_16000_HZ:
   case MAD_UNITS_22050_HZ:
   case MAD_UNITS_24000_HZ:
   case MAD_UNITS_32000_HZ:
   case MAD_UNITS_44100_HZ:
   case MAD_UNITS_48000_HZ:
 
   case MAD_UNITS_24_FPS:
   case MAD_UNITS_25_FPS:
   case MAD_UNITS_30_FPS:
   case MAD_UNITS_48_FPS:
   case MAD_UNITS_50_FPS:
   case MAD_UNITS_60_FPS:
   case MAD_UNITS_75_FPS:
     return timer.seconds * (signed long) units +
       (signed long) scale_rational(timer.fraction, MAD_TIMER_RESOLUTION,
                                    units);
 
   case MAD_UNITS_23_976_FPS:
   case MAD_UNITS_24_975_FPS:
   case MAD_UNITS_29_97_FPS:
   case MAD_UNITS_47_952_FPS:
   case MAD_UNITS_49_95_FPS:
   case MAD_UNITS_59_94_FPS:
     return (mad_timer_count(timer, -units) + 1) * 1000 / 1001;
   }
 
   /* unsupported units */
   return 0;
 }
 
 /*
          * NAME:timer->fraction()
          * DESCRIPTION:return fractional part of timer in arbitrary terms
  */
 unsigned long mad_timer_fraction(mad_timer_t timer, unsigned long denom)
 {
   timer = mad_timer_abs(timer);
 
   switch (denom) {
   case 0:
-    return MAD_TIMER_RESOLUTION / timer.fraction;
+    return timer.fraction ?
+      MAD_TIMER_RESOLUTION / timer.fraction : MAD_TIMER_RESOLUTION + 1;
 
   case MAD_TIMER_RESOLUTION:
     return timer.fraction;
 
   default:
     return scale_rational(timer.fraction, MAD_TIMER_RESOLUTION, denom);
   }
 }
 
 /*
          * NAME:timer->string()
          * DESCRIPTION:write a string representation of a timer using a template
  */
 void mad_timer_string(mad_timer_t timer,
                       char *dest, char const *format, enum mad_units units,
                       enum mad_units fracunits, unsigned long subparts)
 {
   unsigned long hours, minutes, seconds, sub;
   unsigned int frac;
 
   timer = mad_timer_abs(timer);
 
   seconds = timer.seconds;
   frac = sub = 0;
 
   switch (fracunits) {
   case MAD_UNITS_HOURS:
   case MAD_UNITS_MINUTES:
   case MAD_UNITS_SECONDS:
     break;
 
   case MAD_UNITS_DECISECONDS:
   case MAD_UNITS_CENTISECONDS:
   case MAD_UNITS_MILLISECONDS:
 
   case MAD_UNITS_8000_HZ:
   case MAD_UNITS_11025_HZ:
   case MAD_UNITS_12000_HZ:
   case MAD_UNITS_16000_HZ:
   case MAD_UNITS_22050_HZ:
   case MAD_UNITS_24000_HZ:
   case MAD_UNITS_32000_HZ:
   case MAD_UNITS_44100_HZ:
   case MAD_UNITS_48000_HZ:
 
   case MAD_UNITS_24_FPS:
   case MAD_UNITS_25_FPS:
   case MAD_UNITS_30_FPS:
   case MAD_UNITS_48_FPS:
   case MAD_UNITS_50_FPS:
   case MAD_UNITS_60_FPS:
   case MAD_UNITS_75_FPS:
     {
       unsigned long denom;
 
       denom = MAD_TIMER_RESOLUTION / fracunits;
 
       frac = timer.fraction / denom;
       sub  = scale_rational(timer.fraction % denom, denom, subparts);
     }
     break;
 
   case MAD_UNITS_23_976_FPS:
   case MAD_UNITS_24_975_FPS:
   case MAD_UNITS_29_97_FPS:
   case MAD_UNITS_47_952_FPS:
   case MAD_UNITS_49_95_FPS:
   case MAD_UNITS_59_94_FPS:
     /* drop-frame encoding */
     /* N.B. this is only well-defined for MAD_UNITS_29_97_FPS */
     {
       unsigned long frame, cycle, d, m;
 
       frame = mad_timer_count(timer, fracunits);
 
       cycle = -fracunits * 60 * 10 - (10 - 1) * 2;
 
       d = frame / cycle;
       m = frame % cycle;
       frame += (10 - 1) * 2 * d;
       if (m > 2)
         frame += 2 * ((m - 2) / (cycle / 10));
 
       frac    = frame % -fracunits;
       seconds = frame / -fracunits;
     }
     break;
   }
 
   switch (units) {
   case MAD_UNITS_HOURS:
     minutes = seconds / 60;
     hours   = minutes / 60;
 
     sprintf(dest, format,
             hours,
diff --git a/core/multimedia/opieplayer/libmad/timer.h b/core/multimedia/opieplayer/libmad/timer.h
index f8afb8e..4f2be57 100644
--- a/core/multimedia/opieplayer/libmad/timer.h
+++ b/core/multimedia/opieplayer/libmad/timer.h
@@ -1,99 +1,99 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifndef LIBMAD_TIMER_H
 # define LIBMAD_TIMER_H
 
 typedef struct {
           signed long seconds;  /* whole seconds */
           unsigned long fraction;/* 1/MAD_TIMER_RESOLUTION seconds */
 } mad_timer_t;
 
 extern mad_timer_t const mad_timer_zero;
 
         # define MAD_TIMER_RESOLUTION352800000UL
 
 enum mad_units {
           MAD_UNITS_HOURS =    -2,
           MAD_UNITS_MINUTES =    -1,
           MAD_UNITS_SECONDS =     0,
 
   /* metric units */
 
           MAD_UNITS_DECISECONDS =    10,
   MAD_UNITS_CENTISECONDS =   100,
   MAD_UNITS_MILLISECONDS =  1000,
 
   /* audio sample units */
 
           MAD_UNITS_8000_HZ =  8000,
           MAD_UNITS_11025_HZ = 11025,
           MAD_UNITS_12000_HZ = 12000,
 
           MAD_UNITS_16000_HZ = 16000,
           MAD_UNITS_22050_HZ = 22050,
           MAD_UNITS_24000_HZ = 24000,
 
           MAD_UNITS_32000_HZ = 32000,
           MAD_UNITS_44100_HZ = 44100,
           MAD_UNITS_48000_HZ = 48000,
 
   /* video frame/field units */
 
           MAD_UNITS_24_FPS =    24,
           MAD_UNITS_25_FPS =    25,
           MAD_UNITS_30_FPS =    30,
           MAD_UNITS_48_FPS =    48,
           MAD_UNITS_50_FPS =    50,
           MAD_UNITS_60_FPS =    60,
 
   /* CD audio frames */
 
           MAD_UNITS_75_FPS =    75,
 
   /* video drop-frame units */
 
           MAD_UNITS_23_976_FPS =   -24,
           MAD_UNITS_24_975_FPS =   -25,
           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)((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 *);
 mad_timer_t mad_timer_abs(mad_timer_t);
 
 void mad_timer_set(mad_timer_t *, unsigned long, unsigned long, unsigned long);
 void mad_timer_add(mad_timer_t *, mad_timer_t);
 void mad_timer_multiply(mad_timer_t *, signed long);
 
 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);
 
diff --git a/core/multimedia/opieplayer/libmad/version.c b/core/multimedia/opieplayer/libmad/version.c
index fb126f4..4fbef23 100644
--- a/core/multimedia/opieplayer/libmad/version.c
+++ b/core/multimedia/opieplayer/libmad/version.c
@@ -1,91 +1,91 @@
 /*
  * libmad - MPEG audio decoder library
- * Copyright (C) 2000-2001 Robert Leslie
+ * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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
  *
  * $Id$
  */
 
 # ifdef HAVE_CONFIG_H
 #  include "libmad_config.h"
 # endif
 
 # include "libmad_global.h"
 
 # include "libmad_version.h"
 
 char const mad_version[]   = "MPEG Audio Decoder " MAD_VERSION;
 char const mad_copyright[] = "Copyright (C) " MAD_PUBLISHYEAR " " MAD_AUTHOR;
 char const mad_author[]    = MAD_AUTHOR " <" MAD_EMAIL ">";
 
 char const mad_build[] = ""
+# if defined(DEBUG)
+  "DEBUG "
+# elif defined(NDEBUG)
+  "NDEBUG "
+# endif
+
+# if defined(EXPERIMENTAL)
+  "EXPERIMENTAL "
+# endif
+
 # if defined(FPM_64BIT)
   "FPM_64BIT "
 # elif defined(FPM_INTEL)
   "FPM_INTEL "
 # elif defined(FPM_ARM)
   "FPM_ARM "
 # elif defined(FPM_MIPS)
   "FPM_MIPS "
 # elif defined(FPM_SPARC)
   "FPM_SPARC "
 # elif defined(FPM_PPC)
   "FPM_PPC "
 # elif defined(FPM_DEFAULT)
   "FPM_DEFAULT "
 # endif
 
 # if defined(ASO_IMDCT)
   "ASO_IMDCT "
 # endif
 # if defined(ASO_INTERLEAVE1)
   "ASO_INTERLEAVE1 "
 # endif
 # if defined(ASO_INTERLEAVE2)
   "ASO_INTERLEAVE2 "
 # endif
 # if defined(ASO_ZEROCHECK)
   "ASO_ZEROCHECK "
 # endif
 
 # if defined(OPT_SPEED)
   "OPT_SPEED "
 # elif defined(OPT_ACCURACY)
   "OPT_ACCURACY "
 # endif
 
 # if defined(OPT_SSO)
   "OPT_SSO "
 # endif
 
 # if defined(OPT_DCTO)  /* never defined here */
   "OPT_DCTO "
 # endif
 
 # if defined(OPT_STRICT)
   "OPT_STRICT "
 # endif
-
-# if defined(EXPERIMENTAL)
-  "EXPERIMENTAL "
-# endif
-
-# if defined(DEBUG)
-  "DEBUG "
-# elif defined(NDEBUG)
-  "NDEBUG "
-# endif
 ;