umc_reverb_demodlg.cpp

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

  pRevParams->eReflect = revInfo.eReflect;
  pRevParams->lReflect = revInfo.lReflect;
  pRevParams->eReflectScale = 0.5f + (revInfo.RSSliderPos / 10.f) * 0.5f;
  pRevParams->decayTime = revInfo.FSliderPos / 20.f + 1.f;
  pRevParams->outputLevel = (100 - revInfo.LevelSliderPos) * 0.01f;
  Ipp32s cleanLen = (Ipp32s)(pRevParams->decayTime * fileInfo.sRate + 0.5);

  umc_stat = pRevFilter->Init((UMC::BaseCodecParams *)pRevParams);
  if (umc_stat != UMC::UMC_OK) {
    fileInfo.dlg->MessageBox("Failed to Init RevFilter", "Error", MB_ICONERROR);
    goto __exit;
  }

  Ipp32s dataLen = fileInfo.data_chunk.chunk_len >> 1;  //in shorts
  if (fileInfo.nchan == 2) {
    dataLen >>= 1;
  }

  fileInfo.BufIsEmpty = 1;

  Ipp32s prevState = fileInfo.isPlaying;
  while (dataLen != 0) {

    if (fileInfo.isPlaying != prevState) {  // play button was pressed
      if (fileInfo.isPlaying == -1) {  //stop
        pRender->Pause(TRUE);
        goto __exit;
  //      pRender->Stop();
/*
        ippsFree(inBuf);
        delete inData;
        delete pRevParams;
        delete pRevFilter;
        delete pRenderParams;
        delete pRender;
        return 0;
*/
      } else
      if (fileInfo.isPlaying == 0) { //pause
        pRender->Pause(TRUE);
        prevState = fileInfo.isPlaying;
        continue;
      } else
      if (fileInfo.isPlaying == 1) { //pause
        pRender->Pause(FALSE);
        prevState = fileInfo.isPlaying;
      }
    }

    if (fileInfo.isPlaying == 0) {  // stay on pause
      vm_time_sleep(10);
      continue;
    }

    if (revInfo.revParamsChanged == TRUE) {
      revInfo.revParamsChanged = FALSE;
      pRevParams->eReflect = revInfo.eReflect;
      pRevParams->lReflect = revInfo.lReflect;
      pRevParams->eReflectScale = 0.5f + (revInfo.RSSliderPos / 10.f) * 0.5f;
      pRevParams->decayTime = revInfo.FSliderPos / 20.f + 1.f;
      pRevParams->outputLevel = (100 - revInfo.LevelSliderPos) * 0.01f;
      cleanLen = (Ipp32s)(pRevParams->decayTime * fileInfo.sRate + 0.5);
      umc_stat = pRevFilter->SetParams((UMC::BaseCodecParams *)pRevParams);
      if (umc_stat != UMC::UMC_OK) {
        fileInfo.dlg->MessageBox("Failed to check \"Room size\"!!!", "Error", MB_ICONERROR);
        goto __exit;
      }
    }

    if (fileInfo.BufIsEmpty) {
      maxRead = (REVERB_BUF_SIZE > dataLen) ? dataLen : REVERB_BUF_SIZE;
      Ipp32s n = fread(inBuf, sizeof(Ipp16s), maxRead * fileInfo.nchan, fileInfo.data);
      if (n !=  maxRead * fileInfo.nchan) {
        if (ferror(fileInfo.data)) {
          fileInfo.dlg->MessageBox("Failed on fread!!!", "", MB_ICONERROR);
          goto __exit;
        }
        if (n == 0)
          break;
        else {
          maxRead = n;
          if (fileInfo.nchan == 2)
            maxRead >>= 1;
        }
      }
      fileInfo.BufIsEmpty = 0;
    }

    if (revInfo.reverb == TRUE) {
      UMC::Status umcRes;
      do
      {
        umcRes = pRender->LockInputBuffer( &outData );
        if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes) {
          vm_time_sleep(5);
          if (fileInfo.isPlaying != 1)
            break;
        }
      } while ( UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes );

      if ((fileInfo.isPlaying != 1) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)) {
        /* catching that Pause is pushed in the other thread */
        continue;
      }

      umcRes = pRevFilter->GetFrame(inData, &outData);
      if (UMC::UMC_OK != umcRes) {
        fileInfo.dlg->MessageBox("Failed in pRevFilter->GetFrame!!!", "", MB_ICONERROR);
        goto __exit;
      }
      fileInfo.BufIsEmpty = 1;
      outData.SetDataSize(maxRead * fileInfo.nchan * sizeof(Ipp16s));

      if (dataLen == maxRead) {
        umcRes = pRender->UnLockInputBuffer(&outData, UMC::UMC_ERR_END_OF_STREAM);
      } else {
        umcRes = pRender->UnLockInputBuffer(&outData, UMC::UMC_OK);
      }
      if (UMC::UMC_OK != umcRes) {
        fileInfo.dlg->MessageBox("Failed to unlock input buffer!!!", "", MB_ICONERROR);
        goto __exit;
      }

    } else {
      UMC::Status umcRes;
      do
      {
        umcRes = pRender->LockInputBuffer( &outData );
        if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes) {
          vm_time_sleep(5);
          if (fileInfo.isPlaying != 1)
            break;
        }
      } while ( UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes );

      if ((fileInfo.isPlaying != 1) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)) {
        /* catching that Pause is pushed in the other thread */
        continue;
      }

      memcpy(outData.GetDataPointer(), inBuf, maxRead * fileInfo.nchan * sizeof(Ipp16s));
      fileInfo.BufIsEmpty = 1;
      outData.SetDataSize(maxRead * fileInfo.nchan * sizeof(Ipp16s));

      if (dataLen == maxRead) {
        umcRes = pRender->UnLockInputBuffer(&outData, UMC::UMC_ERR_END_OF_STREAM);
      } else {
        umcRes = pRender->UnLockInputBuffer(&outData, UMC::UMC_OK);
      }
      if (UMC::UMC_OK != umcRes) {
        fileInfo.dlg->MessageBox("Failed to unlock input buffer!!!", "", MB_ICONERROR);
        goto __exit;
      }
    }

    dataLen -= maxRead;
  }

  if (revInfo.reverb == TRUE) {  //the last echoes
    UMC::ReverbFilterParams *pInfo = new UMC::ReverbFilterParams;

    umc_stat = pRevFilter->GetInfo((UMC::BaseCodecParams *)pInfo);
    if (umc_stat != UMC::UMC_OK) {
      fileInfo.dlg->MessageBox("Failed to check \"Room size\"!!!", "Error", MB_ICONERROR);
      delete pInfo;
      goto __exit;
    }
    Ipp32s dataLenClean = 0;
    if (revInfo.eReflect) {
      dataLenClean = pInfo->EarlyReflectionsDelayLineLen;
    }
    if (revInfo.lReflect) {
      Ipp32s dlen = (Ipp32s)((pInfo->decayTime) * fileInfo.sRate + 0.5);
      dataLenClean += dlen;
    }

    ippStat = ippsZero_16s(inBuf, REVERB_BUF_SIZE * fileInfo.nchan);
    if (ippStat != ippStsNoErr) {
      fileInfo.dlg->MessageBox("Failed to clean InBuf!!!", "", MB_ICONERROR);
      delete pInfo;
      goto __exit;
    }

    while (dataLenClean != 0) {
      UMC::Status umcRes;
      do
      {
        umcRes = pRender->LockInputBuffer( &outData );
        if (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes) {
          vm_time_sleep(5);
          if (fileInfo.isPlaying != 1)
            break;
        }
      } while ( UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes );

      if ((fileInfo.isPlaying != 1) && (UMC::UMC_ERR_NOT_ENOUGH_BUFFER == umcRes)) {
        /* catching that Pause is pushed in the other thread */
        continue;
      }

      Ipp32s maxRead = (REVERB_BUF_SIZE > dataLenClean) ? dataLenClean : REVERB_BUF_SIZE;
      Ipp32s freeBuff = outData.GetBufferSize() / fileInfo.nchan / sizeof(Ipp16s);
      if (maxRead > freeBuff) {
        maxRead = freeBuff;
      }
      dataLenClean -= maxRead;
      inData->SetDataSize(maxRead * fileInfo.nchan * sizeof(Ipp16s));
      outData.SetDataSize(maxRead * fileInfo.nchan * sizeof(Ipp16s));
      umcRes = pRevFilter->GetFrame(inData, &outData);
      if (UMC::UMC_OK != umcRes) {
        fileInfo.dlg->MessageBox("Failed in pRevFilter->GetFrame!!!", "", MB_ICONERROR);
        goto __exit;
      }

      if (dataLenClean == 0) {
        umcRes = pRender->UnLockInputBuffer(&outData, UMC::UMC_ERR_END_OF_STREAM);
      } else {
        umcRes = pRender->UnLockInputBuffer(&outData, UMC::UMC_OK);
      }
      if (UMC::UMC_OK != umcRes) {
        fileInfo.dlg->MessageBox("Failed to unlock input buffer!!!", "", MB_ICONERROR);
        goto __exit;
      }

    }
    delete pInfo;
  }

  while (pRender->GetTime() != -1.0) {
    vm_debug_trace(VM_DEBUG_ALL, VM_STRING("waiting render to finish\n"));
    vm_time_sleep(100);
  }

__exit:
  ippsFree(inBuf);
  delete pRender;
  delete inData;
  delete pRevParams;
  delete pRevFilter;
  delete pRenderParams;

////pRender->Close();
  fileInfo.isPlaying = -1;
  fileInfo.dlg->m_PlayButton.SetWindowText("Play");

  return 0;
}

void CUmc_reverb_demoDlg::OnButtonPlay()
{
  fileInfo.dlg = this;

  if (fileInfo.isPlaying == -1) {  // playback is stopped
    Ipp32s nIndex = m_FileFromList.GetCurSel();

    if  (m_FileFromList.GetText(nIndex, fileInfo.file_name) == LB_ERR) {
      MessageBox("Choose the file to play!", "Attention", MB_ICONWARNING);
      return;
    }

    Ipp32s res = FillInFileStruct();
    if (res != 0) {
      MessageBox("The file is not of WAV format(mono or stereo)\nor is corrupted!", "", MB_ICONERROR);
      return;
    }

    m_PlayButton.SetWindowText("Pause");
    fileInfo.isPlaying = 1;

    vm_thread_set_invalid(&(fileInfo.play_thread));

    res = vm_thread_create(&(fileInfo.play_thread), playback_thread, &fileInfo);
    if (res != 1) {
      MessageBox("Failed to create a new thread", "Error", MB_ICONERROR);
      return;
    }
  } else
  if (fileInfo.isPlaying == 0) { // playback is paused
    m_PlayButton.SetWindowText("Pause");
    fileInfo.isPlaying = 1;
  } else
  if (fileInfo.isPlaying == 1) { // playback is run
    m_PlayButton.SetWindowText("Play");
    fileInfo.isPlaying = 0;
  }
}

void CUmc_reverb_demoDlg::OnDblclkList()
{
  fileInfo.isPlaying = -1;
  vm_thread_close(&(fileInfo.play_thread));
  this->OnButtonPlay();
}

void CUmc_reverb_demoDlg::OnBnClickedCheckReverb()
{
  if (m_ReverbEnable.GetCheck() == 1) {
    revInfo.reverb = TRUE;
    m_RoomSizeEnable.EnableWindow(TRUE);
    m_FinishingEnable.EnableWindow(TRUE);
    m_RSSliderValue.EnableWindow(TRUE);
    m_FSliderValue.EnableWindow(TRUE);
    m_TextMin.EnableWindow(TRUE);
    m_TextMax.EnableWindow(TRUE);
    m_TextSoft.EnableWindow(TRUE);
    m_TextHard.EnableWindow(TRUE);
    m_RSDef.EnableWindow(TRUE);
    m_FDef.EnableWindow(TRUE);
    m_TextRSLevel.EnableWindow(TRUE);
    m_RSLSliderValue.EnableWindow(TRUE);
    m_TextRSLMax.EnableWindow(TRUE);
    m_TextRSLMin.EnableWindow(TRUE);
  } else {
    revInfo.reverb = FALSE;
    m_RoomSizeEnable.EnableWindow(FALSE);
    m_FinishingEnable.EnableWindow(FALSE);
    m_RSSliderValue.EnableWindow(FALSE);
    m_FSliderValue.EnableWindow(FALSE);
    m_TextMin.EnableWindow(FALSE);
    m_TextMax.EnableWindow(FALSE);
    m_TextSoft.EnableWindow(FALSE);
    m_TextHard.EnableWindow(FALSE);
    m_RSDef.EnableWindow(FALSE);
    m_FDef.EnableWindow(FALSE);
    m_TextRSLevel.EnableWindow(FALSE);
    m_RSLSliderValue.EnableWindow(FALSE);
    m_TextRSLMax.EnableWindow(FALSE);
    m_TextRSLMin.EnableWindow(FALSE);
  }
}

void CUmc_reverb_demoDlg::OnBnClickedCheckRoomsize()
{
  if (m_RoomSizeEnable.GetCheck() == 1) {
    revInfo.eReflect = TRUE;
  } else {
    revInfo.eReflect = FALSE;
  }
  revInfo.revParamsChanged = TRUE;
}

void CUmc_reverb_demoDlg::OnBnClickedCheckFinishing()
{
  if (m_FinishingEnable.GetCheck() == 1) {
    revInfo.lReflect = TRUE;
  } else {
    revInfo.lReflect = FALSE;
  }
  revInfo.revParamsChanged = TRUE;
}

void CUmc_reverb_demoDlg::OnNMReleasedcaptureRoomsizeSlider(NMHDR *pNMHDR, LRESULT *pResult)
{
  Ipp32s cur_pos = m_RSSliderValue.GetPos();

  if (cur_pos != revInfo.RSSliderPos) {
    revInfo.RSSliderPos = cur_pos;
    revInfo.revParamsChanged = TRUE;
  }
  *pResult = 0;
}

void CUmc_reverb_demoDlg::OnNMReleasedcaptureFinishingSlider(NMHDR *pNMHDR, LRESULT *pResult)
{
  Ipp32s cur_pos = m_FSliderValue.GetPos();

  if (cur_pos != revInfo.FSliderPos) {
    revInfo.FSliderPos = cur_pos;
    revInfo.revParamsChanged = TRUE;
  }
  *pResult = 0;
}

void CUmc_reverb_demoDlg::OnBnClickedButtonRsdef()
{
  m_RSSliderValue.SetPos(10);
  revInfo.RSSliderPos = 10;
  revInfo.revParamsChanged = TRUE;
}

void CUmc_reverb_demoDlg::OnBnClickedButtonFdef()
{
  m_FSliderValue.SetPos(20);
  revInfo.FSliderPos = 20;
  revInfo.revParamsChanged = TRUE;
}


void CUmc_reverb_demoDlg::OnNMReleasedcaptureRslSlider(NMHDR *pNMHDR, LRESULT *pResult)
{
  Ipp32s cur_pos = m_RSLSliderValue.GetPos();

  if (cur_pos != revInfo.LevelSliderPos) {
    revInfo.LevelSliderPos = cur_pos;
    revInfo.revParamsChanged = TRUE;
  }
  *pResult = 0;
}