umc_mpeg2_spl.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 "umc_mpeg2_spl.h"
#include "umc_mpeg2ps_spl.h"
#include "umc_mpeg2ts_spl.h"
#include "umc_audio_spl.h"
#include "umc_mpeg2_spl_pure.h"
#include "umc_mpeg4_pure_detect.h"
#include "ipps.h"

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

UMC::Status UMC::MPEG2Splitter::Init(SplitterParams& init)
{
    UMC::Status res;
    UMC::MPEG2SplitterBase *p_spl1 = NULL;

    m_pDataReader = init.m_pDataReader;

    if(!m_pDataReader)
    {
        //only external data reader supported
        return UMC_NULL_PTR;
    }

    //choose a splitter
    SystemStreamType sys_type = DetectSystem();

    switch(sys_type)
    {
    case MPEG2_TRANSPORT_STREAM:
    case MPEG2_TRANSPORT_STREAM_TTS:
        p_spl1 = new UMC::MPEG2TSSplitter;
        break;
    case MPEG2_PROGRAMM_STREAM:
    case MPEG2_PES_PACKETS_STREAM:
        p_spl1 = new UMC::MPEG2PSSplitter;
        break;
    case MPEG2_PURE_VIDEO_STREAM:
        p_spl1 = new UMC::MPEG2VideoSplitter;
        break;
    case H264_PURE_VIDEO_STREAM:
        p_spl1 = new UMC::H264VideoSplitter;
        break;
    case MPEG4_PURE_VIDEO_STREAM:
        p_spl1 = new UMC::MPEG4VideoSplitter;
        break;
    case MPEGx_PURE_AUDIO_STREAM:
        p_spl1 = new UMC::MPEG2AudioSplitter;
        break;
    case H261_PURE_VIDEO_STREAM:
        p_spl1 = new UMC::H261VideoSplitter;
        break;
    case H263_PURE_VIDEO_STREAM:
        p_spl1 = new UMC::H263VideoSplitter;
        break;
    }

    if(!p_spl1)
        return UMC_ALLOC;

    res = p_spl1->Init(init);

    if(UMC_OK == res)
        m_pSpl = p_spl1;
    else
        m_pSpl = NULL;

    return res;
}

UMC::SystemStreamType UMC::MPEG2Splitter::DetectSystem()
{
    unsigned char    code1;
    unsigned int    code2;
    Status          umcSts  = UMC_OK;

    umcSts = m_pDataReader->CheckByte(&code1, 0);
    if(UMC_OK != umcSts) return UNDEF_STREAM;

    umcSts = m_pDataReader->CheckUInt(&code2, 0);
    if(UMC_OK != umcSts) return UNDEF_STREAM;

    //search some MPEG2 PS start code, it can start from bunch of zeros before
    if(0 == code2)
    {
        int check_counter = 1;
        while(0 == code2)
        {
            umcSts = m_pDataReader->CheckUInt(&code2,check_counter);
            if(UMC_OK != umcSts) return UNDEF_STREAM;

            check_counter++;

        }

        umcSts = m_pDataReader->CheckUInt(&code2,check_counter);
        if(UMC_OK != umcSts) return UNDEF_STREAM;

        if((code2 & 0x0000fff0) == 0x0000fff0)
        {
            return MPEGx_PURE_AUDIO_STREAM;
        }
    }

    //check if transport stream, 0x47 is sync byte for it
    if(code1 == ID_TS_SYNC_BYTE)
    {
        return MPEG2_TRANSPORT_STREAM;
    }
    //check if program stream
    else if(code2 == ID_PS_PACK_START_CODE || (code2&0xFFFFFFFC) == 0x000001BC)
    {
        return MPEG2_PROGRAMM_STREAM;
    }
    //check if PES stream,
    //0x000001C0 < audio < 0x000001DF
    //0x000001E0 < audio < 0x000001EF
    else if(((code2 >= 0x000001C0) && (code2 <= 0x000001DF)) ||
            ((code2 >= 0x000001E0) && (code2 <= 0x000001EF)))
    {
        return MPEG2_PES_PACKETS_STREAM;
    }
    //check if MPEG2 Sequence or Picture start code
    else if(code2 == SEQUENCE_HEADER_CODE || (code2 & (~0xff)) == PICTURE_START_CODE)
    {
        vm_var32 size           = 32*1024;
        unsigned char * pData;
        ParseMP4Header* mp4_dec  = new ParseMP4Header;
        UMC::SystemStreamType  type;
        pData        = ippsMalloc_8u(size);
        if(!pData) return UNDEF_STREAM;

        m_pDataReader->CheckData(pData, &size, 0);

        if(mp4_dec->Init(pData, size) == UMC_OK)
        {
            type =  MPEG4_PURE_VIDEO_STREAM;
        }
        else if(code2 == SEQUENCE_HEADER_CODE || (code2 == PICTURE_START_CODE))
        {
            type = MPEG2_PURE_VIDEO_STREAM;
        }
        else if((code2&0x1f) == 7)
        {
            type = H264_PURE_VIDEO_STREAM;
        }
        ippsFree(pData);
        delete mp4_dec;
        return type;

    }
    else if(((code2 & 0xfffffc00) == 0x00008000))
    {
        //H.263 pure video
        return H263_PURE_VIDEO_STREAM;
    }

    else if(((code2 & 0xfffff000) == 0x00010000))
    {
        //H.261 pure video
        return H261_PURE_VIDEO_STREAM;
    }
    //pure H.264 video
    else if((code2&0x1f) == 7 || (code2 == 0x00000001))
    {
        return H264_PURE_VIDEO_STREAM;
    }
    //maybe audio stream, mp3 for example
    //Checking for MP3 and ID3 headers
    else if(((code2 & 0xfff00000) == 0xfff00000) ||
            ((code2 & 0xffffff00) == 0x49443300) || ((code2 == 0)))
    {
        return MPEGx_PURE_AUDIO_STREAM;

    }
    //audio stream, AC3
    else if((code2 & 0xffff0000) == AC3_SYNC_WORD)
    {
        return MPEGx_PURE_AUDIO_STREAM;
    }
    //overload this function to check other formats
    //if operation was successful next basic field must be filled:
    //m_sSplInfo.m_splitter_flags;
    //m_sSplInfo.m_splitter_flags;
    //m_bIgnoreVideo;
    //m_sSplInfo.m_system_info.stream_type;
    //m_sSplInfo.m_audio_info.stream_type;

    //by default it returns not UMC_OK and nothing does

    //last chanse
    {
    unsigned char byte_code;
    unsigned char byte_code1;
    umcSts = m_pDataReader->CheckByte(&byte_code,4);
    if(UMC_OK != umcSts) return UNDEF_STREAM;

    umcSts = m_pDataReader->CheckByte(&byte_code1,196);
    if(UMC_OK != umcSts) return UNDEF_STREAM;

    if((byte_code == 0x47) && (byte_code1 == 0x47))
    {
     //mpeg2 ts tts
        return MPEG2_TRANSPORT_STREAM_TTS;
    }
    }

    //don't have more idea
    return UNDEF_STREAM;
}


UMC::Status UMC::MPEG2Splitter::Close()
{
    UMC::Status ret;
    if(m_pSpl)
    {
        ret = m_pSpl->Close();
        delete m_pSpl;
        m_pSpl = NULL;
    }

    return ret;
}

UMC::Status UMC::MPEG2Splitter::Run()
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->Run();

    return ret;
}

UMC::Status UMC::MPEG2Splitter::Stop()
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->Stop();

    return ret;
}

UMC::Status UMC::MPEG2Splitter::GetNextVideoData(MediaData* data, vm_var32 track_idx)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret =  m_pSpl->GetNextVideoData(data, track_idx);

    return ret;
}

UMC::Status UMC::MPEG2Splitter::CheckNextVideoData(MediaData* data, vm_var32 track_idx)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret =  m_pSpl->CheckNextVideoData(data, track_idx);

    return ret;
}


UMC::Status UMC::MPEG2Splitter::CheckNextAudioData(MediaData* data, vm_var32 track_idx)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret =  m_pSpl->CheckNextAudioData(data, track_idx);

    return ret;
}


UMC::Status UMC::MPEG2Splitter::GetNextAudioData(MediaData* data, vm_var32 track_idx)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret =  m_pSpl->GetNextAudioData(data, track_idx);

    return ret;
}

UMC::Status UMC::MPEG2Splitter::SetPosition(double pos)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->SetPosition(pos);

    return ret;
}

UMC::Status UMC::MPEG2Splitter::SetPosition(double start, double stop)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->SetPosition(start, stop);

    return ret;
}

UMC::Status UMC::MPEG2Splitter::GetPosition(double& pos)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->GetPosition(pos);

    return ret;
}


UMC::Status UMC::MPEG2Splitter::GetInfo(UMC::SplitterInfo* info)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->GetInfo(info);

    return ret;
}


UMC::AudioStreamType UMC::MPEG2Splitter::GetAudioType (void)
{
    AudioStreamType ret = UNDEF_AUDIO;

    if(m_pSpl)
        ret = m_pSpl->GetAudioType();

    return ret;
}

UMC::Status UMC::MPEG2Splitter::GetNextData(MediaData* data, vm_var32* stream_id)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->GetNextData(data, stream_id);

    return ret;
}

UMC::Status MPEG2Splitter::SetRate(double rate)
{
    Status ret = UMC_NOT_INITIALIZED;

    if(m_pSpl)
        ret = m_pSpl->SetRate(rate);

    return ret;
}