1 /* 2 * libmad - MPEG audio decoder library 3 * Copyright (C) 2000-2004 Underbit Technologies, Inc. 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 * $Id: layer3.c,v 1.43 2004/01/23 09:41:32 rob Exp $ 20 */ 21 22 # ifdef HAVE_CONFIG_H 23 # include "config.h" 24 # endif 25 26 # include "global.h" 27 28 # include "fixed.h" 29 # include "bit.h" 30 # include "stream.h" 31 # include "frame.h" 32 # include "huffman.h" 33 # include "layer3.h" 34 35 #define CHAR_BIT 8 /* duh */ 36 37 /* --- Layer III ----------------------------------------------------------- */ 38 39 enum { 40 count1table_select = 0x01, 41 scalefac_scale = 0x02, 42 preflag = 0x04, 43 mixed_block_flag = 0x08 44 }; 45 46 enum { 47 I_STEREO = 0x1, 48 MS_STEREO = 0x2 49 }; 50 51 struct sideinfo { 52 unsigned int main_data_begin; 53 unsigned int private_bits; 54 55 unsigned char scfsi[2]; 56 57 struct granule { 58 struct channel { 59 /* from side info */ 60 unsigned short part2_3_length; 61 unsigned short big_values; 62 unsigned short global_gain; 63 unsigned short scalefac_compress; 64 65 unsigned char flags; 66 unsigned char block_type; 67 unsigned char table_select[3]; 68 unsigned char subblock_gain[3]; 69 unsigned char region0_count; 70 unsigned char region1_count; 71 72 /* from main_data */ 73 unsigned char scalefac[39]; /* scalefac_l and/or scalefac_s */ 74 } ch[2]; 75 } gr[2]; 76 }; 77 78 /* 79 * scalefactor bit lengths 80 * derived from section 2.4.2.7 of ISO/IEC 11172-3 81 */ 82 static 83 struct { 84 unsigned char slen1; 85 unsigned char slen2; 86 } const sflen_table[16] = { 87 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 }, 88 { 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }, 89 { 2, 1 }, { 2, 2 }, { 2, 3 }, { 3, 1 }, 90 { 3, 2 }, { 3, 3 }, { 4, 2 }, { 4, 3 } 91 }; 92 93 /* 94 * number of LSF scalefactor band values 95 * derived from section 2.4.3.2 of ISO/IEC 13818-3 96 */ 97 static 98 unsigned char const nsfb_table[6][3][4] = { 99 { { 6, 5, 5, 5 }, 100 { 9, 9, 9, 9 }, 101 { 6, 9, 9, 9 } }, 102 103 { { 6, 5, 7, 3 }, 104 { 9, 9, 12, 6 }, 105 { 6, 9, 12, 6 } }, 106 107 { { 11, 10, 0, 0 }, 108 { 18, 18, 0, 0 }, 109 { 15, 18, 0, 0 } }, 110 111 { { 7, 7, 7, 0 }, 112 { 12, 12, 12, 0 }, 113 { 6, 15, 12, 0 } }, 114 115 { { 6, 6, 6, 3 }, 116 { 12, 9, 9, 6 }, 117 { 6, 12, 9, 6 } }, 118 119 { { 8, 8, 5, 0 }, 120 { 15, 12, 9, 0 }, 121 { 6, 18, 9, 0 } } 122 }; 123 124 /* 125 * MPEG-1 scalefactor band widths 126 * derived from Table B.8 of ISO/IEC 11172-3 127 */ 128 static 129 unsigned char const sfb_48000_long[] = { 130 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 131 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192 132 }; 133 134 static 135 unsigned char const sfb_44100_long[] = { 136 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 137 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158 138 }; 139 140 static 141 unsigned char const sfb_32000_long[] = { 142 4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 143 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26 144 }; 145 146 static 147 unsigned char const sfb_48000_short[] = { 148 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 149 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14, 150 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66 151 }; 152 153 static 154 unsigned char const sfb_44100_short[] = { 155 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 156 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 157 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56 158 }; 159 160 static 161 unsigned char const sfb_32000_short[] = { 162 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 163 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20, 164 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12 165 }; 166 167 static 168 unsigned char const sfb_48000_mixed[] = { 169 /* long */ 4, 4, 4, 4, 4, 4, 6, 6, 170 /* short */ 4, 4, 4, 6, 6, 6, 6, 6, 6, 10, 171 10, 10, 12, 12, 12, 14, 14, 14, 16, 16, 172 16, 20, 20, 20, 26, 26, 26, 66, 66, 66 173 }; 174 175 static 176 unsigned char const sfb_44100_mixed[] = { 177 /* long */ 4, 4, 4, 4, 4, 4, 6, 6, 178 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 179 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 180 18, 22, 22, 22, 30, 30, 30, 56, 56, 56 181 }; 182 183 static 184 unsigned char const sfb_32000_mixed[] = { 185 /* long */ 4, 4, 4, 4, 4, 4, 6, 6, 186 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 12, 187 12, 12, 16, 16, 16, 20, 20, 20, 26, 26, 188 26, 34, 34, 34, 42, 42, 42, 12, 12, 12 189 }; 190 191 /* 192 * MPEG-2 scalefactor band widths 193 * derived from Table B.2 of ISO/IEC 13818-3 194 */ 195 static 196 unsigned char const sfb_24000_long[] = { 197 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 198 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36 199 }; 200 201 static 202 unsigned char const sfb_22050_long[] = { 203 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 204 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54 205 }; 206 207 # define sfb_16000_long sfb_22050_long 208 209 static 210 unsigned char const sfb_24000_short[] = { 211 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 212 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 213 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12 214 }; 215 216 static 217 unsigned char const sfb_22050_short[] = { 218 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6, 219 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18, 220 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18 221 }; 222 223 static 224 unsigned char const sfb_16000_short[] = { 225 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 226 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18, 227 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18 228 }; 229 230 static 231 unsigned char const sfb_24000_mixed[] = { 232 /* long */ 6, 6, 6, 6, 6, 6, 233 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 234 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 235 24, 32, 32, 32, 44, 44, 44, 12, 12, 12 236 }; 237 238 static 239 unsigned char const sfb_22050_mixed[] = { 240 /* long */ 6, 6, 6, 6, 6, 6, 241 /* short */ 6, 6, 6, 6, 6, 6, 8, 8, 8, 10, 242 10, 10, 14, 14, 14, 18, 18, 18, 26, 26, 243 26, 32, 32, 32, 42, 42, 42, 18, 18, 18 244 }; 245 246 static 247 unsigned char const sfb_16000_mixed[] = { 248 /* long */ 6, 6, 6, 6, 6, 6, 249 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12, 250 12, 12, 14, 14, 14, 18, 18, 18, 24, 24, 251 24, 30, 30, 30, 40, 40, 40, 18, 18, 18 252 }; 253 254 /* 255 * MPEG 2.5 scalefactor band widths 256 * derived from public sources 257 */ 258 # define sfb_12000_long sfb_16000_long 259 # define sfb_11025_long sfb_12000_long 260 261 static 262 unsigned char const sfb_8000_long[] = { 263 12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 264 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2 265 }; 266 267 # define sfb_12000_short sfb_16000_short 268 # define sfb_11025_short sfb_12000_short 269 270 static 271 unsigned char const sfb_8000_short[] = { 272 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16, 273 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 274 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26 275 }; 276 277 # define sfb_12000_mixed sfb_16000_mixed 278 # define sfb_11025_mixed sfb_12000_mixed 279 280 /* the 8000 Hz short block scalefactor bands do not break after 281 the first 36 frequency lines, so this is probably wrong */ 282 static 283 unsigned char const sfb_8000_mixed[] = { 284 /* long */ 12, 12, 12, 285 /* short */ 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16, 286 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36, 287 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26 288 }; 289 290 static 291 struct { 292 unsigned char const *l; 293 unsigned char const *s; 294 unsigned char const *m; 295 } const sfbwidth_table[9] = { 296 { sfb_48000_long, sfb_48000_short, sfb_48000_mixed }, 297 { sfb_44100_long, sfb_44100_short, sfb_44100_mixed }, 298 { sfb_32000_long, sfb_32000_short, sfb_32000_mixed }, 299 { sfb_24000_long, sfb_24000_short, sfb_24000_mixed }, 300 { sfb_22050_long, sfb_22050_short, sfb_22050_mixed }, 301 { sfb_16000_long, sfb_16000_short, sfb_16000_mixed }, 302 { sfb_12000_long, sfb_12000_short, sfb_12000_mixed }, 303 { sfb_11025_long, sfb_11025_short, sfb_11025_mixed }, 304 { sfb_8000_long, sfb_8000_short, sfb_8000_mixed } 305 }; 306 307 /* 308 * scalefactor band preemphasis (used only when preflag is set) 309 * derived from Table B.6 of ISO/IEC 11172-3 310 */ 311 static 312 unsigned char const pretab[22] = { 313 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 314 }; 315 316 /* 317 * table for requantization 318 * 319 * rq_table[x].mantissa * 2^(rq_table[x].exponent) = x^(4/3) 320 */ 321 static 322 struct fixedfloat { 323 unsigned long mantissa; // : 27; 324 unsigned short exponent; // : 5; 325 } const rq_table[8207] = { 326 # include "rq_table.dat" 327 }; 328 329 /* 330 * fractional powers of two 331 * used for requantization and joint stereo decoding 332 * 333 * root_table[3 + x] = 2^(x/4) 334 */ 335 static 336 mad_fixed_t const root_table[7] = { 337 MAD_F(0x09837f05) /* 2^(-3/4) == 0.59460355750136 */, 338 MAD_F(0x0b504f33) /* 2^(-2/4) == 0.70710678118655 */, 339 MAD_F(0x0d744fcd) /* 2^(-1/4) == 0.84089641525371 */, 340 MAD_F(0x10000000) /* 2^( 0/4) == 1.00000000000000 */, 341 MAD_F(0x1306fe0a) /* 2^(+1/4) == 1.18920711500272 */, 342 MAD_F(0x16a09e66) /* 2^(+2/4) == 1.41421356237310 */, 343 MAD_F(0x1ae89f99) /* 2^(+3/4) == 1.68179283050743 */ 344 }; 345 346 /* 347 * coefficients for aliasing reduction 348 * derived from Table B.9 of ISO/IEC 11172-3 349 * 350 * c[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 } 351 * cs[i] = 1 / sqrt(1 + c[i]^2) 352 * ca[i] = c[i] / sqrt(1 + c[i]^2) 353 */ 354 static 355 mad_fixed_t const cs[8] = { 356 +MAD_F(0x0db84a81) /* +0.857492926 */, +MAD_F(0x0e1b9d7f) /* +0.881741997 */, 357 +MAD_F(0x0f31adcf) /* +0.949628649 */, +MAD_F(0x0fbba815) /* +0.983314592 */, 358 +MAD_F(0x0feda417) /* +0.995517816 */, +MAD_F(0x0ffc8fc8) /* +0.999160558 */, 359 +MAD_F(0x0fff964c) /* +0.999899195 */, +MAD_F(0x0ffff8d3) /* +0.999993155 */ 360 }; 361 362 static 363 mad_fixed_t const ca[8] = { 364 -MAD_F(0x083b5fe7) /* -0.514495755 */, -MAD_F(0x078c36d2) /* -0.471731969 */, 365 -MAD_F(0x05039814) /* -0.313377454 */, -MAD_F(0x02e91dd1) /* -0.181913200 */, 366 -MAD_F(0x0183603a) /* -0.094574193 */, -MAD_F(0x00a7cb87) /* -0.040965583 */, 367 -MAD_F(0x003a2847) /* -0.014198569 */, -MAD_F(0x000f27b4) /* -0.003699975 */ 368 }; 369 370 /* 371 * IMDCT coefficients for short blocks 372 * derived from section 2.4.3.4.10.2 of ISO/IEC 11172-3 373 * 374 * imdct_s[i/even][k] = cos((PI / 24) * (2 * (i / 2) + 7) * (2 * k + 1)) 375 * imdct_s[i /odd][k] = cos((PI / 24) * (2 * (6 + (i-1)/2) + 7) * (2 * k + 1)) 376 */ 377 static 378 mad_fixed_t const imdct_s[6][6] = { 379 # include "imdct_s.dat" 380 }; 381 382 # if !defined(ASO_IMDCT) 383 /* 384 * windowing coefficients for long blocks 385 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3 386 * 387 * window_l[i] = sin((PI / 36) * (i + 1/2)) 388 */ 389 static 390 mad_fixed_t const window_l[36] = { 391 MAD_F(0x00b2aa3e) /* 0.043619387 */, MAD_F(0x0216a2a2) /* 0.130526192 */, 392 MAD_F(0x03768962) /* 0.216439614 */, MAD_F(0x04cfb0e2) /* 0.300705800 */, 393 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x07635284) /* 0.461748613 */, 394 MAD_F(0x0898c779) /* 0.537299608 */, MAD_F(0x09bd7ca0) /* 0.608761429 */, 395 MAD_F(0x0acf37ad) /* 0.675590208 */, MAD_F(0x0bcbe352) /* 0.737277337 */, 396 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x0d7e8807) /* 0.843391446 */, 397 398 MAD_F(0x0e313245) /* 0.887010833 */, MAD_F(0x0ec835e8) /* 0.923879533 */, 399 MAD_F(0x0f426cb5) /* 0.953716951 */, MAD_F(0x0f9ee890) /* 0.976296007 */, 400 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ffc19fd) /* 0.999048222 */, 401 MAD_F(0x0ffc19fd) /* 0.999048222 */, MAD_F(0x0fdcf549) /* 0.991444861 */, 402 MAD_F(0x0f9ee890) /* 0.976296007 */, MAD_F(0x0f426cb5) /* 0.953716951 */, 403 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0e313245) /* 0.887010833 */, 404 405 MAD_F(0x0d7e8807) /* 0.843391446 */, MAD_F(0x0cb19346) /* 0.793353340 */, 406 MAD_F(0x0bcbe352) /* 0.737277337 */, MAD_F(0x0acf37ad) /* 0.675590208 */, 407 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0898c779) /* 0.537299608 */, 408 MAD_F(0x07635284) /* 0.461748613 */, MAD_F(0x061f78aa) /* 0.382683432 */, 409 MAD_F(0x04cfb0e2) /* 0.300705800 */, MAD_F(0x03768962) /* 0.216439614 */, 410 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x00b2aa3e) /* 0.043619387 */, 411 }; 412 # endif /* ASO_IMDCT */ 413 414 /* 415 * windowing coefficients for short blocks 416 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3 417 * 418 * window_s[i] = sin((PI / 12) * (i + 1/2)) 419 */ 420 static 421 mad_fixed_t const window_s[12] = { 422 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x061f78aa) /* 0.382683432 */, 423 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0cb19346) /* 0.793353340 */, 424 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0fdcf549) /* 0.991444861 */, 425 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ec835e8) /* 0.923879533 */, 426 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x09bd7ca0) /* 0.608761429 */, 427 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x0216a2a2) /* 0.130526192 */, 428 }; 429 430 /* 431 * coefficients for intensity stereo processing 432 * derived from section 2.4.3.4.9.3 of ISO/IEC 11172-3 433 * 434 * is_ratio[i] = tan(i * (PI / 12)) 435 * is_table[i] = is_ratio[i] / (1 + is_ratio[i]) 436 */ 437 static 438 mad_fixed_t const is_table[7] = { 439 MAD_F(0x00000000) /* 0.000000000 */, 440 MAD_F(0x0361962f) /* 0.211324865 */, 441 MAD_F(0x05db3d74) /* 0.366025404 */, 442 MAD_F(0x08000000) /* 0.500000000 */, 443 MAD_F(0x0a24c28c) /* 0.633974596 */, 444 MAD_F(0x0c9e69d1) /* 0.788675135 */, 445 MAD_F(0x10000000) /* 1.000000000 */ 446 }; 447 448 /* 449 * coefficients for LSF intensity stereo processing 450 * derived from section 2.4.3.2 of ISO/IEC 13818-3 451 * 452 * is_lsf_table[0][i] = (1 / sqrt(sqrt(2)))^(i + 1) 453 * is_lsf_table[1][i] = (1 / sqrt(2)) ^(i + 1) 454 */ 455 static 456 mad_fixed_t const is_lsf_table[2][15] = { 457 { 458 MAD_F(0x0d744fcd) /* 0.840896415 */, 459 MAD_F(0x0b504f33) /* 0.707106781 */, 460 MAD_F(0x09837f05) /* 0.594603558 */, 461 MAD_F(0x08000000) /* 0.500000000 */, 462 MAD_F(0x06ba27e6) /* 0.420448208 */, 463 MAD_F(0x05a8279a) /* 0.353553391 */, 464 MAD_F(0x04c1bf83) /* 0.297301779 */, 465 MAD_F(0x04000000) /* 0.250000000 */, 466 MAD_F(0x035d13f3) /* 0.210224104 */, 467 MAD_F(0x02d413cd) /* 0.176776695 */, 468 MAD_F(0x0260dfc1) /* 0.148650889 */, 469 MAD_F(0x02000000) /* 0.125000000 */, 470 MAD_F(0x01ae89fa) /* 0.105112052 */, 471 MAD_F(0x016a09e6) /* 0.088388348 */, 472 MAD_F(0x01306fe1) /* 0.074325445 */ 473 }, { 474 MAD_F(0x0b504f33) /* 0.707106781 */, 475 MAD_F(0x08000000) /* 0.500000000 */, 476 MAD_F(0x05a8279a) /* 0.353553391 */, 477 MAD_F(0x04000000) /* 0.250000000 */, 478 MAD_F(0x02d413cd) /* 0.176776695 */, 479 MAD_F(0x02000000) /* 0.125000000 */, 480 MAD_F(0x016a09e6) /* 0.088388348 */, 481 MAD_F(0x01000000) /* 0.062500000 */, 482 MAD_F(0x00b504f3) /* 0.044194174 */, 483 MAD_F(0x00800000) /* 0.031250000 */, 484 MAD_F(0x005a827a) /* 0.022097087 */, 485 MAD_F(0x00400000) /* 0.015625000 */, 486 MAD_F(0x002d413d) /* 0.011048543 */, 487 MAD_F(0x00200000) /* 0.007812500 */, 488 MAD_F(0x0016a09e) /* 0.005524272 */ 489 } 490 }; 491 492 /* 493 * NAME: III_sideinfo() 494 * DESCRIPTION: decode frame side information from a bitstream 495 */ 496 static 497 enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch, 498 int lsf, struct sideinfo *si, 499 unsigned int *data_bitlen, 500 unsigned int *priv_bitlen) 501 { 502 unsigned int ngr, gr, ch, i; 503 enum mad_error result = MAD_ERROR_NONE; 504 505 *data_bitlen = 0; 506 *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3); 507 508 si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9); 509 si->private_bits = mad_bit_read(ptr, *priv_bitlen); 510 511 ngr = 1; 512 if (!lsf) { 513 ngr = 2; 514 515 for (ch = 0; ch < nch; ++ch) 516 si->scfsi[ch] = mad_bit_read(ptr, 4); 517 } 518 519 for (gr = 0; gr < ngr; ++gr) { 520 struct granule *granule = &si->gr[gr]; 521 522 for (ch = 0; ch < nch; ++ch) { 523 struct channel *channel = &granule->ch[ch]; 524 525 channel->part2_3_length = mad_bit_read(ptr, 12); 526 channel->big_values = mad_bit_read(ptr, 9); 527 channel->global_gain = mad_bit_read(ptr, 8); 528 channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4); 529 530 *data_bitlen += channel->part2_3_length; 531 532 if (channel->big_values > 288 && result == 0) 533 result = MAD_ERROR_BADBIGVALUES; 534 535 channel->flags = 0; 536 537 /* window_switching_flag */ 538 if (mad_bit_read(ptr, 1)) { 539 channel->block_type = mad_bit_read(ptr, 2); 540 541 if (channel->block_type == 0 && result == 0) 542 result = MAD_ERROR_BADBLOCKTYPE; 543 544 if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0) 545 result = MAD_ERROR_BADSCFSI; 546 547 channel->region0_count = 7; 548 channel->region1_count = 36; 549 550 if (mad_bit_read(ptr, 1)) 551 channel->flags |= mixed_block_flag; 552 else if (channel->block_type == 2) 553 channel->region0_count = 8; 554 555 for (i = 0; i < 2; ++i) 556 channel->table_select[i] = mad_bit_read(ptr, 5); 557 558 # if defined(DEBUG) 559 channel->table_select[2] = 4; /* not used */ 560 # endif 561 562 for (i = 0; i < 3; ++i) 563 channel->subblock_gain[i] = mad_bit_read(ptr, 3); 564 } 565 else { 566 channel->block_type = 0; 567 568 for (i = 0; i < 3; ++i) 569 channel->table_select[i] = mad_bit_read(ptr, 5); 570 571 channel->region0_count = mad_bit_read(ptr, 4); 572 channel->region1_count = mad_bit_read(ptr, 3); 573 } 574 575 /* [preflag,] scalefac_scale, count1table_select */ 576 channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3); 577 } 578 } 579 580 return result; 581 } 582 583 /* 584 * NAME: III_scalefactors_lsf() 585 * DESCRIPTION: decode channel scalefactors for LSF from a bitstream 586 */ 587 static 588 unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr, 589 struct channel *channel, 590 struct channel *gr1ch, int mode_extension) 591 { 592 struct mad_bitptr start; 593 unsigned int scalefac_compress, index, slen[4], part, n, i; 594 unsigned char const *nsfb; 595 596 start = *ptr; 597 598 scalefac_compress = channel->scalefac_compress; 599 index = (channel->block_type == 2) ? 600 ((channel->flags & mixed_block_flag) ? 2 : 1) : 0; 601 602 if (!((mode_extension & I_STEREO) && gr1ch)) { 603 if (scalefac_compress < 400) { 604 slen[0] = (scalefac_compress >> 4) / 5; 605 slen[1] = (scalefac_compress >> 4) % 5; 606 slen[2] = (scalefac_compress % 16) >> 2; 607 slen[3] = scalefac_compress % 4; 608 609 nsfb = nsfb_table[0][index]; 610 } 611 else if (scalefac_compress < 500) { 612 scalefac_compress -= 400; 613 614 slen[0] = (scalefac_compress >> 2) / 5; 615 slen[1] = (scalefac_compress >> 2) % 5; 616 slen[2] = scalefac_compress % 4; 617 slen[3] = 0; 618 619 nsfb = nsfb_table[1][index]; 620 } 621 else { 622 scalefac_compress -= 500; 623 624 slen[0] = scalefac_compress / 3; 625 slen[1] = scalefac_compress % 3; 626 slen[2] = 0; 627 slen[3] = 0; 628 629 channel->flags |= preflag; 630 631 nsfb = nsfb_table[2][index]; 632 } 633 634 n = 0; 635 for (part = 0; part < 4; ++part) { 636 for (i = 0; i < nsfb[part]; ++i) 637 channel->scalefac[n++] = mad_bit_read(ptr, slen[part]); 638 } 639 640 while (n < 39) 641 channel->scalefac[n++] = 0; 642 } 643 else { /* (mode_extension & I_STEREO) && gr1ch (i.e. ch == 1) */ 644 scalefac_compress >>= 1; 645 646 if (scalefac_compress < 180) { 647 slen[0] = scalefac_compress / 36; 648 slen[1] = (scalefac_compress % 36) / 6; 649 slen[2] = (scalefac_compress % 36) % 6; 650 slen[3] = 0; 651 652 nsfb = nsfb_table[3][index]; 653 } 654 else if (scalefac_compress < 244) { 655 scalefac_compress -= 180; 656 657 slen[0] = (scalefac_compress % 64) >> 4; 658 slen[1] = (scalefac_compress % 16) >> 2; 659 slen[2] = scalefac_compress % 4; 660 slen[3] = 0; 661 662 nsfb = nsfb_table[4][index]; 663 } 664 else { 665 scalefac_compress -= 244; 666 667 slen[0] = scalefac_compress / 3; 668 slen[1] = scalefac_compress % 3; 669 slen[2] = 0; 670 slen[3] = 0; 671 672 nsfb = nsfb_table[5][index]; 673 } 674 675 n = 0; 676 for (part = 0; part < 4; ++part) { 677 unsigned int max, is_pos; 678 679 max = (1 << slen[part]) - 1; 680 681 for (i = 0; i < nsfb[part]; ++i) { 682 is_pos = mad_bit_read(ptr, slen[part]); 683 684 channel->scalefac[n] = is_pos; 685 gr1ch->scalefac[n++] = (is_pos == max); 686 } 687 } 688 689 while (n < 39) { 690 channel->scalefac[n] = 0; 691 gr1ch->scalefac[n++] = 0; /* apparently not illegal */ 692 } 693 } 694 695 return mad_bit_length(&start, ptr); 696 } 697 698 /* 699 * NAME: III_scalefactors() 700 * DESCRIPTION: decode channel scalefactors of one granule from a bitstream 701 */ 702 static 703 unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel, 704 struct channel const *gr0ch, unsigned int scfsi) 705 { 706 struct mad_bitptr start; 707 unsigned int slen1, slen2, sfbi; 708 709 start = *ptr; 710 711 slen1 = sflen_table[channel->scalefac_compress].slen1; 712 slen2 = sflen_table[channel->scalefac_compress].slen2; 713 714 if (channel->block_type == 2) { 715 unsigned int nsfb; 716 717 sfbi = 0; 718 719 nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3; 720 while (nsfb--) 721 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1); 722 723 nsfb = 6 * 3; 724 while (nsfb--) 725 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2); 726 727 nsfb = 1 * 3; 728 while (nsfb--) 729 channel->scalefac[sfbi++] = 0; 730 } 731 else { /* channel->block_type != 2 */ 732 if (scfsi & 0x8) { 733 for (sfbi = 0; sfbi < 6; ++sfbi) 734 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 735 } 736 else { 737 for (sfbi = 0; sfbi < 6; ++sfbi) 738 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1); 739 } 740 741 if (scfsi & 0x4) { 742 for (sfbi = 6; sfbi < 11; ++sfbi) 743 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 744 } 745 else { 746 for (sfbi = 6; sfbi < 11; ++sfbi) 747 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1); 748 } 749 750 if (scfsi & 0x2) { 751 for (sfbi = 11; sfbi < 16; ++sfbi) 752 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 753 } 754 else { 755 for (sfbi = 11; sfbi < 16; ++sfbi) 756 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2); 757 } 758 759 if (scfsi & 0x1) { 760 for (sfbi = 16; sfbi < 21; ++sfbi) 761 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi]; 762 } 763 else { 764 for (sfbi = 16; sfbi < 21; ++sfbi) 765 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2); 766 } 767 768 channel->scalefac[21] = 0; 769 } 770 771 return mad_bit_length(&start, ptr); 772 } 773 774 /* 775 * The Layer III formula for requantization and scaling is defined by 776 * section 2.4.3.4.7.1 of ISO/IEC 11172-3, as follows: 777 * 778 * long blocks: 779 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) * 780 * 2^((1/4) * (global_gain - 210)) * 781 * 2^-(scalefac_multiplier * 782 * (scalefac_l[sfb] + preflag * pretab[sfb])) 783 * 784 * short blocks: 785 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) * 786 * 2^((1/4) * (global_gain - 210 - 8 * subblock_gain[w])) * 787 * 2^-(scalefac_multiplier * scalefac_s[sfb][w]) 788 * 789 * where: 790 * scalefac_multiplier = (scalefac_scale + 1) / 2 791 * 792 * The routines III_exponents() and III_requantize() facilitate this 793 * calculation. 794 */ 795 796 /* 797 * NAME: III_exponents() 798 * DESCRIPTION: calculate scalefactor exponents 799 */ 800 static 801 void III_exponents(struct channel const *channel, 802 unsigned char const *sfbwidth, signed int exponents[39]) 803 { 804 signed int gain; 805 unsigned int scalefac_multiplier, sfbi; 806 807 gain = (signed int) channel->global_gain - 210; 808 scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1; 809 810 if (channel->block_type == 2) { 811 unsigned int l; 812 signed int gain0, gain1, gain2; 813 814 sfbi = l = 0; 815 816 if (channel->flags & mixed_block_flag) { 817 unsigned int premask; 818 819 premask = (channel->flags & preflag) ? ~0 : 0; 820 821 /* long block subbands 0-1 */ 822 823 while (l < 36) { 824 exponents[sfbi] = gain - 825 (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) << 826 scalefac_multiplier); 827 828 l += sfbwidth[sfbi++]; 829 } 830 } 831 832 /* this is probably wrong for 8000 Hz short/mixed blocks */ 833 834 gain0 = gain - 8 * (signed int) channel->subblock_gain[0]; 835 gain1 = gain - 8 * (signed int) channel->subblock_gain[1]; 836 gain2 = gain - 8 * (signed int) channel->subblock_gain[2]; 837 838 while (l < 576) { 839 exponents[sfbi + 0] = gain0 - 840 (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier); 841 exponents[sfbi + 1] = gain1 - 842 (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier); 843 exponents[sfbi + 2] = gain2 - 844 (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier); 845 846 l += 3 * sfbwidth[sfbi]; 847 sfbi += 3; 848 } 849 } 850 else { /* channel->block_type != 2 */ 851 if (channel->flags & preflag) { 852 for (sfbi = 0; sfbi < 22; ++sfbi) { 853 exponents[sfbi] = gain - 854 (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) << 855 scalefac_multiplier); 856 } 857 } 858 else { 859 for (sfbi = 0; sfbi < 22; ++sfbi) { 860 exponents[sfbi] = gain - 861 (signed int) (channel->scalefac[sfbi] << scalefac_multiplier); 862 } 863 } 864 } 865 } 866 867 /* 868 * NAME: III_requantize() 869 * DESCRIPTION: requantize one (positive) value 870 */ 871 static 872 mad_fixed_t III_requantize(unsigned int value, signed int exp) 873 { 874 mad_fixed_t requantized; 875 signed int frac; 876 struct fixedfloat const *power; 877 878 frac = exp % 4; /* assumes sign(frac) == sign(exp) */ 879 exp /= 4; 880 881 power = &rq_table[value]; 882 requantized = power->mantissa; 883 exp += power->exponent; 884 885 if (exp < 0) { 886 if (-exp >= sizeof(mad_fixed_t) * CHAR_BIT) { 887 /* underflow */ 888 requantized = 0; 889 } 890 else { 891 requantized += 1L << (-exp - 1); 892 requantized >>= -exp; 893 } 894 } 895 else { 896 if (exp >= 5) { 897 /* overflow */ 898 # if defined(DEBUG) 899 fprintf(stderr, "requantize overflow (%f * 2^%d)\n", 900 mad_f_todouble(requantized), exp); 901 # endif 902 requantized = MAD_F_MAX; 903 } 904 else 905 requantized <<= exp; 906 } 907 908 return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized; 909 } 910 911 /* we must take care that sz >= bits and sz < sizeof(long) lest bits == 0 */ 912 # define MASK(cache, sz, bits) \ 913 (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1)) 914 # define MASK1BIT(cache, sz) \ 915 ((cache) & (1 << ((sz) - 1))) 916 917 /* 918 * NAME: III_huffdecode() 919 * DESCRIPTION: decode Huffman code words of one channel of one granule 920 */ 921 static 922 enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576], 923 struct channel *channel, 924 unsigned char const *sfbwidth, 925 unsigned int part2_length) 926 { 927 signed int exponents[39], exp; 928 signed int const *expptr; 929 struct mad_bitptr peek; 930 signed int bits_left, cachesz; 931 register mad_fixed_t *xrptr; 932 mad_fixed_t const *sfbound; 933 register unsigned long bitcache; 934 935 bits_left = (signed) channel->part2_3_length - (signed) part2_length; 936 if (bits_left < 0) 937 return MAD_ERROR_BADPART3LEN; 938 939 III_exponents(channel, sfbwidth, exponents); 940 941 peek = *ptr; 942 mad_bit_skip(ptr, bits_left); 943 944 /* align bit reads to byte boundaries */ 945 cachesz = mad_bit_bitsleft(&peek); 946 cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7; 947 948 bitcache = mad_bit_read(&peek, cachesz); 949 bits_left -= cachesz; 950 951 xrptr = &xr[0]; 952 953 /* big_values */ 954 { 955 unsigned int region, rcount; 956 struct hufftable const *entry; 957 struct huffpair const *table; 958 unsigned int linbits, startbits, big_values, reqhits; 959 mad_fixed_t reqcache[16]; 960 961 sfbound = xrptr + *sfbwidth++; 962 rcount = channel->region0_count + 1; 963 964 entry = &mad_huff_pair_table[channel->table_select[region = 0]]; 965 table = entry->table; 966 linbits = entry->linbits; 967 startbits = entry->startbits; 968 969 if (table == 0) 970 return MAD_ERROR_BADHUFFTABLE; 971 972 expptr = &exponents[0]; 973 exp = *expptr++; 974 reqhits = 0; 975 976 big_values = channel->big_values; 977 978 while (big_values-- && cachesz + bits_left > 0) { 979 struct huffpair const *pair; 980 unsigned int clumpsz, value; 981 register mad_fixed_t requantized; 982 983 if (xrptr == sfbound) { 984 sfbound += *sfbwidth++; 985 986 /* change table if region boundary */ 987 988 if (--rcount == 0) { 989 if (region == 0) 990 rcount = channel->region1_count + 1; 991 else 992 rcount = 0; /* all remaining */ 993 994 entry = &mad_huff_pair_table[channel->table_select[++region]]; 995 table = entry->table; 996 linbits = entry->linbits; 997 startbits = entry->startbits; 998 999 if (table == 0) 1000 return MAD_ERROR_BADHUFFTABLE; 1001 } 1002 1003 if (exp != *expptr) { 1004 exp = *expptr; 1005 reqhits = 0; 1006 } 1007 1008 ++expptr; 1009 } 1010 1011 if (cachesz < 21) { 1012 unsigned int bits; 1013 1014 bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7; 1015 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits); 1016 cachesz += bits; 1017 bits_left -= bits; 1018 } 1019 1020 /* hcod (0..19) */ 1021 1022 clumpsz = startbits; 1023 pair = &table[MASK(bitcache, cachesz, clumpsz)]; 1024 1025 while (!pair->final) { 1026 cachesz -= clumpsz; 1027 1028 clumpsz = pair->ptr.bits; 1029 pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)]; 1030 } 1031 1032 cachesz -= pair->value.hlen; 1033 1034 if (linbits) { 1035 /* x (0..14) */ 1036 1037 value = pair->value.x; 1038 1039 switch (value) { 1040 case 0: 1041 xrptr[0] = 0; 1042 break; 1043 1044 case 15: 1045 if (cachesz < linbits + 2) { 1046 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 1047 cachesz += 16; 1048 bits_left -= 16; 1049 } 1050 1051 value += MASK(bitcache, cachesz, linbits); 1052 cachesz -= linbits; 1053 1054 requantized = III_requantize(value, exp); 1055 goto x_final; 1056 1057 default: 1058 if (reqhits & (1 << value)) 1059 requantized = reqcache[value]; 1060 else { 1061 reqhits |= (1 << value); 1062 requantized = reqcache[value] = III_requantize(value, exp); 1063 } 1064 1065 x_final: 1066 xrptr[0] = MASK1BIT(bitcache, cachesz--) ? 1067 -requantized : requantized; 1068 } 1069 1070 /* y (0..14) */ 1071 1072 value = pair->value.y; 1073 1074 switch (value) { 1075 case 0: 1076 xrptr[1] = 0; 1077 break; 1078 1079 case 15: 1080 if (cachesz < linbits + 1) { 1081 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 1082 cachesz += 16; 1083 bits_left -= 16; 1084 } 1085 1086 value += MASK(bitcache, cachesz, linbits); 1087 cachesz -= linbits; 1088 1089 requantized = III_requantize(value, exp); 1090 goto y_final; 1091 1092 default: 1093 if (reqhits & (1 << value)) 1094 requantized = reqcache[value]; 1095 else { 1096 reqhits |= (1 << value); 1097 requantized = reqcache[value] = III_requantize(value, exp); 1098 } 1099 1100 y_final: 1101 xrptr[1] = MASK1BIT(bitcache, cachesz--) ? 1102 -requantized : requantized; 1103 } 1104 } 1105 else { 1106 /* x (0..1) */ 1107 1108 value = pair->value.x; 1109 1110 if (value == 0) 1111 xrptr[0] = 0; 1112 else { 1113 if (reqhits & (1 << value)) 1114 requantized = reqcache[value]; 1115 else { 1116 reqhits |= (1 << value); 1117 requantized = reqcache[value] = III_requantize(value, exp); 1118 } 1119 1120 xrptr[0] = MASK1BIT(bitcache, cachesz--) ? 1121 -requantized : requantized; 1122 } 1123 1124 /* y (0..1) */ 1125 1126 value = pair->value.y; 1127 1128 if (value == 0) 1129 xrptr[1] = 0; 1130 else { 1131 if (reqhits & (1 << value)) 1132 requantized = reqcache[value]; 1133 else { 1134 reqhits |= (1 << value); 1135 requantized = reqcache[value] = III_requantize(value, exp); 1136 } 1137 1138 xrptr[1] = MASK1BIT(bitcache, cachesz--) ? 1139 -requantized : requantized; 1140 } 1141 } 1142 1143 xrptr += 2; 1144 } 1145 } 1146 1147 if (cachesz + bits_left < 0) 1148 return MAD_ERROR_BADHUFFDATA; /* big_values overrun */ 1149 1150 /* count1 */ 1151 { 1152 struct huffquad const *table; 1153 register mad_fixed_t requantized; 1154 1155 table = mad_huff_quad_table[channel->flags & count1table_select]; 1156 1157 requantized = III_requantize(1, exp); 1158 1159 while (cachesz + bits_left > 0 && xrptr <= &xr[572]) { 1160 struct huffquad const *quad; 1161 1162 /* hcod (1..6) */ 1163 1164 if (cachesz < 10) { 1165 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 1166 cachesz += 16; 1167 bits_left -= 16; 1168 } 1169 1170 quad = &table[MASK(bitcache, cachesz, 4)]; 1171 1172 /* quad tables guaranteed to have at most one extra lookup */ 1173 if (!quad->final) { 1174 cachesz -= 4; 1175 1176 quad = &table[quad->ptr.offset + 1177 MASK(bitcache, cachesz, quad->ptr.bits)]; 1178 } 1179 1180 cachesz -= quad->value.hlen; 1181 1182 if (xrptr == sfbound) { 1183 sfbound += *sfbwidth++; 1184 1185 if (exp != *expptr) { 1186 exp = *expptr; 1187 requantized = III_requantize(1, exp); 1188 } 1189 1190 ++expptr; 1191 } 1192 1193 /* v (0..1) */ 1194 1195 xrptr[0] = quad->value.v ? 1196 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 1197 1198 /* w (0..1) */ 1199 1200 xrptr[1] = quad->value.w ? 1201 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 1202 1203 xrptr += 2; 1204 1205 if (xrptr == sfbound) { 1206 sfbound += *sfbwidth++; 1207 1208 if (exp != *expptr) { 1209 exp = *expptr; 1210 requantized = III_requantize(1, exp); 1211 } 1212 1213 ++expptr; 1214 } 1215 1216 /* x (0..1) */ 1217 1218 xrptr[0] = quad->value.x ? 1219 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 1220 1221 /* y (0..1) */ 1222 1223 xrptr[1] = quad->value.y ? 1224 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; 1225 1226 xrptr += 2; 1227 } 1228 1229 if (cachesz + bits_left < 0) { 1230 # if 0 && defined(DEBUG) 1231 fprintf(stderr, "huffman count1 overrun (%d bits)\n", 1232 -(cachesz + bits_left)); 1233 # endif 1234 1235 /* technically the bitstream is misformatted, but apparently 1236 some encoders are just a bit sloppy with stuffing bits */ 1237 1238 xrptr -= 4; 1239 } 1240 } 1241 1242 assert(-bits_left <= MAD_BUFFER_GUARD * CHAR_BIT); 1243 1244 # if 0 && defined(DEBUG) 1245 if (bits_left < 0) 1246 fprintf(stderr, "read %d bits too many\n", -bits_left); 1247 else if (cachesz + bits_left > 0) 1248 fprintf(stderr, "%d stuffing bits\n", cachesz + bits_left); 1249 # endif 1250 1251 /* rzero */ 1252 while (xrptr < &xr[576]) { 1253 xrptr[0] = 0; 1254 xrptr[1] = 0; 1255 1256 xrptr += 2; 1257 } 1258 1259 return MAD_ERROR_NONE; 1260 } 1261 1262 # undef MASK 1263 # undef MASK1BIT 1264 1265 /* 1266 * NAME: III_reorder() 1267 * DESCRIPTION: reorder frequency lines of a short block into subband order 1268 */ 1269 static 1270 void III_reorder(mad_fixed_t xr[576], struct channel const *channel, 1271 unsigned char const sfbwidth[39]) 1272 { 1273 mad_fixed_t tmp[32][3][6]; 1274 unsigned int sb, l, f, w, sbw[3], sw[3]; 1275 1276 /* this is probably wrong for 8000 Hz mixed blocks */ 1277 1278 sb = 0; 1279 if (channel->flags & mixed_block_flag) { 1280 sb = 2; 1281 1282 l = 0; 1283 while (l < 36) 1284 l += *sfbwidth++; 1285 } 1286 1287 for (w = 0; w < 3; ++w) { 1288 sbw[w] = sb; 1289 sw[w] = 0; 1290 } 1291 1292 f = *sfbwidth++; 1293 w = 0; 1294 1295 for (l = 18 * sb; l < 576; ++l) { 1296 if (f-- == 0) { 1297 f = *sfbwidth++ - 1; 1298 w = (w + 1) % 3; 1299 } 1300 1301 tmp[sbw[w]][w][sw[w]++] = xr[l]; 1302 1303 if (sw[w] == 6) { 1304 sw[w] = 0; 1305 ++sbw[w]; 1306 } 1307 } 1308 1309 memcpy(&xr[18 * sb], &tmp[sb], (576 - 18 * sb) * sizeof(mad_fixed_t)); 1310 } 1311 1312 /* 1313 * NAME: III_stereo() 1314 * DESCRIPTION: perform joint stereo processing on a granule 1315 */ 1316 static 1317 enum mad_error III_stereo(mad_fixed_t xr[2][576], 1318 struct granule const *granule, 1319 struct mad_header *header, 1320 unsigned char const *sfbwidth) 1321 { 1322 short modes[39]; 1323 unsigned int sfbi, l, n, i; 1324 1325 if (granule->ch[0].block_type != 1326 granule->ch[1].block_type || 1327 (granule->ch[0].flags & mixed_block_flag) != 1328 (granule->ch[1].flags & mixed_block_flag)) 1329 return MAD_ERROR_BADSTEREO; 1330 1331 for (i = 0; i < 39; ++i) 1332 modes[i] = header->mode_extension; 1333 1334 /* intensity stereo */ 1335 1336 if (header->mode_extension & I_STEREO) { 1337 struct channel const *right_ch = &granule->ch[1]; 1338 mad_fixed_t const *right_xr = xr[1]; 1339 unsigned int is_pos; 1340 1341 header->flags |= MAD_FLAG_I_STEREO; 1342 1343 /* first determine which scalefactor bands are to be processed */ 1344 1345 if (right_ch->block_type == 2) { 1346 unsigned int lower, start, max, bound[3], w; 1347 1348 lower = start = max = bound[0] = bound[1] = bound[2] = 0; 1349 1350 sfbi = l = 0; 1351 1352 if (right_ch->flags & mixed_block_flag) { 1353 while (l < 36) { 1354 n = sfbwidth[sfbi++]; 1355 1356 for (i = 0; i < n; ++i) { 1357 if (right_xr[i]) { 1358 lower = sfbi; 1359 break; 1360 } 1361 } 1362 1363 right_xr += n; 1364 l += n; 1365 } 1366 1367 start = sfbi; 1368 } 1369 1370 w = 0; 1371 while (l < 576) { 1372 n = sfbwidth[sfbi++]; 1373 1374 for (i = 0; i < n; ++i) { 1375 if (right_xr[i]) { 1376 max = bound[w] = sfbi; 1377 break; 1378 } 1379 } 1380 1381 right_xr += n; 1382 l += n; 1383 w = (w + 1) % 3; 1384 } 1385 1386 if (max) 1387 lower = start; 1388 1389 /* long blocks */ 1390 1391 for (i = 0; i < lower; ++i) 1392 modes[i] = header->mode_extension & ~I_STEREO; 1393 1394 /* short blocks */ 1395 1396 w = 0; 1397 for (i = start; i < max; ++i) { 1398 if (i < bound[w]) 1399 modes[i] = header->mode_extension & ~I_STEREO; 1400 1401 w = (w + 1) % 3; 1402 } 1403 } 1404 else { /* right_ch->block_type != 2 */ 1405 unsigned int bound; 1406 1407 bound = 0; 1408 for (sfbi = l = 0; l < 576; l += n) { 1409 n = sfbwidth[sfbi++]; 1410 1411 for (i = 0; i < n; ++i) { 1412 if (right_xr[i]) { 1413 bound = sfbi; 1414 break; 1415 } 1416 } 1417 1418 right_xr += n; 1419 } 1420 1421 for (i = 0; i < bound; ++i) 1422 modes[i] = header->mode_extension & ~I_STEREO; 1423 } 1424 1425 /* now do the actual processing */ 1426 1427 if (header->flags & MAD_FLAG_LSF_EXT) { 1428 unsigned char const *illegal_pos = granule[1].ch[1].scalefac; 1429 mad_fixed_t const *lsf_scale; 1430 1431 /* intensity_scale */ 1432 lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1]; 1433 1434 for (sfbi = l = 0; l < 576; ++sfbi, l += n) { 1435 n = sfbwidth[sfbi]; 1436 1437 if (!(modes[sfbi] & I_STEREO)) 1438 continue; 1439 1440 if (illegal_pos[sfbi]) { 1441 modes[sfbi] &= ~I_STEREO; 1442 continue; 1443 } 1444 1445 is_pos = right_ch->scalefac[sfbi]; 1446 1447 for (i = 0; i < n; ++i) { 1448 register mad_fixed_t left; 1449 1450 left = xr[0][l + i]; 1451 1452 if (is_pos == 0) 1453 xr[1][l + i] = left; 1454 else { 1455 register mad_fixed_t opposite; 1456 1457 opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]); 1458 1459 if (is_pos & 1) { 1460 xr[0][l + i] = opposite; 1461 xr[1][l + i] = left; 1462 } 1463 else 1464 xr[1][l + i] = opposite; 1465 } 1466 } 1467 } 1468 } 1469 else { /* !(header->flags & MAD_FLAG_LSF_EXT) */ 1470 for (sfbi = l = 0; l < 576; ++sfbi, l += n) { 1471 n = sfbwidth[sfbi]; 1472 1473 if (!(modes[sfbi] & I_STEREO)) 1474 continue; 1475 1476 is_pos = right_ch->scalefac[sfbi]; 1477 1478 if (is_pos >= 7) { /* illegal intensity position */ 1479 modes[sfbi] &= ~I_STEREO; 1480 continue; 1481 } 1482 1483 for (i = 0; i < n; ++i) { 1484 register mad_fixed_t left; 1485 1486 left = xr[0][l + i]; 1487 1488 xr[0][l + i] = mad_f_mul(left, is_table[ is_pos]); 1489 xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]); 1490 } 1491 } 1492 } 1493 } 1494 1495 /* middle/side stereo */ 1496 1497 if (header->mode_extension & MS_STEREO) { 1498 register mad_fixed_t invsqrt2; 1499 1500 header->flags |= MAD_FLAG_MS_STEREO; 1501 1502 invsqrt2 = root_table[3 + -2]; 1503 1504 for (sfbi = l = 0; l < 576; ++sfbi, l += n) { 1505 n = sfbwidth[sfbi]; 1506 1507 if (modes[sfbi] != MS_STEREO) 1508 continue; 1509 1510 for (i = 0; i < n; ++i) { 1511 register mad_fixed_t m, s; 1512 1513 m = xr[0][l + i]; 1514 s = xr[1][l + i]; 1515 1516 xr[0][l + i] = mad_f_mul(m + s, invsqrt2); /* l = (m + s) / sqrt(2) */ 1517 xr[1][l + i] = mad_f_mul(m - s, invsqrt2); /* r = (m - s) / sqrt(2) */ 1518 } 1519 } 1520 } 1521 1522 return MAD_ERROR_NONE; 1523 } 1524 1525 /* 1526 * NAME: III_aliasreduce() 1527 * DESCRIPTION: perform frequency line alias reduction 1528 */ 1529 static 1530 void III_aliasreduce(mad_fixed_t xr[576], int lines) 1531 { 1532 mad_fixed_t const *bound; 1533 int i; 1534 1535 bound = &xr[lines]; 1536 for (xr += 18; xr < bound; xr += 18) { 1537 for (i = 0; i < 8; ++i) { 1538 register mad_fixed_t a, b; 1539 register mad_fixed64hi_t hi; 1540 register mad_fixed64lo_t lo; 1541 1542 a = xr[-1 - i]; 1543 b = xr[ i]; 1544 1545 # if defined(ASO_ZEROCHECK) 1546 if (a | b) { 1547 # endif 1548 MAD_F_ML0(hi, lo, a, cs[i]); 1549 MAD_F_MLA(hi, lo, -b, ca[i]); 1550 1551 xr[-1 - i] = MAD_F_MLZ(hi, lo); 1552 1553 MAD_F_ML0(hi, lo, b, cs[i]); 1554 MAD_F_MLA(hi, lo, a, ca[i]); 1555 1556 xr[ i] = MAD_F_MLZ(hi, lo); 1557 # if defined(ASO_ZEROCHECK) 1558 } 1559 # endif 1560 } 1561 } 1562 } 1563 1564 # if defined(ASO_IMDCT) 1565 void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int); 1566 # else 1567 # if 1 1568 static 1569 void fastsdct(mad_fixed_t const x[9], mad_fixed_t y[18]) 1570 { 1571 mad_fixed_t a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12; 1572 mad_fixed_t a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25; 1573 mad_fixed_t m0, m1, m2, m3, m4, m5, m6, m7; 1574 1575 enum { 1576 c0 = MAD_F(0x1f838b8d), /* 2 * cos( 1 * PI / 18) */ 1577 c1 = MAD_F(0x1bb67ae8), /* 2 * cos( 3 * PI / 18) */ 1578 c2 = MAD_F(0x18836fa3), /* 2 * cos( 4 * PI / 18) */ 1579 c3 = MAD_F(0x1491b752), /* 2 * cos( 5 * PI / 18) */ 1580 c4 = MAD_F(0x0af1d43a), /* 2 * cos( 7 * PI / 18) */ 1581 c5 = MAD_F(0x058e86a0), /* 2 * cos( 8 * PI / 18) */ 1582 c6 = -MAD_F(0x1e11f642) /* 2 * cos(16 * PI / 18) */ 1583 }; 1584 1585 a0 = x[3] + x[5]; 1586 a1 = x[3] - x[5]; 1587 a2 = x[6] + x[2]; 1588 a3 = x[6] - x[2]; 1589 a4 = x[1] + x[7]; 1590 a5 = x[1] - x[7]; 1591 a6 = x[8] + x[0]; 1592 a7 = x[8] - x[0]; 1593 1594 a8 = a0 + a2; 1595 a9 = a0 - a2; 1596 a10 = a0 - a6; 1597 a11 = a2 - a6; 1598 a12 = a8 + a6; 1599 a13 = a1 - a3; 1600 a14 = a13 + a7; 1601 a15 = a3 + a7; 1602 a16 = a1 - a7; 1603 a17 = a1 + a3; 1604 1605 m0 = mad_f_mul(a17, -c3); 1606 m1 = mad_f_mul(a16, -c0); 1607 m2 = mad_f_mul(a15, -c4); 1608 m3 = mad_f_mul(a14, -c1); 1609 m4 = mad_f_mul(a5, -c1); 1610 m5 = mad_f_mul(a11, -c6); 1611 m6 = mad_f_mul(a10, -c5); 1612 m7 = mad_f_mul(a9, -c2); 1613 1614 a18 = x[4] + a4; 1615 a19 = 2 * x[4] - a4; 1616 a20 = a19 + m5; 1617 a21 = a19 - m5; 1618 a22 = a19 + m6; 1619 a23 = m4 + m2; 1620 a24 = m4 - m2; 1621 a25 = m4 + m1; 1622 1623 /* output to every other slot for convenience */ 1624 1625 y[ 0] = a18 + a12; 1626 y[ 2] = m0 - a25; 1627 y[ 4] = m7 - a20; 1628 y[ 6] = m3; 1629 y[ 8] = a21 - m6; 1630 y[10] = a24 - m1; 1631 y[12] = a12 - 2 * a18; 1632 y[14] = a23 + m0; 1633 y[16] = a22 + m7; 1634 } 1635 1636 static inline 1637 void sdctII(mad_fixed_t const x[18], mad_fixed_t X[18]) 1638 { 1639 mad_fixed_t tmp[9]; 1640 int i; 1641 1642 /* scale[i] = 2 * cos(PI * (2 * i + 1) / (2 * 18)) */ 1643 static mad_fixed_t const scale[9] = { 1644 MAD_F(0x1fe0d3b4), MAD_F(0x1ee8dd47), MAD_F(0x1d007930), 1645 MAD_F(0x1a367e59), MAD_F(0x16a09e66), MAD_F(0x125abcf8), 1646 MAD_F(0x0d8616bc), MAD_F(0x08483ee1), MAD_F(0x02c9fad7) 1647 }; 1648 1649 /* divide the 18-point SDCT-II into two 9-point SDCT-IIs */ 1650 1651 /* even input butterfly */ 1652 1653 for (i = 0; i < 9; i += 3) { 1654 tmp[i + 0] = x[i + 0] + x[18 - (i + 0) - 1]; 1655 tmp[i + 1] = x[i + 1] + x[18 - (i + 1) - 1]; 1656 tmp[i + 2] = x[i + 2] + x[18 - (i + 2) - 1]; 1657 } 1658 1659 fastsdct(tmp, &X[0]); 1660 1661 /* odd input butterfly and scaling */ 1662 1663 for (i = 0; i < 9; i += 3) { 1664 tmp[i + 0] = mad_f_mul(x[i + 0] - x[18 - (i + 0) - 1], scale[i + 0]); 1665 tmp[i + 1] = mad_f_mul(x[i + 1] - x[18 - (i + 1) - 1], scale[i + 1]); 1666 tmp[i + 2] = mad_f_mul(x[i + 2] - x[18 - (i + 2) - 1], scale[i + 2]); 1667 } 1668 1669 fastsdct(tmp, &X[1]); 1670 1671 /* output accumulation */ 1672 1673 for (i = 3; i < 18; i += 8) { 1674 X[i + 0] -= X[(i + 0) - 2]; 1675 X[i + 2] -= X[(i + 2) - 2]; 1676 X[i + 4] -= X[(i + 4) - 2]; 1677 X[i + 6] -= X[(i + 6) - 2]; 1678 } 1679 } 1680 1681 static inline 1682 void dctIV(mad_fixed_t const y[18], mad_fixed_t X[18]) 1683 { 1684 mad_fixed_t tmp[18]; 1685 int i; 1686 1687 /* scale[i] = 2 * cos(PI * (2 * i + 1) / (4 * 18)) */ 1688 static mad_fixed_t const scale[18] = { 1689 MAD_F(0x1ff833fa), MAD_F(0x1fb9ea93), MAD_F(0x1f3dd120), 1690 MAD_F(0x1e84d969), MAD_F(0x1d906bcf), MAD_F(0x1c62648b), 1691 MAD_F(0x1afd100f), MAD_F(0x1963268b), MAD_F(0x1797c6a4), 1692 MAD_F(0x159e6f5b), MAD_F(0x137af940), MAD_F(0x11318ef3), 1693 MAD_F(0x0ec6a507), MAD_F(0x0c3ef153), MAD_F(0x099f61c5), 1694 MAD_F(0x06ed12c5), MAD_F(0x042d4544), MAD_F(0x0165547c) 1695 }; 1696 1697 /* scaling */ 1698 1699 for (i = 0; i < 18; i += 3) { 1700 tmp[i + 0] = mad_f_mul(y[i + 0], scale[i + 0]); 1701 tmp[i + 1] = mad_f_mul(y[i + 1], scale[i + 1]); 1702 tmp[i + 2] = mad_f_mul(y[i + 2], scale[i + 2]); 1703 } 1704 1705 /* SDCT-II */ 1706 1707 sdctII(tmp, X); 1708 1709 /* scale reduction and output accumulation */ 1710 1711 X[0] /= 2; 1712 for (i = 1; i < 17; i += 4) { 1713 X[i + 0] = X[i + 0] / 2 - X[(i + 0) - 1]; 1714 X[i + 1] = X[i + 1] / 2 - X[(i + 1) - 1]; 1715 X[i + 2] = X[i + 2] / 2 - X[(i + 2) - 1]; 1716 X[i + 3] = X[i + 3] / 2 - X[(i + 3) - 1]; 1717 } 1718 X[17] = X[17] / 2 - X[16]; 1719 } 1720 1721 /* 1722 * NAME: imdct36 1723 * DESCRIPTION: perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm 1724 */ 1725 static inline 1726 void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36]) 1727 { 1728 mad_fixed_t tmp[18]; 1729 int i; 1730 1731 /* DCT-IV */ 1732 1733 dctIV(x, tmp); 1734 1735 /* convert 18-point DCT-IV to 36-point IMDCT */ 1736 1737 for (i = 0; i < 9; i += 3) { 1738 y[i + 0] = tmp[9 + (i + 0)]; 1739 y[i + 1] = tmp[9 + (i + 1)]; 1740 y[i + 2] = tmp[9 + (i + 2)]; 1741 } 1742 for (i = 9; i < 27; i += 3) { 1743 y[i + 0] = -tmp[36 - (9 + (i + 0)) - 1]; 1744 y[i + 1] = -tmp[36 - (9 + (i + 1)) - 1]; 1745 y[i + 2] = -tmp[36 - (9 + (i + 2)) - 1]; 1746 } 1747 for (i = 27; i < 36; i += 3) { 1748 y[i + 0] = -tmp[(i + 0) - 27]; 1749 y[i + 1] = -tmp[(i + 1) - 27]; 1750 y[i + 2] = -tmp[(i + 2) - 27]; 1751 } 1752 } 1753 # else 1754 /* 1755 * NAME: imdct36 1756 * DESCRIPTION: perform X[18]->x[36] IMDCT 1757 */ 1758 static inline 1759 void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36]) 1760 { 1761 mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7; 1762 mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15; 1763 register mad_fixed64hi_t hi; 1764 register mad_fixed64lo_t lo; 1765 1766 MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8)); 1767 MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa)); 1768 1769 t6 = MAD_F_MLZ(hi, lo); 1770 1771 MAD_F_MLA(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x061f78aa)); 1772 MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), -MAD_F(0x0ec835e8)); 1773 1774 t0 = MAD_F_MLZ(hi, lo); 1775 1776 MAD_F_MLA(hi, lo, (t8 = X[0] - X[11] - X[12]), MAD_F(0x0216a2a2)); 1777 MAD_F_MLA(hi, lo, (t9 = X[2] - X[9] - X[14]), MAD_F(0x09bd7ca0)); 1778 MAD_F_MLA(hi, lo, (t10 = X[3] - X[8] - X[15]), -MAD_F(0x0cb19346)); 1779 MAD_F_MLA(hi, lo, (t11 = X[5] - X[6] - X[17]), -MAD_F(0x0fdcf549)); 1780 1781 x[7] = MAD_F_MLZ(hi, lo); 1782 x[10] = -x[7]; 1783 1784 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346)); 1785 MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549)); 1786 MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2)); 1787 MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0)); 1788 1789 x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0; 1790 1791 t12 = X[0] - X[3] + X[8] - X[11] - X[12] + X[15]; 1792 t13 = X[2] + X[5] - X[6] - X[9] - X[14] - X[17]; 1793 1794 MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8)); 1795 MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa)); 1796 1797 x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0; 1798 1799 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0)); 1800 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2)); 1801 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549)); 1802 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346)); 1803 1804 t1 = MAD_F_MLZ(hi, lo) + t6; 1805 1806 MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962)); 1807 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245)); 1808 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd)); 1809 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad)); 1810 MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2)); 1811 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779)); 1812 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807)); 1813 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5)); 1814 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352)); 1815 MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e)); 1816 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284)); 1817 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890)); 1818 1819 x[6] = MAD_F_MLZ(hi, lo) + t1; 1820 x[11] = -x[6]; 1821 1822 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5)); 1823 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e)); 1824 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779)); 1825 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890)); 1826 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad)); 1827 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284)); 1828 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245)); 1829 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352)); 1830 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962)); 1831 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807)); 1832 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd)); 1833 MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2)); 1834 1835 x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1; 1836 1837 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352)); 1838 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807)); 1839 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284)); 1840 MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2)); 1841 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890)); 1842 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd)); 1843 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e)); 1844 MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962)); 1845 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5)); 1846 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245)); 1847 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779)); 1848 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad)); 1849 1850 x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1; 1851 1852 MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa)); 1853 MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8)); 1854 1855 t7 = MAD_F_MLZ(hi, lo); 1856 1857 MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346)); 1858 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549)); 1859 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2)); 1860 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0)); 1861 1862 t2 = MAD_F_MLZ(hi, lo); 1863 1864 MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2)); 1865 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd)); 1866 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807)); 1867 MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962)); 1868 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352)); 1869 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245)); 1870 MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284)); 1871 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad)); 1872 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890)); 1873 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779)); 1874 MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e)); 1875 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5)); 1876 1877 x[5] = MAD_F_MLZ(hi, lo); 1878 x[12] = -x[5]; 1879 1880 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad)); 1881 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779)); 1882 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245)); 1883 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5)); 1884 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962)); 1885 MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e)); 1886 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd)); 1887 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890)); 1888 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2)); 1889 MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284)); 1890 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807)); 1891 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352)); 1892 1893 x[0] = MAD_F_MLZ(hi, lo) + t2; 1894 x[17] = -x[0]; 1895 1896 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890)); 1897 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284)); 1898 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e)); 1899 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352)); 1900 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5)); 1901 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807)); 1902 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779)); 1903 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2)); 1904 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad)); 1905 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd)); 1906 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245)); 1907 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962)); 1908 1909 x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2; 1910 1911 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2)); 1912 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0)); 1913 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346)); 1914 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549)); 1915 1916 t3 = MAD_F_MLZ(hi, lo) + t7; 1917 1918 MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e)); 1919 MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962)); 1920 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2)); 1921 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284)); 1922 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779)); 1923 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad)); 1924 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352)); 1925 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807)); 1926 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245)); 1927 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5)); 1928 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890)); 1929 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd)); 1930 1931 x[8] = MAD_F_MLZ(hi, lo) + t3; 1932 x[9] = -x[8]; 1933 1934 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245)); 1935 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352)); 1936 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890)); 1937 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779)); 1938 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd)); 1939 MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2)); 1940 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5)); 1941 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e)); 1942 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807)); 1943 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962)); 1944 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad)); 1945 MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284)); 1946 1947 x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3; 1948 1949 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807)); 1950 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5)); 1951 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad)); 1952 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd)); 1953 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284)); 1954 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890)); 1955 MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962)); 1956 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245)); 1957 MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e)); 1958 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352)); 1959 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2)); 1960 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779)); 1961 1962 x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3; 1963 1964 MAD_F_ML0(hi, lo, t14, -MAD_F(0x0ec835e8)); 1965 MAD_F_MLA(hi, lo, t15, MAD_F(0x061f78aa)); 1966 1967 t4 = MAD_F_MLZ(hi, lo) - t7; 1968 1969 MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa)); 1970 MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8)); 1971 1972 x[4] = MAD_F_MLZ(hi, lo) + t4; 1973 x[13] = -x[4]; 1974 1975 MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0)); 1976 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2)); 1977 MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549)); 1978 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346)); 1979 1980 x[1] = MAD_F_MLZ(hi, lo) + t4; 1981 x[16] = -x[1]; 1982 1983 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549)); 1984 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346)); 1985 MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0)); 1986 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2)); 1987 1988 x[25] = x[28] = MAD_F_MLZ(hi, lo) + t4; 1989 1990 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549)); 1991 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346)); 1992 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0)); 1993 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2)); 1994 1995 t5 = MAD_F_MLZ(hi, lo) - t6; 1996 1997 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779)); 1998 MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2)); 1999 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352)); 2000 MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e)); 2001 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245)); 2002 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962)); 2003 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890)); 2004 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284)); 2005 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd)); 2006 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad)); 2007 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5)); 2008 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807)); 2009 2010 x[2] = MAD_F_MLZ(hi, lo) + t5; 2011 x[15] = -x[2]; 2012 2013 MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284)); 2014 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad)); 2015 MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962)); 2016 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807)); 2017 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e)); 2018 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5)); 2019 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2)); 2020 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd)); 2021 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779)); 2022 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890)); 2023 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352)); 2024 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245)); 2025 2026 x[3] = MAD_F_MLZ(hi, lo) + t5; 2027 x[14] = -x[3]; 2028 2029 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd)); 2030 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890)); 2031 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5)); 2032 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245)); 2033 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807)); 2034 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352)); 2035 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad)); 2036 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779)); 2037 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284)); 2038 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2)); 2039 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962)); 2040 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e)); 2041 2042 x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5; 2043 } 2044 # endif 2045 2046 /* 2047 * NAME: III_imdct_l() 2048 * DESCRIPTION: perform IMDCT and windowing for long blocks 2049 */ 2050 static 2051 void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36], 2052 unsigned int block_type) 2053 { 2054 unsigned int i; 2055 2056 /* IMDCT */ 2057 2058 imdct36(X, z); 2059 2060 /* windowing */ 2061 2062 switch (block_type) { 2063 case 0: /* normal window */ 2064 # if defined(ASO_INTERLEAVE1) 2065 { 2066 register mad_fixed_t tmp1, tmp2; 2067 2068 tmp1 = window_l[0]; 2069 tmp2 = window_l[1]; 2070 2071 for (i = 0; i < 34; i += 2) { 2072 z[i + 0] = mad_f_mul(z[i + 0], tmp1); 2073 tmp1 = window_l[i + 2]; 2074 z[i + 1] = mad_f_mul(z[i + 1], tmp2); 2075 tmp2 = window_l[i + 3]; 2076 } 2077 2078 z[34] = mad_f_mul(z[34], tmp1); 2079 z[35] = mad_f_mul(z[35], tmp2); 2080 } 2081 # elif defined(ASO_INTERLEAVE2) 2082 { 2083 register mad_fixed_t tmp1, tmp2; 2084 2085 tmp1 = z[0]; 2086 tmp2 = window_l[0]; 2087 2088 for (i = 0; i < 35; ++i) { 2089 z[i] = mad_f_mul(tmp1, tmp2); 2090 tmp1 = z[i + 1]; 2091 tmp2 = window_l[i + 1]; 2092 } 2093 2094 z[35] = mad_f_mul(tmp1, tmp2); 2095 } 2096 # elif 1 2097 for (i = 0; i < 36; i += 4) { 2098 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); 2099 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); 2100 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); 2101 z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]); 2102 } 2103 # else 2104 for (i = 0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]); 2105 # endif 2106 break; 2107 2108 case 1: /* start block */ 2109 for (i = 0; i < 18; i += 3) { 2110 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); 2111 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); 2112 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); 2113 } 2114 /* (i = 18; i < 24; ++i) z[i] unchanged */ 2115 for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]); 2116 for (i = 30; i < 36; ++i) z[i] = 0; 2117 break; 2118 2119 case 3: /* stop block */ 2120 for (i = 0; i < 6; ++i) z[i] = 0; 2121 for (i = 6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]); 2122 /* (i = 12; i < 18; ++i) z[i] unchanged */ 2123 for (i = 18; i < 36; i += 3) { 2124 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); 2125 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); 2126 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); 2127 } 2128 break; 2129 } 2130 } 2131 # endif /* ASO_IMDCT */ 2132 2133 /* 2134 * NAME: III_imdct_s() 2135 * DESCRIPTION: perform IMDCT and windowing for short blocks 2136 */ 2137 static 2138 void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36]) 2139 { 2140 mad_fixed_t y[36], *yptr; 2141 mad_fixed_t const *wptr; 2142 int w, i; 2143 register mad_fixed64hi_t hi; 2144 register mad_fixed64lo_t lo; 2145 2146 /* IMDCT */ 2147 2148 yptr = &y[0]; 2149 2150 for (w = 0; w < 3; ++w) { 2151 register mad_fixed_t const (*s)[6]; 2152 2153 s = imdct_s; 2154 2155 for (i = 0; i < 3; ++i) { 2156 MAD_F_ML0(hi, lo, X[0], (*s)[0]); 2157 MAD_F_MLA(hi, lo, X[1], (*s)[1]); 2158 MAD_F_MLA(hi, lo, X[2], (*s)[2]); 2159 MAD_F_MLA(hi, lo, X[3], (*s)[3]); 2160 MAD_F_MLA(hi, lo, X[4], (*s)[4]); 2161 MAD_F_MLA(hi, lo, X[5], (*s)[5]); 2162 2163 yptr[i + 0] = MAD_F_MLZ(hi, lo); 2164 yptr[5 - i] = -yptr[i + 0]; 2165 2166 ++s; 2167 2168 MAD_F_ML0(hi, lo, X[0], (*s)[0]); 2169 MAD_F_MLA(hi, lo, X[1], (*s)[1]); 2170 MAD_F_MLA(hi, lo, X[2], (*s)[2]); 2171 MAD_F_MLA(hi, lo, X[3], (*s)[3]); 2172 MAD_F_MLA(hi, lo, X[4], (*s)[4]); 2173 MAD_F_MLA(hi, lo, X[5], (*s)[5]); 2174 2175 yptr[ i + 6] = MAD_F_MLZ(hi, lo); 2176 yptr[11 - i] = yptr[i + 6]; 2177 2178 ++s; 2179 } 2180 2181 yptr += 12; 2182 X += 6; 2183 } 2184 2185 /* windowing, overlapping and concatenation */ 2186 2187 yptr = &y[0]; 2188 wptr = &window_s[0]; 2189 2190 for (i = 0; i < 6; ++i) { 2191 z[i + 0] = 0; 2192 z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]); 2193 2194 MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]); 2195 MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]); 2196 2197 z[i + 12] = MAD_F_MLZ(hi, lo); 2198 2199 MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]); 2200 MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]); 2201 2202 z[i + 18] = MAD_F_MLZ(hi, lo); 2203 2204 z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]); 2205 z[i + 30] = 0; 2206 2207 ++yptr; 2208 ++wptr; 2209 } 2210 } 2211 2212 /* 2213 * NAME: III_overlap() 2214 * DESCRIPTION: perform overlap-add of windowed IMDCT outputs 2215 */ 2216 static 2217 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18], 2218 mad_fixed_t sample[18][32], unsigned int sb) 2219 { 2220 unsigned int i; 2221 2222 # if defined(ASO_INTERLEAVE2) 2223 { 2224 register mad_fixed_t tmp1, tmp2; 2225 2226 tmp1 = overlap[0]; 2227 tmp2 = overlap[1]; 2228 2229 for (i = 0; i < 16; i += 2) { 2230 sample[i + 0][sb] = output[i + 0 + 0] + tmp1; 2231 overlap[i + 0] = output[i + 0 + 18]; 2232 tmp1 = overlap[i + 2]; 2233 2234 sample[i + 1][sb] = output[i + 1 + 0] + tmp2; 2235 overlap[i + 1] = output[i + 1 + 18]; 2236 tmp2 = overlap[i + 3]; 2237 } 2238 2239 sample[16][sb] = output[16 + 0] + tmp1; 2240 overlap[16] = output[16 + 18]; 2241 sample[17][sb] = output[17 + 0] + tmp2; 2242 overlap[17] = output[17 + 18]; 2243 } 2244 # elif 0 2245 for (i = 0; i < 18; i += 2) { 2246 sample[i + 0][sb] = output[i + 0 + 0] + overlap[i + 0]; 2247 overlap[i + 0] = output[i + 0 + 18]; 2248 2249 sample[i + 1][sb] = output[i + 1 + 0] + overlap[i + 1]; 2250 overlap[i + 1] = output[i + 1 + 18]; 2251 } 2252 # else 2253 for (i = 0; i < 18; ++i) { 2254 sample[i][sb] = output[i + 0] + overlap[i]; 2255 overlap[i] = output[i + 18]; 2256 } 2257 # endif 2258 } 2259 2260 /* 2261 * NAME: III_overlap_z() 2262 * DESCRIPTION: perform "overlap-add" of zero IMDCT outputs 2263 */ 2264 static inline 2265 void III_overlap_z(mad_fixed_t overlap[18], 2266 mad_fixed_t sample[18][32], unsigned int sb) 2267 { 2268 unsigned int i; 2269 2270 # if defined(ASO_INTERLEAVE2) 2271 { 2272 register mad_fixed_t tmp1, tmp2; 2273 2274 tmp1 = overlap[0]; 2275 tmp2 = overlap[1]; 2276 2277 for (i = 0; i < 16; i += 2) { 2278 sample[i + 0][sb] = tmp1; 2279 overlap[i + 0] = 0; 2280 tmp1 = overlap[i + 2]; 2281 2282 sample[i + 1][sb] = tmp2; 2283 overlap[i + 1] = 0; 2284 tmp2 = overlap[i + 3]; 2285 } 2286 2287 sample[16][sb] = tmp1; 2288 overlap[16] = 0; 2289 sample[17][sb] = tmp2; 2290 overlap[17] = 0; 2291 } 2292 # else 2293 for (i = 0; i < 18; ++i) { 2294 sample[i][sb] = overlap[i]; 2295 overlap[i] = 0; 2296 } 2297 # endif 2298 } 2299 2300 /* 2301 * NAME: III_freqinver() 2302 * DESCRIPTION: perform subband frequency inversion for odd sample lines 2303 */ 2304 static 2305 void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb) 2306 { 2307 unsigned int i; 2308 2309 # if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2) 2310 { 2311 register mad_fixed_t tmp1, tmp2; 2312 2313 tmp1 = sample[1][sb]; 2314 tmp2 = sample[3][sb]; 2315 2316 for (i = 1; i < 13; i += 4) { 2317 sample[i + 0][sb] = -tmp1; 2318 tmp1 = sample[i + 4][sb]; 2319 sample[i + 2][sb] = -tmp2; 2320 tmp2 = sample[i + 6][sb]; 2321 } 2322 2323 sample[13][sb] = -tmp1; 2324 tmp1 = sample[17][sb]; 2325 sample[15][sb] = -tmp2; 2326 sample[17][sb] = -tmp1; 2327 } 2328 # else 2329 for (i = 1; i < 18; i += 2) 2330 sample[i][sb] = -sample[i][sb]; 2331 # endif 2332 } 2333 2334 /* 2335 * NAME: III_decode() 2336 * DESCRIPTION: decode frame main_data 2337 */ 2338 static 2339 enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame, 2340 struct sideinfo *si, unsigned int nch) 2341 { 2342 struct mad_header *header = &frame->header; 2343 unsigned int sfreqi, ngr, gr; 2344 2345 { 2346 unsigned int sfreq; 2347 2348 sfreq = header->samplerate; 2349 if (header->flags & MAD_FLAG_MPEG_2_5_EXT) 2350 sfreq *= 2; 2351 2352 /* 48000 => 0, 44100 => 1, 32000 => 2, 2353 24000 => 3, 22050 => 4, 16000 => 5 */ 2354 sfreqi = ((sfreq >> 7) & 0x000f) + 2355 ((sfreq >> 15) & 0x0001) - 8; 2356 2357 if (header->flags & MAD_FLAG_MPEG_2_5_EXT) 2358 sfreqi += 3; 2359 } 2360 2361 /* scalefactors, Huffman decoding, requantization */ 2362 2363 ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2; 2364 2365 for (gr = 0; gr < ngr; ++gr) { 2366 struct granule *granule = &si->gr[gr]; 2367 unsigned char const *sfbwidth[2]; 2368 mad_fixed_t xr[2][576]; 2369 unsigned int ch; 2370 enum mad_error error; 2371 2372 for (ch = 0; ch < nch; ++ch) { 2373 struct channel *channel = &granule->ch[ch]; 2374 unsigned int part2_length; 2375 2376 sfbwidth[ch] = sfbwidth_table[sfreqi].l; 2377 if (channel->block_type == 2) { 2378 sfbwidth[ch] = (channel->flags & mixed_block_flag) ? 2379 sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s; 2380 } 2381 2382 if (header->flags & MAD_FLAG_LSF_EXT) { 2383 part2_length = III_scalefactors_lsf(ptr, channel, 2384 ch == 0 ? 0 : &si->gr[1].ch[1], 2385 header->mode_extension); 2386 } 2387 else { 2388 part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch], 2389 gr == 0 ? 0 : si->scfsi[ch]); 2390 } 2391 2392 error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length); 2393 if (error) 2394 return error; 2395 } 2396 2397 /* joint stereo processing */ 2398 2399 if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) { 2400 error = III_stereo(xr, granule, header, sfbwidth[0]); 2401 if (error) 2402 return error; 2403 } 2404 2405 /* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */ 2406 2407 for (ch = 0; ch < nch; ++ch) { 2408 struct channel const *channel = &granule->ch[ch]; 2409 mad_fixed_t (*sample)[32] = &frame->sbsample[ch][18 * gr]; 2410 unsigned int sb, l, i, sblimit; 2411 mad_fixed_t output[36]; 2412 2413 if (channel->block_type == 2) { 2414 III_reorder(xr[ch], channel, sfbwidth[ch]); 2415 2416 # if !defined(OPT_STRICT) 2417 /* 2418 * According to ISO/IEC 11172-3, "Alias reduction is not applied for 2419 * granules with block_type == 2 (short block)." However, other 2420 * sources suggest alias reduction should indeed be performed on the 2421 * lower two subbands of mixed blocks. Most other implementations do 2422 * this, so by default we will too. 2423 */ 2424 if (channel->flags & mixed_block_flag) 2425 III_aliasreduce(xr[ch], 36); 2426 # endif 2427 } 2428 else 2429 III_aliasreduce(xr[ch], 576); 2430 2431 l = 0; 2432 2433 /* subbands 0-1 */ 2434 2435 if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) { 2436 unsigned int block_type; 2437 2438 block_type = channel->block_type; 2439 if (channel->flags & mixed_block_flag) 2440 block_type = 0; 2441 2442 /* long blocks */ 2443 for (sb = 0; sb < 2; ++sb, l += 18) { 2444 III_imdct_l(&xr[ch][l], output, block_type); 2445 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); 2446 } 2447 } 2448 else { 2449 /* short blocks */ 2450 for (sb = 0; sb < 2; ++sb, l += 18) { 2451 III_imdct_s(&xr[ch][l], output); 2452 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); 2453 } 2454 } 2455 2456 III_freqinver(sample, 1); 2457 2458 /* (nonzero) subbands 2-31 */ 2459 2460 i = 576; 2461 while (i > 36 && xr[ch][i - 1] == 0) 2462 --i; 2463 2464 sblimit = 32 - (576 - i) / 18; 2465 2466 if (channel->block_type != 2) { 2467 /* long blocks */ 2468 for (sb = 2; sb < sblimit; ++sb, l += 18) { 2469 III_imdct_l(&xr[ch][l], output, channel->block_type); 2470 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); 2471 2472 if (sb & 1) 2473 III_freqinver(sample, sb); 2474 } 2475 } 2476 else { 2477 /* short blocks */ 2478 for (sb = 2; sb < sblimit; ++sb, l += 18) { 2479 III_imdct_s(&xr[ch][l], output); 2480 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); 2481 2482 if (sb & 1) 2483 III_freqinver(sample, sb); 2484 } 2485 } 2486 2487 /* remaining (zero) subbands */ 2488 2489 for (sb = sblimit; sb < 32; ++sb) { 2490 III_overlap_z((*frame->overlap)[ch][sb], sample, sb); 2491 2492 if (sb & 1) 2493 III_freqinver(sample, sb); 2494 } 2495 } 2496 } 2497 2498 return MAD_ERROR_NONE; 2499 } 2500 2501 /* 2502 * NAME: layer->III() 2503 * DESCRIPTION: decode a single Layer III frame 2504 */ 2505 int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame) 2506 { 2507 struct mad_header *header = &frame->header; 2508 unsigned int nch, priv_bitlen, next_md_begin = 0; 2509 unsigned int si_len, data_bitlen, md_len; 2510 unsigned int frame_space, frame_used, frame_free; 2511 struct mad_bitptr ptr; 2512 struct sideinfo si; 2513 enum mad_error error; 2514 int result = 0; 2515 2516 /* allocate Layer III dynamic structures */ 2517 2518 if (stream->main_data == 0) { 2519 stream->main_data = malloc(MAD_BUFFER_MDLEN); 2520 if (stream->main_data == 0) { 2521 stream->error = MAD_ERROR_NOMEM; 2522 return -1; 2523 } 2524 } 2525 2526 if (frame->overlap == 0) { 2527 frame->overlap = calloc(2 * 32 * 18, sizeof(mad_fixed_t)); 2528 if (frame->overlap == 0) { 2529 stream->error = MAD_ERROR_NOMEM; 2530 return -1; 2531 } 2532 } 2533 2534 nch = MAD_NCHANNELS(header); 2535 si_len = (header->flags & MAD_FLAG_LSF_EXT) ? 2536 (nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32); 2537 2538 /* check frame sanity */ 2539 2540 if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) < 2541 (signed int) si_len) { 2542 stream->error = MAD_ERROR_BADFRAMELEN; 2543 stream->md_len = 0; 2544 return -1; 2545 } 2546 2547 /* check CRC word */ 2548 2549 if (header->flags & MAD_FLAG_PROTECTION) { 2550 header->crc_check = 2551 mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check); 2552 2553 if (header->crc_check != header->crc_target && 2554 !(frame->options & MAD_OPTION_IGNORECRC)) { 2555 stream->error = MAD_ERROR_BADCRC; 2556 result = -1; 2557 } 2558 } 2559 2560 /* decode frame side information */ 2561 2562 error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT, 2563 &si, &data_bitlen, &priv_bitlen); 2564 if (error && result == 0) { 2565 stream->error = error; 2566 result = -1; 2567 } 2568 2569 header->flags |= priv_bitlen; 2570 header->private_bits |= si.private_bits; 2571 2572 /* find main_data of next frame */ 2573 2574 { 2575 struct mad_bitptr peek; 2576 unsigned long header; 2577 2578 mad_bit_init(&peek, stream->next_frame); 2579 2580 header = mad_bit_read(&peek, 32); 2581 if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) { 2582 if (!(header & 0x00010000L)) /* protection_bit */ 2583 mad_bit_skip(&peek, 16); /* crc_check */ 2584 2585 next_md_begin = 2586 mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8); 2587 } 2588 2589 mad_bit_finish(&peek); 2590 } 2591 2592 /* find main_data of this frame */ 2593 2594 frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr); 2595 2596 if (next_md_begin > si.main_data_begin + frame_space) 2597 next_md_begin = 0; 2598 2599 md_len = si.main_data_begin + frame_space - next_md_begin; 2600 2601 frame_used = 0; 2602 2603 if (si.main_data_begin == 0) { 2604 ptr = stream->ptr; 2605 stream->md_len = 0; 2606 2607 frame_used = md_len; 2608 } 2609 else { 2610 if (si.main_data_begin > stream->md_len) { 2611 if (result == 0) { 2612 stream->error = MAD_ERROR_BADDATAPTR; 2613 result = -1; 2614 } 2615 } 2616 else { 2617 mad_bit_init(&ptr, 2618 *stream->main_data + stream->md_len - si.main_data_begin); 2619 2620 if (md_len > si.main_data_begin) { 2621 assert(stream->md_len + md_len - 2622 si.main_data_begin <= MAD_BUFFER_MDLEN); 2623 2624 memcpy(*stream->main_data + stream->md_len, 2625 mad_bit_nextbyte(&stream->ptr), 2626 frame_used = md_len - si.main_data_begin); 2627 stream->md_len += frame_used; 2628 } 2629 } 2630 } 2631 2632 frame_free = frame_space - frame_used; 2633 2634 /* decode main_data */ 2635 2636 if (result == 0) { 2637 error = III_decode(&ptr, frame, &si, nch); 2638 if (error) { 2639 stream->error = error; 2640 result = -1; 2641 } 2642 2643 /* designate ancillary bits */ 2644 2645 stream->anc_ptr = ptr; 2646 stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen; 2647 } 2648 2649 # if 0 && defined(DEBUG) 2650 fprintf(stderr, 2651 "main_data_begin:%u, md_len:%u, frame_free:%u, " 2652 "data_bitlen:%u, anc_bitlen: %u\n", 2653 si.main_data_begin, md_len, frame_free, 2654 data_bitlen, stream->anc_bitlen); 2655 # endif 2656 2657 /* preload main_data buffer with up to 511 bytes for next frame(s) */ 2658 2659 if (frame_free >= next_md_begin) { 2660 memcpy(*stream->main_data, 2661 stream->next_frame - next_md_begin, next_md_begin); 2662 stream->md_len = next_md_begin; 2663 } 2664 else { 2665 if (md_len < si.main_data_begin) { 2666 unsigned int extra; 2667 2668 extra = si.main_data_begin - md_len; 2669 if (extra + frame_free > next_md_begin) 2670 extra = next_md_begin - frame_free; 2671 2672 if (extra < stream->md_len) { 2673 memmove(*stream->main_data, 2674 *stream->main_data + stream->md_len - extra, extra); 2675 stream->md_len = extra; 2676 } 2677 } 2678 else 2679 stream->md_len = 0; 2680 2681 memcpy(*stream->main_data + stream->md_len, 2682 stream->next_frame - frame_free, frame_free); 2683 stream->md_len += frame_free; 2684 } 2685 2686 return result; 2687 } 2688