main.cpp

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

        err = -4;
        break;
    }

    pAudioCodec = (UMC::AudioCodec *) iterator->Create();

    if (pAudioCodec == NULL) {
        vm_debug_trace(-1, __VM_STRING("Can't create audio codec object '%s'\n"),
            params.codec_name);
        vm_string_printf(__VM_STRING("Can't create audio codec object '%s'\n"),
            params.codec_name);
        err = -5;
        break;
    }

    if (isSplitterRequired) {
        spl->GetNextAudioData(&in_data);
        audio_codec_params->m_pData = &in_data;
        pMediaBuffer = DynamicCast < MediaBuffer > (new SampleBuffer);
        if (NULL == pMediaBuffer) {
            vm_string_printf(VM_STRING("Memory allocation error\n"));
            err = -1;
            break;
        }
    } else {
        audio_codec_params->m_pData = NULL;
        pMediaBuffer = DynamicCast < MediaBuffer > (new LinearBuffer);

        if (NULL == pMediaBuffer) {
            vm_string_printf(VM_STRING("Memory allocation error\n"));
            err = -1;
            break;
        }
    }

    media_buffer_params =
        DynamicCast < MediaBufferParams > (new MediaBufferParams);

    pOut = new MediaData(1024*2*10);
    if (NULL == pOut) {
        vm_string_printf(VM_STRING("Memory allocation error\n"));
        err = -1;
        break;
    }

    media_buffer_params->m_numberOfFrames      = 10;
    media_buffer_params->m_prefInputBufferSize = 768 * 10;

    codec_init.m_pCodec             = pAudioCodec;
    codec_init.m_pMediaBuffer       = pMediaBuffer;
    codec_init.m_pCodecInitParams   = audio_codec_params;
    codec_init.m_pMediaBufferParams = media_buffer_params;

    sts = dual_treaded_codec.InitCodec(&codec_init);
    if (sts != UMC::UMC_OK) {
        vm_string_printf(VM_STRING("Failed to initalize codec plugin\n"));
        return sts;
    }

    if (isSplitterRequired) {
        sts = dual_treaded_codec.LockInputBuffer(&inMediaBuffer);

        if (sts == UMC::UMC_OK) {
            memcpy(inMediaBuffer.GetBufferPointer(), in_data.GetDataPointer(),
                in_data.GetDataSize());
            inMediaBuffer.SetDataSize(in_data.GetDataSize());

            dual_treaded_codec.UnLockInputBuffer(&inMediaBuffer);
        } // if (sts == UMC::UMC_OK)
    } // if (isSplitterRequired)

    if (sts == UMC::UMC_OK) {
        t_freq = vm_time_get_frequency();
        t_end = 0;

#ifdef EX_PARAM
    aacdec_params = new AACDecoderParams;

    if ( params.ModeDecode )
      aacdec_params->ModeDecodeHEAACprofile = HEAAC_LP_MODE;
    else
      aacdec_params->ModeDecodeHEAACprofile = HEAAC_HQ_MODE;

    if ( params.ModeDownSample )
      aacdec_params->ModeDwnmxHEAACprofile  = HEAAC_DWNSMPL_ON;
    else
      aacdec_params->ModeDwnmxHEAACprofile  = HEAAC_DWNSMPL_OFF;

    pAudioCodec->SetParams( DynamicCast<BaseCodecParams>(aacdec_params) );
#endif

    if (!vm_string_strncmp(params.codec_name, VM_STRING("ac3_dec"), 7)) {
      pAudioCodec->SetParams(DynamicCast<BaseCodecParams>(&(params.ac3dec_params)));
    }

    if (isSplitterRequired) {

        do {
            sts = dual_treaded_codec.LockInputBuffer(&inMediaBuffer);

            if (sts == UMC::UMC_OK) {
                umcRes = spl->GetNextAudioData(&in_data);
                memcpy(inMediaBuffer.GetBufferPointer(), in_data.GetDataPointer(),
                    in_data.GetDataSize());

                inMediaBuffer.SetDataSize(in_data.GetDataSize());

                assert(in_data.GetDataSize() <= inMediaBuffer.GetBufferSize());

                dual_treaded_codec.UnLockInputBuffer(&inMediaBuffer);
            }

            do {
            t_start = vm_time_get_tick();
            sts = dual_treaded_codec.GetFrame(pOut);
            t_end += (vm_time_get_tick() - t_start);

            if (sts == UMC::UMC_OK) {
                p_out_file->Write(pOut->GetDataPointer(), pOut->GetDataSize());
                numFramesToProcess++;
//                vm_string_printf(VM_STRING("m_frame_num = %d\r"), numFramesToProcess);
                double start, end;

                pOut->GetTime(start, end);
            }
            } while (sts == UMC::UMC_OK);
        } while ((umcRes != UMC_END_OF_STREAM) && (sts != UMC::UMC_BAD_STREAM));

        } else {
        do {
            sts = dual_treaded_codec.LockInputBuffer(&inMediaBuffer);

            if (sts == UMC::UMC_OK) {
          size_t needSize = inMediaBuffer.GetBufferSize();
          size =
              p_in_file->Read(inMediaBuffer.GetBufferPointer(), needSize);
          inMediaBuffer.SetDataSize(size);
          if (size == needSize)
            dual_treaded_codec.UnLockInputBuffer(&inMediaBuffer);
          else
            dual_treaded_codec.UnLockInputBuffer(&inMediaBuffer, UMC_END_OF_STREAM);
            }

            do {
            t_start = vm_time_get_tick();
            sts = dual_treaded_codec.GetFrame(pOut);
            t_end += (vm_time_get_tick() - t_start);

            if (sts == UMC::UMC_OK) {

                p_out_file->Write(pOut->GetDataPointer(), pOut->GetDataSize());

                if (params.is_text_out) {
                    dbg_dump_array_16s((short *)pOut->GetDataPointer(),
                                        pOut->GetDataSize() / 2, "%s%07d.txt",
                                        params.output_txt, numFramesToProcess);
                }

                numFramesToProcess++;
//                vm_string_printf(VM_STRING("m_frame_num = %d\r"), numFramesToProcess);

                double start, end;

                pOut->GetTime(start, end);
            }
            } while (sts == UMC::UMC_OK);
        } while ((size) && (sts != UMC::UMC_BAD_STREAM));
        }

        t_encode_time = (double)((vm_var64s) (t_end)) / (vm_var64s) t_freq;
    }


    pAudioCodec->GetInfo(audio_codec_params);

    // float dur;
    // pAudioCodec->GetDuration(&dur);
    //  vm_string_printf(__VM_STRING
    //                   ("Encoding/decoding time, sec : %f [%06d frames]\n"),
    //                   t_encode_time, numFramesToProcess);
    //  vm_string_printf(__VM_STRING("Stream duration, sec        : %f\n"), dur);
    // t_encode_time /= dur;
    //  vm_string_printf(__VM_STRING("Performance,(sec/sec)       : %f\n"),
    //                   t_encode_time);
    //  vm_string_printf(__VM_STRING
    //                   ("* Multiply the performance by the CPU frequency to convert into MHz\n"));

    if (audio_codec_params->m_info_out.stream_type == PCM_AUDIO) {
        info_file_out.format_tag = 1;
        info_file_out.channels_number = audio_codec_params->m_info_out.channels;
        info_file_out.sample_rate =
            audio_codec_params->m_info_out.sample_frequency;
        info_file_out.resolution = audio_codec_params->m_info_out.bitPerSample;
        info_file_out.channel_mask = audio_codec_params->m_info_out.channel_mask;

        wav_file_out.SetInfo(&info_file_out);
    }

    break;
  } // while (1)

  p_out_file->Close();
  if (!isSplitterRequired)
    p_in_file->Close();

  if (pOut)
    delete pOut;

  if (pAudioCodec)
    delete pAudioCodec;

  pAudioCodec = NULL;

  if (pMediaBuffer)
    delete pMediaBuffer;

  pMediaBuffer = NULL;

  if (acp_allocated) {
  if (audio_codec_params)
    delete audio_codec_params;
  }

  audio_codec_params = NULL;

  if (media_buffer_params)
    delete media_buffer_params;

  media_buffer_params = NULL;

#ifdef EX_PARAM
  if ( aacdec_params )
    delete aacdec_params;

  aacdec_params = NULL;
#endif

  if (!err) {
  //    vm_string_printf(VM_STRING("Processing is completed successfully\n"));
  }

  return err;
}

void LoadPlugins(Factory & factory)
{

// / Register static plugins into factory
  factory.InitStatic();

#ifndef STATIC_OBJECTS_ONLY

#if defined (_WIN32_WCE)
  factory.Load(VM_STRING("aac_dec_i.dll"));
  factory.Load(VM_STRING("aac_enc_i.dll"));
  factory.Load(VM_STRING("mp3_dec_i.dll"));
  factory.Load(VM_STRING("mp3_enc_i.dll"));
#elif defined (WIN32)
  factory.Load("mp3_dec.dll");
  factory.Load("mp3_dec_i.dll");
  factory.Load("mp3_enc.dll");
  factory.Load("mp3_enc_i.dll");
  factory.Load("aac_dec.dll");
  factory.Load("aac_dec_i.dll");
  factory.Load("aac_enc.dll");
  factory.Load("aac_enc_i.dll");
  factory.Load("ac3_dec.dll");
#elif defined (LINUX32)
  factory.Load("libmp3_dec.so");
  factory.Load("libmp3_dec_i.so");
  factory.Load("libmp3_enc.so");
  factory.Load("libmp3_enc_i.so");
  factory.Load("libaac_dec.so");
  factory.Load("libaac_dec_i.so");
  factory.Load("libaac_enc.so");
  factory.Load("libaac_enc_i.so");
  factory.Load("libac3_dec.so");
#endif

#else  /* STATIC_OBJECTS_ONLY */

#error Please select platform for building

#endif  /* STATIC_OBJECTS_ONLY */

}