umc_vc1_spl.cpp

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

        data->SetBufferPointer(m_frameBuf, m_frameBufSize);
        data->SetDataSize(0);

        umcSts = m_frame_constructor->GetNextFrame(m_readData,data,m_stCodes,splMode);

      while(umcSts == UMC_ERR_NOT_ENOUGH_DATA)
        {
           m_readDataSize = m_readBufSize - (Ipp32u)m_readData->GetDataSize();

           umcStsReader = m_pDataReader->GetData(m_readBuf + (Ipp32u)m_readData->GetDataSize(),
                &m_readDataSize);
           m_readData->SetBufferPointer(m_readBuf,(Ipp32u)m_readData->GetDataSize() + m_readDataSize);
           umcSts = m_frame_constructor->GetNextFrame(m_readData,data,m_stCodes,splMode);
         }

        if(!(umcStsReader == UMC_OK || umcStsReader == UMC_ERR_END_OF_STREAM) )
        {
            data->SetDataSize(0);
            return umcStsReader;
        }

       m_frameSize = (Ipp32u)data->GetDataSize();

       if((((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->stream_subtype == VC1_VIDEO_VC1)
            && (umcSts == UMC_OK || umcSts == UMC_ERR_END_OF_STREAM))
        {
            switch((m_stCodes->values[0])>>24)
            {
            case VC1_SequenceHeader:
                m_seqHeaderFlag = 1;
                SwapData(m_frameBuf, m_frameSize);
                umcSts = m_frame_constructor->ParseVC1SeqHeader((Ipp8u*)data->GetDataPointer() + 4,
                                               &m_frameBufSize,
                                               &m_info);
                if((m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) != FLAG_VSPL_4BYTE_ACCESS)
                      SwapData(m_frameBuf, m_frameSize);
                break;
            case VC1_EndOfSequence:
                data->SetDataSize(data->GetDataSize() - 1);
                return UMC_ERR_NOT_ENOUGH_DATA;
            case VC1_EntryPointHeader:
            case VC1_FrameHeader:
            case VC1_Slice:
            case VC1_Field:
            case VC1_SliceLevelUserData:
            case VC1_FieldLevelUserData:
            case VC1_FrameLevelUserData:
            case VC1_EntryPointLevelUserData:
            case VC1_SequenceLevelUserData:
                if((m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) == FLAG_VSPL_4BYTE_ACCESS)
                    SwapData(m_frameBuf, m_frameSize);
                break;
            default:
                break;
            }

            return umcSts;
        }
        if((((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->stream_subtype == VC1_VIDEO_RCV)
            && (umcSts == UMC_OK || umcSts == UMC_ERR_END_OF_STREAM))
        {
             if((m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) == FLAG_VSPL_4BYTE_ACCESS)
                SwapData(m_frameBuf,(Ipp32u)data->GetDataSize());

            return umcSts;
        }
        else if(umcSts == UMC_ERR_NOT_ENOUGH_BUFFER)
        {
            m_frameBufSize = m_frameBufSize + 2048;

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

            return umcSts;
        }
        else
            return umcSts;
    }

    Status VC1Splitter::CheckNextData(MediaData* data, Ipp32u /*nTrack*/)
    {
        UMC::Status umcSts = UMC_ERR_NOT_ENOUGH_DATA;
        UMC::Status umcStsReader = UMC_OK;
        Ipp32u splMode = 0; //1 - delete 000103, 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);

            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 = 1;

        data->SetBufferPointer(m_frameBuf, m_frameBufSize);
        data->SetDataSize(0);

        umcSts = m_frame_constructor->GetNextFrame(m_readData,data,m_stCodes,splMode);

        while( umcSts == UMC_ERR_NOT_ENOUGH_DATA)
        {
            m_readDataSize = m_readBufSize - (Ipp32u)m_readData->GetDataSize();

            umcStsReader = m_pDataReader->GetData(m_readBuf + (Ipp32u)m_readData->GetDataSize(),
                &m_readDataSize);
            m_readData->SetBufferPointer(m_readBuf,(Ipp32u)m_readData->GetDataSize() + m_readDataSize);
            umcSts = m_frame_constructor->GetNextFrame(m_readData,data,m_stCodes,splMode);
        }

        if(!(umcStsReader == UMC_OK || umcStsReader == UMC_ERR_END_OF_STREAM) )
        {
            data->SetDataSize(0);
            return umcStsReader;
        }

        m_frameSize = (Ipp32u)data->GetDataSize();

        if(umcSts == UMC_OK || (umcSts == UMC_ERR_END_OF_STREAM))
        {
            if((m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) == FLAG_VSPL_4BYTE_ACCESS)
                SwapData(m_frameBuf, (Ipp32u)data->GetDataSize());

            return umcSts;
        }
        else if(umcSts == UMC_ERR_NOT_ENOUGH_BUFFER)
        {
            return umcSts;
        }
        else
            return umcSts;
    }

    Status VC1Splitter::GetTimePosition(Ipp64f& /*timePos*/)
    {
        UMC::Status umcSts = UMC_OK;
        return umcSts;
    }

    Status VC1Splitter::SetRate(Ipp64f /*rate*/)
    {
        Status umcSts = UMC_OK;
        return umcSts;
    }


    Status VC1Splitter::ResizeFrameBuf(Ipp32u bufferSize)
    {
        DeleteFrameBuf();

        //buf size should be divisible by 4
        if( bufferSize&0x00000003)
            m_frameBufSize = (bufferSize&0xFFFFFFFC) + 4;
        else
            m_frameBufSize = bufferSize;

        m_frameBuf = (Ipp8u*)ippsMalloc_8u(m_frameBufSize*sizeof(Ipp8u));
        if(m_frameBuf==NULL)
        {
            return UMC_ERR_ALLOC;
        }
        return UMC_OK;
    }

    Status VC1Splitter::SetTimePosition(Ipp64f /*start_time*/)
    {
        return UMC_OK;
    }

    Status VC1Splitter::GetInfo(SplitterInfo** ppInfo)
    {
        *ppInfo = &m_info;
        return UMC_OK;
    }

    Status VC1Splitter::GetFirstSeqHeader(MediaDataEx* mediaData,
                                          Ipp32u splMode)
    {
        Status umcSts = UMC_OK;
        Status umcStsReader = UMC_OK;
        Ipp32u size;
        Ipp8u* ptr;

        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;

        mediaData->SetBufferPointer(m_frameBuf, m_frameBufSize);
        mediaData->SetExData(m_stCodes);

        m_NextFrame = 1;

        umcSts = m_frame_constructor->GetFirstSeqHeader(m_readData, mediaData,m_stCodes, splMode);

        if((((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->stream_subtype & VC1_VIDEO_VC1)
            &&(m_stCodes->values[0])>>24 == VC1_SequenceHeader)
        {
            m_frameSize =(Ipp32u) mediaData->GetDataSize();
            m_seqHeaderFlag = 1;

            if( (m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) == FLAG_VSPL_4BYTE_ACCESS)
            {
                SwapData(m_frameBuf, m_frameSize);
                umcSts = m_frame_constructor->ParseVC1SeqHeader((Ipp8u*)mediaData->GetDataPointer() + 4,
                                                                &m_frameBufSize,
                                                                &m_info);
            }
            else
            {
                SwapData(m_frameBuf, m_frameSize);
                umcSts = m_frame_constructor->ParseVC1SeqHeader((Ipp8u*)mediaData->GetDataPointer() + 4,
                                                                &m_frameBufSize,
                                                                &m_info);
                SwapData(m_frameBuf, m_frameSize);
            }

              size = (Ipp32u)m_pDataReader->GetSize();

            if(size && ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->bitrate)
                ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->duration  =
                ((Ipp64f)(Ipp64s)(size * 8))/((Ipp64f)(Ipp64s)(((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->bitrate));
            else
               ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->duration = 60*60*3;

            //printf("bitrate = %d\n",((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->bitrate);
            //printf("framerate = %f\n",((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->framerate);
        }
        else if(((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->stream_subtype== VC1_VIDEO_RCV)
        {
            m_frameSize = (Ipp32u)mediaData->GetDataSize();

            ptr = (Ipp8u*)mediaData->GetDataPointer() + 4;
            //size = *(Ipp32u *)ptr;
            size = ((*(ptr+3))<<24) + ((*(ptr+2))<<16) + ((*(ptr+1))<<8) + *(ptr);
            ptr = ptr + 4 + size;

            ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->clip_info.height = ((*(ptr+3))<<24) + ((*(ptr+2))<<16) + ((*(ptr+1))<<8) + *(ptr);


            ptr = ptr + 4;
            ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->clip_info.width = ((*(ptr+3))<<24) + ((*(ptr+2))<<16) + ((*(ptr+1))<<8) + *(ptr);


            if((m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) == FLAG_VSPL_4BYTE_ACCESS)
                SwapData(m_frameBuf, m_frameSize);

            m_seqHeaderFlag = 1;
            if((m_info.m_splitter_flags & FLAG_VSPL_4BYTE_ACCESS) == FLAG_VSPL_4BYTE_ACCESS)
            {
                umcSts = m_frame_constructor->ParseVC1SeqHeader((Ipp8u*)mediaData->GetDataPointer() + 8,
                                                                &m_frameBufSize,
                                                                &m_info);
            }
            else
            {
                SwapData(m_frameBuf, m_frameSize);
                umcSts = m_frame_constructor->ParseVC1SeqHeader((Ipp8u*)mediaData->GetDataPointer() + 8,
                                                                &m_frameBufSize,
                                                                &m_info);
                SwapData(m_frameBuf, m_frameSize);
            }

            size = (Ipp32u)m_pDataReader->GetSize();

            if(size && (((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->bitrate))
                ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->duration  =
                ((Ipp64f)(Ipp64s)(size * 8))/((Ipp64f)(Ipp64s)(((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->bitrate));
            else
                ((VideoStreamInfo*)m_info.m_ppTrackInfo[0]->m_pStreamInfo)->duration = 60*60*3;
        }
        else
            return UMC_ERR_INIT;

        return umcStsReader;
    }
    Status VC1Splitter::EnableTrack(Ipp32u /*nTrack*/, Ipp32s /*iState*/)
    {
        return UMC_ERR_NOT_IMPLEMENTED;
    }
}


#endif //UMC_ENABLE_VC1_SPLITTER