umc_h264_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) 2003-2007 Intel Corporation. All Rights Reserved.
//
*/
#include "umc_defs.h"
#if defined (UMC_ENABLE_H264_SPLITTER)

#include "umc_h264_spl.h"

namespace UMC
{
    H264AnnexBSplitter::H264AnnexBSplitter()
    {
        m_fSource = 0;
        m_bEndOfSourceSeen = false;
        m_bEndOfAUSeen = false;
    }

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

    void H264AnnexBSplitter::Init()
    {
        m_bEndOfSourceSeen = false;
        m_bEndOfAUSeen = false;
        m_dataFile.SetBufferPointer(0, 0);
        m_dataFile.SetDataSize(0);
        m_streamAU.Init();
        m_streamNALU.Init();
    }

    Status H264AnnexBSplitter::Init(const vm_char * p_sFilename)
    {
        Init();

        m_fSource = vm_file_open(p_sFilename, VM_STRING("rb"));
        if( 0 == m_fSource){
            return UMC_ERR_FAILED;
        }

        return UMC_OK;
    }

    Status H264AnnexBSplitter::Close()
    {
        if( 0 != m_fSource){
            vm_file_close(m_fSource);
            m_fSource = 0;
        }
        return UMC_OK;
    }

    Status H264AnnexBSplitter::LoadByteData(MediaData & p_data)
    {
        Ipp32s iRead = (Ipp32s)vm_file_read(m_aFileBuffer, sizeof(Ipp8u), sizeof(m_aFileBuffer), m_fSource);
        p_data.SetBufferPointer(m_aFileBuffer, iRead);
        p_data.SetDataSize(iRead);
        if(iRead == 0){
            return UMC_ERR_END_OF_STREAM;
        }
        return UMC_OK;
    }

    Status H264AnnexBSplitter::GetNALUData(MediaData & p_data)
    {
        if(m_bEndOfSourceSeen){
            return UMC_ERR_END_OF_STREAM;
        }

        m_streamNALU.UnLockOutputData();

        for(;;)
        {
            if(!m_bEndOfSourceSeen){
                if(m_dataFile.GetDataSize() == 0){
                    if( UMC_OK != LoadByteData(m_dataFile)){
                        m_bEndOfSourceSeen = true;
                        m_streamNALU.LockOutputData(p_data);
                        return p_data.GetDataSize() == 0 ? UMC_ERR_END_OF_STREAM : UMC_OK;
                    }
                }
            }

            Status status = m_streamNALU.PutData(m_dataFile);
            if( UMC_OK == status ){
                m_streamNALU.LockOutputData(p_data);
                return status;
            } else if( UMC_ERR_NOT_ENOUGH_DATA == status){
                continue;
            } else {
                // Error or other event seen
                return status;
            }
        }
    }

    bool H264AnnexBSplitter::HasMoreBinData()
    {
        return m_dataFile.GetDataSize() > 0 ? true : false;
    }

    Status H264AnnexBSplitter::GetNextVideoData(MediaData & p_Frame)
    {
        if(m_bEndOfAUSeen){
            p_Frame.SetBufferPointer(0, 0);
            p_Frame.SetDataSize(0);
            return UMC_ERR_END_OF_STREAM;
        }

        for(;;)
        {
            MediaData dataNALU;
            Status status = GetNALUData(dataNALU);
            if(UMC_OK == status){
                Status statusAU = m_streamAU.PutData(dataNALU);
                if(UMC_OK == statusAU){
                    m_streamAU.LockOutputData(p_Frame);
                    return UMC_OK;
                }
            } else {
                m_streamAU.Swap();
                m_streamAU.LockOutputData(p_Frame);
                m_bEndOfAUSeen = true;
                return p_Frame.GetDataSize() == 0 ? UMC_ERR_END_OF_STREAM : UMC_OK;
            }
        }
    }
}

#endif // UMC_ENABLE_H264_SPLITTER