umc_reverb_filter.cpp

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

/*//////////////////////////////////////////////////////////////////////////////
//
//                  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) 2003-2006 Intel Corporation. All Rights Reserved.
//
*/

#include "umc_reverb_filter.h"
#include "reverb_filter.h"
#include "vm_debug.h"

extern Ipp32f firDelays[];
extern Ipp32s combDelays[];

namespace UMC
{

ReverbFilter::ReverbFilter()
{
  pRevState = NULL;
  pFileInfo = NULL;
  //    s3d_params = new Sound3dFilterParams;
        /* default */
/*      s3d_params->Delay = 20;
        s3d_params->LenFilter   = 200;
        s3d_params->LenInvFilter= 200;
        s3d_params->pos_speakers= 30;*/
}

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

Status ReverbFilter::Init(BaseCodecParams* params)
{
  ReverbFilterParams* revParams = (ReverbFilterParams*)params;

  Ipp32s sRate = revParams->fileSampleRate;
  Ipp32s nchan = revParams->fileChannels;
  Ipp32s maxLen = revParams->maxFrameLen;
  Ipp32s i;

  if (revParams == NULL)
    return UMC_ERR_NULL_PTR;

  if ((nchan != 1) && (nchan != 2))
    return UMC_ERR_INIT;

  pFileInfo = (FileInfo *)new FileInfo;
  if (pFileInfo) {
    pFileInfo->nChannels = nchan;
    pFileInfo->sRate = sRate;
  } else {
    return UMC_ERR_INIT;
  }

  pRevState = (ReverbState *)new ReverbState;
  if (pRevState) {
    pRevState->maxFrameLen = maxLen;
    pRevState->eReflect = revParams->eReflect;
    pRevState->lReflect = revParams->lReflect;
    pRevState->eReflectScale = revParams->eReflectScale;
    pRevState->decayTime = revParams->decayTime;
    pRevState->outputLevel = revParams->outputLevel;

    /***** FIR INIT *****/
    RevFIRFilterInit(pRevState);
    /***** EXTRA DELAY INIT *****/
    RevExtraDelayInit(pRevState);
    /***** COMB INIT *****/
    RevCombFilterInit(pRevState);
    /***** ALLPASS INIT *****/
    RevAPFilterInit(pRevState);
  } else {
    return UMC_ERR_INIT;
  }

  frameBuf32 = (Ipp32f **)ippMalloc(nchan * sizeof(Ipp32f *));
  frameBuf32dst = (Ipp32f **)ippMalloc(nchan * sizeof(Ipp32f *));
  frameBuf16 = (Ipp16s **)ippMalloc(nchan * sizeof(Ipp16s *));

  if ((frameBuf32 == NULL) || (frameBuf32dst == NULL) || (frameBuf16 == NULL)) {
    return UMC_ERR_NULL_PTR;
  }

  for (i = 0; i < nchan; i++) {
    frameBuf32[i] = ippsMalloc_32f(maxLen);
    if (frameBuf32[i] == NULL) {
      return UMC_ERR_NULL_PTR;
    }
    frameBuf32dst[i] = ippsMalloc_32f(maxLen);
    if (frameBuf32dst[i] == NULL) {
      return UMC_ERR_NULL_PTR;
    }
    frameBuf16[i] = ippsMalloc_16s(maxLen);
    if (frameBuf16[i] == NULL) {
      return UMC_ERR_NULL_PTR;
    }
  }
  return UMC_OK;
}

Status ReverbFilter::Close()
{
  Ipp32s nchan = pFileInfo->nChannels;
  Ipp32s i;

  for (i = 0; i < nchan; i++) {
    ippsFree(frameBuf32[i]);
    ippsFree(frameBuf32dst[i]);
    ippsFree(frameBuf16[i]);
  }
  ippFree(frameBuf32);
  ippFree(frameBuf32dst);
  ippFree(frameBuf16);
  if (pRevState) {
    /***** FIR FREE *****/
    RevFIRFilterFree(pRevState);
    /***** EXTRA DELAY FREE *****/
    RevExtraDelayFree(pRevState);
    /***** COMB FREE *****/
    RevCombFilterFree(pRevState);
    /***** ALLPASS FREE *****/
    RevAPFilterFree(pRevState);
  }
  delete pRevState;
  delete pFileInfo;

  return UMC_OK;
}

Status ReverbFilter::SetParams(BaseCodecParams* params)
{
  ReverbFilterParams* revParams = (ReverbFilterParams*)params;

  if (revParams == NULL)
    return UMC_ERR_NULL_PTR;

  pFileInfo->sRate = revParams->fileSampleRate;
  pFileInfo->nChannels = revParams->fileChannels;
  pRevState->eReflect = revParams->eReflect;
  pRevState->lReflect = revParams->lReflect;
  pRevState->outputLevel = revParams->outputLevel;

  Ipp32f RMScale = pRevState->eReflectScale;
  if (revParams->eReflectScale != RMScale) {
    RevFIRFilterFree(pRevState);
    RevExtraDelayFree(pRevState);
    pRevState->eReflectScale = revParams->eReflectScale;
    RevFIRFilterInit(pRevState);
    RevExtraDelayInit(pRevState);
  }

  Ipp32f dTime = pRevState->decayTime;
  if (revParams->decayTime != dTime) {
    RevCombFilterFree(pRevState);
    RevAPFilterFree(pRevState);
    pRevState->decayTime = revParams->decayTime;
    RevCombFilterInit(pRevState);
    RevAPFilterInit(pRevState);
  }
  return UMC_OK;
}

Status ReverbFilter::GetInfo(BaseCodecParams *info)
{
  ReverbFilterParams *pInfo = (ReverbFilterParams*)info;

  if (pInfo == NULL)
    return UMC_ERR_NULL_PTR;

  pInfo->fileSampleRate = pFileInfo->sRate;
  pInfo->fileChannels = pFileInfo->nChannels;

  pInfo->eReflect = pRevState->eReflect;
  pInfo->lReflect = pRevState->lReflect;
  pInfo->eReflectScale = pRevState->eReflectScale;
  pInfo->decayTime = pRevState->decayTime;
  pInfo->maxFrameLen = pRevState->maxFrameLen;
  pInfo->outputLevel = pRevState->outputLevel;

  Ipp32s dlen = pRevState->fir.FIRTapPos[FIR_NZTAP_NUM - 1];
  dlen += (Ipp32s)((firDelays[FIR_NZTAP_NUM - 1] - combDelays[0]) * pRevState->eReflectScale * pFileInfo->sRate * 0.001 + 0.5);

  pInfo->EarlyReflectionsDelayLineLen = dlen;

  return UMC_OK;
}

Status ReverbFilter::GetFrame(MediaData* inData, MediaData* outData)
{
  IppStatus ippStat;
  Ipp16s* inBuf = (Ipp16s *)inData->GetDataPointer();
  Ipp16s* outBuf = (Ipp16s *)outData->GetDataPointer();
  Ipp32s len = (inData->GetDataSize()) >> 1; //in shorts
  Ipp32s i;
  Ipp32s nchan = pFileInfo->nChannels;

  if (nchan == 2) {
    len >>= 1;
  }

  ippStat = ippsDeinterleave_16s(inBuf, nchan, len, frameBuf16);
  if (ippStat != ippStsNoErr) {
    return UMC_ERR_FAILED;
  }

  for (i = 0; i < nchan; i++) {
    ippStat = ippsConvert_16s32f(frameBuf16[i], frameBuf32[i], len);
    if (ippStat != ippStsNoErr) {
      return UMC_ERR_FAILED;
    }
    ippStat = ippsZero_32f(frameBuf32dst[i], len);
    if (ippStat != ippStsNoErr) {
      return UMC_ERR_FAILED;
    }
  }
/*
  printf("\nbef rev:\n");
  for (i = 0; i < len; i++) {
    printf("%f ", frameBuf32[0][i]);
  }

  printf("\nbef rev dst:\n");
  for (i = 0; i < len; i++) {
    printf("%f ", frameBuf32dst[0][i]);
  }
*/
  Reverberate(frameBuf32, frameBuf32dst, len, pRevState);
 /* printf("\naft rev:\n");
  for (i = 0; i < len; i++) {
    printf("%f ", frameBuf32dst[0][i]);
  }
*/
  ippStat = ippsJoin_32f16s_D2L((const Ipp32f **)frameBuf32dst, nchan, len, outBuf);
  if (ippStat != ippStsNoErr) {
    return UMC_ERR_FAILED;
  }

  return UMC_OK;
}

}; //namespace UMC