umc_mpeg2_spl_base.cpp

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

            m_systemStreamInfo.stream_type               = MPEG2_PURE_AUDIO_STREAM;
            m_pESArray[0].m_audioStreamInfo.stream_type  = AAC_AUDIO;
            m_MPEGASyncWord                                 = 0x0000fff8;

        } else {
            AudioStreamType mpeg_type[] = {MPEG2_AUDIO, MPEG1_AUDIO};

            m_systemStreamInfo.stream_type = MPEG1_PURE_AUDIO_STREAM;
            m_pESArray[0].m_audioStreamInfo.stream_type  =
                            (AudioStreamType) (mpeg_type[id] | (1<<((4-la)+3)));
            m_MPEGASyncWord                       = 0x0000fffa;

            m_pESArray[0].m_audioStreamInfo.sample_frequency   = MPEGAFequency[id][fr];
            m_pESArray[0].m_audioStreamInfo.channels           = MPEGAChannels[md];
            m_pESArray[0].m_audioStreamInfo.bitPerSample       = 16;
            m_pESArray[0].m_audioStreamInfo.bitrate               = MPEGABitrate[id][la][br];

        }

        m_splitter_flags            &= ~VIDEO_SPLITTER;
        m_splitter_flags            |= AUDIO_SPLITTER;
        m_bIgnoreVideo               = true;
        m_inESCount                  = 1;

    }
    //audio stream, AC3
    else if((code2 & 0xffff0000) == AC3_SYNC_WORD)
    {
        unsigned char aux_byte;

        m_splitter_flags            &= ~VIDEO_SPLITTER;
        m_splitter_flags            |= AUDIO_SPLITTER;
        m_bIgnoreVideo                       = true;
        m_systemStreamInfo.stream_type  = MPEG2_PURE_AUDIO_STREAM;
        m_pESArray[0].m_audioStreamInfo.stream_type   = AC3_AUDIO;

        m_pDataReader->CheckByte(&aux_byte, 4);

        int fscod                = (aux_byte & 0xc0)>> 6;
        int frmsizecod            = (aux_byte & 0x3f);

        m_pESArray[0].m_audioStreamInfo.sample_frequency = AC3Fequency[fscod];
        m_pESArray[0].m_audioStreamInfo.channels         = 2;
        m_pESArray[0].m_audioStreamInfo.bitPerSample     = 16;
        m_pESArray[0].m_audioStreamInfo.bitrate             = AC3FrameSize[frmsizecod].bit_rate;
        m_inESCount                                      = 1;

    }
    //overload this function to check other formats
    //if operation was successful next basic field must be filled:
    //m_sSplInfo.m_splitter_flags;
    //m_sSplInfo.m_splitter_flags;
    //m_bIgnoreVideo;
    //m_sSplInfo.m_system_info.stream_type;
    //m_sSplInfo.m_audio_info.stream_type;

    //by default it returns not UMC_OK and nothing does

    else if(UMC_OK == CheckMoreFormats())
    {
        return UMC_OK;

    }
    //don't have more idea
    else
    {
        return UMC_BAD_STREAM;
    }

    return UMC_OK;
}


Status MPEG2SplitterBase::CheckMoreFormats()
{
    unsigned char byte_code1, byte_code2;

    Status umcSts = m_pDataReader->CheckByte(&byte_code1, 4);
    if(UMC_OK != umcSts) return UMC_NOT_INITIALIZED;

    umcSts = m_pDataReader->CheckByte(&byte_code2, 196);
    if(UMC_OK != umcSts) return UMC_NOT_INITIALIZED;

    if((byte_code1 == 0x47) && (byte_code2 == 0x47))
    {
        m_systemStreamInfo.stream_type = MPEG2_TRANSPORT_STREAM_TTS;
        return UMC_OK;
    }

    return UMC_NOT_INITIALIZED;
}


Status MPEG2SplitterBase::GetPosition(double& pos)// return current position
{
    if(m_pDataReader)
    {
        vm_var64 size      = m_pDataReader->GetSize();
        vm_var64 position  = m_pDataReader->GetPosition();
        pos  = (double)(vm_var64s)(position)/(double)(vm_var64s)size;

        return UMC_OK;
    }

    return UMC_NOT_INITIALIZED;
}


AudioStreamType MPEG2SplitterBase::GetAudioType ()
{
    return UNDEF_AUDIO;
}


Status MPEG2SplitterBase::Run()
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_bStop)
    {
        m_bStop = false;

        if(m_dRate > 0)
            ret = SplitterThread.Create((vm_thread_callback)SplitterThreadProc, (void*)this);
        else
            ret = SplitterThread.Create((vm_thread_callback)SplitterReverseThreadProc, (void*)this);

        while(m_bReadingFinished) // Wait while thread is starting
            vm_time_sleep(5);
    }
    else
        ret = UMC_OK;

    return ret;
}

Status MPEG2SplitterBase::Stop()
{
    m_bStop = true;

    //wait for finishing internal thread
    SplitterThread.Wait();

    return UMC_OK;
}

Status MPEG2SplitterBase::SetPosition(double pos)
{
    Status ret = UMC_OK;

    //ResetStatistic();

    if (m_splitter_flags & FLAG_VSPL_NO_INTERNAL_THREAD)
      m_bStop = false;

    if(m_pDataReader)
    {
        if(pos < 0 || pos >= 1)
            ret = UMC_OPERATION_FAILED;

        if (m_splitter_flags & FLAG_VSPL_NO_INTERNAL_THREAD)
        {
            ret = m_pDataReader->SetPosition(pos);

            if (UMC_OK != ret)
              return ret;

            ret = m_pDataReader->StartReadingAfterReposition();

            if (UMC_OK != ret)
              return ret;

            m_bReadingFinished     = true;

            if(m_pVideoBuffer)
            {
                MediaData data;
                data.SetBufferPointer(0, 0);
                m_pVideoBuffer->UnLockInputBuffer(&data, UMC_END_OF_STREAM);
                m_VideoPrevData.SetBufferPointer(0, 0);
                m_uiVideoFrameCount = 0;
            }

            if(m_pAudioBuffer[0])
            {
                MediaData data;
                data.SetBufferPointer(0, 0);
                m_pAudioBuffer[0]->UnLockInputBuffer(&data, UMC_END_OF_STREAM);
                m_uiAudioFrameCount[0] = 0;
            }

            if(m_pAudioBuffer[1])
            {
                MediaData data;
                data.SetBufferPointer(0, 0);
                m_pAudioBuffer[1]->UnLockInputBuffer(&data, UMC_END_OF_STREAM);
                m_uiAudioFrameCount[1] = 0;
            }

            FlushBuffers();

            ret = MoveToNextSyncWord();

            if (UMC_OK != ret)
              return ret;

            m_bReadingFinished     = false;
        }
        else
        {
            if(!m_bStop)
            {
                if(UMC_OK == ret)
                    ret = Stop();

                if(UMC_OK == ret)
                    ret = m_pDataReader->SetPosition(pos);

                if(UMC_OK == ret)
                    ret = Run();
            }
            else
            {
                if(UMC_OK == ret)
                    ret = m_pDataReader->SetPosition(pos);
            }
        }
    }
    else
        ret = UMC_NOT_INITIALIZED;

    if ((ret == UMC_OK) && !(m_splitter_flags & FLAG_VSPL_NO_INTERNAL_THREAD))
    {
        if(m_pVideoBuffer   ) m_pVideoBuffer   ->m_bDirty = true;
        if(m_pAudioBuffer[0]) m_pAudioBuffer[0]->m_bDirty = true;
        if(m_pAudioBuffer[1]) m_pAudioBuffer[1]->m_bDirty = true;
    }

    return ret;
}


Status MPEG2SplitterBase::Close()
{
    m_bStop = true;

    //wait for finishing internal thread
   if(!(m_splitter_flags & FLAG_VSPL_NO_INTERNAL_THREAD))
        SplitterThread.Wait();

    if(m_pAudioBuffer[0])
    {
        delete m_pAudioBuffer[0];
        m_pAudioBuffer[0]      = NULL;
    }

    if(m_pAudioBuffer[1])
    {
        delete m_pAudioBuffer[1];
        m_pAudioBuffer[1]      = NULL;
    }

    if(m_pVideoBuffer)
    {
        delete m_pVideoBuffer;
        m_pVideoBuffer      = NULL;
    }

    m_pDataReader           = NULL;

    m_bReadingFinished      = false;
    m_bIgnoreVideo          = false;
    m_bIgnoreAudio          = false;
//    m_bReposHappend         = true;
//    m_bPrepareForReposition = false;

    m_eInitAudio.Reset();
    m_eInitVideo.Reset();
    m_eInitComplete.Reset();
    vm_semaphore_destroy(&m_eVideoFrameCount);

    m_dCurrAudioPts     = -1;
    m_uiOutputAudioSize = 0;
    m_frame_types      = SPL_FT_ANY;

    if(m_pESArray)
    {
        delete[] m_pESArray;
        m_pESArray = NULL;
    }

    m_inESCount = 0;
    return UMC_OK;
}


Status MPEG2SplitterBase::FillAudioBuffer(int iLength, unsigned int uiSwapFlag)
{
    MediaData data;
    Status ret = UMC_OK;

    while(!m_bStop && (UMC_OK != ret || iLength))
    {
        if(UMC_OK == ret)
        {
            data.SetTime(m_dCurrAudioPts);
            ret = m_pAudioBuffer[m_uiCurrInputBuffNum]->LockInputBuffer(&data);

            while(!m_bStop && (UMC_TIMEOUT == ret || UMC_NOT_ENOUGH_BUFFER == ret))
            {
                vm_time_sleep(5);
                ret = m_pAudioBuffer[m_uiCurrInputBuffNum]->LockInputBuffer(&data);
            }
        }

        if(UMC_OK == ret)
        {
            if((int)data.GetBufferSize() < iLength)
            {
                vm_time_sleep(5);
                ret = UMC_OK;
            }
            else
            {
                unsigned int nsize = iLength;
                ret = m_pDataReader->GetData(data.GetBufferPointer(), &nsize);

                if(uiSwapFlag == 1)
                    Swap2Bytes((unsigned char*)data.GetBufferPointer(), nsize);
                else if(uiSwapFlag == 2)
                    Swap4Bytes((unsigned char*)data.GetBufferPointer(), nsize);

                data.SetDataSize(nsize);
                iLength -= nsize;
            }
        }

        if(UMC_OK == ret)
        {
            ret = m_pAudioBuffer[m_uiCurrInputBuffNum]->UnLockInputBuffer(&data);
            if(m_splitter_flags & FLAG_VSPL_NO_INTERNAL_THREAD)
            {
                MediaData data;
                if(m_dCurrAudioPts > 0 &&
                    (UMC_OK == (ret = m_pAudioBuffer[m_uiCurrOutBuffNum]->LockOutputBuffer(&data))))
                    m_uiAudioFrameCount[m_uiCurrOutBuffNum]++;
                else
                    ret = UMC_OK;
            }
            m_eInitAudio.Set();
        }

        if(UMC_TIMEOUT == ret || UMC_NOT_ENOUGH_BUFFER == ret)
        {
            vm_time_sleep(5);
            ret = UMC_OK;
        }

        if(UMC_END_OF_STREAM == ret)
            break;
    }

    return ret;
}


Status MPEG2SplitterBase::FillVideoBuffer(int iLength, unsigned int uiSwapFlag)
{
    MediaData data;
    Status ret = UMC_OK;

    while(!m_bStop && (UMC_OK != ret || iLength))
    {
        if(UMC_OK == ret)
            ret = m_pVideoBuffer->LockInputBuffer(&data);

        if(UMC_OK == ret)
        {
            if((int)data.GetBufferSize() < iLength)
            {
                vm_time_sleep(5);
                ret = UMC_OK;
            }
            else
            {
                unsigned int nsize = iLength;
                ret = m_pDataReader->GetData(data.GetBufferPointer(), &nsize);

                if(uiSwapFlag == 1)
                    Swap2Bytes((unsigned char*)data.GetBufferPointer(), nsize);
                else if(uiSwapFlag == 2)
                    Swap4Bytes((unsigned char*)data.GetBufferPointer(), nsize);

                data.SetDataSize(nsize);
                iLength -= nsize;
                data.SetTime(m_dCurrVideoPts, m_dCurrVideoDts);
            }
        }

        if(UMC_OK == ret)
        {
            ret = m_pVideoBuffer->UnLockInputBuffer(&data);
               //m_eInitVideo.Set();
        }

        if(UMC_TIMEOUT == ret || UMC_NOT_ENOUGH_BUFFER == ret)
        {
            vm_time_sleep(5);
            ret = UMC_OK;
        }
    }

    return ret;
}


void MPEG2SplitterBase::FlushBuffers()
{
    if((m_splitter_flags & VIDEO_SPLITTER) && !m_bIgnoreVideo)
    {
        if(m_pVideoBuffer)
            m_pVideoBuffer->Reset();

        if(m_pVideoAuxData)
            m_pVideoAuxData->Reset();
    }

    if((m_splitter_flags & AUDIO_SPLITTER) && !m_bIgnoreAudio)
    {
        if(m_pAudioBuffer[0])
            m_pAudioBuffer[0]->Reset();

        if(m_pAudioBuffer[1])
            m_pAudioBuffer[1]->Reset();
    }
}

Status MPEG2SplitterBase::WaitForVideoFrame()
{
    Status  ret = UMC_WAIT_FOR_REPOSITION;

    while(!m_bStop &&
          (UMC_NOT_ENOUGH_DATA == (ret = m_pVideoBuffer->LockOutputBuffer(&m_VideoPrevData))))
    {
        if(((ret != UMC_OK && m_bReadingFinished) || m_bIgnoreVideo))
            break;

//        if(m_bPrepareForReposition)
//            return UMC_WAIT_FOR_REPOSITION;

        vm_time_sleep(5);
    }

    vm_semaphore_post(&m_eVideoFrameCount);

    if(ret == UMC_OK && m_pVideoAuxData)
    {
        ret = m_pVideoAuxData->LockOutputBuffer(&m_VideoPrevAuxData);
        void* ptr                      = m_VideoPrevAuxData.GetBufferPointer();
        MediaDataEx::_MediaDataEx* ptr1 = NULL;

        if(ptr)
            ptr1 = *(MediaDataEx::_MediaDataEx**)ptr;

        m_VideoPrevData.SetExData(ptr1);
    }

    return ret;
}


Status MPEG2SplitterBase::WaitForAudioFrame()
{
    Status  ret = UMC_WAIT_FOR_REPOSITION;

    while (!m_bStop &&
          (UMC_NOT_ENOUGH_DATA == (ret = m_pAudioBuffer[m_uiCurrOutBuffNum]->LockOutputBuffer(&m_AudioPrevData[m_uiCurrOutBuffNum]))))
    {
        if(((ret != UMC_OK && m_bReadingFinished) || m_bIgnoreAudio))
            break;

//        if(m_bPrepareForReposition)
//            return UMC_WAIT_FOR_REPOSITION;

        vm_time_sleep(5);
    }

    return ret;
}


bool MPEG2SplitterBase::IsLastVideoFrame()
{
    return false;
}


bool MPEG2SplitterBase::IsLastAudioFrame()
{
    return false;
}


Status MPEG2SplitterBase::GetVideoFrame(MediaDataEx* data)
{
    *data = m_VideoPrevData;
    m_VideoPrevData.MoveDataPointer(m_VideoPrevData.GetDataSize());
    if(m_pVideoAuxData)
    {
        m_VideoPrevAuxData.MoveDataPointer(m_VideoPrevAuxData.GetDataSize());
    }

    return UMC_OK;
}


Status MPEG2SplitterBase::GetAudioFrame(MediaData* data)
{
    Status       ret = UMC_OK;

    *data = m_AudioPrevData[m_uiCurrOutBuffNum];

    if((data->GetDataSize() > (size_t)m_uiOutputAudioSize) &&
        !(m_splitter_flags & FLAG_VSPL_NO_INTERNAL_THREAD))
    {
        m_AudioPrevData[m_uiCurrOutBuffNum].SetDataSize(m_AudioPrevData[m_uiCurrOutBuffNum].GetDataSize() - m_uiOutputAudioSize);
        data->SetDataSize(m_uiOutputAudioSize);
    }
    else
    {
        m_AudioPrevData[m_uiCurrOutBuffNum].SetDataSize(0);
    }

    return ret;
}