M4Decoder.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "vdecmpeg4.h"
#include "M4Global.h"
#include "M4BitstreamParser.h"
#include "M4Prediction.h"
#include "M4XCmdSingleThread.h"
 
namespace vdecmpeg4
{
class M4Image;
class M4MotionVectorMgr;
class VIDStream;
 
// Linear texture
#define M4_MEM_OFFSET_LEFT_BLOCK    8   // 8 bytes
#define M4_MEM_SHIFT_MB_TO_Y        4   // * 16
#define M4_MEM_SHIFT_MB_TO_UV       3   // * 8
 
 
class M4Decoder
{
public:
    static M4Decoder* create(M4MemHandler& memHandler);
 
    static void destroy(M4Decoder*& pDecoder, M4MemHandler& memHandler);
 
    VIDError init(const VIDDecoderSetup* setup);
 
    VIDError initBuffers(int16 width, int16 height);
 
    //-------------------------------------------------------------------------
 
    VIDError StreamSet(VIDStreamIO* pStream, VIDStreamEvents* pEvents);
 
    VIDError StreamDecode(float time, const VIDImage** result);
 
 
    //-------------------------------------------------------------------------
 
    VIDError StreamEventsSet(VIDStreamEvents* pEvents)
    {
        mpStreamEvents = pEvents;
        return VID_OK;
    }
 
 
 
 
    VIDError StreamSeekNotify();
 
private:
    M4Decoder(M4MemHandler& memHandler);
 
    ~M4Decoder();
 
    VIDError iFrame();
 
    VIDError pFrame(bool gmc);
 
    VIDError bFrame();
 
    void mbIntra(M4_MB* mb, int32 x, int32 y, bool useACPredition, uint32 cbp, uint8 quant);
 
    void mbInter(M4_MB* mb, int32 x, int32 y, uint32 cbp, MV_PREDICTION mvPrediction, uint32 refImgNo);
 
    void mbInterpolate(uint32 refImgForward, uint32 refImgBackward, M4_MB* mb, int32 mbx, int32 mby, uint32 cbp, uint16 mbLastIdx = 0);
 
    M4Decoder();
 
    M4Decoder(const M4Decoder& pObj);
 
    void freeStuff();
 
    void freeBuffers();
 
    M4Image* AllocVidFrame();
 
    const M4Decoder& operator=(const M4Decoder& pObj);
 
private:
    int16                   mWidth;                 
    int16                   mHeight;                
 
    uint16                  mMBWidth;               
    uint16                  mMBHeight;              
 
    uint32                  mDecoderFlags;          
 
    M4Image*                mCurrent;
 
    M4Image*                mReference[2];
 
    M4Image*                mTempImage[2];
 
    M4_MB*                  mIPMacroblocks;         
    M4_MB*                  mBMacroblocks;          
 
    M4MotionVectorMgr*      mMotVecMgr;
 
    M4Bitstream             mBitstream;
    M4BitstreamParser       mBitstreamParser;       
 
    M4Image**               mpVidImage;
    uint32                  mNumVidImages;
 
 
    uint32                  mFrameCounter;
    M4BitstreamCache        mBitstreamCache;
 
    VIDStreamIO*            mpStreamIO;         
    VIDStreamEvents*        mpStreamEvents;
 
    M4XCmdSingleThread      mXCommand;
 
    friend class M4MotionVectorMgr;
    friend class M4Image;
 
public:
 
    void* operator new(size_t sz, M4MemHandler& memSys)
    {
        return memSys.malloc(sz);
    }
    void operator delete(void* ptr)
    {
        ((M4Decoder*)ptr)->mMemSys.free(ptr);
    }
    static const int32      mDequantTable[4];
    static const uint32     mRoundtab[16];
    static const uint8      mIntraMacroBlocks[8];
 
    M4MemHandler mMemSys;
 
    M4_MEMORY_HANDLER
 
#ifdef _M4_ENABLE_BMP_OUT
    void SetVideoOutToBMP(const char* pFileBaseName);
    char mBaseName[256];
#endif
 
    friend class M4XCmdSingleThread;    // temp hack
 
    void (*mCbPrintf)(const char *pMessage);
    void VIDPrintf(const char *pFormat, ...);
};
 
}