umc_vc1_spl_frame_constr.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) frame constructor
//
*/

#include "umc_defs.h"

#if defined (UMC_ENABLE_VC1_SPLITTER)

#include "umc_vc1_spl_frame_constr.h"
#include "umc_vc1_spl_tbl.h"
#include "umc_vc1_spl_defs.h"
#include "umc_vc1_common_macros_defs.h"
#include "umc_vc1_common.h"
#include "umc_vc1_common_defs.h"



namespace UMC
{
    using namespace VC1Common;
    vc1_frame_constructor_rcv::vc1_frame_constructor_rcv()
    {
    }

    vc1_frame_constructor_rcv::~vc1_frame_constructor_rcv()
    {
    }

    void vc1_frame_constructor_rcv::Reset()
    {
    }

    Status vc1_frame_constructor_rcv::GetNextFrame(MediaData* in,
                                                   MediaData* out,
                                                   MediaDataEx::_MediaDataEx *stCodes,
                                                   Ipp32u splMode)
    {
        UMC::Status umcSts = UMC_ERR_NOT_ENOUGH_DATA;
        Ipp32u frameSize = 0;

        if((Ipp32u)in->GetBufferSize() == 0)
            if((Ipp32u)out->GetDataSize() == 0)
                return UMC_ERR_END_OF_STREAM;
            else
                return UMC_OK;

        if((Ipp32u)out->GetDataSize() == 0)
        {
            if((Ipp32u)in->GetDataSize() < (Ipp32u)in->GetBufferSize() - 4)
            {
                Ipp8u* curr_pos = ((Ipp8u*)in->GetBufferPointer()+(Ipp32u)in->GetDataSize());
                //frameSize = *(Ipp32u*)((Ipp8u*)in->GetBufferPointer()+(Ipp32u)in->GetDataSize());
                frameSize  = ((*(curr_pos+3))<<24) + ((*(curr_pos+2))<<16) + ((*(curr_pos+1))<<8) + *(curr_pos);
                frameSize &= 0x0fffffff;
                frameSize += 8;

                if ((Ipp32u)out->GetBufferSize() < frameSize)
                   return UMC_ERR_NOT_ENOUGH_BUFFER;

                out->SetBufferPointer((Ipp8u*)out->GetBufferPointer(),frameSize);
            }
            else
            {
                Ipp8u* buf = (Ipp8u*)in->GetBufferPointer();
                Ipp8u* data = (Ipp8u*)in->GetBufferPointer() + (Ipp32u)in->GetDataSize();
                ippsCopy_8u(data, buf, (Ipp32u)in->GetBufferSize() - (Ipp32u)in->GetDataSize());
                in->SetDataSize((Ipp32u)in->GetBufferSize() - (Ipp32u)in->GetDataSize());

                return UMC_ERR_NOT_ENOUGH_DATA;
            }
        }

        umcSts = GetData(in, out,stCodes,splMode);

        stCodes->values[0]  = 0x0D010000;
        stCodes->offsets[0] = 0;

        return umcSts;
    }

    Status vc1_frame_constructor_rcv::GetData(MediaData* in,
                                              MediaData* out,
                                              MediaDataEx::_MediaDataEx *stCodes,
                                              Ipp32u splMode)
    {
        if ((Ipp32u)out->GetBufferSize() < (Ipp32u)out->GetDataSize())
           return UMC_ERR_NOT_ENOUGH_BUFFER;

        Ipp32u readDataSize = (Ipp32u)in->GetDataSize();
        Ipp32u readBufSize = (Ipp32u)in->GetBufferSize();
        Ipp8u* readBuf = (Ipp8u*)in->GetBufferPointer();

        Ipp32u currFrameSize = (Ipp32u)out->GetDataSize();
        Ipp8u* currFramePos = (Ipp8u*)out->GetBufferPointer() + currFrameSize;
        Ipp32u frameSize = (Ipp32u)out->GetBufferSize();

        if(currFrameSize + readBufSize - readDataSize <= frameSize )
        {
            ippsCopy_8u(readBuf + readDataSize, currFramePos, readBufSize - readDataSize);

            out->SetDataSize(currFrameSize + readBufSize - readDataSize);
            in->SetDataSize(0);
            return UMC_ERR_NOT_ENOUGH_DATA;
        }
        else
        {
            ippsCopy_8u(readBuf + readDataSize, currFramePos, frameSize - currFrameSize);

            out->SetDataSize(frameSize);
            in->SetDataSize(readDataSize + frameSize - currFrameSize);
            return UMC_OK;
        }
    }

    Status vc1_frame_constructor_rcv::ParseVC1SeqHeader (Ipp8u *data,
                                        Ipp32u* bufferSize,SplitterInfo* info)
    {
        UMC::Status umcSts = UMC_OK;
        VideoStreamInfo* video_info = (VideoStreamInfo *)info->m_ppTrackInfo[0]->m_pStreamInfo;

        Ipp32u tempData;
        Ipp32u *  pbs;
        Ipp32s  bitOffset = 31;

        pbs = (Ipp32u *)data;
        *bufferSize = 0;

        video_info->streamPID = 0;
        video_info->stream_type = VC1_VIDEO;
        video_info->stream_subtype = VC1_VIDEO_RCV;

        video_info->interlace_type = PROGRESSIVE;
        video_info->framerate = 0;
        video_info->bitrate = 0;

        video_info->duration = 0;
        video_info->color_format = YUV420;

        //Simple/main profile
        video_info->aspect_ratio_width  = 1;
        video_info->aspect_ratio_height = 1;

        //PROFILE
        VC1GetNBits(pbs, bitOffset, 2, tempData);

        //Simple/Main profile
        //LEVEL
        VC1GetNBits(pbs, bitOffset, 2, tempData);

        //FRMRTQ_POSTPROC
        VC1GetNBits(pbs, bitOffset, 3, video_info->framerate);

        //BITRTQ_POSTPROC
        VC1GetNBits(pbs, bitOffset, 5, video_info->bitrate);

        //LOOPFILTER
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //reserved
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //MULTIRES
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //reserved
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //FASTUVMC
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //EXTENDED_MV
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //DQUANT
        VC1GetNBits(pbs, bitOffset, 2, tempData);

        //VSTRANSFORM
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //reserved
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //OVERLAP
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //SYNCMARKER
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //RANGERED
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //MAXBFRAMES
        VC1GetNBits(pbs, bitOffset, 3, tempData);

        //QUANTIZER
        VC1GetNBits(pbs, bitOffset, 2, tempData);

        //FINTERPFLAG
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        //last bit in seq header
        VC1GetNBits(pbs, bitOffset, 1, tempData);

        *bufferSize = (video_info->clip_info.height+15 +128)*
            (video_info->clip_info.width + 15 + 128)
            + (((video_info->clip_info.height+15)/2 + 64)*
            ((video_info->clip_info.width +15)/2 + 64))*2;

        video_info->bitrate = 1024 * video_info->bitrate;

        return umcSts;
    }

    Status vc1_frame_constructor_rcv::GetFirstSeqHeader(MediaData* in,
                                                        MediaData* out,
                                                        MediaDataEx::_MediaDataEx *stCodes,
                                                        Ipp32u splMode)
    {
        UMC::Status umcSts = UMC_ERR_NOT_ENOUGH_DATA;
        Ipp32u frameSize = 4;
        Ipp8u* ptemp = (Ipp8u*)in->GetBufferPointer() + 4;
        Ipp32u temp_size = ((*(ptemp+3))<<24) + ((*(ptemp+2))<<16) + ((*(ptemp+1))<<8) + *(ptemp);


        frameSize+= temp_size;
        frameSize+=12;
        ptemp = (Ipp8u*)in->GetBufferPointer() + frameSize;
        temp_size = ((*(ptemp+3))<<24) + ((*(ptemp+2))<<16) + ((*(ptemp+1))<<8) + *(ptemp);
        frameSize+= temp_size;
        frameSize+=4;

        out->SetBufferPointer((Ipp8u*)out->GetBufferPointer(),frameSize);

        umcSts = GetData(in,out,stCodes,splMode);

        return umcSts;
    }

    //Status vc1_frame_constructor_rcv::GetPicType(MediaDataEx* data, Ipp32u& picType)
    //{
    //    Ipp32u Ipp32u*   pbs = (Ipp32u*)data->GetDataPointer();
    //    Ipp32s  bitOffset = 31;
    //    Ipp32u tempData = 0;
    //    return UMC_OK;
    //}

///////////////////////////////////////////////////////////////////////////////////////////
    vc1_frame_constructor_vc1::vc1_frame_constructor_vc1()
    {
    }


    vc1_frame_constructor_vc1::~vc1_frame_constructor_vc1()
    {
    }

    Status vc1_frame_constructor_vc1::GetNextFrame(MediaData* in,
                                                   MediaData* out,
                                                   MediaDataEx::_MediaDataEx *stCodes,
                                                   Ipp32u splMode)
    {
        UMC::Status umcSts = UMC_ERR_NOT_ENOUGH_DATA;
        umcSts = GetData(in, out,stCodes, splMode);
        return umcSts;
    }

    Status vc1_frame_constructor_vc1::GetData(MediaData* in,
                                              MediaData* out,
                                              MediaDataEx::_MediaDataEx *stCodes,
                                              Ipp32u splMode)
    {
        Ipp32u readDataSize = (Ipp32u)in->GetDataSize();
        Ipp32u readBufSize = (Ipp32u)in->GetBufferSize();
        Ipp8u* readBuf = (Ipp8u*)in->GetBufferPointer();

        Ipp8u* readPos = readBuf + (Ipp32u)in->GetDataSize();

        Ipp32u frameSize = (Ipp32u)out->GetDataSize();
        Ipp8u* currFramePos = (Ipp8u*)out->GetBufferPointer() + frameSize;
        Ipp32u frameBufSize = (Ipp32u)out->GetBufferSize();

        Ipp8u* ptr = currFramePos;
        Ipp32u zeroNum = 0;
        Ipp32s size = 0;
        Ipp32u a = 0x0000FF00 | (*readPos);
        Ipp32u b = 0xFFFFFFFF;

        while(readPos < (readBuf + readBufSize))
        {
            //find sequence of 0x000001 or 0x000003
            while(!( b == 0x00000001 || b == 0x00000003 )
                    &&(readPos < (readBuf + readBufSize)))
            {
                readPos++;