umc_vc1_spl.cpp

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

/* /////////////////////////////////////////////////////////////////////////////
//
//                  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) 2004-2007 Intel Corporation. All Rights Reserved.
//
//
//          VC-1 (VC1) splitter
//
*/
#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_SPLITTER)

#include "umc_vc1_spl.h"
#include "umc_vc1_spl_defs.h"
#include "umc_vc1_common.h"
#include "umc_vc1_common_defs.h"



namespace UMC
{
    using namespace UMC::VC1Common;



    VC1Splitter::VC1Splitter()
    {
        m_frame_constructor = NULL;
        m_pDataReader = NULL;

        m_seqHeaderFlag = 0;
        m_NextFrame = 0;

        m_frameBuf = NULL;
        m_frameBufSize = 1024;
        m_frameSize = 0;

        m_readBuf = NULL;
        m_readBufSize = 1024;
        m_readDataSize = 0;

        m_readData = NULL;
        m_stCodes = NULL;

        m_bNotDelete = false;
    }

    VC1Splitter::~VC1Splitter()
    {
        Close();
    }

    Status VC1Splitter::Init(SplitterParams& rInit)
    {
        UMC::Status umcSts = UMC_OK;
        MediaDataEx mediaData;
        Ipp32u splMode = 1;
        Ipp32u temp_val;

        Close();

        m_pDataReader = rInit.m_pDataReader;
        if(!m_pDataReader)
        {
            Close();
            return UMC_ERR_NULL_PTR;
        }

        m_info.m_splitter_flags = rInit.m_lFlags & (~AUDIO_SPLITTER);
        m_info.m_system_info.stream_type = VC1_PURE_VIDEO_STREAM;
        m_info.m_SystemType = VC1_PURE_VIDEO_STREAM;
        m_info.m_nOfTracks = 1;
        m_info.number_audio_tracks = 0;
        m_info.number_video_tracks = 1;

        m_info.m_ppTrackInfo = new TrackInfo*[1];
        if(m_info.m_ppTrackInfo == NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }

        m_info.m_ppTrackInfo[0] = new TrackInfo;
        if(m_info.m_ppTrackInfo[0] == NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }

        m_info.m_ppTrackInfo[0]->m_Type = TRACK_VC1;
        m_info.m_ppTrackInfo[0]->m_isSelected = 1;
        m_info.m_ppTrackInfo[0]->m_pStreamInfo = new VideoStreamInfo;
        if(m_info.m_ppTrackInfo[0]->m_pStreamInfo == NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }

        m_readData = new MediaData();
        if(m_readData == NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }

        m_frameBufSize = 1024;
        m_frameBuf = (Ipp8u*)ippsMalloc_8u(m_frameBufSize*sizeof(Ipp8u));
        if(m_frameBuf==NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }
        memset(m_frameBuf, 0,m_frameBufSize);

        m_readBufSize = 1024;
        m_readBuf = (Ipp8u*)ippsMalloc_8u(m_readBufSize*sizeof(Ipp8u));
        if(m_readBuf==NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }
        memset(m_readBuf, 0, m_readBufSize);

        //for slice, field start code
        m_stCodes = (MediaDataEx::_MediaDataEx *)ippsMalloc_8u(START_CODE_NUMBER*2*sizeof(Ipp32s)+sizeof(MediaDataEx::_MediaDataEx));
        if(m_stCodes == NULL)
        {
            Close();
            return UMC_ERR_ALLOC;
        }
        memset(m_stCodes, 0, (START_CODE_NUMBER*2*sizeof(Ipp32s)+sizeof(MediaDataEx::_MediaDataEx)));
        m_stCodes->count      = 0;
        m_stCodes->index      = 0;
        m_stCodes->bstrm_pos  = 0;
        m_stCodes->offsets    = (Ipp32u*)((Ipp8u*)m_stCodes +
                                            sizeof(MediaDataEx::_MediaDataEx));
        m_stCodes->values     = (Ipp32u*)((Ipp8u*)m_stCodes->offsets +
                                      START_CODE_NUMBER*sizeof( Ipp32u));

        m_readDataSize = m_readBufSize;
        umcSts = m_pDataReader->GetData(m_readBuf,&m_readDataSize);
        if(umcSts != UMC_OK || m_readDataSize == 0)
        {
            Close();
            return UMC_ERR_FAILED;
        }

        m_readData->SetBufferPointer(m_readBuf, m_readDataSize);

       temp_val = ((*(m_readBuf+3))<<24) + ((*(m_readBuf+2))<<16) + ((*(m_readBuf+1))<<8) + *(m_readBuf);
       if(temp_val == 0x0F010000)
        {
            m_frame_constructor = new vc1_frame_constructor_vc1();
            if(m_frame_constructor==NULL)
            {
                Close();
                return UMC_ERR_ALLOC;
            }
            ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->stream_subtype = VC1_VIDEO_VC1;
        }
        else
        {
            m_frame_constructor = new vc1_frame_constructor_rcv();
            if(m_frame_constructor==NULL)
            {
                Close();
                return UMC_ERR_ALLOC;
            }
            ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->stream_subtype = VC1_VIDEO_RCV;
        }

        umcSts = GetFirstSeqHeader(&mediaData, splMode);
        if(umcSts != UMC_OK)
        {
            Close();
            return UMC_ERR_INIT;
        }

        return UMC_OK;
    }

    Status VC1Splitter::Close()
    {
        DeleteReadBuf();
        DeleteFrameBuf();

        m_pDataReader = NULL;

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

        if(m_stCodes)
        {
            ippsFree(m_stCodes);
            m_stCodes = NULL;
        }

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

        if(m_info.m_ppTrackInfo)
        {
            if(m_info.m_ppTrackInfo[0])
            {
                if(m_info.m_ppTrackInfo[0]->m_pStreamInfo)
                {
                    delete m_info.m_ppTrackInfo[0]->m_pStreamInfo;
                    m_info.m_ppTrackInfo[0]->m_pStreamInfo = NULL;
                }

                delete m_info.m_ppTrackInfo[0];
                m_info.m_ppTrackInfo[0] = NULL;
            }

            delete m_info.m_ppTrackInfo;
            m_info.m_ppTrackInfo = NULL;
        }
        m_readDataSize = 0;
        m_frameSize = 0;
        m_seqHeaderFlag = 0;
        m_NextFrame = 0;
        return UMC_OK;
    }


    void VC1Splitter::DeleteReadBuf()
    {
        if(m_readBuf)
        {
            ippsFree(m_readBuf);
            m_readBuf = NULL;
        }

        m_readBufSize = 0;
    }

    void VC1Splitter::DeleteFrameBuf()
    {
        if(m_frameBuf)
        {
            ippsFree(m_frameBuf);
            m_frameBuf = NULL;
        }

        m_frameBufSize = 0;
    }


    Status VC1Splitter::Run()
    {
        UMC::Status umcSts = UMC_OK;
        return umcSts;
    }

    Status VC1Splitter::Stop()
    {
        Status umcSts = UMC_OK;
        return umcSts;
    }

    Status VC1Splitter::GetNextData(MediaData*   data, Ipp32u /*nTrack*/)
    {
        Status umcSts = UMC_ERR_NOT_ENOUGH_DATA;
        Status umcStsReader = UMC_OK;
        Ipp32u splMode = 0;//1 - delete 000003, 0 - not;

        MediaDataEx *data_ex = DynamicCast<MediaDataEx,MediaData>(data);
        if((data_ex != NULL)&&(!m_bNotDelete))
        {
            data_ex->SetExData(m_stCodes);
            splMode = 1;
        }

        if(m_NextFrame == 1)
        {
            data->SetBufferPointer(m_frameBuf, m_frameBufSize);
            data->SetDataSize(m_frameSize);

            m_NextFrame = 0;
            return UMC_OK;
        }

        if(m_seqHeaderFlag)
        {
            if(ResizeFrameBuf(m_frameBufSize)!=UMC_OK)
                return UMC_ERR_ALLOC;

            m_seqHeaderFlag = 0;
        }

        memset(m_stCodes->offsets, 0,START_CODE_NUMBER*sizeof(Ipp32s));
        memset(m_stCodes->values, 0,START_CODE_NUMBER*sizeof(Ipp32s));
        memset(m_frameBuf, 0,m_frameBufSize*sizeof(Ipp8s));
        m_stCodes->count = 0;
        m_NextFrame = 0;