M4Bitstream.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "vdecmpeg4.h"
#include "vdecmpeg4_Stream.h"
#include "M4Memory.h"
 
namespace vdecmpeg4
{
 
#if 1   // Little endian platform
inline uint32 XSWAP(uint32 value)
{
    return (value << 24) | ((value & 0xff00) << 8) | ((value >> 8) & 0xff00) | (value >> 24);
}
#else
#define XSWAP(a)    (a)
#endif
 
 
class M4Bitstream
{
public:
    M4Bitstream();
 
    ~M4Bitstream();
 
    void setMemoryHook(M4MemHandler& memSys);
 
    void init(const uint8* bitstream, uint32 length);
 
    void init(VIDStreamIO* pStream, uint32 streamBufferBytes);
 
    uint32 show(const uint32 bits);
 
    void skip(const uint32 bits);
 
    void align();
 
    void nextStartCode();
    void nextResyncMarker();
    void skipResyncMarker();
 
    uint32 showBitsByteAligned(const uint32 bits);
 
    bool validStuffingBits();
 
    uint32 getBits(const uint32 bits);
 
    uint32 getBit();
 
    bool isEof();
 
    void totalBitsClear();
 
    uint32 totalBitsGet() const;
 
    const uint32* getBaseAddr() const;
 
private:
    VIDError ReadStreamBuffered(uint32& value);
 
    M4Bitstream(const M4Bitstream& pObj);
 
    const M4Bitstream& operator=(const M4Bitstream& pObj);
 
    uint32          mAWord;
    uint32          mBWord;
 
    uint32          mPos;
    uint32*         mTail;
 
    uint32          mLength;            
    uint32*         mStart;             
 
    VIDStreamIO*    mpStreamIO;         
 
    uint8*          mpInternalBuffer;
    uint32          mInternalBufferBytes;
    uint32          mInternalBufferCurrentBytes;
    uint32          mInternalBufferIndex;
 
    M4MemHandler*   mpMemSys;           
 
    uint32          mTotalBits;         
 
};
 
/******************************************************************************
 *  INLINE FUNCTIONS
 ******************************************************************************/
 
// ----------------------------------------------------------------------------
inline void M4Bitstream::totalBitsClear()
{
    mTotalBits = 0;
}
 
 
 
 
// ----------------------------------------------------------------------------
inline M4Bitstream::M4Bitstream()
    : mTail(nullptr)
    , mLength(0)
    , mStart(nullptr)
    , mpStreamIO(nullptr)
    , mpInternalBuffer(nullptr)
    , mInternalBufferBytes(0)
    , mInternalBufferCurrentBytes(0)
    , mInternalBufferIndex(0)
    , mpMemSys(nullptr)
    , mTotalBits(0)
{
}
 
 
// ----------------------------------------------------------------------------
inline M4Bitstream::~M4Bitstream()
{
    if (mpInternalBuffer && mpMemSys)
    {
        mpMemSys->free(mpInternalBuffer);
    }
}
 
 
// ----------------------------------------------------------------------------
inline void M4Bitstream::setMemoryHook(M4MemHandler& memSys)
{
    mpMemSys = &memSys;
}
 
 
inline void M4Bitstream::init(const uint8* bitstream, uint32 length)
{
    mStart = mTail = (uint32*)bitstream;
    // initialize 'working' words with 1st 64 bits from stream
    mAWord = XSWAP(mStart[0]);
    mBWord = XSWAP(mStart[1]);
    mPos = 0;
 
    mLength = length;
 
    mpStreamIO = nullptr;
    if (mpInternalBuffer)
    {
        mpMemSys->free(mpInternalBuffer);
    }
    mpInternalBuffer = nullptr;
    totalBitsClear();
}
 
 
// ----------------------------------------------------------------------------
inline VIDError M4Bitstream::ReadStreamBuffered(uint32& value)
{
    if (mInternalBufferIndex >= mInternalBufferCurrentBytes)
    {
        mInternalBufferIndex = 0;
        VIDStreamResult result = mpStreamIO->Read(mpInternalBuffer, mInternalBufferBytes, mInternalBufferCurrentBytes);
        if (result != VID_STREAM_OK)
        {
            value = 0;
            mInternalBufferCurrentBytes = 0;
            return result == VID_STREAM_EOF ? VID_ERROR_STREAM_EOF : VID_ERROR_STREAM_ERROR;
        }
        else
        {
            // Check returned data is multiple of 4bytes
            M4CHECK((mInternalBufferCurrentBytes & 0x3) == 0 );
            // Check if returned ANY result
            M4CHECK( mInternalBufferCurrentBytes > 0 );
        }
    }
    value = *((uint32*)(mpInternalBuffer + mInternalBufferIndex));
    mInternalBufferIndex += 4;
    return VID_OK;
}
 
 
// ----------------------------------------------------------------------------
inline void M4Bitstream::init(VIDStreamIO* pStreamIO, uint32 streamBufferBytes)
{
    M4CHECK(streamBufferBytes > 0);
 
    mpStreamIO = pStreamIO;
 
    if (mpInternalBuffer)
    {
        mpMemSys->free(mpInternalBuffer);
    }
    mInternalBufferBytes = streamBufferBytes;
    mpInternalBuffer = (uint8*)mpMemSys->malloc(mInternalBufferBytes);
    mInternalBufferCurrentBytes = 0;
    mInternalBufferIndex = 0;
 
    // Read initial chunk of data
    uint32 value;
    ReadStreamBuffered(value);
    mAWord = XSWAP(value);
 
    ReadStreamBuffered(value);
    mBWord = XSWAP(value);
 
    // initialize 'working' words with 1st 64 bits from stream
    mPos = 0;
    mLength = 0;
 
    mStart = mTail = nullptr;
    totalBitsClear();
}
 
inline uint32 M4Bitstream::show(const uint32 bits)
{
    M4CHECK(bits>0 && bits<=32);
    uint32 res2;
    int32 nbit = (int32)bits + int32(mPos - 32);
    if (nbit > 0)
    {
        res2 = ((mAWord & (0xffffffff >> mPos)) << nbit) | (mBWord >> (32 - nbit));
    }
    else
    {
        res2 = (mAWord & (0xffffffff >> mPos)) >> (32 - mPos - bits);
    }
    return res2;
}
 
inline void M4Bitstream::skip(uint32 bits)
{
    M4CHECK(bits>0 && bits<=32);
    mPos += bits;           // advance bit position pointer
    mTotalBits += bits;
    if (mPos >= 32)
    {
        mAWord = mBWord;
        if (mpStreamIO)
        {
            uint32 value;
            ReadStreamBuffered(value);
            mBWord = XSWAP(value);
        }
        else
        {
            mBWord = XSWAP(*(mTail+2));
            mTail++;
        }
        mPos -= 32;
    }
}
 
 
// ----------------------------------------------------------------------------
inline bool M4Bitstream::isEof()
{
    return mpStreamIO ? mpStreamIO->IsEof() : ((8 * 4 * (mTail - mStart) + mPos)>>3) >= mLength;
}
 
inline void M4Bitstream::align()
{
    uint32 remainder = mPos & 7;
    if (remainder)
    {
        skip(8 - remainder);
    }
}
 
 
// ----------------------------------------------------------------------------
inline void M4Bitstream::nextStartCode()
{
    uint32 zeroBit = getBit();
    (void)zeroBit;
    M4CHECK(zeroBit == 0);
    while((mPos & 7) != 0)
    {
        uint32 oneBit = getBit();
        (void)oneBit;
        M4CHECK(oneBit == 1);
    }
}
 
inline void M4Bitstream::nextResyncMarker()
{
    // This is the same as nextStartCode(), actually...
    nextStartCode();
}
 
inline void M4Bitstream::skipResyncMarker()
{
    // Resync marker is at least 16 zero bits followed by a one.
    // The number of zero bits varies depending on the VOP type, but syntactically it is always the same
    // so we can simply skip over zero bits and one 1 bit.
    while(getBit() == 0)
    {
    }
}
 
 
// ----------------------------------------------------------------------------
inline uint32 M4Bitstream::showBitsByteAligned(const uint32 bits)
{
    M4CHECK(bits>0 && bits<=23);
 
    uint32 rem = mPos & 7;
    if (rem == 0)
    {
        // Are the next 8 bits an end marker?
        if (show(8) == 0x7f)
        {
            // Yes. This must be skipped and the next n bits returned.
            uint32 v = show(8 + bits);
            return v & (0xffffffff >> (32 - bits));
        }
        else
        {
            return show(bits);
        }
    }
    else
    {
        uint32 v = show(8 - (mPos & 7) + bits);
        return v & (0xffffffff >> (32 - bits));
    }
}
 
// ----------------------------------------------------------------------------
inline bool M4Bitstream::validStuffingBits()
{
    static const uint8 stuffing[8] = { 0x7f, 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01, 0x00 };
    uint32 rb = mPos & 7;
    if (rb == 0)
    {
        return show(8) == 0x7f;
    }
    else
    {
        uint32 rem = show(8 - rb);
        return rem == stuffing[rb];
    }
}
 
 
inline uint32 M4Bitstream::getBits(const uint32 bits)
{
    uint32 ret = show(bits);
    skip(bits);
    return ret;
}
 
inline uint32 M4Bitstream::getBit()
{
    return getBits(1);
}
 
// ----------------------------------------------------------------------------
inline uint32 M4Bitstream::totalBitsGet() const
{
    return mTotalBits;
}
 
// ----------------------------------------------------------------------------
inline const uint32* M4Bitstream::getBaseAddr() const
{
    return (const uint32*)mStart;
}
 
 
}