umc_mp3_enc_int.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/*//////////////////////////////////////////////////////////////////////////////
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 2002-2005 Intel Corporation. All Rights Reserved.
//
*/

#include "umc_mp3_enc_int.h"

namespace UMC {

  MP3EncoderInt::MP3EncoderInt()
  {
    ippsZero_8u((Ipp8u *)&header, sizeof(header));

    header.id = 1;
    header.bitRate = 9; // 128 kBit
    header.layer = 1;   // layer 3
  }

  MP3EncoderInt::~MP3EncoderInt()
  {
    Close();
  }

  IppBool MP3EncoderInt::CheckBitRate(int br, int &ind)
  {
    if (br == 0)
      return ippFalse;

    for (int i = 0; i < 16; i++) {
      if (mp3enc_bitrate[i] == br) {
        ind = i;
        return ippTrue;
      }
    }

    return ippFalse;
  }

  Status MP3EncoderInt::Init(BaseCodecParams * init)
  {
    AudioCodecParams *pAudioCodecInit = (AudioCodecParams *) init;
    int j, cutoff_frequency;
    short short_cutoff_frequency;
    int samp_rate_per_ch, inScaleFactor;
    short short_tmp;

    if (!pAudioCodecInit)
      return UMC_NULL_PTR;

    stereo = pAudioCodecInit->m_info_in.channels;
    frameSize = 1152;

    si_main_data_begin = 0;
    main_data_ptr = 0;
    resr_bytes = 0;
    resr_mod_slot = 0;

    quant_mode_fast = 0;

    framesNum = 0;

    if (!CheckBitRate(pAudioCodecInit->m_info_out.bitrate, header.bitRate))
      return UMC_FAILED_TO_INITIALIZE;

    switch (pAudioCodecInit->m_info_in.sample_frequency) {
    case 44100:
      header.samplingFreq = 0;
      break;
    case 48000:
      header.samplingFreq = 1;
      break;
    case 32000:
      header.samplingFreq = 2;
      break;
    default:
      return UMC_FAILED_TO_INITIALIZE;
    }

    samp_rate_per_ch = (mp3enc_bitrate[header.bitRate] * 1000) >> (stereo - 1);

    inScaleFactor = 0;
    while (samp_rate_per_ch >= 32768) {
      inScaleFactor += 1;
      samp_rate_per_ch >>= 1;
    }

    short_tmp = (short)samp_rate_per_ch;
    ippsPow34_16s_Sfs(&short_tmp, inScaleFactor, &short_cutoff_frequency, 0, 1);
    cutoff_frequency = short_cutoff_frequency * 8;

    lowpass_maxline = 32 * cutoff_frequency / mp3enc_frequency[header.samplingFreq];
    if (lowpass_maxline > 32)
        lowpass_maxline = 32;

    common_scalefactor_update[0] = 2;
    common_scalefactor_update[1] = 2;
    last_frame_common_scalefactor[0] = 210;
    last_frame_common_scalefactor[1] = 210;

    ippsZero_16s(&input_buffer_short[0][0], 2 *(1152 + 224 + 576));

    mdctInit();
    huffamInit();

    InitPsychoacoustic();
    InitPsychoacousticCom();
    si_private_bits = 0;

    si_beg = 0;
    si_new = 0;
    si_num = 0;

    fbout_prev = 0;

    for (j = 0; j < 3; j++) {
        int ind;
        ind = fbout_prev + j;
        if (ind > 2) ind -= 3;
        fbout_int[j] = &fbout_data[ind];
    }

    return UMC_OK;
  }

  Status MP3EncoderInt::Close()
  {
    int i;

    for (i = 0; i < 17; i++) {
      if (htables[i].phuftable) {
        ippsVLCEncodeFree_32s((IppsVLCEncodeSpec_32s*)htables[i].phuftable);
      }
    }

    if (htables[24].phuftable) {
      ippsVLCEncodeFree_32s((IppsVLCEncodeSpec_32s*)htables[24].phuftable);
    }

    si_private_bits = 0;

    return UMC_OK;
  }

  Status  MP3EncoderInt::GetFrame(MediaData * in, MediaData * out) {
    VM_ALIGN16_DECL(short)buffer[2][1152];
    short  *buff[2];
    int     ch, gr, bytes;
    int     inSamples = (in->GetDataSize() / sizeof(short));
    int     outSamples = 0;

    if (inSamples < stereo * 1152)
      return UMC_NOT_ENOUGH_DATA;
    if (out->GetBufferSize() < 511 + 1050*2) // rough
        return UMC_NOT_ENOUGH_BUFFER;

    if ((stereo * 1152) < inSamples)
      inSamples = stereo * 1152;
    buff[0] = buffer[0];
    buff[1] = buffer[1];

    ippsDeinterleave_16s((Ipp16s *)in->GetDataPointer(), stereo, inSamples / stereo,
                         buff);

    for (ch = 0; ch < stereo; ch++) {
        ippsCopy_16s(&(input_buffer_short[ch][1152]), &(input_buffer_short[ch][0]), 576);
        ippsCopy_16s(buff[ch], &input_buffer_short[ch][576], 1152);
    }

    for (gr = 0; gr < 2; gr++)
        for (ch = 0; ch < stereo; ch++) {
        Psychoacoustic(&input_buffer_short[ch][352 + gr * 576], gr, ch);
        }


// filterbank
    for (gr = 0; gr < 2; gr++)
        for (ch = 0; ch < stereo; ch++) {
            int subband;
            for ( subband = 0; subband < 18; subband++ ) {
                ippsAnalysisPQMF_MP3_16s32s(
                    &(input_buffer_short[ch][1 + gr * 576 + subband * 32]),
                    (int *)&((*(fbout_int[gr+1]))[ch][subband][0]), 1);
            }
        }

    mdctBlock();

    quantization();

    outSamples = bytes = formatBitstream((Ipp8u *)out->GetDataPointer());

    out->SetTime(in->GetTime(),
                 in->GetTime() +
                 (float)(inSamples / stereo) / (float)(mp3enc_frequency[header.samplingFreq]));

    out->SetDataSize(outSamples);

    int     rested_bytes = in->GetDataSize() - inSamples * sizeof(short);

    in->MoveDataPointer(inSamples * sizeof(short));
    if (rested_bytes) {
      in->SetTime(in->GetTime() +
                  (float)(inSamples / stereo) /
                  (float)(mp3enc_frequency[header.samplingFreq]));
    }

    framesNum++;
    return UMC_OK;
  }

  Status MP3EncoderInt::GetInfo(BaseCodecParams * info)
  {
    if (!info)
      return UMC_NULL_PTR;

    info->m_SuggestedInputSize = stereo * sizeof(short) * 1152;

    AudioCodecParams *pAudioCodecInfo =
      DynamicCast < AudioCodecParams, BaseCodecParams > (info);

    if (!pAudioCodecInfo)
      return UMC_OK;

    pAudioCodecInfo->m_info_in.bitPerSample = 16;
    pAudioCodecInfo->m_info_out.bitPerSample = 16;
    pAudioCodecInfo->m_info_in.bitrate = mp3enc_bitrate[header.bitRate];
    pAudioCodecInfo->m_info_out.bitrate = mp3enc_bitrate[header.bitRate];
    pAudioCodecInfo->m_info_in.channels = stereo;
    pAudioCodecInfo->m_info_out.channels = stereo;

    pAudioCodecInfo->m_info_in.sample_frequency =
      mp3enc_frequency[header.samplingFreq];
    pAudioCodecInfo->m_info_out.sample_frequency =
      mp3enc_frequency[header.samplingFreq];

    pAudioCodecInfo->m_info_in.stream_type = MP1L3_AUDIO;
    pAudioCodecInfo->m_info_out.stream_type = PCM_AUDIO;

    return UMC_OK;
  }

  Status MP3EncoderInt::GetDuration(float *p_duration)
  {
    float   duration;

    duration = (float)framesNum *1152;

    duration /= (float)(mp3enc_frequency[header.samplingFreq]);

    p_duration[0] = duration;

    return UMC_OK;
  }

  Status MP3EncoderInt::SetParams(BaseCodecParams * params) {
    return UMC_NOT_IMPLEMENTED;
  };

  Status MP3EncoderInt::Reset() {
    return UMC_NOT_IMPLEMENTED;
  };

};      // namespace UMC