00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00037
00038 #include <mpcdec/mpcdec.h>
00039 #include <mpcdec/internal.h>
00040 #include <mpcdec/requant.h>
00041 #include <mpcdec/huffman.h>
00042
00043
00044
00045
00046 enum
00047 {
00048 EQ_TAP = 13,
00049 DELAY = ((EQ_TAP + 1) / 2),
00050 FIR_BANDS = 4,
00051 MEMSIZE = MPC_DECODER_MEMSIZE,
00052 MEMSIZE2 = (MEMSIZE/2),
00053 MEMMASK = (MEMSIZE-1)
00054 };
00055
00056
00057
00058
00059 void mpc_decoder_init_huffman_sv6(mpc_decoder *d);
00060 void mpc_decoder_init_huffman_sv7(mpc_decoder *d);
00061 void mpc_decoder_read_bitstream_sv6(mpc_decoder *d);
00062 void mpc_decoder_read_bitstream_sv7(mpc_decoder *d);
00063 void mpc_decoder_update_buffer(mpc_decoder *d, mpc_uint32_t RING);
00064 mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample);
00065 void mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band);
00066
00067
00068
00069
00070 static mpc_int32_t f_read(mpc_decoder *d, void *ptr, size_t size)
00071 {
00072 return d->r->read(d->r->data, ptr, size);
00073 };
00074
00075 static mpc_bool_t f_seek(mpc_decoder *d, mpc_int32_t offset)
00076 {
00077 return d->r->seek(d->r->data, offset);
00078 };
00079
00080 static mpc_int32_t f_read_dword(mpc_decoder *d, mpc_uint32_t * ptr, mpc_uint32_t count)
00081 {
00082 count = f_read(d, ptr, count << 2) >> 2;
00083 #ifndef MPC_LITTLE_ENDIAN
00084 mpc_uint32_t n;
00085 for(n = 0; n< count; n++) {
00086 ptr[n] = mpc_swap32(ptr[n]);
00087 }
00088 #endif
00089 return count;
00090 }
00091
00092
00093
00094
00095 static const mpc_uint32_t mask [33] = {
00096 0x00000000, 0x00000001, 0x00000003, 0x00000007,
00097 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
00098 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
00099 0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
00100 0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
00101 0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
00102 0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
00103 0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
00104 0xFFFFFFFF
00105 };
00106
00107
00108
00109
00110 static void
00111 mpc_decoder_reset_bitstream_decode(mpc_decoder *d)
00112 {
00113 d->dword = 0;
00114 d->pos = 0;
00115 d->Zaehler = 0;
00116 d->WordsRead = 0;
00117 }
00118
00119
00120 static mpc_uint32_t
00121 mpc_decoder_bits_read(mpc_decoder *d)
00122 {
00123 return 32 * d->WordsRead + d->pos;
00124 }
00125
00126
00127 static mpc_uint32_t
00128 mpc_decoder_bitstream_read(mpc_decoder *d, const mpc_uint32_t bits)
00129 {
00130 mpc_uint32_t out = d->dword;
00131
00132 d->pos += bits;
00133
00134 if (d->pos < 32) {
00135 out >>= (32 - d->pos);
00136 }
00137 else {
00138 d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
00139 d->pos -= 32;
00140 if (d->pos) {
00141 out <<= d->pos;
00142 out |= d->dword >> (32 - d->pos);
00143 }
00144 ++(d->WordsRead);
00145 }
00146
00147 return out & mask[bits];
00148 }
00149
00150
00151 static void
00152 mpc_decoder_scfi_bundle_read(
00153 mpc_decoder *d,
00154 HuffmanTyp* Table, mpc_int32_t* SCFI, mpc_int32_t* DSCF)
00155 {
00156
00157 mpc_uint32_t code = d->dword << d->pos;
00158 if (d->pos > 26) {
00159 code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
00160 }
00161 while (code < Table->Code) {
00162 Table++;
00163 }
00164
00165
00166 if ((d->pos += Table->Length) >= 32) {
00167 d->pos -= 32;
00168 d->dword = d->Speicher[d->Zaehler = (d->Zaehler+1) & MEMMASK];
00169 ++(d->WordsRead);
00170 }
00171
00172 *SCFI = Table->Value >> 1;
00173 *DSCF = Table->Value & 1;
00174 }
00175
00176 static int
00177 mpc_decoder_huffman_typ_cmpfn(const void* p1, const void* p2)
00178 {
00179 if (((HuffmanTyp*) p1)->Code < ((HuffmanTyp*) p2)->Code ) return +1;
00180 if (((HuffmanTyp*) p1)->Code > ((HuffmanTyp*) p2)->Code ) return -1;
00181 return 0;
00182 }
00183
00184
00185
00186 void
00187 mpc_decoder_resort_huff_tables(
00188 const mpc_uint32_t elements, HuffmanTyp* Table, const mpc_int32_t offset )
00189 {
00190 mpc_uint32_t i;
00191
00192 for ( i = 0; i < elements; i++ ) {
00193 Table[i].Code <<= 32 - Table[i].Length;
00194 Table[i].Value = i - offset;
00195 }
00196 qsort(Table, elements, sizeof(*Table), mpc_decoder_huffman_typ_cmpfn);
00197 }
00198
00199
00200
00201 static mpc_int32_t
00202 mpc_decoder_huffman_decode(mpc_decoder *d, const HuffmanTyp *Table)
00203 {
00204
00205 mpc_uint32_t code = d->dword << d->pos;
00206 if (d->pos > 18) {
00207 code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
00208 }
00209 while (code < Table->Code) {
00210 Table++;
00211 }
00212
00213
00214 if ((d->pos += Table->Length) >= 32) {
00215 d->pos -= 32;
00216 d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
00217 ++(d->WordsRead);
00218 }
00219
00220 return Table->Value;
00221 }
00222
00223
00224
00225 static mpc_int32_t
00226 mpc_decoder_huffman_decode_fast(mpc_decoder *d, const HuffmanTyp* Table)
00227 {
00228
00229 mpc_uint32_t code = d->dword << d->pos;
00230 if (d->pos > 22) {
00231 code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
00232 }
00233 while (code < Table->Code) {
00234 Table++;
00235 }
00236
00237
00238 if ((d->pos += Table->Length) >= 32) {
00239 d->pos -= 32;
00240 d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
00241 ++(d->WordsRead);
00242 }
00243
00244 return Table->Value;
00245 }
00246
00247
00248
00249 static mpc_int32_t
00250 mpc_decoder_huffman_decode_faster(mpc_decoder *d, const HuffmanTyp* Table)
00251 {
00252
00253 mpc_uint32_t code = d->dword << d->pos;
00254 if (d->pos > 27) {
00255 code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
00256 }
00257 while (code < Table->Code) {
00258 Table++;
00259 }
00260
00261
00262 if ((d->pos += Table->Length) >= 32) {
00263 d->pos -= 32;
00264 d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
00265 ++(d->WordsRead);
00266 }
00267
00268 return Table->Value;
00269 }
00270
00271 static void
00272 mpc_decoder_reset_v(mpc_decoder *d)
00273 {
00274 memset(d->V_L, 0, sizeof d->V_L);
00275 memset(d->V_R, 0, sizeof d->V_R);
00276 }
00277
00278 static void
00279 mpc_decoder_reset_synthesis(mpc_decoder *d)
00280 {
00281 mpc_decoder_reset_v(d);
00282 }
00283
00284 static void
00285 mpc_decoder_reset_y(mpc_decoder *d)
00286 {
00287 memset(d->Y_L, 0, sizeof d->Y_L);
00288 memset(d->Y_R, 0, sizeof d->Y_R);
00289 }
00290
00291 static void
00292 mpc_decoder_reset_globals(mpc_decoder *d)
00293 {
00294 mpc_decoder_reset_bitstream_decode(d);
00295
00296 d->DecodedFrames = 0;
00297 d->StreamVersion = 0;
00298 d->MS_used = 0;
00299
00300 memset(d->Y_L , 0, sizeof d->Y_L );
00301 memset(d->Y_R , 0, sizeof d->Y_R );
00302 memset(d->SCF_Index_L , 0, sizeof d->SCF_Index_L );
00303 memset(d->SCF_Index_R , 0, sizeof d->SCF_Index_R );
00304 memset(d->Res_L , 0, sizeof d->Res_L );
00305 memset(d->Res_R , 0, sizeof d->Res_R );
00306 memset(d->SCFI_L , 0, sizeof d->SCFI_L );
00307 memset(d->SCFI_R , 0, sizeof d->SCFI_R );
00308 memset(d->DSCF_Flag_L , 0, sizeof d->DSCF_Flag_L );
00309 memset(d->DSCF_Flag_R , 0, sizeof d->DSCF_Flag_R );
00310 memset(d->DSCF_Reference_L, 0, sizeof d->DSCF_Reference_L );
00311 memset(d->DSCF_Reference_R, 0, sizeof d->DSCF_Reference_R );
00312 memset(d->Q , 0, sizeof d->Q );
00313 memset(d->MS_Flag , 0, sizeof d->MS_Flag );
00314 }
00315
00316 mpc_uint32_t
00317 mpc_decoder_decode_frame(mpc_decoder *d, mpc_uint32_t *in_buffer,
00318 mpc_uint32_t in_len, MPC_SAMPLE_FORMAT *out_buffer)
00319 {
00320 unsigned int i;
00321 mpc_decoder_reset_bitstream_decode(d);
00322 if (in_len > sizeof(d->Speicher)) in_len = sizeof(d->Speicher);
00323 memcpy(d->Speicher, in_buffer, in_len);
00324 #ifdef MPC_LITTLE_ENDIAN
00325 for (i = 0; i < (in_len + 3) / 4; i++)
00326 d->Speicher[i] = mpc_swap32(d->Speicher[i]);
00327 #endif
00328 d->dword = d->Speicher[0];
00329 switch (d->StreamVersion) {
00330 case 0x04:
00331 case 0x05:
00332 case 0x06:
00333 mpc_decoder_read_bitstream_sv6(d);
00334 break;
00335 case 0x07:
00336 case 0x17:
00337 mpc_decoder_read_bitstream_sv7(d);
00338 break;
00339 default:
00340 return (mpc_uint32_t)(-1);
00341 }
00342 mpc_decoder_requantisierung(d, d->Max_Band);
00343 mpc_decoder_synthese_filter_float(d, out_buffer);
00344 return mpc_decoder_bits_read(d);
00345 }
00346
00347 static mpc_uint32_t
00348 mpc_decoder_decode_internal(mpc_decoder *d, MPC_SAMPLE_FORMAT *buffer)
00349 {
00350 mpc_uint32_t output_frame_length = MPC_FRAME_LENGTH;
00351
00352 mpc_uint32_t FrameBitCnt = 0;
00353
00354 if (d->DecodedFrames >= d->OverallFrames) {
00355 return (mpc_uint32_t)(-1);
00356 }
00357
00358
00359 d->FwdJumpInfo = mpc_decoder_bitstream_read(d, 20);
00360
00361 d->ActDecodePos = (d->Zaehler << 5) + d->pos;
00362
00363
00364 FrameBitCnt = mpc_decoder_bits_read(d);
00365 switch (d->StreamVersion) {
00366 case 0x04:
00367 case 0x05:
00368 case 0x06:
00369 mpc_decoder_read_bitstream_sv6(d);
00370 break;
00371 case 0x07:
00372 case 0x17:
00373 mpc_decoder_read_bitstream_sv7(d);
00374 break;
00375 default:
00376 return (mpc_uint32_t)(-1);
00377 }
00378 d->FrameWasValid = mpc_decoder_bits_read(d) - FrameBitCnt == d->FwdJumpInfo;
00379
00380
00381 mpc_decoder_requantisierung(d, d->Max_Band);
00382
00383
00384
00385
00386 mpc_decoder_synthese_filter_float(d, buffer);
00387
00388 d->DecodedFrames++;
00389
00390
00391 if (d->DecodedFrames == d->OverallFrames && d->StreamVersion >= 6) {
00392
00393 mpc_int32_t mod_block = mpc_decoder_bitstream_read(d, 11);
00394 mpc_int32_t FilterDecay;
00395
00396 if (mod_block == 0) {
00397
00398 mod_block = 1152;
00399 }
00400 FilterDecay = (mod_block + MPC_DECODER_SYNTH_DELAY) % MPC_FRAME_LENGTH;
00401
00402
00403 if (MPC_DECODER_SYNTH_DELAY + mod_block >= MPC_FRAME_LENGTH) {
00404
00405
00406
00407
00408
00409
00410
00411 if (!d->TrueGaplessPresent) {
00412 mpc_decoder_reset_y(d);
00413 }
00414 else {
00415
00416 mpc_decoder_bitstream_read(d, 20);
00417 mpc_decoder_read_bitstream_sv7(d);
00418 mpc_decoder_requantisierung(d, d->Max_Band);
00419
00420
00421
00422
00423
00424 }
00425
00426 mpc_decoder_synthese_filter_float(d, buffer + 2304);
00427
00428 output_frame_length = MPC_FRAME_LENGTH + FilterDecay;
00429 }
00430 else {
00431 output_frame_length = FilterDecay;
00432 }
00433 }
00434
00435 if (d->samples_to_skip) {
00436 if (output_frame_length < d->samples_to_skip) {
00437 d->samples_to_skip -= output_frame_length;
00438 output_frame_length = 0;
00439 }
00440 else {
00441 output_frame_length -= d->samples_to_skip;
00442 memmove(
00443 buffer,
00444 buffer + d->samples_to_skip * 2,
00445 output_frame_length * 2 * sizeof (MPC_SAMPLE_FORMAT));
00446 d->samples_to_skip = 0;
00447 }
00448 }
00449
00450 return output_frame_length;
00451 }
00452
00453 mpc_uint32_t mpc_decoder_decode(
00454 mpc_decoder *d,
00455 MPC_SAMPLE_FORMAT *buffer,
00456 mpc_uint32_t *vbr_update_acc,
00457 mpc_uint32_t *vbr_update_bits)
00458 {
00459 for(;;)
00460 {
00461
00462
00463 mpc_uint32_t RING = d->Zaehler;
00464 mpc_int32_t vbr_ring = (RING << 5) + d->pos;
00465
00466 mpc_uint32_t valid_samples = mpc_decoder_decode_internal(d, buffer);
00467
00468 if (valid_samples == (mpc_uint32_t)(-1) ) {
00469 return 0;
00470 }
00471
00472
00473 if (d->FrameWasValid == 0 ) {
00474
00475 return (mpc_uint32_t)(-1);
00476 }
00477 else {
00478 if (vbr_update_acc && vbr_update_bits) {
00479 (*vbr_update_acc) ++;
00480 vbr_ring = (d->Zaehler << 5) + d->pos - vbr_ring;
00481 if (vbr_ring < 0) {
00482 vbr_ring += 524288;
00483 }
00484 (*vbr_update_bits) += vbr_ring;
00485 }
00486
00487 }
00488 mpc_decoder_update_buffer(d, RING);
00489
00490 if (valid_samples > 0) {
00491 return valid_samples;
00492 }
00493 }
00494 }
00495
00496 void
00497 mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
00498 {
00499 mpc_int32_t Band;
00500 mpc_int32_t n;
00501 MPC_SAMPLE_FORMAT facL;
00502 MPC_SAMPLE_FORMAT facR;
00503 MPC_SAMPLE_FORMAT templ;
00504 MPC_SAMPLE_FORMAT tempr;
00505 MPC_SAMPLE_FORMAT* YL;
00506 MPC_SAMPLE_FORMAT* YR;
00507 mpc_int32_t* L;
00508 mpc_int32_t* R;
00509
00510 #ifdef MPC_FIXED_POINT
00511 #if MPC_FIXED_POINT_FRACTPART == 14
00512 #define MPC_MULTIPLY_SCF(CcVal, SCF_idx) \
00513 MPC_MULTIPLY_EX(CcVal, d->SCF[SCF_idx], d->SCF_shift[SCF_idx])
00514 #else
00515
00516 #error FIXME, Cc table is in 18.14 format
00517
00518 #endif
00519 #else
00520 #define MPC_MULTIPLY_SCF(CcVal, SCF_idx) \
00521 MPC_MULTIPLY(CcVal, d->SCF[SCF_idx])
00522 #endif
00523
00524 for ( Band = 0; Band <= Last_Band; Band++ ) {
00525 YL = d->Y_L[0] + Band;
00526 YR = d->Y_R[0] + Band;
00527 L = d->Q[Band].L;
00528 R = d->Q[Band].R;
00529
00530 if ( d->MS_Flag [Band] ) {
00531 if ( d->Res_L [Band] ) {
00532 if ( d->Res_R [Band] ) {
00533 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][0]);
00534 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][0]);
00535 for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
00536 *YL = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
00537 *YR = templ - tempr;
00538 }
00539 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][1]);
00540 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][1]);
00541 for ( ; n < 24; n++, YL += 32, YR += 32 ) {
00542 *YL = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
00543 *YR = templ - tempr;
00544 }
00545 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][2]);
00546 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][2]);
00547 for ( ; n < 36; n++, YL += 32, YR += 32 ) {
00548 *YL = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
00549 *YR = templ - tempr;
00550 }
00551 } else {
00552 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][0]);
00553 for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
00554 *YR = *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00555 }
00556 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][1]);
00557 for ( ; n < 24; n++, YL += 32, YR += 32 ) {
00558 *YR = *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00559 }
00560 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][2]);
00561 for ( ; n < 36; n++, YL += 32, YR += 32 ) {
00562 *YR = *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00563 }
00564 }
00565 } else {
00566 if (d->Res_R[Band])
00567 {
00568 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][0]);
00569 for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
00570 *YR = - (*YL = MPC_MULTIPLY_FLOAT_INT(facR,*(R++)));
00571 }
00572 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][1]);
00573 for ( ; n < 24; n++, YL += 32, YR += 32 ) {
00574 *YR = - (*YL = MPC_MULTIPLY_FLOAT_INT(facR,*(R++)));
00575 }
00576 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][2]);
00577 for ( ; n < 36; n++, YL += 32, YR += 32 ) {
00578 *YR = - (*YL = MPC_MULTIPLY_FLOAT_INT(facR,*(R++)));
00579 }
00580 } else {
00581 for ( n = 0; n < 36; n++, YL += 32, YR += 32 ) {
00582 *YR = *YL = 0;
00583 }
00584 }
00585 }
00586 }
00587
00588 else {
00589 if ( d->Res_L [Band] ) {
00590 if ( d->Res_R [Band] ) {
00591 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][0]);
00592 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][0]);
00593 for (n = 0; n < 12; n++, YL += 32, YR += 32 ) {
00594 *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00595 *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
00596 }
00597 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][1]);
00598 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][1]);
00599 for (; n < 24; n++, YL += 32, YR += 32 ) {
00600 *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00601 *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
00602 }
00603 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][2]);
00604 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][2]);
00605 for (; n < 36; n++, YL += 32, YR += 32 ) {
00606 *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00607 *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
00608 }
00609 } else {
00610 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][0]);
00611 for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
00612 *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00613 *YR = 0;
00614 }
00615 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][1]);
00616 for ( ; n < 24; n++, YL += 32, YR += 32 ) {
00617 *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00618 *YR = 0;
00619 }
00620 facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][2]);
00621 for ( ; n < 36; n++, YL += 32, YR += 32 ) {
00622 *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
00623 *YR = 0;
00624 }
00625 }
00626 }
00627 else {
00628 if ( d->Res_R [Band] ) {
00629 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][0]);
00630 for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
00631 *YL = 0;
00632 *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
00633 }
00634 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][1]);
00635 for ( ; n < 24; n++, YL += 32, YR += 32 ) {
00636 *YL = 0;
00637 *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
00638 }
00639 facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)d->SCF_Index_R[Band][2]);
00640 for ( ; n < 36; n++, YL += 32, YR += 32 ) {
00641 *YL = 0;
00642 *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
00643 }
00644 } else {
00645 for ( n = 0; n < 36; n++, YL += 32, YR += 32 ) {
00646 *YR = *YL = 0;
00647 }
00648 }
00649 }
00650 }
00651 }
00652 }
00653
00654
00655 void
00656 mpc_decoder_read_bitstream_sv6(mpc_decoder *d)
00657 {
00658 mpc_int32_t n,k;
00659 mpc_int32_t Max_used_Band=0;
00660 HuffmanTyp *Table;
00661 const HuffmanTyp *x1;
00662 const HuffmanTyp *x2;
00663 mpc_int32_t *L;
00664 mpc_int32_t *R;
00665 mpc_int32_t *ResL = d->Res_L;
00666 mpc_int32_t *ResR = d->Res_R;
00667
00668
00669 ResL = d->Res_L;
00670 ResR = d->Res_R;
00671 for (n=0; n <= d->Max_Band; ++n, ++ResL, ++ResR)
00672 {
00673 if (n<11) Table = d->Region_A;
00674 else if (n>=11 && n<=22) Table = d->Region_B;
00675 else Table = d->Region_C;
00676
00677 *ResL = d->Q_res[n][mpc_decoder_huffman_decode(d, Table)];
00678 if (d->MS_used) {
00679 d->MS_Flag[n] = mpc_decoder_bitstream_read(d, 1);
00680 }
00681 *ResR = d->Q_res[n][mpc_decoder_huffman_decode(d, Table)];
00682
00683
00684 if (*ResL || *ResR) Max_used_Band = n;
00685 }
00686
00687
00688 ResL = d->Res_L;
00689 ResR = d->Res_R;
00690 for (n=0; n<=Max_used_Band; ++n, ++ResL, ++ResR) {
00691 if (*ResL) mpc_decoder_scfi_bundle_read(d, d->SCFI_Bundle, &(d->SCFI_L[n]), &(d->DSCF_Flag_L[n]));
00692 if (*ResR) mpc_decoder_scfi_bundle_read(d, d->SCFI_Bundle, &(d->SCFI_R[n]), &(d->DSCF_Flag_R[n]));
00693 }
00694
00695
00696 ResL = d->Res_L;
00697 ResR = d->Res_R;
00698 L = d->SCF_Index_L[0];
00699 R = d->SCF_Index_R[0];
00700 for (n=0; n <= Max_used_Band; ++n, ++ResL, ++ResR, L+=3, R+=3)
00701 {
00702 if (*ResL)
00703 {
00704
00705 if (d->DSCF_Flag_L[n]==1)
00706 {
00707 L[2] = d->DSCF_Reference_L[n];
00708 switch (d->SCFI_L[n])
00709 {
00710 case 3:
00711 L[0] = L[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00712 L[1] = L[0];
00713 L[2] = L[1];
00714 break;
00715 case 1:
00716 L[0] = L[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00717 L[1] = L[0] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00718 L[2] = L[1];
00719 break;
00720 case 2:
00721 L[0] = L[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00722 L[1] = L[0];
00723 L[2] = L[1] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00724 break;
00725 case 0:
00726 L[0] = L[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00727 L[1] = L[0] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00728 L[2] = L[1] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00729 break;
00730 default:
00731 return;
00732 break;
00733 }
00734 }
00735
00736 else
00737 {
00738 switch (d->SCFI_L[n])
00739 {
00740 case 3:
00741 L[0] = mpc_decoder_bitstream_read(d, 6);
00742 L[1] = L[0];
00743 L[2] = L[1];
00744 break;
00745 case 1:
00746 L[0] = mpc_decoder_bitstream_read(d, 6);
00747 L[1] = mpc_decoder_bitstream_read(d, 6);
00748 L[2] = L[1];
00749 break;
00750 case 2:
00751 L[0] = mpc_decoder_bitstream_read(d, 6);
00752 L[1] = L[0];
00753 L[2] = mpc_decoder_bitstream_read(d, 6);
00754 break;
00755 case 0:
00756 L[0] = mpc_decoder_bitstream_read(d, 6);
00757 L[1] = mpc_decoder_bitstream_read(d, 6);
00758 L[2] = mpc_decoder_bitstream_read(d, 6);
00759 break;
00760 default:
00761 return;
00762 break;
00763 }
00764 }
00765
00766 d->DSCF_Reference_L[n] = L[2];
00767 }
00768 if (*ResR)
00769 {
00770 R[2] = d->DSCF_Reference_R[n];
00771
00772 if (d->DSCF_Flag_R[n]==1)
00773 {
00774 switch (d->SCFI_R[n])
00775 {
00776 case 3:
00777 R[0] = R[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00778 R[1] = R[0];
00779 R[2] = R[1];
00780 break;
00781 case 1:
00782 R[0] = R[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00783 R[1] = R[0] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00784 R[2] = R[1];
00785 break;
00786 case 2:
00787 R[0] = R[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00788 R[1] = R[0];
00789 R[2] = R[1] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00790 break;
00791 case 0:
00792 R[0] = R[2] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00793 R[1] = R[0] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00794 R[2] = R[1] + mpc_decoder_huffman_decode_fast(d, d->DSCF_Entropie);
00795 break;
00796 default:
00797 return;
00798 break;
00799 }
00800 }
00801
00802 else
00803 {
00804 switch (d->SCFI_R[n])
00805 {
00806 case 3:
00807 R[0] = mpc_decoder_bitstream_read(d, 6);
00808 R[1] = R[0];
00809 R[2] = R[1];
00810 break;
00811 case 1:
00812 R[0] = mpc_decoder_bitstream_read(d, 6);
00813 R[1] = mpc_decoder_bitstream_read(d, 6);
00814 R[2] = R[1];
00815 break;
00816 case 2:
00817 R[0] = mpc_decoder_bitstream_read(d, 6);
00818 R[1] = R[0];
00819 R[2] = mpc_decoder_bitstream_read(d, 6);
00820 break;
00821 case 0:
00822 R[0] = mpc_decoder_bitstream_read(d, 6);
00823 R[1] = mpc_decoder_bitstream_read(d, 6);
00824 R[2] = mpc_decoder_bitstream_read(d, 6);
00825 break;
00826 default:
00827 return;
00828 break;
00829 }
00830 }
00831
00832 d->DSCF_Reference_R[n] = R[2];
00833 }
00834 }
00835
00836
00837 ResL = d->Res_L;
00838 ResR = d->Res_R;
00839 for (n=0; n <= Max_used_Band; ++n, ++ResL, ++ResR)
00840 {
00841
00842 x1 = d->SampleHuff[*ResL];
00843 x2 = d->SampleHuff[*ResR];
00844 L = d->Q[n].L;
00845 R = d->Q[n].R;
00846
00847 if (x1!=NULL || x2!=NULL)
00848 for (k=0; k<36; ++k)
00849 {
00850 if (x1 != NULL) *L++ = mpc_decoder_huffman_decode_fast(d, x1);
00851 if (x2 != NULL) *R++ = mpc_decoder_huffman_decode_fast(d, x2);
00852 }
00853
00854 if (*ResL>7 || *ResR>7)
00855 for (k=0; k<36; ++k)
00856 {
00857 if (*ResL>7) *L++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResL]) - Dc[*ResL];
00858 if (*ResR>7) *R++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResR]) - Dc[*ResR];
00859 }
00860 }
00861 }
00862
00863
00864 void
00865 mpc_decoder_read_bitstream_sv7(mpc_decoder *d)
00866 {
00867
00868 mpc_int32_t idx30[] = { -1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1};
00869 mpc_int32_t idx31[] = { -1,-1,-1, 0, 0, 0, 1, 1, 1,-1,-1,-1, 0, 0, 0, 1, 1, 1,-1,-1,-1, 0, 0, 0, 1, 1, 1};
00870 mpc_int32_t idx32[] = { -1,-1,-1,-1,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1};
00871 mpc_int32_t idx50[] = { -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
00872 mpc_int32_t idx51[] = { -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2};
00873
00874 mpc_int32_t n,k;
00875 mpc_int32_t Max_used_Band=0;
00876 const HuffmanTyp *Table;
00877 mpc_int32_t idx;
00878 mpc_int32_t *L ,*R;
00879 mpc_int32_t *ResL,*ResR;
00880 mpc_uint32_t tmp;
00881
00882
00883 ResL = d->Res_L;
00884 ResR = d->Res_R;
00885
00886
00887 *ResL = mpc_decoder_bitstream_read(d, 4);
00888 *ResR = mpc_decoder_bitstream_read(d, 4);
00889 if (d->MS_used && !(*ResL==0 && *ResR==0)) {
00890 d->MS_Flag[0] = mpc_decoder_bitstream_read(d, 1);
00891 }
00892
00893
00894 ++ResL; ++ResR;
00895 for (n=1; n <= d->Max_Band; ++n, ++ResL, ++ResR)
00896 {
00897 idx = mpc_decoder_huffman_decode_fast(d, d->HuffHdr);
00898 *ResL = (idx!=4) ? *(ResL-1) + idx : (int) mpc_decoder_bitstream_read(d, 4);
00899
00900 idx = mpc_decoder_huffman_decode_fast(d, d->HuffHdr);
00901 *ResR = (idx!=4) ? *(ResR-1) + idx : (int) mpc_decoder_bitstream_read(d, 4);
00902
00903 if (d->MS_used && !(*ResL==0 && *ResR==0)) {
00904 d->MS_Flag[n] = mpc_decoder_bitstream_read(d, 1);
00905 }
00906
00907
00908 if (*ResL!=0 || *ResR!=0) {
00909 Max_used_Band = n;
00910 }
00911 }
00912
00913 L = d->SCFI_L;
00914 R = d->SCFI_R;
00915 ResL = d->Res_L;
00916 ResR = d->Res_R;
00917 for (n=0; n <= Max_used_Band; ++n, ++L, ++R, ++ResL, ++ResR) {
00918 if (*ResL) *L = mpc_decoder_huffman_decode_faster(d, d->HuffSCFI);
00919 if (*ResR) *R = mpc_decoder_huffman_decode_faster(d, d->HuffSCFI);
00920 }
00921
00922
00923 ResL = d->Res_L;
00924 ResR = d->Res_R;
00925 L = d->SCF_Index_L[0];
00926 R = d->SCF_Index_R[0];
00927 for (n=0; n<=Max_used_Band; ++n, ++ResL, ++ResR, L+=3, R+=3) {
00928 if (*ResL)
00929 {
00930 L[2] = d->DSCF_Reference_L[n];
00931 switch (d->SCFI_L[n])
00932 {
00933 case 1:
00934 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00935 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00936 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00937 L[1] = (idx!=8) ? L[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00938 L[2] = L[1];
00939 break;
00940 case 3:
00941 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00942 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00943 L[1] = L[0];
00944 L[2] = L[1];
00945 break;
00946 case 2:
00947 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00948 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00949 L[1] = L[0];
00950 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00951 L[2] = (idx!=8) ? L[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00952 break;
00953 case 0:
00954 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00955 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00956 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00957 L[1] = (idx!=8) ? L[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00958 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00959 L[2] = (idx!=8) ? L[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00960 break;
00961 default:
00962 return;
00963 break;
00964 }
00965
00966 d->DSCF_Reference_L[n] = L[2];
00967 }
00968 if (*ResR)
00969 {
00970 R[2] = d->DSCF_Reference_R[n];
00971 switch (d->SCFI_R[n])
00972 {
00973 case 1:
00974 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00975 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00976 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00977 R[1] = (idx!=8) ? R[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00978 R[2] = R[1];
00979 break;
00980 case 3:
00981 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00982 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00983 R[1] = R[0];
00984 R[2] = R[1];
00985 break;
00986 case 2:
00987 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00988 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00989 R[1] = R[0];
00990 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00991 R[2] = (idx!=8) ? R[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00992 break;
00993 case 0:
00994 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00995 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00996 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00997 R[1] = (idx!=8) ? R[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
00998 idx = mpc_decoder_huffman_decode_fast(d, d->HuffDSCF);
00999 R[2] = (idx!=8) ? R[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
01000 break;
01001 default:
01002 return;
01003 break;
01004 }
01005
01006 d->DSCF_Reference_R[n] = R[2];
01007 }
01008 }
01009
01010 ResL = d->Res_L;
01011 ResR = d->Res_R;
01012 L = d->Q[0].L;
01013 R = d->Q[0].R;
01014 for (n=0; n <= Max_used_Band; ++n, ++ResL, ++ResR, L+=36, R+=36)
01015 {
01016
01017 switch (*ResL)
01018 {
01019 case -2: case -3: case -4: case -5: case -6: case -7: case -8: case -9:
01020 case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17:
01021 L += 36;
01022 break;
01023 case -1:
01024 for (k=0; k<36; k++ ) {
01025 tmp = mpc_random_int(d);
01026 *L++ = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >> 8) & 0xFF) + ((tmp >> 0) & 0xFF) - 510;
01027 }
01028 break;
01029 case 0:
01030 L += 36;
01031 break;
01032 case 1:
01033 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][1];
01034 for (k=0; k<12; ++k)
01035 {
01036 idx = mpc_decoder_huffman_decode_fast(d, Table);
01037 *L++ = idx30[idx];
01038 *L++ = idx31[idx];
01039 *L++ = idx32[idx];
01040 }
01041 break;
01042 case 2:
01043 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][2];
01044 for (k=0; k<18; ++k)
01045 {
01046 idx = mpc_decoder_huffman_decode_fast(d, Table);
01047 *L++ = idx50[idx];
01048 *L++ = idx51[idx];
01049 }
01050 break;
01051 case 3:
01052 case 4:
01053 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
01054 for (k=0; k<36; ++k)
01055 *L++ = mpc_decoder_huffman_decode_faster(d, Table);
01056 break;
01057 case 5:
01058 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
01059 for (k=0; k<36; ++k)
01060 *L++ = mpc_decoder_huffman_decode_fast(d, Table);
01061 break;
01062 case 6:
01063 case 7:
01064 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
01065 for (k=0; k<36; ++k)
01066 *L++ = mpc_decoder_huffman_decode(d, Table);
01067 break;
01068 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
01069 tmp = Dc[*ResL];
01070 for (k=0; k<36; ++k)
01071 *L++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResL]) - tmp;
01072 break;
01073 default:
01074 return;
01075 }
01076
01077 switch (*ResR)
01078 {
01079 case -2: case -3: case -4: case -5: case -6: case -7: case -8: case -9:
01080 case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17:
01081 R += 36;
01082 break;
01083 case -1:
01084 for (k=0; k<36; k++ ) {
01085 tmp = mpc_random_int(d);
01086 *R++ = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >> 8) & 0xFF) + ((tmp >> 0) & 0xFF) - 510;
01087 }
01088 break;
01089 case 0:
01090 R += 36;
01091 break;
01092 case 1:
01093 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][1];
01094 for (k=0; k<12; ++k)
01095 {
01096 idx = mpc_decoder_huffman_decode_fast(d, Table);
01097 *R++ = idx30[idx];
01098 *R++ = idx31[idx];
01099 *R++ = idx32[idx];
01100 }
01101 break;
01102 case 2:
01103 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][2];
01104 for (k=0; k<18; ++k)
01105 {
01106 idx = mpc_decoder_huffman_decode_fast(d, Table);
01107 *R++ = idx50[idx];
01108 *R++ = idx51[idx];
01109 }
01110 break;
01111 case 3:
01112 case 4:
01113 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
01114 for (k=0; k<36; ++k)
01115 *R++ = mpc_decoder_huffman_decode_faster(d, Table);
01116 break;
01117 case 5:
01118 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
01119 for (k=0; k<36; ++k)
01120 *R++ = mpc_decoder_huffman_decode_fast(d, Table);
01121 break;
01122 case 6:
01123 case 7:
01124 Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
01125 for (k=0; k<36; ++k)
01126 *R++ = mpc_decoder_huffman_decode(d, Table);
01127 break;
01128 case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
01129 tmp = Dc[*ResR];
01130 for (k=0; k<36; ++k)
01131 *R++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResR]) - tmp;
01132 break;
01133 default:
01134 return;
01135 }
01136 }
01137 }
01138
01139 void mpc_decoder_setup(mpc_decoder *d, mpc_reader *r)
01140 {
01141 d->r = r;
01142
01143 d->HuffQ[0][0] = 0;
01144 d->HuffQ[1][0] = 0;
01145 d->HuffQ[0][1] = d->HuffQ1[0];
01146 d->HuffQ[1][1] = d->HuffQ1[1];
01147 d->HuffQ[0][2] = d->HuffQ2[0];
01148 d->HuffQ[1][2] = d->HuffQ2[1];
01149 d->HuffQ[0][3] = d->HuffQ3[0];
01150 d->HuffQ[1][3] = d->HuffQ3[1];
01151 d->HuffQ[0][4] = d->HuffQ4[0];
01152 d->HuffQ[1][4] = d->HuffQ4[1];
01153 d->HuffQ[0][5] = d->HuffQ5[0];
01154 d->HuffQ[1][5] = d->HuffQ5[1];
01155 d->HuffQ[0][6] = d->HuffQ6[0];
01156 d->HuffQ[1][6] = d->HuffQ6[1];
01157 d->HuffQ[0][7] = d->HuffQ7[0];
01158 d->HuffQ[1][7] = d->HuffQ7[1];
01159
01160 d->SampleHuff[0] = NULL;
01161 d->SampleHuff[1] = d->Entropie_1;
01162 d->SampleHuff[2] = d->Entropie_2;
01163 d->SampleHuff[3] = d->Entropie_3;
01164 d->SampleHuff[4] = d->Entropie_4;
01165 d->SampleHuff[5] = d->Entropie_5;
01166 d->SampleHuff[6] = d->Entropie_6;
01167 d->SampleHuff[7] = d->Entropie_7;
01168 d->SampleHuff[8] = NULL;
01169 d->SampleHuff[9] = NULL;
01170 d->SampleHuff[10] = NULL;
01171 d->SampleHuff[11] = NULL;
01172 d->SampleHuff[12] = NULL;
01173 d->SampleHuff[13] = NULL;
01174 d->SampleHuff[14] = NULL;
01175 d->SampleHuff[15] = NULL;
01176 d->SampleHuff[16] = NULL;
01177 d->SampleHuff[17] = NULL;
01178
01179 d->EQ_activated = 0;
01180 d->MPCHeaderPos = 0;
01181 d->StreamVersion = 0;
01182 d->MS_used = 0;
01183 d->FwdJumpInfo = 0;
01184 d->ActDecodePos = 0;
01185 d->FrameWasValid = 0;
01186 d->OverallFrames = 0;
01187 d->DecodedFrames = 0;
01188 d->LastValidSamples = 0;
01189 d->TrueGaplessPresent = 0;
01190 d->WordsRead = 0;
01191 d->Max_Band = 0;
01192 d->SampleRate = 0;
01193
01194 d->__r1 = 1;
01195 d->__r2 = 1;
01196
01197 d->dword = 0;
01198 d->pos = 0;
01199 d->Zaehler = 0;
01200 d->WordsRead = 0;
01201 d->Max_Band = 0;
01202
01203 mpc_decoder_initialisiere_quantisierungstabellen(d, 1.0f);
01204 mpc_decoder_init_huffman_sv6(d);
01205 mpc_decoder_init_huffman_sv7(d);
01206 }
01207
01208 void mpc_decoder_set_streaminfo(mpc_decoder *d, mpc_streaminfo *si)
01209 {
01210 mpc_decoder_reset_synthesis(d);
01211 mpc_decoder_reset_globals(d);
01212
01213 d->StreamVersion = si->stream_version;
01214 d->MS_used = si->ms;
01215 d->Max_Band = si->max_band;
01216 d->OverallFrames = si->frames;
01217 d->MPCHeaderPos = si->header_position;
01218 d->LastValidSamples = si->last_frame_samples;
01219 d->TrueGaplessPresent = si->is_true_gapless;
01220 d->SampleRate = (mpc_int32_t)si->sample_freq;
01221
01222 d->samples_to_skip = MPC_DECODER_SYNTH_DELAY;
01223 }
01224
01225 mpc_bool_t mpc_decoder_initialize(mpc_decoder *d, mpc_streaminfo *si)
01226 {
01227 mpc_decoder_set_streaminfo(d, si);
01228
01229
01230 switch (d->StreamVersion) {
01231 case 0x04: f_seek(d, 4 + d->MPCHeaderPos); d->pos = 16; break;
01232 case 0x05:
01233 case 0x06: f_seek(d, 8 + d->MPCHeaderPos); d->pos = 0; break;
01234 case 0x07:
01235 case 0x17: d->pos = 8; break;
01236 default: return FALSE;
01237 }
01238
01239
01240 f_read_dword(d, d->Speicher, MEMSIZE );
01241 d->dword = d->Speicher[d->Zaehler = 0];
01242
01243 return TRUE;
01244 }
01245
01246
01247
01248
01249
01250 #if 0
01251 static void
01252 helper1(mpc_decoder *d, mpc_uint32_t bitpos)
01253 {
01254 f_seek(d, (bitpos >> 5) * 4 + d->MPCHeaderPos);
01255 f_read_dword(d, d->Speicher, 2);
01256 d->dword = d->Speicher[d->Zaehler = 0];
01257 d->pos = bitpos & 31;
01258 }
01259 #endif
01260
01261 static void
01262 helper2(mpc_decoder *d, mpc_uint32_t bitpos)
01263 {
01264 f_seek(d, (bitpos>>5) * 4 + d->MPCHeaderPos);
01265 f_read_dword(d, d->Speicher, MEMSIZE);
01266 d->dword = d->Speicher[d->Zaehler = 0];
01267 d->pos = bitpos & 31;
01268 }
01269
01270 #if 0
01271 static void
01272 helper3(mpc_decoder *d, mpc_uint32_t bitpos, mpc_uint32_t* buffoffs)
01273 {
01274 d->pos = bitpos & 31;
01275 bitpos >>= 5;
01276 if ((mpc_uint32_t)(bitpos - *buffoffs) >= MEMSIZE - 2) {
01277 *buffoffs = bitpos;
01278 f_seek(d, bitpos * 4L + d->MPCHeaderPos);
01279 f_read_dword(d, d->Speicher, MEMSIZE );
01280 }
01281 d->dword = d->Speicher[d->Zaehler = bitpos - *buffoffs ];
01282 }
01283 #endif
01284
01285 static mpc_uint32_t get_initial_fpos(mpc_decoder *d, mpc_uint32_t StreamVersion)
01286 {
01287 mpc_uint32_t fpos = 0;
01288 (void) StreamVersion;
01289 switch ( d->StreamVersion ) {
01290 case 0x04: fpos = 48; break;
01291 case 0x05:
01292 case 0x06: fpos = 64; break;
01293 case 0x07:
01294 case 0x17: fpos = 200; break;
01295 }
01296 return fpos;
01297 }
01298
01299 mpc_bool_t mpc_decoder_seek_seconds(mpc_decoder *d, double seconds)
01300 {
01301 return mpc_decoder_seek_sample(d, (mpc_int64_t)(seconds * (double)d->SampleRate + 0.5));
01302 }
01303
01304 mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample)
01305 {
01306 mpc_uint32_t fpos;
01307 mpc_uint32_t fwd;
01308
01309 fwd = (mpc_uint32_t) (destsample / MPC_FRAME_LENGTH);
01310 d->samples_to_skip = MPC_DECODER_SYNTH_DELAY + (mpc_uint32_t)(destsample % MPC_FRAME_LENGTH);
01311
01312 memset(d->Y_L , 0, sizeof d->Y_L );
01313 memset(d->Y_R , 0, sizeof d->Y_R );
01314 memset(d->SCF_Index_L , 0, sizeof d->SCF_Index_L );
01315 memset(d->SCF_Index_R , 0, sizeof d->SCF_Index_R );
01316 memset(d->Res_L , 0, sizeof d->Res_L );
01317 memset(d->Res_R , 0, sizeof d->Res_R );
01318 memset(d->SCFI_L , 0, sizeof d->SCFI_L );
01319 memset(d->SCFI_R , 0, sizeof d->SCFI_R );
01320 memset(d->DSCF_Flag_L , 0, sizeof d->DSCF_Flag_L );
01321 memset(d->DSCF_Flag_R , 0, sizeof d->DSCF_Flag_R );
01322 memset(d->DSCF_Reference_L, 0, sizeof d->DSCF_Reference_L );
01323 memset(d->DSCF_Reference_R, 0, sizeof d->DSCF_Reference_R );
01324 memset(d->Q , 0, sizeof d->Q );
01325 memset(d->MS_Flag , 0, sizeof d->MS_Flag );
01326
01327
01328 mpc_decoder_reset_synthesis(d);
01329
01330
01331 fwd = fwd < d->OverallFrames ? fwd : d->OverallFrames;
01332
01333
01334 d->DecodedFrames = 0;
01335
01336 fpos = get_initial_fpos(d, d->StreamVersion);
01337 if (fpos == 0) {
01338 return FALSE;
01339 }
01340
01341 helper2(d, fpos);
01342
01343
01344 for ( ; d->DecodedFrames < fwd; d->DecodedFrames++ ) {
01345 mpc_uint32_t FrameBitCnt;
01346 mpc_uint32_t RING;
01347 RING = d->Zaehler;
01348 d->FwdJumpInfo = mpc_decoder_bitstream_read(d, 20);
01349 d->ActDecodePos = (d->Zaehler << 5) + d->pos;
01350 FrameBitCnt = mpc_decoder_bits_read(d);
01351 if (d->StreamVersion >= 7) {
01352 mpc_decoder_read_bitstream_sv7(d);
01353 }
01354 else {
01355 mpc_decoder_read_bitstream_sv6(d);
01356 }
01357 if (mpc_decoder_bits_read(d) - FrameBitCnt != d->FwdJumpInfo ) {
01358
01359 return FALSE;
01360 }
01361
01362 if ((RING ^ d->Zaehler) & MEMSIZE2) {
01363 f_read_dword(d, d->Speicher + (RING & MEMSIZE2), MEMSIZE2);
01364 }
01365 }
01366
01367
01368
01369
01370 return TRUE;
01371 }
01372
01373 void mpc_decoder_update_buffer(mpc_decoder *d, mpc_uint32_t RING)
01374 {
01375 if ((RING ^ d->Zaehler) & MEMSIZE2 ) {
01376
01377 f_read_dword(d, d->Speicher + (RING & MEMSIZE2), MEMSIZE2);
01378 }
01379 }
01380
01381