umc_speech_codec.cpp

audio-video-codecs.rar语音编解码器

   Close();

   m_codec.pInfo.params.direction = USC_ENCODE;
   m_codec.pInfo.params.law = pSpeechCodecInit->m_law;
   m_codec.pInfo.params.framesize = pSpeechCodecInit->m_framesize;
   m_codec.pInfo.params.modes.vad = pSpeechCodecInit->m_Vad;
   m_codec.pInfo.params.modes.truncate = pSpeechCodecInit->m_Truncate;
   m_codec.pInfo.params.modes.pf = pSpeechCodecInit->m_Pf;
   m_codec.pInfo.params.modes.hpf = pSpeechCodecInit->m_Hpf;
   m_codec.pInfo.params.modes.outMode  = pSpeechCodecInit->m_outMode;
   m_codec.pInfo.params.pcmType.sample_frequency = pSpeechCodecInit->m_info_in.sample_frequency;
   m_codec.pInfo.params.pcmType.nChannels = pSpeechCodecInit->m_info_in.channels;
   if(CheckBitRate(pSpeechCodecInit->m_info_out.bitrate))
      m_codec.pInfo.params.modes.bitrate = pSpeechCodecInit->m_info_out.bitrate;

   USCStatus = m_codec.pUSC_CODEC_Fxns->std.NumAlloc((const USC_Option *)&m_codec.pInfo.params, &m_codec.nBanks);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INIT);

   m_codec.pBanks            = (USC_MemBank*)ippsMalloc_8s(m_codec.nBanks*sizeof(USC_MemBank));
   if (!m_codec.pBanks)
      return (UMC_ERR_INIT);

   USCStatus = m_codec.pUSC_CODEC_Fxns->std.MemAlloc((const USC_Option *)&m_codec.pInfo.params, m_codec.pBanks);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INIT);
   for(i=0; i<m_codec.nBanks;i++){
      m_codec.pBanks[i].pMem            = (char *)ippsMalloc_8s(m_codec.pBanks[i].nbytes);
   }
   for(i=0; i<m_codec.nBanks;i++){
      if (!m_codec.pBanks[i].pMem)
         return (UMC_ERR_INIT);
   }

   m_codec.input.bitrate = m_codec.pInfo.params.modes.bitrate;
   m_codec.input.pcmType.bitPerSample = m_codec.pInfo.params.pcmType.bitPerSample;
   m_codec.input.pcmType.sample_frequency = m_codec.pInfo.params.pcmType.sample_frequency;
   m_codec.input.pcmType.nChannels = m_codec.pInfo.params.pcmType.nChannels;

   USCStatus = m_codec.pUSC_CODEC_Fxns->std.Init((const USC_Option *)&m_codec.pInfo.params, m_codec.pBanks, &m_codec.encoder);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INIT);

   m_codec.pUSC_CODEC_Fxns->std.GetInfo(m_codec.encoder, &m_codec.pInfo);

   m_frame_num = 0;
   return UMC_OK;

}

Status
USCEncoder::SetParams(BaseCodecParams* params)
{
   USC_Status USCStatus;
   SpeechCodecParams* pSpeechCodecInit;

   if(params==NULL) return UMC_ERR_NULL_PTR;

   pSpeechCodecInit = DynamicCast<SpeechCodecParams, BaseCodecParams>(params);

   if(CheckBitRate(pSpeechCodecInit->m_info_out.bitrate)) {
      m_codec.pInfo.params.modes.bitrate = pSpeechCodecInit->m_info_out.bitrate;
      m_rate                             = pSpeechCodecInit->m_info_out.bitrate;
   }
   m_codec.pInfo.params.modes.truncate = pSpeechCodecInit->m_Truncate;
   m_codec.pInfo.params.modes.pf       = pSpeechCodecInit->m_Pf;
   m_codec.pInfo.params.modes.hpf      = pSpeechCodecInit->m_Hpf;
   m_codec.pInfo.params.modes.vad      = pSpeechCodecInit->m_Vad;
   m_codec.pInfo.params.modes.outMode  = pSpeechCodecInit->m_outMode;

   USCStatus = m_codec.pUSC_CODEC_Fxns->SetFrameSize(&(m_codec.pInfo.params),
      m_codec.encoder, pSpeechCodecInit->m_framesize);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INIT);
   USCStatus = m_codec.pUSC_CODEC_Fxns->std.Control(&((USC_Option*)&m_codec.pInfo.params)->modes, m_codec.encoder);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INIT);

   return UMC_OK;
}

Status
USCEncoder::GetInfo(BaseCodecParams *info)
{
   USC_Status USCStatus;
   Ipp32s tmp;
    if(info==NULL) return UMC_ERR_NULL_PTR;

    USCStatus = m_codec.pUSC_CODEC_Fxns->std.GetInfo(m_codec.encoder, &(m_codec.pInfo));
    if(USCStatus!=USC_NoError) return (UMC_ERR_INIT); // ??status??

    SpeechCodecParams* pSpeechCodecInfo = DynamicCast<SpeechCodecParams, BaseCodecParams>(info);
    if (!pSpeechCodecInfo) {
       info->m_SuggestedInputSize = m_codec.pInfo.params.framesize;
       return UMC_OK;
    }

    pSpeechCodecInfo->m_SuggestedInputSize     = m_codec.pInfo.params.framesize;

    pSpeechCodecInfo->m_framesize  = m_codec.pInfo.params.framesize;
    pSpeechCodecInfo->m_maxbitsize = m_codec.pInfo.maxbitsize;
    pSpeechCodecInfo->m_nVAD = m_nVad;
    pSpeechCodecInfo->m_nRates = m_codec.pInfo.nRates;
    pSpeechCodecInfo->m_tblRates = (const Ipp32s *)m_codec.pInfo.pRateTbl;

    m_codec.input.bitrate = m_codec.pInfo.params.modes.bitrate;
    pSpeechCodecInfo->m_info_in.bitPerSample     = m_codec.pInfo.params.pcmType.bitPerSample;
    pSpeechCodecInfo->m_info_in.bitrate = m_codec.input.bitrate;
    pSpeechCodecInfo->m_info_in.channels = m_codec.pInfo.params.pcmType.nChannels;
    pSpeechCodecInfo->m_info_in.sample_frequency = m_codec.pInfo.params.pcmType.sample_frequency;

    pSpeechCodecInfo->m_info_out.bitPerSample    = m_codec.pInfo.params.pcmType.bitPerSample;
    pSpeechCodecInfo->m_info_out.channels = m_codec.pInfo.params.pcmType.nChannels;
    pSpeechCodecInfo->m_info_out.sample_frequency= m_codec.pInfo.params.pcmType.sample_frequency;
    pSpeechCodecInfo->m_info_out.bitrate = m_codec.input.bitrate;
    pSpeechCodecInfo->m_info_out.stream_type     = UNDEF_AUDIO;

    pSpeechCodecInfo->m_law                      = m_codec.pInfo.params.law;
    pSpeechCodecInfo->m_Vad                      = m_codec.pInfo.params.modes.vad;
    pSpeechCodecInfo->m_Truncate                 = m_codec.pInfo.params.modes.truncate;
    pSpeechCodecInfo->m_Pf                       = m_codec.pInfo.params.modes.pf;
    pSpeechCodecInfo->m_Hpf                      = m_codec.pInfo.params.modes.hpf;
    pSpeechCodecInfo->m_outMode                  = m_codec.pInfo.params.modes.outMode;
    pSpeechCodecInfo->m_nameCodec                = (vm_char*)m_codec.pInfo.name;
    pSpeechCodecInfo->m_frame_num = m_frame_num;

    //Save VAD mode
    tmp = m_codec.pInfo.params.modes.vad;
    // Disable VAD to get right information
    m_codec.pInfo.params.modes.vad = 0;
    // Get BlockAlign
    m_codec.pUSC_CODEC_Fxns->GetOutStreamSize(&m_codec.pInfo.params,
                                                  m_codec.pInfo.params.modes.bitrate,
                                                  m_codec.pInfo.params.framesize,
                                                  &pSpeechCodecInfo->m_BlockAlign);
    //Restore VAD mode
    m_codec.pInfo.params.modes.vad = tmp;

    return UMC_OK;
}

Status
USCEncoder::GetFrame(MediaData *in, MediaData *out)
{
   Ipp32s  inSamples, outSize;
   size_t  sizePCMstream;
   USC_Status USCStatus;
   SpeechMediaData *spOutData;

   if(in==NULL) return UMC_ERR_NULL_PTR;
   if(out==NULL) return UMC_ERR_NULL_PTR;

   spOutData = DynamicCast<SpeechMediaData, MediaData>(out);

   sizePCMstream = in->GetDataSize();
   m_codec.input.pBuffer = (char *)in->GetDataPointer();
   m_codec.input.bitrate = m_codec.pInfo.params.modes.bitrate;
   m_codec.input.nbytes = (int)sizePCMstream;
   m_codec.input.pcmType.bitPerSample = m_codec.pInfo.params.pcmType.bitPerSample;
   m_codec.input.pcmType.sample_frequency = m_codec.pInfo.params.pcmType.sample_frequency;
   m_codec.input.pcmType.nChannels = m_codec.pInfo.params.pcmType.nChannels;

   m_codec.output.pBuffer = (char *)out->GetDataPointer();

   USCStatus = m_codec.pUSC_CODEC_Fxns->Encode (m_codec.encoder, &m_codec.input, &m_codec.output);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INVALID_STREAM);
   spOutData->SetFrameType(m_codec.output.frametype);
   spOutData->SetBitrate(m_codec.output.bitrate);
   spOutData->SetNBytes(m_codec.output.nbytes);
   outSize = m_codec.output.nbytes;

   inSamples = m_codec.input.nbytes/(m_codec.pInfo.params.pcmType.bitPerSample>>3);
   in->SetDataSize(sizePCMstream-m_codec.input.nbytes);
   in->SetTime(in->GetTime()+((Ipp32f)inSamples/(Ipp32f)m_codec.pInfo.params.pcmType.sample_frequency));
   out->SetDataSize(outSize);
   out->SetTime(in->GetTime(), in->GetTime()+((Ipp32f)inSamples/(Ipp32f)m_codec.pInfo.params.pcmType.sample_frequency));
   m_frame_num++;

   return UMC_OK;
}

Status
USCEncoder::Reset(void)
{
   USC_Status USCStatus;
   USCStatus = m_codec.pUSC_CODEC_Fxns->std.Reinit(&((USC_Option*)&m_codec.pInfo.params)->modes, m_codec.encoder);
   if(USCStatus!=USC_NoError) return (UMC_ERR_INIT);
   return UMC_OK;
}

Status
USCEncoder::Close(void)
{
   Ipp32s i;
   if(m_codec.nBanks) {
      if(m_codec.pBanks) {
         for(i=0;i<m_codec.nBanks;i++) {
            if(m_codec.pBanks[i].pMem)  {
               ippsFree(m_codec.pBanks[i].pMem);
               m_codec.pBanks[i].pMem = NULL;
               m_codec.pBanks[i].nbytes = 0;
            }
         }
         ippsFree(m_codec.pBanks);
         m_codec.pBanks = NULL;
         m_codec.nBanks = 0;
      }
   }
   m_stateFlag = 0;
   m_frame_num = 0;

   return UMC_OK;
}

USCEncoder::~USCEncoder(void)
{
   Close();
}

Status
USCEncoder::GetDuration(Ipp32f* p_duration)
{
    Ipp32f duration;

    duration = (Ipp32f)m_frame_num * (m_codec.pInfo.params.framesize/(m_codec.pInfo.params.pcmType.bitPerSample>>3));
    duration /= m_codec.pInfo.params.pcmType.sample_frequency;

    p_duration[0] = duration;

    return UMC_OK;
}

PrivateUSCEncoder::PrivateUSCEncoder(USC_Fxns *FNS) : USCEncoder(FNS)
{
   m_pSpeechBitstream = NULL;
}

PrivateUSCEncoder::~PrivateUSCEncoder()
{
   if(m_pSpeechBitstream) {
      delete m_pSpeechBitstream;
      m_pSpeechBitstream = NULL;
   }
}

#define USC_BITSTREAM_HEADER_SIZE 6

Status PrivateUSCEncoder::GetFrame(MediaData *in, MediaData *out)
{
   Status umcRes;

   if(in==NULL) return UMC_ERR_NULL_PTR;
   if(out==NULL) return UMC_ERR_NULL_PTR;

   size_t inputSize = in->GetDataSize();
   size_t outputSize;

   if(m_pSpeechBitstream==NULL) {
      m_pSpeechBitstream = new SpeechMediaData;
   }

   m_pSpeechBitstream->SetBufferPointer((Ipp8u*)out->GetDataPointer()+USC_BITSTREAM_HEADER_SIZE,out->GetBufferSize()-USC_BITSTREAM_HEADER_SIZE);

   umcRes = USCEncoder::GetFrame(in,m_pSpeechBitstream);

   if(UMC_OK==umcRes) {
      Ipp8u tmp;
      Ipp32s fieldValue;
      Ipp8s *pHeader = (Ipp8s*)out->GetDataPointer();

      fieldValue = m_pSpeechBitstream->GetBitrate();
      tmp = (Ipp8u)(((Ipp32u)fieldValue)>>16);
      pHeader[0] = (Ipp8s)(tmp&0xFF);
      tmp = (Ipp8u)(((Ipp32u)fieldValue)>>8);
      pHeader[1] = (Ipp8s)(tmp&0xFF);
      pHeader[2] = (Ipp8s)(fieldValue&0xFF);

      fieldValue = m_pSpeechBitstream->GetFrameType();
      pHeader[3] = (Ipp8s)fieldValue;

      fieldValue = m_pSpeechBitstream->GetNBytes();
      tmp = (Ipp8u)(((Ipp16u)fieldValue)>>8);
      pHeader[4] = (Ipp8s)(tmp&0xFF);

      pHeader[5] = (Ipp8s)(fieldValue&0xFF);

      out->SetDataSize(m_pSpeechBitstream->GetDataSize()+USC_BITSTREAM_HEADER_SIZE);
      outputSize = in->GetDataSize();

      size_t diff = inputSize-outputSize;
      if(diff > 0) {
         in->SetDataSize(inputSize);
         in->MoveDataPointer((Ipp32s)diff);
         in->SetTime(m_pSpeechBitstream->GetTime());
      }
   }
   return umcRes;
}

PrivateUSCDecoder::PrivateUSCDecoder(USC_Fxns *FNS) : USCDecoder(FNS)
{
   m_pSpeechBitstream = NULL;
}

PrivateUSCDecoder::~PrivateUSCDecoder()
{
   if(m_pSpeechBitstream) {
      delete m_pSpeechBitstream;
      m_pSpeechBitstream = NULL;
   }
}

Status PrivateUSCDecoder::GetFrame(MediaData *in, MediaData *out)
{
   Status umcRes;

   if(in==NULL) return UMC_ERR_NULL_PTR;
   if(out==NULL) return UMC_ERR_NULL_PTR;

   size_t inputSize = in->GetDataSize();
   size_t outputSize;

   if(m_pSpeechBitstream==NULL) {
      m_pSpeechBitstream = new SpeechMediaData;
   }

   m_pSpeechBitstream->SetBufferPointer((Ipp8u*)in->GetDataPointer()+USC_BITSTREAM_HEADER_SIZE,in->GetDataSize()-USC_BITSTREAM_HEADER_SIZE);
   m_pSpeechBitstream->SetDataSize(in->GetDataSize()-USC_BITSTREAM_HEADER_SIZE);
   m_pSpeechBitstream->SetTime(in->GetTime());
   /*Read frame header*/
   Ipp8s *pHeader = (Ipp8s *)in->GetDataPointer();
   m_pSpeechBitstream->SetBitrate((Ipp32s)(((Ipp8u)(pHeader[0])<<16)|((Ipp8u)(pHeader[1])<<8)|(Ipp8u)pHeader[2]));
   m_pSpeechBitstream->SetFrameType((Ipp32s)(pHeader[3]));
   m_pSpeechBitstream->SetNBytes((Ipp32s)(((Ipp8u)(pHeader[4])<<8)|(Ipp8u)pHeader[5]));

   umcRes = USCDecoder::GetFrame(m_pSpeechBitstream,out);

   if(UMC_OK==umcRes) {
      outputSize = m_pSpeechBitstream->GetDataSize() + USC_BITSTREAM_HEADER_SIZE;
      int diff = (int)(inputSize-outputSize);
      if(diff >= 0) {
         in->SetDataSize(inputSize);
         in->MoveDataPointer((Ipp32s)(diff+USC_BITSTREAM_HEADER_SIZE));
      }
   }

   return umcRes;
}

};// namespace UMC