mpc_decoder.c

tcpmp.src.0.72RC1 优秀的多媒体播放器TCPMP的源代码

            for (k=0; k<36; ++k)
                *L++ = mpc_decoder_huffman_decode_fast(d, Table);
            break;
        case 6:
        case 7:
            Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResL];
            for (k=0; k<36; ++k)
                *L++ = mpc_decoder_huffman_decode(d, Table);
            break;
        case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
            tmp = Dc[*ResL];
            for (k=0; k<36; ++k)
                *L++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResL]) - tmp;
            break;
        default:
            return;
        }
        /************** rechts **************/
        switch (*ResR)
        {
        case  -2: case  -3: case  -4: case  -5: case  -6: case  -7: case  -8: case  -9:
        case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17:
            R += 36;
            break;
        case -1:
                for (k=0; k<36; k++ ) {
                    tmp  = random_int(d);
                    *R++ = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >>  8) & 0xFF) + ((tmp >>  0) & 0xFF) - 510;
                }
                break;
            case 0:
                R += 36;// increase pointer
                break;
            case 1:
                Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][1];
                for (k=0; k<12; ++k)
                {
                    idx = mpc_decoder_huffman_decode_fast(d, Table);
                    *R++ = idx30[idx];
                    *R++ = idx31[idx];
                    *R++ = idx32[idx];
                }
                break;
            case 2:
                Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][2];
                for (k=0; k<18; ++k)
                {
                    idx = mpc_decoder_huffman_decode_fast(d, Table);
                    *R++ = idx50[idx];
                    *R++ = idx51[idx];
                }
                break;
            case 3:
            case 4:
                Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
                for (k=0; k<36; ++k)
                    *R++ = mpc_decoder_huffman_decode_faster(d, Table);
                break;
            case 5:
                Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
                for (k=0; k<36; ++k)
                    *R++ = mpc_decoder_huffman_decode_fast(d, Table);
                break;
            case 6:
            case 7:
                Table = d->HuffQ[mpc_decoder_bitstream_read(d, 1)][*ResR];
                for (k=0; k<36; ++k)
                    *R++ = mpc_decoder_huffman_decode(d, Table);
                break;
            case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
                tmp = Dc[*ResR];
                for (k=0; k<36; ++k)
                    *R++ = (mpc_int32_t)mpc_decoder_bitstream_read(d, Res_bit[*ResR]) - tmp;
                break;
            default:
                return;
        }
    }
}

void mpc_decoder_setup(mpc_decoder *d, mpc_reader *r)
{
  d->r = r;

  d->HuffQ[0][0] = 0;
  d->HuffQ[1][0] = 0;
  d->HuffQ[0][1] = d->HuffQ1[0];
  d->HuffQ[1][1] = d->HuffQ1[1];
  d->HuffQ[0][2] = d->HuffQ2[0];
  d->HuffQ[1][2] = d->HuffQ2[1];
  d->HuffQ[0][3] = d->HuffQ3[0];
  d->HuffQ[1][3] = d->HuffQ3[1];
  d->HuffQ[0][4] = d->HuffQ4[0];
  d->HuffQ[1][4] = d->HuffQ4[1];
  d->HuffQ[0][5] = d->HuffQ5[0];
  d->HuffQ[1][5] = d->HuffQ5[1];
  d->HuffQ[0][6] = d->HuffQ6[0];
  d->HuffQ[1][6] = d->HuffQ6[1];
  d->HuffQ[0][7] = d->HuffQ7[0];
  d->HuffQ[1][7] = d->HuffQ7[1];

  d->SampleHuff[0] = NULL;
  d->SampleHuff[1] = d->Entropie_1;
  d->SampleHuff[2] = d->Entropie_2;
  d->SampleHuff[3] = d->Entropie_3;
  d->SampleHuff[4] = d->Entropie_4;
  d->SampleHuff[5] = d->Entropie_5;
  d->SampleHuff[6] = d->Entropie_6;
  d->SampleHuff[7] = d->Entropie_7;
  d->SampleHuff[8] = NULL;
  d->SampleHuff[9] = NULL;
  d->SampleHuff[10] = NULL;
  d->SampleHuff[11] = NULL;
  d->SampleHuff[12] = NULL;
  d->SampleHuff[13] = NULL;
  d->SampleHuff[14] = NULL;
  d->SampleHuff[15] = NULL;
  d->SampleHuff[16] = NULL;
  d->SampleHuff[17] = NULL;

  d->EQ_activated = 0;
  d->MPCHeaderPos = 0;
  d->StreamVersion = 0;
  d->MS_used = 0;
  d->FwdJumpInfo = 0;
  d->ActDecodePos = 0;
  d->FrameWasValid = 0;
  d->OverallFrames = 0;
  d->DecodedFrames = 0;
  d->LastValidSamples = 0;
  d->TrueGaplessPresent = 0;
  d->WordsRead = 0;
  d->Max_Band = 0;
  d->SampleRate = 0;
//  clips = 0;
  d->__r1 = 1;
  d->__r2 = 1;

  d->SeekTable = NULL; // Picard 2005.04.29 
  d->dword = 0;
  d->pos = 0;
  d->Zaehler = 0;
  d->WordsRead = 0;
  d->Max_Band = 0;

  mpc_decoder_initialisiere_quantisierungstabellen(d, 1.0f);
  mpc_decoder_init_huffman_sv6(d);
  mpc_decoder_init_huffman_sv7(d);
}

static void mpc_decoder_set_streaminfo(mpc_decoder *d, mpc_streaminfo *si)
{
    mpc_decoder_reset_synthesis(d);
    mpc_decoder_reset_globals(d);

    d->StreamVersion      = si->stream_version;
    d->MS_used            = si->ms;
    d->Max_Band           = si->max_band;
    d->OverallFrames      = si->frames;
    d->MPCHeaderPos       = si->header_position;
    d->LastValidSamples   = si->last_frame_samples;
    d->TrueGaplessPresent = si->is_true_gapless;
    d->SampleRate         = (mpc_int32_t)si->sample_freq;

    d->samples_to_skip = MPC_DECODER_SYNTH_DELAY;
}

mpc_bool_t mpc_decoder_initialize(mpc_decoder *d, mpc_streaminfo *si) 
{
    mpc_decoder_set_streaminfo(d, si);

    // AB: setting position to the beginning of the data-bitstream
    switch (d->StreamVersion) {
    case 0x04: f_seek(d, 4 + d->MPCHeaderPos); d->pos = 16; break;  // Geht auch 黚er eine der Helperfunktionen
    case 0x05:
    case 0x06: f_seek(d, 8 + d->MPCHeaderPos); d->pos =  0; break;
    case 0x07:
    case 0x17: /*f_seek ( 24 + d->MPCHeaderPos );*/ d->pos =  8; break;
    default: return FALSE;
    }

    // AB: fill buffer and initialize decoder
    f_read_dword(d, d->Speicher, MEMSIZE );
    d->dword = d->Speicher[d->Zaehler = 0];

    return TRUE;
}

//---------------------------------------------------------------
// will seek from the beginning of the file to the desired
// position in ms (given by seek_needed)
//---------------------------------------------------------------
#if 0
static void
helper1(mpc_decoder *d, mpc_uint32_t bitpos) 
{
    f_seek(d, (bitpos >> 5) * 4 + d->MPCHeaderPos);
    f_read_dword(d, d->Speicher, 2);
    d->dword = d->Speicher[d->Zaehler = 0];
    d->pos = bitpos & 31;
}
#endif

static void
helper2(mpc_decoder *d, mpc_uint32_t bitpos) 
{
    f_seek(d, (bitpos>>5) * 4 + d->MPCHeaderPos);
    f_read_dword(d, d->Speicher, MEMSIZE);
    d->dword = d->Speicher[d->Zaehler = 0];
    d->pos = bitpos & 31;
}

static void
helper3(mpc_decoder *d, mpc_uint32_t bitpos, mpc_uint32_t* buffoffs) 
{
    d->pos = bitpos & 31;
    bitpos >>= 5;
    if ((mpc_uint32_t)(bitpos - *buffoffs) >= MEMSIZE - 2) {
        *buffoffs = bitpos;
        f_seek(d, bitpos * 4L + d->MPCHeaderPos);
        f_read_dword(d, d->Speicher, MEMSIZE );
    }
    d->dword = d->Speicher[d->Zaehler = bitpos - *buffoffs ];
}

static mpc_uint32_t get_initial_fpos(mpc_decoder *d, mpc_uint32_t StreamVersion)
{
    mpc_uint32_t fpos = 0;
    switch ( d->StreamVersion ) {                                                  // setting position to the beginning of the data-bitstream
    case  0x04: fpos =  48; break;
    case  0x05:
    case  0x06: fpos =  64; break;
    case  0x07:
    case  0x17: fpos = 200; break;
    }
    return fpos;
}

#if 0 //TCPMP floating point...
mpc_bool_t mpc_decoder_seek_seconds(mpc_decoder *d, double seconds) 
{
    return mpc_decoder_seek_sample(d, (mpc_int64_t)(seconds * (double)d->SampleRate + 0.5));
}
#endif

mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample) 
{
    mpc_uint32_t fpos;
    mpc_uint32_t fwd;

    fwd = (mpc_uint32_t) (destsample / MPC_FRAME_LENGTH);
    d->samples_to_skip = MPC_DECODER_SYNTH_DELAY + (mpc_uint32_t)(destsample % MPC_FRAME_LENGTH);

    memset(d->Y_L          , 0, sizeof d->Y_L           );
    memset(d->Y_R          , 0, sizeof d->Y_R           );
    memset(d->SCF_Index_L     , 0, sizeof d->SCF_Index_L      );
    memset(d->SCF_Index_R     , 0, sizeof d->SCF_Index_R      );
    memset(d->Res_L           , 0, sizeof d->Res_L            );
    memset(d->Res_R           , 0, sizeof d->Res_R            );
    memset(d->SCFI_L          , 0, sizeof d->SCFI_L           );
    memset(d->SCFI_R          , 0, sizeof d->SCFI_R           );
    memset(d->DSCF_Flag_L     , 0, sizeof d->DSCF_Flag_L      );
    memset(d->DSCF_Flag_R     , 0, sizeof d->DSCF_Flag_R      );
    memset(d->DSCF_Reference_L, 0, sizeof d->DSCF_Reference_L );
    memset(d->DSCF_Reference_R, 0, sizeof d->DSCF_Reference_R );
    memset(d->Q               , 0, sizeof d->Q                );
    memset(d->MS_Flag         , 0, sizeof d->MS_Flag          );

    // resetting synthesis filter to avoid "clicks"
    mpc_decoder_reset_synthesis(d);

    // prevent from desired position out of allowed range
    fwd = fwd < d->OverallFrames  ?  fwd  :  d->OverallFrames;

    // reset number of decoded frames
    d->DecodedFrames = 0;

    fpos = get_initial_fpos(d, d->StreamVersion);
    if (fpos == 0) {
        return FALSE;
    }

	// Picard 2005.04.29
	if (d->SeekTable)
	{
		unsigned long buffoffs = 0x80000000;
        for (;d->DecodedFrames + 128 < fwd; d->DecodedFrames++) 
		{
            if (d->SeekTable[d->DecodedFrames] == 0) 
			{
                helper3(d, fpos, &buffoffs);
                fpos += d->SeekTable[d->DecodedFrames] = 20 + mpc_decoder_bitstream_read(d,20);
            } 
			else 
                fpos += d->SeekTable[d->DecodedFrames];
        }
    }

    helper2(d, fpos);

    // read the last 32 frames before the desired position to scan the scalefactors (artifactless jumping)
    for ( ; d->DecodedFrames < fwd; d->DecodedFrames++ ) {
        mpc_uint32_t   FrameBitCnt;
        mpc_uint32_t   RING;
        RING         = d->Zaehler;
        d->FwdJumpInfo  = mpc_decoder_bitstream_read(d, 20);    // read jump-info
		if (d->SeekTable)
			d->SeekTable[d->DecodedFrames] = 20 + d->FwdJumpInfo; // Picard 2005.04.29
        d->ActDecodePos = (d->Zaehler << 5) + d->pos;
        FrameBitCnt  = mpc_decoder_bits_read(d);  // scanning the scalefactors and check for validity of frame
        if (d->StreamVersion >= 7)  {
            mpc_decoder_read_bitstream_sv7(d);
        }
        else {
            mpc_decoder_read_bitstream_sv6(d);
        }
        if (mpc_decoder_bits_read(d) - FrameBitCnt != d->FwdJumpInfo ) {
            // Box ("Bug in perform_jump");
            return FALSE;
        }
        // update buffer
        if ((RING ^ d->Zaehler) & MEMSIZE2) {
            f_read_dword(d, d->Speicher + (RING & MEMSIZE2),  MEMSIZE2);
        }
    }

    // LastBitsRead = BitsRead ();
    // LastFrame = d->DecodedFrames;

    return TRUE;
}

void mpc_decoder_update_buffer(mpc_decoder *d, mpc_uint32_t RING) 
{
    if ((RING ^ d->Zaehler) & MEMSIZE2 ) {
        // update buffer
        f_read_dword(d, d->Speicher + (RING & MEMSIZE2), MEMSIZE2);
    }
}