src/lib/doslib/ext/faad/bits.c

   1 /*
   2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
   3 ** Copyright (C) 2003-2005 M. Bakker, Nero AG, http://www.nero.com
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU General Public License as published by
   7 ** the Free Software Foundation; either version 2 of the License, or
   8 ** (at your option) any later version.
   9 **
  10 ** This program is distributed in the hope that it will be useful,
  11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ** GNU General Public License for more details.
  14 **
  15 ** You should have received a copy of the GNU General Public License
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 **
  19 ** Any non-GPL usage of this software or parts of this software is strictly
  20 ** forbidden.
  21 **
  22 ** The "appropriate copyright message" mentioned in section 2c of the GPLv2
  23 ** must read: "Code from FAAD2 is copyright (c) Nero AG, www.nero.com"
  24 **
  25 ** Commercial non-GPL licensing of this software is possible.
  26 ** For more info contact Nero AG through Mpeg4AAClicense@nero.com.
  27 **
  28 ** $Id: bits.c,v 1.44 2007/11/01 12:33:29 menno Exp $
  29 **/
  30
  31 #include "common.h"
  32 #include "structs.h"
  33
  34 #include <stdlib.h>
  35 #include "bits.h"
  36
  37 /* initialize buffer, call once before first getbits or showbits */
  38 void faad_initbits(bitfile *ld, const void *_buffer, const uint32_t buffer_size)
  39 {
  40     uint32_t tmp;
  41
  42     if (ld == NULL)
  43         return;
  44
  45     // useless
  46     //memset(ld, 0, sizeof(bitfile));
  47
  48     if (buffer_size == 0 || _buffer == NULL)
  49     {
  50         ld->error = 1;
  51         return;
  52     }
  53
  54     ld->buffer = _buffer;
  55
  56     ld->buffer_size = buffer_size;
  57     ld->bytes_left  = buffer_size;
  58
  59     if (ld->bytes_left >= 4)
  60     {
  61         tmp = getdword((uint32_t*)ld->buffer);
  62         ld->bytes_left -= 4;
  63     } else {
  64         tmp = getdword_n((uint32_t*)ld->buffer, ld->bytes_left);
  65         ld->bytes_left = 0;
  66     }
  67     ld->bufa = tmp;
  68
  69     if (ld->bytes_left >= 4)
  70     {
  71         tmp = getdword((uint32_t*)ld->buffer + 1);
  72         ld->bytes_left -= 4;
  73     } else {
  74         tmp = getdword_n((uint32_t*)ld->buffer + 1, ld->bytes_left);
  75         ld->bytes_left = 0;
  76     }
  77     ld->bufb = tmp;
  78
  79     ld->start = (uint32_t*)ld->buffer;
  80     ld->tail = ((uint32_t*)ld->buffer + 2);
  81
  82     ld->bits_left = 32;
  83
  84     ld->error = 0;
  85 }
  86
  87 void faad_endbits(bitfile *ld)
  88 {
  89     // void
  90 }
  91
  92 uint32_t faad_get_processed_bits(bitfile *ld)
  93 {
  94     return (uint32_t)(8 * (4*(ld->tail - ld->start) - 4) - (ld->bits_left));
  95 }
  96
  97 uint8_t faad_byte_align(bitfile *ld)
  98 {
  99     int remainder = (32 - ld->bits_left) & 0x7;
 100
 101     if (remainder)
 102     {
 103         faad_flushbits(ld, 8 - remainder);
 104         return (uint8_t)(8 - remainder);
 105     }
 106     return 0;
 107 }
 108
 109 void faad_flushbits_ex(bitfile *ld, uint32_t bits)
 110 {
 111     uint32_t tmp;
 112
 113     ld->bufa = ld->bufb;
 114     if (ld->bytes_left >= 4)
 115     {
 116         tmp = getdword(ld->tail);
 117         ld->bytes_left -= 4;
 118     } else {
 119         tmp = getdword_n(ld->tail, ld->bytes_left);
 120         ld->bytes_left = 0;
 121     }
 122     ld->bufb = tmp;
 123     ld->tail++;
 124     ld->bits_left += (32 - bits);
 125     //ld->bytes_left -= 4;
 126 //    if (ld->bytes_left == 0)
 127 //        ld->no_more_reading = 1;
 128 //    if (ld->bytes_left < 0)
 129 //        ld->error = 1;
 130 }
 131
 132 /* rewind to beginning */
 133 void faad_rewindbits(bitfile *ld)
 134 {
 135     uint32_t tmp;
 136
 137     ld->bytes_left = ld->buffer_size;
 138
 139     if (ld->bytes_left >= 4)
 140     {
 141         tmp = getdword((uint32_t*)&ld->start[0]);
 142         ld->bytes_left -= 4;
 143     } else {
 144         tmp = getdword_n((uint32_t*)&ld->start[0], ld->bytes_left);
 145         ld->bytes_left = 0;
 146     }
 147     ld->bufa = tmp;
 148
 149     if (ld->bytes_left >= 4)
 150     {
 151         tmp = getdword((uint32_t*)&ld->start[1]);
 152         ld->bytes_left -= 4;
 153     } else {
 154         tmp = getdword_n((uint32_t*)&ld->start[1], ld->bytes_left);
 155         ld->bytes_left = 0;
 156     }
 157     ld->bufb = tmp;
 158
 159     ld->bits_left = 32;
 160     ld->tail = &ld->start[2];
 161 }
 162
 163 /* reset to a certain point */
 164 void faad_resetbits(bitfile *ld, int bits)
 165 {
 166     uint32_t tmp;
 167     int words = bits >> 5;
 168     int remainder = bits & 0x1F;
 169
 170     ld->bytes_left = ld->buffer_size - words*4;
 171
 172     if (ld->bytes_left >= 4)
 173     {
 174         tmp = getdword(&ld->start[words]);
 175         ld->bytes_left -= 4;
 176     } else {
 177         tmp = getdword_n(&ld->start[words], ld->bytes_left);
 178         ld->bytes_left = 0;
 179     }
 180     ld->bufa = tmp;
 181
 182     if (ld->bytes_left >= 4)
 183     {
 184         tmp = getdword(&ld->start[words+1]);
 185         ld->bytes_left -= 4;
 186     } else {
 187         tmp = getdword_n(&ld->start[words+1], ld->bytes_left);
 188         ld->bytes_left = 0;
 189     }
 190     ld->bufb = tmp;
 191
 192     ld->bits_left = 32 - remainder;
 193     ld->tail = &ld->start[words+2];
 194
 195     /* recheck for reading too many bytes */
 196     ld->error = 0;
 197 //    if (ld->bytes_left == 0)
 198 //        ld->no_more_reading = 1;
 199 //    if (ld->bytes_left < 0)
 200 //        ld->error = 1;
 201 }
 202
 203 uint8_t *faad_getbitbuffer(bitfile *ld, uint32_t bits
 204                        DEBUGDEC)
 205 {
 206     int i;
 207     unsigned int temp;
 208     int bytes = bits >> 3;
 209     int remainder = bits & 0x7;
 210
 211     uint8_t *buffer = (uint8_t*)faad_malloc((bytes+1)*sizeof(uint8_t));
 212
 213     for (i = 0; i < bytes; i++)
 214     {
 215         buffer[i] = (uint8_t)faad_getbits(ld, 8 DEBUGVAR(print,var,dbg));
 216     }
 217
 218     if (remainder)
 219     {
 220         temp = faad_getbits(ld, remainder DEBUGVAR(print,var,dbg)) << (8-remainder);
 221
 222         buffer[bytes] = (uint8_t)temp;
 223     }
 224
 225     return buffer;
 226 }
 227
 228 #ifdef DRM
 229 /* return the original data buffer */
 230 void *faad_origbitbuffer(bitfile *ld)
 231 {
 232     return (void*)ld->start;
 233 }
 234
 235 /* return the original data buffer size */
 236 uint32_t faad_origbitbuffer_size(bitfile *ld)
 237 {
 238     return ld->buffer_size;
 239 }
 240 #endif
 241
 242 /* reversed bit reading routines, used for RVLC and HCR */
 243 void faad_initbits_rev(bitfile *ld, void *buffer,
 244                        uint32_t bits_in_buffer)
 245 {
 246     uint32_t tmp;
 247     int32_t index;
 248
 249     ld->buffer_size = bit2byte(bits_in_buffer);
 250
 251     index = (bits_in_buffer+31)/32 - 1;
 252
 253     ld->start = (uint32_t*)buffer + index - 2;
 254
 255     tmp = getdword((uint32_t*)buffer + index);
 256     ld->bufa = tmp;
 257
 258     tmp = getdword((uint32_t*)buffer + index - 1);
 259     ld->bufb = tmp;
 260
 261     ld->tail = (uint32_t*)buffer + index;
 262
 263     ld->bits_left = bits_in_buffer % 32;
 264     if (ld->bits_left == 0)
 265         ld->bits_left = 32;
 266
 267     ld->bytes_left = ld->buffer_size;
 268     ld->error = 0;
 269 }
 270
 271 /* EOF */