avsync.cpp

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

    }

    if (UMC::UMC_OK != umcRes)
    {
        Stop();
    }

    m_MutAccess.Unlock();

    LOG(VM_STRING("Start,-,1"));
    return umcRes;
}

UMC::Status
AVSync::Stop()
{
    Close();
    return UMC::UMC_OK;
}
void
AVSync::Close()
{
    LOG(VM_STRING("Close,+"));

    m_MutAccess.Lock();

    m_bStopFlag = true;
    m_StepEvent.Set();

    if (NULL != m_pSplitter)
    {
        m_pSplitter->Stop();
    }

    if (m_VideoThread.IsValid()) {
        LOG(VM_STRING("Close,before wait video_thread"));
        m_VideoThread.Wait();
        LOG(VM_STRING("Close,after wait video_thread"));
    }
    if (m_SyncThread.IsValid())  {
        LOG(VM_STRING("Close,before wait sync_thread"));
        m_SyncThread.Wait();
        LOG(VM_STRING("Close,after wait sync_thread"));
    }
    if (m_AudioThread.IsValid()) {
        LOG(VM_STRING("Close,before wait audio_thread"));
        m_AudioThread.Wait();
        LOG(VM_STRING("Close,after wait audio_thread"));
    }

    if (NULL != m_pVideoRender) {
        delete m_pVideoRender;
        m_pVideoRender = NULL;
    }

    if (NULL != m_pAudioRender) {
        delete m_pAudioRender;
        m_pAudioRender = NULL;
    }

    if ( NULL != m_pVideoDecoder )
    {
        delete m_pVideoDecoder;
        m_pVideoDecoder = NULL;
    }
    if ( NULL != m_pDSAudioCodec )
    {
        delete m_pDSAudioCodec;
        m_pDSAudioCodec = NULL;
    }
    if ( NULL != m_pMediaBuffer )
    {
        delete m_pMediaBuffer;
        m_pMediaBuffer = NULL;
    }
    if ( NULL != m_pAudioDecoder )
    {
        delete m_pAudioDecoder;
        m_pAudioDecoder = NULL;
    }
    if (NULL != m_pSplitter)
    {
        if(!(m_ccParams.pExternalInfo && m_ccParams.pExternalInfo->m_pSplitter))
        {
            delete m_pSplitter;
            m_pSplitter = NULL;
        }
    }

    if (NULL != m_pDataReader)
    {
        if(!(m_ccParams.pExternalInfo && m_ccParams.pExternalInfo->m_pDataReader))
        {
            delete m_pDataReader;
            m_pDataReader = NULL;
        }
    }
    m_MutAccess.Unlock();

    LOG(VM_STRING("Close,-"));
}

UMC::Status
AVSync::GetStat(Stat& rStat)
{
    UMC::Status umcRes = UMC::UMC_OK;
    m_MutAccess.Lock();
    rStat = m_Stat;
    m_MutAccess.Unlock();
    return umcRes;
}

UMC::Status
AVSync::Step()
{
    LOG(VM_STRING("Step,+"));
    UMC::Status umcRes = m_StepEvent.Pulse();
    LOG(VM_STRING("Step,+"));
    return umcRes;
}

UMC::Status
AVSync::Resume()
{
    UMC::Status umcRes = UMC::UMC_OK;
    LOG(VM_STRING("Resume,+"));
    m_MutAccess.Lock();

    if (NULL != m_pAudioRender)
    {   umcRes = m_pAudioRender->Pause(false);  }

    if (UMC::UMC_OK == umcRes)
    {
        m_bPaused = false;
        umcRes = m_StepEvent.Set();
    }

    m_MutAccess.Unlock();
    LOG(VM_STRING("Resume,-"));
    return umcRes;
}

UMC::Status
AVSync::Pause()
{
    UMC::Status umcRes = UMC::UMC_OK;
    LOG(VM_STRING("Pause,+"));
    m_MutAccess.Lock();

    m_bPaused = true;

    if (!m_AudioThread.IsValid())
    {   umcRes = m_StepEvent.Pulse();   }
    else
    {   umcRes = m_pAudioRender->Pause(true);   }

    m_MutAccess.Unlock();
    LOG(VM_STRING("Pause,-"));
    return umcRes;
}

bool
AVSync::IsPlaying()
{
    return m_SyncThread.IsValid() ||
           m_AudioThread.IsValid() ||
           m_VideoThread.IsValid();
}

void
AVSync::WaitForStop()
{
    //always synchronized stream finishing with SyncProc
    if(m_SyncThread.IsValid())
    {
        LOG(VM_STRING("PlayFileList,before wait sync_thread"));
        m_SyncThread.Wait();
        LOG(VM_STRING("PlayFileList,after wait sync_thread"));
    }
    else
    {
        //there is an exception: pure audio files
        //SyncProc is absent in this case
        if(m_AudioThread.IsValid())
        {
            LOG(VM_STRING("PlayFileList,before wait audio_thread"));
            m_AudioThread.Wait();
            LOG(VM_STRING("PlayFileList,after wait audio_thread"));
        }

    }
}

void
AVSync::SetFullScreen(UMC::ModuleContext& ModContext,
                      bool bFoolScreen)
{
    if (NULL != m_pVideoRender)
    {   m_pVideoRender->SetFullScreen(ModContext, bFoolScreen); }
}

vm_sizet
AVSync::GetStreamSize()
{
    vm_sizet stRes = 0;
    if (NULL != m_pDataReader)
    {   stRes = m_pDataReader->GetSize();   }
    return stRes;
}

void
AVSync::GetPosition(double& rdfPos)
{
    rdfPos = 0;
    if (NULL != m_pSplitter)
    {   m_pSplitter->GetPosition(rdfPos);   }
}

void
AVSync::HideSurface()
{
    if (NULL != m_pVideoRender)
    {   m_pVideoRender->HideSurface();  }
}

void
AVSync::ShowSurface()
{
    if (NULL != m_pVideoRender)
    {   m_pVideoRender->ShowSurface();  }
}

void
AVSync::SetPosition(double dfPos)
{
    UMC::Status umcRes = UMC::UMC_OK;
    UMC::MediaDataEx videoData;
    UMC::MediaData  audioData;
    float volume = 0;

    vm_debug_trace(-1, VM_STRING("Reposition starts\n"));

    m_bStopSyncForReposition = true;
    if (m_AudioThread.IsValid())
    {
        //vm_debug_trace(-1, VM_STRING("SyncPointAudio.Reset begin\n"));
        m_eventSyncPointAudio.Reset();
        if(m_pAudioRender)
        {
            m_pAudioRender->Reset();
            volume = m_pAudioRender->GetVolume();
            m_pAudioRender->SetVolume(0);
        }
        //vm_debug_trace(-1, VM_STRING("SyncPointAudio.Reset end\n"));
    }


    if(m_pVideoRender)
        m_pVideoRender->Reset();

    if (m_SyncThread.IsValid())
    {
        //vm_debug_trace(-1, VM_STRING("SyncPointSync.Reset begin\n"));
        m_eventSyncPointSync.Reset();
        //vm_debug_trace(-1, VM_STRING("SyncPointSync.Reset end\n"));
    }

    if (m_VideoThread.IsValid())
    {
        //vm_debug_trace(-1, VM_STRING("SyncPointVideo.Reset begin\n"));
        m_eventSyncPointVideo.Reset();
        //vm_debug_trace(-1, VM_STRING("SyncPointVideo.Reset end\n"));
    }

    if (m_SyncThread.IsValid())
    {
        //vm_debug_trace(-1, VM_STRING("SyncPoint1Sync.Wait begin\n"));
        m_eventSyncPoint1Sync.Wait();
        //vm_debug_trace(-1, VM_STRING("SyncPoint1Sync.Wait end\n"));
    }

    if (m_AudioThread.IsValid())
    {
       //vm_debug_trace(-1, VM_STRING("SyncPoint1Audio.Wait begin\n"));
       m_eventSyncPoint1Audio.Wait();
       //vm_debug_trace(-1, VM_STRING("SyncPoint1Audio.Wait end\n"));
    }

    if (m_VideoThread.IsValid())
    {
        //vm_debug_trace(-1, VM_STRING("SyncPoint1Video.Wait begin\n"));
        m_eventSyncPoint1Video.Wait();
        //vm_debug_trace(-1, VM_STRING("SyncPoint1Video.Wait end\n"));
    }

    if(m_pVideoRender)
    {
       // vm_debug_trace(-1, VM_STRING("m_pVideoRender->Reset begin\n"));
        m_pVideoRender->Reset();
        //vm_debug_trace(-1, VM_STRING("m_pVideoRender->Reset end\n"));
    }

    if(m_pVideoDecoder)
    {
        //vm_debug_trace(-1, VM_STRING("m_pVideoDecoder->Reset begin\n"));
        m_pVideoDecoder->Reset();
        //vm_debug_trace(-1, VM_STRING("m_pVideoDecoder->Reset end\n"));
    }


    if(m_pAudioRender)
    {
        //vm_debug_trace(-1, VM_STRING("m_pAudioRender->Reset begin\n"));
        if (!(m_SplitterInfo.m_splitter_flags & UMC::AUDIO_SPLITTER) && m_bSync)
        {
            delete m_pAudioRender; m_pAudioRender = NULL;
        }
        else
            m_pAudioRender->Reset();
        //vm_debug_trace(-1, VM_STRING("m_pAudioRender->Reset end\n"));
    }

    if(m_pDSAudioCodec)
    {
        //vm_debug_trace(-1, VM_STRING("m_pDSAudioCodec->Reset begin\n"));
        m_pDSAudioCodec->Reset();
        //vm_debug_trace(-1, VM_STRING("m_pDSAudioCodec->Reset end\n"));
    }


    m_bStopSyncForReposition = false;

    if (NULL != m_pSplitter)
    {
        vm_debug_trace(-1, VM_STRING("m_pSplitter->SetPosition started = %lf\n"), dfPos);
        umcRes = m_pSplitter->SetPosition(dfPos);
        vm_debug_trace(-1, VM_STRING("m_pSplitter->SetPosition returned\n"));

        vm_time_sleep(10);

        if(umcRes != UMC::UMC_OK)
        {
            if (m_SyncThread.IsValid())
            {
                vm_debug_trace(-1, VM_STRING("SyncPointSync.Set\n"));
                m_eventSyncPointSync.Set();
            }
            if (m_AudioThread.IsValid())
            {
                vm_debug_trace(-1, VM_STRING("SyncPointAudio.Set\n"));
                m_eventSyncPointAudio.Set();
            }
            if (m_VideoThread.IsValid())
            {
                vm_debug_trace(-1, VM_STRING("SyncPointVideo.Set\n"));
                m_eventSyncPointVideo.Set();
            }
        }

        do
        {
            if(m_SplitterInfo.m_splitter_flags & UMC::VIDEO_SPLITTER)
            {
                //vm_debug_trace(-1, VM_STRING("CheckNextVideoData start\n"));
                umcRes = m_pSplitter->CheckNextVideoData(&videoData);
                //vm_debug_trace(-1, VM_STRING("CheckNextVideoData end = %lf\n"),videoData.GetTime());
                vm_time_sleep(1);
            }
         } while(umcRes == UMC::UMC_WAIT_FOR_REPOSITION &&(umcRes != UMC::UMC_END_OF_STREAM));
        do
        {

               if(m_SplitterInfo.m_splitter_flags & UMC::AUDIO_SPLITTER)
                {
                    //vm_debug_trace(-1, VM_STRING("CheckNextAudioData start\n"));
                    umcRes = m_pSplitter->CheckNextAudioData(&audioData);
                    //vm_debug_trace(-1, VM_STRING("CheckNextAudioData end = %lf\n"),audioData.GetTime());
                    vm_time_sleep(1);
                }
         } while(umcRes == UMC::UMC_WAIT_FOR_REPOSITION &&(umcRes != UMC::UMC_END_OF_STREAM));

        double videoTime;
        double audioTime;

        videoTime = videoData.GetTime();
        audioTime = audioData.GetTime();


        if(m_SplitterInfo.m_splitter_flags & UMC::AUDIO_SPLITTER &&
           m_SplitterInfo.m_splitter_flags & UMC::VIDEO_SPLITTER  )
        {

            videoTime = videoData.GetTime();
            audioTime = audioData.GetTime();

            while(videoTime < 0 && (umcRes != UMC::UMC_END_OF_STREAM))
            {
                vm_debug_trace(-1, VM_STRING("CheckNextVideoData start\n"));
                umcRes = m_pSplitter->GetNextVideoData(&videoData);
                umcRes = m_pSplitter->CheckNextVideoData(&videoData);
                videoTime = videoData.GetTime();