GxMotionEncoder.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
#include <assert.h>
#include <vector>
 
using namespace ::gx::core;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class KeyCache
{
public:
    KeyCache(void) : _x(0.0f){}
    f32 _x;     
};
 
namespace NEW_MOTION_ENCODER
{
    //-----------------------------------------------------------------------------
    // カーブヘッダWORD
    //-----------------------------------------------------------------------------
    union Header
{
#if GX_BIG_ENDIAN
    struct {
        u16 _flags;                 
        u16 _frames;                
        union
        {
            struct
            {
                u8  _gap;           
                s8  _decimalBit;    
                u16 _param;         
            };
            f32 _constantValue;     
        };
    };
    u32     _d[2];                  
#else //GX_BIG_ENDIAN
    struct
    {
        u16 _frames;                
        u16 _flags;                 
        union
        {
            struct
            {
                u16 _param;         
                s8  _decimalBit;    
                u8  _gap;           
            };
            f32 _constantValue;     
        };
    };
    u32     _d[2];                  
#endif // !GX_BIG_ENDIAN
};
 
// Header::flags のフラグ定義
#define KEYFRAME_INTERVAL_MASK          0x0001  // キーフレームの間隔マスク
#define KEYFRAME_CONSTANT_INTERVAL      0x0000  // 一定間隔でのキーフレーム
#define KEYFRAME_SPECIFY_POSITION       0x0001  // フレーム位置を指定(未実装)
#define KEYFRAME_SHORT_TYPE             0x0002  // キーフレームの型は short 型
#define CONSTANT_DATA                   0x0004  // 完全な定数データ
#define KEYFRAME_RAWDATA                0x0008  // 完全な無圧縮データ
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
union KeyFrame
{
    struct
    {
        s32     _x0;        
        s32     _v0;        
    };
    u32 _d[2];              
};
 
// キーフレーム参照配列に、キーフレームが定数であることを示すビット
#define KEYFRAME_CONSTANT_VALUE         0x8000
 
//-----------------------------------------------------------------------------
// キーフレームWORD(int16_t型)
//-----------------------------------------------------------------------------
union KeyFrameShort
{
    struct
    {
#if GX_BIG_ENDIAN
        s16     _v0;            
        s16     _x0;            
#else //GX_BIG_ENDIAN
        s16     _x0;            
        s16     _v0;            
#endif // !GX_BIG_ENDIAN
    };
    f32     _constantValue;     
    u32     _d[1];              
};
 
//-----------------------------------------------------------------------------
// ビット幅変更WORD
//-----------------------------------------------------------------------------
union BitWidthChange
{
    struct
    {
#if GX_BIG_ENDIAN
        s16     _b;     
        u8      _w;     
        u8      _c;     
#else //GX_BIG_ENDIAN
        u8      _c;     
        u8      _w;     
        s16     _b;     
#endif // !GX_BIG_ENDIAN
    };
    u32     _d[1];      
};
 
// BitWidthChange::w(圧縮率)の定義
#define COMPRATE_2BIT       0
#define COMPRATE_3BIT       1
#define COMPRATE_4BIT       2
#define COMPRATE_5BIT       3
#define COMPRATE_6BIT       4
#define COMPRATE_8BIT       5
#define COMPRATE_16BIT      6
#define COMPRATE_32BIT      7
#define COMPRATE_RUNLENGTH  8
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
struct CompressBitType
{
    u32 _bitPerFrame;   
    u32 _framePerBlock; 
};
 
const CompressBitType COMPRESS_BIT_TYPE_TABLE[] = 
{
    { 2, 16 },  // COMPRATE_2BIT
    { 3, 10 },  // COMPRATE_3BIT
    { 4, 8 },   // COMPRATE_4BIT
    { 5, 6 },   // COMPRATE_5BIT
    { 6, 5 },   // COMPRATE_6BIT
    { 8, 4 },   // COMPRATE_8BIT
    { 16, 2 },  // COMPRATE_16BIT
    { 32, 1 },  // COMPRATE_32BIT
};
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
s32 uncompressData(u32* pCompressData, f32* pData);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
s32 uncompressUnitQuaternion(u32** ppCompressData, f32* pData[4]);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
s32 uncompressUnitQuaternionFrame(u32** ppCompressData, u32 frame0, u32 frame1, f32* pDataStw[3], f32* pData[4]);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
f32 inverseQuantize(s32 in, s8 width);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void getQuaternion(f32 data[3], f32 outData[4]);
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
f32 getCurveValueFromFrame(u32* pCompressData, u32 frame, KeyCache* pCache);
    
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
f32 getCurveValueFromCache(u32* pCompressData, u32 frame, KeyCache* pCache, u32 cacheFrame);
 
}