umc_transcoder_con_main.cpp

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

                         t_params.video_stream_type  = UMC::MPEG2_VIDEO;
                         t_params.system_stream_type = UMC::MPEG2_PURE_VIDEO_STREAM;
                         t_params.audio_stream_type  = UMC::UNDEF_AUDIO;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_mpeg4_ps")))
                     {
                         t_params.video_stream_type  = UMC::MPEG4_VIDEO;
                         t_params.system_stream_type = UMC::MPEG2_PROGRAMM_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_mpeg4_ts")))
                     {
                         t_params.video_stream_type  = UMC::MPEG4_VIDEO;
                         t_params.system_stream_type = UMC::MPEG2_TRANSPORT_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_mpeg4_pv")))
                     {
                         t_params.video_stream_type  = UMC::MPEG4_VIDEO;
                         t_params.system_stream_type = UMC::MPEG4_PURE_VIDEO_STREAM;
                         t_params.audio_stream_type  = UMC::UNDEF_AUDIO;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_mpeg4_at")))
                     {
                         t_params.video_stream_type  = UMC::MPEG4_VIDEO;
                         t_params.system_stream_type = UMC::MP4_ATOM_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_h_264_pv")))
                     {
                         t_params.video_stream_type  = UMC::H264_VIDEO;
                         t_params.system_stream_type = UMC::H264_PURE_VIDEO_STREAM;
                         t_params.audio_stream_type  = UMC::UNDEF_AUDIO;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_h_264_ts")))
                     {
                         t_params.video_stream_type  = UMC::H264_VIDEO;
                         t_params.system_stream_type = UMC::MPEG2_TRANSPORT_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_h_264_ps")))
                     {
                         t_params.video_stream_type  = UMC::H264_VIDEO;
                         t_params.system_stream_type = UMC::MPEG2_PROGRAMM_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_h_264_at")))
                     {
                         t_params.video_stream_type  = UMC::H264_VIDEO;
                         t_params.system_stream_type = UMC::MP4_ATOM_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_non")))
                     {
                         t_params.video_stream_type  = UMC::UNDEF_VIDEO;
                         t_params.system_stream_type = UMC::MPEGx_PURE_AUDIO_STREAM;
                     }
                     else if(0 == vm_string_strcmp(argv[i], VM_STRING("-vf_vc1_pv")))
                     {
                         t_params.video_stream_type  = UMC::VC1_VIDEO;
                         t_params.system_stream_type = UMC::VC1_PURE_VIDEO_STREAM;
                     }
                     else
                     {
                          vm_string_printf(__VM_STRING("Unknown option: %s\n"), argv[i]);
                          umcRes = UMC::UMC_ERR_FAILED;
                     }
                    break;
                    default:
                        vm_string_printf(__VM_STRING("Unknown option (d): %s\n"), argv[i]);
                        PrintHelp(argv[0]);
                        return UMC::UMC_ERR_FAILED;
                    break;
                }
        }
        else
        {
            if (NULL == t_params.input_video_filename)
                t_params.input_video_filename = argv[i];
            else
            {
                vm_string_printf(__VM_STRING("Too many file names in command line - %s and %s\n"),
                                 t_params.input_video_filename, argv[i]);
                PrintHelp(argv[0]);
                return UMC::UMC_ERR_FAILED;
            }
         }
        i++;
     }

     if(!t_params.input_video_filename)
     {
         PrintHelp(argv[0]);
         umcRes = UMC::UMC_ERR_FAILED;
     }
     if(!t_params.output_filename)
         t_params.output_filename = "output.mpg";

     if (!t_params.CheckParams())
     {
        PrintHelp(argv[0]);
        return UMC::UMC_ERR_FAILED;
     }
     return UMC::UMC_OK;

}

void PrintStreamInfo(UMC::VideoStreamInfo VideoInfo, UMC::AudioStreamInfo AudioInfo)
{
    switch(VideoInfo.stream_type)
    {
        case UMC::MPEG1_VIDEO:           vm_string_printf("MPEG1 video input\n"); break;
        case UMC::MPEG2_VIDEO:           vm_string_printf("MPEG2 video input\n"); break;
        case UMC::MPEG4_VIDEO:           vm_string_printf("MPEG4 video input\n"); break;
        case UMC::H264_VIDEO:            vm_string_printf("H.264 video input\n"); break;
        case UMC::DIGITAL_VIDEO_SD:      vm_string_printf("DV video input\n");    break;
        case UMC::UNCOMPRESSED_VIDEO:    vm_string_printf("Camera input\n");      break;
    }
    vm_string_printf("Video bitrate   = %d bps\n",VideoInfo.bitrate);
    vm_string_printf("Video framerate = %f fps\n",VideoInfo.framerate);
    vm_string_printf("Video width     = %d pel\n",VideoInfo.clip_info.width);
    vm_string_printf("Video height    = %d pel\n",VideoInfo.clip_info.height);

    switch(AudioInfo.stream_type)
    {
        case UMC::AC3_AUDIO:    vm_string_printf("AC3 audio input\n");             break;
        case UMC::AAC_AUDIO:    vm_string_printf("AAC audio input\n");             break;
        case UMC::PCM_AUDIO:    vm_string_printf("PCM audio input\n");             break;
        case UMC::MP1L1_AUDIO:  vm_string_printf("MPEG1 Layer I audio input\n");   break;
        case UMC::MP1L2_AUDIO:  vm_string_printf("MPEG1 Layer II audio input\n");  break;
        case UMC::MP1L3_AUDIO:  vm_string_printf("MPEG1 Layer III audio input\n"); break;
    }

    vm_string_printf("Audio bitPerSample     = %d \n",AudioInfo.bitPerSample);
    vm_string_printf("Audio bitrate          = %d bps\n",AudioInfo.bitrate);
    vm_string_printf("Audio channels         = %d \n",AudioInfo.channels);
    vm_string_printf("Audio sample_frequency = %d Hz\n\n",AudioInfo.sample_frequency);
}

int main(Ipp32u argc, vm_char* argv[])
{
    // Check bad params
   if ((argc == 1) || (argv[1] == NULL))
    {
         vm_string_printf("Please, enter correct parameters!\n");
         PrintHelp(argv[0]);
         return 0;
    }

    TranscoderParams transcoder_params;

    // parsing command line args
    UMC::Status umcRes = ParseCommandLineArgs(argc, argv, transcoder_params);

    if (umcRes != UMC::UMC_OK)
    {
        vm_debug_message(VM_STRING("failed to parse command line args\n"));
        return 0;
    }

    ippStaticInit();

    UMC::VideoStreamInfo VideoInfo;
    UMC::AudioStreamInfo AudioInfo;

    Transcoder* pTranscoder = new Transcoder;
    if (pTranscoder->Init(transcoder_params) != UMC::UMC_OK)
    {
        vm_debug_message(VM_STRING("failed to initialize transcoder\n"));
        delete pTranscoder;
        return 1;
    }

    if (UMC::UMC_OK != pTranscoder->GetStreamInfo(VideoInfo, AudioInfo))
    {
        vm_debug_message(VM_STRING("failed to get source stream(s) info\n"));
        delete pTranscoder;
        return 1;
    }

    PrintStreamInfo(VideoInfo, AudioInfo);

    if (pTranscoder->Run() != UMC::UMC_OK)
    {
        vm_debug_message(VM_STRING("failed to run transcoder\n"));
        delete pTranscoder;
        return 1;
    }

    vm_string_printf("press space to stop\n");

    // create thread to get progress from transcoder and print it
    vm_thread g_stat_thread;

    vm_thread_set_invalid(&g_stat_thread);
    stop_stat_flag = true;
    vm_thread_create(&g_stat_thread, StatThreadFunc, (void*)pTranscoder);
    if(!vm_thread_is_valid(&g_stat_thread))
         vm_string_printf("Can't create output statistic thread\n");

    Ipp32u space = 0;

    while ((-1.0 != pTranscoder->GetProgress()) && (space != ' '))
    {
         vm_time_sleep(500);
#if defined ( WIN32 ) || defined ( WIN64 ) || defined (_WIN32)
         if (kbhit())
              space = getch();
#endif
    }

    stop_stat_flag = false;
    vm_thread_wait(&g_stat_thread);

    bool errors = (UMC::UMC_OK != pTranscoder->GetErrorStatus());
    vm_string_printf("Transcoding complited %s errors\n", errors ? "with" : "without");
    vm_debug_message(VM_STRING("transcoding completed %s errors\n"), errors ? "with" : "without");

    delete pTranscoder;
    return errors;
}