Andreas Grün
MP3 Player without external hardware MP3 Player without external hardware. A software based MP3 player based on a modified version of libmad. Mono output (at the moment) via AnalogOut. Files are read from an USB drive. This is a demo program, it plays only one file at the moment. Documentation is in "main.cpp" and "config.h"
Embed:
(wiki syntax)
Show/hide line numbers
layer3.cpp
00001 /* 00002 * libmad - MPEG audio decoder library 00003 * Copyright (C) 2000-2004 Underbit Technologies, Inc. 00004 * 00005 * This program is free software; you can redistribute it and/or modify 00006 * it under the terms of the GNU General Public License as published by 00007 * the Free Software Foundation; either version 2 of the License, or 00008 * (at your option) any later version. 00009 * 00010 * This program is distributed in the hope that it will be useful, 00011 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00012 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00013 * GNU General Public License for more details. 00014 * 00015 * You should have received a copy of the GNU General Public License 00016 * along with this program; if not, write to the Free Software 00017 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 00018 * 00019 * $Id: layer3.c,v 1.1 2010/11/23 20:12:57 andy Exp $ 00020 */ 00021 00022 # include "config.h" 00023 00024 # include "global.h" 00025 00026 # include <stdlib.h> 00027 # include <string.h> 00028 00029 # ifdef HAVE_LIMITS_H 00030 # include <limits.h> 00031 # else 00032 # define CHAR_BIT 8 00033 # endif 00034 00035 # include "fixed.h" 00036 # include "bit.h" 00037 # include "stream.h" 00038 # include "frame.h" 00039 # include "huffman.h" 00040 # include "layer3.h" 00041 00042 /* --- Layer III ----------------------------------------------------------- */ 00043 00044 enum { 00045 count1table_select = 0x01, 00046 scalefac_scale = 0x02, 00047 preflag = 0x04, 00048 mixed_block_flag = 0x08 00049 }; 00050 00051 enum { 00052 I_STEREO = 0x1, 00053 MS_STEREO = 0x2 00054 }; 00055 00056 00057 struct channel { 00058 /* from side info */ 00059 unsigned short part2_3_length; 00060 unsigned short big_values; 00061 unsigned short global_gain; 00062 unsigned short scalefac_compress; 00063 00064 unsigned char flags; 00065 unsigned char block_type; 00066 unsigned char table_select[3]; 00067 unsigned char subblock_gain[3]; 00068 unsigned char region0_count; 00069 unsigned char region1_count; 00070 00071 /* from main_data */ 00072 unsigned char scalefac[39]; /* scalefac_l and/or scalefac_s */ 00073 }; 00074 struct granule { 00075 struct channel ch[2]; 00076 }; 00077 00078 00079 struct sideinfo { 00080 unsigned int main_data_begin; 00081 unsigned int private_bits; 00082 00083 unsigned char scfsi[2]; 00084 00085 struct granule gr[2]; 00086 }; 00087 00088 /* 00089 * scalefactor bit lengths 00090 * derived from section 2.4.2.7 of ISO/IEC 11172-3 00091 */ 00092 static 00093 struct { 00094 unsigned char slen1; 00095 unsigned char slen2; 00096 } const sflen_table[16] = { 00097 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 }, 00098 { 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }, 00099 { 2, 1 }, { 2, 2 }, { 2, 3 }, { 3, 1 }, 00100 { 3, 2 }, { 3, 3 }, { 4, 2 }, { 4, 3 } 00101 }; 00102 00103 /* 00104 * number of LSF scalefactor band values 00105 * derived from section 2.4.3.2 of ISO/IEC 13818-3 00106 */ 00107 static 00108 unsigned char const nsfb_table[6][3][4] = { 00109 { { 6, 5, 5, 5 }, 00110 { 9, 9, 9, 9 }, 00111 { 6, 9, 9, 9 } }, 00112 00113 { { 6, 5, 7, 3 }, 00114 { 9, 9, 12, 6 }, 00115 { 6, 9, 12, 6 } }, 00116 00117 { { 11, 10, 0, 0 }, 00118 { 18, 18, 0, 0 }, 00119 { 15, 18, 0, 0 } }, 00120 00121 { { 7, 7, 7, 0 }, 00122 { 12, 12, 12, 0 }, 00123 { 6, 15, 12, 0 } }, 00124 00125 { { 6, 6, 6, 3 }, 00126 { 12, 9, 9, 6 }, 00127 { 6, 12, 9, 6 } }, 00128 00129 { { 8, 8, 5, 0 }, 00130 { 15, 12, 9, 0 }, 00131 { 6, 18, 9, 0 } } 00132 }; 00133 00134 /* 00135 * MPEG-1 scalefactor band widths 00136 * derived from Table B.8 of ISO/IEC 11172-3 00137 */ 00138 static 00139 unsigned char const sfb_48000_long[] = { 00140 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 00141 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192 00142 }; 00143 00144 static 00145 unsigned char const sfb_44100_long[] = { 00146 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 00147 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158 00148 }; 00149 00150 static 00151 unsigned char const sfb_32000_long[] = { 00152 4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 00153 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26 00154 }; 00155 00156 static 00157 unsigned char const sfb_48000_short[] = { 00158 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 00159 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14, 00160 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66 00161 }; 00162 00163 static 00164 unsigned char const sfb_44100_short[] = { 00165 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 00166 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 00167 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56 00168 }; 00169 00170 static 00171 unsigned char const sfb_32000_short[] = { 00172 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 00173 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 00174 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12 00175 }; 00176 00177 static 00178 unsigned char const sfb_48000_mixed[] = { 00179 /* long */ 4, 4, 4, 4, 4, 4, 6, 6, 00180 /* short */ 4, 4, 4, 6, 6, 6, 6, 6, 6, 10, 00181 10, 10, 12, 12, 12, 14, 14, 14, 16, 16, 00182 16, 20, 20, 20, 26, 26, 26, 66, 66, 66 00183 }; 00184 00185 static 00186 unsigned char const sfb_44100_mixed[] = { 00187 /* long */ 4, 4, 4, 4, 4, 4, 6, 6, 00188 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 00189 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 00190 18, 22, 22, 22, 30, 30, 30, 56, 56, 56 00191 }; 00192 00193 static 00194 unsigned char const sfb_32000_mixed[] = { 00195 /* long */ 4, 4, 4, 4, 4, 4, 6, 6, 00196 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 12, 00197 12, 12, 16, 16, 16, 20, 20, 20, 26, 26, 00198 26, 34, 34, 34, 42, 42, 42, 12, 12, 12 00199 }; 00200 00201 /* 00202 * MPEG-2 scalefactor band widths 00203 * derived from Table B.2 of ISO/IEC 13818-3 00204 */ 00205 static 00206 unsigned char const sfb_24000_long[] = { 00207 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 00208 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36 00209 }; 00210 00211 static 00212 unsigned char const sfb_22050_long[] = { 00213 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 00214 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 00215 }; 00216 00217 # define sfb_16000_long sfb_22050_long 00218 00219 static 00220 unsigned char const sfb_24000_short[] = { 00221 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 00222 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 00223 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12 00224 }; 00225 00226 static 00227 unsigned char const sfb_22050_short[] = { 00228 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6, 00229 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18, 00230 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18 00231 }; 00232 00233 static 00234 unsigned char const sfb_16000_short[] = { 00235 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 00236 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 00237 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18 00238 }; 00239 00240 static 00241 unsigned char const sfb_24000_mixed[] = { 00242 /* long */ 6, 6, 6, 6, 6, 6, 00243 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 00244 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 00245 24, 32, 32, 32, 44, 44, 44, 12, 12, 12 00246 }; 00247 00248 static 00249 unsigned char const sfb_22050_mixed[] = { 00250 /* long */ 6, 6, 6, 6, 6, 6, 00251 /* short */ 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 00252 10, 10, 14, 14, 14, 18, 18, 18, 26, 26, 00253 26, 32, 32, 32, 42, 42, 42, 18, 18, 18 00254 }; 00255 00256 static 00257 unsigned char const sfb_16000_mixed[] = { 00258 /* long */ 6, 6, 6, 6, 6, 6, 00259 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 00260 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 00261 24, 30, 30, 30, 40, 40, 40, 18, 18, 18 00262 }; 00263 00264 /* 00265 * MPEG 2.5 scalefactor band widths 00266 * derived from public sources 00267 */ 00268 # define sfb_12000_long sfb_16000_long 00269 # define sfb_11025_long sfb_12000_long 00270 00271 static 00272 unsigned char const sfb_8000_long[] = { 00273 12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 00274 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2 00275 }; 00276 00277 # define sfb_12000_short sfb_16000_short 00278 # define sfb_11025_short sfb_12000_short 00279 00280 static 00281 unsigned char const sfb_8000_short[] = { 00282 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16, 00283 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 00284 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26 00285 }; 00286 00287 # define sfb_12000_mixed sfb_16000_mixed 00288 # define sfb_11025_mixed sfb_12000_mixed 00289 00290 /* the 8000 Hz short block scalefactor bands do not break after 00291 the first 36 frequency lines, so this is probably wrong */ 00292 static 00293 unsigned char const sfb_8000_mixed[] = { 00294 /* long */ 12, 12, 12, 00295 /* short */ 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16, 00296 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36, 00297 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26 00298 }; 00299 00300 static 00301 struct { 00302 unsigned char const *l; 00303 unsigned char const *s; 00304 unsigned char const *m; 00305 } const sfbwidth_table[9] = { 00306 { sfb_48000_long, sfb_48000_short, sfb_48000_mixed }, 00307 { sfb_44100_long, sfb_44100_short, sfb_44100_mixed }, 00308 { sfb_32000_long, sfb_32000_short, sfb_32000_mixed }, 00309 { sfb_24000_long, sfb_24000_short, sfb_24000_mixed }, 00310 { sfb_22050_long, sfb_22050_short, sfb_22050_mixed }, 00311 { sfb_16000_long, sfb_16000_short, sfb_16000_mixed }, 00312 { sfb_12000_long, sfb_12000_short, sfb_12000_mixed }, 00313 { sfb_11025_long, sfb_11025_short, sfb_11025_mixed }, 00314 { sfb_8000_long, sfb_8000_short, sfb_8000_mixed } 00315 }; 00316 00317 /* 00318 * scalefactor band preemphasis (used only when preflag is set) 00319 * derived from Table B.6 of ISO/IEC 11172-3 00320 */ 00321 static 00322 unsigned char const pretab[22] = { 00323 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 00324 }; 00325 00326 /* 00327 * table for requantization 00328 * 00329 * rq_table[x].mantissa * 2^(rq_table[x].exponent) = x^(4/3) 00330 */ 00331 static 00332 struct fixedfloat { 00333 unsigned long mantissa : 27; 00334 unsigned short exponent : 5; 00335 } const rq_table[8207] = { 00336 # include "rq_table.h" 00337 }; 00338 00339 /* 00340 * fractional powers of two 00341 * used for requantization and joint stereo decoding 00342 * 00343 * root_table[3 + x] = 2^(x/4) 00344 */ 00345 static 00346 mad_fixed_t const root_table[7] = { 00347 MAD_F(0x09837f05) /* 2^(-3/4) == 0.59460355750136 */, 00348 MAD_F(0x0b504f33) /* 2^(-2/4) == 0.70710678118655 */, 00349 MAD_F(0x0d744fcd) /* 2^(-1/4) == 0.84089641525371 */, 00350 MAD_F(0x10000000) /* 2^( 0/4) == 1.00000000000000 */, 00351 MAD_F(0x1306fe0a) /* 2^(+1/4) == 1.18920711500272 */, 00352 MAD_F(0x16a09e66) /* 2^(+2/4) == 1.41421356237310 */, 00353 MAD_F(0x1ae89f99) /* 2^(+3/4) == 1.68179283050743 */ 00354 }; 00355 00356 /* 00357 * coefficients for aliasing reduction 00358 * derived from Table B.9 of ISO/IEC 11172-3 00359 * 00360 * c[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 } 00361 * cs[i] = 1 / sqrt(1 + c[i]^2) 00362 * ca[i] = c[i] / sqrt(1 + c[i]^2) 00363 */ 00364 static 00365 mad_fixed_t const cs[8] = { 00366 +MAD_F(0x0db84a81) /* +0.857492926 */, +MAD_F(0x0e1b9d7f) /* +0.881741997 */, 00367 +MAD_F(0x0f31adcf) /* +0.949628649 */, +MAD_F(0x0fbba815) /* +0.983314592 */, 00368 +MAD_F(0x0feda417) /* +0.995517816 */, +MAD_F(0x0ffc8fc8) /* +0.999160558 */, 00369 +MAD_F(0x0fff964c) /* +0.999899195 */, +MAD_F(0x0ffff8d3) /* +0.999993155 */ 00370 }; 00371 00372 static 00373 mad_fixed_t const ca[8] = { 00374 -MAD_F(0x083b5fe7) /* -0.514495755 */, -MAD_F(0x078c36d2) /* -0.471731969 */, 00375 -MAD_F(0x05039814) /* -0.313377454 */, -MAD_F(0x02e91dd1) /* -0.181913200 */, 00376 -MAD_F(0x0183603a) /* -0.094574193 */, -MAD_F(0x00a7cb87) /* -0.040965583 */, 00377 -MAD_F(0x003a2847) /* -0.014198569 */, -MAD_F(0x000f27b4) /* -0.003699975 */ 00378 }; 00379 00380 /* 00381 * IMDCT coefficients for short blocks 00382 * derived from section 2.4.3.4.10.2 of ISO/IEC 11172-3 00383 * 00384 * imdct_s[i/even][k] = cos((PI / 24) * (2 * (i / 2) + 7) * (2 * k + 1)) 00385 * imdct_s[i /odd][k] = cos((PI / 24) * (2 * (6 + (i-1)/2) + 7) * (2 * k + 1)) 00386 */ 00387 static 00388 mad_fixed_t const imdct_s[6][6] = { 00389 # include "imdct_s.h" 00390 }; 00391 00392 # if !defined(ASO_IMDCT) 00393 /* 00394 * windowing coefficients for long blocks 00395 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3 00396 * 00397 * window_l[i] = sin((PI / 36) * (i + 1/2)) 00398 */ 00399 static 00400 mad_fixed_t const window_l[36] = { 00401 MAD_F(0x00b2aa3e) /* 0.043619387 */, MAD_F(0x0216a2a2) /* 0.130526192 */, 00402 MAD_F(0x03768962) /* 0.216439614 */, MAD_F(0x04cfb0e2) /* 0.300705800 */, 00403 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x07635284) /* 0.461748613 */, 00404 MAD_F(0x0898c779) /* 0.537299608 */, MAD_F(0x09bd7ca0) /* 0.608761429 */, 00405 MAD_F(0x0acf37ad) /* 0.675590208 */, MAD_F(0x0bcbe352) /* 0.737277337 */, 00406 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x0d7e8807) /* 0.843391446 */, 00407 00408 MAD_F(0x0e313245) /* 0.887010833 */, MAD_F(0x0ec835e8) /* 0.923879533 */, 00409 MAD_F(0x0f426cb5) /* 0.953716951 */, MAD_F(0x0f9ee890) /* 0.976296007 */, 00410 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ffc19fd) /* 0.999048222 */, 00411 MAD_F(0x0ffc19fd) /* 0.999048222 */, MAD_F(0x0fdcf549) /* 0.991444861 */, 00412 MAD_F(0x0f9ee890) /* 0.976296007 */, MAD_F(0x0f426cb5) /* 0.953716951 */, 00413 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0e313245) /* 0.887010833 */, 00414 00415 MAD_F(0x0d7e8807) /* 0.843391446 */, MAD_F(0x0cb19346) /* 0.793353340 */, 00416 MAD_F(0x0bcbe352) /* 0.737277337 */, MAD_F(0x0acf37ad) /* 0.675590208 */, 00417 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0898c779) /* 0.537299608 */, 00418 MAD_F(0x07635284) /* 0.461748613 */, MAD_F(0x061f78aa) /* 0.382683432 */, 00419 MAD_F(0x04cfb0e2) /* 0.300705800 */, MAD_F(0x03768962) /* 0.216439614 */, 00420 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x00b2aa3e) /* 0.043619387 */, 00421 }; 00422 # endif /* ASO_IMDCT */ 00423 00424 /* 00425 * windowing coefficients for short blocks 00426 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3 00427 * 00428 * window_s[i] = sin((PI / 12) * (i + 1/2)) 00429 */ 00430 static 00431 mad_fixed_t const window_s[12] = { 00432 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x061f78aa) /* 0.382683432 */, 00433 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0cb19346) /* 0.793353340 */, 00434 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0fdcf549) /* 0.991444861 */, 00435 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ec835e8) /* 0.923879533 */, 00436 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x09bd7ca0) /* 0.608761429 */, 00437 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x0216a2a2) /* 0.130526192 */, 00438 }; 00439 00440 /* 00441 * coefficients for intensity stereo processing 00442 * derived from section 2.4.3.4.9.3 of ISO/IEC 11172-3 00443 * 00444 * is_ratio[i] = tan(i * (PI / 12)) 00445 * is_table[i] = is_ratio[i] / (1 + is_ratio[i]) 00446 */ 00447 static 00448 mad_fixed_t const is_table[7] = { 00449 MAD_F(0x00000000) /* 0.000000000 */, 00450 MAD_F(0x0361962f) /* 0.211324865 */, 00451 MAD_F(0x05db3d74) /* 0.366025404 */, 00452 MAD_F(0x08000000) /* 0.500000000 */, 00453 MAD_F(0x0a24c28c) /* 0.633974596 */, 00454 MAD_F(0x0c9e69d1) /* 0.788675135 */, 00455 MAD_F(0x10000000) /* 1.000000000 */ 00456 }; 00457 00458 /* 00459 * coefficients for LSF intensity stereo processing 00460 * derived from section 2.4.3.2 of ISO/IEC 13818-3 00461 * 00462 * is_lsf_table[0][i] = (1 / sqrt(sqrt(2)))^(i + 1) 00463 * is_lsf_table[1][i] = (1 / sqrt(2)) ^(i + 1) 00464 */ 00465 static 00466 mad_fixed_t const is_lsf_table[2][15] = { 00467 { 00468 MAD_F(0x0d744fcd) /* 0.840896415 */, 00469 MAD_F(0x0b504f33) /* 0.707106781 */, 00470 MAD_F(0x09837f05) /* 0.594603558 */, 00471 MAD_F(0x08000000) /* 0.500000000 */, 00472 MAD_F(0x06ba27e6) /* 0.420448208 */, 00473 MAD_F(0x05a8279a) /* 0.353553391 */, 00474 MAD_F(0x04c1bf83) /* 0.297301779 */, 00475 MAD_F(0x04000000) /* 0.250000000 */, 00476 MAD_F(0x035d13f3) /* 0.210224104 */, 00477 MAD_F(0x02d413cd) /* 0.176776695 */, 00478 MAD_F(0x0260dfc1) /* 0.148650889 */, 00479 MAD_F(0x02000000) /* 0.125000000 */, 00480 MAD_F(0x01ae89fa) /* 0.105112052 */, 00481 MAD_F(0x016a09e6) /* 0.088388348 */, 00482 MAD_F(0x01306fe1) /* 0.074325445 */ 00483 }, { 00484 MAD_F(0x0b504f33) /* 0.707106781 */, 00485 MAD_F(0x08000000) /* 0.500000000 */, 00486 MAD_F(0x05a8279a) /* 0.353553391 */, 00487 MAD_F(0x04000000) /* 0.250000000 */, 00488 MAD_F(0x02d413cd) /* 0.176776695 */, 00489 MAD_F(0x02000000) /* 0.125000000 */, 00490 MAD_F(0x016a09e6) /* 0.088388348 */, 00491 MAD_F(0x01000000) /* 0.062500000 */, 00492 MAD_F(0x00b504f3) /* 0.044194174 */, 00493 MAD_F(0x00800000) /* 0.031250000 */, 00494 MAD_F(0x005a827a) /* 0.022097087 */, 00495 MAD_F(0x00400000) /* 0.015625000 */, 00496 MAD_F(0x002d413d) /* 0.011048543 */, 00497 MAD_F(0x00200000) /* 0.007812500 */, 00498 MAD_F(0x0016a09e) /* 0.005524272 */ 00499 } 00500 }; 00501 00502 /* 00503 * NAME: III_sideinfo() 00504 * DESCRIPTION: decode frame side information from a bitstream 00505 */ 00506 static 00507 enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch, 00508 int lsf, struct sideinfo *si, 00509 unsigned int *data_bitlen, 00510 unsigned int *priv_bitlen) 00511 { 00512 unsigned int ngr, gr, ch, i; 00513 enum mad_error result = MAD_ERROR_NONE; 00514 00515 *data_bitlen = 0; 00516 *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3); 00517 00518 si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9); 00519 si->private_bits = mad_bit_read(ptr, *priv_bitlen); 00520 00521 ngr = 1; 00522 if (!lsf) { 00523 ngr = 2; 00524 00525 for (ch = 0; ch < nch; ++ch) 00526 si->scfsi[ch] = mad_bit_read(ptr, 4); 00527 } 00528 00529 for (gr = 0; gr < ngr; ++gr) { 00530 struct granule *granule = &si->gr[gr]; 00531 00532 for (ch = 0; ch < nch; ++ch) { 00533 struct channel *channel = &granule->ch[ch]; 00534 00535 channel->part2_3_length = mad_bit_read(ptr, 12); 00536 channel->big_values = mad_bit_read(ptr, 9); 00537 channel->global_gain = mad_bit_read(ptr, 8); 00538 channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4); 00539 00540 *data_bitlen += channel->part2_3_length; 00541 00542 if (channel->big_values > 288 && result == 0) 00543 result = MAD_ERROR_BADBIGVALUES; 00544 00545 channel->flags = 0; 00546 00547 /* window_switching_flag */ 00548 if (mad_bit_read(ptr, 1)) { 00549 channel->block_type = mad_bit_read(ptr, 2); 00550 00551 if (channel->block_type == 0 && result == 0) 00552 result = MAD_ERROR_BADBLOCKTYPE; 00553 00554 if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0) 00555 result = MAD_ERROR_BADSCFSI; 00556 00557 channel->region0_count = 7; 00558 channel->region1_count = 36; 00559 00560 if (mad_bit_read(ptr, 1)) 00561 channel->flags |= mixed_block_flag; 00562 else if (channel->block_type == 2) 00563 channel->region0_count = 8; 00564 00565 for (i = 0; i < 2; ++i) 00566 channel->table_select[i] = mad_bit_read(ptr, 5); 00567 00568 # if defined(DEBUG) 00569 channel->table_select[2] = 4; /* not used */ 00570 # endif 00571 00572 for (i = 0; i < 3; ++i) 00573 channel->subblock_gain[i] = mad_bit_read(ptr, 3); 00574 } 00575 else { 00576 channel->block_type = 0; 00577 00578 for (i = 0; i < 3; ++i) 00579 channel->table_select[i] = mad_bit_read(ptr, 5); 00580 00581 channel->region0_count = mad_bit_read(ptr, 4); 00582 channel->region1_count = mad_bit_read(ptr, 3); 00583 } 00584 00585 /* [preflag,] scalefac_scale, count1table_select */ 00586 channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3); 00587 } 00588 } 00589 00590 return result; 00591 } 00592 00593 /* 00594 * NAME: III_scalefactors_lsf() 00595 * DESCRIPTION: decode channel scalefactors for LSF from a bitstream 00596 */ 00597 static 00598 unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr, 00599 struct channel *channel, 00600 struct channel *gr1ch, int mode_extension) 00601 { 00602 struct mad_bitptr start; 00603 unsigned int scalefac_compress, index, slen[4], part, n, i; 00604 unsigned char const *nsfb; 00605 00606 start = *ptr; 00607 00608 scalefac_compress = channel->scalefac_compress; 00609 index = (channel->block_type == 2) ? 00610 ((channel->flags & mixed_block_flag) ? 2 : 1) : 0; 00611 00612 if (!((mode_extension & I_STEREO) && gr1ch)) { 00613 if (scalefac_compress < 400) { 00614 slen[0] = (scalefac_compress >> 4) / 5; 00615 slen[1] = (scalefac_compress >> 4) % 5; 00616 slen[2] = (scalefac_compress % 16) >> 2; 00617 slen[3] = scalefac_compress % 4; 00618 00619 nsfb = nsfb_table[0][index]; 00620 } 00621 else if (scalefac_compress < 500) { 00622 scalefac_compress -= 400; 00623 00624 slen[0] = (scalefac_compress >> 2) / 5; 00625 slen[1] = (scalefac_compress >> 2) % 5; 00626 slen[2] = scalefac_compress % 4; 00627 slen[3] = 0; 00628 00629 nsfb = nsfb_table[1][index]; 00630 } 00631 else { 00632 scalefac_compress -= 500; 00633 00634 slen[0] = scalefac_compress / 3; 00635 slen[1] = scalefac_compress % 3; 00636 slen[2] = 0; 00637 slen[3] = 0; 00638 00639 channel->flags |= preflag; 00640 00641 nsfb = nsfb_table[2][index]; 00642 } 00643 00644 n = 0; 00645 for (part = 0; part < 4; ++part) { 00646 for (i = 0; i < nsfb[part]; ++i) 00647 channel->scalefac[n++] = mad_bit_read(ptr, slen[part]); 00648 } 00649 00650 while (n < 39) 00651 channel->scalefac[n++] = 0; 00652 } 00653 else { /* (mode_extension & I_STEREO) && gr1ch (i.e. ch == 1) */ 00654 scalefac_compress >>= 1; 00655 00656 if (scalefac_compress < 180) { 00657 slen[0] = scalefac_compress / 36; 00658 slen[1] = (scalefac_compress % 36) / 6; 00659 slen[2] = (scalefac_compress % 36) % 6; 00660 slen[3] = 0; 00661 00662 nsfb = nsfb_table[3][index]; 00663 } 00664 else if (scalefac_compress < 244) { 00665 scalefac_compress -= 180; 00666 00667 slen[0] = (scalefac_compress % 64) >> 4; 00668 slen[1] = (scalefac_compress % 16) >> 2; 00669 slen[2] = scalefac_compress % 4; 00670 slen[3] = 0; 00671 00672 nsfb = nsfb_table[4][index]; 00673 } 00674 else { 00675 scalefac_compress -= 244; 00676 00677 slen[0] = scalefac_compress / 3; 00678 slen[1] = scalefac_compress % 3; 00679 slen[2] = 0; 00680 slen[3] = 0; 00681 00682 nsfb = nsfb_table[5][index]; 00683 } 00684 00685 n = 0; 00686 for (part = 0; part < 4; ++part) { 00687 unsigned int max, is_pos; 00688 00689 max = (1 << slen[part]) - 1; 00690 00691 for (i = 0; i < nsfb[part]; ++i) { 00692 is_pos = mad_bit_read(ptr, slen[part]); 00693 00694 channel->scalefac[n] = is_pos; 00695 gr1ch->scalefac[n++] = (is_pos == max); 00696 } 00697 } 00698 00699 while (n < 39) { 00700 channel->scalefac[n] = 0; 00701 gr1ch->scalefac[n++] = 0; /* apparently not illegal */ 00702 } 00703 } 00704 00705 return mad_bit_length(&start, ptr); 00706 } 00707 00708 /* 00709 * NAME: III_scalefactors() 00710 * DESCRIPTION: decode channel scalefactors of one granule from a bitstream 00711 */ 00712 static 00713 unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel, 00714 struct channel const *gr0ch, unsigned int scfsi) 00715 { 00716 struct mad_bitptr start; 00717 unsigned int slen1, slen2, sfbi; 00718 00719 start = *ptr; 00720 00721 slen1 = sflen_table[channel->scalefac_compress].slen1; 00722 slen2 = sflen_table[channel->scalefac_compress].slen2; 00723 00724 if (channel->block_type == 2) { 00725 unsigned int nsfb; 00726 00727 sfbi = 0; 00728 00729 nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3; 00730 while (nsfb--) 00731 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1); 00732 00733 nsfb = 6 * 3; 00734 while (nsfb--) 00735 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2); 00736 00737 nsfb = 1 * 3; 00738 while (nsfb--) 00739 channel->scalefac[sfbi++] = 0; 00740 } 00741 else { /* channel->block_type != 2 */ 00742 if (scfsi & 0x8) { 00743 for (sfbi = 0; sfbi < 6; ++sfbi) 00744 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 00745 } 00746 else { 00747 for (sfbi = 0; sfbi < 6; ++sfbi) 00748 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1); 00749 } 00750 00751 if (scfsi & 0x4) { 00752 for (sfbi = 6; sfbi < 11; ++sfbi) 00753 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 00754 } 00755 else { 00756 for (sfbi = 6; sfbi < 11; ++sfbi) 00757 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1); 00758 } 00759 00760 if (scfsi & 0x2) { 00761 for (sfbi = 11; sfbi < 16; ++sfbi) 00762 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 00763 } 00764 else { 00765 for (sfbi = 11; sfbi < 16; ++sfbi) 00766 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2); 00767 } 00768 00769 if (scfsi & 0x1) { 00770 for (sfbi = 16; sfbi < 21; ++sfbi) 00771 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 00772 } 00773 else { 00774 for (sfbi = 16; sfbi < 21; ++sfbi) 00775 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2); 00776 } 00777 00778 channel->scalefac[21] = 0; 00779 } 00780 00781 return mad_bit_length(&start, ptr); 00782 } 00783 00784 /* 00785 * The Layer III formula for requantization and scaling is defined by 00786 * section 2.4.3.4.7.1 of ISO/IEC 11172-3, as follows: 00787 * 00788 * long blocks: 00789 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) * 00790 * 2^((1/4) * (global_gain - 210)) * 00791 * 2^-(scalefac_multiplier * 00792 * (scalefac_l[sfb] + preflag * pretab[sfb])) 00793 * 00794 * short blocks: 00795 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) * 00796 * 2^((1/4) * (global_gain - 210 - 8 * subblock_gain[w])) * 00797 * 2^-(scalefac_multiplier * scalefac_s[sfb][w]) 00798 * 00799 * where: 00800 * scalefac_multiplier = (scalefac_scale + 1) / 2 00801 * 00802 * The routines III_exponents() and III_requantize() facilitate this 00803 * calculation. 00804 */ 00805 00806 /* 00807 * NAME: III_exponents() 00808 * DESCRIPTION: calculate scalefactor exponents 00809 */ 00810 static 00811 void III_exponents(struct channel const *channel, 00812 unsigned char const *sfbwidth, signed int exponents[39]) 00813 { 00814 signed int gain; 00815 unsigned int scalefac_multiplier, sfbi; 00816 00817 gain = (signed int) channel->global_gain - 210; 00818 scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1; 00819 00820 if (channel->block_type == 2) { 00821 unsigned int l; 00822 signed int gain0, gain1, gain2; 00823 00824 sfbi = l = 0; 00825 00826 if (channel->flags & mixed_block_flag) { 00827 unsigned int premask; 00828 00829 premask = (channel->flags & preflag) ? ~0 : 0; 00830 00831 /* long block subbands 0-1 */ 00832 00833 while (l < 36) { 00834 exponents[sfbi] = gain - 00835 (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) << 00836 scalefac_multiplier); 00837 00838 l += sfbwidth[sfbi++]; 00839 } 00840 } 00841 00842 /* this is probably wrong for 8000 Hz short/mixed blocks */ 00843 00844 gain0 = gain - 8 * (signed int) channel->subblock_gain[0]; 00845 gain1 = gain - 8 * (signed int) channel->subblock_gain[1]; 00846 gain2 = gain - 8 * (signed int) channel->subblock_gain[2]; 00847 00848 while (l < 576) { 00849 exponents[sfbi + 0] = gain0 - 00850 (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier); 00851 exponents[sfbi + 1] = gain1 - 00852 (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier); 00853 exponents[sfbi + 2] = gain2 - 00854 (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier); 00855 00856 l += 3 * sfbwidth[sfbi]; 00857 sfbi += 3; 00858 } 00859 } 00860 else { /* channel->block_type != 2 */ 00861 if (channel->flags & preflag) { 00862 for (sfbi = 0; sfbi < 22; ++sfbi) { 00863 exponents[sfbi] = gain - 00864 (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) << 00865 scalefac_multiplier); 00866 } 00867 } 00868 else { 00869 for (sfbi = 0; sfbi < 22; ++sfbi) { 00870 exponents[sfbi] = gain - 00871 (signed int) (channel->scalefac[sfbi] << scalefac_multiplier); 00872 } 00873 } 00874 } 00875 } 00876 00877 /* 00878 * NAME: III_requantize() 00879 * DESCRIPTION: requantize one (positive) value 00880 */ 00881 static 00882 mad_fixed_t III_requantize(unsigned int value, signed int exp) 00883 { 00884 mad_fixed_t requantized; 00885 signed int frac; 00886 struct fixedfloat const *power; 00887 00888 frac = exp % 4; /* assumes sign(frac) == sign(exp) */ 00889 exp /= 4; 00890 00891 power = &rq_table[value]; 00892 requantized = power->mantissa; 00893 exp += power->exponent; 00894 00895 if (exp < 0) { 00896 if (-exp >= sizeof(mad_fixed_t) * CHAR_BIT) { 00897 /* underflow */ 00898 requantized = 0; 00899 } 00900 else { 00901 requantized += 1L << (-exp - 1); 00902 requantized >>= -exp; 00903 } 00904 } 00905 else { 00906 if (exp >= 5) { 00907 /* overflow */ 00908 # if defined(DEBUG) 00909 fprintf(stderr, "requantize overflow (%f * 2^%d)\n", 00910 mad_f_todouble(requantized), exp); 00911 # endif 00912 requantized = MAD_F_MAX; 00913 } 00914 else 00915 requantized <<= exp; 00916 } 00917 00918 return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized; 00919 } 00920 00921 /* we must take care that sz >= bits and sz < sizeof(long) lest bits == 0 */ 00922 # define MASK(cache, sz, bits) \ 00923 (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1)) 00924 # define MASK1BIT(cache, sz) \ 00925 ((cache) & (1 << ((sz) - 1))) 00926 00927 /* 00928 * NAME: III_huffdecode() 00929 * DESCRIPTION: decode Huffman code words of one channel of one granule 00930 */ 00931 static 00932 enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576], 00933 struct channel *channel, 00934 unsigned char const *sfbwidth, 00935 unsigned int part2_length) 00936 { 00937 signed int exponents[39], exp; 00938 signed int const *expptr; 00939 struct mad_bitptr peek; 00940 signed int bits_left, cachesz; 00941 register mad_fixed_t *xrptr; 00942 mad_fixed_t const *sfbound; 00943 register unsigned long bitcache; 00944 00945 bits_left = (signed) channel->part2_3_length - (signed) part2_length; 00946 if (bits_left < 0) 00947 return MAD_ERROR_BADPART3LEN; 00948 00949 III_exponents(channel, sfbwidth, exponents); 00950 00951 peek = *ptr; 00952 mad_bit_skip(ptr, bits_left); 00953 00954 /* align bit reads to byte boundaries */ 00955 cachesz = mad_bit_bitsleft(&peek); 00956 cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7; 00957 00958 bitcache = mad_bit_read(&peek, cachesz); 00959 bits_left -= cachesz; 00960 00961 xrptr = &xr[0]; 00962 00963 /* big_values */ 00964 { 00965 unsigned int region, rcount; 00966 struct hufftable const *entry; 00967 union huffpair const *table; 00968 unsigned int linbits, startbits, big_values, reqhits; 00969 mad_fixed_t reqcache[16]; 00970 00971 sfbound = xrptr + *sfbwidth++; 00972 rcount = channel->region0_count + 1; 00973 00974 entry = &mad_huff_pair_table[channel->table_select[region = 0]]; 00975 table = entry->table; 00976 linbits = entry->linbits; 00977 startbits = entry->startbits; 00978 00979 if (table == 0) 00980 return MAD_ERROR_BADHUFFTABLE; 00981 00982 expptr = &exponents[0]; 00983 exp = *expptr++; 00984 reqhits = 0; 00985 00986 big_values = channel->big_values; 00987 00988 while (big_values-- && cachesz + bits_left > 0) { 00989 union huffpair const *pair; 00990 unsigned int clumpsz, value; 00991 register mad_fixed_t requantized; 00992 00993 if (xrptr == sfbound) { 00994 sfbound += *sfbwidth++; 00995 00996 /* change table if region boundary */ 00997 00998 if (--rcount == 0) { 00999 if (region == 0) 01000 rcount = channel->region1_count + 1; 01001 else 01002 rcount = 0; /* all remaining */ 01003 01004 entry = &mad_huff_pair_table[channel->table_select[++region]]; 01005 table = entry->table; 01006 linbits = entry->linbits; 01007 startbits = entry->startbits; 01008 01009 if (table == 0) 01010 return MAD_ERROR_BADHUFFTABLE; 01011 } 01012 01013 if (exp != *expptr) { 01014 exp = *expptr; 01015 reqhits = 0; 01016 } 01017 01018 ++expptr; 01019 } 01020 01021 if (cachesz < 21) { 01022 unsigned int bits; 01023 01024 bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7; 01025 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits); 01026 cachesz += bits; 01027 bits_left -= bits; 01028 } 01029 01030 /* hcod (0..19) */ 01031 01032 clumpsz = startbits; 01033 pair = &table[MASK(bitcache, cachesz, clumpsz)]; 01034 01035 while (!pair->final) { 01036 cachesz -= clumpsz; 01037 01038 clumpsz = pair->ptr.bits; 01039 pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)]; 01040 } 01041 01042 cachesz -= pair->value.hlen; 01043 01044 if (linbits) { 01045 /* x (0..14) */ 01046 01047 value = pair->value.x; 01048 01049 switch (value) { 01050 case 0: 01051 xrptr[0] = 0; 01052 break; 01053 01054 case 15: 01055 if (cachesz < linbits + 2) { 01056 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 01057 cachesz += 16; 01058 bits_left -= 16; 01059 } 01060 01061 value += MASK(bitcache, cachesz, linbits); 01062 cachesz -= linbits; 01063 01064 requantized = III_requantize(value, exp); 01065 goto x_final; 01066 01067 default: 01068 if (reqhits & (1 << value)) 01069 requantized = reqcache[value]; 01070 else { 01071 reqhits |= (1 << value); 01072 requantized = reqcache[value] = III_requantize(value, exp); 01073 } 01074 01075 x_final: 01076 xrptr[0] = MASK1BIT(bitcache, cachesz--) ? 01077 -requantized : requantized; 01078 } 01079 01080 /* y (0..14) */ 01081 01082 value = pair->value.y; 01083 01084 switch (value) { 01085 case 0: 01086 xrptr[1] = 0; 01087 break; 01088 01089 case 15: 01090 if (cachesz < linbits + 1) { 01091 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 01092 cachesz += 16; 01093 bits_left -= 16; 01094 } 01095 01096 value += MASK(bitcache, cachesz, linbits); 01097 cachesz -= linbits; 01098 01099 requantized = III_requantize(value, exp); 01100 goto y_final; 01101 01102 default: 01103 if (reqhits & (1 << value)) 01104 requantized = reqcache[value]; 01105 else { 01106 reqhits |= (1 << value); 01107 requantized = reqcache[value] = III_requantize(value, exp); 01108 } 01109 01110 y_final: 01111 xrptr[1] = MASK1BIT(bitcache, cachesz--) ? 01112 -requantized : requantized; 01113 } 01114 } 01115 else { 01116 /* x (0..1) */ 01117 01118 value = pair->value.x; 01119 01120 if (value == 0) 01121 xrptr[0] = 0; 01122 else { 01123 if (reqhits & (1 << value)) 01124 requantized = reqcache[value]; 01125 else { 01126 reqhits |= (1 << value); 01127 requantized = reqcache[value] = III_requantize(value, exp); 01128 } 01129 01130 xrptr[0] = MASK1BIT(bitcache, cachesz--) ? 01131 -requantized : requantized; 01132 } 01133 01134 /* y (0..1) */ 01135 01136 value = pair->value.y; 01137 01138 if (value == 0) 01139 xrptr[1] = 0; 01140 else { 01141 if (reqhits & (1 << value)) 01142 requantized = reqcache[value]; 01143 else { 01144 reqhits |= (1 << value); 01145 requantized = reqcache[value] = III_requantize(value, exp); 01146 } 01147 01148 xrptr[1] = MASK1BIT(bitcache, cachesz--) ? 01149 -requantized : requantized; 01150 } 01151 } 01152 01153 xrptr += 2; 01154 } 01155 } 01156 01157 if (cachesz + bits_left < 0) 01158 return MAD_ERROR_BADHUFFDATA; /* big_values overrun */ 01159 01160 /* count1 */ 01161 { 01162 union huffquad const *table; 01163 register mad_fixed_t requantized; 01164 01165 table = mad_huff_quad_table[channel->flags & count1table_select]; 01166 01167 requantized = III_requantize(1, exp); 01168 01169 while (cachesz + bits_left > 0 && xrptr <= &xr[572]) { 01170 union huffquad const *quad; 01171 01172 /* hcod (1..6) */ 01173 01174 if (cachesz < 10) { 01175 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 01176 cachesz += 16; 01177 bits_left -= 16; 01178 } 01179 01180 quad = &table[MASK(bitcache, cachesz, 4)]; 01181 01182 /* quad tables guaranteed to have at most one extra lookup */ 01183 if (!quad->final) { 01184 cachesz -= 4; 01185 01186 quad = &table[quad->ptr.offset + 01187 MASK(bitcache, cachesz, quad->ptr.bits)]; 01188 } 01189 01190 cachesz -= quad->value.hlen; 01191 01192 if (xrptr == sfbound) { 01193 sfbound += *sfbwidth++; 01194 01195 if (exp != *expptr) { 01196 exp = *expptr; 01197 requantized = III_requantize(1, exp); 01198 } 01199 01200 ++expptr; 01201 } 01202 01203 /* v (0..1) */ 01204 01205 xrptr[0] = quad->value.v ? 01206 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 01207 01208 /* w (0..1) */ 01209 01210 xrptr[1] = quad->value.w ? 01211 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 01212 01213 xrptr += 2; 01214 01215 if (xrptr == sfbound) { 01216 sfbound += *sfbwidth++; 01217 01218 if (exp != *expptr) { 01219 exp = *expptr; 01220 requantized = III_requantize(1, exp); 01221 } 01222 01223 ++expptr; 01224 } 01225 01226 /* x (0..1) */ 01227 01228 xrptr[0] = quad->value.x ? 01229 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 01230 01231 /* y (0..1) */ 01232 01233 xrptr[1] = quad->value.y ? 01234 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 01235 01236 xrptr += 2; 01237 } 01238 01239 if (cachesz + bits_left < 0) { 01240 # if 0 && defined(DEBUG) 01241 fprintf(stderr, "huffman count1 overrun (%d bits)\n", 01242 -(cachesz + bits_left)); 01243 # endif 01244 01245 /* technically the bitstream is misformatted, but apparently 01246 some encoders are just a bit sloppy with stuffing bits */ 01247 01248 xrptr -= 4; 01249 } 01250 } 01251 01252 /* assert(-bits_left <= MAD_BUFFER_GUARD * CHAR_BIT);*/ 01253 01254 # if 0 && defined(DEBUG) 01255 if (bits_left < 0) 01256 fprintf(stderr, "read %d bits too many\n", -bits_left); 01257 else if (cachesz + bits_left > 0) 01258 fprintf(stderr, "%d stuffing bits\n", cachesz + bits_left); 01259 # endif 01260 01261 /* rzero */ 01262 while (xrptr < &xr[576]) { 01263 xrptr[0] = 0; 01264 xrptr[1] = 0; 01265 01266 xrptr += 2; 01267 } 01268 01269 return MAD_ERROR_NONE; 01270 } 01271 01272 # undef MASK 01273 # undef MASK1BIT 01274 01275 /* 01276 * NAME: III_reorder() 01277 * DESCRIPTION: reorder frequency lines of a short block into subband order 01278 */ 01279 static 01280 void III_reorder(mad_fixed_t xr[576], struct channel const *channel, 01281 unsigned char const sfbwidth[39]) 01282 { 01283 mad_fixed_t tmp[32][3][6]; 01284 unsigned int sb, l, f, w, sbw[3], sw[3]; 01285 01286 /* this is probably wrong for 8000 Hz mixed blocks */ 01287 01288 sb = 0; 01289 if (channel->flags & mixed_block_flag) { 01290 sb = 2; 01291 01292 l = 0; 01293 while (l < 36) 01294 l += *sfbwidth++; 01295 } 01296 01297 for (w = 0; w < 3; ++w) { 01298 sbw[w] = sb; 01299 sw[w] = 0; 01300 } 01301 01302 f = *sfbwidth++; 01303 w = 0; 01304 01305 for (l = 18 * sb; l < 576; ++l) { 01306 if (f-- == 0) { 01307 f = *sfbwidth++ - 1; 01308 w = (w + 1) % 3; 01309 } 01310 01311 tmp[sbw[w]][w][sw[w]++] = xr[l]; 01312 01313 if (sw[w] == 6) { 01314 sw[w] = 0; 01315 ++sbw[w]; 01316 } 01317 } 01318 01319 memcpy(&xr[18 * sb], &tmp[sb], (576 - 18 * sb) * sizeof(mad_fixed_t)); 01320 } 01321 01322 /* 01323 * NAME: III_stereo() 01324 * DESCRIPTION: perform joint stereo processing on a granule 01325 */ 01326 static 01327 enum mad_error III_stereo(mad_fixed_t xr[2][576], 01328 struct granule const *granule, 01329 struct mad_header *header, 01330 unsigned char const *sfbwidth) 01331 { 01332 short modes[39]; 01333 unsigned int sfbi, l, n, i; 01334 01335 if (granule->ch[0].block_type != 01336 granule->ch[1].block_type || 01337 (granule->ch[0].flags & mixed_block_flag) != 01338 (granule->ch[1].flags & mixed_block_flag)) 01339 return MAD_ERROR_BADSTEREO; 01340 01341 for (i = 0; i < 39; ++i) 01342 modes[i] = header->mode_extension; 01343 01344 /* intensity stereo */ 01345 01346 if (header->mode_extension & I_STEREO) { 01347 struct channel const *right_ch = &granule->ch[1]; 01348 mad_fixed_t const *right_xr = xr[1]; 01349 unsigned int is_pos; 01350 01351 header->flags |= MAD_FLAG_I_STEREO; 01352 01353 /* first determine which scalefactor bands are to be processed */ 01354 01355 if (right_ch->block_type == 2) { 01356 unsigned int lower, start, max, bound[3], w; 01357 01358 lower = start = max = bound[0] = bound[1] = bound[2] = 0; 01359 01360 sfbi = l = 0; 01361 01362 if (right_ch->flags & mixed_block_flag) { 01363 while (l < 36) { 01364 n = sfbwidth[sfbi++]; 01365 01366 for (i = 0; i < n; ++i) { 01367 if (right_xr[i]) { 01368 lower = sfbi; 01369 break; 01370 } 01371 } 01372 01373 right_xr += n; 01374 l += n; 01375 } 01376 01377 start = sfbi; 01378 } 01379 01380 w = 0; 01381 while (l < 576) { 01382 n = sfbwidth[sfbi++]; 01383 01384 for (i = 0; i < n; ++i) { 01385 if (right_xr[i]) { 01386 max = bound[w] = sfbi; 01387 break; 01388 } 01389 } 01390 01391 right_xr += n; 01392 l += n; 01393 w = (w + 1) % 3; 01394 } 01395 01396 if (max) 01397 lower = start; 01398 01399 /* long blocks */ 01400 01401 for (i = 0; i < lower; ++i) 01402 modes[i] = header->mode_extension & ~I_STEREO; 01403 01404 /* short blocks */ 01405 01406 w = 0; 01407 for (i = start; i < max; ++i) { 01408 if (i < bound[w]) 01409 modes[i] = header->mode_extension & ~I_STEREO; 01410 01411 w = (w + 1) % 3; 01412 } 01413 } 01414 else { /* right_ch->block_type != 2 */ 01415 unsigned int bound; 01416 01417 bound = 0; 01418 for (sfbi = l = 0; l < 576; l += n) { 01419 n = sfbwidth[sfbi++]; 01420 01421 for (i = 0; i < n; ++i) { 01422 if (right_xr[i]) { 01423 bound = sfbi; 01424 break; 01425 } 01426 } 01427 01428 right_xr += n; 01429 } 01430 01431 for (i = 0; i < bound; ++i) 01432 modes[i] = header->mode_extension & ~I_STEREO; 01433 } 01434 01435 /* now do the actual processing */ 01436 01437 if (header->flags & MAD_FLAG_LSF_EXT) { 01438 unsigned char const *illegal_pos = granule[1].ch[1].scalefac; 01439 mad_fixed_t const *lsf_scale; 01440 01441 /* intensity_scale */ 01442 lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1]; 01443 01444 for (sfbi = l = 0; l < 576; ++sfbi, l += n) { 01445 n = sfbwidth[sfbi]; 01446 01447 if (!(modes[sfbi] & I_STEREO)) 01448 continue; 01449 01450 if (illegal_pos[sfbi]) { 01451 modes[sfbi] &= ~I_STEREO; 01452 continue; 01453 } 01454 01455 is_pos = right_ch->scalefac[sfbi]; 01456 01457 for (i = 0; i < n; ++i) { 01458 register mad_fixed_t left; 01459 01460 left = xr[0][l + i]; 01461 01462 if (is_pos == 0) 01463 xr[1][l + i] = left; 01464 else { 01465 register mad_fixed_t opposite; 01466 01467 opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]); 01468 01469 if (is_pos & 1) { 01470 xr[0][l + i] = opposite; 01471 xr[1][l + i] = left; 01472 } 01473 else 01474 xr[1][l + i] = opposite; 01475 } 01476 } 01477 } 01478 } 01479 else { /* !(header->flags & MAD_FLAG_LSF_EXT) */ 01480 for (sfbi = l = 0; l < 576; ++sfbi, l += n) { 01481 n = sfbwidth[sfbi]; 01482 01483 if (!(modes[sfbi] & I_STEREO)) 01484 continue; 01485 01486 is_pos = right_ch->scalefac[sfbi]; 01487 01488 if (is_pos >= 7) { /* illegal intensity position */ 01489 modes[sfbi] &= ~I_STEREO; 01490 continue; 01491 } 01492 01493 for (i = 0; i < n; ++i) { 01494 register mad_fixed_t left; 01495 01496 left = xr[0][l + i]; 01497 01498 xr[0][l + i] = mad_f_mul(left, is_table[ is_pos]); 01499 xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]); 01500 } 01501 } 01502 } 01503 } 01504 01505 /* middle/side stereo */ 01506 01507 if (header->mode_extension & MS_STEREO) { 01508 register mad_fixed_t invsqrt2; 01509 01510 header->flags |= MAD_FLAG_MS_STEREO; 01511 01512 invsqrt2 = root_table[3 + -2]; 01513 01514 for (sfbi = l = 0; l < 576; ++sfbi, l += n) { 01515 n = sfbwidth[sfbi]; 01516 01517 if (modes[sfbi] != MS_STEREO) 01518 continue; 01519 01520 for (i = 0; i < n; ++i) { 01521 register mad_fixed_t m, s; 01522 01523 m = xr[0][l + i]; 01524 s = xr[1][l + i]; 01525 01526 xr[0][l + i] = mad_f_mul(m + s, invsqrt2); /* l = (m + s) / sqrt(2) */ 01527 xr[1][l + i] = mad_f_mul(m - s, invsqrt2); /* r = (m - s) / sqrt(2) */ 01528 } 01529 } 01530 } 01531 01532 return MAD_ERROR_NONE; 01533 } 01534 01535 /* 01536 * NAME: III_aliasreduce() 01537 * DESCRIPTION: perform frequency line alias reduction 01538 */ 01539 static 01540 void III_aliasreduce(mad_fixed_t xr[576], int lines) 01541 { 01542 mad_fixed_t const *bound; 01543 int i; 01544 01545 bound = &xr[lines]; 01546 for (xr += 18; xr < bound; xr += 18) { 01547 for (i = 0; i < 8; ++i) { 01548 register mad_fixed_t a, b; 01549 register mad_fixed64hi_t hi; 01550 register mad_fixed64lo_t lo; 01551 01552 a = xr[-1 - i]; 01553 b = xr[ i]; 01554 01555 # if defined(ASO_ZEROCHECK) 01556 if (a | b) { 01557 # endif 01558 MAD_F_ML0(hi, lo, a, cs[i]); 01559 MAD_F_MLA(hi, lo, -b, ca[i]); 01560 01561 xr[-1 - i] = MAD_F_MLZ(hi, lo); 01562 01563 MAD_F_ML0(hi, lo, b, cs[i]); 01564 MAD_F_MLA(hi, lo, a, ca[i]); 01565 01566 xr[ i] = MAD_F_MLZ(hi, lo); 01567 # if defined(ASO_ZEROCHECK) 01568 } 01569 # endif 01570 } 01571 } 01572 } 01573 01574 # if defined(ASO_IMDCT) 01575 void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int); 01576 # else 01577 # if 1 01578 static 01579 void fastsdct(mad_fixed_t const x[9], mad_fixed_t y[18]) 01580 { 01581 mad_fixed_t a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12; 01582 mad_fixed_t a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25; 01583 mad_fixed_t m0, m1, m2, m3, m4, m5, m6, m7; 01584 01585 enum { 01586 c0 = MAD_F(0x1f838b8d), /* 2 * cos( 1 * PI / 18) */ 01587 c1 = MAD_F(0x1bb67ae8), /* 2 * cos( 3 * PI / 18) */ 01588 c2 = MAD_F(0x18836fa3), /* 2 * cos( 4 * PI / 18) */ 01589 c3 = MAD_F(0x1491b752), /* 2 * cos( 5 * PI / 18) */ 01590 c4 = MAD_F(0x0af1d43a), /* 2 * cos( 7 * PI / 18) */ 01591 c5 = MAD_F(0x058e86a0), /* 2 * cos( 8 * PI / 18) */ 01592 c6 = -MAD_F(0x1e11f642) /* 2 * cos(16 * PI / 18) */ 01593 }; 01594 01595 a0 = x[3] + x[5]; 01596 a1 = x[3] - x[5]; 01597 a2 = x[6] + x[2]; 01598 a3 = x[6] - x[2]; 01599 a4 = x[1] + x[7]; 01600 a5 = x[1] - x[7]; 01601 a6 = x[8] + x[0]; 01602 a7 = x[8] - x[0]; 01603 01604 a8 = a0 + a2; 01605 a9 = a0 - a2; 01606 a10 = a0 - a6; 01607 a11 = a2 - a6; 01608 a12 = a8 + a6; 01609 a13 = a1 - a3; 01610 a14 = a13 + a7; 01611 a15 = a3 + a7; 01612 a16 = a1 - a7; 01613 a17 = a1 + a3; 01614 01615 m0 = mad_f_mul(a17, -c3); 01616 m1 = mad_f_mul(a16, -c0); 01617 m2 = mad_f_mul(a15, -c4); 01618 m3 = mad_f_mul(a14, -c1); 01619 m4 = mad_f_mul(a5, -c1); 01620 m5 = mad_f_mul(a11, -c6); 01621 m6 = mad_f_mul(a10, -c5); 01622 m7 = mad_f_mul(a9, -c2); 01623 01624 a18 = x[4] + a4; 01625 a19 = 2 * x[4] - a4; 01626 a20 = a19 + m5; 01627 a21 = a19 - m5; 01628 a22 = a19 + m6; 01629 a23 = m4 + m2; 01630 a24 = m4 - m2; 01631 a25 = m4 + m1; 01632 01633 /* output to every other slot for convenience */ 01634 01635 y[ 0] = a18 + a12; 01636 y[ 2] = m0 - a25; 01637 y[ 4] = m7 - a20; 01638 y[ 6] = m3; 01639 y[ 8] = a21 - m6; 01640 y[10] = a24 - m1; 01641 y[12] = a12 - 2 * a18; 01642 y[14] = a23 + m0; 01643 y[16] = a22 + m7; 01644 } 01645 01646 static inline 01647 void sdctII(mad_fixed_t const x[18], mad_fixed_t X[18]) 01648 { 01649 mad_fixed_t tmp[9]; 01650 int i; 01651 01652 /* scale[i] = 2 * cos(PI * (2 * i + 1) / (2 * 18)) */ 01653 static mad_fixed_t const scale[9] = { 01654 MAD_F(0x1fe0d3b4), MAD_F(0x1ee8dd47), MAD_F(0x1d007930), 01655 MAD_F(0x1a367e59), MAD_F(0x16a09e66), MAD_F(0x125abcf8), 01656 MAD_F(0x0d8616bc), MAD_F(0x08483ee1), MAD_F(0x02c9fad7) 01657 }; 01658 01659 /* divide the 18-point SDCT-II into two 9-point SDCT-IIs */ 01660 01661 /* even input butterfly */ 01662 01663 for (i = 0; i < 9; i += 3) { 01664 tmp[i + 0] = x[i + 0] + x[18 - (i + 0) - 1]; 01665 tmp[i + 1] = x[i + 1] + x[18 - (i + 1) - 1]; 01666 tmp[i + 2] = x[i + 2] + x[18 - (i + 2) - 1]; 01667 } 01668 01669 fastsdct(tmp, &X[0]); 01670 01671 /* odd input butterfly and scaling */ 01672 01673 for (i = 0; i < 9; i += 3) { 01674 tmp[i + 0] = mad_f_mul(x[i + 0] - x[18 - (i + 0) - 1], scale[i + 0]); 01675 tmp[i + 1] = mad_f_mul(x[i + 1] - x[18 - (i + 1) - 1], scale[i + 1]); 01676 tmp[i + 2] = mad_f_mul(x[i + 2] - x[18 - (i + 2) - 1], scale[i + 2]); 01677 } 01678 01679 fastsdct(tmp, &X[1]); 01680 01681 /* output accumulation */ 01682 01683 for (i = 3; i < 18; i += 8) { 01684 X[i + 0] -= X[(i + 0) - 2]; 01685 X[i + 2] -= X[(i + 2) - 2]; 01686 X[i + 4] -= X[(i + 4) - 2]; 01687 X[i + 6] -= X[(i + 6) - 2]; 01688 } 01689 } 01690 01691 static inline 01692 void dctIV(mad_fixed_t const y[18], mad_fixed_t X[18]) 01693 { 01694 mad_fixed_t tmp[18]; 01695 int i; 01696 01697 /* scale[i] = 2 * cos(PI * (2 * i + 1) / (4 * 18)) */ 01698 static mad_fixed_t const scale[18] = { 01699 MAD_F(0x1ff833fa), MAD_F(0x1fb9ea93), MAD_F(0x1f3dd120), 01700 MAD_F(0x1e84d969), MAD_F(0x1d906bcf), MAD_F(0x1c62648b), 01701 MAD_F(0x1afd100f), MAD_F(0x1963268b), MAD_F(0x1797c6a4), 01702 MAD_F(0x159e6f5b), MAD_F(0x137af940), MAD_F(0x11318ef3), 01703 MAD_F(0x0ec6a507), MAD_F(0x0c3ef153), MAD_F(0x099f61c5), 01704 MAD_F(0x06ed12c5), MAD_F(0x042d4544), MAD_F(0x0165547c) 01705 }; 01706 01707 /* scaling */ 01708 01709 for (i = 0; i < 18; i += 3) { 01710 tmp[i + 0] = mad_f_mul(y[i + 0], scale[i + 0]); 01711 tmp[i + 1] = mad_f_mul(y[i + 1], scale[i + 1]); 01712 tmp[i + 2] = mad_f_mul(y[i + 2], scale[i + 2]); 01713 } 01714 01715 /* SDCT-II */ 01716 01717 sdctII(tmp, X); 01718 01719 /* scale reduction and output accumulation */ 01720 01721 X[0] /= 2; 01722 for (i = 1; i < 17; i += 4) { 01723 X[i + 0] = X[i + 0] / 2 - X[(i + 0) - 1]; 01724 X[i + 1] = X[i + 1] / 2 - X[(i + 1) - 1]; 01725 X[i + 2] = X[i + 2] / 2 - X[(i + 2) - 1]; 01726 X[i + 3] = X[i + 3] / 2 - X[(i + 3) - 1]; 01727 } 01728 X[17] = X[17] / 2 - X[16]; 01729 } 01730 01731 /* 01732 * NAME: imdct36 01733 * DESCRIPTION: perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm 01734 */ 01735 static inline 01736 void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36]) 01737 { 01738 mad_fixed_t tmp[18]; 01739 int i; 01740 01741 /* DCT-IV */ 01742 01743 dctIV(x, tmp); 01744 01745 /* convert 18-point DCT-IV to 36-point IMDCT */ 01746 01747 for (i = 0; i < 9; i += 3) { 01748 y[i + 0] = tmp[9 + (i + 0)]; 01749 y[i + 1] = tmp[9 + (i + 1)]; 01750 y[i + 2] = tmp[9 + (i + 2)]; 01751 } 01752 for (i = 9; i < 27; i += 3) { 01753 y[i + 0] = -tmp[36 - (9 + (i + 0)) - 1]; 01754 y[i + 1] = -tmp[36 - (9 + (i + 1)) - 1]; 01755 y[i + 2] = -tmp[36 - (9 + (i + 2)) - 1]; 01756 } 01757 for (i = 27; i < 36; i += 3) { 01758 y[i + 0] = -tmp[(i + 0) - 27]; 01759 y[i + 1] = -tmp[(i + 1) - 27]; 01760 y[i + 2] = -tmp[(i + 2) - 27]; 01761 } 01762 } 01763 # else 01764 /* 01765 * NAME: imdct36 01766 * DESCRIPTION: perform X[18]->x[36] IMDCT 01767 */ 01768 static inline 01769 void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36]) 01770 { 01771 mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7; 01772 mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15; 01773 register mad_fixed64hi_t hi; 01774 register mad_fixed64lo_t lo; 01775 01776 MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8)); 01777 MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa)); 01778 01779 t6 = MAD_F_MLZ(hi, lo); 01780 01781 MAD_F_MLA(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x061f78aa)); 01782 MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), -MAD_F(0x0ec835e8)); 01783 01784 t0 = MAD_F_MLZ(hi, lo); 01785 01786 MAD_F_MLA(hi, lo, (t8 = X[0] - X[11] - X[12]), MAD_F(0x0216a2a2)); 01787 MAD_F_MLA(hi, lo, (t9 = X[2] - X[9] - X[14]), MAD_F(0x09bd7ca0)); 01788 MAD_F_MLA(hi, lo, (t10 = X[3] - X[8] - X[15]), -MAD_F(0x0cb19346)); 01789 MAD_F_MLA(hi, lo, (t11 = X[5] - X[6] - X[17]), -MAD_F(0x0fdcf549)); 01790 01791 x[7] = MAD_F_MLZ(hi, lo); 01792 x[10] = -x[7]; 01793 01794 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346)); 01795 MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549)); 01796 MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2)); 01797 MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0)); 01798 01799 x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0; 01800 01801 t12 = X[0] - X[3] + X[8] - X[11] - X[12] + X[15]; 01802 t13 = X[2] + X[5] - X[6] - X[9] - X[14] - X[17]; 01803 01804 MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8)); 01805 MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa)); 01806 01807 x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0; 01808 01809 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0)); 01810 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2)); 01811 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549)); 01812 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346)); 01813 01814 t1 = MAD_F_MLZ(hi, lo) + t6; 01815 01816 MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962)); 01817 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245)); 01818 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd)); 01819 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad)); 01820 MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2)); 01821 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779)); 01822 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807)); 01823 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5)); 01824 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352)); 01825 MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e)); 01826 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284)); 01827 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890)); 01828 01829 x[6] = MAD_F_MLZ(hi, lo) + t1; 01830 x[11] = -x[6]; 01831 01832 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5)); 01833 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e)); 01834 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779)); 01835 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890)); 01836 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad)); 01837 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284)); 01838 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245)); 01839 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352)); 01840 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962)); 01841 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807)); 01842 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd)); 01843 MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2)); 01844 01845 x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1; 01846 01847 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352)); 01848 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807)); 01849 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284)); 01850 MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2)); 01851 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890)); 01852 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd)); 01853 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e)); 01854 MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962)); 01855 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5)); 01856 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245)); 01857 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779)); 01858 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad)); 01859 01860 x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1; 01861 01862 MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa)); 01863 MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8)); 01864 01865 t7 = MAD_F_MLZ(hi, lo); 01866 01867 MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346)); 01868 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549)); 01869 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2)); 01870 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0)); 01871 01872 t2 = MAD_F_MLZ(hi, lo); 01873 01874 MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2)); 01875 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd)); 01876 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807)); 01877 MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962)); 01878 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352)); 01879 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245)); 01880 MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284)); 01881 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad)); 01882 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890)); 01883 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779)); 01884 MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e)); 01885 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5)); 01886 01887 x[5] = MAD_F_MLZ(hi, lo); 01888 x[12] = -x[5]; 01889 01890 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad)); 01891 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779)); 01892 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245)); 01893 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5)); 01894 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962)); 01895 MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e)); 01896 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd)); 01897 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890)); 01898 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2)); 01899 MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284)); 01900 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807)); 01901 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352)); 01902 01903 x[0] = MAD_F_MLZ(hi, lo) + t2; 01904 x[17] = -x[0]; 01905 01906 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890)); 01907 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284)); 01908 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e)); 01909 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352)); 01910 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5)); 01911 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807)); 01912 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779)); 01913 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2)); 01914 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad)); 01915 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd)); 01916 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245)); 01917 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962)); 01918 01919 x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2; 01920 01921 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2)); 01922 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0)); 01923 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346)); 01924 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549)); 01925 01926 t3 = MAD_F_MLZ(hi, lo) + t7; 01927 01928 MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e)); 01929 MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962)); 01930 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2)); 01931 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284)); 01932 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779)); 01933 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad)); 01934 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352)); 01935 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807)); 01936 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245)); 01937 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5)); 01938 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890)); 01939 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd)); 01940 01941 x[8] = MAD_F_MLZ(hi, lo) + t3; 01942 x[9] = -x[8]; 01943 01944 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245)); 01945 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352)); 01946 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890)); 01947 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779)); 01948 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd)); 01949 MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2)); 01950 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5)); 01951 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e)); 01952 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807)); 01953 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962)); 01954 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad)); 01955 MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284)); 01956 01957 x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3; 01958 01959 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807)); 01960 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5)); 01961 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad)); 01962 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd)); 01963 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284)); 01964 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890)); 01965 MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962)); 01966 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245)); 01967 MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e)); 01968 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352)); 01969 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2)); 01970 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779)); 01971 01972 x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3; 01973 01974 MAD_F_ML0(hi, lo, t14, -MAD_F(0x0ec835e8)); 01975 MAD_F_MLA(hi, lo, t15, MAD_F(0x061f78aa)); 01976 01977 t4 = MAD_F_MLZ(hi, lo) - t7; 01978 01979 MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa)); 01980 MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8)); 01981 01982 x[4] = MAD_F_MLZ(hi, lo) + t4; 01983 x[13] = -x[4]; 01984 01985 MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0)); 01986 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2)); 01987 MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549)); 01988 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346)); 01989 01990 x[1] = MAD_F_MLZ(hi, lo) + t4; 01991 x[16] = -x[1]; 01992 01993 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549)); 01994 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346)); 01995 MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0)); 01996 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2)); 01997 01998 x[25] = x[28] = MAD_F_MLZ(hi, lo) + t4; 01999 02000 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549)); 02001 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346)); 02002 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0)); 02003 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2)); 02004 02005 t5 = MAD_F_MLZ(hi, lo) - t6; 02006 02007 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779)); 02008 MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2)); 02009 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352)); 02010 MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e)); 02011 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245)); 02012 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962)); 02013 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890)); 02014 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284)); 02015 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd)); 02016 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad)); 02017 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5)); 02018 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807)); 02019 02020 x[2] = MAD_F_MLZ(hi, lo) + t5; 02021 x[15] = -x[2]; 02022 02023 MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284)); 02024 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad)); 02025 MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962)); 02026 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807)); 02027 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e)); 02028 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5)); 02029 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2)); 02030 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd)); 02031 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779)); 02032 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890)); 02033 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352)); 02034 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245)); 02035 02036 x[3] = MAD_F_MLZ(hi, lo) + t5; 02037 x[14] = -x[3]; 02038 02039 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd)); 02040 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890)); 02041 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5)); 02042 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245)); 02043 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807)); 02044 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352)); 02045 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad)); 02046 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779)); 02047 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284)); 02048 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2)); 02049 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962)); 02050 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e)); 02051 02052 x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5; 02053 } 02054 # endif 02055 02056 /* 02057 * NAME: III_imdct_l() 02058 * DESCRIPTION: perform IMDCT and windowing for long blocks 02059 */ 02060 static 02061 void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36], 02062 unsigned int block_type) 02063 { 02064 unsigned int i; 02065 02066 /* IMDCT */ 02067 02068 imdct36(X, z); 02069 02070 /* windowing */ 02071 02072 switch (block_type) { 02073 case 0: /* normal window */ 02074 # if defined(ASO_INTERLEAVE1) 02075 { 02076 register mad_fixed_t tmp1, tmp2; 02077 02078 tmp1 = window_l[0]; 02079 tmp2 = window_l[1]; 02080 02081 for (i = 0; i < 34; i += 2) { 02082 z[i + 0] = mad_f_mul(z[i + 0], tmp1); 02083 tmp1 = window_l[i + 2]; 02084 z[i + 1] = mad_f_mul(z[i + 1], tmp2); 02085 tmp2 = window_l[i + 3]; 02086 } 02087 02088 z[34] = mad_f_mul(z[34], tmp1); 02089 z[35] = mad_f_mul(z[35], tmp2); 02090 } 02091 # elif defined(ASO_INTERLEAVE2) 02092 { 02093 register mad_fixed_t tmp1, tmp2; 02094 02095 tmp1 = z[0]; 02096 tmp2 = window_l[0]; 02097 02098 for (i = 0; i < 35; ++i) { 02099 z[i] = mad_f_mul(tmp1, tmp2); 02100 tmp1 = z[i + 1]; 02101 tmp2 = window_l[i + 1]; 02102 } 02103 02104 z[35] = mad_f_mul(tmp1, tmp2); 02105 } 02106 # elif 1 02107 for (i = 0; i < 36; i += 4) { 02108 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); 02109 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); 02110 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); 02111 z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]); 02112 } 02113 # else 02114 for (i = 0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]); 02115 # endif 02116 break; 02117 02118 case 1: /* start block */ 02119 for (i = 0; i < 18; i += 3) { 02120 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); 02121 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); 02122 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); 02123 } 02124 /* (i = 18; i < 24; ++i) z[i] unchanged */ 02125 for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]); 02126 for (i = 30; i < 36; ++i) z[i] = 0; 02127 break; 02128 02129 case 3: /* stop block */ 02130 for (i = 0; i < 6; ++i) z[i] = 0; 02131 for (i = 6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]); 02132 /* (i = 12; i < 18; ++i) z[i] unchanged */ 02133 for (i = 18; i < 36; i += 3) { 02134 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); 02135 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); 02136 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); 02137 } 02138 break; 02139 } 02140 } 02141 # endif /* ASO_IMDCT */ 02142 02143 /* 02144 * NAME: III_imdct_s() 02145 * DESCRIPTION: perform IMDCT and windowing for short blocks 02146 */ 02147 static 02148 void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36]) 02149 { 02150 mad_fixed_t y[36], *yptr; 02151 mad_fixed_t const *wptr; 02152 int w, i; 02153 register mad_fixed64hi_t hi; 02154 register mad_fixed64lo_t lo; 02155 02156 /* IMDCT */ 02157 02158 yptr = &y[0]; 02159 02160 for (w = 0; w < 3; ++w) { 02161 register mad_fixed_t const (*s)[6]; 02162 02163 s = imdct_s; 02164 02165 for (i = 0; i < 3; ++i) { 02166 MAD_F_ML0(hi, lo, X[0], (*s)[0]); 02167 MAD_F_MLA(hi, lo, X[1], (*s)[1]); 02168 MAD_F_MLA(hi, lo, X[2], (*s)[2]); 02169 MAD_F_MLA(hi, lo, X[3], (*s)[3]); 02170 MAD_F_MLA(hi, lo, X[4], (*s)[4]); 02171 MAD_F_MLA(hi, lo, X[5], (*s)[5]); 02172 02173 yptr[i + 0] = MAD_F_MLZ(hi, lo); 02174 yptr[5 - i] = -yptr[i + 0]; 02175 02176 ++s; 02177 02178 MAD_F_ML0(hi, lo, X[0], (*s)[0]); 02179 MAD_F_MLA(hi, lo, X[1], (*s)[1]); 02180 MAD_F_MLA(hi, lo, X[2], (*s)[2]); 02181 MAD_F_MLA(hi, lo, X[3], (*s)[3]); 02182 MAD_F_MLA(hi, lo, X[4], (*s)[4]); 02183 MAD_F_MLA(hi, lo, X[5], (*s)[5]); 02184 02185 yptr[ i + 6] = MAD_F_MLZ(hi, lo); 02186 yptr[11 - i] = yptr[i + 6]; 02187 02188 ++s; 02189 } 02190 02191 yptr += 12; 02192 X += 6; 02193 } 02194 02195 /* windowing, overlapping and concatenation */ 02196 02197 yptr = &y[0]; 02198 wptr = &window_s[0]; 02199 02200 for (i = 0; i < 6; ++i) { 02201 z[i + 0] = 0; 02202 z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]); 02203 02204 MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]); 02205 MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]); 02206 02207 z[i + 12] = MAD_F_MLZ(hi, lo); 02208 02209 MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]); 02210 MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]); 02211 02212 z[i + 18] = MAD_F_MLZ(hi, lo); 02213 02214 z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]); 02215 z[i + 30] = 0; 02216 02217 ++yptr; 02218 ++wptr; 02219 } 02220 } 02221 02222 /* 02223 * NAME: III_overlap() 02224 * DESCRIPTION: perform overlap-add of windowed IMDCT outputs 02225 */ 02226 static 02227 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18], 02228 mad_fixed_t sample[18][32], unsigned int sb) 02229 { 02230 unsigned int i; 02231 02232 # if defined(ASO_INTERLEAVE2) 02233 { 02234 register mad_fixed_t tmp1, tmp2; 02235 02236 tmp1 = overlap[0]; 02237 tmp2 = overlap[1]; 02238 02239 for (i = 0; i < 16; i += 2) { 02240 sample[i + 0][sb] = output[i + 0 + 0] + tmp1; 02241 overlap[i + 0] = output[i + 0 + 18]; 02242 tmp1 = overlap[i + 2]; 02243 02244 sample[i + 1][sb] = output[i + 1 + 0] + tmp2; 02245 overlap[i + 1] = output[i + 1 + 18]; 02246 tmp2 = overlap[i + 3]; 02247 } 02248 02249 sample[16][sb] = output[16 + 0] + tmp1; 02250 overlap[16] = output[16 + 18]; 02251 sample[17][sb] = output[17 + 0] + tmp2; 02252 overlap[17] = output[17 + 18]; 02253 } 02254 # elif 0 02255 for (i = 0; i < 18; i += 2) { 02256 sample[i + 0][sb] = output[i + 0 + 0] + overlap[i + 0]; 02257 overlap[i + 0] = output[i + 0 + 18]; 02258 02259 sample[i + 1][sb] = output[i + 1 + 0] + overlap[i + 1]; 02260 overlap[i + 1] = output[i + 1 + 18]; 02261 } 02262 # else 02263 for (i = 0; i < 18; ++i) { 02264 sample[i][sb] = output[i + 0] + overlap[i]; 02265 overlap[i] = output[i + 18]; 02266 } 02267 # endif 02268 } 02269 02270 /* 02271 * NAME: III_overlap_z() 02272 * DESCRIPTION: perform "overlap-add" of zero IMDCT outputs 02273 */ 02274 static inline 02275 void III_overlap_z(mad_fixed_t overlap[18], 02276 mad_fixed_t sample[18][32], unsigned int sb) 02277 { 02278 unsigned int i; 02279 02280 # if defined(ASO_INTERLEAVE2) 02281 { 02282 register mad_fixed_t tmp1, tmp2; 02283 02284 tmp1 = overlap[0]; 02285 tmp2 = overlap[1]; 02286 02287 for (i = 0; i < 16; i += 2) { 02288 sample[i + 0][sb] = tmp1; 02289 overlap[i + 0] = 0; 02290 tmp1 = overlap[i + 2]; 02291 02292 sample[i + 1][sb] = tmp2; 02293 overlap[i + 1] = 0; 02294 tmp2 = overlap[i + 3]; 02295 } 02296 02297 sample[16][sb] = tmp1; 02298 overlap[16] = 0; 02299 sample[17][sb] = tmp2; 02300 overlap[17] = 0; 02301 } 02302 # else 02303 for (i = 0; i < 18; ++i) { 02304 sample[i][sb] = overlap[i]; 02305 overlap[i] = 0; 02306 } 02307 # endif 02308 } 02309 02310 /* 02311 * NAME: III_freqinver() 02312 * DESCRIPTION: perform subband frequency inversion for odd sample lines 02313 */ 02314 static 02315 void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb) 02316 { 02317 unsigned int i; 02318 02319 # if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2) 02320 { 02321 register mad_fixed_t tmp1, tmp2; 02322 02323 tmp1 = sample[1][sb]; 02324 tmp2 = sample[3][sb]; 02325 02326 for (i = 1; i < 13; i += 4) { 02327 sample[i + 0][sb] = -tmp1; 02328 tmp1 = sample[i + 4][sb]; 02329 sample[i + 2][sb] = -tmp2; 02330 tmp2 = sample[i + 6][sb]; 02331 } 02332 02333 sample[13][sb] = -tmp1; 02334 tmp1 = sample[17][sb]; 02335 sample[15][sb] = -tmp2; 02336 sample[17][sb] = -tmp1; 02337 } 02338 # else 02339 for (i = 1; i < 18; i += 2) 02340 sample[i][sb] = -sample[i][sb]; 02341 # endif 02342 } 02343 02344 /* 02345 * NAME: III_decode() 02346 * DESCRIPTION: decode frame main_data 02347 */ 02348 static 02349 enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame, 02350 struct sideinfo *si, unsigned int nch) 02351 { 02352 struct mad_header *header = &frame->header; 02353 unsigned int sfreqi, ngr, gr; 02354 02355 { 02356 unsigned int sfreq; 02357 02358 sfreq = header->samplerate; 02359 if (header->flags & MAD_FLAG_MPEG_2_5_EXT) 02360 sfreq *= 2; 02361 02362 /* 48000 => 0, 44100 => 1, 32000 => 2, 02363 24000 => 3, 22050 => 4, 16000 => 5 */ 02364 sfreqi = ((sfreq >> 7) & 0x000f) + 02365 ((sfreq >> 15) & 0x0001) - 8; 02366 02367 if (header->flags & MAD_FLAG_MPEG_2_5_EXT) 02368 sfreqi += 3; 02369 } 02370 02371 /* scalefactors, Huffman decoding, requantization */ 02372 02373 ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2; 02374 02375 for (gr = 0; gr < ngr; ++gr) { 02376 struct granule *granule = &si->gr[gr]; 02377 unsigned char const *sfbwidth[2]; 02378 mad_fixed_t xr[2][576]; 02379 unsigned int ch; 02380 enum mad_error error; 02381 02382 for (ch = 0; ch < nch; ++ch) { 02383 struct channel *channel = &granule->ch[ch]; 02384 unsigned int part2_length; 02385 02386 sfbwidth[ch] = sfbwidth_table[sfreqi].l; 02387 if (channel->block_type == 2) { 02388 sfbwidth[ch] = (channel->flags & mixed_block_flag) ? 02389 sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s; 02390 } 02391 02392 if (header->flags & MAD_FLAG_LSF_EXT) { 02393 part2_length = III_scalefactors_lsf(ptr, channel, 02394 ch == 0 ? 0 : &si->gr[1].ch[1], 02395 header->mode_extension); 02396 } 02397 else { 02398 part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch], 02399 gr == 0 ? 0 : si->scfsi[ch]); 02400 } 02401 02402 error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length); 02403 if (error) 02404 return error; 02405 } 02406 02407 /* joint stereo processing */ 02408 02409 if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) { 02410 error = III_stereo(xr, granule, header, sfbwidth[0]); 02411 if (error) 02412 return error; 02413 } 02414 02415 /* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */ 02416 02417 for (ch = 0; ch < nch; ++ch) { 02418 struct channel const *channel = &granule->ch[ch]; 02419 mad_fixed_t (*sample)[32] = &frame->sbsample[ch][18 * gr]; 02420 unsigned int sb, l, i, sblimit; 02421 mad_fixed_t output[36]; 02422 02423 if (channel->block_type == 2) { 02424 III_reorder(xr[ch], channel, sfbwidth[ch]); 02425 02426 # if !defined(OPT_STRICT) 02427 /* 02428 * According to ISO/IEC 11172-3, "Alias reduction is not applied for 02429 * granules with block_type == 2 (short block)." However, other 02430 * sources suggest alias reduction should indeed be performed on the 02431 * lower two subbands of mixed blocks. Most other implementations do 02432 * this, so by default we will too. 02433 */ 02434 if (channel->flags & mixed_block_flag) 02435 III_aliasreduce(xr[ch], 36); 02436 # endif 02437 } 02438 else 02439 III_aliasreduce(xr[ch], 576); 02440 02441 l = 0; 02442 02443 /* subbands 0-1 */ 02444 02445 if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) { 02446 unsigned int block_type; 02447 02448 block_type = channel->block_type; 02449 if (channel->flags & mixed_block_flag) 02450 block_type = 0; 02451 02452 /* long blocks */ 02453 for (sb = 0; sb < 2; ++sb, l += 18) { 02454 III_imdct_l(&xr[ch][l], output, block_type); 02455 III_overlap(output, (frame->overlap)[ch][sb], sample, sb); 02456 } 02457 } 02458 else { 02459 /* short blocks */ 02460 for (sb = 0; sb < 2; ++sb, l += 18) { 02461 III_imdct_s(&xr[ch][l], output); 02462 III_overlap(output, (frame->overlap)[ch][sb], sample, sb); 02463 } 02464 } 02465 02466 III_freqinver(sample, 1); 02467 02468 /* (nonzero) subbands 2-31 */ 02469 02470 i = 576; 02471 while (i > 36 && xr[ch][i - 1] == 0) 02472 --i; 02473 02474 sblimit = 32 - (576 - i) / 18; 02475 02476 if (channel->block_type != 2) { 02477 /* long blocks */ 02478 for (sb = 2; sb < sblimit; ++sb, l += 18) { 02479 III_imdct_l(&xr[ch][l], output, channel->block_type); 02480 III_overlap(output, (frame->overlap)[ch][sb], sample, sb); 02481 02482 if (sb & 1) 02483 III_freqinver(sample, sb); 02484 } 02485 } 02486 else { 02487 /* short blocks */ 02488 for (sb = 2; sb < sblimit; ++sb, l += 18) { 02489 III_imdct_s(&xr[ch][l], output); 02490 III_overlap(output, (frame->overlap)[ch][sb], sample, sb); 02491 02492 if (sb & 1) 02493 III_freqinver(sample, sb); 02494 } 02495 } 02496 02497 /* remaining (zero) subbands */ 02498 02499 for (sb = sblimit; sb < 32; ++sb) { 02500 III_overlap_z((frame->overlap)[ch][sb], sample, sb); 02501 02502 if (sb & 1) 02503 III_freqinver(sample, sb); 02504 } 02505 } 02506 } 02507 02508 return MAD_ERROR_NONE; 02509 } 02510 02511 /* 02512 * NAME: layer->III() 02513 * DESCRIPTION: decode a single Layer III frame 02514 */ 02515 int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame) 02516 { 02517 struct mad_header *header = &frame->header; 02518 unsigned int nch, priv_bitlen, next_md_begin = 0; 02519 unsigned int si_len, data_bitlen, md_len; 02520 unsigned int frame_space, frame_used, frame_free; 02521 struct mad_bitptr ptr; 02522 struct sideinfo si; 02523 enum mad_error error; 02524 int result = 0; 02525 02526 /* allocate Layer III dynamic structures */ 02527 02528 if (stream->main_data == 0) { 02529 #if defined(TARGET_LPC1768) 02530 stream->main_data = (unsigned char (*)[MAD_BUFFER_MDLEN])mad_malloc(MAD_BUFFER_MDLEN); 02531 #else 02532 stream->main_data = (unsigned char (*)[MAD_BUFFER_MDLEN])malloc(MAD_BUFFER_MDLEN); 02533 #endif 02534 if (stream->main_data == 0) { 02535 stream->error = MAD_ERROR_NOMEM; 02536 return -1; 02537 } 02538 } 02539 02540 nch = MAD_NCHANNELS(header); 02541 si_len = (header->flags & MAD_FLAG_LSF_EXT) ? 02542 (nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32); 02543 02544 /* check frame sanity */ 02545 02546 if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) < 02547 (signed int) si_len) { 02548 stream->error = MAD_ERROR_BADFRAMELEN; 02549 stream->md_len = 0; 02550 return -1; 02551 } 02552 02553 /* check CRC word */ 02554 02555 if (header->flags & MAD_FLAG_PROTECTION) { 02556 header->crc_check = 02557 mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check); 02558 02559 if (header->crc_check != header->crc_target && 02560 !(frame->options & MAD_OPTION_IGNORECRC)) { 02561 stream->error = MAD_ERROR_BADCRC; 02562 result = -1; 02563 } 02564 } 02565 02566 /* decode frame side information */ 02567 02568 error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT, 02569 &si, &data_bitlen, &priv_bitlen); 02570 if (error && result == 0) { 02571 stream->error = error; 02572 result = -1; 02573 } 02574 02575 header->flags |= priv_bitlen; 02576 header->private_bits |= si.private_bits; 02577 02578 /* find main_data of next frame */ 02579 02580 { 02581 struct mad_bitptr peek; 02582 unsigned long header; 02583 02584 mad_bit_init(&peek, stream->next_frame); 02585 02586 header = mad_bit_read(&peek, 32); 02587 if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) { 02588 if (!(header & 0x00010000L)) /* protection_bit */ 02589 mad_bit_skip(&peek, 16); /* crc_check */ 02590 02591 next_md_begin = 02592 mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8); 02593 } 02594 02595 mad_bit_finish(&peek); 02596 } 02597 02598 /* find main_data of this frame */ 02599 02600 frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr); 02601 02602 if (next_md_begin > si.main_data_begin + frame_space) 02603 next_md_begin = 0; 02604 02605 md_len = si.main_data_begin + frame_space - next_md_begin; 02606 02607 frame_used = 0; 02608 02609 if (si.main_data_begin == 0) { 02610 ptr = stream->ptr; 02611 stream->md_len = 0; 02612 02613 frame_used = md_len; 02614 } 02615 else { 02616 if (si.main_data_begin > stream->md_len) { 02617 if (result == 0) { 02618 stream->error = MAD_ERROR_BADDATAPTR; 02619 result = -1; 02620 } 02621 } 02622 else { 02623 mad_bit_init(&ptr, 02624 *stream->main_data + stream->md_len - si.main_data_begin); 02625 02626 if (md_len > si.main_data_begin) { 02627 /*assert(stream->md_len + md_len -si.main_data_begin <= MAD_BUFFER_MDLEN); */ 02628 02629 memcpy(*stream->main_data + stream->md_len, 02630 mad_bit_nextbyte(&stream->ptr), 02631 frame_used = md_len - si.main_data_begin); 02632 stream->md_len += frame_used; 02633 } 02634 } 02635 } 02636 02637 frame_free = frame_space - frame_used; 02638 02639 /* decode main_data */ 02640 02641 if (result == 0) { 02642 error = III_decode(&ptr, frame, &si, nch); 02643 if (error) { 02644 stream->error = error; 02645 result = -1; 02646 } 02647 02648 /* designate ancillary bits */ 02649 02650 stream->anc_ptr = ptr; 02651 stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen; 02652 } 02653 02654 # if 0 && defined(DEBUG) 02655 fprintf(stderr, 02656 "main_data_begin:%u, md_len:%u, frame_free:%u, " 02657 "data_bitlen:%u, anc_bitlen: %u\n", 02658 si.main_data_begin, md_len, frame_free, 02659 data_bitlen, stream->anc_bitlen); 02660 # endif 02661 02662 /* preload main_data buffer with up to 511 bytes for next frame(s) */ 02663 02664 if (frame_free >= next_md_begin) { 02665 memcpy(*stream->main_data, 02666 stream->next_frame - next_md_begin, next_md_begin); 02667 stream->md_len = next_md_begin; 02668 } 02669 else { 02670 if (md_len < si.main_data_begin) { 02671 unsigned int extra; 02672 02673 extra = si.main_data_begin - md_len; 02674 if (extra + frame_free > next_md_begin) 02675 extra = next_md_begin - frame_free; 02676 02677 if (extra < stream->md_len) { 02678 memmove(*stream->main_data, 02679 *stream->main_data + stream->md_len - extra, extra); 02680 stream->md_len = extra; 02681 } 02682 } 02683 else 02684 stream->md_len = 0; 02685 02686 memcpy(*stream->main_data + stream->md_len, 02687 stream->next_frame - frame_free, frame_free); 02688 stream->md_len += frame_free; 02689 } 02690 02691 return result; 02692 }
Generated on Tue Jul 12 2022 23:11:09 by
1.7.2