Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/zorg/src/mpc_decoder.c

    r18 r25  
    5959#endif
    6060
     61#ifndef MPC_LITTLE_ENDIAN
     62#define SWAP(X) mpc_swap32(X)
     63#else
     64#define SWAP(X) X
     65#endif
     66
     67#ifdef SCF_HACK
     68#define SCF_DIFF(SCF, D) (SCF == -128 ? -128 : SCF + D)
     69#else
     70#define SCF_DIFF(SCF, D) SCF + D
     71#endif
     72
     73#define LOOKUP(x, e, q) mpc_decoder_make_huffman_lookup ( (q), sizeof(q), (x), (e) )
     74#define DECODE_DSCF() HUFFMAN_DECODE_FASTEST ( d, mpc_table_HuffDSCF, LUTDSCF, 6 )
     75#define HUFFMAN_DECODE_FASTEST(d,a,b,c) mpc_decoder_huffman_decode_fastest ( (d), (a), (b), 32-(c) )
     76#define HUFFMAN_DECODE_FASTERER(d,a,b,c) mpc_decoder_huffman_decode_fasterer ( (d), (a), (b), 32-(c) )
     77
     78mpc_uint8_t     LUT1_0  [1<< 6];
     79mpc_uint8_t     LUT1_1  [1<< 9];            //  576 Bytes
     80mpc_uint8_t     LUT2_0  [1<< 7];
     81mpc_uint8_t     LUT2_1  [1<<10];            // 1152 Bytes
     82mpc_uint8_t     LUT3_0  [1<< 4];
     83mpc_uint8_t     LUT3_1  [1<< 5];            //   48 Bytes
     84mpc_uint8_t     LUT4_0  [1<< 4];
     85mpc_uint8_t     LUT4_1  [1<< 5];            //   48 Bytes
     86mpc_uint8_t     LUT5_0  [1<< 6];
     87mpc_uint8_t     LUT5_1  [1<< 8];            //  320 Bytes
     88mpc_uint8_t     LUT6_0  [1<< 7];
     89mpc_uint8_t     LUT6_1  [1<< 7];            //  256 Bytes
     90mpc_uint8_t     LUT7_0  [1<< 8];
     91mpc_uint8_t     LUT7_1  [1<< 8];            //  512 Bytes
     92mpc_uint8_t     LUTDSCF [1<< 6];            //   64 Bytes = 2976 Bytes
     93
    6194//------------------------------------------------------------------------------
    6295// types
    … …  
    76109//------------------------------------------------------------------------------
    77110void mpc_decoder_read_bitstream_sv6(mpc_decoder *d);
    78 void mpc_decoder_read_bitstream_sv7(mpc_decoder *d);
    79 void mpc_decoder_update_buffer(mpc_decoder *d, mpc_uint32_t RING);
     111void mpc_decoder_read_bitstream_sv7(mpc_decoder *d, mpc_bool_t isFastSeeking);
     112void mpc_decoder_update_buffer(mpc_decoder *d);
    80113mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample);
    81114void mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band);
     115void mpc_decoder_seek_to(mpc_decoder *d, mpc_uint32_t bitPos);
     116void mpc_decoder_seek_forward(mpc_decoder *d, mpc_uint32_t bits);
     117mpc_uint32_t mpc_decoder_jump_frame(mpc_decoder *d);
     118void mpc_decoder_fill_buffer(mpc_decoder *d);
     119void mpc_decoder_reset_state(mpc_decoder *d);
     120static mpc_uint32_t get_initial_fpos(mpc_decoder *d, mpc_uint32_t StreamVersion);
     121static __inline mpc_int32_t mpc_decoder_huffman_decode_fastest(mpc_decoder *d, const HuffmanTyp* Table, const mpc_uint8_t* tab, mpc_uint16_t unused_bits);
     122static void mpc_move_next(mpc_decoder *d);
    82123
    83124//------------------------------------------------------------------------------
    … …  
    130171    d->dword = 0;
    131172    d->pos = 0;
     173    d->next = 0;
    132174    d->Zaehler = 0;
    133175    d->WordsRead = 0;
    … …  
    141183}
    142184
     185static void
     186mpc_move_next(mpc_decoder *d)
     187{
     188    d->Zaehler = (d->Zaehler + 1) & MEMMASK;
     189    d->dword = d->next;
     190    d->next = SWAP(d->Speicher[(d->Zaehler + 1) & MEMMASK]);
     191    d->pos -= 32;
     192    ++(d->WordsRead);
     193}
     194
    143195// read desired number of bits out of the bitstream
    144 static mpc_uint32_t
     196static __inline mpc_uint32_t
    145197mpc_decoder_bitstream_read(mpc_decoder *d, const mpc_uint32_t bits)
    146198{
    … …  
    153205    }
    154206    else {
    155         d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
    156         d->pos -= 32;
     207        mpc_move_next(d);
    157208        if (d->pos) {
    158209            out <<= d->pos;
    159210            out |= d->dword >> (32 - d->pos);
    160211        }
    161         ++(d->WordsRead);
    162212    }
    163213
    164214    return out & mask[bits];
     215}
     216
     217static void
     218mpc_decoder_make_huffman_lookup(
     219    mpc_uint8_t* lookup, size_t length, const HuffmanTyp* Table, size_t elements)
     220{
     221    size_t i, idx  = elements;
     222    mpc_uint32_t dval = (mpc_uint32_t)0x80000000L / length * 2;
     223    mpc_uint32_t val  = dval - 1;
     224
     225    for ( i = 0; i < length; i++, val += dval ) {
     226        while ( idx > 0  &&  val >= Table[idx-1].Code )
     227            idx--;
     228        *lookup++ = (mpc_uint8_t)idx;
     229    }
     230
     231    return;
    165232}
    166233
    … …  
    174241    mpc_uint32_t code  = d->dword << d->pos;
    175242    if (d->pos > 26) {
    176         code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
     243        code |= d->next >> (32 - d->pos);
    177244    }
    178245    while (code < Table->Code) {
    … …  
    182249    // set the new position within bitstream without performing a dummy-read
    183250    if ((d->pos += Table->Length) >= 32) {
    184         d->pos -= 32;
    185         d->dword = d->Speicher[d->Zaehler = (d->Zaehler+1) & MEMMASK];
    186         ++(d->WordsRead);
     251         mpc_move_next(d);
    187252    }
    188253
    … …  
    199264    mpc_uint32_t code = d->dword << d->pos;
    200265    if (d->pos > 18) {
    201         code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
     266        code |= d->next >> (32 - d->pos);
    202267    }
    203268    while (code < Table->Code) {
    … …  
    207272    // set the new position within bitstream without performing a dummy-read
    208273    if ((d->pos += Table->Length) >= 32) {
    209         d->pos -= 32;
    210         d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
    211         ++(d->WordsRead);
     274        mpc_move_next(d);
    212275    }
    213276
    … …  
    223286    mpc_uint32_t code  = d->dword << d->pos;
    224287    if (d->pos > 22) {
    225         code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
     288        code |= d->next >> (32 - d->pos);
    226289    }
    227290    while (code < Table->Code) {
    … …  
    231294    // set the new position within bitstream without performing a dummy-read
    232295    if ((d->pos += Table->Length) >= 32) {
    233         d->pos -= 32;
    234         d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
    235         ++(d->WordsRead);
     296        mpc_move_next(d);
    236297    }
    237298
    … …  
    247308    mpc_uint32_t code  = d->dword << d->pos;
    248309    if (d->pos > 27) {
    249         code |= d->Speicher[(d->Zaehler + 1) & MEMMASK] >> (32 - d->pos);
     310        code |= d->next >> (32 - d->pos);
    250311    }
    251312    while (code < Table->Code) {
    … …  
    255316    // set the new position within bitstream without performing a dummy-read
    256317    if ((d->pos += Table->Length) >= 32) {
    257         d->pos -= 32;
    258         d->dword = d->Speicher[d->Zaehler = (d->Zaehler + 1) & MEMMASK];
    259         ++(d->WordsRead);
     318        mpc_move_next(d);
     319    }
     320
     321    return Table->Value;
     322}
     323
     324/* partial lookup table decode */
     325static mpc_int32_t
     326mpc_decoder_huffman_decode_fasterer(
     327    mpc_decoder *d,
     328    const HuffmanTyp* Table, const mpc_uint8_t* tab, mpc_uint16_t unused_bits)
     329{
     330    // load preview and decode
     331    mpc_uint32_t code  = d->dword << d->pos;
     332
     333    if (d->pos > 18) { // preview 14 bits
     334        code |= d->next >> (32 - d->pos);
     335    }
     336
     337    Table += tab [(size_t)(code >> unused_bits) ];
     338
     339    while (code < Table->Code) {
     340        Table++;
     341    }
     342
     343    // set the new position within bitstream without performing a dummy-read
     344    if ((d->pos += Table->Length) >= 32) {
     345        mpc_move_next(d);
     346    }
     347
     348    return Table->Value;
     349}
     350
     351/* full decode using lookup table */
     352static __inline mpc_int32_t
     353mpc_decoder_huffman_decode_fastest(
     354    mpc_decoder *d,
     355    const HuffmanTyp* Table, const mpc_uint8_t* tab, mpc_uint16_t unused_bits)
     356{
     357    // load preview and decode
     358    mpc_uint32_t code  = d->dword << d->pos;
     359
     360    if (d->pos > unused_bits) {
     361        code |= d->next >> (32 - d->pos);
     362    }
     363
     364    Table+=tab [(size_t)(code >> unused_bits) ];
     365
     366    // set the new position within bitstream without performing a dummy-read
     367    if ((d->pos += Table->Length) >= 32) {
     368        mpc_move_next(d);
    260369    }
    261370
    … …  
    289398
    290399    d->DecodedFrames  = 0;
     400    d->SeekTableIndex = 0;
     401    d->MaxDecodedFrames = 0;
    291402    d->StreamVersion  = 0;
    292403    d->MS_used        = 0;
    … …  
    314425                         mpc_uint32_t in_len, MPC_SAMPLE_FORMAT *out_buffer)
    315426{
    316   unsigned int i;
    317427  mpc_decoder_reset_bitstream_decode(d);
    318428  if (in_len > sizeof(d->Speicher)) in_len = sizeof(d->Speicher);
    319429  memcpy(d->Speicher, in_buffer, in_len);
    320 #ifdef MPC_LITTLE_ENDIAN
    321   for (i = 0; i < (in_len + 3) / 4; i++)
    322     d->Speicher[i] = mpc_swap32(d->Speicher[i]);
    323 #endif
    324   d->dword = d->Speicher[0];
     430   d->dword = SWAP(d->Speicher[0]);
     431   d->next  = SWAP(d->Speicher[1]);
    325432  switch (d->StreamVersion) {
    326433#ifdef MPC_SUPPORT_SV456
    … …  
    333440    case 0x07:
    334441    case 0x17:
    335         mpc_decoder_read_bitstream_sv7(d);
     442        mpc_decoder_read_bitstream_sv7(d, FALSE);
    336443        break;
    337444    default:
    … …  
    353460        return (mpc_uint32_t)(-1);                           // end of file -> abort decoding
    354461    }
     462
     463    if (d->DecodedFrames == 0 && d->Use_SeekTable)
     464        d->SeekTable[0] = mpc_decoder_bits_read(d);
    355465
    356466    // read jump-info for validity check of frame
    … …  
    371481    case 0x07:
    372482    case 0x17:
    373         mpc_decoder_read_bitstream_sv7(d);
     483        mpc_decoder_read_bitstream_sv7(d, FALSE);
    374484        break;
    375485    default:
    … …  
    378488    d->FrameWasValid = mpc_decoder_bits_read(d) - FrameBitCnt == d->FwdJumpInfo;
    379489
     490    d->DecodedFrames++;
     491
     492    if (d->Use_SeekTable) {
     493        if (d->SeekTable_Step == 1) {
     494            d->SeekTable [d->DecodedFrames] = d->FwdJumpInfo + 20;
     495        } else {
     496            if ((d->DecodedFrames-1) % d->SeekTable_Step == 0) {
     497                d->SeekTable[d->SeekTableIndex] = d->SeekTableCounter;
     498                d->SeekTableIndex  += 1;
     499                d->SeekTableCounter = 0;
     500            }
     501            d->SeekTableCounter += d->FwdJumpInfo + 20;
     502        }
     503    }
     504
    380505    // synthesize signal
    381506    mpc_decoder_requantisierung(d, d->Max_Band);
    … …  
    385510
    386511    mpc_decoder_synthese_filter_float(d, buffer);
    387 
    388     d->DecodedFrames++;
    389512
    390513    // cut off first MPC_DECODER_SYNTH_DELAY zero-samples
    … …  
    406529            } else {
    407530                mpc_decoder_bitstream_read(d, 20);
    408                 mpc_decoder_read_bitstream_sv7(d);
     531                mpc_decoder_read_bitstream_sv7(d, FALSE);
    409532                mpc_decoder_requantisierung(d, d->Max_Band);
    410533            }
    … …  
    472595
    473596        }
    474         mpc_decoder_update_buffer(d, RING);
     597        mpc_decoder_update_buffer(d);
    475598
    476599        if (valid_samples > 0) {
    … …  
    8871010/****************************************** SV 7 ******************************************/
    8881011void
    889 mpc_decoder_read_bitstream_sv7(mpc_decoder *d)
     1012mpc_decoder_read_bitstream_sv7(mpc_decoder *d, mpc_bool_t isFastSeeking)
    8901013{
    8911014    // these arrays hold decoding results for bundled quantizers (3- and 5-step)
    … …  
    9041027    mpc_int8_t   *ResL, *ResR;
    9051028    mpc_uint32_t tmp;
     1029    mpc_uint8_t *LUT;
     1030    mpc_uint8_t max_length;
    9061031
    9071032    /***************************** Header *****************************/
    … …  
    9141039    if (d->MS_used && !(*ResL==0 && *ResR==0)) {
    9151040        d->MS_Flag[0] = mpc_decoder_bitstream_read(d, 1);
     1041    } else {
     1042        d->MS_Flag[0] = 0;
    9161043    }
    9171044
    … …  
    9281055        if (d->MS_used && !(*ResL==0 && *ResR==0)) {
    9291056            d->MS_Flag[n] = mpc_decoder_bitstream_read(d, 1);
     1057        } else {
     1058            d->MS_Flag[n] = 0;
    9301059        }
    9311060
    … …  
    9571086            {
    9581087            case 1:
    959                 idx  = mpc_decoder_huffman_decode_fast(d, mpc_table_HuffDSCF);
    960                 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
    961                 idx  = mpc_decoder_huffman_decode_fast(d, mpc_table_HuffDSCF);
    962                 L[1] = (idx!=8) ? L[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1088                idx  = DECODE_DSCF();
     1089                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : mpc_decoder_bitstream_read(d, 6);
     1090                idx  = DECODE_DSCF();
     1091                L[1] = (idx!=8) ? SCF_DIFF(L[0], idx) : mpc_decoder_bitstream_read(d, 6);
    9631092                L[2] = L[1];
    9641093                break;
    9651094            case 3:
    966                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    967                 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1095                idx  = DECODE_DSCF();
     1096                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : mpc_decoder_bitstream_read(d, 6);
    9681097                L[1] = L[0];
    9691098                L[2] = L[1];
    9701099                break;
    9711100            case 2:
    972                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    973                 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1101                idx  = DECODE_DSCF();
     1102                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : mpc_decoder_bitstream_read(d, 6);
    9741103                L[1] = L[0];
    975                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    976                 L[2] = (idx!=8) ? L[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1104                idx  = DECODE_DSCF();
     1105                L[2] = (idx!=8) ? SCF_DIFF(L[1], idx) : mpc_decoder_bitstream_read(d, 6);
    9771106                break;
    9781107            case 0:
    979                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    980                 L[0] = (idx!=8) ? L[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
    981                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    982                 L[1] = (idx!=8) ? L[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
    983                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    984                 L[2] = (idx!=8) ? L[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1108                idx  = DECODE_DSCF();
     1109                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : mpc_decoder_bitstream_read(d, 6);
     1110                idx  = DECODE_DSCF();
     1111                L[1] = (idx!=8) ? SCF_DIFF(L[0], idx) : mpc_decoder_bitstream_read(d, 6);
     1112                idx  = DECODE_DSCF();
     1113                L[2] = (idx!=8) ? SCF_DIFF(L[1], idx) : mpc_decoder_bitstream_read(d, 6);
    9851114                break;
    9861115            default:
    … …  
    9971126            {
    9981127            case 1:
    999                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1000                 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
    1001                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1002                 R[1] = (idx!=8) ? R[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1128                idx  = DECODE_DSCF();
     1129                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : mpc_decoder_bitstream_read(d, 6);
     1130                idx  = DECODE_DSCF();
     1131                R[1] = (idx!=8) ? SCF_DIFF(R[0], idx) : mpc_decoder_bitstream_read(d, 6);
    10031132                R[2] = R[1];
    10041133                break;
    10051134            case 3:
    1006                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1007                 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1135                idx  = DECODE_DSCF();
     1136                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : mpc_decoder_bitstream_read(d, 6);
    10081137                R[1] = R[0];
    10091138                R[2] = R[1];
    10101139                break;
    10111140            case 2:
    1012                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1013                 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1141                idx  = DECODE_DSCF();
     1142                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : mpc_decoder_bitstream_read(d, 6);
    10141143                R[1] = R[0];
    1015                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1016                 R[2] = (idx!=8) ? R[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1144                idx  = DECODE_DSCF();
     1145                R[2] = (idx!=8) ? SCF_DIFF(R[1], idx) : mpc_decoder_bitstream_read(d, 6);
    10171146                break;
    10181147            case 0:
    1019                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1020                 R[0] = (idx!=8) ? R[2] + idx : (int) mpc_decoder_bitstream_read(d, 6);
    1021                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1022                 R[1] = (idx!=8) ? R[0] + idx : (int) mpc_decoder_bitstream_read(d, 6);
    1023                 idx  = mpc_decoder_huffman_decode_fast(d,  mpc_table_HuffDSCF);
    1024                 R[2] = (idx!=8) ? R[1] + idx : (int) mpc_decoder_bitstream_read(d, 6);
     1148                idx  = DECODE_DSCF();
     1149                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : mpc_decoder_bitstream_read(d, 6);
     1150                idx  = DECODE_DSCF();
     1151                R[1] = (idx!=8) ? SCF_DIFF(R[0], idx) : mpc_decoder_bitstream_read(d, 6);
     1152                idx  = DECODE_DSCF();
     1153                R[2] = (idx!=8) ? SCF_DIFF(R[1], idx) : mpc_decoder_bitstream_read(d, 6);
    10251154                break;
    10261155            default:
    … …  
    10321161        }
    10331162    }
     1163
     1164    if(isFastSeeking)
     1165        return;
     1166
    10341167    /***************************** Samples ****************************/
    10351168    ResL = d->Res_L;
    … …  
    10561189            break;
    10571190        case 1:
    1058             Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][1];
     1191            if (mpc_decoder_bitstream_read(d, 1)) {
     1192                Table = mpc_table_HuffQ[1][1];
     1193                LUT = LUT1_1;
     1194                max_length = 9;
     1195            } else {
     1196                Table = mpc_table_HuffQ[0][1];
     1197                LUT = LUT1_0;
     1198                max_length = 6;
     1199            }
    10591200            for (k=0; k<12; ++k)
    10601201            {
    1061                 idx = mpc_decoder_huffman_decode_fast(d,  Table);
     1202                idx   = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    10621203                *LQ++ = idx30[idx];
    10631204                *LQ++ = idx31[idx];
    … …  
    10661207            break;
    10671208        case 2:
    1068             Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][2];
     1209            if (mpc_decoder_bitstream_read(d, 1)) {
     1210                Table = mpc_table_HuffQ[1][2];
     1211                LUT = LUT2_1;
     1212                max_length = 10;
     1213            } else {
     1214                Table = mpc_table_HuffQ[0][2];
     1215                LUT = LUT2_0;
     1216                max_length = 7;
     1217            }
    10691218            for (k=0; k<18; ++k)
    10701219            {
    1071                 idx = mpc_decoder_huffman_decode_fast(d,  Table);
     1220                idx   = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    10721221                *LQ++ = idx50[idx];
    10731222                *LQ++ = idx51[idx];
    … …  
    10751224            break;
    10761225        case 3:
     1226            if (mpc_decoder_bitstream_read(d, 1)) {
     1227                Table = mpc_table_HuffQ[1][3];
     1228                LUT = LUT3_1;
     1229                max_length = 5;
     1230            } else {
     1231                Table = mpc_table_HuffQ[0][3];
     1232                LUT = LUT3_0;
     1233                max_length = 4;
     1234            }
     1235            for (k=0; k<36; ++k)
     1236                *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
     1237            break;
    10771238        case 4:
    1078             Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
     1239            if (mpc_decoder_bitstream_read(d, 1)) {
     1240                Table = mpc_table_HuffQ[1][4];
     1241                LUT = LUT4_1;
     1242                max_length = 5;
     1243            } else {
     1244                Table = mpc_table_HuffQ[0][4];
     1245                LUT = LUT4_0;
     1246                max_length = 4;
     1247            }
    10791248            for (k=0; k<36; ++k)
    1080                 *LQ++ = mpc_decoder_huffman_decode_faster(d, Table);
     1249                *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    10811250            break;
    10821251        case 5:
    1083             Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
     1252            if (mpc_decoder_bitstream_read(d, 1)) {
     1253                Table = mpc_table_HuffQ[1][5];
     1254                LUT = LUT5_1;
     1255                max_length = 8;
     1256            } else {
     1257                Table = mpc_table_HuffQ[0][5];
     1258                LUT = LUT5_0;
     1259                max_length = 6;
     1260            }
    10841261            for (k=0; k<36; ++k)
    1085                 *LQ++ = mpc_decoder_huffman_decode_fast(d, Table);
     1262                *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    10861263            break;
    10871264        case 6:
     1265            if (mpc_decoder_bitstream_read(d, 1)) {
     1266                Table = mpc_table_HuffQ[1][6];
     1267                LUT = LUT6_1;
     1268                max_length = 7;
     1269                for (k=0; k<36; ++k)
     1270                    *LQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
     1271            } else {
     1272                Table = mpc_table_HuffQ[0][6];
     1273                LUT = LUT6_0;
     1274                max_length = 7;
     1275                for (k=0; k<36; ++k)
     1276                    *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
     1277            }
     1278            break;
    10881279        case 7:
    1089             Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
    1090             for (k=0; k<36; ++k)
    1091                 *LQ++ = mpc_decoder_huffman_decode(d, Table);
     1280            if (mpc_decoder_bitstream_read(d, 1)) {
     1281                Table = mpc_table_HuffQ[1][7];
     1282                LUT = LUT7_1;
     1283                max_length = 8;
     1284                for (k=0; k<36; ++k)
     1285                    *LQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
     1286            } else {
     1287                Table = mpc_table_HuffQ[0][7];
     1288                LUT = LUT7_0;
     1289                max_length = 8;
     1290                for (k=0; k<36; ++k)
     1291                    *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
     1292            }
    10921293            break;
    10931294        case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
    10941295            tmp = Dc[*ResL];
    10951296            for (k=0; k<36; ++k)
    1096                 *LQ++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResL]) - tmp;
     1297                *LQ++ = (mpc_int16_t) mpc_decoder_bitstream_read(d, Res_bit[*ResL]) - tmp;
    10971298            break;
    10981299        default:
    … …  
    11161317                break;
    11171318            case 1:
    1118                 Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][1];
     1319                if (mpc_decoder_bitstream_read(d, 1)) {
     1320                    Table = mpc_table_HuffQ[1][1];
     1321                    LUT = LUT1_1;
     1322                    max_length = 9;
     1323                } else {
     1324                    Table = mpc_table_HuffQ[0][1];
     1325                    LUT = LUT1_0;
     1326                    max_length = 6;
     1327                }
    11191328                for (k=0; k<12; ++k)
    11201329                {
    1121                     idx = mpc_decoder_huffman_decode_fast(d, Table);
     1330                    idx = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    11221331                    *RQ++ = idx30[idx];
    11231332                    *RQ++ = idx31[idx];
    … …  
    11261335                break;
    11271336            case 2:
    1128                 Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][2];
     1337                if (mpc_decoder_bitstream_read(d, 1)) {
     1338                    Table = mpc_table_HuffQ[1][2];
     1339                    LUT = LUT2_1;
     1340                    max_length = 10;
     1341                } else {
     1342                    Table = mpc_table_HuffQ[0][2];
     1343                    LUT = LUT2_0;
     1344                    max_length = 7;
     1345                }
    11291346                for (k=0; k<18; ++k)
    11301347                {
    1131                     idx = mpc_decoder_huffman_decode_fast(d, Table);
     1348                    idx = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    11321349                    *RQ++ = idx50[idx];
    11331350                    *RQ++ = idx51[idx];
    … …  
    11351352                break;
    11361353            case 3:
     1354                if (mpc_decoder_bitstream_read(d, 1)) {
     1355                    Table = mpc_table_HuffQ[1][3];
     1356                    LUT = LUT3_1;
     1357                    max_length = 5;
     1358                } else {
     1359                    Table = mpc_table_HuffQ[0][3];
     1360                    LUT = LUT3_0;
     1361                    max_length = 4;
     1362                }
     1363                for (k=0; k<36; ++k)
     1364                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
     1365                break;
    11371366            case 4:
    1138                 Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
     1367                if (mpc_decoder_bitstream_read(d, 1)) {
     1368                    Table = mpc_table_HuffQ[1][4];
     1369                    LUT = LUT4_1;
     1370                    max_length = 5;
     1371                } else {
     1372                    Table = mpc_table_HuffQ[0][4];
     1373                    LUT = LUT4_0;
     1374                    max_length = 4;
     1375                }
    11391376                for (k=0; k<36; ++k)
    1140                     *RQ++ = mpc_decoder_huffman_decode_faster(d, Table);
     1377                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    11411378                break;
    11421379            case 5:
    1143                 Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
     1380                if (mpc_decoder_bitstream_read(d, 1)) {
     1381                    Table = mpc_table_HuffQ[1][5];
     1382                    LUT = LUT5_1;
     1383                    max_length = 8;
     1384                } else {
     1385                    Table = mpc_table_HuffQ[0][5];
     1386                    LUT = LUT5_0;
     1387                    max_length = 6;
     1388                }
    11441389                for (k=0; k<36; ++k)
    1145                     *RQ++ = mpc_decoder_huffman_decode_fast(d, Table);
     1390                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
    11461391                break;
    11471392            case 6:
     1393                if (mpc_decoder_bitstream_read(d, 1)) {
     1394                    Table = mpc_table_HuffQ[1][6];
     1395                    LUT = LUT6_1;
     1396                    max_length = 7;
     1397                    for (k=0; k<36; ++k)
     1398                        *RQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
     1399                } else {
     1400                    Table = mpc_table_HuffQ[0][6];
     1401                    LUT = LUT6_0;
     1402                    max_length = 7;
     1403                    for (k=0; k<36; ++k)
     1404                        *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
     1405                }
     1406                break;
    11481407            case 7:
    1149                 Table = mpc_table_HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
    1150                 for (k=0; k<36; ++k)
    1151                     *RQ++ = mpc_decoder_huffman_decode(d, Table);
     1408                if (mpc_decoder_bitstream_read(d, 1)) {
     1409                    Table = mpc_table_HuffQ[1][7];
     1410                    LUT = LUT7_1;
     1411                    max_length = 8;
     1412                    for (k=0; k<36; ++k)
     1413                        *RQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
     1414                } else {
     1415                    Table = mpc_table_HuffQ[0][7];
     1416                    LUT = LUT7_0;
     1417                    max_length = 8;
     1418                    for (k=0; k<36; ++k)
     1419                        *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
     1420                }
    11521421                break;
    11531422            case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
    11541423                tmp = Dc[*ResR];
    11551424                for (k=0; k<36; ++k)
    1156                     *RQ++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResR]) - tmp;
     1425                    *RQ++ = (mpc_int16_t) mpc_decoder_bitstream_read(d, Res_bit[*ResR]) - tmp;
    11571426                break;
    11581427            default:
    … …  
    11741443  d->OverallFrames = 0;
    11751444  d->DecodedFrames = 0;
     1445  d->MaxDecodedFrames = 0;
    11761446  d->TrueGaplessPresent = 0;
    11771447  d->WordsRead = 0;
    … …  
    11841454  d->pos = 0;
    11851455  d->Zaehler = 0;
     1456  d->Ring = 0;
    11861457  d->WordsRead = 0;
    11871458  d->Max_Band = 0;
     1459  d->SeekTable = NULL;
     1460  d->Use_FastSeek = TRUE;
     1461  d->Use_SeekTable = TRUE;
     1462  d->Use_StaticSeekTable = FALSE;
     1463  d->SeekTable_Step = 1;
     1464  d->SeekTableIndex = 0;
     1465  d->SeekTableCounter = 0;
     1466  d->Max_SeekTable_Size = 0;
    11881467
    11891468  mpc_decoder_initialisiere_quantisierungstabellen(d, 1.0f);
    11901469#if 0
    1191   mpc_decoder_init_huffman_sv6(d);
    1192   mpc_decoder_init_huffman_sv7(d);
     1470    mpc_decoder_init_huffman_sv6(d);
     1471    mpc_decoder_init_huffman_sv7(d);
    11931472#endif
     1473
     1474  LOOKUP ( mpc_table_HuffQ[0][1], 27, LUT1_0  );
     1475  LOOKUP ( mpc_table_HuffQ[1][1], 27, LUT1_1  );
     1476  LOOKUP ( mpc_table_HuffQ[0][2], 25, LUT2_0  );
     1477  LOOKUP ( mpc_table_HuffQ[1][2], 25, LUT2_1  );
     1478  LOOKUP ( mpc_table_HuffQ[0][3], 7,  LUT3_0  );
     1479  LOOKUP ( mpc_table_HuffQ[1][3], 7,  LUT3_1  );
     1480  LOOKUP ( mpc_table_HuffQ[0][4], 9,  LUT4_0  );
     1481  LOOKUP ( mpc_table_HuffQ[1][4], 9,  LUT4_1  );
     1482  LOOKUP ( mpc_table_HuffQ[0][5], 15, LUT5_0  );
     1483  LOOKUP ( mpc_table_HuffQ[1][5], 15, LUT5_1  );
     1484  LOOKUP ( mpc_table_HuffQ[0][6], 31, LUT6_0  );
     1485  LOOKUP ( mpc_table_HuffQ[1][6], 31, LUT6_1  );
     1486  LOOKUP ( mpc_table_HuffQ[0][7], 63, LUT7_0  );
     1487  LOOKUP ( mpc_table_HuffQ[1][7], 63, LUT7_1  );
     1488  LOOKUP ( mpc_table_HuffDSCF,    16, LUTDSCF );
     1489}
     1490
     1491void mpc_decoder_destroy(mpc_decoder *d)
     1492{
     1493    free(d->Speicher);
     1494    if (d->SeekTable != NULL && d->Use_StaticSeekTable == FALSE)
     1495        free(d->SeekTable);
    11941496}
    11951497
    11961498void mpc_decoder_set_streaminfo(mpc_decoder *d, mpc_streaminfo *si)
    11971499{
     1500    mpc_uint16_t seekTableSize;
     1501
    11981502    mpc_decoder_reset_synthesis(d);
    11991503    mpc_decoder_reset_globals(d);
    … …  
    12081512
    12091513    d->samples_to_skip = MPC_DECODER_SYNTH_DELAY;
     1514
     1515    if (d->SeekTable != NULL && d->Use_StaticSeekTable == FALSE)
     1516        free(d->SeekTable);
     1517
     1518    if (d->Use_SeekTable) {
     1519        if (d->Use_StaticSeekTable == FALSE) {
     1520            if (d->Max_SeekTable_Size == 0) {
     1521                seekTableSize = si->frames +1;
     1522            } else {
     1523                seekTableSize = min(si->frames +1, d->Max_SeekTable_Size / sizeof(mpc_uint32_t));
     1524            }
     1525            d->SeekTable = (mpc_uint32_t*) calloc(seekTableSize, sizeof(mpc_uint32_t));
     1526            d->SeekTable_Step = (si->frames +1) / seekTableSize;
     1527            if ((si->frames +1) % seekTableSize)
     1528                d->SeekTable_Step+=1;
     1529        } else {
     1530            seekTableSize = d->Max_SeekTable_Size / sizeof(mpc_uint32_t);
     1531            d->SeekTable_Step = (si->frames +1) / seekTableSize;
     1532            if ((si->frames +1) % seekTableSize)
     1533                d->SeekTable_Step+=1;
     1534        }
     1535    }
    12101536}
    12111537
    12121538mpc_bool_t mpc_decoder_initialize(mpc_decoder *d, mpc_streaminfo *si)
    12131539{
     1540    mpc_uint32_t bitPos;
     1541    mpc_uint32_t fpos;
     1542
     1543    d->Speicher = malloc(MPC_DECODER_MEMSIZE * sizeof(mpc_uint32_t));
    12141544    mpc_decoder_set_streaminfo(d, si);
    12151545
    1216     // AB: setting position to the beginning of the data-bitstream
    1217     switch (d->StreamVersion) {
    1218     case 0x04: f_seek(d, 4 + d->MPCHeaderPos); d->pos = 16; break;  // Geht auch über eine der Helperfunktionen
    1219     case 0x05:
    1220     case 0x06: f_seek(d, 8 + d->MPCHeaderPos); d->pos =  0; break;
    1221     case 0x07:
    1222     case 0x17: /*f_seek ( 24 + d->MPCHeaderPos );*/ d->pos =  8; break;
    1223     default: return FALSE;
    1224     }
    1225 
    1226     // AB: fill buffer and initialize decoder
     1546     // setting position to the beginning of the data-bitstream
     1547     bitPos = get_initial_fpos(d, d->StreamVersion);
     1548     fpos = bitPos >> 5;
     1549
     1550    // fill buffer and initialize decoder
     1551        f_seek(d, fpos*4 + d->MPCHeaderPos);
    12271552    f_read_dword(d, d->Speicher, MEMSIZE );
    1228     d->dword = d->Speicher[d->Zaehler = 0];
     1553    d->Ring = 0;
     1554    d->Zaehler = 0;
     1555    d->pos = bitPos & 31;
     1556    d->WordsRead = fpos;
     1557    d->dword = SWAP(d->Speicher[0]);
     1558    d->next = SWAP(d->Speicher[1]);
     1559    d->SeekTable_Step = 1;
    12291560
    12301561    return TRUE;
    … …  
    12411572    f_seek(d, (bitpos >> 5) * 4 + d->MPCHeaderPos);
    12421573    f_read_dword(d, d->Speicher, 2);
    1243     d->dword = d->Speicher[d->Zaehler = 0];
     1574    d->dword = SWAP(d->Speicher[d->Zaehler = 0]);
    12441575    d->pos = bitpos & 31;
    12451576}
    1246 #endif
    12471577
    12481578static void
    … …  
    12511581    f_seek(d, (bitpos>>5) * 4 + d->MPCHeaderPos);
    12521582    f_read_dword(d, d->Speicher, MEMSIZE);
    1253     d->dword = d->Speicher[d->Zaehler = 0];
     1583    d->dword = SWAP(d->Speicher[d->Zaehler = 0]);
    12541584    d->pos = bitpos & 31;
    12551585}
    12561586
    1257 #if 0
    12581587static void
    12591588helper3(mpc_decoder *d, mpc_uint32_t bitpos, mpc_uint32_t* buffoffs)
    … …  
    12661595        f_read_dword(d, d->Speicher, MEMSIZE );
    12671596    }
    1268     d->dword = d->Speicher[d->Zaehler = bitpos - *buffoffs ];
     1597    d->dword = SWAP(d->Speicher[d->Zaehler = bitpos - *buffoffs ]);
    12691598}
    12701599#endif
     1600
     1601// jumps over the current frame
     1602mpc_uint32_t mpc_decoder_jump_frame(mpc_decoder *d) {
     1603
     1604    mpc_uint32_t frameSize;
     1605
     1606    // ensure the buffer is full
     1607    mpc_decoder_update_buffer(d);
     1608
     1609    // bits in frame
     1610    frameSize = mpc_decoder_bitstream_read(d, 20);
     1611
     1612    // jump forward
     1613    mpc_decoder_seek_forward(d, frameSize);
     1614
     1615    return frameSize + 20;
     1616
     1617}
    12711618
    12721619static mpc_uint32_t get_initial_fpos(mpc_decoder *d, mpc_uint32_t StreamVersion)
    … …  
    12891636}
    12901637
    1291 mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample)
    1292 {
    1293     mpc_uint32_t fpos;
    1294     mpc_uint32_t fwd;
    1295 
    1296     fwd = (mpc_uint32_t) (destsample / MPC_FRAME_LENGTH);
    1297     d->samples_to_skip = MPC_DECODER_SYNTH_DELAY + (mpc_uint32_t)(destsample % MPC_FRAME_LENGTH);
     1638void mpc_decoder_reset_state(mpc_decoder *d) {
    12981639
    12991640    memset(d->Y_L          , 0, sizeof d->Y_L           );
    13001641    memset(d->Y_R          , 0, sizeof d->Y_R           );
     1642#ifdef SCF_HACK
     1643    memset(d->SCF_Index_L     , -128, sizeof d->SCF_Index_L      );
     1644    memset(d->SCF_Index_R     , -128, sizeof d->SCF_Index_R      );
     1645#else
    13011646    memset(d->SCF_Index_L     , 0, sizeof d->SCF_Index_L      );
    13021647    memset(d->SCF_Index_R     , 0, sizeof d->SCF_Index_R      );
     1648#endif
    13031649    memset(d->Res_L           , 0, sizeof d->Res_L            );
    13041650    memset(d->Res_R           , 0, sizeof d->Res_R            );
    … …  
    13131659    memset(d->Q               , 0, sizeof d->Q                );
    13141660    memset(d->MS_Flag         , 0, sizeof d->MS_Flag          );
    1315 
    1316     // resetting synthesis filter to avoid "clicks"
    1317     mpc_decoder_reset_synthesis(d);
     1661}
     1662
     1663mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample)
     1664{
     1665    mpc_uint32_t fpos;
     1666    mpc_uint32_t seekFrame = 0;   // the frame to seek to
     1667    mpc_uint32_t lastFrame = 0;   // last frame to seek to before scanning scale factors
     1668    mpc_uint32_t delta = 0;       // direction of seeks
     1669
     1670     destsample += MPC_DECODER_SYNTH_DELAY;
     1671     seekFrame = (mpc_uint32_t) ((destsample) / MPC_FRAME_LENGTH);
     1672     d->samples_to_skip = (mpc_uint32_t)((destsample) % MPC_FRAME_LENGTH);
    13181673
    13191674    // prevent from desired position out of allowed range
    1320     fwd = fwd < d->OverallFrames  ?  fwd  :  d->OverallFrames;
    1321 
    1322     // reset number of decoded frames
    1323     d->DecodedFrames = 0;
    1324 
    1325     fpos = get_initial_fpos(d, d->StreamVersion);
    1326     if (fpos == 0) {
    1327         return FALSE;
    1328     }
    1329 
    1330     helper2(d, fpos);
    1331 
    1332     // read the last 32 frames before the desired position to scan the scalefactors (artifactless jumping)
    1333     for ( ; d->DecodedFrames < fwd; d->DecodedFrames++ ) {
     1675    seekFrame = seekFrame < d->OverallFrames  ?  seekFrame  :  d->OverallFrames;
     1676
     1677    // seek direction (note: avoids casting to int64)
     1678    delta = (d->DecodedFrames > seekFrame ? -(mpc_int32_t)(d->DecodedFrames - seekFrame) : (mpc_int32_t)(seekFrame - d->DecodedFrames));
     1679
     1680    // update max decoded frames
     1681    if (d->DecodedFrames > d->MaxDecodedFrames)
     1682        d->MaxDecodedFrames = d->DecodedFrames;
     1683
     1684    if (seekFrame > 33)
     1685        lastFrame = seekFrame - 33 + 1 - d->SeekTable_Step;
     1686
     1687    if ((!d->Use_SeekTable && delta < 0) || d->MaxDecodedFrames == 0)
     1688    {
     1689
     1690        mpc_decoder_reset_state(d);
     1691
     1692        // starts from the beginning since no frames have been decoded yet, or not using seek table
     1693        fpos = get_initial_fpos(d, d->StreamVersion);
     1694
     1695        // seek to the first frame
     1696        mpc_decoder_seek_to(d, fpos);
     1697
     1698        // reset number of decoded frames
     1699        d->DecodedFrames = 0;
     1700
     1701        if (d->Use_SeekTable)
     1702        {
     1703            // jump to the last frame, updating seek table
     1704            if (d->SeekTable_Step == 1)
     1705            {
     1706                d->SeekTable[0] = (mpc_uint32_t)fpos;
     1707                for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1708                    d->SeekTable[d->DecodedFrames+1] = mpc_decoder_jump_frame(d);
     1709            }
     1710            else
     1711            {
     1712                d->SeekTableIndex = 0;
     1713                d->SeekTableCounter = (mpc_uint32_t)fpos;
     1714                for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1715                {
     1716                    if (d->DecodedFrames % d->SeekTable_Step == 0)
     1717                    {
     1718                        d->SeekTable[d->SeekTableIndex] = d->SeekTableCounter;
     1719                        d->SeekTableIndex += 1;
     1720                        d->SeekTableCounter = 0;
     1721                    }
     1722                    d->SeekTableCounter += mpc_decoder_jump_frame(d);
     1723                }
     1724            }
     1725        }
     1726        else
     1727        {
     1728            // just jump to the last frame
     1729            for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1730                mpc_decoder_jump_frame(d);
     1731        }
     1732    }
     1733    else if (delta < 0)
     1734    {
     1735
     1736        mpc_decoder_reset_state(d);
     1737
     1738        // jumps backwards using the seek table
     1739        fpos = d->SeekTable[0];
     1740        if (d->SeekTable_Step == 1)
     1741        {
     1742            for (d->DecodedFrames = 0;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1743            fpos += d->SeekTable[d->DecodedFrames+1];
     1744        }
     1745        else
     1746        {
     1747            d->SeekTableIndex = 0;
     1748            //d->SeekTableCounter = 0;
     1749            for (d->DecodedFrames = 0;d->DecodedFrames < lastFrame; d->DecodedFrames+=d->SeekTable_Step, d->SeekTableIndex++)
     1750                fpos += d->SeekTable[d->SeekTableIndex+1];
     1751            d->SeekTableCounter = d->SeekTable[d->SeekTableIndex];
     1752        }
     1753        mpc_decoder_seek_to(d, fpos);
     1754
     1755    }
     1756    else if (delta > 33)
     1757    {
     1758
     1759        mpc_decoder_reset_state(d);
     1760
     1761        // jumps forward from the current position
     1762        if (d->Use_SeekTable)
     1763        {
     1764            if (d->MaxDecodedFrames > lastFrame) // REVIEW: Correct?? or (d->MaxDecodedFrames > d->DecodedFrames)
     1765            {
     1766                // jump to the last usable position in the seek table
     1767                if (d->SeekTable_Step == 1)
     1768                {
     1769                    fpos = mpc_decoder_bits_read(d);
     1770                    for (; d->DecodedFrames < d->MaxDecodedFrames && d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1771                        fpos += d->SeekTable[d->DecodedFrames+1];
     1772                }
     1773                else
     1774                {
     1775                    // could test SeekTable offset and jump to next entry but this is easier for now...
     1776                    //d->SeekTableIndex = 0;
     1777                    //d->SeekTableCounter = 0;
     1778                    fpos = d->SeekTable[0];
     1779                    d->SeekTableIndex = 0;
     1780                    for (d->DecodedFrames = 0;d->DecodedFrames < d->MaxDecodedFrames && d->DecodedFrames < lastFrame; d->DecodedFrames+=d->SeekTable_Step, d->SeekTableIndex++)
     1781                        fpos += d->SeekTable[d->SeekTableIndex+1];
     1782                    d->SeekTableCounter = d->SeekTable[d->SeekTableIndex];
     1783                }
     1784                mpc_decoder_seek_to(d, fpos);
     1785            }
     1786
     1787            if (d->SeekTable_Step == 1)
     1788            {
     1789                for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1790                    d->SeekTable[d->DecodedFrames+1] = mpc_decoder_jump_frame(d);
     1791            }
     1792            else
     1793            {
     1794                for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1795                {
     1796                    if (d->DecodedFrames % d->SeekTable_Step == 0)
     1797                    {
     1798                        d->SeekTable[d->SeekTableIndex] = d->SeekTableCounter;
     1799                        d->SeekTableIndex += 1;
     1800                        d->SeekTableCounter = 0;
     1801                    }
     1802                    d->SeekTableCounter += mpc_decoder_jump_frame(d);
     1803                }
     1804            }
     1805        }
     1806        else
     1807        {
     1808            for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
     1809                mpc_decoder_jump_frame(d);
     1810        }
     1811    }
     1812
     1813    // REVIEW: Needed?
     1814    mpc_decoder_update_buffer(d);
     1815
     1816    for (;d->DecodedFrames < seekFrame; d->DecodedFrames++) {
    13341817        mpc_uint32_t   FrameBitCnt;
    1335         mpc_uint32_t   RING;
    1336         RING         = d->Zaehler;
    13371818        d->FwdJumpInfo  = mpc_decoder_bitstream_read(d, 20);    // read jump-info
    13381819        d->ActDecodePos = (d->Zaehler << 5) + d->pos;
    1339         FrameBitCnt  = mpc_decoder_bits_read(d);  // scanning the scalefactors and check for validity of frame
     1820        FrameBitCnt  = mpc_decoder_bits_read(d);
     1821            // scanning the scalefactors (and check for validity of frame)
    13401822        if (d->StreamVersion >= 7)  {
    1341             mpc_decoder_read_bitstream_sv7(d);
     1823            mpc_decoder_read_bitstream_sv7(d, d->Use_FastSeek && (d->DecodedFrames < seekFrame - 1));
    13421824        }
    13431825        else {
    … …  
    13481830#endif
    13491831        }
    1350         if (mpc_decoder_bits_read(d) - FrameBitCnt != d->FwdJumpInfo ) {
    1351             // Box ("Bug in perform_jump");
     1832        FrameBitCnt = mpc_decoder_bits_read(d) - FrameBitCnt;
     1833
     1834        if (d->Use_FastSeek && d->FwdJumpInfo > FrameBitCnt)
     1835            mpc_decoder_seek_forward(d, d->FwdJumpInfo - FrameBitCnt);
     1836        else if (FrameBitCnt != d->FwdJumpInfo )
     1837            // Bug in perform_jump;
    13521838            return FALSE;
    1353         }
     1839
     1840        // REVIEW: Only if decodedFrames < maxDecodedFrames??
     1841        if (d->Use_SeekTable)
     1842        {
     1843            if (d->SeekTable_Step == 1)
     1844            {
     1845                // check that the frame length corresponds with any data already in the seek table
     1846                if (d->SeekTable[d->DecodedFrames+1] != 0 && d->SeekTable[d->DecodedFrames+1] != d->FwdJumpInfo + 20)
     1847                    return FALSE;
     1848                d->SeekTable [d->DecodedFrames+1] = d->FwdJumpInfo + 20;
     1849            }
     1850            else
     1851            {
     1852                if (d->DecodedFrames % d->SeekTable_Step == 0)
     1853                {
     1854                    if (d->SeekTable[d->SeekTableIndex] != 0 && d->SeekTable[d->SeekTableIndex] != d->SeekTableCounter)
     1855                        return FALSE;
     1856                    d->SeekTable[d->SeekTableIndex] = d->SeekTableCounter;
     1857                    d->SeekTableIndex += 1;
     1858                    d->SeekTableCounter = 0;
     1859                }
     1860                d->SeekTableCounter += d->FwdJumpInfo + 20;
     1861            }
     1862        }
     1863
    13541864        // update buffer
    1355         if ((RING ^ d->Zaehler) & MEMSIZE2) {
    1356             f_read_dword(d, d->Speicher + (RING & MEMSIZE2),  MEMSIZE2);
    1357         }
    1358     }
    1359 
    1360     // LastBitsRead = BitsRead ();
    1361     // LastFrame = d->DecodedFrames;
     1865        mpc_decoder_update_buffer(d);
     1866
     1867        if (d->DecodedFrames == seekFrame - 1)
     1868        {
     1869            // initialize the synth correctly for perfect decoding
     1870            mpc_decoder_requantisierung(d, d->Max_Band);
     1871            mpc_decoder_synthese_filter_float(d, NULL);
     1872        }
     1873    }
    13621874
    13631875    return TRUE;
    13641876}
    13651877
    1366 void mpc_decoder_update_buffer(mpc_decoder *d, mpc_uint32_t RING)
    1367 {
    1368     if ((RING ^ d->Zaehler) & MEMSIZE2 ) {
     1878void mpc_decoder_fill_buffer(mpc_decoder *d)
     1879{
     1880    f_read_dword(d, d->Speicher, MEMSIZE);
     1881    d->dword = SWAP(d->Speicher[d->Zaehler = 0]);
     1882    d->next = SWAP(d->Speicher[1]);
     1883    d->Ring = 0;
     1884}
     1885
     1886void mpc_decoder_update_buffer(mpc_decoder *d)
     1887{
     1888    if ((d->Ring ^ d->Zaehler) & MEMSIZE2) {
    13691889        // update buffer
    1370         f_read_dword(d, d->Speicher + (RING & MEMSIZE2), MEMSIZE2);
    1371     }
    1372 }
    1373 
    1374 
     1890        f_read_dword(d, d->Speicher + (d->Ring & MEMSIZE2), MEMSIZE2);
     1891        d->Ring = d->Zaehler;
     1892    }
     1893}
     1894
     1895
     1896void mpc_decoder_seek_to(mpc_decoder *d, mpc_uint32_t bitPos)
     1897{
     1898    // required dword
     1899    mpc_uint32_t fpos = (bitPos >> 5);
     1900    mpc_uint32_t bufferStart = d->WordsRead - d->Zaehler;
     1901    if ((d->Zaehler & MEMSIZE2) != FALSE)
     1902        bufferStart += MEMSIZE2;
     1903
     1904    if (fpos >= bufferStart && fpos < bufferStart + MEMSIZE)
     1905    {
     1906        // required position is within the buffer, no need to seek
     1907        d->Zaehler = (fpos - bufferStart + ((d->Zaehler & MEMSIZE2) != FALSE ? MEMSIZE2 : 0)) & MEMMASK;
     1908        d->pos = bitPos & 31;
     1909        d->WordsRead = fpos;
     1910        d->dword = SWAP(d->Speicher[d->Zaehler]);
     1911        d->next = SWAP(d->Speicher[(d->Zaehler + 1) & MEMMASK]);
     1912
     1913        mpc_decoder_update_buffer(d);
     1914    }
     1915    else
     1916    {
     1917        // DWORD aligned
     1918        f_seek(d, fpos*4 + d->MPCHeaderPos);
     1919        d->Zaehler = 0;
     1920        d->pos = bitPos & 31;
     1921        d->WordsRead = fpos;
     1922
     1923        mpc_decoder_fill_buffer(d);
     1924    }
     1925}
     1926
     1927void mpc_decoder_seek_forward(mpc_decoder *d, mpc_uint32_t bits)
     1928{       
     1929    bits += d->pos;
     1930    d->pos = bits & 31;
     1931    bits = bits >> 5; // to DWORDs
     1932    d->Zaehler = (d->Zaehler + bits) & MEMMASK;
     1933    d->dword = SWAP(d->Speicher[d->Zaehler]);
     1934    d->next = SWAP(d->Speicher[(d->Zaehler + 1) & MEMMASK]);
     1935    d->WordsRead += bits;
     1936}
     1937
     1938void mpc_decoder_set_seek_table(mpc_decoder *d, mpc_uint32_t *seek_table, mpc_uint32_t max_table_size)
     1939{
     1940    d->Use_StaticSeekTable = TRUE;
     1941    d->SeekTable = seek_table;
     1942    d->Max_SeekTable_Size = max_table_size;
     1943}
Note: See TracChangeset for help on using the changeset viewer.