main.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) 2004-2005 Intel Corporation. All Rights Reserved.
//
*/

#define VM_DEBUG 7

#include "vm_thread.h"
#include "vm_mmap.h"
#include "vm_time.h"

#include "vm_debug.h"

#include <stdio.h>
#include "dbg.h"
#include "umc_structures.h"
#include "umc_audio_codec.h"
#include "params.h"
#include "umc_file_reader.h"

#ifdef UMC_ENABLE_MP4_SPLITTER
    #include "umc_mp4_spl.h"
#endif
#ifdef EX_PARAM
    #include "umc_aac_decoder.h"
#endif

#include "audio_codec_object.h"
#include "factory.h"

#include "wav_file.h"
#include "simple_file.h"

#include "umc_dual_thread_codec.h"
#include "umc_cyclic_buffer.h"
#include "umc_defs.h"

using namespace UMC;

struct sCommandLineParams
{
  vm_char input_file[256];
  vm_char output_file[256];

  int bUsePluginDll;
};

void LoadPlugins(Factory & factory);

int main(int argc, vm_char *argv[])
{
  AudioFile*                 p_in_file;
  AudioFile*                 p_out_file;

  SimpleFile                 file_in;
  SimpleFile                 file_out;

  WavFile                    wav_file_in;
  WavFile                    wav_file_out;

  WavFile::Info              info_file_in;
  WavFile::Info              info_file_out;

  int                        is_input_wav = 0;
  int                        err;
  int                        isSplitterRequired = 0;
  int                        acp_allocated = 0;

  vm_tick                    t_freq, t_start, t_end;
  double                     t_encode_time;
  int                        numFramesToProcess = 0;

  UMC::MediaData*            pOut = NULL;

  UMC::MediaData             inMediaBuffer;
  size_t                     size = 0;

  UMC::Status                sts;

  UMC::AudioCodec*           pAudioCodec;
  UMC::MediaBuffer*          pMediaBuffer;
  UMC::DualThreadedCodec     dual_treaded_codec;

  UMC::AudioCodecParams*     audio_codec_params;
#ifdef EX_PARAM
  UMC::AACDecoderParams*     aacdec_params = NULL;
#endif

  UMC::MediaBufferParams *   media_buffer_params;
  UMC::DualThreadCodecParams codec_init;

  sProgramParameters         params;
  Factory                    factory;

  MediaData                  in_data;

  Factory::Iterator < AudioCodecObject > iterator;


  // Initialization
  pAudioCodec  = NULL;
  pMediaBuffer = NULL;
  pAudioCodec  = NULL;
  audio_codec_params  = NULL;
  media_buffer_params = NULL;

  LoadPlugins(factory);

  if (argc < 2) {
    params_print_usage();
    return -1;
  }

  params_fill_by_default(&params);
  params_parse_command_line(&params, argc, argv);

  if (params.enumerate) {
    iterator = factory;

    vm_string_printf(VM_STRING("The following codecs are available:\n"));
    vm_string_printf(VM_STRING("%-25s %s\n------\n"),
                     VM_STRING("Codec name"), VM_STRING("Version"));

    while (iterator != NULL) {
      vm_string_printf(VM_STRING("%-25s %s\n"), iterator->GetName(), iterator->GetVersion());
      iterator++;
    }
    return 0;
  }

  p_in_file = &wav_file_in;
  p_out_file = &wav_file_out;

  if ((!vm_string_strncmp(params.codec_name, VM_STRING("aac_enc"), 7)) ||
      (!vm_string_strncmp(params.codec_name, VM_STRING("aac_enc_i"), 9))) {
    audio_codec_params = DynamicCast<AudioCodecParams>(&params.aacenc_params);
  } else {
  audio_codec_params = new UMC::AudioCodecParams;
  if (NULL == audio_codec_params) {
     vm_string_printf(VM_STRING("Memory allocation error\n"));
     return -1;
    }
    acp_allocated = 1;
  }

  UMC::SplitterParams   splInitParams;
  UMC::SplitterInfo     spl_info;
  UMC::FileReaderParams frInitParams;

  UMC::FileReader* pStream = NULL;
  UMC::Splitter*   spl     = NULL;

  UMC::Status umcRes = UMC::UMC_OK;

  while (1) {
    // Init FileReader
    pStream = new UMC::FileReader;

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

    vm_string_strcpy(frInitParams.m_file_name, params.input_file);

    if (pStream->Init(&frInitParams) != UMC::UMC_OK) {
      vm_string_printf(VM_STRING("Can't open input file: %s\n"), params.input_file);
      err = -1;
      break;
    }

    // Select splitter
    SystemStreamType type_splitter = UMC::Splitter::GetStreamType(pStream);

    if (type_splitter == UMC::MP4_ATOM_STREAM) {
#ifdef UMC_ENABLE_MP4_SPLITTER
      spl = new UMC::MP4Splitter;
      if (NULL == spl) {
        vm_string_printf(VM_STRING("Memory allocation error\n"));
        err = -1;
        break;
      }
#endif
      if (NULL == spl) {
          vm_string_printf(VM_STRING("Required splitter is not supported. Decoding is not possible\n\n"));
          err = -6;
          break;
      };

      // Parametrs of splitter
      splInitParams.m_lFlags      = UMC::AUDIO_SPLITTER;
      splInitParams.m_pDataReader = pStream;

      // Init Splitter
      if (spl->Init(splInitParams) != UMC::UMC_OK) {
        vm_string_printf(VM_STRING("Splitter initializion error\n\n"));
        err = -1;
        break;
      }

      // Get info about a mp4 file
      spl->GetInfo(&spl_info);
      if (spl_info.number_audio_tracks < 1) {
        vm_string_printf(VM_STRING("Audio tracks are absent in input files\n\n"));
        err = -7;
        break;
      }

      audio_codec_params->m_info_in = spl_info.m_audio_info;
      isSplitterRequired = 1;

    } else {
      isSplitterRequired = 0;
      audio_codec_params->m_info_in.stream_type = UNDEF_AUDIO;
      err = p_in_file->Open(params.input_file, AudioFile::AFM_NO_CONTENT_WRN);

      if (err < 0) {
        vm_debug_trace(-1, VM_STRING("Can't open input file '%s'"),
            params.input_file);
        vm_string_printf(VM_STRING("Can't open input file '%s'"),
            params.input_file);
        err = -2;
        break;

      } else if (err == 0) {
        is_input_wav = 1;
        err = wav_file_in.GetInfo(&info_file_in);

        if (err == 0) {
          if (info_file_in.format_tag == 1) {
            audio_codec_params->m_info_in.stream_type = PCM_AUDIO;
            p_out_file = &file_out;
          } else {
            audio_codec_params->m_info_in.stream_type = UNDEF_AUDIO;
            p_out_file = &wav_file_out;
          }

          audio_codec_params->m_info_in.channel_mask = 0;
          audio_codec_params->m_info_in.sample_frequency =
              info_file_in.sample_rate;
          audio_codec_params->m_info_in.bitPerSample = info_file_in.resolution;
          audio_codec_params->m_info_in.channels =
              info_file_in.channels_number;
          audio_codec_params->m_info_in.bitrate = 0;
          audio_codec_params->m_info_out.bitrate = params.bitrate;
        }
      } else {
        p_in_file->Close();
        p_in_file = &file_in;

        err = p_in_file->Open(params.input_file, AudioFile::AFM_NO_CONTENT_WRN);

        if (err < 0) {
          vm_debug_trace(-1, VM_STRING("Can't open input file '%s'"),
            params.input_file);
          vm_string_printf(VM_STRING("Can't open input file '%s'"),
            params.input_file);
          err = -2;
          break;
        }
      }
    }

    err = p_out_file->Open(params.output_file, AudioFile::AFM_CREATE);

    if (err) {
        vm_debug_trace(-1, __VM_STRING("Can't create output file '%s'"),
            params.output_file);
        vm_string_printf(__VM_STRING("Can't create output file '%s'"),
            params.output_file);
        err = -3;
        break;
    }

    iterator = factory;

    if (false == iterator.Find(params.codec_name)) {
        vm_debug_trace(-1, VM_STRING("The codec '%s'is not found.\n"),
            params.codec_name);
        vm_string_printf(VM_STRING("The codec '%s'is not found.\n"),
            params.codec_name);