ntv2m31publicinterface.h

Go to the documentation of this file.

/* SPDX-License-Identifier: MIT */
#ifndef NTV2M31PUBLICINTERFACE_H
#define NTV2M31PUBLICINTERFACE_H
#include "ajatypes.h"

#if !defined(NTV2_DEPRECATE_17_6)   //  Corvid HEVC support removed in SDK 17.6

#include "ntv2m31enums.h"

#define        CPARAM_REG_START         0x20000000

// Common param register index (to get actual register location we multiply index by 4 then add CPARAM_REG_START)

typedef enum
{
    kRegCParamCC,                       // 0x20000000
    kRegCParamReserved0,                // 0x20000004
    kRegCParamStillColor,               // 0x20000008
    kRegCParamScBuf,                    // 0x2000000C
    
    kRegCParamResoType7_0,              // 0x20000010
    kRegCParamResoType15_8,             // 0x20000014
    kRegCParamResoType23_16,            // 0x20000018
    kRegCParamResoType31_24             // 0x2000001C

} CParamRegisterIndex;


typedef enum
{
    kRegMaskCParamCC                    = 0xFFFF,

    // kRegCParamStillColor
    kRegMaskCParamStillColorY           = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskCParamStillColorCb          = BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskCParamStillColorCr          = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),

    // kRegCParamScBuf
    kRegMaskCParamScRobustMode          = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskCParamScBuf                 = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),

    // kRegCParamResoType7_0
    kRegMaskCParamResoType7             = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskCParamResoType6             = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskCParamResoType5             = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskCParamResoType4             = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskCParamResoType3             = BIT(12)+BIT(13)+BIT(15)+BIT(15),
    kRegMaskCParamResoType2             = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskCParamResoType1             = BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskCParamResoType0             = BIT(0)+BIT(1)+BIT(2)+BIT(3)
    
} CParamRegisterMask;


typedef enum
{
    kRegShiftCParamCC                   = 0,

    // kRegCParamStillColor
    kRegShiftCParamStillColorY          = 16,
    kRegShiftCParamStillColorCb         = 8,
    kRegShiftCParamStillColorCr         = 0,

    // kRegCParamScBuf
    kRegShiftCParamScRobustMode         = 8,
    kRegShiftCParamScBuf                = 0,

    // kRegCParamResoType7_0
    kRegShiftCParamResoType7            = 28,
    kRegShiftCParamResoType6            = 24,
    kRegShiftCParamResoType5            = 20,
    kRegShiftCParamResoType4            = 16,
    kRegShiftCParamResoType3            = 12,
    kRegShiftCParamResoType2            = 8,
    kRegShiftCParamResoType1            = 4,
    kRegShiftCParamResoType0            = 0
    
} CParamRegisterShift;


#define        VIPARAM_REG_START        0x20000020
#define        VIPARAM_CH_SIZE          0x30

// VI param register index (to get actual register location we multiply index by 4 then add VIPARAM_REG_START)

typedef enum
{
    kRegVI0ParamCC,                     // 0x20000020
    kRegVI1ParamCC,                     // 0x20000024
    kRegVI2ParamCC,                     // 0x20000028
    kRegVI3ParamCC,                     // 0x2000002C
    
    // Channel 0
    kRegVI0Param,                       // 0x20000030
    kRegVI0ParamStartLine,              // 0x20000034
    kRegVI0ParamMaxCount,               // 0x20000038
    kRegVI0ParamValidPosLine,           // 0x2000003C
    kRegVI0ParamValidLineCount,         // 0x20000040
    kRegVI0ParamValidVCount,            // 0x20000044
    kRegVI0ParamReserved0,              // 0x20000048
    kRegVI0ParamReserved1,              // 0x2000004C
    kRegVI0ParamReserved2,              // 0x20000050
    kRegVI0ParamReserved3,              // 0x20000054
    kRegVI0ParamMisc,                   // 0x20000058
    kRegVI0ParamReserved4,              // 0x2000005C
   
    // Channel 1
    kRegVI1Param,                       // 0x20000060
    kRegVI1ParamStartLine,              // 0x20000064
    kRegVI1ParamMaxCount,               // 0x20000068
    kRegVI1ParamValidPosLine,           // 0x2000006C
    kRegVI1ParamValidLineCount,         // 0x20000070
    kRegVI1ParamValidVCount,            // 0x20000074
    kRegVI1ParamReserved0,              // 0x20000078
    kRegVI1ParamReserved1,              // 0x2000007C
    kRegVI1ParamReserved2,              // 0x20000080
    kRegVI1ParamReserved3,              // 0x20000084
    kRegVI1ParamMisc,                   // 0x20000088
    kRegVI1ParamReserved4,              // 0x2000008C
  
    // Channel 2
    kRegVI2Param,                       // 0x20000090
    kRegVI2ParamStartLine,              // 0x20000094
    kRegVI2ParamMaxCount,               // 0x20000098
    kRegVI2ParamValidPosLine,           // 0x2000009C
    kRegVI2ParamValidLineCount,         // 0x200000A0
    kRegVI2ParamValidVCount,            // 0x200000A4
    kRegVI2ParamReserved0,              // 0x200000A8
    kRegVI2ParamReserved1,              // 0x200000AC
    kRegVI2ParamReserved2,              // 0x200000B0
    kRegVI2ParamReserved3,              // 0x200000B4
    kRegVI2ParamMisc,                   // 0x200000B8
    kRegVI2ParamReserved4,              // 0x200000BC
    
    // Channel 3
    kRegVI3Param,                       // 0x200000C0
    kRegVI3ParamStartLine,              // 0x200000C4
    kRegVI3ParamMaxCount,               // 0x200000C8
    kRegVI3ParamValidPosLine,           // 0x200000CC
    kRegVI3ParamValidLineCount,         // 0x200000D0
    kRegVI3ParamValidVCount,            // 0x200000D4
    kRegVI3ParamReserved0,              // 0x200000D8
    kRegVI3ParamReserved1,              // 0x200000DC
    kRegVI3ParamReserved2,              // 0x200000E0
    kRegVI3ParamReserved3,              // 0x200000E4
    kRegVI3ParamMisc,                   // 0x200000E8
    kRegVI3ParamReserved4,              // 0x200000EC
    
    // Extras at the end don't belong to a channel
    kRegVIParamReserved0,               // 0x200000F0
    kRegVIParamReserved1,               // 0x200000F4
    kRegVIParamReserved2,               // 0x200000F8
    kRegVIParamReserved3                // 0x200000FC

} VIParamRegisterIndex;


typedef enum
{
    kRegMaskVIParamCC                   = 0xFFFF,
    
    // kRegVI0Param
    kRegMaskVIParamYCMux                = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVIParamYCSwap               = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskVIParamPrivate01            = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskVIParamPrivate02            = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskVIParamPrivate03            = BIT(12)+BIT(13)+BIT(15)+BIT(15),
    kRegMaskVIParamPrivate04            = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskVIParamFormat               = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),
    
    // kRegVI0ParamStartLine
    kRegMaskVIParamPrivate05            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVIParamPrivate06            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    // kRegVI0ParamMaxCount
    kRegMaskVIParamPrivate07            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVIParamPrivate08            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    // kRegVI1ParamValidPosLine
    kRegMaskVIParamPrivate09            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVIParamPrivate10            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    // kRegVI0ParamValidLineCount
    kRegMaskVIParamPrivate11            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVIParamPrivate12            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    // kRegVI0ParamValidVCount
    kRegMaskVIParamPrivate13            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    
    // kRegVI0ParamMisc
    kRegMaskVIParamGPIO                 = BIT(0),
    kRegMaskVIParamSyncMembers          = BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskVIParamSyncMaster           = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskVIParamInputPort            = BIT(12)+BIT(13)+BIT(15)+BIT(15)

} VIParamRegisterMask;


typedef enum
{
    kRegShiftVIParamCC                  = 0,
    
    // kRegVI0Param
    kRegShiftVIParamYCMux               = 28,
    kRegShiftVIParamYCSwap              = 24,
    kRegShiftVIParamPrivate01           = 20,
    kRegShiftVIParamPrivate02           = 16,
    kRegShiftVIParamPrivate03           = 12,
    kRegShiftVIParamPrivate04           = 8,
    kRegShiftVIParamFormat              = 0,
    
    // kRegVI0ParamStartLine
    kRegShiftVIParamPrivate05           = 16,
    kRegShiftVIParamPrivate06           = 0,
    
    // kRegVI0ParamMaxCount
    kRegShiftVIParamPrivate07           = 16,
    kRegShiftVIParamPrivate08           = 0,
    
    // kRegVI1ParamValidPosLine
    kRegShiftVIParamPrivate09           = 16,
    kRegShiftVIParamPrivate10           = 0,
    
    // kRegVI0ParamValidLineCount
    kRegShiftVIParamPrivate11           = 16,
    kRegShiftVIParamPrivate12           = 0,
    
    // kRegVI0ParamValidVCount
    kRegShiftVIParamPrivate13           = 16,
    
    // kRegVI0ParamMisc
    kRegShiftVIParamGPIO                = 0,
    kRegShiftVIParamSyncMembers         = 3,
    kRegShiftVIParamSyncMaster          = 8,
    kRegShiftVIParamInputPort           = 12
    
} VIParamRegisterShift;


#define        VINPARAM_REG_START       0x20000100
#define        VINPARAM_CH_SIZE         0x20

// VIn param register index (to get actual register location we multiply index by 4 then add VINPARAM_REG_START)

// Note:    Each encoder channel has the following VIn registers.  This register map will be repeated for each of the 32 virtual
//            channels.  The current firmware supports four physical encoder channels.

typedef enum
{
    kRegVINParamCC,                     // 0x20000100
    kRegVINParamSource,                 // 0x20000104
    kRegVINParamOut,                    // 0x20000108
    kRegVINParamSize,                   // 0x2000010C
    
    kRegVINParamPTSModeInitialMSB,      // 0x20000110
    kRegVINParamInitialPTS,             // 0x20000114
    kRegVINParamInitialSerialNum,       // 0x20000118
    kRegVINParamReserved1               // 0x2000011C

} VINParamRegisterIndex;


typedef enum
{
    kRegMaskVINParamCC                  = 0xFFFF,
    
    // kRegVINParamSource
    kRegMaskVINParamSource              = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVINParamSourceId            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskVINParamChromaFormat        = BIT(4)+ BIT(5)+BIT(6)+BIT(7),
    kRegMaskVINParamBitDepth            = BIT(0)+BIT(1)+BIT(2)+BIT(3),

    // kRegVINParamOut
    kRegMaskVInParamFrameRate           = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVInParamPrivate01           = BIT(0)+BIT(1)+BIT(2)+BIT(3),

    // kRegVINParamSize
    kRegMaskVINParamHSize               = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVINParamVSize               = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVINParamPTSModeInitialMSB
    kRegMaskVINParamPTSMode             = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVINParamInitialPTSMSB       = BIT(0),

    kRegMaskVINParamInitialPTS          = 0xFFFFFFFF,
    kRegMaskVINParamInitialSerialNum    = 0xFFFFFFFF

} VINParamRegisterMask;


typedef enum
{
    kRegShiftVINParamCC                 = 0,

    // kRegVINParamSource
    kRegShiftVINParamSource             = 28,
    kRegShiftVINParamSourceId           = 16,
    kRegShiftVINParamChromaFormat       = 4,
    kRegShiftVINParamBitDepth           = 0,
    
    // kRegVINParamOut
    kRegShiftVInParamFrameRate          = 24,
    kRegShiftVInParamPrivate01          = 0,
    
    // kRegVINParamSize
    kRegShiftVINParamHSize              = 16,
    kRegShiftVINParamVSize              = 0,
    
    // kRegVINParamPTSModeInitialMSB
    kRegShiftVINParamPTSMode            = 28,
    kRegShiftVINParamInitialPTSMSB      = 0,
    
    kRegShiftVINParamInitialPTS         = 0,
    kRegShiftVINParamInitialSerialNum   = 0

} VINParamRegisterShift;


#define        VAPARAM_REG_START        0x20000800
#define        VAPARAM_CH_SIZE          0x30

// VA param register index (to get actual register location we multiply index by 4 then add VAPARAM_REG_START)

// Note:    Each encoder channel has the following VA registers.  This register map will be repeated for each of the 32 virtual
//            channels.  The current firmware supports four physical encoder channels.

typedef enum
{
    kRegVAParamCC,                      // 0x20000800
    kRegVAParamSource,                  // 0x20000804
    kRegVAParamRateFormat,              // 0x20000808
    kRegVAParamSizeVA,                  // 0x2000080C
    kRegVAParamSizeEH,                  // 0x20000810
    
    kRegVAParamCoef1_0,                 // 0x20000814
    kRegVAParamCoef3_2,                 // 0x20000818
    kRegVAParamCoef5_4,                 // 0x2000081C
    kRegVAParamCoef7_6,                 // 0x20000820

    kRegVAParamStartOffset,             // 0x20000824
    kRegVAParamSceneChange,             // 0x20000828
    kRegVAParamReserved2                // 0x2000082C

} VAParamRegisterIndex;


typedef enum
{
    kRegMaskVAParamCC                   = 0xFFFF,

    // kRegVAParamSource
    kRegMaskVAParamSource               = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamSourceId             = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskVAInterlace                 = BIT(8)+ BIT(9)+BIT(10)+BIT(11),
    kRegMaskVAParamChromaFormat         = BIT(4)+ BIT(5)+BIT(6)+BIT(7),
    kRegMaskVAParamBitDepth             = BIT(0)+BIT(1)+BIT(2)+BIT(3),
    
    // kRegVAParamRateFormat
    kRegMaskVAParamFrameRate            = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamChromaFormatOut      = BIT(4)+ BIT(5)+BIT(6)+BIT(7),
    kRegMaskVAParamBitDepthOut          = BIT(0)+BIT(1)+BIT(2)+BIT(3),

    // kRegVAParamSizeVA
    kRegMaskVAParamHSizeVA              = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamVSizeVA              = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamSizeEH
    kRegMaskVAParamHSizeEH              = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamVSizeEH              = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamCoef1_0
    kRegMaskVAParamCoef1                = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamCoef0                = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamCoef3_2
    kRegMaskVAParamCoef3                = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamCoef2                = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamCoef5_4
    kRegMaskVAParamCoef5                = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamCoef4                = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamCoef7_6
    kRegMaskVAParamCoef7                = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamCoef6                = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamStartOffset
    kRegMaskVAParamPrivate01            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskVAParamPrivate02            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegVAParamSceneChange
    kRegMaskVAParamSceneChange          = BIT(16)+BIT(17)+BIT(18)+BIT(19)

} VAParamRegisterMask;


typedef enum
{
    kRegShiftVAParamCC                  = 0,

    // kRegVAParamSource
    kRegShiftVAParamSource              = 28,
    kRegShiftVAParamSourceId            = 16,
    kRegShiftVAInterlace                = 8,
    kRegShiftVAParamChromaFormat        = 4,
    kRegShiftVAParamBitDepth            = 0,
    
    // kRegVAParamRateFormat
    kRegShiftVAParamFrameRate           = 24,
    kRegShiftVAParamChromaFormatOut     = 4,
    kRegShiftVAParamBitDepthOut         = 0,

    // kRegVAParamSizeVA
    kRegShiftVAParamHSizeVA             = 16,
    kRegShiftVAParamVSizeVA             = 0,
    
    // kRegVAParamSizeEH
    kRegShiftVAParamHSizeEH             = 16,
    kRegShiftVAParamVSizeEH             = 0,

    // kRegVAParamCoef1_0
    kRegShiftVAParamCoef1               = 16,
    kRegShiftVAParamCoef0               = 0,
    
    // kRegVAParamCoef3_2
    kRegShiftVAParamCoef3               = 16,
    kRegShiftVAParamCoef2               = 0,
    
    // kRegVAParamCoef5_4
    kRegShiftVAParamCoef5               = 16,
    kRegShiftVAParamCoef4               = 0,
    
    // kRegVAParamCoef7_6
    kRegShiftVAParamCoef7               = 16,
    kRegShiftVAParamCoef6               = 0,

    // kRegVAParamStartOffset
    kRegShiftVAParamPrivate01           = 16,
    kRegShiftVAParamPrivate02           = 0,
    
    // kRegVAParamSceneChange
    kRegShiftVAParamSceneChange         = 16

} VAParamRegisterShift;


#define        EHPARAM_REG_START        0x20001000
#define        EHPARAM_CH_SIZE          0x100

// VA param register index (to get actual register location we multiply index by 4 then add VAPARAM_REG_START)

// Note:    Each encoder channel has the following VA registers.  This register map will be repeated for each of the 32 virtual
//            channels.  The current firmware supports four physical encoder channels.

typedef enum
{
    kRegEHParamCC,                      // 0x20001000
    kRegEHParamSource,                  // 0x20001004
    kRegEHParamSizeVA,                  // 0x20001008
    kRegEHParamSizeEH,                  // 0x2000100C
    
    kRegEHParamProfile,                 // 0x20001010
    kRegEHParamAspectRatio,             // 0x20001014
    kRegEHParamSAR,                     // 0x20001018

    kRegEHParamSlice,                   // 0x2000101C
    kRegEHParamGop1,                    // 0x20001020
    kRegEHParamGop2,                    // 0x20001024
    kRegEHParamRCMode,                  // 0x20001028

    kRegEHParamBitRate,                 // 0x2000102C
    kRegEHParamVBRMaxBitRate,           // 0x20001030
    kRegEHParamVBRAveBitRate,           // 0x20001034
    kRegEHParamVBRMinBitRate,           // 0x20001038
    kRegEHParamVBRFillerBitRate,        // 0x2000103C
    
    kRegEHParamNumUnitsInTickMax,       // 0x20001040
    kRegEHParamTimeScale,               // 0x20001044
    kRegEHParamNumUnitsInTick,          // 0x20001048
    kRegEHParamCPBDelay,                // 0x2000104C
    kRegEHParamReserved1,               // 0x20001050
    kRegEHParamReserved2,               // 0x20001054

    kRegEHParamCUTUSize,                // 0x20001058
    kRegEHParamTUDepth,                 // 0x2000105C
    kRegEHParamTSkip,                   // 0x20001060
    kRegEHParamAMP_WP,                  // 0x20001064
    kRegEHParamReserved3,               // 0x20001068

    kRegEHParamPCM,                     // 0x2000106C
    kRegEHParamSAO,                     // 0x20001070
    kRegEHParamDF,                      // 0x20001074
    kRegEHParamRDOQ,                    // 0x20001078
    kRegEHParamPPS,                     // 0x2000107C
    kRegEHParamBufCtrl,                 // 0x20001080
    
    kRegEHParamOverscan,                // 0x20001084
    kRegEHParamVideo,                   // 0x20001088
    kRegEHParamMatrixCoef,              // 0x2000108C

    kRegEHParamCropLR,                  // 0x20001090
    kRegEHParamCropTB,                  // 0x20001094
    kRegEHParamGDR,                     // 0x20001098
    kRegEHParamRecovery,                // 0x2000109C
    
    kRegEHParamPanScanLR,               // 0x200010A0
    kRegEHParamPanScanTB,               // 0x200010A4
    kRegEHParamHash,                    // 0x200010A8

    kRegEHParamReserved4,               // 0x200010AC
    kRegEHParamReserved5,               // 0x200010B0
    kRegEHParamReserved6,               // 0x200010B4
    kRegEHParamReserved7,               // 0x200010B8
    kRegEHParamReserved8,               // 0x200010BC
    kRegEHParamReserved9,               // 0x200010C0
    kRegEHParamReserved10,              // 0x200010C4
    kRegEHParamReserved11,              // 0x200010C8
    kRegEHParamReserved12,              // 0x200010CC
    kRegEHParamReserved13,              // 0x200010D0
    kRegEHParamReserved14,              // 0x200010D4
    kRegEHParamReserved15,              // 0x200010D8
    kRegEHParamReserved16,              // 0x200010DC
    kRegEHParamReserved17,              // 0x200010E0
    kRegEHParamReserved18,              // 0x200010E4
    kRegEHParamReserved19,              // 0x200010E8
    kRegEHParamReserved20,              // 0x200010EC
    kRegEHParamReserved21,              // 0x200010F0
    kRegEHParamReserved22,              // 0x200010F4
    kRegEHParamReserved23,              // 0x200010F8
    kRegEHParamReserved24               // 0x200010FC

} EHParamRegisterIndex;


typedef enum
{
    kRegMaskEHParamCC                   = 0xFFFF,
    
    // kRegEHParamSource
    kRegMaskEHParamSource               = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamSourceId             = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamHsEncodeMode         = BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskEHParamInterlace            = BIT(8)+ BIT(9)+BIT(10)+BIT(11),
    kRegMaskEHParamChromaFormat         = BIT(4)+ BIT(5)+BIT(6)+BIT(7),
    kRegMaskEHParamBitDepth             = BIT(0)+BIT(1)+BIT(2)+BIT(3),
    
    // kRegEHParamSizeVA
    kRegMaskEHParamHSizeVA              = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamVSizeVA              = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    // kRegEHParamSizeEH
    kRegMaskEHParamHSizeEH              = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamVSizeEH              = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    //kRegEHParamProfile
    kRegMaskEHParamProfile              = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamLevel                = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamTier                 = BIT(12)+BIT(13)+BIT(14)+BIT(15),

    //kRegEHParamAspectRatio
    kRegMaskEHParamAspectRatio          = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),

    //kRegEHParamSAR
    kRegMaskEHParamSARWidth             = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamSARHeight            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    //kRegEHParamSlice
    kRegMaskEHParamPrivate01            = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamPrivate02            = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamPrivate03            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamPrivate04            = BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskEHParamPrivate05            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),

    //kRegEHParamGop1
    kRegMaskEHParamFrameNumInGOP        = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamGOPHierarchy         = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamUseTemporalID        = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskEHParamPrivate06            = BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskEHParamPrivate07            = BIT(0)+BIT(1)+BIT(2)+BIT(3),
    
    //kRegEHParamGop2
    kRegMaskEHParamPASL0B               = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamIpPeriod             = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamAdaptiveGOP          = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamClosedGOP            = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskEHParamIDRInterval          = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    //kRegEHParamRCMode
    kRegMaskEHParamRCMode               = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamMinQpCtrl            = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamPrivate08            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamAdaptiveQuant        = BIT(0)+BIT(1)+BIT(2)+BIT(3),

    kRegMaskEHParamBitRate              = 0xFFFFFFFF,
    kRegMaskEHParamVBRMaxBitRate        = 0xFFFFFFFF,
    kRegMaskEHParamVBRAveBitRate        = 0xFFFFFFFF,
    kRegMaskEHParamPrivate09            = 0xFFFFFFFF,
    kRegMaskEHParamPrivate10            = 0xFFFFFFFF,
    kRegMaskEHParamNumUnitsInTickMax    = 0xFFFFFFFF,
    kRegMaskEHParamTimeScale            = 0xFFFFFFFF,
    kRegMaskEHParamNumUnitsInTick       = 0xFFFFFFFF,
    kRegMaskEHParamCPBDelay             = 0xFFFFFFFF,

    //kRegEHParamCUTUSize
    kRegMaskEHParamPrivate11            = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamMinCUSize            = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamMaxTUSize            = BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskEHParamMinTUSize            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),

    //kRegEHParamTUDepth
    kRegMaskEHParamTUDepthIntra         = BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskEHParamTUDepthInter         = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),

    //kRegEHParamTSkip
    kRegMaskEHParamPrivate12            = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamPrivate13            = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamIntraSmoothing       = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamPrivate14            = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskEHParamMergeCand            = BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    //kRegEHParamAMP_WP
    kRegMaskEHParamPrivate15            = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamPrivate16            = BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    //kRegEHParamPCM
    kRegMaskEHParamPrivate17            = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamPrivate18            = BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamPrivate19            = BIT(12)+BIT(13)+BIT(14)+BIT(15)+BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskEHParamPrivate20            = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskEHParamPrivate21            = BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskEHParamPrivate22            = BIT(0)+BIT(1)+BIT(2)+BIT(3),
    
    //kRegEHParamSAO
    kRegMaskEHParamPrivate23            = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamPrivate24            = BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    //kRegEHParamDF
    kRegMaskEHParamDF                   = BIT(28)+BIT(29)+BIT(30)+BIT(31),

    //kRegEHParamRDOQ
    kRegMaskEHParamPrivate25            = BIT(28)+BIT(29)+BIT(30)+BIT(31),

    //kRegEHParamPPS
    kRegMaskEHParamPPSInsertion         = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamEOS                  = BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskEHParamESGap                = BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskEHParamMP4                  = BIT(0)+BIT(1)+BIT(2)+BIT(3),
    
    //kRegEHParamBufCtrl
    kRegMaskEHParamBufCtrl              = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamVCLHRD               = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamPrivate26            = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamVPSTiming            = BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    //kRegEHParamOverscan
    kRegMaskEHParamOverscanInfo         = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamBitRestriction       = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    
    //kRegEHParamVideo
    kRegMaskEHParamVideoSignalType      = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamVideoFormat          = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamVideoFullRange       = BIT(20)+BIT(21)+BIT(22)+BIT(23),
    kRegMaskEHParamColourDescription    = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskEHParamColourPrimaries      = BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    kRegMaskEHParamTransferChar         = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7),

    //kRegEHParamMatrixCoef
    kRegMaskEHParamMatrixCoef           = BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamChromaLocInfo        = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskEHParamSampleLocTop         = BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskEHParamSampleLocBot         = BIT(0)+BIT(1)+BIT(2)+BIT(3),

    //kRegEHParamCropLR
    kRegMaskEHParamCropLeft             = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamCropRight            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    //kRegEHParamCropTB
    kRegMaskEHParamCropTop              = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamCropBottom           = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    //kRegEHParamGDR
    kRegMaskEHParamPrivate27            = BIT(4)+BIT(5)+BIT(6)+BIT(7),
    kRegMaskEHParamPrivate28            = BIT(0)+BIT(1)+BIT(2)+BIT(3),

    //kRegEHParamRecovery
    kRegMaskEHParamPrivate29            = BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamUseTpIrap            = BIT(24)+BIT(25)+BIT(26)+BIT(27),
    kRegMaskEHParamPicTiming            = BIT(16)+BIT(17)+BIT(18)+BIT(19),
    kRegMaskEHParamScanType             = BIT(8)+BIT(9)+BIT(10)+BIT(11),
    kRegMaskEHParamFramePacking         = BIT(0)+BIT(1)+BIT(2)+BIT(3),
    
    //kRegEHParamPanScanLR
    kRegMaskEHParamScanLeft             = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamScanRight            = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),

    //kRegEHParamPanScanTB
    kRegMaskEHParamScanTop              = BIT(16)+BIT(17)+BIT(18)+BIT(19)+BIT(20)+BIT(21)+BIT(22)+BIT(23)+BIT(24)+BIT(25)+BIT(26)+BIT(27)+BIT(28)+BIT(29)+BIT(30)+BIT(31),
    kRegMaskEHParamScanBottom           = BIT(0)+BIT(1)+BIT(2)+BIT(3)+BIT(4)+BIT(5)+BIT(6)+BIT(7)+BIT(8)+BIT(9)+BIT(10)+BIT(11)+BIT(12)+BIT(13)+BIT(14)+BIT(15),
    
    //kRegEHParamHash
    kRegMaskEHParamPrivate30            = BIT(30)+BIT(31)
        
} EHParamRegisterMask;


typedef enum
{
    kRegShiftEHParamCC                  = 0,
    
    // kRegEHParamSource
    kRegShiftEHParamSource              = 28,
    kRegShiftEHParamSourceId            = 16,
    kRegShiftEHParamHsEncodeMode        = 12,
    kRegShiftEHParamInterlace           = 8,
    kRegShiftEHParamChromaFormat        = 4,
    kRegShiftEHParamBitDepth            = 0,
    
    // kRegEHParamSizeVA
    kRegShiftEHParamHSizeVA             = 16,
    kRegShiftEHParamVSizeVA             = 0,
    
    // kRegEHParamSizeEH
    kRegShiftEHParamHSizeEH             = 16,
    kRegShiftEHParamVSizeEH             = 0,
    
    //kRegEHParamProfile
    kRegShiftEHParamProfile             = 24,
    kRegShiftEHParamLevel               = 16,
    kRegShiftEHParamTier                = 12,
    
    //kRegEHParamAspectRatio
    kRegShiftEHParamAspectRatio         = 24,
    
    //kRegEHParamSAR
    kRegShiftEHParamSARWidth            = 16,
    kRegShiftEHParamSARHeight           = 0,
    
    //kRegEHParamSlice
    kRegShiftEHParamPrivate01           = 28,
    kRegShiftEHParamPrivate02           = 24,
    kRegShiftEHParamPrivate03           = 16,
    kRegShiftEHParamPrivate04           = 8,
    kRegShiftEHParamPrivate05           = 0,
    
    //kRegEHParamGop1
    kRegShiftEHParamFrameNumInGOP       = 24,
    kRegShiftEHParamGOPHierarchy        = 20,
    kRegShiftEHParamUseTemporalID       = 16,
    kRegShiftEHParamPrivate06           = 4,
    kRegShiftEHParamPrivate07           = 0,
    
    //kRegEHParamGop2
    kRegShiftEHParamPASL0B              = 28,
    kRegShiftEHParamIpPeriod            = 24,
    kRegShiftEHParamAdaptiveGOP         = 20,
    kRegShiftEHParamClosedGOP           = 16,
    kRegShiftEHParamIDRInterval         = 0,
    
    //kRegEHParamRCMode
    kRegShiftEHParamRCMode              = 28,
    kRegShiftEHParamMinQpCtrl           = 24,
    kRegShiftEHParamPrivate08           = 16,
    kRegShiftEHParamAdaptiveQuant       = 0,
    
    kRegShiftEHParamBitRate             = 0,
    kRegShiftEHParamVBRMaxBitRate       = 0,
    kRegShiftEHParamVBRAveBitRate       = 0,
    kRegShiftEHParamPrivate09           = 0,
    kRegShiftEHParamPrivate10           = 0,
    kRegShiftEHParamNumUnitsInTickMax   = 0,
    kRegShiftEHParamTimeScale           = 0,
    kRegShiftEHParamNumUnitsInTick      = 0,
    kRegShiftEHParamCPBDelay            = 0,
    
    //kRegEHParamCUTUSize
    kRegShiftEHParamPrivate11           = 24,
    kRegShiftEHParamMinCUSize           = 16,
    kRegShiftEHParamMaxTUSize           = 8,
    kRegShiftEHParamMinTUSize           = 0,
    
    //kRegEHParamTUDepth
    kRegShiftEHParamTUDepthIntra        = 8,
    kRegShiftEHParamTUDepthInter        = 0,
    
    //kRegEHParamTSkip
    kRegShiftEHParamPrivate12           = 28,
    kRegShiftEHParamPrivate13           = 24,
    kRegShiftEHParamIntraSmoothing      = 20,
    kRegShiftEHParamPrivate14           = 16,
    kRegShiftEHParamMergeCand           = 12,
    
    //kRegEHParamAMP_WP
    kRegShiftEHParamPrivate15           = 28,
    kRegShiftEHParamPrivate16           = 12,
    
    //kRegEHParamPCM
    kRegShiftEHParamPrivate17           = 28,
    kRegShiftEHParamPrivate18           = 20,
    kRegShiftEHParamPrivate19           = 12,
    kRegShiftEHParamPrivate20           = 8,
    kRegShiftEHParamPrivate21           = 4,
    kRegShiftEHParamPrivate22           = 0,
    
    //kRegEHParamSAO
    kRegShiftEHParamPrivate23           = 28,
    kRegShiftEHParamPrivate24           = 12,
    
    //kRegEHParamDF
    kRegShiftEHParamDF                  = 28,
    
    //kRegEHParamRDOQ
    kRegShiftEHParamPrivate25           = 28,
    
    //kRegEHParamPPS
    kRegShiftEHParamPPSInsertion        = 28,
    kRegShiftEHParamEOS                 = 12,
    kRegShiftEHParamESGap               = 4,
    kRegShiftEHParamMP4                 = 0,
    
    //kRegEHParamBufCtrl
    kRegShiftEHParamBufCtrl             = 28,
    kRegShiftEHParamVCLHRD              = 24,
    kRegShiftEHParamPrivate26           = 20,
    kRegShiftEHParamVPSTiming           = 12,
    
    //kRegEHParamOverscan
    kRegShiftEHParamOverscanInfo        = 28,
    kRegShiftEHParamBitRestriction      = 24,
    
    //kRegEHParamVideo
    kRegShiftEHParamVideoSignalType     = 28,
    kRegShiftEHParamVideoFormat         = 24,
    kRegShiftEHParamVideoFullRange      = 20,
    kRegShiftEHParamColourDescription   = 16,
    kRegShiftEHParamColourPrimaries     = 8,
    kRegShiftEHParamTransferChar        = 0,
    
    //kRegEHParamMatrixCoef
    kRegShiftEHParamMatrixCoef          = 24,
    kRegShiftEHParamChromaLocInfo       = 8,
    kRegShiftEHParamSampleLocTop        = 4,
    kRegShiftEHParamSampleLocBot        = 0,
   
    //kRegEHParamCropLR
    kRegShiftEHParamCropLeft            = 16,
    kRegShiftEHParamCropRight           = 0,
    
    //kRegEHParamCropTB
    kRegShiftEHParamCropTop             = 16,
    kRegShiftEHParamCropBottom          = 0,
    
    //kRegEHParamGDR
    kRegShiftEHParamPrivate27           = 4,
    kRegShiftEHParamPrivate28           = 0,
    
    //kRegEHParamRecovery
    kRegShiftEHParamPrivate29           = 28,
    kRegShiftEHParamUseTpIrap           = 24,
    kRegShiftEHParamPicTiming           = 16,
    kRegShiftEHParamScanType            = 8,
    kRegShiftEHParamFramePacking        = 0,
    
    //kRegEHParamPanScanLR
    kRegShiftEHParamScanLeft            = 16,
    kRegShiftEHParamScanRight           = 0,
    
    //kRegEHParamPanScanTB
    kRegShiftEHParamScanTop             = 16,
    kRegShiftEHParamScanBottom          = 0,
    
    //kRegEHParamHash
    kRegShiftEHParamPrivate30           = 30

    
} EHParamRegisterShift;

#endif//defined(NTV2_DEPRECATE_17_6)

#endif    //    NTV2M31PUBLICINTERFACE_H