00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00025 # ifdef HAVE_CONFIG_H
00026 # include "config.h"
00027 # endif
00028
00029 # include "global.h"
00030
00031 # include <stdlib.h>
00032 # include <string.h>
00033
00034 # ifdef HAVE_ASSERT_H
00035 # include <assert.h>
00036 # endif
00037
00038 # ifdef HAVE_LIMITS_H
00039 # include <limits.h>
00040 # else
00041 # define CHAR_BIT 8
00042 # endif
00043
00044 # include "fixed.h"
00045 # include "bit.h"
00046 # include "stream.h"
00047 # include "frame.h"
00048 # include "huffman.h"
00049 # include "layer3.h"
00050
00051
00055 enum {
00056 count1table_select = 0x01,
00057 scalefac_scale = 0x02,
00058 preflag = 0x04,
00059 mixed_block_flag = 0x08
00060 };
00061
00062 enum {
00063 I_STEREO = 0x1,
00064 MS_STEREO = 0x2
00065 };
00066
00067 struct sideinfo {
00068 unsigned int main_data_begin;
00069 unsigned int private_bits;
00070
00071 unsigned char scfsi[2];
00072
00073 struct granule {
00074 struct channel {
00075
00076 unsigned short part2_3_length;
00077 unsigned short big_values;
00078 unsigned short global_gain;
00079 unsigned short scalefac_compress;
00080
00081 unsigned char flags;
00082 unsigned char block_type;
00083 unsigned char table_select[3];
00084 unsigned char subblock_gain[3];
00085 unsigned char region0_count;
00086 unsigned char region1_count;
00087
00088
00089 unsigned char scalefac[39];
00090 } ch[2];
00091 } gr[2];
00092 };
00093
00098 static
00099 struct {
00100 unsigned char slen1;
00101 unsigned char slen2;
00102 } const sflen_table[16] = {
00103 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
00104 { 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
00105 { 2, 1 }, { 2, 2 }, { 2, 3 }, { 3, 1 },
00106 { 3, 2 }, { 3, 3 }, { 4, 2 }, { 4, 3 }
00107 };
00108
00113 static
00114 unsigned char const nsfb_table[6][3][4] = {
00115 { { 6, 5, 5, 5 },
00116 { 9, 9, 9, 9 },
00117 { 6, 9, 9, 9 } },
00118
00119 { { 6, 5, 7, 3 },
00120 { 9, 9, 12, 6 },
00121 { 6, 9, 12, 6 } },
00122
00123 { { 11, 10, 0, 0 },
00124 { 18, 18, 0, 0 },
00125 { 15, 18, 0, 0 } },
00126
00127 { { 7, 7, 7, 0 },
00128 { 12, 12, 12, 0 },
00129 { 6, 15, 12, 0 } },
00130
00131 { { 6, 6, 6, 3 },
00132 { 12, 9, 9, 6 },
00133 { 6, 12, 9, 6 } },
00134
00135 { { 8, 8, 5, 0 },
00136 { 15, 12, 9, 0 },
00137 { 6, 18, 9, 0 } }
00138 };
00139
00144 static
00145 unsigned char const sfb_48000_long[] = {
00146 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10,
00147 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192
00148 };
00149
00150 static
00151 unsigned char const sfb_44100_long[] = {
00152 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
00153 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158
00154 };
00155
00156 static
00157 unsigned char const sfb_32000_long[] = {
00158 4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12,
00159 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26
00160 };
00161
00162 static
00163 unsigned char const sfb_48000_short[] = {
00164 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
00165 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14,
00166 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
00167 };
00168
00169 static
00170 unsigned char const sfb_44100_short[] = {
00171 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
00172 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14,
00173 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
00174 };
00175
00176 static
00177 unsigned char const sfb_32000_short[] = {
00178 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
00179 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20,
00180 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
00181 };
00182
00183 static
00184 unsigned char const sfb_48000_mixed[] = {
00185 4, 4, 4, 4, 4, 4, 6, 6,
00186 4, 4, 4, 6, 6, 6, 6, 6, 6, 10,
00187 10, 10, 12, 12, 12, 14, 14, 14, 16, 16,
00188 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
00189 };
00190
00191 static
00192 unsigned char const sfb_44100_mixed[] = {
00193 4, 4, 4, 4, 4, 4, 6, 6,
00194 4, 4, 4, 6, 6, 6, 8, 8, 8, 10,
00195 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
00196 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
00197 };
00198
00199 static
00200 unsigned char const sfb_32000_mixed[] = {
00201 4, 4, 4, 4, 4, 4, 6, 6,
00202 4, 4, 4, 6, 6, 6, 8, 8, 8, 12,
00203 12, 12, 16, 16, 16, 20, 20, 20, 26, 26,
00204 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
00205 };
00206
00211 static
00212 unsigned char const sfb_24000_long[] = {
00213 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
00214 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36
00215 };
00216
00217 static
00218 unsigned char const sfb_22050_long[] = {
00219 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
00220 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54
00221 };
00222
00223 # define sfb_16000_long sfb_22050_long
00224
00225 static
00226 unsigned char const sfb_24000_short[] = {
00227 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
00228 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
00229 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
00230 };
00231
00232 static
00233 unsigned char const sfb_22050_short[] = {
00234 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6,
00235 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18,
00236 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
00237 };
00238
00239 static
00240 unsigned char const sfb_16000_short[] = {
00241 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
00242 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
00243 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
00244 };
00245
00246 static
00247 unsigned char const sfb_24000_mixed[] = {
00248 6, 6, 6, 6, 6, 6,
00249 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
00250 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
00251 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
00252 };
00253
00254 static
00255 unsigned char const sfb_22050_mixed[] = {
00256 6, 6, 6, 6, 6, 6,
00257 6, 6, 6, 6, 6, 6, 8, 8, 8, 10,
00258 10, 10, 14, 14, 14, 18, 18, 18, 26, 26,
00259 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
00260 };
00261
00262 static
00263 unsigned char const sfb_16000_mixed[] = {
00264 6, 6, 6, 6, 6, 6,
00265 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
00266 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
00267 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
00268 };
00269
00274 # define sfb_12000_long sfb_16000_long
00275 # define sfb_11025_long sfb_12000_long
00276
00277 static
00278 unsigned char const sfb_8000_long[] = {
00279 12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32,
00280 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2
00281 };
00282
00283 # define sfb_12000_short sfb_16000_short
00284 # define sfb_11025_short sfb_12000_short
00285
00286 static
00287 unsigned char const sfb_8000_short[] = {
00288 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16,
00289 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36,
00290 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
00291 };
00292
00293 # define sfb_12000_mixed sfb_16000_mixed
00294 # define sfb_11025_mixed sfb_12000_mixed
00295
00296
00297
00298 static
00299 unsigned char const sfb_8000_mixed[] = {
00300 12, 12, 12,
00301 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16,
00302 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36,
00303 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
00304 };
00305
00306 static
00307 struct {
00308 unsigned char const *l;
00309 unsigned char const *s;
00310 unsigned char const *m;
00311 } const sfbwidth_table[9] = {
00312 { sfb_48000_long, sfb_48000_short, sfb_48000_mixed },
00313 { sfb_44100_long, sfb_44100_short, sfb_44100_mixed },
00314 { sfb_32000_long, sfb_32000_short, sfb_32000_mixed },
00315 { sfb_24000_long, sfb_24000_short, sfb_24000_mixed },
00316 { sfb_22050_long, sfb_22050_short, sfb_22050_mixed },
00317 { sfb_16000_long, sfb_16000_short, sfb_16000_mixed },
00318 { sfb_12000_long, sfb_12000_short, sfb_12000_mixed },
00319 { sfb_11025_long, sfb_11025_short, sfb_11025_mixed },
00320 { sfb_8000_long, sfb_8000_short, sfb_8000_mixed }
00321 };
00322
00327 static
00328 unsigned char const pretab[22] = {
00329 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0
00330 };
00331
00337 static
00338 struct fixedfloat {
00339 unsigned long mantissa : 27;
00340 unsigned short exponent : 5;
00341 } const rq_table[8207] = {
00342 # include "rq_table.dat"
00343 };
00344
00351 static
00352 mad_fixed_t const root_table[7] = {
00353 MAD_F(0x09837f05) ,
00354 MAD_F(0x0b504f33) ,
00355 MAD_F(0x0d744fcd) ,
00356 MAD_F(0x10000000) ,
00357 MAD_F(0x1306fe0a) ,
00358 MAD_F(0x16a09e66) ,
00359 MAD_F(0x1ae89f99)
00360 };
00361
00370 static
00371 mad_fixed_t const cs[8] = {
00372 +MAD_F(0x0db84a81) , +MAD_F(0x0e1b9d7f) ,
00373 +MAD_F(0x0f31adcf) , +MAD_F(0x0fbba815) ,
00374 +MAD_F(0x0feda417) , +MAD_F(0x0ffc8fc8) ,
00375 +MAD_F(0x0fff964c) , +MAD_F(0x0ffff8d3)
00376 };
00377
00378 static
00379 mad_fixed_t const ca[8] = {
00380 -MAD_F(0x083b5fe7) , -MAD_F(0x078c36d2) ,
00381 -MAD_F(0x05039814) , -MAD_F(0x02e91dd1) ,
00382 -MAD_F(0x0183603a) , -MAD_F(0x00a7cb87) ,
00383 -MAD_F(0x003a2847) , -MAD_F(0x000f27b4)
00384 };
00385
00393 static
00394 mad_fixed_t const imdct_s[6][6] = {
00395 # include "imdct_s.dat"
00396 };
00397
00398 # if !defined(ASO_IMDCT)
00399
00405 static
00406 mad_fixed_t const window_l[36] = {
00407 MAD_F(0x00b2aa3e) , MAD_F(0x0216a2a2) ,
00408 MAD_F(0x03768962) , MAD_F(0x04cfb0e2) ,
00409 MAD_F(0x061f78aa) , MAD_F(0x07635284) ,
00410 MAD_F(0x0898c779) , MAD_F(0x09bd7ca0) ,
00411 MAD_F(0x0acf37ad) , MAD_F(0x0bcbe352) ,
00412 MAD_F(0x0cb19346) , MAD_F(0x0d7e8807) ,
00413
00414 MAD_F(0x0e313245) , MAD_F(0x0ec835e8) ,
00415 MAD_F(0x0f426cb5) , MAD_F(0x0f9ee890) ,
00416 MAD_F(0x0fdcf549) , MAD_F(0x0ffc19fd) ,
00417 MAD_F(0x0ffc19fd) , MAD_F(0x0fdcf549) ,
00418 MAD_F(0x0f9ee890) , MAD_F(0x0f426cb5) ,
00419 MAD_F(0x0ec835e8) , MAD_F(0x0e313245) ,
00420
00421 MAD_F(0x0d7e8807) , MAD_F(0x0cb19346) ,
00422 MAD_F(0x0bcbe352) , MAD_F(0x0acf37ad) ,
00423 MAD_F(0x09bd7ca0) , MAD_F(0x0898c779) ,
00424 MAD_F(0x07635284) , MAD_F(0x061f78aa) ,
00425 MAD_F(0x04cfb0e2) , MAD_F(0x03768962) ,
00426 MAD_F(0x0216a2a2) , MAD_F(0x00b2aa3e) ,
00427 };
00428 # endif
00429
00436 static
00437 mad_fixed_t const window_s[12] = {
00438 MAD_F(0x0216a2a2) , MAD_F(0x061f78aa) ,
00439 MAD_F(0x09bd7ca0) , MAD_F(0x0cb19346) ,
00440 MAD_F(0x0ec835e8) , MAD_F(0x0fdcf549) ,
00441 MAD_F(0x0fdcf549) , MAD_F(0x0ec835e8) ,
00442 MAD_F(0x0cb19346) , MAD_F(0x09bd7ca0) ,
00443 MAD_F(0x061f78aa) , MAD_F(0x0216a2a2) ,
00444 };
00445
00453 static
00454 mad_fixed_t const is_table[7] = {
00455 MAD_F(0x00000000) ,
00456 MAD_F(0x0361962f) ,
00457 MAD_F(0x05db3d74) ,
00458 MAD_F(0x08000000) ,
00459 MAD_F(0x0a24c28c) ,
00460 MAD_F(0x0c9e69d1) ,
00461 MAD_F(0x10000000)
00462 };
00463
00471 static
00472 mad_fixed_t const is_lsf_table[2][15] = {
00473 {
00474 MAD_F(0x0d744fcd) ,
00475 MAD_F(0x0b504f33) ,
00476 MAD_F(0x09837f05) ,
00477 MAD_F(0x08000000) ,
00478 MAD_F(0x06ba27e6) ,
00479 MAD_F(0x05a8279a) ,
00480 MAD_F(0x04c1bf83) ,
00481 MAD_F(0x04000000) ,
00482 MAD_F(0x035d13f3) ,
00483 MAD_F(0x02d413cd) ,
00484 MAD_F(0x0260dfc1) ,
00485 MAD_F(0x02000000) ,
00486 MAD_F(0x01ae89fa) ,
00487 MAD_F(0x016a09e6) ,
00488 MAD_F(0x01306fe1)
00489 }, {
00490 MAD_F(0x0b504f33) ,
00491 MAD_F(0x08000000) ,
00492 MAD_F(0x05a8279a) ,
00493 MAD_F(0x04000000) ,
00494 MAD_F(0x02d413cd) ,
00495 MAD_F(0x02000000) ,
00496 MAD_F(0x016a09e6) ,
00497 MAD_F(0x01000000) ,
00498 MAD_F(0x00b504f3) ,
00499 MAD_F(0x00800000) ,
00500 MAD_F(0x005a827a) ,
00501 MAD_F(0x00400000) ,
00502 MAD_F(0x002d413d) ,
00503 MAD_F(0x00200000) ,
00504 MAD_F(0x0016a09e)
00505 }
00506 };
00507
00511 static
00512 enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
00513 int lsf, struct sideinfo *si,
00514 unsigned int *data_bitlen,
00515 unsigned int *priv_bitlen)
00516 {
00517 unsigned int ngr, gr, ch, i;
00518 enum mad_error result = MAD_ERROR_NONE;
00519
00520 *data_bitlen = 0;
00521 *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3);
00522
00523 si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9);
00524 si->private_bits = mad_bit_read(ptr, *priv_bitlen);
00525
00526 ngr = 1;
00527 if (!lsf) {
00528 ngr = 2;
00529
00530 for (ch = 0; ch < nch; ++ch)
00531 si->scfsi[ch] = mad_bit_read(ptr, 4);
00532 }
00533
00534 for (gr = 0; gr < ngr; ++gr) {
00535 struct granule *granule = &si->gr[gr];
00536
00537 for (ch = 0; ch < nch; ++ch) {
00538 struct channel *channel = &granule->ch[ch];
00539
00540 channel->part2_3_length = mad_bit_read(ptr, 12);
00541 channel->big_values = mad_bit_read(ptr, 9);
00542 channel->global_gain = mad_bit_read(ptr, 8);
00543 channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4);
00544
00545 *data_bitlen += channel->part2_3_length;
00546
00547 if (channel->big_values > 288 && result == 0)
00548 result = MAD_ERROR_BADBIGVALUES;
00549
00550 channel->flags = 0;
00551
00552
00553 if (mad_bit_read(ptr, 1)) {
00554 channel->block_type = mad_bit_read(ptr, 2);
00555
00556 if (channel->block_type == 0 && result == 0)
00557 result = MAD_ERROR_BADBLOCKTYPE;
00558
00559 if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)
00560 result = MAD_ERROR_BADSCFSI;
00561
00562 channel->region0_count = 7;
00563 channel->region1_count = 36;
00564
00565 if (mad_bit_read(ptr, 1))
00566 channel->flags |= mixed_block_flag;
00567 else if (channel->block_type == 2)
00568 channel->region0_count = 8;
00569
00570 for (i = 0; i < 2; ++i)
00571 channel->table_select[i] = mad_bit_read(ptr, 5);
00572
00573 # if defined(DEBUG)
00574 channel->table_select[2] = 4;
00575 # endif
00576
00577 for (i = 0; i < 3; ++i)
00578 channel->subblock_gain[i] = mad_bit_read(ptr, 3);
00579 }
00580 else {
00581 channel->block_type = 0;
00582
00583 for (i = 0; i < 3; ++i)
00584 channel->table_select[i] = mad_bit_read(ptr, 5);
00585
00586 channel->region0_count = mad_bit_read(ptr, 4);
00587 channel->region1_count = mad_bit_read(ptr, 3);
00588 }
00589
00590
00591 channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3);
00592 }
00593 }
00594
00595 return result;
00596 }
00597
00601 static
00602 unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
00603 struct channel *channel,
00604 struct channel *gr1ch, int mode_extension)
00605 {
00606 struct mad_bitptr start;
00607 unsigned int scalefac_compress, index, slen[4], part, n, i;
00608 unsigned char const *nsfb;
00609
00610 start = *ptr;
00611
00612 scalefac_compress = channel->scalefac_compress;
00613 index = (channel->block_type == 2) ?
00614 ((channel->flags & mixed_block_flag) ? 2 : 1) : 0;
00615
00616 if (!((mode_extension & I_STEREO) && gr1ch)) {
00617 if (scalefac_compress < 400) {
00618 slen[0] = (scalefac_compress >> 4) / 5;
00619 slen[1] = (scalefac_compress >> 4) % 5;
00620 slen[2] = (scalefac_compress % 16) >> 2;
00621 slen[3] = scalefac_compress % 4;
00622
00623 nsfb = nsfb_table[0][index];
00624 }
00625 else if (scalefac_compress < 500) {
00626 scalefac_compress -= 400;
00627
00628 slen[0] = (scalefac_compress >> 2) / 5;
00629 slen[1] = (scalefac_compress >> 2) % 5;
00630 slen[2] = scalefac_compress % 4;
00631 slen[3] = 0;
00632
00633 nsfb = nsfb_table[1][index];
00634 }
00635 else {
00636 scalefac_compress -= 500;
00637
00638 slen[0] = scalefac_compress / 3;
00639 slen[1] = scalefac_compress % 3;
00640 slen[2] = 0;
00641 slen[3] = 0;
00642
00643 channel->flags |= preflag;
00644
00645 nsfb = nsfb_table[2][index];
00646 }
00647
00648 n = 0;
00649 for (part = 0; part < 4; ++part) {
00650 for (i = 0; i < nsfb[part]; ++i)
00651 channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);
00652 }
00653
00654 while (n < 39)
00655 channel->scalefac[n++] = 0;
00656 }
00657 else {
00658 scalefac_compress >>= 1;
00659
00660 if (scalefac_compress < 180) {
00661 slen[0] = scalefac_compress / 36;
00662 slen[1] = (scalefac_compress % 36) / 6;
00663 slen[2] = (scalefac_compress % 36) % 6;
00664 slen[3] = 0;
00665
00666 nsfb = nsfb_table[3][index];
00667 }
00668 else if (scalefac_compress < 244) {
00669 scalefac_compress -= 180;
00670
00671 slen[0] = (scalefac_compress % 64) >> 4;
00672 slen[1] = (scalefac_compress % 16) >> 2;
00673 slen[2] = scalefac_compress % 4;
00674 slen[3] = 0;
00675
00676 nsfb = nsfb_table[4][index];
00677 }
00678 else {
00679 scalefac_compress -= 244;
00680
00681 slen[0] = scalefac_compress / 3;
00682 slen[1] = scalefac_compress % 3;
00683 slen[2] = 0;
00684 slen[3] = 0;
00685
00686 nsfb = nsfb_table[5][index];
00687 }
00688
00689 n = 0;
00690 for (part = 0; part < 4; ++part) {
00691 unsigned int max, is_pos;
00692
00693 max = (1 << slen[part]) - 1;
00694
00695 for (i = 0; i < nsfb[part]; ++i) {
00696 is_pos = mad_bit_read(ptr, slen[part]);
00697
00698 channel->scalefac[n] = is_pos;
00699 gr1ch->scalefac[n++] = (is_pos == max);
00700 }
00701 }
00702
00703 while (n < 39) {
00704 channel->scalefac[n] = 0;
00705 gr1ch->scalefac[n++] = 0;
00706 }
00707 }
00708
00709 return mad_bit_length(&start, ptr);
00710 }
00711
00715 static
00716 unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
00717 struct channel const *gr0ch, unsigned int scfsi)
00718 {
00719 struct mad_bitptr start;
00720 unsigned int slen1, slen2, sfbi;
00721
00722 start = *ptr;
00723
00724 slen1 = sflen_table[channel->scalefac_compress].slen1;
00725 slen2 = sflen_table[channel->scalefac_compress].slen2;
00726
00727 if (channel->block_type == 2) {
00728 unsigned int nsfb;
00729
00730 sfbi = 0;
00731
00732 nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3;
00733 while (nsfb--)
00734 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1);
00735
00736 nsfb = 6 * 3;
00737 while (nsfb--)
00738 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2);
00739
00740 nsfb = 1 * 3;
00741 while (nsfb--)
00742 channel->scalefac[sfbi++] = 0;
00743 }
00744 else {
00745 if (scfsi & 0x8) {
00746 for (sfbi = 0; sfbi < 6; ++sfbi)
00747 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
00748 }
00749 else {
00750 for (sfbi = 0; sfbi < 6; ++sfbi)
00751 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
00752 }
00753
00754 if (scfsi & 0x4) {
00755 for (sfbi = 6; sfbi < 11; ++sfbi)
00756 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
00757 }
00758 else {
00759 for (sfbi = 6; sfbi < 11; ++sfbi)
00760 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
00761 }
00762
00763 if (scfsi & 0x2) {
00764 for (sfbi = 11; sfbi < 16; ++sfbi)
00765 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
00766 }
00767 else {
00768 for (sfbi = 11; sfbi < 16; ++sfbi)
00769 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
00770 }
00771
00772 if (scfsi & 0x1) {
00773 for (sfbi = 16; sfbi < 21; ++sfbi)
00774 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
00775 }
00776 else {
00777 for (sfbi = 16; sfbi < 21; ++sfbi)
00778 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
00779 }
00780
00781 channel->scalefac[21] = 0;
00782 }
00783
00784 return mad_bit_length(&start, ptr);
00785 }
00786
00815 static
00816 void III_exponents(struct channel const *channel,
00817 unsigned char const *sfbwidth, signed int exponents[39])
00818 {
00819 signed int gain;
00820 unsigned int scalefac_multiplier, sfbi;
00821
00822 gain = (signed int) channel->global_gain - 210;
00823 scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1;
00824
00825 if (channel->block_type == 2) {
00826 unsigned int l;
00827 signed int gain0, gain1, gain2;
00828
00829 sfbi = l = 0;
00830
00831 if (channel->flags & mixed_block_flag) {
00832 unsigned int premask;
00833
00834 premask = (channel->flags & preflag) ? ~0 : 0;
00835
00836
00837
00838 while (l < 36) {
00839 exponents[sfbi] = gain -
00840 (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<
00841 scalefac_multiplier);
00842
00843 l += sfbwidth[sfbi++];
00844 }
00845 }
00846
00847
00848
00849 gain0 = gain - 8 * (signed int) channel->subblock_gain[0];
00850 gain1 = gain - 8 * (signed int) channel->subblock_gain[1];
00851 gain2 = gain - 8 * (signed int) channel->subblock_gain[2];
00852
00853 while (l < 576) {
00854 exponents[sfbi + 0] = gain0 -
00855 (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier);
00856 exponents[sfbi + 1] = gain1 -
00857 (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier);
00858 exponents[sfbi + 2] = gain2 -
00859 (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier);
00860
00861 l += 3 * sfbwidth[sfbi];
00862 sfbi += 3;
00863 }
00864 }
00865 else {
00866 if (channel->flags & preflag) {
00867 for (sfbi = 0; sfbi < 22; ++sfbi) {
00868 exponents[sfbi] = gain -
00869 (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) <<
00870 scalefac_multiplier);
00871 }
00872 }
00873 else {
00874 for (sfbi = 0; sfbi < 22; ++sfbi) {
00875 exponents[sfbi] = gain -
00876 (signed int) (channel->scalefac[sfbi] << scalefac_multiplier);
00877 }
00878 }
00879 }
00880 }
00881
00885 static
00886 mad_fixed_t III_requantize(unsigned int value, signed int exp)
00887 {
00888 mad_fixed_t requantized;
00889 signed int frac;
00890 struct fixedfloat const *power;
00891
00892 frac = exp % 4;
00893 exp /= 4;
00894
00895 power = &rq_table[value];
00896 requantized = power->mantissa;
00897 exp += power->exponent;
00898
00899 if (exp < 0) {
00900 if (-exp >= sizeof(mad_fixed_t) * CHAR_BIT) {
00901
00902 requantized = 0;
00903 }
00904 else {
00905 requantized += 1L << (-exp - 1);
00906 requantized >>= -exp;
00907 }
00908 }
00909 else {
00910 if (exp >= 5) {
00911
00912 # if defined(DEBUG)
00913 fprintf(stderr, "requantize overflow (%f * 2^%d)\n",
00914 mad_f_todouble(requantized), exp);
00915 # endif
00916 requantized = MAD_F_MAX;
00917 }
00918 else
00919 requantized <<= exp;
00920 }
00921
00922 return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized;
00923 }
00924
00925
00926 # define MASK(cache, sz, bits) \
00927 (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1))
00928 # define MASK1BIT(cache, sz) \
00929 ((cache) & (1 << ((sz) - 1)))
00930
00934 static
00935 enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576],
00936 struct channel *channel,
00937 unsigned char const *sfbwidth,
00938 unsigned int part2_length)
00939 {
00940 signed int exponents[39], exp;
00941 signed int const *expptr;
00942 struct mad_bitptr peek;
00943 signed int bits_left, cachesz;
00944 register mad_fixed_t *xrptr;
00945 mad_fixed_t const *sfbound;
00946 register unsigned long bitcache;
00947
00948 bits_left = (signed) channel->part2_3_length - (signed) part2_length;
00949 if (bits_left < 0)
00950 return MAD_ERROR_BADPART3LEN;
00951
00952 III_exponents(channel, sfbwidth, exponents);
00953
00954 peek = *ptr;
00955 mad_bit_skip(ptr, bits_left);
00956
00957
00958 cachesz = mad_bit_bitsleft(&peek);
00959 cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7;
00960
00961 bitcache = mad_bit_read(&peek, cachesz);
00962 bits_left -= cachesz;
00963
00964 xrptr = &xr[0];
00965
00966
00967 {
00968 unsigned int region, rcount;
00969 struct hufftable const *entry;
00970 union huffpair const *table;
00971 unsigned int linbits, startbits, big_values, reqhits;
00972 mad_fixed_t reqcache[16];
00973
00974 sfbound = xrptr + *sfbwidth++;
00975 rcount = channel->region0_count + 1;
00976
00977 entry = &mad_huff_pair_table[channel->table_select[region = 0]];
00978 table = entry->table;
00979 linbits = entry->linbits;
00980 startbits = entry->startbits;
00981
00982 if (table == 0)
00983 return MAD_ERROR_BADHUFFTABLE;
00984
00985 expptr = &exponents[0];
00986 exp = *expptr++;
00987 reqhits = 0;
00988
00989 big_values = channel->big_values;
00990
00991 while (big_values-- && cachesz + bits_left > 0) {
00992 union huffpair const *pair;
00993 unsigned int clumpsz, value;
00994 register mad_fixed_t requantized;
00995
00996 if (xrptr == sfbound) {
00997 sfbound += *sfbwidth++;
00998
00999
01000
01001 if (--rcount == 0) {
01002 if (region == 0)
01003 rcount = channel->region1_count + 1;
01004 else
01005 rcount = 0;
01006
01007 entry = &mad_huff_pair_table[channel->table_select[++region]];
01008 table = entry->table;
01009 linbits = entry->linbits;
01010 startbits = entry->startbits;
01011
01012 if (table == 0)
01013 return MAD_ERROR_BADHUFFTABLE;
01014 }
01015
01016 if (exp != *expptr) {
01017 exp = *expptr;
01018 reqhits = 0;
01019 }
01020
01021 ++expptr;
01022 }
01023
01024 if (cachesz < 21) {
01025 unsigned int bits;
01026
01027 bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7;
01028 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
01029 cachesz += bits;
01030 bits_left -= bits;
01031 }
01032
01033
01034
01035 clumpsz = startbits;
01036 pair = &table[MASK(bitcache, cachesz, clumpsz)];
01037
01038 while (!pair->final) {
01039 cachesz -= clumpsz;
01040
01041 clumpsz = pair->ptr.bits;
01042 pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)];
01043 }
01044
01045 cachesz -= pair->value.hlen;
01046
01047 if (linbits) {
01048
01049
01050 value = pair->value.x;
01051
01052 switch (value) {
01053 case 0:
01054 xrptr[0] = 0;
01055 break;
01056
01057 case 15:
01058 if (cachesz < linbits + 2) {
01059 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
01060 cachesz += 16;
01061 bits_left -= 16;
01062 }
01063
01064 value += MASK(bitcache, cachesz, linbits);
01065 cachesz -= linbits;
01066
01067 requantized = III_requantize(value, exp);
01068 goto x_final;
01069
01070 default:
01071 if (reqhits & (1 << value))
01072 requantized = reqcache[value];
01073 else {
01074 reqhits |= (1 << value);
01075 requantized = reqcache[value] = III_requantize(value, exp);
01076 }
01077
01078 x_final:
01079 xrptr[0] = MASK1BIT(bitcache, cachesz--) ?
01080 -requantized : requantized;
01081 }
01082
01083
01084
01085 value = pair->value.y;
01086
01087 switch (value) {
01088 case 0:
01089 xrptr[1] = 0;
01090 break;
01091
01092 case 15:
01093 if (cachesz < linbits + 1) {
01094 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
01095 cachesz += 16;
01096 bits_left -= 16;
01097 }
01098
01099 value += MASK(bitcache, cachesz, linbits);
01100 cachesz -= linbits;
01101
01102 requantized = III_requantize(value, exp);
01103 goto y_final;
01104
01105 default:
01106 if (reqhits & (1 << value))
01107 requantized = reqcache[value];
01108 else {
01109 reqhits |= (1 << value);
01110 requantized = reqcache[value] = III_requantize(value, exp);
01111 }
01112
01113 y_final:
01114 xrptr[1] = MASK1BIT(bitcache, cachesz--) ?
01115 -requantized : requantized;
01116 }
01117 }
01118 else {
01119
01120
01121 value = pair->value.x;
01122
01123 if (value == 0)
01124 xrptr[0] = 0;
01125 else {
01126 if (reqhits & (1 << value))
01127 requantized = reqcache[value];
01128 else {
01129 reqhits |= (1 << value);
01130 requantized = reqcache[value] = III_requantize(value, exp);
01131 }
01132
01133 xrptr[0] = MASK1BIT(bitcache, cachesz--) ?
01134 -requantized : requantized;
01135 }
01136
01137
01138
01139 value = pair->value.y;
01140
01141 if (value == 0)
01142 xrptr[1] = 0;
01143 else {
01144 if (reqhits & (1 << value))
01145 requantized = reqcache[value];
01146 else {
01147 reqhits |= (1 << value);
01148 requantized = reqcache[value] = III_requantize(value, exp);
01149 }
01150
01151 xrptr[1] = MASK1BIT(bitcache, cachesz--) ?
01152 -requantized : requantized;
01153 }
01154 }
01155
01156 xrptr += 2;
01157 }
01158 }
01159
01160 if (cachesz + bits_left < 0)
01161 return MAD_ERROR_BADHUFFDATA;
01162
01163
01164 {
01165 union huffquad const *table;
01166 register mad_fixed_t requantized;
01167
01168 table = mad_huff_quad_table[channel->flags & count1table_select];
01169
01170 requantized = III_requantize(1, exp);
01171
01172 while (cachesz + bits_left > 0 && xrptr <= &xr[572]) {
01173 union huffquad const *quad;
01174
01175
01176
01177 if (cachesz < 10) {
01178 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
01179 cachesz += 16;
01180 bits_left -= 16;
01181 }
01182
01183 quad = &table[MASK(bitcache, cachesz, 4)];
01184
01185
01186 if (!quad->final) {
01187 cachesz -= 4;
01188
01189 quad = &table[quad->ptr.offset +
01190 MASK(bitcache, cachesz, quad->ptr.bits)];
01191 }
01192
01193 cachesz -= quad->value.hlen;
01194
01195 if (xrptr == sfbound) {
01196 sfbound += *sfbwidth++;
01197
01198 if (exp != *expptr) {
01199 exp = *expptr;
01200 requantized = III_requantize(1, exp);
01201 }
01202
01203 ++expptr;
01204 }
01205
01206
01207
01208 xrptr[0] = quad->value.v ?
01209 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
01210
01211
01212
01213 xrptr[1] = quad->value.w ?
01214 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
01215
01216 xrptr += 2;
01217
01218 if (xrptr == sfbound) {
01219 sfbound += *sfbwidth++;
01220
01221 if (exp != *expptr) {
01222 exp = *expptr;
01223 requantized = III_requantize(1, exp);
01224 }
01225
01226 ++expptr;
01227 }
01228
01229
01230
01231 xrptr[0] = quad->value.x ?
01232 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
01233
01234
01235
01236 xrptr[1] = quad->value.y ?
01237 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
01238
01239 xrptr += 2;
01240 }
01241
01242 if (cachesz + bits_left < 0) {
01243 # if 0 && defined(DEBUG)
01244 fprintf(stderr, "huffman count1 overrun (%d bits)\n",
01245 -(cachesz + bits_left));
01246 # endif
01247
01248
01249
01250
01251 xrptr -= 4;
01252 }
01253 }
01254
01255 assert(-bits_left <= MAD_BUFFER_GUARD * CHAR_BIT);
01256
01257 # if 0 && defined(DEBUG)
01258 if (bits_left < 0)
01259 fprintf(stderr, "read %d bits too many\n", -bits_left);
01260 else if (cachesz + bits_left > 0)
01261 fprintf(stderr, "%d stuffing bits\n", cachesz + bits_left);
01262 # endif
01263
01264
01265 while (xrptr < &xr[576]) {
01266 xrptr[0] = 0;
01267 xrptr[1] = 0;
01268
01269 xrptr += 2;
01270 }
01271
01272 return MAD_ERROR_NONE;
01273 }
01274
01275 # undef MASK
01276 # undef MASK1BIT
01277
01281 static
01282 void III_reorder(mad_fixed_t xr[576], struct channel const *channel,
01283 unsigned char const sfbwidth[39])
01284 {
01285 mad_fixed_t tmp[32][3][6];
01286 unsigned int sb, l, f, w, sbw[3], sw[3];
01287
01288
01289
01290 sb = 0;
01291 if (channel->flags & mixed_block_flag) {
01292 sb = 2;
01293
01294 l = 0;
01295 while (l < 36)
01296 l += *sfbwidth++;
01297 }
01298
01299 for (w = 0; w < 3; ++w) {
01300 sbw[w] = sb;
01301 sw[w] = 0;
01302 }
01303
01304 f = *sfbwidth++;
01305 w = 0;
01306
01307 for (l = 18 * sb; l < 576; ++l) {
01308 if (f-- == 0) {
01309 f = *sfbwidth++ - 1;
01310 w = (w + 1) % 3;
01311 }
01312
01313 tmp[sbw[w]][w][sw[w]++] = xr[l];
01314
01315 if (sw[w] == 6) {
01316 sw[w] = 0;
01317 ++sbw[w];
01318 }
01319 }
01320
01321 memcpy(&xr[18 * sb], &tmp[sb], (576 - 18 * sb) * sizeof(mad_fixed_t));
01322 }
01323
01327 static
01328 enum mad_error III_stereo(mad_fixed_t xr[2][576],
01329 struct granule const *granule,
01330 struct mad_header *header,
01331 unsigned char const *sfbwidth)
01332 {
01333 short modes[39];
01334 unsigned int sfbi, l, n, i;
01335
01336 if (granule->ch[0].block_type !=
01337 granule->ch[1].block_type ||
01338 (granule->ch[0].flags & mixed_block_flag) !=
01339 (granule->ch[1].flags & mixed_block_flag))
01340 return MAD_ERROR_BADSTEREO;
01341
01342 for (i = 0; i < 39; ++i)
01343 modes[i] = header->mode_extension;
01344
01345
01346
01347 if (header->mode_extension & I_STEREO) {
01348 struct channel const *right_ch = &granule->ch[1];
01349 mad_fixed_t const *right_xr = xr[1];
01350 unsigned int is_pos;
01351
01352 header->flags |= MAD_FLAG_I_STEREO;
01353
01354
01355
01356 if (right_ch->block_type == 2) {
01357 unsigned int lower, start, max, bound[3], w;
01358
01359 lower = start = max = bound[0] = bound[1] = bound[2] = 0;
01360
01361 sfbi = l = 0;
01362
01363 if (right_ch->flags & mixed_block_flag) {
01364 while (l < 36) {
01365 n = sfbwidth[sfbi++];
01366
01367 for (i = 0; i < n; ++i) {
01368 if (right_xr[i]) {
01369 lower = sfbi;
01370 break;
01371 }
01372 }
01373
01374 right_xr += n;
01375 l += n;
01376 }
01377
01378 start = sfbi;
01379 }
01380
01381 w = 0;
01382 while (l < 576) {
01383 n = sfbwidth[sfbi++];
01384
01385 for (i = 0; i < n; ++i) {
01386 if (right_xr[i]) {
01387 max = bound[w] = sfbi;
01388 break;
01389 }
01390 }
01391
01392 right_xr += n;
01393 l += n;
01394 w = (w + 1) % 3;
01395 }
01396
01397 if (max)
01398 lower = start;
01399
01400
01401
01402 for (i = 0; i < lower; ++i)
01403 modes[i] = header->mode_extension & ~I_STEREO;
01404
01405
01406
01407 w = 0;
01408 for (i = start; i < max; ++i) {
01409 if (i < bound[w])
01410 modes[i] = header->mode_extension & ~I_STEREO;
01411
01412 w = (w + 1) % 3;
01413 }
01414 }
01415 else {
01416 unsigned int bound;
01417
01418 bound = 0;
01419 for (sfbi = l = 0; l < 576; l += n) {
01420 n = sfbwidth[sfbi++];
01421
01422 for (i = 0; i < n; ++i) {
01423 if (right_xr[i]) {
01424 bound = sfbi;
01425 break;
01426 }
01427 }
01428
01429 right_xr += n;
01430 }
01431
01432 for (i = 0; i < bound; ++i)
01433 modes[i] = header->mode_extension & ~I_STEREO;
01434 }
01435
01436
01437
01438 if (header->flags & MAD_FLAG_LSF_EXT) {
01439 unsigned char const *illegal_pos = granule[1].ch[1].scalefac;
01440 mad_fixed_t const *lsf_scale;
01441
01442
01443 lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1];
01444
01445 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
01446 n = sfbwidth[sfbi];
01447
01448 if (!(modes[sfbi] & I_STEREO))
01449 continue;
01450
01451 if (illegal_pos[sfbi]) {
01452 modes[sfbi] &= ~I_STEREO;
01453 continue;
01454 }
01455
01456 is_pos = right_ch->scalefac[sfbi];
01457
01458 for (i = 0; i < n; ++i) {
01459 register mad_fixed_t left;
01460
01461 left = xr[0][l + i];
01462
01463 if (is_pos == 0)
01464 xr[1][l + i] = left;
01465 else {
01466 register mad_fixed_t opposite;
01467
01468 opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]);
01469
01470 if (is_pos & 1) {
01471 xr[0][l + i] = opposite;
01472 xr[1][l + i] = left;
01473 }
01474 else
01475 xr[1][l + i] = opposite;
01476 }
01477 }
01478 }
01479 }
01480 else {
01481 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
01482 n = sfbwidth[sfbi];
01483
01484 if (!(modes[sfbi] & I_STEREO))
01485 continue;
01486
01487 is_pos = right_ch->scalefac[sfbi];
01488
01489 if (is_pos >= 7) {
01490 modes[sfbi] &= ~I_STEREO;
01491 continue;
01492 }
01493
01494 for (i = 0; i < n; ++i) {
01495 register mad_fixed_t left;
01496
01497 left = xr[0][l + i];
01498
01499 xr[0][l + i] = mad_f_mul(left, is_table[ is_pos]);
01500 xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
01501 }
01502 }
01503 }
01504 }
01505
01506
01507
01508 if (header->mode_extension & MS_STEREO) {
01509 register mad_fixed_t invsqrt2;
01510
01511 header->flags |= MAD_FLAG_MS_STEREO;
01512
01513 invsqrt2 = root_table[3 + -2];
01514
01515 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
01516 n = sfbwidth[sfbi];
01517
01518 if (modes[sfbi] != MS_STEREO)
01519 continue;
01520
01521 for (i = 0; i < n; ++i) {
01522 register mad_fixed_t m, s;
01523
01524 m = xr[0][l + i];
01525 s = xr[1][l + i];
01526
01527 xr[0][l + i] = mad_f_mul(m + s, invsqrt2);
01528 xr[1][l + i] = mad_f_mul(m - s, invsqrt2);
01529 }
01530 }
01531 }
01532
01533 return MAD_ERROR_NONE;
01534 }
01535
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),
01587 c1 = MAD_F(0x1bb67ae8),
01588 c2 = MAD_F(0x18836fa3),
01589 c3 = MAD_F(0x1491b752),
01590 c4 = MAD_F(0x0af1d43a),
01591 c5 = MAD_F(0x058e86a0),
01592 c6 = -MAD_F(0x1e11f642)
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
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
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
01660
01661
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
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
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
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
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
01716
01717 sdctII(tmp, X);
01718
01719
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
01734 static inline
01735 void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36])
01736 {
01737 mad_fixed_t tmp[18];
01738 int i;
01739
01740
01741
01742 dctIV(x, tmp);
01743
01744
01745
01746 for (i = 0; i < 9; i += 3) {
01747 y[i + 0] = tmp[9 + (i + 0)];
01748 y[i + 1] = tmp[9 + (i + 1)];
01749 y[i + 2] = tmp[9 + (i + 2)];
01750 }
01751 for (i = 9; i < 27; i += 3) {
01752 y[i + 0] = -tmp[36 - (9 + (i + 0)) - 1];
01753 y[i + 1] = -tmp[36 - (9 + (i + 1)) - 1];
01754 y[i + 2] = -tmp[36 - (9 + (i + 2)) - 1];
01755 }
01756 for (i = 27; i < 36; i += 3) {
01757 y[i + 0] = -tmp[(i + 0) - 27];
01758 y[i + 1] = -tmp[(i + 1) - 27];
01759 y[i + 2] = -tmp[(i + 2) - 27];
01760 }
01761 }
01762 # else
01763
01766 static inline
01767 void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
01768 {
01769 mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7;
01770 mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15;
01771 register mad_fixed64hi_t hi;
01772 register mad_fixed64lo_t lo;
01773
01774 MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8));
01775 MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa));
01776
01777 t6 = MAD_F_MLZ(hi, lo);
01778
01779 MAD_F_MLA(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x061f78aa));
01780 MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), -MAD_F(0x0ec835e8));
01781
01782 t0 = MAD_F_MLZ(hi, lo);
01783
01784 MAD_F_MLA(hi, lo, (t8 = X[0] - X[11] - X[12]), MAD_F(0x0216a2a2));
01785 MAD_F_MLA(hi, lo, (t9 = X[2] - X[9] - X[14]), MAD_F(0x09bd7ca0));
01786 MAD_F_MLA(hi, lo, (t10 = X[3] - X[8] - X[15]), -MAD_F(0x0cb19346));
01787 MAD_F_MLA(hi, lo, (t11 = X[5] - X[6] - X[17]), -MAD_F(0x0fdcf549));
01788
01789 x[7] = MAD_F_MLZ(hi, lo);
01790 x[10] = -x[7];
01791
01792 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346));
01793 MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549));
01794 MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2));
01795 MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0));
01796
01797 x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0;
01798
01799 t12 = X[0] - X[3] + X[8] - X[11] - X[12] + X[15];
01800 t13 = X[2] + X[5] - X[6] - X[9] - X[14] - X[17];
01801
01802 MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8));
01803 MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa));
01804
01805 x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0;
01806
01807 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0));
01808 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2));
01809 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549));
01810 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346));
01811
01812 t1 = MAD_F_MLZ(hi, lo) + t6;
01813
01814 MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962));
01815 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245));
01816 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd));
01817 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad));
01818 MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2));
01819 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779));
01820 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807));
01821 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5));
01822 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352));
01823 MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e));
01824 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284));
01825 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890));
01826
01827 x[6] = MAD_F_MLZ(hi, lo) + t1;
01828 x[11] = -x[6];
01829
01830 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5));
01831 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e));
01832 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779));
01833 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890));
01834 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad));
01835 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284));
01836 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245));
01837 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352));
01838 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962));
01839 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807));
01840 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd));
01841 MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2));
01842
01843 x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1;
01844
01845 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352));
01846 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807));
01847 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284));
01848 MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2));
01849 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890));
01850 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd));
01851 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e));
01852 MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962));
01853 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5));
01854 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245));
01855 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779));
01856 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad));
01857
01858 x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1;
01859
01860 MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa));
01861 MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8));
01862
01863 t7 = MAD_F_MLZ(hi, lo);
01864
01865 MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346));
01866 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549));
01867 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2));
01868 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0));
01869
01870 t2 = MAD_F_MLZ(hi, lo);
01871
01872 MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2));
01873 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd));
01874 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807));
01875 MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962));
01876 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352));
01877 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245));
01878 MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284));
01879 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad));
01880 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890));
01881 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779));
01882 MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e));
01883 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5));
01884
01885 x[5] = MAD_F_MLZ(hi, lo);
01886 x[12] = -x[5];
01887
01888 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad));
01889 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779));
01890 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245));
01891 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5));
01892 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962));
01893 MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e));
01894 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd));
01895 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890));
01896 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2));
01897 MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284));
01898 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807));
01899 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352));
01900
01901 x[0] = MAD_F_MLZ(hi, lo) + t2;
01902 x[17] = -x[0];
01903
01904 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890));
01905 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284));
01906 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e));
01907 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352));
01908 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5));
01909 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807));
01910 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779));
01911 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2));
01912 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad));
01913 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd));
01914 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245));
01915 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962));
01916
01917 x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2;
01918
01919 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2));
01920 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0));
01921 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346));
01922 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549));
01923
01924 t3 = MAD_F_MLZ(hi, lo) + t7;
01925
01926 MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e));
01927 MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962));
01928 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2));
01929 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284));
01930 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779));
01931 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad));
01932 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352));
01933 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807));
01934 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245));
01935 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5));
01936 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890));
01937 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd));
01938
01939 x[8] = MAD_F_MLZ(hi, lo) + t3;
01940 x[9] = -x[8];
01941
01942 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245));
01943 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352));
01944 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890));
01945 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779));
01946 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd));
01947 MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2));
01948 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5));
01949 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e));
01950 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807));
01951 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962));
01952 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad));
01953 MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284));
01954
01955 x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3;
01956
01957 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807));
01958 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5));
01959 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad));
01960 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd));
01961 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284));
01962 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890));
01963 MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962));
01964 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245));
01965 MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e));
01966 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352));
01967 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2));
01968 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779));
01969
01970 x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3;
01971
01972 MAD_F_ML0(hi, lo, t14, -MAD_F(0x0ec835e8));
01973 MAD_F_MLA(hi, lo, t15, MAD_F(0x061f78aa));
01974
01975 t4 = MAD_F_MLZ(hi, lo) - t7;
01976
01977 MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa));
01978 MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8));
01979
01980 x[4] = MAD_F_MLZ(hi, lo) + t4;
01981 x[13] = -x[4];
01982
01983 MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0));
01984 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2));
01985 MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549));
01986 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346));
01987
01988 x[1] = MAD_F_MLZ(hi, lo) + t4;
01989 x[16] = -x[1];
01990
01991 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549));
01992 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346));
01993 MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0));
01994 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2));
01995
01996 x[25] = x[28] = MAD_F_MLZ(hi, lo) + t4;
01997
01998 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549));
01999 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346));
02000 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0));
02001 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2));
02002
02003 t5 = MAD_F_MLZ(hi, lo) - t6;
02004
02005 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779));
02006 MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2));
02007 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352));
02008 MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e));
02009 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245));
02010 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962));
02011 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890));
02012 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284));
02013 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd));
02014 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad));
02015 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5));
02016 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807));
02017
02018 x[2] = MAD_F_MLZ(hi, lo) + t5;
02019 x[15] = -x[2];
02020
02021 MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284));
02022 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad));
02023 MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962));
02024 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807));
02025 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e));
02026 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5));
02027 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2));
02028 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd));
02029 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779));
02030 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890));
02031 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352));
02032 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245));
02033
02034 x[3] = MAD_F_MLZ(hi, lo) + t5;
02035 x[14] = -x[3];
02036
02037 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd));
02038 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890));
02039 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5));
02040 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245));
02041 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807));
02042 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352));
02043 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad));
02044 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779));
02045 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284));
02046 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2));
02047 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962));
02048 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e));
02049
02050 x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5;
02051 }
02052 # endif
02053
02057 static
02058 void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
02059 unsigned int block_type)
02060 {
02061 unsigned int i;
02062
02063
02064
02065 imdct36(X, z);
02066
02067
02068
02069 switch (block_type) {
02070 case 0:
02071 # if defined(ASO_INTERLEAVE1)
02072 {
02073 register mad_fixed_t tmp1, tmp2;
02074
02075 tmp1 = window_l[0];
02076 tmp2 = window_l[1];
02077
02078 for (i = 0; i < 34; i += 2) {
02079 z[i + 0] = mad_f_mul(z[i + 0], tmp1);
02080 tmp1 = window_l[i + 2];
02081 z[i + 1] = mad_f_mul(z[i + 1], tmp2);
02082 tmp2 = window_l[i + 3];
02083 }
02084
02085 z[34] = mad_f_mul(z[34], tmp1);
02086 z[35] = mad_f_mul(z[35], tmp2);
02087 }
02088 # elif defined(ASO_INTERLEAVE2)
02089 {
02090 register mad_fixed_t tmp1, tmp2;
02091
02092 tmp1 = z[0];
02093 tmp2 = window_l[0];
02094
02095 for (i = 0; i < 35; ++i) {
02096 z[i] = mad_f_mul(tmp1, tmp2);
02097 tmp1 = z[i + 1];
02098 tmp2 = window_l[i + 1];
02099 }
02100
02101 z[35] = mad_f_mul(tmp1, tmp2);
02102 }
02103 # elif 1
02104 for (i = 0; i < 36; i += 4) {
02105 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
02106 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
02107 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
02108 z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]);
02109 }
02110 # else
02111 for (i = 0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
02112 # endif
02113 break;
02114
02115 case 1:
02116 for (i = 0; i < 18; i += 3) {
02117 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
02118 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
02119 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
02120 }
02121
02122 for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]);
02123 for (i = 30; i < 36; ++i) z[i] = 0;
02124 break;
02125
02126 case 3:
02127 for (i = 0; i < 6; ++i) z[i] = 0;
02128 for (i = 6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]);
02129
02130 for (i = 18; i < 36; i += 3) {
02131 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
02132 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
02133 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
02134 }
02135 break;
02136 }
02137 }
02138 # endif
02139
02143 static
02144 void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36])
02145 {
02146 mad_fixed_t y[36], *yptr;
02147 mad_fixed_t const *wptr;
02148 int w, i;
02149 register mad_fixed64hi_t hi;
02150 register mad_fixed64lo_t lo;
02151
02152
02153
02154 yptr = &y[0];
02155
02156 for (w = 0; w < 3; ++w) {
02157 register mad_fixed_t const (*s)[6];
02158
02159 s = imdct_s;
02160
02161 for (i = 0; i < 3; ++i) {
02162 MAD_F_ML0(hi, lo, X[0], (*s)[0]);
02163 MAD_F_MLA(hi, lo, X[1], (*s)[1]);
02164 MAD_F_MLA(hi, lo, X[2], (*s)[2]);
02165 MAD_F_MLA(hi, lo, X[3], (*s)[3]);
02166 MAD_F_MLA(hi, lo, X[4], (*s)[4]);
02167 MAD_F_MLA(hi, lo, X[5], (*s)[5]);
02168
02169 yptr[i + 0] = MAD_F_MLZ(hi, lo);
02170 yptr[5 - i] = -yptr[i + 0];
02171
02172 ++s;
02173
02174 MAD_F_ML0(hi, lo, X[0], (*s)[0]);
02175 MAD_F_MLA(hi, lo, X[1], (*s)[1]);
02176 MAD_F_MLA(hi, lo, X[2], (*s)[2]);
02177 MAD_F_MLA(hi, lo, X[3], (*s)[3]);
02178 MAD_F_MLA(hi, lo, X[4], (*s)[4]);
02179 MAD_F_MLA(hi, lo, X[5], (*s)[5]);
02180
02181 yptr[ i + 6] = MAD_F_MLZ(hi, lo);
02182 yptr[11 - i] = yptr[i + 6];
02183
02184 ++s;
02185 }
02186
02187 yptr += 12;
02188 X += 6;
02189 }
02190
02191
02192
02193 yptr = &y[0];
02194 wptr = &window_s[0];
02195
02196 for (i = 0; i < 6; ++i) {
02197 z[i + 0] = 0;
02198 z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]);
02199
02200 MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]);
02201 MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]);
02202
02203 z[i + 12] = MAD_F_MLZ(hi, lo);
02204
02205 MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]);
02206 MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]);
02207
02208 z[i + 18] = MAD_F_MLZ(hi, lo);
02209
02210 z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]);
02211 z[i + 30] = 0;
02212
02213 ++yptr;
02214 ++wptr;
02215 }
02216 }
02217
02221 static
02222 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
02223 mad_fixed_t sample[18][32], unsigned int sb)
02224 {
02225 unsigned int i;
02226
02227 # if defined(ASO_INTERLEAVE2)
02228 {
02229 register mad_fixed_t tmp1, tmp2;
02230
02231 tmp1 = overlap[0];
02232 tmp2 = overlap[1];
02233
02234 for (i = 0; i < 16; i += 2) {
02235 sample[i + 0][sb] = output[i + 0 + 0] + tmp1;
02236 overlap[i + 0] = output[i + 0 + 18];
02237 tmp1 = overlap[i + 2];
02238
02239 sample[i + 1][sb] = output[i + 1 + 0] + tmp2;
02240 overlap[i + 1] = output[i + 1 + 18];
02241 tmp2 = overlap[i + 3];
02242 }
02243
02244 sample[16][sb] = output[16 + 0] + tmp1;
02245 overlap[16] = output[16 + 18];
02246 sample[17][sb] = output[17 + 0] + tmp2;
02247 overlap[17] = output[17 + 18];
02248 }
02249 # elif 0
02250 for (i = 0; i < 18; i += 2) {
02251 sample[i + 0][sb] = output[i + 0 + 0] + overlap[i + 0];
02252 overlap[i + 0] = output[i + 0 + 18];
02253
02254 sample[i + 1][sb] = output[i + 1 + 0] + overlap[i + 1];
02255 overlap[i + 1] = output[i + 1 + 18];
02256 }
02257 # else
02258 for (i = 0; i < 18; ++i) {
02259 sample[i][sb] = output[i + 0] + overlap[i];
02260 overlap[i] = output[i + 18];
02261 }
02262 # endif
02263 }
02264
02268 static inline
02269 void III_overlap_z(mad_fixed_t overlap[18],
02270 mad_fixed_t sample[18][32], unsigned int sb)
02271 {
02272 unsigned int i;
02273
02274 # if defined(ASO_INTERLEAVE2)
02275 {
02276 register mad_fixed_t tmp1, tmp2;
02277
02278 tmp1 = overlap[0];
02279 tmp2 = overlap[1];
02280
02281 for (i = 0; i < 16; i += 2) {
02282 sample[i + 0][sb] = tmp1;
02283 overlap[i + 0] = 0;
02284 tmp1 = overlap[i + 2];
02285
02286 sample[i + 1][sb] = tmp2;
02287 overlap[i + 1] = 0;
02288 tmp2 = overlap[i + 3];
02289 }
02290
02291 sample[16][sb] = tmp1;
02292 overlap[16] = 0;
02293 sample[17][sb] = tmp2;
02294 overlap[17] = 0;
02295 }
02296 # else
02297 for (i = 0; i < 18; ++i) {
02298 sample[i][sb] = overlap[i];
02299 overlap[i] = 0;
02300 }
02301 # endif
02302 }
02303
02307 static
02308 void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
02309 {
02310 unsigned int i;
02311
02312 # if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2)
02313 {
02314 register mad_fixed_t tmp1, tmp2;
02315
02316 tmp1 = sample[1][sb];
02317 tmp2 = sample[3][sb];
02318
02319 for (i = 1; i < 13; i += 4) {
02320 sample[i + 0][sb] = -tmp1;
02321 tmp1 = sample[i + 4][sb];
02322 sample[i + 2][sb] = -tmp2;
02323 tmp2 = sample[i + 6][sb];
02324 }
02325
02326 sample[13][sb] = -tmp1;
02327 tmp1 = sample[17][sb];
02328 sample[15][sb] = -tmp2;
02329 sample[17][sb] = -tmp1;
02330 }
02331 # else
02332 for (i = 1; i < 18; i += 2)
02333 sample[i][sb] = -sample[i][sb];
02334 # endif
02335 }
02336
02340 static
02341 enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
02342 struct sideinfo *si, unsigned int nch)
02343 {
02344 struct mad_header *header = &frame->header;
02345 unsigned int sfreqi, ngr, gr;
02346
02347 {
02348 unsigned int sfreq;
02349
02350 sfreq = header->samplerate;
02351 if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
02352 sfreq *= 2;
02353
02354
02355
02356 sfreqi = ((sfreq >> 7) & 0x000f) +
02357 ((sfreq >> 15) & 0x0001) - 8;
02358
02359 if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
02360 sfreqi += 3;
02361 }
02362
02363
02364
02365 ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2;
02366
02367 for (gr = 0; gr < ngr; ++gr) {
02368 struct granule *granule = &si->gr[gr];
02369 unsigned char const *sfbwidth[2];
02370 mad_fixed_t xr[2][576];
02371 unsigned int ch;
02372 enum mad_error error;
02373
02374 for (ch = 0; ch < nch; ++ch) {
02375 struct channel *channel = &granule->ch[ch];
02376 unsigned int part2_length;
02377
02378 sfbwidth[ch] = sfbwidth_table[sfreqi].l;
02379 if (channel->block_type == 2) {
02380 sfbwidth[ch] = (channel->flags & mixed_block_flag) ?
02381 sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s;
02382 }
02383
02384 if (header->flags & MAD_FLAG_LSF_EXT) {
02385 part2_length = III_scalefactors_lsf(ptr, channel,
02386 ch == 0 ? 0 : &si->gr[1].ch[1],
02387 header->mode_extension);
02388 }
02389 else {
02390 part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch],
02391 gr == 0 ? 0 : si->scfsi[ch]);
02392 }
02393
02394 error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length);
02395 if (error)
02396 return error;
02397 }
02398
02399
02400
02401 if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) {
02402 error = III_stereo(xr, granule, header, sfbwidth[0]);
02403 if (error)
02404 return error;
02405 }
02406
02407
02408
02409 for (ch = 0; ch < nch; ++ch) {
02410 struct channel const *channel = &granule->ch[ch];
02411 mad_fixed_t (*sample)[32] = &frame->sbsample[ch][18 * gr];
02412 unsigned int sb, l, i, sblimit;
02413 mad_fixed_t output[36];
02414
02415 if (channel->block_type == 2) {
02416 III_reorder(xr[ch], channel, sfbwidth[ch]);
02417
02418 # if !defined(OPT_STRICT)
02419
02420
02421
02422
02423
02424
02425
02426 if (channel->flags & mixed_block_flag)
02427 III_aliasreduce(xr[ch], 36);
02428 # endif
02429 }
02430 else
02431 III_aliasreduce(xr[ch], 576);
02432
02433 l = 0;
02434
02435
02436
02437 if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) {
02438 unsigned int block_type;
02439
02440 block_type = channel->block_type;
02441 if (channel->flags & mixed_block_flag)
02442 block_type = 0;
02443
02444
02445 for (sb = 0; sb < 2; ++sb, l += 18) {
02446 III_imdct_l(&xr[ch][l], output, block_type);
02447 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
02448 }
02449 }
02450 else {
02451
02452 for (sb = 0; sb < 2; ++sb, l += 18) {
02453 III_imdct_s(&xr[ch][l], output);
02454 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
02455 }
02456 }
02457
02458 III_freqinver(sample, 1);
02459
02460
02461
02462 i = 576;
02463 while (i > 36 && xr[ch][i - 1] == 0)
02464 --i;
02465
02466 sblimit = 32 - (576 - i) / 18;
02467
02468 if (channel->block_type != 2) {
02469
02470 for (sb = 2; sb < sblimit; ++sb, l += 18) {
02471 III_imdct_l(&xr[ch][l], output, channel->block_type);
02472 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
02473
02474 if (sb & 1)
02475 III_freqinver(sample, sb);
02476 }
02477 }
02478 else {
02479
02480 for (sb = 2; sb < sblimit; ++sb, l += 18) {
02481 III_imdct_s(&xr[ch][l], output);
02482 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
02483
02484 if (sb & 1)
02485 III_freqinver(sample, sb);
02486 }
02487 }
02488
02489
02490
02491 for (sb = sblimit; sb < 32; ++sb) {
02492 III_overlap_z((*frame->overlap)[ch][sb], sample, sb);
02493
02494 if (sb & 1)
02495 III_freqinver(sample, sb);
02496 }
02497 }
02498 }
02499
02500 return MAD_ERROR_NONE;
02501 }
02502
02506 int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
02507 {
02508 struct mad_header *header = &frame->header;
02509 unsigned int nch, priv_bitlen, next_md_begin = 0;
02510 unsigned int si_len, data_bitlen, md_len;
02511 unsigned int frame_space, frame_used, frame_free;
02512 struct mad_bitptr ptr;
02513 struct sideinfo si;
02514 enum mad_error error;
02515 int result = 0;
02516
02517
02518
02519 if (stream->main_data == 0) {
02520 stream->main_data = malloc(MAD_BUFFER_MDLEN);
02521 if (stream->main_data == 0) {
02522 stream->error = MAD_ERROR_NOMEM;
02523 return -1;
02524 }
02525 }
02526
02527 if (frame->overlap == 0) {
02528 frame->overlap = calloc(2 * 32 * 18, sizeof(mad_fixed_t));
02529 if (frame->overlap == 0) {
02530 stream->error = MAD_ERROR_NOMEM;
02531 return -1;
02532 }
02533 }
02534
02535 nch = MAD_NCHANNELS(header);
02536 si_len = (header->flags & MAD_FLAG_LSF_EXT) ?
02537 (nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32);
02538
02539
02540
02541 if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) <
02542 (signed int) si_len) {
02543 stream->error = MAD_ERROR_BADFRAMELEN;
02544 stream->md_len = 0;
02545 return -1;
02546 }
02547
02548
02549
02550 if (header->flags & MAD_FLAG_PROTECTION) {
02551 header->crc_check =
02552 mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check);
02553
02554 if (header->crc_check != header->crc_target &&
02555 !(frame->options & MAD_OPTION_IGNORECRC)) {
02556 stream->error = MAD_ERROR_BADCRC;
02557 result = -1;
02558 }
02559 }
02560
02561
02562
02563 error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT,
02564 &si, &data_bitlen, &priv_bitlen);
02565 if (error && result == 0) {
02566 stream->error = error;
02567 result = -1;
02568 }
02569
02570 header->flags |= priv_bitlen;
02571 header->private_bits |= si.private_bits;
02572
02573
02574
02575 {
02576 struct mad_bitptr peek;
02577 unsigned long header;
02578
02579 mad_bit_init(&peek, stream->next_frame);
02580
02581 header = mad_bit_read(&peek, 32);
02582 if ((header & 0xffe60000L) == 0xffe20000L) {
02583 if (!(header & 0x00010000L))
02584 mad_bit_skip(&peek, 16);
02585
02586 next_md_begin =
02587 mad_bit_read(&peek, (header & 0x00080000L) ? 9 : 8);
02588 }
02589
02590 mad_bit_finish(&peek);
02591 }
02592
02593
02594
02595 frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr);
02596
02597 if (next_md_begin > si.main_data_begin + frame_space)
02598 next_md_begin = 0;
02599
02600 md_len = si.main_data_begin + frame_space - next_md_begin;
02601
02602 frame_used = 0;
02603
02604 if (si.main_data_begin == 0) {
02605 ptr = stream->ptr;
02606 stream->md_len = 0;
02607
02608 frame_used = md_len;
02609 }
02610 else {
02611 if (si.main_data_begin > stream->md_len) {
02612 if (result == 0) {
02613 stream->error = MAD_ERROR_BADDATAPTR;
02614 result = -1;
02615 }
02616 }
02617 else {
02618 mad_bit_init(&ptr,
02619 *stream->main_data + stream->md_len - si.main_data_begin);
02620
02621 if (md_len > si.main_data_begin) {
02622 assert(stream->md_len + md_len -
02623 si.main_data_begin <= MAD_BUFFER_MDLEN);
02624
02625 memcpy(*stream->main_data + stream->md_len,
02626 mad_bit_nextbyte(&stream->ptr),
02627 frame_used = md_len - si.main_data_begin);
02628 stream->md_len += frame_used;
02629 }
02630 }
02631 }
02632
02633 frame_free = frame_space - frame_used;
02634
02635
02636
02637 if (result == 0) {
02638 error = III_decode(&ptr, frame, &si, nch);
02639 if (error) {
02640 stream->error = error;
02641 result = -1;
02642 }
02643
02644
02645
02646 stream->anc_ptr = ptr;
02647 stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen;
02648 }
02649
02650 # if 0 && defined(DEBUG)
02651 fprintf(stderr,
02652 "main_data_begin:%u, md_len:%u, frame_free:%u, "
02653 "data_bitlen:%u, anc_bitlen: %u\n",
02654 si.main_data_begin, md_len, frame_free,
02655 data_bitlen, stream->anc_bitlen);
02656 # endif
02657
02658
02659
02660 if (frame_free >= next_md_begin) {
02661 memcpy(*stream->main_data,
02662 stream->next_frame - next_md_begin, next_md_begin);
02663 stream->md_len = next_md_begin;
02664 }
02665 else {
02666 if (md_len < si.main_data_begin) {
02667 unsigned int extra;
02668
02669 extra = si.main_data_begin - md_len;
02670 if (extra + frame_free > next_md_begin)
02671 extra = next_md_begin - frame_free;
02672
02673 if (extra < stream->md_len) {
02674 memmove(*stream->main_data,
02675 *stream->main_data + stream->md_len - extra, extra);
02676 stream->md_len = extra;
02677 }
02678 }
02679 else
02680 stream->md_len = 0;
02681
02682 memcpy(*stream->main_data + stream->md_len,
02683 stream->next_frame - frame_free, frame_free);
02684 stream->md_len += frame_free;
02685 }
02686
02687 return result;
02688 }