M4MotionVectorMgr.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "vdecmpeg4.h"
#include "M4Decoder.h"
#include "M4Memory.h"
#include "M4Global.h"
#include "M4MemOps.h"
 
namespace vdecmpeg4
{
 
class M4MotionVectorMgr
{
public:
    static M4MotionVectorMgr* create(M4Decoder* pDecoder, M4MemHandler& memSys);
 
    static void destroy(M4MotionVectorMgr*& pMgr, M4MemHandler& memSys);
 
    // -----------------------------------------------------------------------------------------
 
    void init();
 
    void readMvForward(M4_MB* mb);
 
    void predictAddForward(M4_MB* mb, int32 mbx, int32 mby);
 
    void addMv(M4_VECTOR& res, uint16 code, const M4_VECTOR& inputMv, const M4_VECTOR& predictor)
    {
        int32 scale_fac = 1 << (code - 1);
        int32 high = (32 * scale_fac) - 1;
        int32 low = (-32 * scale_fac);
        int32 range = (64 * scale_fac);
 
        res.x = predictor.x + inputMv.x;
        res.y = predictor.y + inputMv.y;
 
        if (res.x < low)
        {
            res.x += range;
        }
        else if (res.x > high)
        {
            res.x -= range;
        }
 
        if (res.y < low)
        {
            res.y += range;
        }
        else if (res.y > high)
        {
            res.y -= range;
        }
    }
 
    void addMvForward(M4_VECTOR& res, const M4_VECTOR& inputMv, const M4_VECTOR& predictor)
    {
        // Add input motion vector to predictor
        res.x = inputMv.x + predictor.x;
        res.y = inputMv.y + predictor.y;
 
        // clipping
        if (res.x < mMvClipLow)
        {
            res.x += mMvClipRange;
        }
        else if (res.x > mMvClipHigh)
        {
            res.x -= mMvClipRange;
        }
 
        if (res.y < mMvClipLow)
        {
            res.y += mMvClipRange;
        }
        else if (res.y > mMvClipHigh)
        {
            res.y -= mMvClipRange;
        }
    }
 
    void readMv(M4_VECTOR& res, uint16 code)
    {
        // Get the differential motion vector (MVDx, MVDy) from the bitstream
        res.x = mDecoder->mBitstreamParser.getMv(code);
        res.y = mDecoder->mBitstreamParser.getMv(code);
    }
 
    static const M4_VECTOR MV_ZERO;
 
    void* operator new(size_t sz, M4MemHandler& memSys);
    void operator delete(void* ptr);
 
private:
 
    M4MotionVectorMgr(M4Decoder* decoder);
 
    ~M4MotionVectorMgr()
    {
    }
 
    void _predictMv(M4_VECTOR& res, int32 mbx, int32 mby, uint32 block);
 
    M4MotionVectorMgr();
 
    M4MotionVectorMgr(const M4MotionVectorMgr &pObj);
 
    const M4MotionVectorMgr &operator=(const M4MotionVectorMgr &pObj);
 
    int32       mMvClipHigh;        
    int32       mMvClipLow;         
    int32       mMvClipRange;       
 
    M4Decoder*  mDecoder;
 
    M4_MEMORY_HANDLER
};
 
 
inline void M4MotionVectorClear(M4_MB* mb)
{
    FMemory::Memzero(mb->mFMv, sizeof(M4_VECTOR)*4);
    mb->mMvResidual = 0;
}
 
}