main.cpp

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

  // C-channel
          s3d_params->Azimuth = 0;
          s3d_params->Elevation = 0;
          s3d_filter[1]->Init((UMC::BaseCodecParams *) s3d_params);
  // R-channel
          s3d_params->Azimuth = 30;
          s3d_params->Elevation = 0;
          s3d_filter[2]->Init((UMC::BaseCodecParams *) s3d_params);
  // SL-channel
          s3d_params->Azimuth = -30;
          s3d_params->Elevation = 180;
          s3d_filter[3]->Init((UMC::BaseCodecParams *) s3d_params);
  // SR-channel
          s3d_params->Azimuth = 30;
          s3d_params->Elevation = 180;
          s3d_filter[4]->Init((UMC::BaseCodecParams *) s3d_params);
  // LFE-channel
          s3d_params->Azimuth = 0;
          s3d_params->Elevation = 0;
          s3d_filter[5]->Init((UMC::BaseCodecParams *) s3d_params);

  /*
   * render can't play 12 ch. Every audio ch from filter is stereo. for every
   * stereo ch own reneder
   */
          audio_render_params->info.bitPerSample = 16;
          audio_render_params->info.channels = 2;
          audio_render_params->info.sample_frequency =
            audio_codec_params->m_info_out.sample_frequency;
          audio_render_params->info.stream_type = (UMC::AudioStreamType) 1;
          audio_render_params->pModuleContext = &HWNDContext;
  /*
   * if user has multi-ch system
   */
          if(SoundCardSupport_5p1)
          {
            ac_render_params5p1->info.bitPerSample = 16;
            ac_render_params5p1->info.channels = 6;
            ac_render_params5p1->info.sample_frequency =
              audio_codec_params->m_info_out.sample_frequency;
            ac_render_params5p1->info.stream_type = (UMC::AudioStreamType) 1;
            ac_render_params5p1->pModuleContext = &HWNDContext;
          }
  /*
   * if user choice DOLBY DWNMX
   */
          ac_render_paramsStereo->info.bitPerSample = 16;
          ac_render_paramsStereo->info.channels = 2;
          ac_render_paramsStereo->info.sample_frequency =
            audio_codec_params->m_info_out.sample_frequency;
          ac_render_paramsStereo->info.stream_type = (UMC::AudioStreamType) 1;
          ac_render_paramsStereo->pModuleContext = &HWNDContext;

          for (i = 0; i < 6; i++) {
            pMediaReceiverParams =
              DynamicCast < MediaReceiverParams,
              AudioRenderParams > (audio_render_params);

            umcRes = audioRender[i]->Init(pMediaReceiverParams);
            if (umcRes != UMC_OK) {
              printf("problem with Render (init) %s", GetErrString(umcRes));
              return -5;
            }
          }

          if(SoundCardSupport_5p1)
          {
            pMediaReceiverParams =
              DynamicCast < MediaReceiverParams,
              AudioRenderParams > (ac_render_params5p1);
            umcRes = ac_render5p1->Init(pMediaReceiverParams);
            if (umcRes != UMC_OK) {
                printf("problem with Render (ac_render5p1 init) %s", GetErrString(umcRes));
              return -5;
            }
          }

          pMediaReceiverParams =
            DynamicCast < MediaReceiverParams,
            AudioRenderParams > (ac_render_paramsStereo);
          umcRes = ac_renderStereo->Init(pMediaReceiverParams);
          if (umcRes != UMC_OK) {
              printf("problem with Render (ac_renderStereo init) %s", GetErrString(umcRes));
            return -5;
          }
        }
        t_end += (vm_time_get_tick() - t_start);

        if (sts == UMC::UMC_OK) {
          if (flag_s3d) {
            ippsConvert_16s32f((Ipp16s *)pOut->GetDataPointer(), buff_common,
                               (Ipp32s)(pOut->GetDataSize() / 2));
            Ipp32s  len_of_chanel =
              (Ipp32s)(pOut->GetDataSize() /
                    audio_codec_params->m_info_out.channels / 2);
            ippsDeinterleave_32f(buff_common,
                                 audio_codec_params->m_info_out.channels,
                                 len_of_chanel, (Ipp32f **)buff_ch_32f);

            for (i = 0; i < audio_codec_params->m_info_out.channels; i++) {
              pInData->SetBufferPointer((Ipp8u *)buff_ch_32f[i],
                                        len_of_chanel * sizeof(Ipp32f));
              pInData->SetDataSize(len_of_chanel * sizeof(Ipp32f));

              s3d_filter[i]->GetFrame(pInData, pOutData);
              size_out = (Ipp32u)(pOutData->GetDataSize() / 2);
              ippsCopy_16s((Ipp16s *)pOutData->GetDataPointer(), buff_ch_16s[i],
                           size_out);
            }
    /*
     * render
     */
            for (i = 0; i < 6; i++) {
              pInData->SetBufferPointer((Ipp8u *)buff_ch_16s[i],
                                        size_out * sizeof(Ipp16s));
              pInData->SetDataSize(size_out * sizeof(Ipp16s));
              audioRender[i]->SendFrame(pInData);
            }
          } else {
            if ((user_choice == DOLBY_DWNMX) && (FlagAC3))
              ac_renderStereo->SendFrame(pOut);
            else
              ac_render5p1->SendFrame(pOut);
          }
          numFramesToProcess++;

          Ipp64f  start, end;

          pOut->GetTime(start, end);
        }

      } while (sts == UMC::UMC_OK);

    } while (size);

    t_encode_time = (Ipp64f)((Ipp64s) (t_end)) / (Ipp64s) t_freq;
  }

  Ipp32f  dur;

  pAudioCodec->GetInfo(audio_codec_params);

  pAudioCodec->GetDuration(&dur);
  printf("Encoding/decoding time, sec : %f [%06d frames]\n", t_encode_time,
         numFramesToProcess);
  printf("Stream duration, sec        : %f\n", dur);
  t_encode_time /= dur;

  printf("Performance,(sec/sec)       : %f\n", t_encode_time);
  printf
    ("* Multiply the performance by the CPU frequency to convert into MHz\n");

  p_in_file->Close();

// // FREE MEMORY
  if (pOut)
    delete  pOut;

  if (pInData)
    delete  pInData;

  if (pOutData)
    delete  pOutData;

  if (buff_common)
    delete[]buff_common;
  if (buff_32f)
    delete[]buff_32f;
  if (buff_16s)
    delete[]buff_16s;

  if (pMediaBuffer)
    delete  pMediaBuffer;

  pMediaBuffer = NULL;

  if (media_buffer_params)
    delete  media_buffer_params;

  media_buffer_params = NULL;

  if (pAudioCodec)
    delete  pAudioCodec;

  pAudioCodec = NULL;

  if (audio_codec_params)
    delete  audio_codec_params;

  audio_codec_params = NULL;

// FREE 3D POSITION EFFECT
  if (hrtf_data)
    delete  hrtf_data;

  hrtf_data = NULL;

  if (s3d_params)
    delete  s3d_params;

  s3d_params = NULL;

// delete renders and s3d_filter
  for (i = 0; i < 6; i++) {
    if (s3d_filter[i])
      delete  s3d_filter[i];

    s3d_filter[i] = NULL;
    if (audioRender[i])
    {
      audioRender[i]->Close();
      delete  audioRender[i];
    }
  }

  if (ac_render5p1)
  {
    ac_render5p1->Close();
    delete  ac_render5p1;
  }

  if (ac_renderStereo)
  {
    ac_renderStereo->Close();
    delete  ac_renderStereo;
  }

// delete render params
  if (ac_render_params5p1)
    delete  ac_render_params5p1;

  if (ac_render_paramsStereo)
    delete  ac_render_paramsStereo;

  if (audio_render_params)
    delete  audio_render_params;

  return 0;     // OK
}

void LoadPlugins(Factory & factory)
{
// / Register static plug-ins into factory
  factory.InitStatic();

#ifndef STATIC_OBJECTS_ONLY
#if defined (__linux)

  factory.Load("libaac_dec_i.so");
  factory.Load("libaac_dec.so");
  factory.Load("libac3_dec.so");

#else

  factory.Load("aac_dec_i.dll");
  factory.Load("aac_dec.dll");
  factory.Load("ac3_dec.dll");

#endif
#endif
}

USER_MENU ParserUserChoice(Ipp16s my_key, bool * flag_s3d, Ipp32s FlagAC3,
                           UMC::AudioRender * ac_render5p1,
                           UMC::AudioRender * ac_renderStereo,
                           UMC::AudioRender ** audioRender,
                           Sound3dFilterParams * s3d_params,
                           Sound3dFilter ** s3d_filter,
                           bool SoundCardSupport_5p1)
{
  USER_MENU user_choice = UNKNOW;
  Ipp32s  i;

/*
 * USER CHOICE
 */
// ------------------------------------------------
  my_key = GetKeyState(49);     // key '1' HRTF only
  if (my_key & 0x1000) {
    printf("pressdown key <1> \r");
    user_choice = HRTF;
    *flag_s3d = true;

      if( SoundCardSupport_5p1 )
    ac_render5p1->Pause(true);

    ac_renderStereo->Pause(true);

    s3d_params->type_set_param = UMC::ONLY_CTC_OFF;

    for (i = 0; i < 6; i++) {
      audioRender[i]->Pause(false);
      s3d_filter[i]->SetParams((UMC::BaseCodecParams *) s3d_params);
    }
  }

  my_key = GetKeyState(51);     // key '3' Dolby Downmix
  if (my_key & 0x1000) {
    if (FlagAC3) {
      printf("pressdown key <3> \r");
      user_choice = DOLBY_DWNMX;
      *flag_s3d = false;
      ac_render5p1->Pause(true);
      ac_renderStereo->Pause(false);

      for (i = 0; i < 6; i++)
        audioRender[i]->Pause(true);
    } else {
// printf("mode <3> is used by AC3 only\n");
      if( !SoundCardSupport_5p1 )
        return user_choice;

      printf("pressdown key <4> \r");
      user_choice = MULT_5p1;
      *flag_s3d = false;
      ac_render5p1->Pause(false);
      ac_renderStereo->Pause(true);

      for (i = 0; i < 6; i++)
        audioRender[i]->Pause(true);
    }
  }

  my_key = GetKeyState(50);     // key '2' HRTF + CTC
  if (my_key & 0x1000) {
    printf("pressdown key <2> \r");
    user_choice = HRTF_CTC;
    *flag_s3d = true;
    ac_render5p1->Pause(true);
    ac_renderStereo->Pause(true);

    s3d_params->type_set_param = UMC::ONLY_CTC_ON;

    for (i = 0; i < 6; i++) {
      audioRender[i]->Pause(false);
      s3d_filter[i]->SetParams((UMC::BaseCodecParams *) s3d_params);
    }
  }

  if(SoundCardSupport_5p1)
  {
    my_key = GetKeyState(52);     // key '4' realy MULTI-CHANNEL MODE
    if (my_key & 0x1000) {
      printf("pressdown key <4> \r");
      user_choice = MULT_5p1;
      *flag_s3d = false;
      ac_render5p1->Pause(false);
      ac_renderStereo->Pause(true);

      for (i = 0; i < 6; i++) {
        audioRender[i]->Pause(true);
      }
    }
  }
// ---------------------------------------------
  return user_choice;
}

/*
  PARSER COMAND LINE
*/

Ipp32s params_parse_command_line(sProgramParameters * p_param, Ipp32s argc, char *argv[])
{
  Ipp32s  i;

  if (argc < 2)
    return 1;

  for (i = 1; i < argc; i++) {
    if (argv[i][0] == '-') {
      if (argv[i][1] == '-') {
      } else {
// / Program specific command line papameters !
        if (argv[i][1] == 'c' && argv[i][2] == 't') {
          i++;
          strcpy(p_param->codec_name, argv[i]);
        } else if (argv[i][1] == 'b' && argv[i][2] == 'r') {
          i++;
          p_param->bitrate = atoi(argv[i]);
        } else if (argv[i][1] == 'd' && argv[i][2] == 't') {
          i++;
          strcpy(p_param->output_txt, argv[i]);
          p_param->is_text_out = 1;
        } else if (argv[i][1] == 'e') {
          p_param->enumerate = 1;
        }
      }
    } else {
      if (p_param->input_file[0] != 0)
        strcpy(p_param->output_file, argv[i]);
      else
        strcpy(p_param->input_file, argv[i]);
    }
  }

  if (!p_param->output_file[0] && (i < argc)) {
    strncpy(p_param->output_file, p_param->input_file,
            strlen(p_param->input_file) - 3);
    strcat(p_param->output_file, "dat");
  }
  return 0;
}

/* ********************************************************** */
void params_print_usage(void)
{
  printf("Usage:\n");
  printf
    ("virtual_ac_5p1.exe -ct <codec type> <audio-stream(5.1)> <CIPIC HRTF DATABASE> \n");
  printf("-ct - codec type (ac3_dec,aac_dec)\n");
  printf("\n");
}