umc_frame_constructor.h

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

        Ipp32s m_iReadyBits;
    };

    // object extends base bitstream reader for h264 video
    // it removes start code emulation prevention bytes
    class H264BitstreamReader : public BitstreamReader
    {
    public:
        // Constructor
        H264BitstreamReader(void);
        // Function is overloaded for resetting of m_iZeroes
        void Init(Ipp8u *pStream);

    protected:
        // Function is overloaded for removing prevention bytes
        virtual void Refresh(void);

    protected:
        // amount of sequential zeroes
        Ipp32s m_iZeroes;
    };

    class FrameConstructorParams : public MediaReceiverParams
    {
        DYNAMIC_CAST_DECL(FrameConstructorParams, MediaReceiverParams)

    public:
        // constructor-initializer
        FrameConstructorParams();

        // pointer to heritable ESInfo (may be NULL if inheritance isn't needed)
        Mpeg2TrackInfo *m_pInfo;
        // size of buffer to allocate
        size_t m_lBufferSize;
        // initial number of samples in buffer (might be dynamically allocated if needed)
        Ipp32u m_nOfFrames;
        // pointer to memory allocator object (if NULL it will be created internally)
        MemoryAllocator *m_pMemoryAllocator;
    };

    // base class for all frame constructors
    // it implements most of functionality
    // that can be extended by by derived classes or used directly
    // the most important fuction to implement is GetFrame()
    // that actually performs frame constructing
    class FrameConstructor : public MediaBuffer
    {
        DYNAMIC_CAST_DECL(FrameConstructor, MediaBuffer)

    public:
        // constructor
        FrameConstructor();
        // destructor
        ~FrameConstructor();

        // inherited from base MediaBuffer
        virtual Status Init(MediaReceiverParams *pInit);
        virtual Status Close();
        virtual Status Reset();
        virtual Status Stop();
        virtual Status LockInputBuffer(MediaData *in);
        virtual Status UnLockInputBuffer(MediaData *in, Status streamStatus = UMC_OK);
        virtual Status LockOutputBuffer(MediaData *out);
        virtual Status UnLockOutputBuffer(MediaData *out);

        // resets tailing bytes after last constracted sample
        virtual Status SoftReset();
        // sets playback rate, affects only video frame constructors
        virtual void SetRate(Ipp64f dRate);
        // unlocks input buffer and tries to construct frame
        // but constructed frame is uncommited (can be rolled back)
        virtual Status PreUnLockInputBuffer(MediaData *in, Status streamStatus = UMC_OK);
        // returns last constructed frame
        virtual Status GetLastFrame(MediaData *data);
        // returns pointer to ESInfo
        virtual Mpeg2TrackInfo *GetInfo(void);

    protected:
        virtual Status GetFrame(SplMediaData *frame);
        virtual Status GetSampleFromQueue(FCSample *pSample);
        void AssignAbsPos(Ipp32s iPos);
        void AssignTimeStamps(Ipp32s iPos);

        // synchro object
        vm_mutex m_synchro;

        // pointer to allocated buffer
        Ipp8u *m_pBuf;
        // memory ID of allocated buffer
        MemID m_midAllocatedBuffer;

        // frame being constructed
        FCSample m_CurFrame;
        // queue of output samples
        ReorderQueue m_OutputQueue;
        // index of first-to-decode sample
        Ipp32s m_iFirstInDecOrderIdx;
        // last constructed frame
        SplMediaData m_LastFrame;
        // previous input sample
        FCSample m_PrevSample;
        // last input sample
        FCSample m_LastSample;

        // indicates end of stream
        bool m_bEndOfStream;
        // is output buffer locked
        bool m_bIsOutputBufferLocked;
        // is info filled, this is needed to prevent info changing
        bool m_bInfoFilled;

        // size of allocated buffer
        Ipp32s m_lBufferSize;
        // position in buffer of byte after last data byte
        Ipp32s m_lLastBytePos;
        // position in buffer of first data byte
        Ipp32s m_lFirstBytePos;
        // current position in buffer
        Ipp32s m_lCurPos;
        // position in buffer of picture start code of frame being constuncted
        Ipp32s m_lCurPicStart;

        // playback rate
        Ipp64f m_dRate;
        // number of commited frames
        Ipp32u m_uiCommitedFrames;
        // total number of frames in buffer
        Ipp32u m_uiTotalFrames;
        // actual size of user data
        Ipp32s m_iCurrentLevel;
        // pointer to info structure
        Mpeg2TrackInfo *m_pInfo;
    };

    class AudioFrameConstructor : public FrameConstructor
    {
    public:
        static const AudioStreamType MpegAStreamType[2][3];
        static const Ipp32s MpegAFrequency[3][4];
        static const Ipp32s MpegABitrate[2][3][15];
        static const Ipp32s MpegAChannels[4];
        static const Ipp32s AC3Frequency[3];
        static const Ipp32s AC3FrequencyExt[8];
        static const Ipp32s AC3BitRate[19];
        static const Ipp32s AC3NumChannels[];
        static const Ipp32f MpegAFramesize[2][4];
        static const Ipp32s AACFrequency[16];
        static const Ipp32s AACChannels[16];
        static const Ipp32s DTSChannels[16];
        static const Ipp32s DTSFrequency[16];
        static const Ipp32s DTSBitrate[32];
        static const Ipp32s LPCMChannels[16];
        Status Init(MediaReceiverParams *pInit);
    protected:
        // parses headers of all supported audio
        Status ParseHeader();
        // indicate if header parsed
        bool m_bHeaderParsed;
    };

    class TimeStampedAudioFrameConstructor : public AudioFrameConstructor
    {
    public:
        Status GetFrame(SplMediaData *frame);
    };

    class BufferedAudioFrameConstructor : public AudioFrameConstructor
    {
    public:
        Status GetFrame(SplMediaData *frame);
    };

    class PureAudioFrameConstructor : public AudioFrameConstructor
    {
    public:
        Status GetFrame(SplMediaData *frame);
    };

    class VideoFrameConstructor : public FrameConstructor
    {
    public:
        VideoFrameConstructor(void);
        virtual Status Init(MediaReceiverParams *pInit);
        virtual Status Reset(void);
        virtual Status SoftReset(void);
        virtual void SetRate(Ipp64f dRate);
        virtual bool IsFrameStartFound(void);

    protected:
        // find next sample to output, performs reordering at backward
        virtual Status GetSampleFromQueue(FCSample *pSample);
        // returns true when sample such sample is allowed at playback rate
        bool IsSampleComplyWithTmPolicy(FCSample &sample, Ipp64f dRate);
        // is sequence header found and parsed
        bool m_bSeqSCFound;
        // is picture header found and parsed
        bool m_bPicSCFound;
        // is start of frame found
        bool m_bFrameBegFound;
        // FrameConstructor generate 4-zero sequence at the end of last video frame
        bool m_bIsFinalizeSequenceSent;
    };

    class Mpeg2FrameConstructor : public VideoFrameConstructor
    {
    public:
        // parses sequence header and fills info if passed
        static Status ParseSequenceHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo);
        // parses picture header and sets interlace_type field if info struct passed
        static Status ParsePictureHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo);
        // mpeg1/2 frame rate values
        static const Ipp64f FrameRate[9];
        // mpeg1 aspect ratio valus
        static const Ipp64f AspectRatioMp1[15];
        // mpeg2 aspect ratio valus
        static const Ipp32s AspectRatioMp2[5][2];
    protected:
        virtual Status GetFrame(SplMediaData *frame);
    };

    class Mpeg4FrameConstructor : public VideoFrameConstructor
    {
    public:
        // parses video object layer header and fills info if passed
        static Status ParseVideoObjectLayer(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo);
        // mpeg4 aspect ratio values
        static const Ipp32s AspectRatio[6][2];
    protected:
        virtual Status GetFrame(SplMediaData *frame);
    };

    class H261FrameConstructor : public VideoFrameConstructor
    {
    public:
        // parses h261 header and fills info if passed
        static Status ParseHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo);
    protected:
        virtual Status GetFrame(SplMediaData *frame);
    };

    class H263FrameConstructor : public VideoFrameConstructor
    {
    public:
        // parses h263 header and fills info if passed
        static Status ParseHeader(Ipp8u *buf, Ipp32s iLen, Mpeg2TrackInfo *pInfo);
        // valid frame sizes for h263 video
        static const Ipp16s PictureSize[6][2];
    protected:
        virtual Status GetFrame(SplMediaData *frame);
    };

    enum
    {
        NALU_SLICE      = 0x01,
        NALU_IDR_SLICE  = 0x05,
        NALU_SEI        = 0x06,
        NALU_SPS        = 0x07,
        NALU_PPS        = 0x08,
        NALU_DELIMITER  = 0x09
    };

    class H264FrameConstructor : public VideoFrameConstructor
    {
    public:
        // parses SPS NAL unit, stores interesting params into header set and fills info if passed
        static Status ParseSequenceParameterSet(Ipp8u *buf, Ipp32s iLen, H264HeaderSet *pHeaders, Mpeg2TrackInfo *pInfo);
        // parses PPS NAL unit, stores interesting params into header set
        static Status ParsePictureParameterSet(Ipp8u *buf, Ipp32s iLen, H264HeaderSet *pHeaders);
        // parses slice header, stores interesting params into header set and sets interlace_type field if info strunct passed
        static Status ParseSliceHeader(Ipp8u *buf, Ipp32s iLen, H264HeaderSet *pHeaders, Mpeg2TrackInfo *pInfo);
        // compares two last slice headers to decide is last slice from the same AU or from the next one
        static bool IsFirstVLCNALUnit(H264HeaderSet *pHeaders);
        // h264 aspect ratio valus
        static const Ipp16u AspectRatio[14][2];
        // slice types
        static const FrameType SliceType[10];

        virtual Status Init(MediaReceiverParams *pInit);
        virtual Status Reset(void);
        virtual Status SoftReset(void);

    protected:
        virtual Status GetFrame(SplMediaData *frame);
        bool IsSampleComplyWithTmPolicy(FCSample &sample, Ipp64f dRate);

        // store of all headers
        H264HeaderSet m_h264Headers;
        // is first VLC NAL unit of current AU detected
        bool m_bFirstVLCNALUnitDetected;
        // is current AU corrupted (e.g. refers to invalid SPS/PPS)
        bool m_bIsCorrupted;
    };

    class PesFrameConstructor : public FrameConstructor
    {
    public:
        virtual Status Init(MediaReceiverParams *pInit);
        virtual Status Reset(void);
        virtual Status SoftReset(void);

    protected:
        virtual Status GetFrame(SplMediaData *frame);

    protected:
        bool m_bIsFirst;
    };

}

#endif /* __UMC_FRAME_CONSTRUCTOR_H__ */