umc_avi_splitter_base.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 "vm_debug.h"
#include "vm_time.h"

#include "umc_media_data.h"
#include "umc_avi_spl_base.h"

struct ThreadData
{
    UMC::BaseAVISplitter* pthis;
    int                   iType;
    vm_var32              uiIndex;
};

UMC::BaseAVISplitter::BaseAVISplitter():
    m_pStreams(NULL),

    m_pAudioStreams(NULL),
    m_pVideoStreams(NULL),

    m_uiVideoStreamCount(0),
    m_uiAudioStreamCount(0),

    m_dfCurAudioTime(0),

    m_VideoChunkCode(AVI_FOURCC_00DB),

    m_uiFlags(0)
{
    memset(&m_sAviHdr, 0, sizeof(m_sAviHdr));
    m_info.m_video_info.stream_type = UNDEF_VIDEO;
    m_info.m_audio_info.stream_type = UNDEF_AUDIO;
}

UMC::BaseAVISplitter::~BaseAVISplitter()
{
    Close();
}


UMC::Status
UMC::BaseAVISplitter::Init(SplitterParams& rInitParams)
{
    Status umcRes = UMC_OK;

    m_uiVideoStreamCount = 0;
    m_uiAudioStreamCount = 0;

    m_pDataReader = rInitParams.m_pDataReader;

    if (NULL == m_pDataReader)
    {   umcRes = UMC_NULL_PTR;  }

    if (UMC_OK == umcRes) { umcRes = m_ObjAccessMut.Init(); }
    if (UMC_OK == umcRes) { umcRes = m_NewPosMailBox.Init();    }

    if (UMC_OK == umcRes)
    {
        m_info.m_splitter_flags = rInitParams.m_lFlags;
        umcRes = ReadFormat(m_pDataReader,
                            m_DataReaderMut,
                            m_sAviHdr,
                            m_pStreams,
                            m_AviIndex,
                            m_uiFlags,
                            m_VideoChunkCode);
    }

    if (UMC_OK == umcRes)
    {
        m_info.m_system_info.stream_type = AVI_STREAM;
        m_uiFlags = FLAGS_AVISPL_ZERO;
        umcRes = SelectStreams(rInitParams);
    }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter Init failed\n")); }

    if (UMC_OK == umcRes && m_pAudioStreams &&
        -1 != m_pAudioStreams[0].m_iStreamInd)
    {
        vm_var32 uiInd = m_pAudioStreams[0].m_iStreamInd;
        UMC::WAVEFORMATEX* pWaveFmt =
            reinterpret_cast<UMC::WAVEFORMATEX*>(m_pStreams[uiInd].pbStrmFmt);
        if (WAVE_FORMAT_PCM != pWaveFmt->wFormatTag)
        {   m_dfCurAudioTime = -1;    }
    }

    //  Start file reading thread
    if (UMC_OK == umcRes)
    {   umcRes = StartFileRdThrd(); }

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4,__VM_STRING("H264Splitter Init failed\n"));    }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::SelectStreams(SplitterParams& rInitParams)
{
    Status umcRes = UMC_OK;
    // Array of stream types (Audio or Video) for AVI streams
    long* lpStreamType = new long [m_sAviHdr.uiStreams];

    if (NULL == lpStreamType)
    {   umcRes = UMC_ALLOC; }
    else
    {   memset(lpStreamType, 0, sizeof(long) * m_sAviHdr.uiStreams);    }

    // Let's distinguish stream types in AVI file
    if (UMC_OK == umcRes)
    {
        for (vm_var32 i = 0; i < m_sAviHdr.uiStreams; i++)
        {
            if (AVI_FOURCC_VIDEOSTRM == m_pStreams[i].sStrmHdr.fccType)
            {
                m_uiVideoStreamCount++;
                lpStreamType[i] = VIDEO_SPLITTER;
            }
            else if (AVI_FOURCC_AUDIOSTRM == m_pStreams[i].sStrmHdr.fccType)
            {
                m_uiAudioStreamCount++;
                lpStreamType[i] = AUDIO_SPLITTER;
            }
        }
    }

    // Clear Video from splitter flags if we don't have one
    if (0 == m_uiVideoStreamCount)
    {   m_info.m_splitter_flags &= ~VIDEO_SPLITTER; }

    if (UMC_OK == umcRes && VIDEO_SPLITTER & m_info.m_splitter_flags)
    {
        Status umcResInt = UMC_OK;

        delete[] m_pVideoStreams;
        m_pVideoStreams = NULL;

        delete[] m_info.m_video_info_aux;
        m_info.m_video_info_aux = NULL;

        m_pVideoStreams = new AVIStream[m_uiVideoStreamCount];

        if (1 < m_uiVideoStreamCount)
        {
            m_info.m_video_info_aux =
                new sVideoStreamInfo [m_uiVideoStreamCount - 1];
        }

        if (NULL == m_pVideoStreams ||
            (1 < m_uiVideoStreamCount && NULL == m_info.m_video_info_aux))
        {   umcRes = UMC_ALLOC; }

        if (UMC_OK == umcRes)
        {
            for (vm_var32 i = 0, k = 0;
                 i < m_sAviHdr.uiStreams && UMC_OK == umcResInt; i++)
            {
                umcResInt = UMC_OPERATION_FAILED;
                if (lpStreamType[i] == VIDEO_SPLITTER)
                {
                    tFOURCC VideoFourcc = m_VideoChunkCode +
                            ((i & 0xF) << 8) | ((i & 0xF0) >> 4);

                    umcResInt = ExtractVideoInfo(i, &m_pVideoStreams[k].m_Fifo);

                    if (UMC_OK == umcResInt)
                    {
                        umcResInt = m_pVideoStreams[k].m_Channel.Init(
                                                        LockableDataReaderRef(
                                                        rInitParams.m_pDataReader,
                                                        &m_DataReaderMut),
                                                        VideoFourcc,
                                                        FLAGS_AVISPL_RECPRESENT & m_uiFlags);
                    }
                }

                if (UMC_OK == umcResInt)
                {
                    m_pVideoStreams[k++].m_iStreamInd = i;
                    if (1 == k)
                    {   FillVideoInfo(k-1, &m_info.m_video_info);   }
                    else
                    {   FillVideoInfo(k-1, &m_info.m_video_info_aux[k-2]);  }
                }
            }
        }
    }

    // Clear Video from splitter flags if we don't have one
    if (0 == m_uiAudioStreamCount)
    {   m_info.m_splitter_flags &= ~AUDIO_SPLITTER; }

    if (UMC_OK == umcRes && (AUDIO_SPLITTER & m_info.m_splitter_flags))
    {
        Status umcResInt = UMC_OK;

        delete[] m_pAudioStreams;
        m_pAudioStreams = NULL;

        delete[] m_info.m_audio_info_aux;
        m_info.m_audio_info_aux = NULL;

        m_pAudioStreams = new AVIStream[m_uiAudioStreamCount];

        if (1 < m_uiAudioStreamCount)
        {   m_info.m_audio_info_aux = new sAudioStreamInfo[m_uiAudioStreamCount - 1];  }

        if (NULL == m_pAudioStreams ||
            (1 < m_uiAudioStreamCount && NULL == m_info.m_audio_info_aux))
        {    umcRes = UMC_ALLOC;    }

        if (UMC_OK == umcRes)
        {
            for (vm_var32 i = 0, k = 0;
                 i < m_sAviHdr.uiStreams &&
                     (UMC_OK == umcResInt || UMC_BAD_STREAM == umcResInt);
                 i++)
            {
                umcResInt = UMC_BAD_STREAM;
                if (lpStreamType[i] == AUDIO_SPLITTER)
                {
                    tFOURCC AudioFourcc = AVI_FOURCC_00WB +
                        ((i & 0xF) << 8) | ((i & 0xF0) >> 4);
                    umcResInt = ExtractAudioInfo(i, &m_pAudioStreams[k].m_Fifo);
                    if (UMC_OK == umcResInt)
                    {
                        umcResInt = m_pAudioStreams[k].m_Channel.Init(
                                            LockableDataReaderRef(
                                            rInitParams.m_pDataReader,
                                            &m_DataReaderMut),
                                            AudioFourcc,
                                            FLAGS_AVISPL_RECPRESENT & m_uiFlags);
                    }
                }

                if (UMC_OK == umcResInt)
                {
                    m_pAudioStreams[k++].m_iStreamInd = i;
                    if (1 == k)
                    {   FillAudioInfo(k-1, &m_info.m_audio_info);    }
                    else
                    {   FillAudioInfo(k-1, &m_info.m_audio_info_aux[k-2]);   }
                }
            }
        }
    }

    delete[] lpStreamType;

    if (UMC_OK != umcRes)
    {   vm_debug_trace(4, VM_STRING("BaseAVISplitter SelectStreams failed\n"));    }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::StartFileRdThrd()
{
    Status umcRes = UMC_OK;
    ThreadData* pThrdData = NULL;

    if (VIDEO_SPLITTER & m_info.m_splitter_flags)
    {
        for (vm_var32 i = 0; i < m_uiVideoStreamCount && UMC_OK == umcRes; i++)
        {
            //  Must be deleted in started thread!!!
            pThrdData = new ThreadData;

            if (NULL == pThrdData)
            {   umcRes = UMC_ALLOC; }

            if (UMC_OK == umcRes)
            {
                pThrdData->pthis = this;
                pThrdData->iType = VIDEO_SPLITTER;
                pThrdData->uiIndex  = i;

                vm_debug_trace(4, VM_STRING("%d "), pThrdData->iType);
                vm_debug_trace(4, VM_STRING("%d "), pThrdData->uiIndex);
                vm_debug_trace(4, VM_STRING("%P \n"), pThrdData->pthis);
            }

            if (UMC_OK == umcRes)
            {
                umcRes = m_pVideoStreams[i].m_Thread.Create(FileReadThreadProc,
                                                            pThrdData);
            }

            if (UMC_OK != umcRes)
            {
                delete pThrdData;
                umcRes = UMC_OPERATION_FAILED;
            }

            if (UMC_OK != umcRes)
            {    vm_debug_trace(4, VM_STRING("BaseAVISplitter StartFileRdThrd failed\n"));    }
        }
    }

    umcRes = UMC_OK;
    if (AUDIO_SPLITTER & m_info.m_splitter_flags)
    {
        for (vm_var32 i = 0; i < m_uiAudioStreamCount && UMC_OK == umcRes; i++)
        {
            //  Must be deleted in started thread!!!
            pThrdData = new ThreadData;

            if (NULL == pThrdData)
            {   umcRes = UMC_ALLOC; }

            if (UMC_OK == umcRes)
            {
                pThrdData->pthis = this;
                pThrdData->iType = AUDIO_SPLITTER;
                pThrdData->uiIndex  = i;

                vm_debug_trace(-1,VM_STRING("%d "), pThrdData->iType);
                vm_debug_trace(-1,VM_STRING("%d "), pThrdData->uiIndex);
                vm_debug_trace(-1,VM_STRING("%P \n"), pThrdData->pthis);
            }

            if (UMC_OK == umcRes)
            {
                umcRes = m_pAudioStreams[i].m_Thread.Create(FileReadThreadProc,
                                                           pThrdData);
            }
            if (UMC_OK != umcRes)
            {
                delete pThrdData;
                umcRes = UMC_OPERATION_FAILED;
            }

            if (UMC_OK != umcRes)
            {    vm_debug_trace(4, VM_STRING("BaseAVISplitter StartFileRdThrd failed\n"));    }
        }
    }

    return umcRes;
}

UMC::Status
UMC::BaseAVISplitter::Close()
{
    if (VIDEO_SPLITTER & m_info.m_splitter_flags)
    {
           m_uiFlags |= FLAGS_AVISPL_STOPFILERD;
        for (vm_var32 i = 0; i < m_uiVideoStreamCount; i++)
        {
            m_pVideoStreams[i].m_Thread.Wait();
            m_pVideoStreams[i].m_uiThreadState = AVI_SPL_THREAD_STOP;
            m_pVideoStreams[i].m_Fifo.Close();
            m_pVideoStreams[i].m_iStreamInd = -1;
        }
        m_uiFlags &= ~FLAGS_AVISPL_STOPFILERD;
    }

    if (AUDIO_SPLITTER & m_info.m_splitter_flags)
    {
        m_uiFlags |= FLAGS_AVISPL_STOPFILERD;
        for (vm_var32 i = 0; i < m_uiAudioStreamCount; i++)
        {
            m_pAudioStreams[i].m_Thread.Wait();
            m_pAudioStreams[i].m_uiThreadState = AVI_SPL_THREAD_STOP;
            m_pAudioStreams[i].m_Fifo.Close();
            m_pAudioStreams[i].m_iStreamInd = -1;
        }
        m_uiFlags &= ~FLAGS_AVISPL_STOPFILERD;
    }

    m_dfCurAudioTime = 0;

    if (NULL != m_pStreams)
    {
        assert(0 != m_sAviHdr.uiStreams);
        delete[] m_pStreams;
        m_pStreams = NULL;
    }

    memset(&m_sAviHdr, 0, sizeof(m_sAviHdr));

    delete[] m_pVideoStreams;
    m_pVideoStreams = NULL;