diff src/aac/libfaad2/bits.c @ 3004:8867d3491f60

Sync with FAAD 2.7; will fix warnings in separate commits.

--- a/src/aac/libfaad2/bits.c	Sat Feb 28 02:34:13 2009 +0000
+++ b/src/aac/libfaad2/bits.c	Wed Apr 08 20:12:57 2009 +0100
@@ -1,6 +1,6 @@
 /*
 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
-** Copyright (C) 2003-2004 M. Bakker, Ahead Software AG, http://www.nero.com
+** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
 **  
 ** 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
@@ -13,23 +13,25 @@
 ** 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+** along with this program; if not, write to the Free Software 
+** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 **
 ** Any non-GPL usage of this software or parts of this software is strictly
 ** forbidden.
 **
+** The "appropriate copyright message" mentioned in section 2c of the GPLv2
+** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
+**
 ** Commercial non-GPL licensing of this software is possible.
-** For more info contact Ahead Software through [e-mail].
+** For more info contact Nero AG through [e-mail].
 **
-** $Id: bits.c,v 1.39 2004/09/04 14:56:27 menno Exp $
+** $Id: bits.c,v 1.44 2007/11/01 12:33:29 menno Exp $
 **/
 
 #include "common.h"
 #include "structs.h"
 
 #include <stdlib.h>
-#include <string.h>
 #include "bits.h"
 
 /* initialize buffer, call once before first getbits or showbits */
@@ -40,25 +42,38 @@
     if (ld == NULL)
         return;
 
-    memset(ld, 0, sizeof(bitfile));
+    // useless
+    //memset(ld, 0, sizeof(bitfile));
 
     if (buffer_size == 0 || _buffer == NULL)
     {
         ld->error = 1;
-        ld->no_more_reading = 1;
         return;
     }
 
-    ld->buffer = faad_malloc((buffer_size+12)*sizeof(uint8_t));
-    memset(ld->buffer, 0, (buffer_size+12)*sizeof(uint8_t));
-    memcpy(ld->buffer, _buffer, buffer_size*sizeof(uint8_t));
+    ld->buffer = _buffer;
 
     ld->buffer_size = buffer_size;
+    ld->bytes_left  = buffer_size;
 
-    tmp = getdword((uint32_t*)ld->buffer);
+    if (ld->bytes_left >= 4)
+    {
+        tmp = getdword((uint32_t*)ld->buffer);
+        ld->bytes_left -= 4;
+    } else {
+        tmp = getdword_n((uint32_t*)ld->buffer, ld->bytes_left);
+        ld->bytes_left = 0;
+    }
     ld->bufa = tmp;
 
-    tmp = getdword((uint32_t*)ld->buffer + 1);
+    if (ld->bytes_left >= 4)
+    {
+        tmp = getdword((uint32_t*)ld->buffer + 1);
+        ld->bytes_left -= 4;
+    } else {
+        tmp = getdword_n((uint32_t*)ld->buffer + 1, ld->bytes_left);
+        ld->bytes_left = 0;
+    }
     ld->bufb = tmp;
 
     ld->start = (uint32_t*)ld->buffer;
@@ -66,21 +81,12 @@
 
     ld->bits_left = 32;
 
-    ld->bytes_used = 0;
-    ld->no_more_reading = 0;
     ld->error = 0;
 }
 
 void faad_endbits(bitfile *ld)
 {
-    if (ld)
-    {
-        if (ld->buffer)
-        {
-            faad_free(ld->buffer);
-            ld->buffer = NULL;
-        }
-    }
+    // void
 }
 
 uint32_t faad_get_processed_bits(bitfile *ld)
@@ -90,12 +96,12 @@
 
 uint8_t faad_byte_align(bitfile *ld)
 {
-    uint8_t remainder = (uint8_t)((32 - ld->bits_left) % 8);
+    int remainder = (32 - ld->bits_left) & 0x7;
 
     if (remainder)
     {
         faad_flushbits(ld, 8 - remainder);
-        return (8 - remainder);
+        return (uint8_t)(8 - remainder);
     }
     return 0;
 }
@@ -105,20 +111,22 @@
     uint32_t tmp;
 
     ld->bufa = ld->bufb;
-    if (ld->no_more_reading == 0)
+    if (ld->bytes_left >= 4)
     {
         tmp = getdword(ld->tail);
-        ld->tail++;
+        ld->bytes_left -= 4;
     } else {
-        tmp = 0;
+        tmp = getdword_n(ld->tail, ld->bytes_left);
+        ld->bytes_left = 0;
     }
     ld->bufb = tmp;
+    ld->tail++;
     ld->bits_left += (32 - bits);
-    ld->bytes_used += 4;
-    if (ld->bytes_used == ld->buffer_size)
-        ld->no_more_reading = 1;
-    if (ld->bytes_used > ld->buffer_size)
-        ld->error = 1;
+    //ld->bytes_left -= 4;
+//    if (ld->bytes_left == 0)
+//        ld->no_more_reading = 1;
+//    if (ld->bytes_left < 0)
+//        ld->error = 1;
 }
 
 /* rewind to beginning */
@@ -126,30 +134,79 @@
 {
     uint32_t tmp;
 
-    tmp = ld->start[0];
-#ifndef ARCH_IS_BIG_ENDIAN
-    BSWAP(tmp);
-#endif
+    ld->bytes_left = ld->buffer_size;
+
+    if (ld->bytes_left >= 4)
+    {
+        tmp = getdword((uint32_t*)&ld->start[0]);
+        ld->bytes_left -= 4;
+    } else {
+        tmp = getdword_n((uint32_t*)&ld->start[0], ld->bytes_left);
+        ld->bytes_left = 0;
+    }
     ld->bufa = tmp;
 
-    tmp = ld->start[1];
-#ifndef ARCH_IS_BIG_ENDIAN
-    BSWAP(tmp);
-#endif
+    if (ld->bytes_left >= 4)
+    {
+        tmp = getdword((uint32_t*)&ld->start[1]);
+        ld->bytes_left -= 4;
+    } else {
+        tmp = getdword_n((uint32_t*)&ld->start[1], ld->bytes_left);
+        ld->bytes_left = 0;
+    }
     ld->bufb = tmp;
+
     ld->bits_left = 32;
     ld->tail = &ld->start[2];
-    ld->bytes_used = 0;
-    ld->no_more_reading = 0;
+}
+
+/* reset to a certain point */
+void faad_resetbits(bitfile *ld, int bits)
+{
+    uint32_t tmp;
+    int words = bits >> 5;
+    int remainder = bits & 0x1F;
+
+    ld->bytes_left = ld->buffer_size - words*4;
+
+    if (ld->bytes_left >= 4)
+    {
+        tmp = getdword(&ld->start[words]);
+        ld->bytes_left -= 4;
+    } else {
+        tmp = getdword_n(&ld->start[words], ld->bytes_left);
+        ld->bytes_left = 0;
+    }
+    ld->bufa = tmp;
+
+    if (ld->bytes_left >= 4)
+    {
+        tmp = getdword(&ld->start[words+1]);
+        ld->bytes_left -= 4;
+    } else {
+        tmp = getdword_n(&ld->start[words+1], ld->bytes_left);
+        ld->bytes_left = 0;
+    }
+    ld->bufb = tmp;
+
+    ld->bits_left = 32 - remainder;
+    ld->tail = &ld->start[words+2];
+
+    /* recheck for reading too many bytes */
+    ld->error = 0;
+//    if (ld->bytes_left == 0)
+//        ld->no_more_reading = 1;
+//    if (ld->bytes_left < 0)
+//        ld->error = 1;
 }
 
 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
                        DEBUGDEC)
 {
-    uint16_t i;
-    uint8_t temp;
-    uint16_t bytes = (uint16_t)bits / 8;
-    uint8_t remainder = (uint8_t)bits % 8;
+    int i;
+    unsigned int temp;
+    int bytes = bits >> 3;
+    int remainder = bits & 0x7;
 
     uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t));
 
@@ -160,9 +217,9 @@
 
     if (remainder)
     {
-        temp = (uint8_t)faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder);
+        temp = faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder);
 
-        buffer[bytes] = temp;
+        buffer[bytes] = (uint8_t)temp;
     }
 
     return buffer;
@@ -207,7 +264,8 @@
     if (ld->bits_left == 0)
         ld->bits_left = 32;
 
-    ld->bytes_used = 0;
-    ld->no_more_reading = 0;
+    ld->bytes_left = ld->buffer_size;
     ld->error = 0;
 }
+
+/* EOF */