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

#include "avsync.h"
#include <math.h>

#include "codec_pipeline.h"
#include "umc_log.h"
#include "umc_media_data_ex.h"
#include "void_audio_render.h"
#include "umc_module_context.h"
#include "umc_audio_codec.h"


#if !defined(ARM) && !defined(_ARM_)
#define TASK_SWITCH()   vm_time_sleep(0);
#else
#define TASK_SWITCH()
#endif

#undef CLASSNAME
#define CLASSNAME VM_STRING("AVSync")

#define REPOSITION_AVSYNC_PRECISION 0.99
AVSync::CommonCtl::CommonCtl():
    cformat(UMC::NONE),                     // YUV color format
    ulReduceCoeff(UMC::FLAG_CCNV_NONE),     // Reduce coefficient
    ulSplitterFlags(UMC::UNDEF_SPLITTER),   // Splitter Flags
    ulVideoDecoderFlags(UMC::FLAG_VDEC_NONE),                 // Video Decoder Flags
    ulAudioDecoderFlags(0),                 // Audio Decoder Flags
    ulVideoRenderFlags(0),                  // Video Render Flags
    ulAudioRenderFlags(0),                  // Audio Render Flags
    pRenContext(NULL),                      // Module context (HWND or some other)
    pReadContext(NULL),                     // Module context (local or remote)
    lInterpolation(UMC::FLAG_CCNV_NONE),         // Interpolation Flags
    uiPrefVideoRender(UMC::DEF_VIDEO_RENDER),    // Prefered video render
    uiPrefDataReader(DEF_DATA_READER),      // Prefered data reader
    lPostPcoc(0),                           // Post Processing Flags
    pExternalInfo(NULL),
    terminate(false),                       // terminate the program after playback
    performance(false),                     // Performance statistic
    repeat(false),                          // repeatedly playback
    fullscr(false),                         // turn on full screen
    stick(true),                            // stick to the window size
    debug(true),                            // enable step & fast forward, sound disabled
    step(false),                            // enable step & fast forward, sound disabled
    bSync(true),                            //  Play synchronously even if no sound
    uiLimitVideoDecodeThreads(1),
    uiSelectedVideoID(0),                   //zero is default value to select any video stream
    uiSelectedAudioID(0)                   //zero is default value to select any audio stream
{}

AVSync::AVSync():
    m_pDataReader(NULL),
    m_pSplitter(NULL),
    m_pAudioDecoder(NULL),
    m_pDSAudioCodec(NULL),
    m_pMediaBuffer(NULL),
    m_pAudioRender(NULL),
    m_pVideoDecoder(NULL),
    m_pVideoRender(NULL),
    m_bStopFlag(false),
    m_bAudioPlaying(false),
    m_bVideoPlaying(false),
    m_bPaused(false),
    m_bSync(false),
    m_dfFrameRate(1)

{
    LOG(VM_STRING("AVSync,+"));
    m_DecodedFrameSize.width = 0;
    m_DecodedFrameSize.height = 0;
    m_lliFreq = vm_time_get_frequency();
    m_cFormat = UMC::YV12;
    LOG(VM_STRING("AVSync,-"));
}

UMC::Status
AVSync::Init(CommonCtl& rControlParams)
{
    UMC::Status umcRes = UMC::UMC_OK;
    UMC::MediaDataEx FirstFrameV;
    UMC::MediaData   FirstFrameA;
    ExternalInfo* pExtInf = rControlParams.pExternalInfo;

    LOG(VM_STRING("Init,+"));

    m_MutAccess.Lock();

    m_bStopSyncForReposition = false;
    m_ccParams = rControlParams;

    m_eventSyncPointSync.Init(1, 1);
    m_eventSyncPointVideo.Init(1, 1);
    m_eventSyncPointAudio.Init(1, 1);
    m_eventSyncPoint1Sync.Init(1, 0);
    m_eventSyncPoint1Video.Init(1, 0);
    m_eventSyncPoint1Audio.Init(1, 0);

    m_cFormat = rControlParams.cformat;

    if (UMC::UMC_OK == umcRes)
    {
        if(pExtInf && pExtInf->m_pDataReader)
        {
            m_pDataReader = pExtInf->m_pDataReader;
        }
        else
        {
            umcRes = CodecPipeline::SelectDataReader(
                                       *rControlParams.pReadContext,
                                       m_pDataReader,
                                       rControlParams.uiPrefDataReader);
        }
    }

    if (UMC::UMC_OK == umcRes)
    {
        if(pExtInf && pExtInf->m_pSplitter)
        {
            m_pSplitter = pExtInf->m_pSplitter;
        }
        else
        {
            umcRes = CodecPipeline::SelectSplitter(m_pDataReader,
                                                  rControlParams.ulSplitterFlags,
                                                  m_pSplitter,
                                                  FirstFrameV,
                                                  rControlParams.uiSelectedVideoID,
                                                  rControlParams.uiSelectedAudioID);
        }
    }

    if (UMC::UMC_OK == umcRes)
    {
        umcRes = m_pSplitter->GetInfo(&m_SplitterInfo);

        if (UMC::UMC_OK != umcRes)
        {
            vm_debug_msg(-1, VM_STRING("Failed to get splitter info\n"));
        }
    }

    if (UMC::UMC_OK == umcRes &&
        UMC::UNDEF_AUDIO != m_SplitterInfo.m_audio_info.stream_type)
    {
        // Get splitter some time to read out at least one audio frame
        vm_time_sleep(0);

        if (UMC::UMC_OK == umcRes &&
            UMC::PCM_AUDIO != m_SplitterInfo.m_audio_info.stream_type)
        {    umcRes = m_pSplitter->GetNextAudioData(&FirstFrameA);    }

        if (UMC::UMC_OK == umcRes)
        {
            umcRes = CodecPipeline::SelectDTAudioDecoder(
                                                    m_SplitterInfo.m_audio_info,
                                                    m_pAudioDecoder,
                                                    m_pDSAudioCodec,
                                                    m_pMediaBuffer,
                                                    &FirstFrameA);
        }

        if (UMC::UMC_OK == umcRes &&
            UMC::UNDEF_AUDIO != m_SplitterInfo.m_audio_info.stream_type)
        {
            if (UMC::FLAG_AREN_VOID & rControlParams.ulAudioRenderFlags)
            {
                rControlParams.uiPrefAudioRender = UMC::NULL_AUDIO_RENDER;
            }
            umcRes = CodecPipeline::SelectAudioRender(
                                                m_SplitterInfo.m_audio_info,
                                                *rControlParams.pRenContext,
                                                m_pAudioRender,
                                                rControlParams.uiPrefAudioRender);
        }
        else if (UMC::UMC_BAD_FORMAT == umcRes)
        {
            m_SplitterInfo.m_splitter_flags &= ~UMC::AUDIO_SPLITTER;
            umcRes = UMC::UMC_OK;
        }
    }

    if (UMC::UMC_OK == umcRes &&
        UMC::UNDEF_VIDEO == m_SplitterInfo.m_video_info.stream_type )
    {
        m_SplitterInfo.m_splitter_flags &= ~UMC::VIDEO_SPLITTER;
    }

    if (UMC::UMC_OK == umcRes &&
        m_SplitterInfo.m_splitter_flags & UMC::VIDEO_SPLITTER)
    {
        umcRes = CodecPipeline::SelectVideoDecoder(m_SplitterInfo.m_video_info,
                                     FirstFrameV,
                                     rControlParams.cformat,
                                     rControlParams.ulReduceCoeff,
                                     rControlParams.lInterpolation,
                                     rControlParams.lPostPcoc,
                                     rControlParams.uiLimitVideoDecodeThreads,
                                     rControlParams.ulVideoDecoderFlags,
                                     m_ColorConverter,
                                     m_pVideoDecoder);

        if (UMC::UMC_OK == umcRes)
        {
            if((m_SplitterInfo.m_video_info.stream_type & UMC::H264_VIDEO)/* &&
                (m_SplitterInfo.m_system_info.stream_type & UMC::AVI_STREAM)*/)
            {
                m_DecodedFrameSize = m_SplitterInfo.m_video_info.clip_info;

                switch(rControlParams.ulReduceCoeff)
                {
                case UMC::FLAG_CCNV_NONE:
                case UMC::FLAG_CCNV_CONVERT:
                    break;
                case UMC::FLAG_CCNV_RESIZE_2S:
                    m_DecodedFrameSize.width  /= 2;
                    m_DecodedFrameSize.height /= 2;
                    break;
                case UMC::FLAG_CCNV_RESIZE_4S:
                    m_DecodedFrameSize.width  /= 4;
                    m_DecodedFrameSize.height /= 4;
                    break;
                case UMC::FLAG_CCNV_RESIZE_8S:
                    m_DecodedFrameSize.width  /= 8;
                    m_DecodedFrameSize.height /= 8;
                    break;
                }

            }
            else
            {
                UMC::VideoDecoderParams vParams;
                umcRes = m_pVideoDecoder->GetInfo(&vParams);
                if(!(int)m_SplitterInfo.m_video_info.framerate)m_SplitterInfo.m_video_info.framerate = vParams.info.framerate;
                if(!m_SplitterInfo.m_video_info.clip_info.width)m_SplitterInfo.m_video_info.clip_info.width = vParams.info.clip_info.width;
                if(!m_SplitterInfo.m_video_info.clip_info.height)m_SplitterInfo.m_video_info.clip_info.height = vParams.info.clip_info.height;
                m_DecodedFrameSize = vParams.info.clip_info;
            }
        }

        if (UMC::UMC_OK == umcRes)
        {

            if(pExtInf && pExtInf->m_pVideoRender)
            {
                m_pVideoRender = pExtInf->m_pVideoRender;
            }
            else
            {
                if (UMC::DEF_VIDEO_RENDER == rControlParams.uiPrefVideoRender)
                {
                    rControlParams.uiPrefVideoRender =
                #if defined(USE_FW_RENDERER)
                        UMC::FW_VIDEO_RENDERER;
                #elif defined(USE_NULL_RENDERER)
                        UMC::NULL_VIDEO_RENDERER;
                #elif defined(_WIN32_WINNT)
                        UMC::BLT_VIDEO_RENDER;
                #else
                        UMC::DEF_VIDEO_RENDER;
                #endif
                }
                umcRes = CodecPipeline::SelectVideoRender(*rControlParams.pRenContext,
                                                         m_DecodedFrameSize,
                                                         rControlParams.rectDisp,
                                                         rControlParams.rectDisp,
                                                         rControlParams.cformat,
                                                         rControlParams.ulVideoRenderFlags,
                                                         m_pVideoRender,
                                                         rControlParams.uiPrefVideoRender);
            }

            if (UMC::UMC_OK != umcRes)
            {
                vm_message(VM_STRING("Failed to intialize video render\n"));
            }
        }
        if (UMC::UMC_OK == umcRes)
        {   umcRes = m_StepEvent.Init(1,1); }

        if (UMC::UMC_OK == umcRes &&
            m_SplitterInfo.m_splitter_flags & UMC::VIDEO_SPLITTER)
        {
            if(rControlParams.step)
                umcRes = m_StepEvent.Reset();
            else
                umcRes = m_StepEvent.Set();

        }


        if (UMC::UMC_OK == umcRes)
        {
            m_bSync = rControlParams.bSync;
            m_dfFrameRate = m_SplitterInfo.m_video_info.framerate;
            m_Stat.Reset();
            m_bStopFlag = false;
            m_Stat.dfFrameRate = m_dfFrameRate;
            m_Stat.dfDuration =
                m_SplitterInfo.m_video_info.duration
                     < m_SplitterInfo.m_audio_info.duration?
                                 m_SplitterInfo.m_audio_info.duration:
                                             m_SplitterInfo.m_video_info.duration;
        }
    }

    if (UMC::UMC_OK == umcRes)
    {
        vm_string_printf(VM_STRING("\n"));
        vm_string_printf(VM_STRING("Stream Type  :\t\t%s\n"), UMC::GetStreamTypeString(m_SplitterInfo.m_system_info.stream_type));
        vm_string_printf(VM_STRING("Video Info   :\n"));
        vm_string_printf(VM_STRING("-Video Type  :\t\t%s\n"), UMC::GetVideoTypeString((UMC::VideoStreamType)m_SplitterInfo.m_video_info.stream_type));
        vm_string_printf(VM_STRING("-Resolution  :\t\t%dx%d\n"), m_SplitterInfo.m_video_info.clip_info.width,m_SplitterInfo.m_video_info.clip_info.height);
        vm_string_printf(VM_STRING("-Frame Rate  :\t\t%.2lf\n"), m_SplitterInfo.m_video_info.framerate);
        vm_string_printf(VM_STRING("Audio Info   :\n"));
        vm_string_printf(VM_STRING("-Audio Type  :\t\t%s\n"), UMC::GetAudioTypeString((UMC::AudioStreamType)m_SplitterInfo.m_audio_info.stream_type));
        vm_string_printf(VM_STRING("-S.Frequency :\t\t%d\n"), m_SplitterInfo.m_audio_info.sample_frequency);
        vm_string_printf(VM_STRING("-Num.Channel :\t\t%d\n"), m_SplitterInfo.m_audio_info.channels);
        vm_string_printf(VM_STRING("-BitPerSample:\t\t%d\n"), m_SplitterInfo.m_audio_info.bitPerSample);
        vm_string_printf(VM_STRING("\n"));
    }

    m_MutAccess.Unlock();

    LOG(VM_STRING("Init,-"));

    return umcRes;
}


UMC::Status
AVSync::Start()
{
    UMC::Status umcRes = UMC::UMC_OK;

    LOG(VM_STRING("Start,+"));

    m_MutAccess.Lock();

    m_bStopFlag = false;
    m_bAudioPlaying = false;
    m_bVideoPlaying = false;
    m_Stat.Reset();


    if (UMC::UMC_OK == umcRes &&
        m_SplitterInfo.m_splitter_flags & UMC::VIDEO_SPLITTER)
    {
        assert(NULL != m_pVideoRender);
        vm_debug_trace(4, VM_STRING("Start: VideoProc start:\n"));
        umcRes = m_VideoThread.Create(VideoThreadProc,
                                      static_cast<AVSync*>(this));
    }

    if (UMC::UMC_OK == umcRes &&
        m_SplitterInfo.m_splitter_flags & UMC::AUDIO_SPLITTER)
    {
        assert(NULL != m_pAudioRender);
        assert(m_SplitterInfo.m_audio_info.stream_type != UMC::UNDEF_AUDIO);
        vm_debug_trace(4, VM_STRING("Start: AudioThread start:\n"));
        umcRes = m_AudioThread.Create(AudioThreadProc,
                                      static_cast<AVSync*>(this));
    }

    if (UMC::UMC_OK == umcRes &&
        (NULL != m_pVideoRender))
//        (NULL != m_pVideoRender || NULL != m_pAudioRender))
    {
        vm_debug_trace(4, VM_STRING("Start: SyncThread start\n"));
        umcRes = m_SyncThread.Create(SyncThreadProc,
                                     static_cast<AVSync*>(this));
    }

    if (UMC::UMC_OK == umcRes && NULL != m_pVideoRender)
    {
        vm_debug_trace(4, VM_STRING("Start: Video Render ShowSurface:\n"));
        m_pVideoRender->ShowSurface();
    }

    if (UMC::UMC_OK == umcRes)
    {
        vm_time_sleep(1);

#if defined (ARM) || defined (_ARM_)
        m_SyncThread.SetPriority(VM_THREAD_PRIORITY_NORMAL);
        m_AudioThread.SetPriority(VM_THREAD_PRIORITY_NORMAL);
        m_VideoThread.SetPriority(VM_THREAD_PRIORITY_NORMAL);
#else
        m_SyncThread.SetPriority(VM_THREAD_PRIORITY_HIGHEST);
        //m_AudioThread.SetPriority(VM_THREAD_PRIORITY_HIGHEST);
        m_AudioThread.SetPriority(VM_THREAD_PRIORITY_HIGH);
        m_VideoThread.SetPriority(VM_THREAD_PRIORITY_NORMAL);
#endif