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

#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
#include "umc_mp4_mux.h"
#include "umc_file_writer.h"

#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"
#include "ippcore.h"

using namespace UMC;

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

  Ipp32s bUsePluginDll;
};

void LoadPlugins(Factory & factory);

int main(Ipp32s 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;

  Ipp32s                is_input_wav = 0;
  Ipp32s                err;
  Ipp32s                isSplitterRequired = 0;
  Ipp32s                acp_allocated = 0;

  vm_tick               t_freq, t_start, t_end;
  Ipp64f                t_encode_time;
  Ipp32s                numFramesToProcess = 0;

  MediaData*            pOut = NULL;

  MediaData             inMediaBuffer;
  size_t                size = 0;

  Status                sts;

  AudioCodec*           pAudioCodec;
  MediaBuffer*          pMediaBuffer;
  DualThreadedCodec     dual_treaded_codec;
  MP4Muxer*             pMP4Muxer;

  MuxerParams*          pMP4MuxerParams;
  AudioCodecParams*     audio_codec_params;
  MediaBufferParams *   media_buffer_params;
  DualThreadCodecParams codec_init;

  FileWriter*           pFileWriter;
  FileWriterParams*     pFileWriterParams;

  TrackParams*          pMP4TrackParams;

  sProgramParameters    params;
  Factory               factory;

  MediaData             in_data;

  Factory::Iterator < AudioCodecObject > iterator;

  // Initialization
  pAudioCodec  = NULL;
  pMediaBuffer = NULL;
  pMP4Muxer = NULL;
  pFileWriter = NULL;
  audio_codec_params  = NULL;
  media_buffer_params = NULL;
  pMP4MuxerParams = NULL;
  pFileWriterParams = NULL;
  pMP4TrackParams = NULL;

  LoadPlugins(factory);

  if (argc < 2) {
    params_print_usage(argv[0]);
    return -1;
  }

  params_fill_by_default(&params);
  if (params_parse_command_line(&params, argc, argv) < 0) {
    return -1;
  }

  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 if ((!vm_string_strncmp(params.codec_name, VM_STRING("aac_dec"), 7)) ||
            (!vm_string_strncmp(params.codec_name, VM_STRING("aac_dec_i"), 9))) {
         audio_codec_params = DynamicCast<AudioCodecParams>(&params.aacdec_params);
         //audio_codec_params = new UMC::AudioCodecParams;
  } else if ((!vm_string_strncmp(params.codec_name, VM_STRING("mp3_enc"), 7)) ||
            (!vm_string_strncmp(params.codec_name, VM_STRING("mp3_enc_i"), 9))) {
         audio_codec_params = DynamicCast<AudioCodecParams>(&params.mp3enc_params);
         //audio_codec_params = new UMC::AudioCodecParams;
  } else if ((!vm_string_strncmp(params.codec_name, VM_STRING("mp3_dec"), 7)) ||
            (!vm_string_strncmp(params.codec_name, VM_STRING("mp3_dec_i"), 9))) {
         audio_codec_params = DynamicCast<AudioCodecParams>(&params.mp3dec_params);
         //audio_codec_params = new UMC::AudioCodecParams;
  } else {
        audio_codec_params = new AudioCodecParams;
        acp_allocated = 1;
  }

  if (NULL == audio_codec_params) {
     vm_string_printf(VM_STRING("Memory allocation error\n"));
     return -1;
  }

  SplitterParams   splInitParams;
  SplitterInfo     *spl_info;
  FileReaderParams frInitParams;

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

  Status umcRes = UMC_OK;
  Ipp32u trNumber = 0;

  while (1) {
    // Init FileReader
    pStream = new 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_OK) {
      vm_string_printf(VM_STRING("Can't open input file: %s\n"), params.input_file);
      err = -1;
      break;
    }

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

    if (type_splitter == MP4_ATOM_STREAM) {
#ifdef UMC_ENABLE_MP4_SPLITTER
      spl = new 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;
      };

      // Parameters of splitter
      splInitParams.m_lFlags      = AUDIO_SPLITTER;
      splInitParams.m_pDataReader = pStream;

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

      spl->Run();

      // Get info about a mp4 file
      spl->GetInfo(&spl_info);
      for (trNumber = 0; trNumber < spl_info->m_nOfTracks; trNumber++) {
        if ((spl_info->m_ppTrackInfo[trNumber]->m_isSelected) &&
          (spl_info->m_ppTrackInfo[trNumber]->m_Type & TRACK_ANY_AUDIO)) {
          break;
        }
      }
      if (trNumber == spl_info->m_nOfTracks) {
        vm_string_printf(VM_STRING("Audio tracks are absent in input files\n\n"));
        err = -7;
        break;
      }

      audio_codec_params->m_info_in = *((AudioStreamInfo *)(spl_info->m_ppTrackInfo[trNumber]->m_pStreamInfo));
      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_trace1(VM_DEBUG_ALL, 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;
          err = 0;
          switch(params.channel_conf) {
            case 1:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_CENTER;
              break;
            case 2:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT;
              break;
            case 3:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_FRONT_CENTER;
              break;
            case 4:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_BACK_CENTER;
              break;
            case 5:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_FRONT_CENTER | CHANNEL_BACK_CENTER;
              break;
            case 6:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT;
              break;
            case 7:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_FRONT_CENTER |
                CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT;
              break;
            case 13:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_FRONT_CENTER |
                CHANNEL_LOW_FREQUENCY;
              break;
            case 14:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_BACK_CENTER |
                CHANNEL_LOW_FREQUENCY;
              break;
            case 15:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_FRONT_CENTER |
                CHANNEL_BACK_CENTER | CHANNEL_LOW_FREQUENCY;
              break;
            case 16:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_BACK_LEFT |
                CHANNEL_BACK_RIGHT | CHANNEL_LOW_FREQUENCY;
              break;
            case 17:
              audio_codec_params->m_info_in.channel_mask =
                CHANNEL_FRONT_LEFT | CHANNEL_FRONT_RIGHT | CHANNEL_FRONT_CENTER |
                CHANNEL_BACK_LEFT | CHANNEL_BACK_RIGHT | CHANNEL_LOW_FREQUENCY;
              break;
            case 0:
              break;
            default:
              err = -6;
              vm_string_printf(__VM_STRING("Unsupported channel configuration '%d'"),
                params.channel_conf);
          }
          if (err)
            break;
          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 * 1000;
        }
      } 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_trace1(VM_DEBUG_ALL, 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;
        }
      }
    }

    iterator = factory;

    if (false == iterator.Find(params.codec_name)) {
        vm_debug_trace1(VM_DEBUG_ALL, 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);
        err = -4;
        break;
    }

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

    if (pAudioCodec == NULL) {
        vm_debug_trace1(VM_DEBUG_ALL, __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;