avsync.cpp

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

        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
    }

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

    m_MutAccess.Unlock();

    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Start"), VM_STRING("Start,-,1"));
    return umcRes;
}

UMC::Status AVSync::Stop()
{
    Close();
    return UMC::UMC_OK;
}

void AVSync::Close()
{
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,+"));

    m_MutAccess.Lock();

    m_bStopFlag = true;
    m_StepEvent.Set();

    if (m_VideoThread.IsValid()) {
        vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,before wait video_thread"));
        m_VideoThread.Wait();
        vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,after wait video_thread"));
    }

    //Splitter can be stopped only after the video thread has finished
    if (NULL != m_pSplitter)
    {
        m_pSplitter->Stop();
    }

    if (m_SyncThread.IsValid())  {
        vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,before wait sync_thread"));
        m_SyncThread.Wait();
        vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,after wait sync_thread"));
    }
    if (m_AudioThread.IsValid()) {
        vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,before wait audio_thread"));
        m_AudioThread.Wait();
        vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), VM_STRING("Close,after wait audio_thread"));
    }
    if (NULL != m_pVideoRender) {
        delete m_pVideoRender;
        m_pVideoRender = NULL;
    }
    if (NULL != m_pAudioRender) {
        m_pAudioRender->Stop();
        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();

    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Close"), 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()
{
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Step"), VM_STRING("Step,+"));
    UMC::Status umcRes = m_StepEvent.Pulse();
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Step"), VM_STRING("Step,-"));
    return umcRes;
}

UMC::Status AVSync::Resume()
{
    UMC::Status umcRes = UMC::UMC_OK;
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Resume"), 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();
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Resume"), VM_STRING("Resume,-"));
    return umcRes;
}

UMC::Status AVSync::Pause()
{
    UMC::Status umcRes = UMC::UMC_OK;
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Pause"), 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();
    vm_debug_trace_withfunc(VM_DEBUG_FILE, VM_STRING("AVSync::Pause"), 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())
    {
        vm_debug_trace_withfunc(VM_DEBUG_FILE,
                                VM_STRING("AVSync::WaitForStop"),
                                VM_STRING("PlayFileList,before wait sync_thread"));
        m_SyncThread.Wait();
        vm_debug_trace_withfunc(VM_DEBUG_FILE,
                                VM_STRING("AVSync::WaitForStop"),
                                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())
        {
            vm_debug_trace_withfunc(VM_DEBUG_FILE,
                                    VM_STRING("AVSync::WaitForStop"),
                                    VM_STRING("PlayFileList,before wait audio_thread"));
            m_AudioThread.Wait();
            vm_debug_trace_withfunc(VM_DEBUG_FILE,
                                    VM_STRING("AVSync::WaitForStop"),
                                    VM_STRING("PlayFileList,after wait audio_thread"));
        }
    }
}

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

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

void AVSync::GetPosition(Ipp64f& 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(Ipp64f /*dfPos*/)
{

/*    UMC::Status umcRes = UMC::UMC_OK;
    UMC::MediaDataEx videoData;
    UMC::MediaData audioData;
    Ipp32f volume = 0;

    vm_debug_trace(VM_DEBUG_NONE, VM_STRING("Reposition starts\n"));

    m_bStopSyncForReposition = true;
    if (m_AudioThread.IsValid())
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPointAudio.Reset begin\n"));
        m_eventSyncPointAudio.Reset();
        if(m_pAudioRender)
        {
//            m_pAudioRender->PrepareForRePosition(); it seems that it is not needed
            volume = m_pAudioRender->GetVolume();
            m_pAudioRender->SetVolume(0);
        }
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPointAudio.Reset end\n"));
    }
    else
    {
       if(m_SplitterInfo.m_splitter_flags & UMC::AUDIO_SPLITTER)

        {

        }
    }
    if(m_pVideoRender)
        m_pVideoRender->PrepareForRePosition();

    if(m_pSplitter)
        m_pSplitter->PrepareForRePosition();
    else
        return;

    if (m_SyncThread.IsValid())
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPointSync.Reset begin\n"));
        m_eventSyncPointSync.Reset();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPointSync.Reset end\n"));
    }
    if (m_VideoThread.IsValid())
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPointVideo.Reset begin\n"));
        m_eventSyncPointVideo.Reset();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPointVideo.Reset end\n"));
    }
    if (m_SyncThread.IsValid())
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPoint1Sync.Wait begin\n"));
        m_eventSyncPoint1Sync.Wait();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPoint1Sync.Wait end\n"));
    }
    if (m_AudioThread.IsValid())
    {
       //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPoint1Audio.Wait begin\n"));
       m_eventSyncPoint1Audio.Wait();
       //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPoint1Audio.Wait end\n"));
    }
    if (m_VideoThread.IsValid())
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPoint1Video.Wait begin\n"));
        m_eventSyncPoint1Video.Wait();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("SyncPoint1Video.Wait end\n"));
    }
    if (m_pVideoRender)
    {
       // vm_debug_trace(VM_DEBUG_NONE, VM_STRING("m_pVideoRender->Reset begin\n"));
        m_pVideoRender->Reset();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("m_pVideoRender->Reset end\n"));
    }
    if (m_pVideoDecoder)
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("m_pVideoDecoder->Reset begin\n"));
        m_pVideoDecoder->Reset();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("m_pVideoDecoder->Reset end\n"));
    }
    if (m_pAudioRender)
    {
        //vm_debug_trace(VM_DEBUG_NONE, 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(VM_DEBUG_NONE, VM_STRING("m_pAudioRender->Reset end\n"));
    }
    if (m_pDSAudioCodec)
    {
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("m_pDSAudioCodec->Reset begin\n"));
        m_pDSAudioCodec->Reset();
        //vm_debug_trace(VM_DEBUG_NONE, VM_STRING("m_pDSAudioCodec->Reset end\n"));
    }
    m_bStopSyncForReposition = false;

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

        vm_time_sleep(10);

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

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

        Ipp64f videoTime;
        Ipp64f 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_ERR_END_OF_STREAM))
            {
                vm_debug_trace(VM_DEBUG_NONE, VM_STRING("CheckNextVideoData start\n"));
                umcRes = m_pSplitter->GetNextVideoData(&videoData);
                umcRes = m_pSplitter->CheckNextVideoData(&videoData);
                videoTime = videoData.GetTime();
                vm_debug_trace1(VM_DEBUG_NONE, VM_STRING("CheckNextVideoData end = %lf\n"),videoData.GetTime());
                vm_time_sleep(1);
            }

            while(audioTime < 0 && (umcRes != UMC::UMC_ERR_END_OF_STREAM))
            {
                vm_debug_trace(VM_DEBUG_NONE, VM_STRING("CheckNextAudioData start\n"));
                umcRes = m_pSplitter->GetNextAudioData(&audioData);
                umcRes = m_pSplitter->CheckNextAudioData(&audioData);
                audioTime = audioData.GetTime();
                vm_debug_trace1(VM_DEBUG_NONE, VM_STRING("CheckNextAudioData end = %lf\n"),audioData.GetTime());
                vm_time_sleep(1);
            }

            if((videoTime > audioTime) && (REPOSITION_AVSYNC_PRECISION != -1))
            {