umc_mp3_encoder.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_encoder.h"

namespace UMC {

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

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

    pMDCTSpec12 = NULL;
    pMDCTSpec36 = NULL;

    pDCTSpec = NULL;

    for (int ch = 0; ch < 2; ch++) {
      pFFTSpecLong[ch] = NULL;
      pFFTSpecShort[ch] = NULL;
    }
  }

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

  IppBool MP3Encoder::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 MP3Encoder::Init(BaseCodecParams * init)
  {
    AudioCodecParams *pAudioCodecInit = (AudioCodecParams *) init;
    int j;
    Ipp32f cutoff_frequency;
    Ipp32f samp_rate_per_ch;

    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 = (float)(mp3enc_bitrate[header.bitRate] * 1000 / stereo);
    ippsPow34_32f(&samp_rate_per_ch, &cutoff_frequency, 1);
    cutoff_frequency *= 8.0;
    lowpass_maxline = (int)(32 * cutoff_frequency /
        (float)(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_32f(&input_buffer[0][0],2*(1152+448));

    mdctInit();
    huffamInit();

    PsychoacousticInit();
    windowSubBandInit();

    si_private_bits = 0;

    m_norm =
      1. / ((float)mp3enc_frequency[header.samplingFreq] * sizeof(short) * stereo);

    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[j] = &fbout_data[ind];
    }

    return UMC_OK;
  }

  Status MP3Encoder::Close()
  {
    int i;

    if (pMDCTSpec12)
      ippsMDCTFwdFree_32f(pMDCTSpec12);
    pMDCTSpec12 = NULL;

    if (pMDCTSpec36)
      ippsMDCTFwdFree_32f(pMDCTSpec36);
    pMDCTSpec36 = NULL;

    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);
    }

    if (pDCTSpec)
      ippsDCTInvFree_32f(pDCTSpec);
    pDCTSpec = NULL;

    si_private_bits = 0;

    return UMC_OK;
  }

  Status  MP3Encoder::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_32f(&(input_buffer[ch][1152]), &(input_buffer[ch][0]), 224);
        ippsConvert_16s32f(buff[ch], &input_buffer[ch][224], 1152);
    }

    for (gr = 0; gr < 2; gr++)
      for (ch = 0; ch < stereo; ch++)
        Psychoacoustic(&input_buffer[ch][gr * 576], gr, ch);

// filterbank
    for (gr = 0; gr < 2; gr++)
      for (ch = 0; ch < stereo; ch++)
        windowSubBand(&input_buffer[ch][129 + gr * 576], (float *)&((*(fbout[gr+1]))[ch][0][0]), ch);


    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 MP3Encoder::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 MP3Encoder::GetDuration(float *p_duration)
  {
    float   duration;

    duration = (float)framesNum *1152;

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

    p_duration[0] = duration;

    return UMC_OK;
  }

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

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

};      // namespace UMC