Google Git
Sign in
fuchsia / third_party / github.com / intel / media-driver / 81615efaaa8cda6622f61f8ef43b5398286d9bab / . / media_driver / agnostic / gen10 / codec / hal / codechal_encode_vp8_g10.cpp
blob: 4c96cacb1b2f537490fd0e87bd247adeeab0ca73 [file] [log] [blame]
/*
* Copyright (c) 2017, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \file codechal_encode_vp8_g10.cpp
//! \brief VP8 dual-pipe encoder for GEN10.
//!
#include "codechal_encode_vp8_g10.h"
#include "codeckrnheader.h"
#ifndef _FULL_OPEN_SOURCE
#include "igcodeckrn_g10.h"
#endif
#include "mhw_vdbox_mfx_hwcmd_g10_X.h"
#define INTRA_PROBABILIY 63
#define INTER_LAST_PROBABILIY 255
#define INTER_GOLD_PROBABILIY 128
#define NAX_NUM_TEMPORAL_LAYERS 4
enum CodechalBindingTableOffsetVp8BrcInitResetG10
{
CODECHAL_VP8_BRC_INIT_RESET_HISTORY_G10 = 0,
CODECHAL_VP8_BRC_INIT_RESET_DISTORTION_G10 = 1,
CODECHAL_VP8_BRC_INIT_RESET_NUM_SURFACES_G10 = 2
};
enum CodechalBindingTableOffsetVp8BrcUpdateG10
{
CODECHAL_VP8_BRC_UPDATE_HISTORY_G10 = 1,
CODECHAL_VP8_BRC_UPDATE_PAK_STATISTICS_OUTPUT_G10 = 2,
CODECHAL_VP8_BRC_UPDATE_MFX_ENCODER_CFG_READ_G10 = 3,
CODECHAL_VP8_BRC_UPDATE_MFX_ENCODER_CFG_WRITE_G10 = 4,
CODECHAL_VP8_BRC_UPDATE_MBENC_CURBE_READ_G10 = 5,
CODECHAL_VP8_BRC_UPDATE_MBENC_CURBE_WRITE_G10 = 6,
CODECHAL_VP8_BRC_UPDATE_DISTORTION_SURFACE_G10 = 7,
CODECHAL_VP8_BRC_UPDATE_CONSTANT_DATA_G10 = 8,
CODECHAL_VP8_BRC_UPDATE_SEGMENT_MAP_G10 = 9,
CODECHAL_VP8_BRC_UPDATE_MPU_CURBE_READ_G10 = 10,
CODECHAL_VP8_BRC_UPDATE_MPU_CURBE_WRITE_G10 = 11,
CODECHAL_VP8_BRC_UPDATE_TPU_CURBE_READ_G10 = 12,
CODECHAL_VP8_BRC_UPDATE_TPU_CURBE_WRITE_G10 = 13,
CODECHAL_VP8_BRC_UPDATE_NUM_SURFACES_G10 = 14
};
enum CodechalBindingTableOffsetVp8MeG10
{
CODECHAL_VP8_ME_MV_DATA_G10 = 0,
CODECHAL_VP8_16xME_MV_DATA_G10 = 2,
CODECHAL_VP8_ME_DISTORTION_G10 = 3,
CODECHAL_VP8_ME_MIN_DIST_BRC_DATA_G10 = 4,
CODECHAL_VP8_VME_INTER_PRED_G10 = 5,
CODECHAL_VP8_ME_REF1_PIC_G10 = 6,
CODECHAL_VP8_ME_REF2_PIC_G10 = 8,
CODECHAL_VP8_ME_REF3_PIC_G10 = 10,
CODECHAL_VP8_ME_NUM_SURFACES_G10 = 11
};
enum CodechalBindingTableOffsetVp8MbencG10
{
CODECHAL_VP8_MBENC_PER_MB_OUT_G10 = 0,
CODECHAL_VP8_MBENC_CURR_Y_G10 = 1,
CODECHAL_VP8_MBENC_CURR_UV_G10 = 2,
};
enum CodechalBindingTableOffsetVp8MbencIFrameG10
{
CODECHAL_VP8_MBENC_MB_MODE_COST_LUMA_G10 = 3,
CODECHAL_VP8_MBENC_BLOCK_MODE_COST_G10 = 4,
CODECHAL_VP8_MBENC_CHROMA_RECON_G10 = 5,
CODECHAL_VP8_MBENC_SEGMENTATION_MAP_G10 = 6,
CODECHAL_VP8_MBENC_HISTOGRAM_G10 = 7,
CODECHAL_VP8_MBENC_I_VME_DEBUG_STREAMOUT_G10 = 8,
CODECHAL_VP8_MBENC_VME_G10 = 9,
CODECHAL_VP8_MBENC_IDIST_G10 = 10,
CODECHAL_VP8_MBENC_CURR_Y_DOWNSCALED_G10 = 11,
CODECHAL_VP8_MBENC_VME_Coarse_Intra_G10 = 12
};
enum CodechalBindingTableOffsetVp8MbencPFrameG10
{
CODECHAL_VP8_MBENC_MV_DATA_FROM_ME_G10 = 3,
CODECHAL_VP8_MBENC_IND_MV_DATA_G10 = 4,
CODECHAL_VP8_MBENC_REF_MB_COUNT_G10 = 5,
CODECHAL_VP8_MBENC_INTER_PRED_G10 = 8,
CODECHAL_VP8_MBENC_REF1_PIC_G10 = 9,
CODECHAL_VP8_MBENC_REF2_PIC_G10 = 11,
CODECHAL_VP8_MBENC_REF3_PIC_G10 = 13,
CODECHAL_VP8_MBENC_P_PER_MB_QUANT_G10 = 14,
CODECHAL_VP8_MBEBC_INTER_PRED_DISTORTION_G10 = 15,
CODECHAL_VP8_MBEBC_PER_MV_DATA_G10 = 16,
CODECHAL_VP8_MBENC_MODE_COST_UPDATE_G10 = 17,
CODECHAL_VP8_MBENC_P_VME_DEBUG_STREAMOUT_G10 = 18,
CODECHAL_VP8_MBENC_NUM_SURFACES_G10 = 19
};
enum CodechalBindingTableOffsetVp8MpuFhbG10
{
CODECHAL_VP8_MPU_FHB_HISTOGRAM_G10 = 0,
CODECHAL_VP8_MPU_FHB_REF_MODE_PROBABILITY_G10 = 1,
CODECHAL_VP8_MPU_FHB_CURR_MODE_PROBABILITY_G10 = 2,
CODECHAL_VP8_MPU_FHB_REF_TOKEN_PROBABILITY_G10 = 3,
CODECHAL_VP8_MPU_FHB_CURR_TOKEN_PROBABILITY_G10 = 4,
CODECHAL_VP8_MPU_FHB_HEADER_BITSTREAM_G10 = 5,
CODECHAL_VP8_MPU_FHB_HEADER_METADATA_G10 = 6,
CODECHAL_VP8_MPU_FHB_PICTURE_STATE_G10 = 7,
CODECHAL_VP8_MPU_FHB_MPU_BITSTREAM_G10 = 8,
CODECHAL_VP8_MPU_FHB_TOKEN_BITS_DATA_TABLE_G10 = 9,
CODECHAL_VP8_MPU_FHB_VME_DEBUG_STREAMOUT_G10 = 10,
CODECHAL_VP8_MPU_FHB_ENTROPY_COST_TABLE_G10 = 11,
CODECHAL_VP8_MPU_MODE_COST_UPDATE_G10 = 12,
CODECHAL_VP8_MPU_FHB_NUM_SURFACES_G10 = 13
};
enum CodechalBindingTableOffsetVp8TpuFhbG10
{
CODECHAL_VP8_TPU_FHB_PAK_TOKEN_STATISTICS_G10 = 0,
CODECHAL_VP8_TPU_FHB_TOKEN_UPDATE_FLAGS_G10 = 1,
CODECHAL_VP8_TPU_FHB_ENTROPY_COST_TABLE_G10 = 2,
CODECHAL_VP8_TPU_FHB_HEADER_BITSTREAM_G10 = 3,
CODECHAL_VP8_TPU_FHB_DEFAULT_TOKEN_PROBABILITY_G10 = 4,
CODECHAL_VP8_TPU_FHB_PICTURE_STATE_G10 = 5,
CODECHAL_VP8_TPU_FHB_MPU_CURBE_DATA_G10 = 6,
CODECHAL_VP8_TPU_FHB_HEADER_METADATA_G10 = 7,
CODECHAL_VP8_TPU_FHB_TOKEN_PROBABILITY_G10 = 8,
CODECHAL_VP8_TPU_FHB_PAK_HW_PASS1_PROBABILITY_G10 = 9,
CODECHAL_VP8_TPU_FHB_KEY_TOKEN_PROBABILITY_G10 = 10,
CODECHAL_VP8_TPU_FHB_UPDATED_TOKEN_PROBABILITY_G10 = 11,
CODECHAL_VP8_TPU_FHB_PAK_HW_PASS2_PROBABILITY_G10 = 12,
CODECHAL_VP8_TPU_FHB_VME_DEBUG_STREAMOUT_G10 = 13,
CODECHAL_VP8_TPU_FHB_REPAK_DECISION_G10 = 14,
CODECHAL_VP8_TPU_FHB_NUM_SURFACES_G10 = 15
};
struct MediaObjectVp8BrcInitResetStaticDataG10
{
union
{
struct
{
uint32_t ProfileLevelMaxFrame : 32;
};
struct
{
uint32_t Value;
};
} DW0;
union
{
struct
{
uint32_t InitBufFullInBits : 32;
};
struct
{
uint32_t Value;
};
} DW1;
union
{
struct
{
uint32_t BufSizeInBits : 32;
};
struct
{
uint32_t Value;
};
} DW2;
union
{
struct
{
uint32_t AverageBitRate : 32;
};
struct
{
uint32_t Value;
};
} DW3;
union
{
struct
{
uint32_t MaxBitRate : 32;
};
struct
{
uint32_t Value;
};
} DW4;
union
{
struct
{
uint32_t MinBitRate : 32;
};
struct
{
uint32_t Value;
};
} DW5;
union
{
struct
{
uint32_t FrameRateM : 32;
};
struct
{
uint32_t Value;
};
} DW6;
union
{
struct
{
uint32_t FrameRateD : 32;
};
struct
{
uint32_t Value;
};
} DW7;
union
{
struct
{
uint32_t BRCFlag : 16;
uint32_t GopP : 16;
};
struct
{
uint32_t Value;
};
} DW8;
union
{
struct
{
uint32_t Reserved : 16;
uint32_t FrameWidthInBytes : 16;
};
struct
{
uint32_t Value;
};
} DW9;
union
{
struct
{
uint32_t FrameHeightInBytes : 16;
uint32_t AVBRAccuracy : 16;
};
struct
{
uint32_t Value;
};
} DW10;
union
{
struct
{
uint32_t AVBRConvergence : 16;
uint32_t MinQP : 16;
};
struct
{
uint32_t Value;
};
} DW11;
union
{
struct
{
uint32_t MaxQP : 16;
uint32_t LevelQP : 16;
};
struct
{
uint32_t Value;
};
} DW12;
union
{
struct
{
uint32_t MaxSection_pct : 16;
uint32_t OverShootCBR_pct : 16;
};
struct
{
uint32_t Value;
};
} DW13;
union
{
struct
{
uint32_t VBRBias_pct : 16;
uint32_t MinSection_pct : 16;
};
struct
{
uint32_t Value;
};
} DW14;
union
{
struct
{
uint32_t InstantRateThreshold0ForP : 8;
uint32_t InstantRateThreshold1ForP : 8;
uint32_t InstantRateThreshold2ForP : 8;
uint32_t InstantRateThreshold3ForP : 8;
};
struct
{
uint32_t Value;
};
} DW15;
union
{
struct
{
uint32_t Reserved : 32;
};
struct
{
uint32_t Value;
};
} DW16;
union
{
struct
{
uint32_t InstantRateThreshold0ForI : 8;
uint32_t InstantRateThreshold1ForI : 8;
uint32_t InstantRateThreshold2ForI : 8;
uint32_t InstantRateThreshold3ForI : 8;
};
struct
{
uint32_t Value;
};
} DW17;
union
{
struct
{
uint32_t DeviationThreshold0ForP : 8; // Signed byte
uint32_t DeviationThreshold1ForP : 8; // Signed byte
uint32_t DeviationThreshold2ForP : 8; // Signed byte
uint32_t DeviationThreshold3ForP : 8; // Signed byte
};
struct
{
uint32_t Value;
};
} DW18;
union
{
struct
{
uint32_t DeviationThreshold4ForP : 8; // Signed byte
uint32_t DeviationThreshold5ForP : 8; // Signed byte
uint32_t DeviationThreshold6ForP : 8; // Signed byte
uint32_t DeviationThreshold7ForP : 8; // Signed byte
};
struct
{
uint32_t Value;
};
} DW19;
union
{
struct
{
uint32_t DeviationThreshold0ForVBR : 8; // Signed byte
uint32_t DeviationThreshold1ForVBR : 8; // Signed byte
uint32_t DeviationThreshold2ForVBR : 8; // Signed byte
uint32_t DeviationThreshold3ForVBR : 8; // Signed byte
};
struct
{
uint32_t Value;
};
} DW20;
union
{
struct
{
uint32_t DeviationThreshold4ForVBR : 8; // Signed byte
uint32_t DeviationThreshold5ForVBR : 8; // Signed byte
uint32_t DeviationThreshold6ForVBR : 8; // Signed byte
uint32_t DeviationThreshold7ForVBR : 8; // Signed byte
};
struct
{
uint32_t Value;
};
} DW21;
union
{
struct
{
uint32_t DeviationThreshold0ForI : 8; // Signed byte
uint32_t DeviationThreshold1ForI : 8; // Signed byte
uint32_t DeviationThreshold2ForI : 8; // Signed byte
uint32_t DeviationThreshold3ForI : 8; // Signed byte
};
struct
{
uint32_t Value;
};
} DW22;
union
{
struct
{
uint32_t DeviationThreshold4ForI : 8; // Signed byte
uint32_t DeviationThreshold5ForI : 8; // Signed byte
uint32_t DeviationThreshold6ForI : 8; // Signed byte
uint32_t DeviationThreshold7ForI : 8; // Signed byte
};
struct
{
uint32_t Value;
};
} DW23;
union
{
struct
{
uint32_t NumTLevels : 8;
uint32_t INITBCK_MaxLevel_Ratio_U8_Layer0 : 8;
uint32_t INITBCK_MaxLevel_Ratio_U8_Layer1 : 8;
uint32_t INITBCK_MaxLevel_Ratio_U8_Layer2 : 8;
};
struct
{
uint32_t Value;
};
} DW24;
union
{
struct
{
uint32_t INITBCK_MaxLevel_Ratio_U8_Layer3 : 8;
uint32_t Reserved : 24;
};
struct
{
uint32_t Value;
};
} DW25;
union
{
struct
{
uint32_t HistoryBufferBTI : 32; // Signed byte
};
struct
{
uint32_t Value;
};
} DW26;
union
{
struct
{
uint32_t DistortionBufferBTI : 32; // Signed byte
};
struct
{
uint32_t Value;
};
} DW27;
};
struct MediaObjectVp8BrcUpdateStaticDataG10
{
union
{
struct
{
uint32_t TargetSize : 32;
};
struct
{
uint32_t Value;
};
} DW0;
union
{
struct
{
uint32_t FrameNumber : 32;
};
struct
{
uint32_t Value;
};
} DW1;
union
{
struct
{
uint32_t PictureHeaderSize : 32;
};
struct
{
uint32_t Value;
};
} DW2;
union
{
struct
{
uint32_t startGAdjFrame0 : 16;
uint32_t startGAdjFrame1 : 16;
};
struct
{
uint32_t Value;
};
} DW3;
union
{
struct
{
uint32_t startGAdjFrame2 : 16;
uint32_t startGAdjFrame3 : 16;
};
struct
{
uint32_t Value;
};
} DW4;
union
{
struct
{
uint32_t TargetSizeFlag : 8;
uint32_t BRCFlag : 8;
uint32_t MaxNumPAKs : 8;
uint32_t CurrFrameType : 8;
};
struct
{
uint32_t Value;
};
} DW5;
// This offset indicates the byte position of the q_scale_type bit
// in the 2nd level batch buffer containing the INSERT_OBJ command
// for inserting the picture header data into the bitstream.
// This offset includes the 8 bytes of the INSERT command at the
// beginning of the buffer.
// Similarly for the VbvDelay field.
union
{
struct
{
uint32_t TID : 8;
uint32_t NumTLevels : 8;
uint32_t Reserved : 16;
};
struct
{
uint32_t Value;
};
} DW6;
// This size is the size of the entire 2nd level batch buffer
// containing the INSERT_OBJ command for inserting the
// picture header data into the bitstream. It includes the batch buffer end
// command at the end of the buffer.
union
{
struct
{
uint32_t Reserved0 : 32;
};
struct
{
uint32_t Value;
};
} DW7;
union
{
struct
{
uint32_t StartGlobalAdjustMult0 : 8;
uint32_t StartGlobalAdjustMult1 : 8;
uint32_t StartGlobalAdjustMult2 : 8;
uint32_t StartGlobalAdjustMult3 : 8;
};
struct
{
uint32_t Value;
};
} DW8;
union
{
struct
{
uint32_t StartGlobalAdjustMult4 : 8;
uint32_t StartGlobalAdjustDiv0 : 8;
uint32_t StartGlobalAdjustDiv1 : 8;
uint32_t StartGlobalAdjustDiv2 : 8;
};
struct
{
uint32_t Value;
};
} DW9;
union
{
struct
{
uint32_t StartGlobalAdjustDiv3 : 8;
uint32_t StartGlobalAdjustDiv4 : 8;
uint32_t QPThreshold0 : 8;
uint32_t QPThreshold1 : 8;
};
struct
{
uint32_t Value;
};
} DW10;
union
{
struct
{
uint32_t QPThreshold2 : 8;
uint32_t QPThreshold3 : 8;
uint32_t gRateRatioThreshold0 : 8;
uint32_t gRateRatioThreshold1 : 8;
};
struct
{
uint32_t Value;
};
} DW11;
union
{
struct
{
uint32_t gRateRatioThreshold2 : 8;
uint32_t gRateRatioThreshold3 : 8;
uint32_t gRateRatioThreshold4 : 8;
uint32_t gRateRatioThreshold5 : 8;
};
struct
{
uint32_t Value;
};
} DW12;
union
{
struct
{
uint32_t gRateRatioThresholdQP0 : 8;
uint32_t gRateRatioThresholdQP1 : 8;
uint32_t gRateRatioThresholdQP2 : 8;
uint32_t gRateRatioThresholdQP3 : 8;
};
struct
{
uint32_t Value;
};
} DW13;
union
{
struct
{
uint32_t gRateRatioThresholdQP4 : 8;
uint32_t gRateRatioThresholdQP5 : 8;
uint32_t gRateRatioThresholdQP6 : 8;
uint32_t IndexOfPreviousQP : 8;
};
struct
{
uint32_t Value;
};
} DW14;
union
{
struct
{
uint32_t FrameWidthInMB : 16;
uint32_t FrameHeightInMB : 16;
};
struct
{
uint32_t Value;
};
} DW15;
union
{
struct
{
uint32_t PFrameQPSeg0 : 8;
uint32_t PFrameQPSeg1 : 8;
uint32_t PFrameQPSeg2 : 8;
uint32_t PFrameQPSeg3 : 8;
};
struct
{
uint32_t Value;
};
} DW16;
union
{
struct
{
uint32_t KeyFrameQPSeg0 : 8;
uint32_t KeyFrameQPSeg1 : 8;
uint32_t KeyFrameQPSeg2 : 8;
uint32_t KeyFrameQPSeg3 : 8;
};
struct
{
uint32_t Value;
};
} DW17;
union
{
struct
{
uint32_t QDeltaPlane0 : 8;
uint32_t QDeltaPlane1 : 8;
uint32_t QDeltaPlane2 : 8;
uint32_t QDeltaPlane3 : 8;
};
struct
{
uint32_t Value;
};
} DW18;
union
{
struct
{
uint32_t QDeltaPlane4 : 8;
uint32_t QIndex : 8;
uint32_t MainRef : 8;
uint32_t RefFrameFlags : 8;
};
struct
{
uint32_t Value;
};
} DW19;
union
{
struct
{
uint32_t SegOn : 8;
uint32_t MBRC : 8;
uint32_t BRCMethod : 8;
uint32_t VMEIntraPrediction : 8;
};
struct
{
uint32_t Value;
};
} DW20;
union
{
struct
{
uint32_t CurrentFrameQPIndex : 8;
uint32_t LastFrameQPIndex : 8;
uint32_t GoldFrameQPIndex : 8;
uint32_t AltFrameQPIndex : 8;
};
struct
{
uint32_t Value;
};
} DW21;
union
{
struct
{
uint32_t HistorytBufferBTI : 32;
};
struct
{
uint32_t Value;
};
} DW22;
union
{
struct
{
uint32_t PakStatisticsBTI : 32;
};
struct
{
uint32_t Value;
};
} DW23;
union
{
struct
{
uint32_t MfxVp8EncoderCfgReadBTI :32;
};
struct
{
uint32_t Value;
};
} DW24;
union
{
struct
{
uint32_t MfxVp8EncoderCfgWriteBTI : 32;
};
struct
{
uint32_t Value;
};
} DW25;
union
{
struct
{
uint32_t MBEncCurbeReadBTI : 32;
};
struct
{
uint32_t Value;
};
} DW26;
union
{
struct
{
uint32_t MBEncCurbeWriteBTI : 32;
};
struct
{
uint32_t Value;
};
} DW27;
union
{
struct
{
uint32_t DistortionBTI : 32;
};
struct
{
uint32_t Value;
};
} DW28;
union
{
struct
{
uint32_t ConstantDataBTI : 32;
};
struct
{
uint32_t Value;
};
} DW29;
union
{
struct
{
uint32_t SegmentMapBTI : 32;
};
struct
{
uint32_t Value;
};
} DW30;
union
{
struct
{
uint32_t MpuCurbeReadBTI : 32;
};
struct
{
uint32_t Value;
};
} DW31;
union
{
struct
{
uint32_t MpuCurbeWriteBTI : 32;
};
struct
{
uint32_t Value;
};
} DW32;
union
{
struct
{
uint32_t TpuCurbeReadBTI : 32;
};
struct
{
uint32_t Value;
};
} DW33;
union
{
struct
{
uint32_t TpuCurbeWriteBTI : 32;
};
struct
{
uint32_t Value;
};
} DW34;
};
struct MediaObjectVp8MeStaticDataG10
{
// DW0
union
{
struct
{
uint32_t SkipModeEn : MOS_BITFIELD_BIT(0);
uint32_t AdaptiveEn : MOS_BITFIELD_BIT(1);
uint32_t BiMixDis : MOS_BITFIELD_BIT(2);
uint32_t Reserved0 : MOS_BITFIELD_RANGE(3, 4);
uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT(5);
uint32_t Reserved1 : MOS_BITFIELD_BIT(6);
uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT(7);
uint32_t Reserved2 : MOS_BITFIELD_RANGE(8,23);
uint32_t EarlyImeStop : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW0;
// DW1
union
{
struct
{
uint32_t MaxNumMVs : MOS_BITFIELD_RANGE(0,5);
uint32_t Reserved0 : MOS_BITFIELD_RANGE(6,15);
uint32_t BiWeight : MOS_BITFIELD_RANGE(16,21);
uint32_t Reserved1 : MOS_BITFIELD_RANGE(22,27);
uint32_t UniMixDisable : MOS_BITFIELD_BIT(28);
uint32_t Reserved2 : MOS_BITFIELD_RANGE(29,31);
};
struct
{
uint32_t Value;
};
} DW1;
// DW2
union
{
struct
{
uint32_t MaxLenSP : MOS_BITFIELD_RANGE(0,7);
uint32_t MaxNumSU : MOS_BITFIELD_RANGE(8,15);
uint32_t Reserved0 : MOS_BITFIELD_RANGE(16,31);
};
struct
{
uint32_t Value;
};
} DW2;
// DW3
union
{
struct
{
uint32_t SrcSize : MOS_BITFIELD_RANGE(0,1);
uint32_t Reserved0 : MOS_BITFIELD_RANGE(2,3);
uint32_t MbTypeRemap : MOS_BITFIELD_RANGE(4,5);
uint32_t SrcAccess : MOS_BITFIELD_BIT(6);
uint32_t RefAccess : MOS_BITFIELD_BIT(7);
uint32_t SearchCtrl : MOS_BITFIELD_RANGE(8,10);
uint32_t DualSearchPathOption : MOS_BITFIELD_BIT(11);
uint32_t SubPelMode : MOS_BITFIELD_RANGE(12,13);
uint32_t SkipType : MOS_BITFIELD_BIT(14);
uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT(15);
uint32_t InterChromaMode : MOS_BITFIELD_BIT(16);
uint32_t FTEnable : MOS_BITFIELD_BIT(17);
uint32_t BMEDisableFBR : MOS_BITFIELD_BIT(18);
uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT(19);
uint32_t InterSAD : MOS_BITFIELD_RANGE(20,21);
uint32_t IntraSAD : MOS_BITFIELD_RANGE(22,23);
uint32_t SubMbPartMask : MOS_BITFIELD_RANGE(24,30);
uint32_t Reserved1 : MOS_BITFIELD_BIT(31);
};
struct
{
uint32_t Value;
};
} DW3;
// DW4
union
{
struct
{
uint32_t Reserved0 : MOS_BITFIELD_RANGE(0,7);
uint32_t PictureHeightMinus1 : MOS_BITFIELD_RANGE(8,15);
uint32_t PictureWidth : MOS_BITFIELD_RANGE(16,23);
uint32_t Reserved1 : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW4;
// DW5
union
{
struct
{
uint32_t Reserved0 : MOS_BITFIELD_RANGE(0,7);
uint32_t QpPrimeY : MOS_BITFIELD_RANGE(8,15);
uint32_t RefWidth : MOS_BITFIELD_RANGE(16,23);
uint32_t RefHeight : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW5;
// DW6
union
{
struct
{
uint32_t Reserved0 : MOS_BITFIELD_RANGE(0,2);
uint32_t MEModes : MOS_BITFIELD_RANGE(3,4);
uint32_t Reserved1 : MOS_BITFIELD_RANGE(5,7);
uint32_t SuperCombineDist : MOS_BITFIELD_RANGE(8,15);
uint32_t MaxVmvR : MOS_BITFIELD_RANGE(16,31);
};
struct
{
uint32_t Value;
};
} DW6;
// DW7
union
{
struct
{
uint32_t Reserved0 : MOS_BITFIELD_RANGE(0,15);
uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE(16,17);
uint32_t BilinearEnable : MOS_BITFIELD_BIT(18);
uint32_t SrcFieldPolarity : MOS_BITFIELD_BIT(19);
uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT(20);
uint32_t AConlyHAAR : MOS_BITFIELD_BIT(21);
uint32_t RefIDCostMode : MOS_BITFIELD_BIT(22);
uint32_t Reserved1 : MOS_BITFIELD_BIT(23);
uint32_t SkipCenterMask : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW7;
// DW8
union
{
struct
{
uint32_t Mode0Cost : MOS_BITFIELD_RANGE(0,7);
uint32_t Mode1Cost : MOS_BITFIELD_RANGE(8,15);
uint32_t Mode2Cost : MOS_BITFIELD_RANGE(16,23);
uint32_t Mode3Cost : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW8;
// DW9
union
{
struct
{
uint32_t Mode4Cost : MOS_BITFIELD_RANGE(0,7);
uint32_t Mode5Cost : MOS_BITFIELD_RANGE(8,15);
uint32_t Mode6Cost : MOS_BITFIELD_RANGE(16,23);
uint32_t Mode7Cost : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW9;
// DW10
union
{
struct
{
uint32_t Mode8Cost : MOS_BITFIELD_RANGE(0,7);
uint32_t Mode9Cost : MOS_BITFIELD_RANGE(8,15);
uint32_t RefIDCost : MOS_BITFIELD_RANGE(16,23);
uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW10;
// DW11
union
{
struct
{
uint32_t MV0Cost : MOS_BITFIELD_RANGE(0,7);
uint32_t MV1Cost : MOS_BITFIELD_RANGE(8,15);
uint32_t MV2Cost : MOS_BITFIELD_RANGE(16,23);
uint32_t MV3Cost : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW11;
// DW12
union
{
struct
{
uint32_t MV4Cost : MOS_BITFIELD_RANGE(0,7);
uint32_t MV5Cost : MOS_BITFIELD_RANGE(8,15);
uint32_t MV6Cost : MOS_BITFIELD_RANGE(16,23);
uint32_t MV7Cost : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW12;
// DW13
union
{
struct
{
uint32_t NumRefIdxL0MinusOne : MOS_BITFIELD_RANGE(0,7);
uint32_t NumRefIdxL1MinusOne : MOS_BITFIELD_RANGE(8,15);
uint32_t ActualMBWidth : MOS_BITFIELD_RANGE(16,23);
uint32_t ActualMBHeight : MOS_BITFIELD_RANGE(24,31);
};
struct
{
uint32_t Value;
};
} DW13;
// DW14
union
{
struct
{
uint32_t L0RefPicPolarityBits : MOS_BITFIELD_RANGE(0,7);
uint32_t L1RefPicPolarityBits : MOS_BITFIELD_RANGE(8,9);
uint32_t Reserved : MOS_BITFIELD_RANGE(10,31);
};
struct
{
uint32_t Value;
};
} DW14;
// DW15
union
{
struct
{
uint32_t Reserved : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW15;
struct
{
// DW16
union
{
struct
{
SearchPathDelta SPDelta_0;
SearchPathDelta SPDelta_1;
SearchPathDelta SPDelta_2;
SearchPathDelta SPDelta_3;
};
struct
{
uint32_t Value;
};
} DW16;
// DW17
union
{
struct
{
SearchPathDelta SPDelta_4;
SearchPathDelta SPDelta_5;
SearchPathDelta SPDelta_6;
SearchPathDelta SPDelta_7;
};
struct
{
uint32_t Value;
};
} DW17;
// DW18
union
{
struct
{
SearchPathDelta SPDelta_8;
SearchPathDelta SPDelta_9;
SearchPathDelta SPDelta_10;
SearchPathDelta SPDelta_11;
};
struct
{
uint32_t Value;
};
} DW18;
// DW19
union
{
struct
{
SearchPathDelta SPDelta_12;
SearchPathDelta SPDelta_13;
SearchPathDelta SPDelta_14;
SearchPathDelta SPDelta_15;
};
struct
{
uint32_t Value;
};
} DW19;
// DW20
union
{
struct
{
SearchPathDelta SPDelta_16;
SearchPathDelta SPDelta_17;
SearchPathDelta SPDelta_18;
SearchPathDelta SPDelta_19;
};
struct
{
uint32_t Value;
};
} DW20;
// DW21
union
{
struct
{
SearchPathDelta SPDelta_20;
SearchPathDelta SPDelta_21;
SearchPathDelta SPDelta_22;
SearchPathDelta SPDelta_23;
};
struct
{
uint32_t Value;
};
} DW21;
// DW22
union
{
struct
{
SearchPathDelta SPDelta_24;
SearchPathDelta SPDelta_25;
SearchPathDelta SPDelta_26;
SearchPathDelta SPDelta_27;
};
struct
{
uint32_t Value;
};
} DW22;
// DW23
union
{
struct
{
SearchPathDelta SPDelta_28;
SearchPathDelta SPDelta_29;
SearchPathDelta SPDelta_30;
SearchPathDelta SPDelta_31;
};
struct
{
uint32_t Value;
};
} DW23;
// DW24
union
{
struct
{
SearchPathDelta SPDelta_32;
SearchPathDelta SPDelta_33;
SearchPathDelta SPDelta_34;
SearchPathDelta SPDelta_35;
};
struct
{
uint32_t Value;
};
} DW24;
// DW25
union
{
struct
{
SearchPathDelta SPDelta_36;
SearchPathDelta SPDelta_37;
SearchPathDelta SPDelta_38;
SearchPathDelta SPDelta_39;
};
struct
{
uint32_t Value;
};
} DW25;
// DW26
union
{
struct
{
SearchPathDelta SPDelta_40;
SearchPathDelta SPDelta_41;
SearchPathDelta SPDelta_42;
SearchPathDelta SPDelta_43;
};
struct
{
uint32_t Value;
};
} DW26;
// DW27
union
{
struct
{
SearchPathDelta SPDelta_44;
SearchPathDelta SPDelta_45;
SearchPathDelta SPDelta_46;
SearchPathDelta SPDelta_47;
};
struct
{
uint32_t Value;
};
} DW27;
// DW28
union
{
struct
{
SearchPathDelta SPDelta_48;
SearchPathDelta SPDelta_49;
SearchPathDelta SPDelta_50;
SearchPathDelta SPDelta_51;
};
struct
{
uint32_t Value;
};
} DW28;
// DW29
union
{
struct
{
SearchPathDelta SPDelta_52;
SearchPathDelta SPDelta_53;
SearchPathDelta SPDelta_54;
SearchPathDelta SPDelta_55;
};
struct
{
uint32_t Value;
};
} DW29;
} SpDelta;
// DW30
union
{
struct
{
uint32_t Reserved0 : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW30;
// DW31
union
{
struct
{
uint32_t Reserved0 : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW31;
// DW32
union
{
struct
{
uint32_t VP8MeMVOutputDataBTI : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW32;
// DW33
union
{
struct
{
uint32_t VP8MeMVInputDataBTI : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW33;
// DW34
union
{
struct
{
uint32_t VP8MeDistortionBTI : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW34;
// DW35
union
{
struct
{
uint32_t VP8MeMinDistBrcBTI : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW35;
// DW36
union
{
struct
{
uint32_t ForwardRefBTI : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW36;
// DW37
union
{
struct
{
uint32_t BackwardRefBTI : MOS_BITFIELD_RANGE(0,31);
};
struct
{
uint32_t Value;
};
} DW37;
};
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(struct MediaObjectVp8MeStaticDataG10)) == 38);
struct MediaObjectVp8MbencIStaticDataG10
{
// DW0
union
{
struct
{
uint32_t FrameWidth : 16;
uint32_t FrameHeight : 16;
};
struct
{
uint32_t Value;
};
} DW0;
// DW1
union
{
struct
{
uint32_t FrameType : 1;
uint32_t EnableSegmentation : 1;
uint32_t EnableHWIntraPrediction : 1;
uint32_t EnableDebugDumps : 1;
uint32_t EnableCoeffClamp : 1;
uint32_t EnableEnableChromaIPEnhancement : 1;
uint32_t EnableMPUHistogramUpdate : 1;
uint32_t ReservedMBZ : 1;
uint32_t VMEEnableTMCheck : 1;
uint32_t VMEDistortionMeasure : 2;
uint32_t : 21;
};
struct
{
uint32_t Value;
};
} DW1;
// DW2
union
{
struct
{
uint32_t LambdaSegment0 : 16;
uint32_t LambdaSegment1 : 16;
};
struct
{
uint32_t Value;
};
} DW2;
// DW3
union
{
struct
{
uint32_t LambdaSegment2 : 16;
uint32_t LambdaSegment3 : 16;
};
struct
{
uint32_t Value;
};
} DW3;
// DW4
union
{
struct
{
uint32_t AllDCBiasSegment0 : 16;
uint32_t AllDCBiasSegment1 : 16;
};
struct
{
uint32_t Value;
};
} DW4;
// DW5
union
{
struct
{
uint32_t AllDCBiasSegment2 : 16;
uint32_t AllDCBiasSegment3 : 16;
};
struct
{
uint32_t Value;
};
} DW5;
// DW6
union
{
struct
{
uint32_t ChromaDCDeQuantSegment0 : 16;
uint32_t ChromaDCDeQuantSegment1 : 16;
};
struct
{
uint32_t Value;
};
} DW6;
// DW7
union
{
struct
{
uint32_t ChromaDCDeQuantSegment2 : 16;
uint32_t ChromaDCDeQuantSegment3 : 16;
};
struct
{
uint32_t Value;
};
} DW7;
// DW8
union
{
struct
{
uint32_t ChromaACDeQuantSegment0 : 16;
uint32_t ChromaACDeQuantSegment1 : 16;
};
struct
{
uint32_t Value;
};
} DW8;
// DW9
union
{
struct
{
uint32_t ChromaACDeQuantSegment2 : 16;
uint32_t ChromaACDeQuantSegment3 : 16;
};
struct
{
uint32_t Value;
};
} DW9;
// DW10
union
{
struct
{
uint32_t ChromaAC0Threshold0Segment0 : 16;
uint32_t ChromaAC0Threshold1Segment0 : 16;
};
struct
{
uint32_t Value;
};
} DW10;
// DW11
union
{
struct
{
uint32_t ChromaAC0Threshold0Segment1 : 16;
uint32_t ChromaAC0Threshold1Segment1 : 16;
};
struct
{
uint32_t Value;
};
} DW11;
// DW12
union
{
struct
{
uint32_t ChromaAC0Threshold0Segment2 : 16;
uint32_t ChromaAC0Threshold1Segment2 : 16;
};
struct
{
uint32_t Value;
};
} DW12;
// DW13
union
{
struct
{
uint32_t ChromaAC0Threshold0Segment3 : 16;
uint32_t ChromaAC0Threshold1Segment3 : 16;
};
struct
{
uint32_t Value;
};
} DW13;
// DW14
union
{
struct
{
uint32_t ChromaDCThreshold0Segment0 : 16;
uint32_t ChromaDCThreshold1Segment0 : 16;
};
struct
{
uint32_t Value;
};
} DW14;
// DW15
union
{
struct
{
uint32_t ChromaDCThreshold2Segment0 : 16;
uint32_t ChromaDCThreshold3Segment0 : 16;
};
struct
{
uint32_t Value;
};
} DW15;
// DW16
union
{
struct
{
uint32_t ChromaDCThreshold0Segment1 : 16;
uint32_t ChromaDCThreshold1Segment1 : 16;
};
struct
{
uint32_t Value;
};
} DW16;
// DW17
union
{
struct
{
uint32_t ChromaDCThreshold2Segment1 : 16;
uint32_t ChromaDCThreshold3Segment1 : 16;
};
struct
{
uint32_t Value;
};
} DW17;
// DW18
union
{
struct
{
uint32_t ChromaDCThreshold0Segment2 : 16;
uint32_t ChromaDCThreshold1Segment2 : 16;
};
struct
{
uint32_t Value;
};
} DW18;
// DW19
union
{
struct
{
uint32_t ChromaDCThreshold2Segment2 : 16;
uint32_t ChromaDCThreshold3Segment2 : 16;
};
struct
{
uint32_t Value;
};
} DW19;
// DW20
union
{
struct
{
uint32_t ChromaDCThreshold0Segment3 : 16;
uint32_t ChromaDCThreshold1Segment3 : 16;
};
struct
{
uint32_t Value;
};
} DW20;
// DW21
union
{
struct
{
uint32_t ChromaDCThreshold2Segment3 : 16;
uint32_t ChromaDCThreshold3Segment3 : 16;
};
struct
{
uint32_t Value;
};
} DW21;
// DW22
union
{
struct
{
uint32_t ChromaAC1ThresholdSegment0 : 16;
uint32_t ChromaAC1ThresholdSegment1 : 16;
};
struct
{
uint32_t Value;
};
} DW22;
// DW23
union
{
struct
{
uint32_t ChromaAC1ThresholdSegment2 : 16;
uint32_t ChromaAC1ThresholdSegment3 : 16;
};
struct
{
uint32_t Value;
};
} DW23;
// DW24
union
{
struct
{
uint32_t VME16x16CostSegment0 : 8;
uint32_t VME16x16CostSegment1 : 8;
uint32_t VME16x16CostSegment2 : 8;
uint32_t VME16x16CostSegment3 : 8;
};
struct
{
uint32_t Value;
};
} DW24;
// DW25
union
{
struct
{
uint32_t VME4x4CostSegment0 : 8;
uint32_t VME4x4CostSegment1 : 8;
uint32_t VME4x4CostSegment2 : 8;
uint32_t VME4x4CostSegment3 : 8;
};
struct
{
uint32_t Value;
};
} DW25;
// DW26
union
{
struct
{
uint32_t VME16x16NonDCPenaltySegment0 : 8;
uint32_t VME16x16NonDCPenaltySegment1 : 8;
uint32_t VME16x16NonDCPenaltySegment2 : 8;
uint32_t VME16x16NonDCPenaltySegment3 : 8;
};
struct
{
uint32_t Value;
};
} DW26;
// DW27
union
{
struct
{
uint32_t VME4x4NonDCPenaltySegment0 : 8;
uint32_t VME4x4NonDCPenaltySegment1 : 8;
uint32_t VME4x4NonDCPenaltySegment2 : 8;
uint32_t VME4x4NonDCPenaltySegment3 : 8;
};
struct
{
uint32_t Value;
};
} DW27;
// DW28
union
{
struct
{
uint32_t : 32;
};
struct
{
uint32_t Value;
};
} DW28;
// DW29
union
{
struct
{
uint32_t : 32;
};
struct
{
uint32_t Value;
};
} DW29;
// DW30
union
{
struct
{
uint32_t : 32;
};
struct
{
uint32_t Value;
};
} DW30;
// DW31
union
{
struct
{
uint32_t : 32;
};
struct
{
uint32_t Value;
};
} DW31;
// DW32
union
{
struct
{
uint32_t MBEncPerMBOutDataSurfBTI : 32;
};
struct
{
uint32_t Value;
};
} DW32;
// DW33
union
{
struct
{
uint32_t MBEncCurrYBTI : 32;
};
struct
{
uint32_t Value;
};
} DW33;
// DW34
union
{
struct
{
uint32_t MBEncCurrUVBTI : 32;
};
struct
{
uint32_t Value;
};
} DW34;
// DW35
union
{
struct
{
uint32_t MBModeCostLumaBTI : 32;
};
struct
{
uint32_t Value;
};
} DW35;
// DW36
union
{
struct
{
uint32_t MBEncBlockModeCostBTI : 32;
};
struct
{
uint32_t Value;
};
} DW36;
// DW37
union
{
struct
{
uint32_t ChromaReconSurfBTI : 32;
};
struct
{
uint32_t Value;
};
} DW37;
// DW38
union
{
struct
{
uint32_t SegmentationMapBTI : 32;
};
struct
{
uint32_t Value;
};
} DW38;
// DW39
union
{
struct
{
uint32_t HistogramBTI : 32;
};
struct
{
uint32_t Value;
};
} DW39;
// DW40
union
{
struct
{
uint32_t MBEncVMEDebugStreamOutBTI : 32;
};
struct
{
uint32_t Value;
};
} DW40;
// DW41
union
{
struct
{
uint32_t VmeBTI : 32;
};
struct
{
uint32_t Value;
};
} DW41;
// DW42
union
{
struct
{
uint32_t IDistortionSurfaceBTI : 32;
};
struct
{
uint32_t Value;
};
} DW42;
// DW43
union
{
struct
{
uint32_t MBEncCurrYDownScaledBTI : 32;
};
struct
{
uint32_t Value;
};
} DW43;
// DW44
union
{
struct
{
uint32_t MBEncVMECoarseIntraBTI : 32;
};
struct
{
uint32_t Value;
};
} DW44;
} ;
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(struct MediaObjectVp8MbencIStaticDataG10)) == 45);
struct MediaObjectVp8MbencPStaticDataG10
{
// DW0
union
{
struct
{
uint32_t FrameWidth : 16;
uint32_t FrameHeight : 16;
};
struct
{
uint32_t Value;
};
} DW0;
//DW1
union
{
struct
{
uint32_t FrameType :1;
uint32_t MultiplePred :2;
uint32_t HMEEnable :1;
uint32_t HMECombineOverlap :2;
uint32_t AllFractional :1;
uint32_t EnableTemporalScalability :1;
uint32_t HMECombinedExtraSU :8;
uint32_t RefFrameFlags :4;
uint32_t EnableSegmentation :1;
uint32_t EnableSegmentationInfoUpdate :1;
uint32_t EnableCoeffClamp :1;
uint32_t MultiReferenceQPCheck :1;
uint32_t ModecostEnableFlag :1;
uint32_t MainRef :6;
uint32_t EnableDebugDumps :1;
};
struct
{
uint32_t Value;
};
} DW1;
//DW2
union
{
struct
{
uint32_t LambdaIntraSegment0 :16;
uint32_t LambdaInterSegment0 :16;
};
struct
{
uint32_t Value;
};
} DW2;
//DW3
union
{
struct
{
uint32_t LambdaIntraSegment1 :16;
uint32_t LambdaInterSegment1 :16;
};
struct
{
uint32_t Value;
};
} DW3;
//DW4
union
{
struct
{
uint32_t LambdaIntraSegment2 :16;
uint32_t LambdaInterSegment2 :16;
};
struct
{
uint32_t Value;
};
} DW4;
//DW5
union
{
struct
{
uint32_t LambdaIntraSegment3 :16;
uint32_t LambdaInterSegment3 :16;
};
struct
{
uint32_t Value;
};
} DW5;
// DW6
union
{
struct
{
uint32_t ReferenceFrameSignBias_0 : 8;
uint32_t ReferenceFrameSignBias_1 : 8;
uint32_t ReferenceFrameSignBias_2 : 8;
uint32_t ReferenceFrameSignBias_3 : 8;
};
struct
{
uint32_t Value;
};
} DW6;
//DW7
union
{
struct
{
uint32_t RawDistThreshold :16;
uint32_t TemporalLayerID :8;
uint32_t ReservedMBZ :8;
};
struct
{
uint32_t Value;
};
} DW7;
//DW8
union
{
struct
{
uint32_t SkipModeEnable :1;
uint32_t AdaptiveSearchEnable :1;
uint32_t BidirectionalMixDisbale :1;
uint32_t ReservedMBZ1 :2;
uint32_t EarlyIMESuccessEnable :1;
uint32_t ReservedMBZ2 :1;
uint32_t Transform8x8FlagForInterEnable :1;
uint32_t ReservedMBZ3 :16;
uint32_t EarlyIMESuccessfulStopThreshold :8;
};
struct
{
uint32_t Value;
};
} DW8;
//DW9
union
{
struct
{
uint32_t MaximumNumberOfMotionVectors :6;
uint32_t ReservedMBZ1 :2;
uint32_t RefIDPolarityBits :8;
uint32_t BidirectionalWeight :6;
uint32_t ReservedMBZ2 :6;
uint32_t UnidirectionMixEnable :1;
uint32_t RefPixelBiasEnable :1;
uint32_t ReservedMBZ3 :2;
};
struct
{
uint32_t Value;
};
} DW9;
//DW10
union
{
struct
{
uint32_t MaxFixedSearchPathLength :8;
uint32_t MaximumSearchPathLength :8;
uint32_t ReservedMBZ :16;
};
struct
{
uint32_t Value;
};
} DW10;
//DW11
union
{
struct
{
uint32_t SourceBlockSize :2;
uint32_t ReservedMBZ1 :2;
uint32_t InterMbTypeRoadMap :2;
uint32_t SourceAccess :1;
uint32_t ReferenceAccess :1;
uint32_t SearchControl :3;
uint32_t DualSearchPathOption :1;
uint32_t SubPelMode :2;
uint32_t SkipModeType :1;
uint32_t DisableFieldCacheAllocation :1;
uint32_t ProcessInterChromaPixelsMode :1;
uint32_t ForwardTransformSkipCheckEnable :1;
uint32_t BMEdisableforFBRMessage :1;
uint32_t BlockBasedSkipEnable :1;
uint32_t InterSADMeasureAdjustment :2;
uint32_t IntraSADMeasureAdjustment :2;
uint32_t SubMacroBlockSubPartitionMask :6;
uint32_t ReservedMBZ2 :1;
};
struct
{
uint32_t Value;
};
} DW11;
//DW12
union
{
struct
{
uint32_t ReservedMBZ :16;
uint32_t ReferenceSearchWindowsWidth :8;
uint32_t ReferenceSearchWindowsHeight :8;
};
struct
{
uint32_t Value;
};
} DW12;
// DW13
union
{
struct
{
uint32_t Mode0CostSegment0 :8;
uint32_t Mode1CostSegment0 :8;
uint32_t Mode2CostSegment0 :8;
uint32_t Mode3CostSegment0 :8;
};
struct
{
uint32_t Value;
};
} DW13;
// DW14
union
{
struct
{
uint32_t Mode4CostSegment0 :8;
uint32_t Mode5CostSegment0 :8;
uint32_t Mode6CostSegment0 :8;
uint32_t Mode7CostSegment0 :8;
};
struct
{
uint32_t Value;
};
} DW14;
// DW15
union
{
struct
{
uint32_t Mode8CostSegment0 :8;
uint32_t Mode9CostSegment0 :8;
uint32_t RefIDCostSegment0 :8;
uint32_t ChromaCostSegment0 :8;
};
struct
{
uint32_t Value;
};
} DW15;
// DW16
union
{
struct
{
SearchPathDelta SPDelta_0;
SearchPathDelta SPDelta_1;
SearchPathDelta SPDelta_2;
SearchPathDelta SPDelta_3;
};
struct
{
uint32_t Value;
};
} DW16;
// DW17
union
{
struct
{
SearchPathDelta SPDelta_4;
SearchPathDelta SPDelta_5;
SearchPathDelta SPDelta_6;
SearchPathDelta SPDelta_7;
};
struct
{
uint32_t Value;
};
} DW17;
// DW18
union
{
struct
{
SearchPathDelta SPDelta_8;
SearchPathDelta SPDelta_9;
SearchPathDelta SPDelta_10;
SearchPathDelta SPDelta_11;
};
struct
{
uint32_t Value;
};
} DW18;
// DW19
union
{
struct
{
SearchPathDelta SPDelta_12;
SearchPathDelta SPDelta_13;
SearchPathDelta SPDelta_14;
SearchPathDelta SPDelta_15;
};
struct
{
uint32_t Value;
};
} DW19;
// DW20
union
{
struct
{
SearchPathDelta SPDelta_16;
SearchPathDelta SPDelta_17;
SearchPathDelta SPDelta_18;
SearchPathDelta SPDelta_19;
};
struct
{
uint32_t Value;
};
} DW20;
// DW21
union
{
struct
{
SearchPathDelta SPDelta_20;
SearchPathDelta SPDelta_21;
SearchPathDelta SPDelta_22;
SearchPathDelta SPDelta_23;
};
struct
{
uint32_t Value;
};
} DW21;
// DW22
union
{
struct
{
SearchPathDelta SPDelta_24;
SearchPathDelta SPDelta_25;
SearchPathDelta SPDelta_26;
SearchPathDelta SPDelta_27;
};
struct
{
uint32_t Value;
};
} DW22;
// DW23
union
{
struct
{
SearchPathDelta SPDelta_28;
SearchPathDelta SPDelta_29;
SearchPathDelta SPDelta_30;
SearchPathDelta SPDelta_31;
};
struct
{
uint32_t Value;
};
} DW23;
// DW24
union
{
struct
{
SearchPathDelta SPDelta_32;
SearchPathDelta SPDelta_33;
SearchPathDelta SPDelta_34;
SearchPathDelta SPDelta_35;
};
struct
{
uint32_t Value;
};
} DW24;
// DW25
union
{
struct
{
SearchPathDelta SPDelta_36;
SearchPathDelta SPDelta_37;
SearchPathDelta SPDelta_38;
SearchPathDelta SPDelta_39;
};
struct
{
uint32_t Value;
};
} DW25;
// DW26
union
{
struct
{
SearchPathDelta SPDelta_40;
SearchPathDelta SPDelta_41;
SearchPathDelta SPDelta_42;
SearchPathDelta SPDelta_43;
};
struct
{
uint32_t Value;
};
} DW26;
// DW27
union
{
struct
{
SearchPathDelta SPDelta_44;
SearchPathDelta SPDelta_45;
SearchPathDelta SPDelta_46;
SearchPathDelta SPDelta_47;
};
struct
{
uint32_t Value;
};
} DW27;
// DW28
union
{
struct
{
SearchPathDelta SPDelta_48;
SearchPathDelta SPDelta_49;
SearchPathDelta SPDelta_50;
SearchPathDelta SPDelta_51;
};
struct
{
uint32_t Value;
};
} DW28;
// DW29
union
{
struct
{
SearchPathDelta SPDelta_52;
SearchPathDelta SPDelta_53;
SearchPathDelta SPDelta_54;
SearchPathDelta SPDelta_55;
};
struct
{
uint32_t Value;
};
} DW29;
// DW30
union
{
struct
{
uint32_t MV0CostSegment0 :8;
uint32_t MV1CostSegment0 :8;
uint32_t MV2CostSegment0 :8;
uint32_t MV3CostSegment0 :8;
};
struct
{
uint32_t Value;
};
} DW30;
// DW31
union
{
struct
{
uint32_t MV4CostSegment0 :8;
uint32_t MV5CostSegment0 :8;
uint32_t MV6CostSegment0 :8;
uint32_t MV7CostSegment0 :8;
};
struct
{
uint32_t Value;
};
} DW31;
// DW32
union
{
struct
{
uint32_t Intra16x16NoDCPenaltySegment0 :8;
uint32_t Intra16x16NoDCPenaltySegment1 :8;
uint32_t ReservedMBZ1 :7;
uint32_t BilinearEnable :1;
uint32_t ReservedMBZ2 :8;
};
struct
{
uint32_t Value;
};
} DW32;
// DW33
union
{
struct
{
uint32_t HMECombineLen :16;
uint32_t Intra16x16NoDCPenaltySegment2 :8;
uint32_t Intra16x16NoDCPenaltySegment3 :8;
};
struct
{
uint32_t Value;
};
} DW33;
// DW34
union
{
struct
{
uint32_t MvRefCostContext_0_0_0 : 16;
uint32_t MvRefCostContext_0_0_1 : 16;
};
struct
{
uint32_t Value;
};
} DW34;
// DW35
union
{
struct
{
uint32_t MvRefCostContext_0_1_0 : 16;
uint32_t MvRefCostContext_0_1_1 : 16;
};
struct
{
uint32_t Value;
};
} DW35;
// DW36
union
{
struct
{
uint32_t MvRefCostContext_0_2_0 : 16;
uint32_t MvRefCostContext_0_2_1 : 16;
};
struct
{
uint32_t Value;
};
} DW36;
// DW37
union
{
struct
{
uint32_t MvRefCostContext_0_3_0 : 16;
uint32_t MvRefCostContext_0_3_1 : 16;
};
struct
{
uint32_t Value;
};
} DW37;
// DW38
union
{
struct
{
uint32_t MvRefCostContext_1_0_0 : 16;
uint32_t MvRefCostContext_1_0_1 : 16;
};
struct
{
uint32_t Value;
};
} DW38;
// DW39
union
{
struct
{
uint32_t MvRefCostContext_1_1_0 : 16;
uint32_t MvRefCostContext_1_1_1 : 16;
};
struct
{
uint32_t Value;
};
} DW39;
// DW40
union
{
struct
{
uint32_t MvRefCostContext_1_2_0 : 16;
uint32_t MvRefCostContext_1_2_1 : 16;
};
struct
{
uint32_t Value;
};
} DW40;
// DW41
union
{
struct
{
uint32_t MvRefCostContext_1_3_0 : 16;
uint32_t MvRefCostContext_1_3_1 : 16;
};
struct
{
uint32_t Value;
};
} DW41;
// DW42
union
{
struct
{
uint32_t MvRefCostContext_2_0_0 : 16;
uint32_t MvRefCostContext_2_0_1 : 16;
};
struct
{
uint32_t Value;
};
} DW42;
// DW43
union
{
struct
{
uint32_t MvRefCostContext_2_1_0 : 16;
uint32_t MvRefCostContext_2_1_1 : 16;
};
struct
{
uint32_t Value;
};
} DW43;
// DW44
union
{
struct
{
uint32_t MvRefCostContext_2_2_0 : 16;
uint32_t MvRefCostContext_2_2_1 : 16;
};
struct
{
uint32_t Value;
};
} DW44;
// DW45
union
{
struct
{
uint32_t MvRefCostContext_2_3_0 : 16;
uint32_t MvRefCostContext_2_3_1 : 16;
};
struct
{
uint32_t Value;
};
} DW45;
// DW46
union
{
struct
{
uint32_t MvRefCostContext_3_0_0 : 16;
uint32_t MvRefCostContext_3_0_1 : 16;
};
struct
{
uint32_t Value;
};
} DW46;
// DW47
union
{
struct
{
uint32_t MvRefCostContext_3_1_0 : 16;
uint32_t MvRefCostContext_3_1_1 : 16;
};
struct
{
uint32_t Value;
};
} DW47;
// DW48
union
{
struct
{
uint32_t MvRefCostContext_3_2_0 : 16;
uint32_t MvRefCostContext_3_2_1 : 16;
};
struct
{
uint32_t Value;
};
} DW48;
// DW49
union
{
struct
{
uint32_t MvRefCostContext_3_3_0 : 16;
uint32_t MvRefCostContext_3_3_1 : 16;
};
struct
{
uint32_t Value;
};
} DW49;
// DW50
union
{
struct
{
uint32_t MvRefCostContext_4_0_0 : 16;
uint32_t MvRefCostContext_4_0_1 : 16;
};
struct
{
uint32_t Value;
};
} DW50;
// DW51
union
{
struct
{
uint32_t MvRefCostContext_4_1_0 : 16;
uint32_t MvRefCostContext_4_1_1 : 16;
};
struct
{
uint32_t Value;
};
} DW51;
// DW52
union
{
struct
{
uint32_t MvRefCostContext_4_2_0 : 16;
uint32_t MvRefCostContext_4_2_1 : 16;
};
struct
{
uint32_t Value;
};
} DW52;
// DW53
union
{
struct
{
uint32_t MvRefCostContext_4_3_0 : 16;
uint32_t MvRefCostContext_4_3_1 : 16;
};
struct
{
uint32_t Value;
};
} DW53;
// DW54
union
{
struct
{
uint32_t MvRefCostContext_5_0_0 : 16;
uint32_t MvRefCostContext_5_0_1 : 16;
};
struct
{
uint32_t Value;
};
} DW54;
// DW55
union
{
struct
{
uint32_t MvRefCostContext_5_1_0 : 16;
uint32_t MvRefCostContext_5_1_1 : 16;
};
struct
{
uint32_t Value;
};
} DW55;
// DW56
union
{
struct
{
uint32_t MvRefCostContext_5_2_0 : 16;
uint32_t MvRefCostContext_5_2_1 : 16;
};
struct
{
uint32_t Value;
};
} DW56;
// DW57
union
{
struct
{
uint32_t MvRefCostContext_5_3_0 : 16;
uint32_t MvRefCostContext_5_3_1 : 16;
};
struct
{
uint32_t Value;
};
} DW57;
// DW58
union
{
struct
{
uint32_t EncCost16x16 : 16;
uint32_t EncCost16x8 : 16;
};
struct
{
uint32_t Value;
};
} DW58;
// DW59
union
{
struct
{
uint32_t EncCost8x8 : 16;
uint32_t EncCost4x4 : 16;
};
struct
{
uint32_t Value;
};
} DW59;
// DW60
union
{
struct
{
uint32_t FrameCountProbabilityRefFrameCost_0 : 16;
uint32_t FrameCountProbabilityRefFrameCost_1 : 16;
};
struct
{
uint32_t Value;
};
} DW60;
// DW61
union
{
struct
{
uint32_t FrameCountProbabilityRefFrameCost_2 : 16;
uint32_t FrameCountProbabilityRefFrameCost_3 : 16;
};
struct
{
uint32_t Value;
};
} DW61;
// DW62
union
{
struct
{
uint32_t AverageQPOfLastRefFrame :8;
uint32_t AverageQPOfGoldRefFrame :8;
uint32_t AverageQPOfAltRefFrame :8;
uint32_t ReservedMBZ :8;
};
struct
{
uint32_t Value;
};
} DW62;
// DW63
union
{
struct
{
uint32_t Intra4x4NoDCPenaltySegment0 :8;
uint32_t Intra4x4NoDCPenaltySegment1 :8;
uint32_t Intra4x4NoDCPenaltySegment2 :8;
uint32_t Intra4x4NoDCPenaltySegment3 :8;
};
struct
{
uint32_t Value;
};
} DW63;
// DW64
union
{
struct
{
uint32_t Mode0CostSegment1 :8;
uint32_t Mode1CostSegment1 :8;
uint32_t Mode2CostSegment1 :8;
uint32_t Mode3CostSegment1 :8;
};
struct
{
uint32_t Value;
};
} DW64;
// DW65
union
{
struct
{
uint32_t Mode4CostSegment1 :8;
uint32_t Mode5CostSegment1 :8;
uint32_t Mode6CostSegment1 :8;
uint32_t Mode7CostSegment1 :8;
};
struct
{
uint32_t Value;
};
} DW65;
// DW66
union
{
struct
{
uint32_t Mode8CostSegment1 :8;
uint32_t Mode9CostSegment1 :8;
uint32_t RefIDCostSegment1 :8;
uint32_t ChromaCostSegment1 :8;
};
struct
{
uint32_t Value;
};
} DW66;
// DW67
union
{
struct
{
uint32_t MV0CostSegment1 :8;
uint32_t MV1CostSegment1 :8;
uint32_t MV2CostSegment1 :8;
uint32_t MV3CostSegment1 :8;
};
struct
{
uint32_t Value;
};
} DW67;
// DW68
union
{
struct
{
uint32_t MV4CostSegment1 :8;
uint32_t MV5CostSegment1 :8;
uint32_t MV6CostSegment1 :8;
uint32_t MV7CostSegment1 :8;
};
struct
{
uint32_t Value;
};
} DW68;
// DW69
union
{
struct
{
uint32_t Mode0CostSegment2 :8;
uint32_t Mode1CostSegment2 :8;
uint32_t Mode2CostSegment2 :8;
uint32_t Mode3CostSegment2 :8;
};
struct
{
uint32_t Value;
};
} DW69;
// DW70
union
{
struct
{
uint32_t Mode4CostSegment2 :8;
uint32_t Mode5CostSegment2 :8;
uint32_t Mode6CostSegment2 :8;
uint32_t Mode7CostSegment2 :8;
};
struct
{
uint32_t Value;
};
} DW70;
// DW71
union
{
struct
{
uint32_t Mode8CostSegment2 :8;
uint32_t Mode9CostSegment2 :8;
uint32_t RefIDCostSegment2 :8;
uint32_t ChromaCostSegment2 :8;
};
struct
{
uint32_t Value;
};
} DW71;
// DW72
union
{
struct
{
uint32_t MV0CostSegment2 :8;
uint32_t MV1CostSegment2 :8;
uint32_t MV2CostSegment2 :8;
uint32_t MV3CostSegment2 :8;
};
struct
{
uint32_t Value;
};
} DW72;
// DW73
union
{
struct
{
uint32_t MV4CostSegment2 :8;
uint32_t MV5CostSegment2 :8;
uint32_t MV6CostSegment2 :8;
uint32_t MV7CostSegment2 :8;
};
struct
{
uint32_t Value;
};
} DW73;
// DW74
union
{
struct
{
uint32_t Mode0CostSegment3 :8;
uint32_t Mode1CostSegment3 :8;
uint32_t Mode2CostSegment3 :8;
uint32_t Mode3CostSegment3 :8;
};
struct
{
uint32_t Value;
};
} DW74;
// DW75
union
{
struct
{
uint32_t Mode4CostSegment3 :8;
uint32_t Mode5CostSegment3 :8;
uint32_t Mode6CostSegment3 :8;
uint32_t Mode7CostSegment3 :8;
};
struct
{
uint32_t Value;
};
} DW75;
// DW76
union
{
struct
{
uint32_t Mode8CostSegment3 :8;
uint32_t Mode9CostSegment3 :8;
uint32_t RefIDCostSegment3 :8;
uint32_t ChromaCostSegment3 :8;
};
struct
{
uint32_t Value;
};
} DW76;
// DW77
union
{
struct
{
uint32_t MV0CostSegment3 :8;
uint32_t MV1CostSegment3 :8;
uint32_t MV2CostSegment3 :8;
uint32_t MV3CostSegment3 :8;
};
struct
{
uint32_t Value;
};
} DW77;
// DW78
union
{
struct
{
uint32_t MV4CostSegment3 :8;
uint32_t MV5CostSegment3 :8;
uint32_t MV6CostSegment3 :8;
uint32_t MV7CostSegment3 :8;
};
struct
{
uint32_t Value;
};
} DW78;
// DW79
union
{
struct
{
uint32_t NewMVSkipThresholdSegment0 :16;
uint32_t NewMVSkipThresholdSegment1 :16;
};
struct
{
uint32_t Value;
};
} DW79;
// DW80
union
{
struct
{
uint32_t NewMVSkipThresholdSegment2 :16;
uint32_t NewMVSkipThresholdSegment3 :16;
};
struct
{
uint32_t Value;
};
} DW80;
// DW81
union
{
struct
{
uint32_t PerMbOutputDataSurfaceBTI :32;
};
struct
{
uint32_t Value;
};
} DW81;
// DW82
union
{
struct
{
uint32_t CurrentPictureYSurfaceBTI :32;
};
struct
{
uint32_t Value;
};
} DW82;
// DW83
union
{
struct
{
uint32_t CurrentPictureInterleavedUVSurfaceBTI :32;
};
struct
{
uint32_t Value;
};
} DW83;
// DW84
union
{
struct
{
uint32_t HMEMVDataSurfaceBTI :32;
};
struct
{
uint32_t Value;
};
} DW84;
// DW85
union
{
struct
{
uint32_t MVDataSurfaceBTI :32;
};
struct
{
uint32_t Value;
};
} DW85;
// DW86
union
{
struct
{
uint32_t MbCountPerReferenceFrameBTI :32;
};
struct
{
uint32_t Value;
};
} DW86;
// DW87
union
{
struct
{
uint32_t VMEInterPredictionBTI :32;
};
struct
{
uint32_t Value;
};
} DW87;
// DW88
union
{
struct
{
uint32_t ActiveRef1BTI : 32;
};
struct
{
uint32_t Value;
};
} DW88;
// DW89
union
{
struct
{
uint32_t ActiveRef2BTI : 32;
};
struct
{
uint32_t Value;
};
} DW89;
// DW90
union
{
struct
{
uint32_t ActiveRef3BTI : 32;
};
struct
{
uint32_t Value;
};
} DW90;
// DW91
union
{
struct
{
uint32_t PerMbQuantDataBTI :32;
};
struct
{
uint32_t Value;
};
} DW91;
// DW92
union
{
struct
{
uint32_t SegmentMapBTI :32;
};
struct
{
uint32_t Value;
};
} DW92;
// DW93
union
{
struct
{
uint32_t InterPredictionDistortionBTI :32;
};
struct
{
uint32_t Value;
};
} DW93;
// DW94
union
{
struct
{
uint32_t HistogramBTI :32;
};
struct
{
uint32_t Value;
};
} DW94;
// DW95
union
{
struct
{
uint32_t PredMVDataBTI :32;
};
struct
{
uint32_t Value;
};
} DW95;
// DW96
union
{
struct
{
uint32_t ModeCostUpdateBTI :32;
};
struct
{
uint32_t Value;
};
} DW96;
// DW97
union
{
struct
{
uint32_t KernelDebugDumpBTI :32;
};
struct
{
uint32_t Value;
};
} DW97;
};
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(struct MediaObjectVp8MbencPStaticDataG10)) == 98);
struct MediaObjectVp8MpuFhbStaticDataG10
{
// uint32_t 0
union {
struct {
uint32_t FrameWidth : MOS_BITFIELD_RANGE( 0,15 ); //
uint32_t FrameHeight : MOS_BITFIELD_RANGE( 16,31 ); //
};
uint32_t Value;
} DW0;
// uint32_t 1
union {
struct {
uint32_t FrameType : MOS_BITFIELD_BIT( 0 ); //
uint32_t Version : MOS_BITFIELD_RANGE( 1, 3 ); //
uint32_t ShowFrame : MOS_BITFIELD_BIT( 4 ); //
uint32_t HorizontalScaleCode : MOS_BITFIELD_RANGE( 5, 6 ); //
uint32_t VerticalScaleCode : MOS_BITFIELD_RANGE( 7, 8 ); //
uint32_t ColorSpaceType : MOS_BITFIELD_BIT( 9 ); //
uint32_t ClampType : MOS_BITFIELD_BIT( 10 ); //
uint32_t PartitionNumL2 : MOS_BITFIELD_RANGE( 11,12 ); //
uint32_t EnableSegmentation : MOS_BITFIELD_BIT( 13 ); //
uint32_t SegMapUpdate : MOS_BITFIELD_BIT( 14 ); //
uint32_t SegmentationFeatureUpdate : MOS_BITFIELD_BIT( 15 ); //
uint32_t SegmentationFeatureMode : MOS_BITFIELD_BIT( 16 ); //
uint32_t LoopFilterType : MOS_BITFIELD_BIT( 17 ); //
uint32_t SharpnessLevel : MOS_BITFIELD_RANGE( 18,20 ); //
uint32_t LoopFilterAdjustmentOn : MOS_BITFIELD_BIT( 21 ); //
uint32_t MBNoCoeffiscientSkip : MOS_BITFIELD_BIT( 22 ); //
uint32_t GoldenReferenceCopyFlag : MOS_BITFIELD_RANGE( 23,24 ); //
uint32_t AlternateReferenceCopyFlag : MOS_BITFIELD_RANGE( 25,26 ); //
uint32_t LastFrameUpdate : MOS_BITFIELD_BIT( 27 ); //
uint32_t SignBiasGolden : MOS_BITFIELD_BIT( 28 ); //
uint32_t SignBiasAltRef : MOS_BITFIELD_BIT( 29 ); //
uint32_t RefreshEntropyP : MOS_BITFIELD_BIT( 30 ); //
uint32_t ForcedLFUpdateForKeyFrame : MOS_BITFIELD_BIT( 31 ); //
};
uint32_t Value;
} DW1;
// uint32_t 2
union {
struct {
uint32_t LoopFilterLevel : MOS_BITFIELD_RANGE( 0, 5 ); //
uint32_t : MOS_BITFIELD_RANGE( 6, 7 ); //
uint32_t Qindex : MOS_BITFIELD_RANGE( 8,14 ); //
uint32_t : MOS_BITFIELD_BIT( 15 ); //
uint32_t Y1DCQindex : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t Y2DCQindex : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW2;
// uint32_t 3
union {
struct {
uint32_t Y2ACQindex : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t UVDCQindex : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t UVACQindex : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t FeatureData0Segment0 : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW3;
// uint32_t 4
union {
struct {
uint32_t FeatureData0Segment1 : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t FeatureData0Segment2 : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t FeatureData0Segment3 : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t FeatureData1Segment0 : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW4;
// uint32_t 5
union {
struct {
uint32_t FeatureData1Segment1 : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t FeatureData1Segment2 : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t FeatureData1Segment3 : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t RefLFDelta0 : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW5;
// uint32_t 6
union {
struct {
uint32_t RefLFDelta1 : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t RefLFDelta2 : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t RefLFDelta3 : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t ModeLFDelta0 : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW6;
// uint32_t 7
union {
struct {
uint32_t ModeLFDelta1 : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t ModeLFDelta2 : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t ModeLFDelta3 : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t ForcedTokenSurfaceRead : MOS_BITFIELD_BIT( 24 );
uint32_t ModecostEnableFlag : MOS_BITFIELD_BIT( 25 );
uint32_t MCFilterSelect : MOS_BITFIELD_BIT( 26 );
uint32_t ChromaFullPixelMCFilterMode : MOS_BITFIELD_BIT(27);
uint32_t MaxNumPakPasses : MOS_BITFIELD_RANGE(28, 31); //
};
uint32_t Value;
} DW7;
// uint32_t 8
union {
struct {
uint32_t TemporalLayerID : MOS_BITFIELD_RANGE(0, 7); //
uint32_t NumTLevels : MOS_BITFIELD_RANGE(8, 15); //
uint32_t ReservedMBZ : MOS_BITFIELD_RANGE(16, 31); //
};
uint32_t Value;
} DW8;
// uint32_t 9
union {
struct {
uint32_t ReservedMBZ : MOS_BITFIELD_RANGE(0, 31); //
};
uint32_t Value;
} DW9;
// uint32_t 10
union {
struct {
uint32_t ReservedMBZ : MOS_BITFIELD_RANGE(0, 31); //
};
uint32_t Value;
} DW10;
// uint32_t 11
union {
struct {
uint32_t ReservedMBZ : MOS_BITFIELD_RANGE(0, 31); //
};
uint32_t Value;
} DW11;
// uint32_t 12
union {
struct {
uint32_t HistogramBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW12;
// uint32_t 13
union {
struct {
uint32_t ReferenceModeProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW13;
// uint32_t 14
union {
struct {
uint32_t ModeProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW14;
// uint32_t 15
union {
struct {
uint32_t ReferenceTokenProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW15;
// uint32_t 16
union {
struct {
uint32_t TokenProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW16;
// uint32_t 17
union {
struct {
uint32_t FrameHeaderBitstreamBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW17;
// uint32_t 18
union {
struct {
uint32_t HeaderMetaDataBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW18;
// uint32_t 19
union {
struct {
uint32_t PictureStateBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW19;
// uint32_t 20
union {
struct {
uint32_t MPUBitStreamBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW20;
union {
struct {
uint32_t TokenBitsDataBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW21;
union {
struct {
uint32_t KernelDebugDumpBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW22;
union {
struct {
uint32_t EntropyCostBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW23;
union {
struct {
uint32_t ModeCostUpdateBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW24;
};
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(struct MediaObjectVp8MpuFhbStaticDataG10)) == 25);
struct MediaObjectVp8TpuFhbStaticDataG10
{
// uint32_t 0
union {
struct {
uint32_t MBsInFrame : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW0;
// uint32_t 1
union {
struct {
uint32_t FrameType : MOS_BITFIELD_BIT( 0 ); //
uint32_t EnableSegmentation : MOS_BITFIELD_BIT( 1 ); //
uint32_t RebinarizationFrameHdr : MOS_BITFIELD_BIT( 2 ); //
uint32_t RefreshEntropyP : MOS_BITFIELD_BIT( 3 ); //
uint32_t MBNoCoeffiscientSkip : MOS_BITFIELD_BIT( 4 ); //
uint32_t : MOS_BITFIELD_RANGE( 5,31 ); //
};
uint32_t Value;
} DW1;
// uint32_t 2
union {
struct {
uint32_t TokenProbabilityStatOffset : MOS_BITFIELD_RANGE( 0,15 ); //
uint32_t TokenProbabilityEndOffset : MOS_BITFIELD_RANGE( 16,31 ); //
};
uint32_t Value;
} DW2;
// uint32_t 3
union {
struct {
uint32_t FrameHeaderBitCount : MOS_BITFIELD_RANGE( 0,15 ); //
uint32_t MaxQP : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t MinQP : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW3;
// uint32_t 4
union {
struct {
uint32_t LoopFilterLevelSegment0 : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t LoopFilterLevelSegment1 : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t LoopFilterLevelSegment2 : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t LoopFilterLevelSegment3 : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW4;
// uint32_t 5
union {
struct {
uint32_t QuantizationIndexSegment0 : MOS_BITFIELD_RANGE( 0, 7 ); //
uint32_t QuantizationIndexSegment1 : MOS_BITFIELD_RANGE( 8,15 ); //
uint32_t QuantizationIndexSegment2 : MOS_BITFIELD_RANGE( 16,23 ); //
uint32_t QuantizationIndexSegment3 : MOS_BITFIELD_RANGE( 24,31 ); //
};
uint32_t Value;
} DW5;
// uint32_t 6
union {
struct {
uint32_t PakPassNum : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW6;
// uint32_t 7
union {
struct {
uint32_t TokenCostDeltaThreshold : MOS_BITFIELD_RANGE(0, 15); //
uint32_t SkipCostDeltaThreshold : MOS_BITFIELD_RANGE(16, 31); //
};
uint32_t Value;
} DW7;
// uint32_t 8
union {
struct {
uint32_t CumulativeDQIndex01 : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW8;
// uint32_t 9
union {
struct {
uint32_t CumulativeDQIndex02 : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW9;
// uint32_t 10
union {
struct {
uint32_t CumulativeLoopFilter01 : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW10;
// uint32_t 11
union {
struct {
uint32_t CumulativeLoopFilter02 : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW11;
// uint32_t 12
union {
struct {
uint32_t PakTokenStatisticsBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW12;
// uint32_t 13
union {
struct {
uint32_t TokenUpdateFlagsBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW13;
// uint32_t 14
union {
struct {
uint32_t EntropyCostTableBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW14;
// uint32_t 15
union {
struct {
uint32_t FrameHeaderBitstreamBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW15;
// uint32_t 16
union {
struct {
uint32_t DefaultTokenProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW16;
// uint32_t 17
union {
struct {
uint32_t PictureStateBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW17;
// uint32_t 18
union {
struct {
uint32_t MpuCurbeDataBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW18;
// uint32_t 19
union {
struct {
uint32_t HeaderMetaDataBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW19;
// uint32_t 20
union {
struct {
uint32_t TokenProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW20;
// uint32_t 21
union {
struct {
uint32_t PakHardwareTokenProbabilityPass1BTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW21;
// uint32_t 22
union {
struct {
uint32_t KeyFrameTokenProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW22;
// uint32_t 23
union {
struct {
uint32_t UpdatedTokenProbabilityBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW23;
// uint32_t 24
union {
struct {
uint32_t PakHardwareTokenProbabilityPass2BTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW24;
// uint32_t 25
union {
struct {
uint32_t KernelDebugDumpBTI : MOS_BITFIELD_RANGE( 0, 31); //
};
uint32_t Value;
} DW25;
// uint32_t 26
union {
struct {
uint32_t RepakDecisionSurfaceBTI : MOS_BITFIELD_RANGE(0, 31); //
};
uint32_t Value;
} DW26;
};
C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(struct MediaObjectVp8TpuFhbStaticDataG10)) == 27);
struct CodechalVp8KernelHeaderG10 {
int nKernelCount;
// Normal mode
CODECHAL_KERNEL_HEADER VP8MBEnc_Norm_Frm_I;
CODECHAL_KERNEL_HEADER VP8MBEnc_Norm_Frm_P;
// MPU/FHB
CODECHAL_KERNEL_HEADER VP8_MPU;
// TPU
CODECHAL_KERNEL_HEADER VP8_TPU;
// Intra prediction mode search for only luma components of key-frame.
// To be used when HW intra prediction is disabled.
CODECHAL_KERNEL_HEADER VP8MBEnc_I_Luma;
// HME
CODECHAL_KERNEL_HEADER VP8_ME_P;
// DownScaling
CODECHAL_KERNEL_HEADER PLY_DScale_PLY;
// MBEnc I Dist
CODECHAL_KERNEL_HEADER VP8MBEnc_I_Dist;
// BRC Init
CODECHAL_KERNEL_HEADER VP8_BRC_InitFrame;
// BRC Reset
CODECHAL_KERNEL_HEADER VP8_BRC_ResetFrame;
// BRC Update
CODECHAL_KERNEL_HEADER VP8_BRC_FrameEncUpdate;
};
const uint8_t VP8_IFRAME_VME_COSTS_G10[128][4] =
{
{0x05, 0x1f, 0x02, 0x09},
{0x05, 0x1f, 0x02, 0x09},
{0x08, 0x2b, 0x03, 0x0e},
{0x08, 0x2b, 0x03, 0x0e},
{0x0a, 0x2f, 0x04, 0x12},
{0x0a, 0x2f, 0x04, 0x12},
{0x0d, 0x39, 0x05, 0x17},
{0x0d, 0x39, 0x05, 0x17},
{0x0d, 0x39, 0x05, 0x17},
{0x0f, 0x3b, 0x06, 0x1b},
{0x0f, 0x3b, 0x06, 0x1b},
{0x19, 0x3d, 0x07, 0x20},
{0x19, 0x3d, 0x07, 0x20},
{0x1a, 0x3f, 0x08, 0x24},
{0x1a, 0x3f, 0x08, 0x24},
{0x1a, 0x3f, 0x08, 0x24},
{0x1b, 0x48, 0x09, 0x29},
{0x1b, 0x48, 0x09, 0x29},
{0x1d, 0x49, 0x09, 0x2d},
{0x1d, 0x49, 0x09, 0x2d},
{0x1d, 0x49, 0x09, 0x2d},
{0x1d, 0x49, 0x09, 0x2d},
{0x1e, 0x4a, 0x0a, 0x32},
{0x1e, 0x4a, 0x0a, 0x32},
{0x1e, 0x4a, 0x0a, 0x32},
{0x1e, 0x4a, 0x0a, 0x32},
{0x1f, 0x4b, 0x0b, 0x36},
{0x1f, 0x4b, 0x0b, 0x36},
{0x1f, 0x4b, 0x0b, 0x36},
{0x28, 0x4c, 0x0c, 0x3b},
{0x28, 0x4c, 0x0c, 0x3b},
{0x29, 0x4d, 0x0d, 0x3f},
{0x29, 0x4d, 0x0d, 0x3f},
{0x29, 0x4e, 0x0e, 0x44},
{0x29, 0x4e, 0x0e, 0x44},
{0x2a, 0x4f, 0x0f, 0x48},
{0x2a, 0x4f, 0x0f, 0x48},
{0x2b, 0x58, 0x10, 0x4d},
{0x2b, 0x58, 0x10, 0x4d},
{0x2b, 0x58, 0x11, 0x51},
{0x2b, 0x58, 0x11, 0x51},
{0x2b, 0x58, 0x11, 0x51},
{0x2c, 0x58, 0x12, 0x56},
{0x2c, 0x58, 0x12, 0x56},
{0x2c, 0x59, 0x13, 0x5a},
{0x2c, 0x59, 0x13, 0x5a},
{0x2d, 0x59, 0x14, 0x5f},
{0x2d, 0x59, 0x14, 0x5f},
{0x2e, 0x5a, 0x15, 0x63},
{0x2e, 0x5a, 0x15, 0x63},
{0x2e, 0x5a, 0x16, 0x68},
{0x2e, 0x5a, 0x16, 0x68},
{0x2e, 0x5a, 0x16, 0x68},
{0x2f, 0x5b, 0x17, 0x6c},
{0x2f, 0x5b, 0x17, 0x6c},
{0x38, 0x5b, 0x18, 0x71},
{0x38, 0x5b, 0x18, 0x71},
{0x38, 0x5c, 0x19, 0x76},
{0x38, 0x5c, 0x19, 0x76},
{0x38, 0x5c, 0x1a, 0x7a},
{0x38, 0x5c, 0x1a, 0x7a},
{0x39, 0x5d, 0x1a, 0x7f},
{0x39, 0x5d, 0x1a, 0x7f},
{0x39, 0x5d, 0x1b, 0x83},
{0x39, 0x5d, 0x1b, 0x83},
{0x39, 0x5e, 0x1c, 0x88},
{0x39, 0x5e, 0x1c, 0x88},
{0x3a, 0x5e, 0x1d, 0x8c},
{0x3a, 0x5e, 0x1d, 0x8c},
{0x3a, 0x5f, 0x1e, 0x91},
{0x3a, 0x5f, 0x1e, 0x91},
{0x3a, 0x5f, 0x1f, 0x95},
{0x3a, 0x5f, 0x1f, 0x95},
{0x3a, 0x68, 0x20, 0x9a},
{0x3a, 0x68, 0x20, 0x9a},
{0x3b, 0x68, 0x21, 0x9e},
{0x3b, 0x68, 0x21, 0x9e},
{0x3b, 0x68, 0x22, 0xa3},
{0x3b, 0x68, 0x22, 0xa3},
{0x3b, 0x68, 0x23, 0xa7},
{0x3b, 0x68, 0x23, 0xa7},
{0x3c, 0x68, 0x24, 0xac},
{0x3c, 0x68, 0x24, 0xac},
{0x3c, 0x68, 0x24, 0xac},
{0x3c, 0x69, 0x25, 0xb0},
{0x3c, 0x69, 0x25, 0xb0},
{0x3c, 0x69, 0x26, 0xb5},
{0x3c, 0x69, 0x26, 0xb5},
{0x3d, 0x69, 0x27, 0xb9},
{0x3d, 0x69, 0x27, 0xb9},
{0x3d, 0x69, 0x28, 0xbe},
{0x3d, 0x69, 0x28, 0xbe},
{0x3d, 0x6a, 0x29, 0xc2},
{0x3d, 0x6a, 0x29, 0xc2},
{0x3e, 0x6a, 0x2a, 0xc7},
{0x3e, 0x6a, 0x2a, 0xc7},
{0x3e, 0x6a, 0x2b, 0xcb},
{0x3e, 0x6a, 0x2b, 0xd0},
{0x3f, 0x6b, 0x2c, 0xd4},
{0x3f, 0x6b, 0x2d, 0xd9},
{0x3f, 0x6b, 0x2e, 0xdd},
{0x48, 0x6b, 0x2f, 0xe2},
{0x48, 0x6b, 0x2f, 0xe2},
{0x48, 0x6c, 0x30, 0xe6},
{0x48, 0x6c, 0x31, 0xeb},
{0x48, 0x6c, 0x32, 0xf0},
{0x48, 0x6c, 0x33, 0xf4},
{0x48, 0x6c, 0x34, 0xf9},
{0x49, 0x6d, 0x35, 0xfd},
{0x49, 0x6d, 0x36, 0xff},
{0x49, 0x6d, 0x37, 0xff},
{0x49, 0x6d, 0x38, 0xff},
{0x49, 0x6e, 0x3a, 0xff},
{0x49, 0x6e, 0x3b, 0xff},
{0x4a, 0x6e, 0x3c, 0xff},
{0x4a, 0x6f, 0x3d, 0xff},
{0x4a, 0x6f, 0x3d, 0xff},
{0x4a, 0x6f, 0x3e, 0xff},
{0x4a, 0x6f, 0x3f, 0xff},
{0x4a, 0x6f, 0x40, 0xff},
{0x4b, 0x78, 0x41, 0xff},
{0x4b, 0x78, 0x42, 0xff},
{0x4b, 0x78, 0x43, 0xff},
{0x4b, 0x78, 0x44, 0xff},
{0x4b, 0x78, 0x46, 0xff},
{0x4c, 0x78, 0x47, 0xff},
{0x4c, 0x79, 0x49, 0xff},
{0x4c, 0x79, 0x4a, 0xff}
};
const uint32_t VP8_NewMVSkipThreshold_G10[128] =
{
111, 120, 129, 137, 146, 155, 163, 172, 180, 189, 198, 206, 215, 224, 232, 241,
249, 258, 267, 275, 284, 293, 301, 310, 318, 327, 336, 344, 353, 362, 370, 379,
387, 396, 405, 413, 422, 431, 439, 448, 456, 465, 474, 482, 491, 500, 508, 517,
525, 534, 543, 551, 560, 569, 577, 586, 594, 603, 612, 620, 629, 638, 646, 655,
663, 672, 681, 689, 698, 707, 715, 724, 733, 741, 750, 758, 767, 776, 784, 793,
802, 810, 819, 827, 836, 845, 853, 862, 871, 879, 888, 896, 905, 914, 922, 931,
940, 948, 957, 965, 974, 983, 991, 1000, 1009, 1017, 1026, 1034, 1043, 1052, 1060, 1069,
1078, 1086, 1095, 1103, 1112, 1121, 1129, 1138, 1147, 1155, 1164, 1172, 1181, 1190, 1198, 1208
};
const uint32_t VP8_COST_TABLE_G10[128][7] =
{
{0x398f0500, 0x6f6f6f6f, 0x0000006f, 0x06040402, 0x1a0c0907, 0x08, 0x0e},
{0x3b8f0600, 0x6f6f6f6f, 0x0000006f, 0x06040402, 0x1a0c0907, 0x0a, 0x11},
{0x3e8f0700, 0x6f6f6f6f, 0x0000006f, 0x06040402, 0x1a0c0907, 0x0c, 0x14},
{0x488f0800, 0x6f6f6f6f, 0x0000006f, 0x06040402, 0x1a0c0907, 0x0f, 0x18},
{0x498f0a00, 0x6f6f6f6f, 0x0000006f, 0x0d080805, 0x291b190e, 0x11, 0x1b},
{0x4a8f0b00, 0x6f6f6f6f, 0x0000006f, 0x0d080805, 0x291b190e, 0x13, 0x1e},
{0x4b8f0c00, 0x6f6f6f6f, 0x0000006f, 0x0d080805, 0x291b190e, 0x15, 0x22},
{0x4b8f0c00, 0x6f6f6f6f, 0x0000006f, 0x0d080805, 0x291b190e, 0x15, 0x22},
{0x4d8f0d00, 0x6f6f6f6f, 0x0000006f, 0x0d080805, 0x291b190e, 0x17, 0x25},
{0x4e8f0e00, 0x6f6f6f6f, 0x0000006f, 0x190b0c07, 0x2e281e1a, 0x19, 0x29},
{0x4f8f0f00, 0x6f6f6f6f, 0x0000006f, 0x190b0c07, 0x2e281e1a, 0x1b, 0x2c},
{0x588f1800, 0x6f6f6f6f, 0x0000006f, 0x190b0c07, 0x2e281e1a, 0x1d, 0x2f},
{0x588f1900, 0x6f6f6f6f, 0x0000006f, 0x190b0c07, 0x2e281e1a, 0x1f, 0x33},
{0x598f1900, 0x6f6f6f6f, 0x0000006f, 0x1c0f0f0a, 0x392b291e, 0x21, 0x36},
{0x5a8f1a00, 0x6f6f6f6f, 0x0000006f, 0x1c0f0f0a, 0x392b291e, 0x23, 0x3a},
{0x5a8f1a00, 0x6f6f6f6f, 0x0000006f, 0x1c0f0f0a, 0x392b291e, 0x23, 0x3a},
{0x5a8f1a00, 0x6f6f6f6f, 0x0000006f, 0x1c0f0f0a, 0x392b291e, 0x25, 0x3d},
{0x5b8f1b00, 0x6f6f6f6f, 0x0000006f, 0x1c0f0f0a, 0x392b291e, 0x27, 0x40},
{0x5b8f1c00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x2a, 0x44},
{0x5b8f1c00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x2a, 0x44},
{0x5c8f1c00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x2c, 0x47},
{0x5c8f1c00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x2c, 0x47},
{0x5d8f1d00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x2e, 0x4a},
{0x5d8f1d00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x2e, 0x4a},
{0x5d8f1d00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x30, 0x4e},
{0x5d8f1d00, 0x6f6f6f6f, 0x0000006f, 0x2819190c, 0x3c2e2b29, 0x30, 0x4e},
{0x5e8f1e00, 0x6f6f6f6f, 0x0000006f, 0x291b1b0f, 0x3e382e2a, 0x32, 0x51},
{0x5e8f1f00, 0x6f6f6f6f, 0x0000006f, 0x291b1b0f, 0x3e382e2a, 0x34, 0x55},
{0x5e8f1f00, 0x6f6f6f6f, 0x0000006f, 0x291b1b0f, 0x3e382e2a, 0x34, 0x55},
{0x5f8f1f00, 0x6f6f6f6f, 0x0000006f, 0x291b1b0f, 0x3e382e2a, 0x36, 0x58},
{0x688f2800, 0x6f6f6f6f, 0x0000006f, 0x291b1b0f, 0x3e382e2a, 0x38, 0x5b},
{0x688f2800, 0x6f6f6f6f, 0x0000006f, 0x2b1d1d18, 0x483a382c, 0x3a, 0x5f},
{0x688f2800, 0x6f6f6f6f, 0x0000006f, 0x2b1d1d18, 0x483a382c, 0x3c, 0x62},
{0x688f2900, 0x6f6f6f6f, 0x0000006f, 0x2b1d1d18, 0x483a382c, 0x3e, 0x65},
{0x698f2900, 0x6f6f6f6f, 0x0000006f, 0x2b1d1d18, 0x483a382c, 0x40, 0x69},
{0x698f2900, 0x6f6f6f6f, 0x0000006f, 0x2c1f1f19, 0x493b392e, 0x43, 0x6c},
{0x698f2900, 0x6f6f6f6f, 0x0000006f, 0x2c1f1f19, 0x493b392e, 0x45, 0x70},
{0x6a8f2a00, 0x6f6f6f6f, 0x0000006f, 0x2c1f1f19, 0x493b392e, 0x47, 0x73},
{0x6a8f2a00, 0x6f6f6f6f, 0x0000006f, 0x2c1f1f19, 0x493b392e, 0x49, 0x76},
{0x6a8f2a00, 0x6f6f6f6f, 0x0000006f, 0x2e28281b, 0x4b3d3a38, 0x4b, 0x7a},
{0x6b8f2b00, 0x6f6f6f6f, 0x0000006f, 0x2e28281b, 0x4b3d3a38, 0x4d, 0x7d},
{0x6b8f2b00, 0x6f6f6f6f, 0x0000006f, 0x2e28281b, 0x4b3d3a38, 0x4d, 0x7d},
{0x6b8f2b00, 0x6f6f6f6f, 0x0000006f, 0x2e28281b, 0x4b3d3a38, 0x4f, 0x81},
{0x6b8f2b00, 0x6f6f6f6f, 0x0000006f, 0x2e28281b, 0x4b3d3a38, 0x51, 0x84},
{0x6b8f2c00, 0x6f6f6f6f, 0x0000006f, 0x2f29291c, 0x4c3e3b38, 0x53, 0x87},
{0x6c8f2c00, 0x6f6f6f6f, 0x0000006f, 0x2f29291c, 0x4c3e3b38, 0x55, 0x8b},
{0x6c8f2c00, 0x6f6f6f6f, 0x0000006f, 0x2f29291c, 0x4c3e3b38, 0x57, 0x8e},
{0x6c8f2c00, 0x6f6f6f6f, 0x0000006f, 0x2f29291c, 0x4c3e3b38, 0x59, 0x91},
{0x6d8f2d00, 0x6f6f6f6f, 0x0000006f, 0x382a2a1d, 0x4d483c39, 0x5b, 0x95},
{0x6d8f2d00, 0x6f6f6f6f, 0x0000006f, 0x382a2a1d, 0x4d483c39, 0x5e, 0x98},
{0x6d8f2d00, 0x6f6f6f6f, 0x0000006f, 0x382a2a1d, 0x4d483c39, 0x60, 0x9c},
{0x6d8f2d00, 0x6f6f6f6f, 0x0000006f, 0x382a2a1d, 0x4d483c39, 0x60, 0x9c},
{0x6d8f2e00, 0x6f6f6f6f, 0x0000006f, 0x382a2a1d, 0x4d483c39, 0x62, 0x9f},
{0x6e8f2e00, 0x6f6f6f6f, 0x0000006f, 0x392b2b1e, 0x4e483e3a, 0x64, 0xa2},
{0x6e8f2e00, 0x6f6f6f6f, 0x0000006f, 0x392b2b1e, 0x4e483e3a, 0x66, 0xa6},
{0x6e8f2e00, 0x6f6f6f6f, 0x0000006f, 0x392b2b1e, 0x4e483e3a, 0x68, 0xa9},
{0x6f8f2f00, 0x6f6f6f6f, 0x0000006f, 0x392b2b1e, 0x4e483e3a, 0x6a, 0xad},
{0x6f8f2f00, 0x6f6f6f6f, 0x0000006f, 0x3a2c2c1f, 0x4f493f3b, 0x6c, 0xb0},
{0x6f8f2f00, 0x6f6f6f6f, 0x0000006f, 0x3a2c2c1f, 0x4f493f3b, 0x6e, 0xb3},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3a2c2c1f, 0x4f493f3b, 0x70, 0xb7},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3a2c2c1f, 0x4f493f3b, 0x72, 0xba},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3b2d2d28, 0x584a483c, 0x74, 0xbd},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3b2d2d28, 0x584a483c, 0x76, 0xc1},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3b2d2d28, 0x584a483c, 0x79, 0xc4},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3b2d2d28, 0x584a483c, 0x7b, 0xc8},
{0x788f3800, 0x6f6f6f6f, 0x0000006f, 0x3b2e2e29, 0x594b483d, 0x7d, 0xcb},
{0x798f3900, 0x6f6f6f6f, 0x0000006f, 0x3b2e2e29, 0x594b483d, 0x7f, 0xce},
{0x798f3900, 0x6f6f6f6f, 0x0000006f, 0x3b2e2e29, 0x594b483d, 0x81, 0xd2},
{0x798f3900, 0x6f6f6f6f, 0x0000006f, 0x3b2e2e29, 0x594b483d, 0x83, 0xd5},
{0x798f3900, 0x6f6f6f6f, 0x0000006f, 0x3c2f2f29, 0x594b493e, 0x85, 0xd9},
{0x798f3900, 0x6f6f6f6f, 0x0000006f, 0x3c2f2f29, 0x594b493e, 0x87, 0xdc},
{0x798f3900, 0x6f6f6f6f, 0x0000006f, 0x3c2f2f29, 0x594b493e, 0x89, 0xdf},
{0x798f3a00, 0x6f6f6f6f, 0x0000006f, 0x3c2f2f29, 0x594b493e, 0x8b, 0xe3},
{0x7a8f3a00, 0x6f6f6f6f, 0x0000006f, 0x3d38382a, 0x5a4c493f, 0x8d, 0xe6},
{0x7a8f3a00, 0x6f6f6f6f, 0x0000006f, 0x3d38382a, 0x5a4c493f, 0x8f, 0xe9},
{0x7a8f3a00, 0x6f6f6f6f, 0x0000006f, 0x3d38382a, 0x5a4c493f, 0x91, 0xed},
{0x7a8f3a00, 0x6f6f6f6f, 0x0000006f, 0x3d38382a, 0x5a4c493f, 0x94, 0xf0},
{0x7a8f3a00, 0x6f6f6f6f, 0x0000006f, 0x3e38382b, 0x5b4d4a48, 0x96, 0xf4},
{0x7a8f3a00, 0x6f6f6f6f, 0x0000006f, 0x3e38382b, 0x5b4d4a48, 0x98, 0xf7},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3e38382b, 0x5b4d4a48, 0x9a, 0xfa},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3e38382b, 0x5b4d4a48, 0x9c, 0xfe},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3f38392b, 0x5b4d4b48, 0x9e, 0xff},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3f38392b, 0x5b4d4b48, 0x9e, 0xff},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3f38392b, 0x5b4d4b48, 0xa0, 0xff},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3f38392b, 0x5b4d4b48, 0xa2, 0xff},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3f38392b, 0x5b4d4b48, 0xa4, 0xff},
{0x7b8f3b00, 0x6f6f6f6f, 0x0000006f, 0x3f39392c, 0x5c4e4b48, 0xa6, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x3f39392c, 0x5c4e4b48, 0xa8, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x3f39392c, 0x5c4e4b48, 0xaa, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x3f39392c, 0x5c4e4b48, 0xac, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x48393a2c, 0x5c4f4c49, 0xaf, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x48393a2c, 0x5c4f4c49, 0xb1, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x48393a2c, 0x5c4f4c49, 0xb3, 0xff},
{0x7c8f3c00, 0x6f6f6f6f, 0x0000006f, 0x48393a2c, 0x5c4f4c49, 0xb5, 0xff},
{0x7d8f3d00, 0x6f6f6f6f, 0x0000006f, 0x483a3a2d, 0x5d584c49, 0xb7, 0xff},
{0x7d8f3d00, 0x6f6f6f6f, 0x0000006f, 0x483a3a2d, 0x5d584c49, 0xb9, 0xff},
{0x7d8f3d00, 0x6f6f6f6f, 0x0000006f, 0x483a3a2d, 0x5d584c49, 0xbd, 0xff},
{0x7d8f3d00, 0x6f6f6f6f, 0x0000006f, 0x493a3b2e, 0x5e584d4a, 0xc1, 0xff},
{0x7e8f3e00, 0x6f6f6f6f, 0x0000006f, 0x493a3b2e, 0x5e584d4a, 0xc5, 0xff},
{0x7e8f3e00, 0x6f6f6f6f, 0x0000006f, 0x493b3b2e, 0x5e584e4a, 0xc8, 0xff},
{0x7e8f3e00, 0x6f6f6f6f, 0x0000006f, 0x493b3b2e, 0x5e584e4a, 0xcc, 0xff},
{0x7e8f3e00, 0x6f6f6f6f, 0x0000006f, 0x493b3c2f, 0x5f594e4b, 0xd0, 0xff},
{0x7f8f3f00, 0x6f6f6f6f, 0x0000006f, 0x493b3c2f, 0x5f594e4b, 0xd2, 0xff},
{0x7f8f3f00, 0x6f6f6f6f, 0x0000006f, 0x493b3c2f, 0x5f594e4b, 0xd4, 0xff},
{0x7f8f3f00, 0x6f6f6f6f, 0x0000006f, 0x4a3c3c2f, 0x5f594f4b, 0xd8, 0xff},
{0x7f8f3f00, 0x6f6f6f6f, 0x0000006f, 0x4a3c3c2f, 0x5f594f4b, 0xdc, 0xff},
{0x888f4800, 0x6f6f6f6f, 0x0000006f, 0x4a3c3d38, 0x68594f4c, 0xe0, 0xff},
{0x888f4800, 0x6f6f6f6f, 0x0000006f, 0x4a3c3d38, 0x68594f4c, 0xe5, 0xff},
{0x888f4800, 0x6f6f6f6f, 0x0000006f, 0x4b3d3d38, 0x685a584c, 0xe9, 0xff},
{0x888f4800, 0x6f6f6f6f, 0x0000006f, 0x4b3d3d38, 0x685a584c, 0xed, 0xff},
{0x888f4800, 0x6f6f6f6f, 0x0000006f, 0x4b3d3e38, 0x685a584c, 0xf1, 0xff},
{0x888f4800, 0x6f6f6f6f, 0x0000006f, 0x4b3d3e38, 0x685a584c, 0xf5, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4b3e3e39, 0x695b584d, 0xfe, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4c3e3e39, 0x695b594d, 0xff, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4c3e3e39, 0x695b594d, 0xff, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4c3f3f39, 0x695b594e, 0xff, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4c3f3f39, 0x695b594e, 0xff, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4d3f3f3a, 0x6a5c594e, 0xff, 0xff},
{0x898f4900, 0x6f6f6f6f, 0x0000006f, 0x4d3f3f3a, 0x6a5c594e, 0xff, 0xff},
{0x8a8f4a00, 0x6f6f6f6f, 0x0000006f, 0x4d48483a, 0x6a5c594f, 0xff, 0xff},
{0x8a8f4a00, 0x6f6f6f6f, 0x0000006f, 0x4d48483a, 0x6a5c594f, 0xff, 0xff},
{0x8a8f4a00, 0x6f6f6f6f, 0x0000006f, 0x4d48483a, 0x6a5c5a4f, 0xff, 0xff},
{0x8a8f4a00, 0x6f6f6f6f, 0x0000006f, 0x4d48483a, 0x6a5c5a4f, 0xff, 0xff},
{0x8a8f4a00, 0x6f6f6f6f, 0x0000006f, 0x4e48483a, 0x6a5d5a58, 0xff, 0xff},
{0x8b8f4b00, 0x6f6f6f6f, 0x0000006f, 0x4e48483b, 0x6b5d5a58, 0xff, 0xff},
{0x8b8f4b00, 0x6f6f6f6f, 0x0000006f, 0x4e48483b, 0x6b5d5a58, 0xff, 0xff},
{0x8b8f4b00, 0x6f6f6f6f, 0x0000006f, 0x4f48493b, 0x6b5d5b58, 0xff, 0xff},
{0x8b8f4b00, 0x6f6f6f6f, 0x0000006f, 0x4f49493b, 0x6b5e5b58, 0xff, 0xff}
};
const uint32_t VP8_SINGLESU[56] =
{
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000
};
const uint8_t VP8_FULLSPIRAL_48x40[56] =
{
// L -> U -> R -> D
0x0F,
0xF0,
0x01, 0x01,
0x10, 0x10,
0x0F, 0x0F, 0x0F,
0xF0, 0xF0, 0xF0,
0x01, 0x01, 0x01, 0x01,
0x10, 0x10, 0x10, 0x10,
0x0F, 0x0F, 0x0F, 0x0F, 0x0F,
0xF0, 0xF0, 0xF0, 0xF0, 0xF0,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // The last 0x10 steps outside the search window.
0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, // These are outside the search window.
0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0
};
const uint8_t VP8_RASTERSCAN_48x40[56] =
{
0x11, 0x01, 0x01, 0x01,
0x11, 0x01, 0x01, 0x01,
0x11, 0x01, 0x01, 0x01,
0x11, 0x01, 0x01, 0x01,
0x11, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00
};
const uint8_t VP8_DIAMOND[56] =
{
0x0F, 0xF1, 0x0F, 0x12,//5
0x0D, 0xE2, 0x22, 0x1E,//9
0x10, 0xFF, 0xE2, 0x20,//13
0xFC, 0x06, 0xDD,//16
0x2E, 0xF1, 0x3F, 0xD3, 0x11, 0x3D, 0xF3, 0x1F,//24
0xEB, 0xF1, 0xF1, 0xF1,//28
0x4E, 0x11, 0x12, 0xF2, 0xF1,//33
0xE0, 0xFF, 0xFF, 0x0D, 0x1F, 0x1F,//39
0x20, 0x11, 0xCF, 0xF1, 0x05, 0x11,//45
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//51
0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
const uint8_t VP8_MAINREF_TABLE_G10[8] =
{
0, 1, 2, 9, 3, 13, 14, 57
};
const uint8_t VP8_NUM_REFS_G10[8] =
{
0, 1, 1, 2, 1, 2, 2, 3
};
const uint8_t VP8_BRC_IFRAME_COST_TABLE_G10[128][4] =
{
{ 0x5, 0x5, 0x8, 0x8},
{ 0xa, 0xa, 0xd, 0xd},
{ 0xd, 0xf, 0xf, 0x19},
{0x19, 0x1a, 0x1a, 0x1a},
{0x1b, 0x1b, 0x1d, 0x1d},
{0x1d, 0x1d, 0x1e, 0x1e},
{0x1e, 0x1e, 0x1f, 0x1f},
{0x1f, 0x28, 0x28, 0x29},
{0x29, 0x29, 0x29, 0x2a},
{0x2a, 0x2b, 0x2b, 0x2b},
{0x2b, 0x2b, 0x2c, 0x2c},
{0x2c, 0x2c, 0x2d, 0x2d},
{0x2e, 0x2e, 0x2e, 0x2e},
{0x2e, 0x2f, 0x2f, 0x38},
{0x38, 0x38, 0x38, 0x38},
{0x38, 0x39, 0x39, 0x39},
{0x39, 0x39, 0x39, 0x3a},
{0x3a, 0x3a, 0x3a, 0x3a},
{0x3a, 0x3a, 0x3a, 0x3b},
{0x3b, 0x3b, 0x3b, 0x3b},
{0x3b, 0x3c, 0x3c, 0x3c},
{0x3c, 0x3c, 0x3c, 0x3c},
{0x3d, 0x3d, 0x3d, 0x3d},
{0x3d, 0x3d, 0x3e, 0x3e},
{0x3e, 0x3e, 0x3f, 0x3f},
{0x3f, 0x48, 0x48, 0x48},
{0x48, 0x48, 0x48, 0x48},
{0x49, 0x49, 0x49, 0x49},
{0x49, 0x49, 0x4a, 0x4a},
{0x4a, 0x4a, 0x4a, 0x4a},
{0x4b, 0x4b, 0x4b, 0x4b},
{0x4b, 0x4c, 0x4c, 0x4c},
{0x1f, 0x1f, 0x2b, 0x2b},
{0x2f, 0x2f, 0x39, 0x39},
{0x39, 0x3b, 0x3b, 0x3d},
{0x3d, 0x3f, 0x3f, 0x3f},
{0x48, 0x48, 0x49, 0x49},
{0x49, 0x49, 0x4a, 0x4a},
{0x4a, 0x4a, 0x4b, 0x4b},
{0x4b, 0x4c, 0x4c, 0x4d},
{0x4d, 0x4e, 0x4e, 0x4f},
{0x4f, 0x58, 0x58, 0x58},
{0x58, 0x58, 0x58, 0x58},
{0x59, 0x59, 0x59, 0x59},
{0x5a, 0x5a, 0x5a, 0x5a},
{0x5a, 0x5b, 0x5b, 0x5b},
{0x5b, 0x5c, 0x5c, 0x5c},
{0x5c, 0x5d, 0x5d, 0x5d},
{0x5d, 0x5e, 0x5e, 0x5e},
{0x5e, 0x5f, 0x5f, 0x5f},
{0x5f, 0x68, 0x68, 0x68},
{0x68, 0x68, 0x68, 0x68},
{0x68, 0x68, 0x68, 0x68},
{0x69, 0x69, 0x69, 0x69},
{0x69, 0x69, 0x69, 0x69},
{0x6a, 0x6a, 0x6a, 0x6a},
{0x6a, 0x6a, 0x6b, 0x6b},
{0x6b, 0x6b, 0x6b, 0x6c},
{0x6c, 0x6c, 0x6c, 0x6c},
{0x6d, 0x6d, 0x6d, 0x6d},
{0x6e, 0x6e, 0x6e, 0x6f},
{0x6f, 0x6f, 0x6f, 0x6f},
{0x78, 0x78, 0x78, 0x78},
{0x78, 0x78, 0x79, 0x79},
{ 0x2, 0x2, 0x3, 0x3},
{ 0x4, 0x4, 0x5, 0x5},
{ 0x5, 0x6, 0x6, 0x7},
{ 0x7, 0x8, 0x8, 0x8},
{ 0x9, 0x9, 0x9, 0x9},
{ 0x9, 0x9, 0xa, 0xa},
{ 0xa, 0xa, 0xb, 0xb},
{ 0xb, 0xc, 0xc, 0xd},
{ 0xd, 0xe, 0xe, 0xf},
{ 0xf, 0x10, 0x10, 0x11},
{0x11, 0x11, 0x12, 0x12},
{0x13, 0x13, 0x14, 0x14},
{0x15, 0x15, 0x16, 0x16},
{0x16, 0x17, 0x17, 0x18},
{0x18, 0x19, 0x19, 0x1a},
{0x1a, 0x1a, 0x1a, 0x1b},
{0x1b, 0x1c, 0x1c, 0x1d},
{0x1d, 0x1e, 0x1e, 0x1f},
{0x1f, 0x20, 0x20, 0x21},
{0x21, 0x22, 0x22, 0x23},
{0x23, 0x24, 0x24, 0x24},
{0x25, 0x25, 0x26, 0x26},
{0x27, 0x27, 0x28, 0x28},
{0x29, 0x29, 0x2a, 0x2a},
{0x2b, 0x2b, 0x2c, 0x2d},
{0x2e, 0x2f, 0x2f, 0x30},
{0x31, 0x32, 0x33, 0x34},
{0x35, 0x36, 0x37, 0x38},
{0x3a, 0x3b, 0x3c, 0x3d},
{0x3d, 0x3e, 0x3f, 0x40},
{0x41, 0x42, 0x43, 0x44},
{0x46, 0x47, 0x49, 0x4a},
{ 0x9, 0x9, 0xe, 0xe},
{0x12, 0x12, 0x17, 0x17},
{0x17, 0x1b, 0x1b, 0x20},
{0x20, 0x24, 0x24, 0x24},
{0x29, 0x29, 0x2d, 0x2d},
{0x2d, 0x2d, 0x32, 0x32},
{0x32, 0x32, 0x36, 0x36},
{0x36, 0x3b, 0x3b, 0x3f},
{0x3f, 0x44, 0x44, 0x48},
{0x48, 0x4d, 0x4d, 0x51},
{0x51, 0x51, 0x56, 0x56},
{0x5a, 0x5a, 0x5f, 0x5f},
{0x63, 0x63, 0x68, 0x68},
{0x68, 0x6c, 0x6c, 0x71},
{0x71, 0x76, 0x76, 0x7a},
{0x7a, 0x7f, 0x7f, 0x83},
{0x83, 0x88, 0x88, 0x8c},
{0x8c, 0x91, 0x91, 0x95},
{0x95, 0x9a, 0x9a, 0x9e},
{0x9e, 0xa3, 0xa3, 0xa7},
{0xa7, 0xac, 0xac, 0xac},
{0xb0, 0xb0, 0xb5, 0xb5},
{0xb9, 0xb9, 0xbe, 0xbe},
{0xc2, 0xc2, 0xc7, 0xc7},
{0xcb, 0xd0, 0xd4, 0xd9},
{0xdd, 0xe2, 0xe2, 0xe6},
{0xeb, 0xf0, 0xf4, 0xf9},
{0xfd, 0xff, 0xff, 0xff},
{0xff, 0xff, 0xff, 0xff},
{0xff, 0xff, 0xff, 0xff},
{0xff, 0xff, 0xff, 0xff},
{0xff, 0xff, 0xff, 0xff}
};
const uint32_t VP8_BRC_PFRAME_COST_TABLE_G10[256] =
{
0x06040402,
0x06040402,
0x06040402,
0x06040402,
0x0d080805,
0x0d080805,
0x0d080805,
0x0d080805,
0x0d080805,
0x190b0c07,
0x190b0c07,
0x190b0c07,
0x190b0c07,
0x1c0f0f0a,
0x1c0f0f0a,
0x1c0f0f0a,
0x1c0f0f0a,
0x1c0f0f0a,
0x2819190c,
0x2819190c,
0x2819190c,
0x2819190c,
0x2819190c,
0x2819190c,
0x2819190c,
0x2819190c,
0x291b1b0f,
0x291b1b0f,
0x291b1b0f,
0x291b1b0f,
0x291b1b0f,
0x2b1d1d18,
0x2b1d1d18,
0x2b1d1d18,
0x2b1d1d18,
0x2c1f1f19,
0x2c1f1f19,
0x2c1f1f19,
0x2c1f1f19,
0x2e28281b,
0x2e28281b,
0x2e28281b,
0x2e28281b,
0x2e28281b,
0x2f29291c,
0x2f29291c,
0x2f29291c,
0x2f29291c,
0x382a2a1d,
0x382a2a1d,
0x382a2a1d,
0x382a2a1d,
0x382a2a1d,
0x392b2b1e,
0x392b2b1e,
0x392b2b1e,
0x392b2b1e,
0x3a2c2c1f,
0x3a2c2c1f,
0x3a2c2c1f,
0x3a2c2c1f,
0x3b2d2d28,
0x3b2d2d28,
0x3b2d2d28,
0x3b2d2d28,
0x3b2e2e29,
0x3b2e2e29,
0x3b2e2e29,
0x3b2e2e29,
0x3c2f2f29,
0x3c2f2f29,
0x3c2f2f29,
0x3c2f2f29,
0x3d38382a,
0x3d38382a,
0x3d38382a,
0x3d38382a,
0x3e38382b,
0x3e38382b,
0x3e38382b,
0x3e38382b,
0x3f38392b,
0x3f38392b,
0x3f38392b,
0x3f38392b,
0x3f38392b,
0x3f39392c,
0x3f39392c,
0x3f39392c,
0x3f39392c,
0x48393a2c,
0x48393a2c,
0x48393a2c,
0x48393a2c,
0x483a3a2d,
0x483a3a2d,
0x483a3a2d,
0x493a3b2e,
0x493a3b2e,
0x493b3b2e,
0x493b3b2e,
0x493b3c2f,
0x493b3c2f,
0x493b3c2f,
0x4a3c3c2f,
0x4a3c3c2f,
0x4a3c3d38,
0x4a3c3d38,
0x4b3d3d38,
0x4b3d3d38,
0x4b3d3e38,
0x4b3d3e38,
0x4b3e3e39,
0x4c3e3e39,
0x4c3e3e39,
0x4c3f3f39,
0x4c3f3f39,
0x4d3f3f3a,
0x4d3f3f3a,
0x4d48483a,
0x4d48483a,
0x4d48483a,
0x4d48483a,
0x4e48483a,
0x4e48483b,
0x4e48483b,
0x4f48493b,
0x4f49493b,
0x1a0c0907,
0x1a0c0907,
0x1a0c0907,
0x1a0c0907,
0x291b190e,
0x291b190e,
0x291b190e,
0x291b190e,
0x291b190e,
0x2e281e1a,
0x2e281e1a,
0x2e281e1a,
0x2e281e1a,
0x392b291e,
0x392b291e,
0x392b291e,
0x392b291e,
0x392b291e,
0x3c2e2b29,
0x3c2e2b29,
0x3c2e2b29,
0x3c2e2b29,
0x3c2e2b29,
0x3c2e2b29,
0x3c2e2b29,
0x3c2e2b29,
0x3e382e2a,
0x3e382e2a,
0x3e382e2a,
0x3e382e2a,
0x3e382e2a,
0x483a382c,
0x483a382c,
0x483a382c,
0x483a382c,
0x493b392e,
0x493b392e,
0x493b392e,
0x493b392e,
0x4b3d3a38,
0x4b3d3a38,
0x4b3d3a38,
0x4b3d3a38,
0x4b3d3a38,
0x4c3e3b38,
0x4c3e3b38,
0x4c3e3b38,
0x4c3e3b38,
0x4d483c39,
0x4d483c39,
0x4d483c39,
0x4d483c39,
0x4d483c39,
0x4e483e3a,
0x4e483e3a,
0x4e483e3a,
0x4e483e3a,
0x4f493f3b,
0x4f493f3b,
0x4f493f3b,
0x4f493f3b,
0x584a483c,
0x584a483c,
0x584a483c,
0x584a483c,
0x594b483d,
0x594b483d,
0x594b483d,
0x594b483d,
0x594b493e,
0x594b493e,
0x594b493e,
0x594b493e,
0x5a4c493f,
0x5a4c493f,
0x5a4c493f,
0x5a4c493f,
0x5b4d4a48,
0x5b4d4a48,
0x5b4d4a48,
0x5b4d4a48,
0x5b4d4b48,
0x5b4d4b48,
0x5b4d4b48,
0x5b4d4b48,
0x5b4d4b48,
0x5c4e4b48,
0x5c4e4b48,
0x5c4e4b48,
0x5c4e4b48,
0x5c4f4c49,
0x5c4f4c49,
0x5c4f4c49,
0x5c4f4c49,
0x5d584c49,
0x5d584c49,
0x5d584c49,
0x5e584d4a,
0x5e584d4a,
0x5e584e4a,
0x5e584e4a,
0x5f594e4b,
0x5f594e4b,
0x5f594e4b,
0x5f594f4b,
0x5f594f4b,
0x68594f4c,
0x68594f4c,
0x685a584c,
0x685a584c,
0x685a584c,
0x685a584c,
0x695b584d,
0x695b594d,
0x695b594d,
0x695b594e,
0x695b594e,
0x6a5c594e,
0x6a5c594e,
0x6a5c594f,
0x6a5c594f,
0x6a5c5a4f,
0x6a5c5a4f,
0x6a5d5a58,
0x6b5d5a58,
0x6b5d5a58,
0x6b5d5b58,
0x6b5e5b58,
};
const uint16_t VP8_MvRefCostContext_G10[6][4][2] =
{
{ { 1328, 10 },
{ 2047, 1 },
{ 2047, 1 },
{ 214, 304 },
},
{ { 1072, 21 },
{ 979, 27 },
{ 1072, 21 },
{ 321, 201 },
},
{ { 235, 278 },
{ 511, 107 },
{ 553, 93 },
{ 488, 115 },
},
{ { 534, 99 },
{ 560, 92 },
{ 255, 257 },
{ 505, 109 },
},
{ { 174, 361 },
{ 238, 275 },
{ 255, 257 },
{ 744, 53 },
},
{ { 32, 922 },
{ 113, 494 },
{ 255, 257 },
{ 816, 43 },
},
};
const uint16_t VP8_QUANT_DC_G10[CODECHAL_VP8_MAX_QP] =
{
4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17,
18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
91, 93, 95, 96, 98, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118,
122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157
};
const uint16_t VP8_QUANT_AC_G10[CODECHAL_VP8_MAX_QP/* + 1 + 32*/] =
{
/*4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,*/
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76,
78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108,
110, 112, 114, 116, 119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152,
155, 158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209,
213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259, 264, 269, 274, 279, 284/*,
284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284*/
};
extern const uint16_t VP8_MB_MODE_COST_LUMA_G10[10] =
{ 657, 869, 915, 917, 208, 0, 0, 0, 0, 0};
static const uint16_t VP8_BLOCK_MODE_COST_G10[10][10][10] =
{
{ {37, 1725, 1868, 1151, 1622, 2096, 2011, 1770, 2218, 2128 },
{139, 759, 1683, 911, 1455, 1846, 1570, 1295, 1792, 1648 },
{560, 1383, 408, 639, 1612, 1174, 1562, 1736, 847, 991 },
{191, 1293, 1299, 466, 1774, 1840, 1784, 1691, 1698, 1505 },
{211, 1624, 1294, 779, 714, 1622, 2222, 1554, 1706, 903 },
{297, 1259, 1098, 1062, 1583, 618, 1053, 1889, 851, 1127 },
{275, 703, 1356, 1111, 1597, 1075, 656, 1529, 1531, 1275 },
{150, 1046, 1760, 1039, 1353, 1981, 2174, 728, 1730, 1379 },
{516, 1414, 741, 1045, 1495, 738, 1288, 1619, 442, 1200 },
{424, 1365, 706, 825, 1197, 1453, 1191, 1462, 1186, 519 },
},
{ {393, 515, 1491, 549, 1598, 1524, 964, 1126, 1651, 2172 },
{693, 237, 1954, 641, 1525, 2073, 1183, 971, 1973, 2235 },
{560, 739, 855, 836, 1224, 1115, 966, 839, 1076, 767 },
{657, 368, 1406, 425, 1672, 1853, 1210, 1125, 1969, 1542 },
{321, 1056, 1776, 774, 803, 3311, 1265, 1177, 1366, 636 },
{693, 510, 949, 877, 1049, 658, 882, 1178, 1515, 1111 },
{744, 377, 1278, 958, 1576, 1168, 477, 1146, 1838, 1501 },
{488, 477, 1767, 973, 1107, 1511, 1773, 486, 1527, 1449 },
{744, 1004, 695, 1012, 1326, 834, 1215, 774, 724, 704 },
{522, 567, 1036, 1082, 1039, 1333, 873, 1135, 1189, 677 },
},
{ {103, 1441, 1000, 864, 1513, 1928, 1832, 1916, 1663, 1567 },
{304, 872, 1100, 515, 1416, 1417, 3463, 1051, 1305, 1227 },
{684, 2176, 242, 729, 1867, 1496, 2056, 1544, 1038, 930 },
{534, 1198, 669, 300, 1805, 1377, 2165, 1894, 1249, 1153 },
{346, 1602, 1178, 612, 997, 3381, 1335, 1328, 997, 646 },
{393, 1027, 649, 813, 1276, 945, 1545, 1278, 875, 1031 },
{528, 996, 930, 617, 1086, 1190, 621, 2760, 787, 1347 },
{216, 873, 1595, 738, 1339, 3896, 3898, 743, 1343, 1605 },
{675, 1580, 543, 749, 1859, 1245, 1589, 2377, 384, 1075 },
{594, 1163, 415, 684, 1474, 1080, 1491, 1478, 1077, 801 },
},
{ {238, 1131, 1483, 398, 1510, 1651, 1495, 1545, 1970, 2090 },
{499, 456, 1499, 449, 1558, 1691, 1272, 969, 2114, 2116 },
{675, 1386, 318, 645, 1449, 1588, 1666, 1925, 979, 859 },
{467, 957, 1223, 238, 1825, 1704, 1608, 1560, 1665, 1376 },
{331, 1460, 1238, 627, 787, 1882, 3928, 1544, 1897, 579 },
{457, 1038, 903, 784, 1158, 725, 955, 1517, 842, 1016 },
{505, 497, 1131, 812, 1508, 1206, 703, 1072, 1254, 1256 },
{397, 741, 1336, 642, 1506, 1852, 1340, 599, 1854, 1000 },
{625, 1212, 597, 750, 1291, 1057, 1401, 1401, 527, 954 },
{499, 1041, 654, 752, 1299, 1217, 1605, 1424, 1377, 505 },
},
{ {263, 1094, 1218, 602, 938, 1487, 1231, 1016, 1724, 1448 },
{452, 535, 1728, 562, 1008, 1471, 1473, 873, 3182, 1136 },
{553, 1570, 935, 1093, 826, 1339, 879, 1007, 1006, 476 },
{365, 900, 1050, 582, 866, 1398, 1236, 1123, 1608, 1039 },
{294, 2044, 1790, 1143, 430, 1642, 3688, 1549, 2080, 704 },
{703, 1210, 958, 815, 1211, 960, 623, 2455, 815, 559 },
{675, 574, 862, 1261, 866, 864, 761, 1267, 1014, 936 },
{342, 1254, 1857, 989, 612, 1856, 1858, 553, 1840, 1037 },
{553, 1316, 811, 1072, 1068, 728, 1328, 1317, 1064, 475 },
{288, 1303, 1167, 1167, 823, 1634, 1636, 2497, 1294, 491 },
},
{ {227, 1059, 1369, 1066, 1505, 740, 970, 1511, 972, 1775 },
{516, 587, 1033, 646, 1188, 748, 978, 1445, 1294, 1450 },
{684, 1048, 663, 747, 1126, 826, 1386, 1128, 635, 924 },
{494, 814, 933, 510, 1606, 951, 878, 1344, 1031, 1347 },
{553, 1071, 1327, 726, 809, 3376, 1330, 1324, 1062, 407 },
{625, 1120, 988, 1121, 1197, 347, 1064, 1308, 862, 1206 },
{633, 853, 1657, 1073, 1662, 634, 460, 1405, 811, 1155 },
{505, 621, 1394, 876, 1394, 876, 878, 795, 878, 1399 },
{684, 1302, 968, 1704, 1280, 561, 972, 1713, 387, 1104 },
{397, 1447, 1060, 867, 957, 1058, 749, 1475, 1210, 660 },
},
{ {331, 933, 1647, 761, 1647, 998, 513, 1402, 1461, 2219 },
{573, 485, 1968, 641, 1570, 1198, 588, 1086, 1382, 1982 },
{790, 942, 570, 790, 1607, 1005, 938, 1193, 714, 751 },
{511, 745, 1152, 492, 1878, 1206, 596, 1867, 1617, 1157 },
{452, 1308, 896, 896, 451, 1308, 3354, 1301, 1306, 794 },
{693, 670, 1072, 1020, 1687, 566, 488, 1432, 1096, 3142 },
{778, 566, 1993, 1283, 3139, 1251, 227, 1378, 1784, 1447 },
{393, 937, 1091, 934, 939, 1348, 1092, 579, 1351, 1095 },
{560, 1013, 1007, 1014, 1011, 644, 1165, 1155, 605, 1016 },
{567, 627, 997, 793, 2562, 998, 849, 1260, 922, 748 },
},
{ {338, 762, 1868, 717, 1247, 1757, 1263, 535, 1751, 2162 },
{488, 442, 3235, 756, 1658, 1814, 1264, 528, 1857, 2119 },
{522, 1087, 840, 1103, 843, 1354, 1098, 888, 946, 588 },
{483, 688, 1502, 651, 1213, 1446, 1397, 491, 1908, 1253 },
{452, 1386, 1910, 1175, 298, 1507, 3553, 930, 1904, 905 },
{713, 839, 716, 715, 932, 719, 931, 848, 3088, 1042 },
{516, 495, 1331, 1340, 1331, 1069, 665, 702, 1593, 1337 },
{401, 977, 2167, 1537, 1069, 1764, 3810, 259, 3624, 1578 },
{560, 1104, 601, 1371, 965, 658, 2704, 779, 967, 969 },
{547, 1057, 801, 1141, 1133, 1397, 937, 605, 1252, 631 },
},
{ {163, 1240, 925, 983, 1653, 1321, 1353, 1566, 946, 1601 },
{401, 726, 758, 836, 1241, 926, 1656, 795, 1394, 1396 },
{905, 1073, 366, 876, 1436, 1576, 1732, 2432, 459, 1019 },
{594, 922, 835, 417, 1387, 1124, 1098, 2042, 843, 1023 },
{415, 1262, 860, 1274, 758, 1272, 3318, 1010, 1276, 503 },
{641, 1018, 1020, 1095, 1619, 667, 1371, 2348, 397, 849 },
{560, 817, 903, 1014, 1420, 695, 756, 904, 821, 1421 },
{406, 596, 1001, 993, 1257, 1258, 1260, 746, 1002, 1264 },
{979, 1371, 780, 1188, 1693, 1024, 1286, 1699, 183, 1405 },
{733, 1292, 458, 884, 1554, 889, 1151, 1286, 738, 740 },
},
{ {109, 1377, 1177, 933, 1140, 1928, 1639, 1705, 1861, 1292 },
{342, 570, 1081, 638, 1154, 1231, 1339, 1342, 1750, 1494 },
{560, 1203, 345, 767, 1325, 1681, 1425, 1905, 1205, 786 },
{406, 1027, 1011, 410, 1306, 1901, 1389, 1636, 1493, 776 },
{206, 1329, 1337, 1037, 802, 1600, 3646, 1451, 1603, 693 },
{472, 1167, 758, 911, 1424, 703, 2749, 1428, 703, 764 },
{342, 780, 1139, 889, 1290, 1139, 781, 1544, 957, 1042 },
{227, 888, 1039, 929, 988, 3753, 1707, 818, 1710, 1306 },
{767, 1055, 627, 725, 1312, 980, 1065, 1324, 599, 811 },
{304, 1372, 888, 1173, 979, 1578, 1580, 1974, 1318, 482 },
}
};
// VP8 BRC
extern const uint8_t VP8_BRC_IFRAME_COST_TABLE_G10[128][4];
extern const uint32_t VP8_BRC_PFRAME_COST_TABLE_G10[256];
extern const uint32_t VP8_NewMVSkipThreshold_G10[128];
const uint8_t VP8_BRC_QPAdjustment_DistThreshold_MaxFrameThreshold_DistQPAdjustment_IPB_g10[576] =
{
0x01, 0x03, 0x05, 0x07, 0x09, 0x01, 0x02, 0x03, 0x05, 0x07, 0x00, 0x00, 0x01, 0x02, 0x04, 0x00,
0x00, 0x00, 0x01, 0x02, 0xff, 0x00, 0x00, 0x00, 0x01, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0xfb, 0xfc,
0xfe, 0xff, 0x00, 0xf9, 0xfa, 0xfc, 0xfe, 0xff, 0xf7, 0xf9, 0xfb, 0xfe, 0xff, 0x00, 0x04, 0x1e,
0x3c, 0x50, 0x78, 0x8c, 0xc8, 0xff, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x02, 0x05, 0x08, 0x0a, 0x01, 0x02, 0x04, 0x06, 0x08, 0x00, 0x01, 0x02, 0x04, 0x06, 0x00,
0x00, 0x00, 0x01, 0x02, 0xff, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xfd, 0xfe,
0xff, 0xff, 0x00, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0xf9, 0xfa, 0xfc, 0xfe, 0xff, 0x00, 0x04, 0x1e,
0x3c, 0x50, 0x78, 0x8c, 0xc8, 0xff, 0x04, 0x05, 0x06, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x02, 0x05, 0x08, 0x0a, 0x01, 0x02, 0x04, 0x06, 0x08, 0x00, 0x01, 0x02, 0x04, 0x06, 0x00,
0x00, 0x00, 0x01, 0x02, 0xff, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xfd, 0xfe,
0xff, 0xff, 0x00, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0xf9, 0xfa, 0xfc, 0xfe, 0xff, 0x00, 0x02, 0x14,
0x28, 0x46, 0x82, 0xa0, 0xc8, 0xff, 0x04, 0x05, 0x06, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x06, 0x08, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05,
0x07, 0x09, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x06, 0x07, 0xfe, 0xff, 0x00, 0x00, 0x00,
0x01, 0x02, 0x03, 0x05, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x03, 0x05, 0xfc, 0xfe, 0xff,
0x00, 0x00, 0x00, 0x01, 0x03, 0x05, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x03, 0x05, 0xfa,
0xfc, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x03, 0x05, 0xfa, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x03,
0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x07, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05,
0x06, 0x08, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x07, 0x08, 0xfe, 0xff, 0x00, 0x00, 0x00,
0x02, 0x04, 0x05, 0x06, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0xfc, 0xfe, 0xff,
0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0xfc, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x04, 0x05, 0xfc,
0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x05, 0xfb, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x07, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05,
0x06, 0x08, 0xff, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x07, 0x08, 0xfe, 0xff, 0x00, 0x00, 0x00,
0x02, 0x04, 0x05, 0x06, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0xfc, 0xfe, 0xff,
0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0xfc, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x04, 0x05, 0xfc,
0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x05, 0xfb, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01,
0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
const uint16_t VP8_BRC_QUANT_DC_TABLE [128] =
{
4, 5, 6, 7, 8, 9, 10, 10, 11, 12, 13, 14, 15, 16, 17, 17,
18, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 25, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
91, 93, 95, 96, 98, 100, 101, 102, 104, 106, 108, 110, 112, 114, 116, 118,
122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 143, 145, 148, 151, 154, 157
};
const uint16_t VP8_BRC_QUANT_AC_TABLE [128] =
{
4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76,
78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108,
110, 112, 114, 116, 119, 122, 125, 128, 131, 134, 137, 140, 143, 146, 149, 152,
155, 158, 161, 164, 167, 170, 173, 177, 181, 185, 189, 193, 197, 201, 205, 209,
213, 217, 221, 225, 229, 234, 239, 245, 249, 254, 259, 264, 269, 274, 279, 284
};
const uint16_t VP8_BRC_SKIP_MV_THRESHOLD_TABLE [256] =
{
111, 120, 129, 137, 146, 155, 163, 172, 180, 189, 198, 206, 215, 224, 232, 241,
249, 258, 267, 275, 284, 293, 301, 310, 318, 327, 336, 344, 353, 362, 370, 379,
387, 396, 405, 413, 422, 431, 439, 448, 456, 465, 474, 482, 491, 500, 508, 517,
525, 534, 543, 551, 560, 569, 577, 586, 594, 603, 612, 620, 629, 638, 646, 655,
663, 672, 681, 689, 698, 707, 715, 724, 733, 741, 750, 758, 767, 776, 784, 793,
802, 810, 819, 827, 836, 845, 853, 862, 871, 879, 888, 896, 905, 914, 922, 931,
940, 948, 957, 965, 974, 983, 991, 1000, 1009, 1017, 1026, 1034, 1043, 1052, 1060, 1069,
1078,1086, 1095, 1103, 1112, 1121, 1129, 1138, 1147, 1155, 1164, 1172, 1181, 1190, 1198, 1208
};
extern const uint32_t VP8_MODE_MV_COST_TABLE_G10[128][5] =
{
{0x008f0000, 0x006f0000, 0x00000000, 0x09060400, 0x000e000a},
{0x008f0000, 0x006f0000, 0x00000000, 0x09000400, 0x0f000c00},
{0x008f0000, 0x006f0000, 0x00000000, 0x09000400, 0x0f000c00},
{0x008f0000, 0x006f0000, 0x00000000, 0x09000400, 0x0f000c00},
{0x008f0000, 0x006f0000, 0x00000000, 0x12000900, 0x1e001800},
{0x008f0000, 0x006f0000, 0x00000000, 0x12000900, 0x1e001800},
{0x008f0000, 0x006f0000, 0x00000000, 0x12000900, 0x1e001800},
{0x008f0000, 0x006f0000, 0x00000000, 0x12000900, 0x1e001800},
{0x008f0000, 0x006f0000, 0x00000000, 0x12000900, 0x1e001800},
{0x008f0000, 0x006f0000, 0x00000000, 0x1b000d00, 0x2d002400},
{0x008f0000, 0x006f0000, 0x00000000, 0x1b000d00, 0x2d002400},
{0x008f0000, 0x006f0000, 0x00000000, 0x1b000d00, 0x2d002400},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x468f0000, 0x006f0200, 0x05000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0000, 0x006f0500, 0x0b000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x6f8f0010, 0x006f0700, 0x18000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x188f0010, 0x006f0a00, 0x16000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x5e8f0020, 0x006f0d00, 0x1b000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0x6f8f0020, 0x006f0f00, 0x21000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0xea8f0030, 0x006f1200, 0x26000000, 0x00000000, 0x00000000},
{0x388f0030, 0x006f1500, 0x2c000000, 0x00000000, 0x00000000},
{0x388f0030, 0x006f1500, 0x2c000000, 0x00000000, 0x00000000},
{0x388f0030, 0x006f1500, 0x2c000000, 0x00000000, 0x00000000},
{0x388f0030, 0x006f1500, 0x2c000000, 0x00000000, 0x00000000},
{0x388f0030, 0x006f1500, 0x2c000000, 0x00000000, 0x00000000},
{0x388f0030, 0x006f1500, 0x2c000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x768f0030, 0x006f1700, 0x31000000, 0x00000000, 0x00000000},
{0x6f8f0040, 0x006f1a00, 0x37000000, 0x00000000, 0x00000000},
{0x6f8f0040, 0x006f1a00, 0x37000000, 0x00000000, 0x00000000},
{0x6f8f0040, 0x006f1a00, 0x37000000, 0x00000000, 0x00000000},
{0x6f8f0040, 0x006f1a00, 0x37000000, 0x00000000, 0x00000000},
{0x6f8f0040, 0x006f1a00, 0x37000000, 0x00000000, 0x00000000},
{0x028f0040, 0x006f1d00, 0x3c000000, 0x00000000, 0x00000000},
};
extern const uint8_t VP8_DEFAULT_COEFF_PROBS_G10[4][8][3][11] =
{
{
{
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 253, 136, 254, 255, 228, 219, 128, 128, 128, 128, 128},
{ 189, 129, 242, 255, 227, 213, 255, 219, 128, 128, 128},
{ 106, 126, 227, 252, 214, 209, 255, 255, 128, 128, 128}
},
{
{ 1, 98, 248, 255, 236, 226, 255, 255, 128, 128, 128},
{ 181, 133, 238, 254, 221, 234, 255, 154, 128, 128, 128},
{ 78, 134, 202, 247, 198, 180, 255, 219, 128, 128, 128}
},
{
{ 1, 185, 249, 255, 243, 255, 128, 128, 128, 128, 128},
{ 184, 150, 247, 255, 236, 224, 128, 128, 128, 128, 128},
{ 77, 110, 216, 255, 236, 230, 128, 128, 128, 128, 128}
},
{
{ 1, 101, 251, 255, 241, 255, 128, 128, 128, 128, 128},
{ 170, 139, 241, 252, 236, 209, 255, 255, 128, 128, 128},
{ 37, 116, 196, 243, 228, 255, 255, 255, 128, 128, 128}
},
{
{ 1, 204, 254, 255, 245, 255, 128, 128, 128, 128, 128},
{ 207, 160, 250, 255, 238, 128, 128, 128, 128, 128, 128},
{ 102, 103, 231, 255, 211, 171, 128, 128, 128, 128, 128}
},
{
{ 1, 152, 252, 255, 240, 255, 128, 128, 128, 128, 128},
{ 177, 135, 243, 255, 234, 225, 128, 128, 128, 128, 128},
{ 80, 129, 211, 255, 194, 224, 128, 128, 128, 128, 128}
},
{
{ 1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 246, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 255, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
}
},
{
{
{ 198, 35, 237, 223, 193, 187, 162, 160, 145, 155, 62},
{ 131, 45, 198, 221, 172, 176, 220, 157, 252, 221, 1},
{ 68, 47, 146, 208, 149, 167, 221, 162, 255, 223, 128}
},
{
{ 1, 149, 241, 255, 221, 224, 255, 255, 128, 128, 128},
{ 184, 141, 234, 253, 222, 220, 255, 199, 128, 128, 128},
{ 81, 99, 181, 242, 176, 190, 249, 202, 255, 255, 128}
},
{
{ 1, 129, 232, 253, 214, 197, 242, 196, 255, 255, 128},
{ 99, 121, 210, 250, 201, 198, 255, 202, 128, 128, 128},
{ 23, 91, 163, 242, 170, 187, 247, 210, 255, 255, 128}
},
{
{ 1, 200, 246, 255, 234, 255, 128, 128, 128, 128, 128},
{ 109, 178, 241, 255, 231, 245, 255, 255, 128, 128, 128},
{ 44, 130, 201, 253, 205, 192, 255, 255, 128, 128, 128}
},
{
{ 1, 132, 239, 251, 219, 209, 255, 165, 128, 128, 128},
{ 94, 136, 225, 251, 218, 190, 255, 255, 128, 128, 128},
{ 22, 100, 174, 245, 186, 161, 255, 199, 128, 128, 128}
},
{
{ 1, 182, 249, 255, 232, 235, 128, 128, 128, 128, 128},
{ 124, 143, 241, 255, 227, 234, 128, 128, 128, 128, 128},
{ 35, 77, 181, 251, 193, 211, 255, 205, 128, 128, 128}
},
{
{ 1, 157, 247, 255, 236, 231, 255, 255, 128, 128, 128},
{ 121, 141, 235, 255, 225, 227, 255, 255, 128, 128, 128},
{ 45, 99, 188, 251, 195, 217, 255, 224, 128, 128, 128}
},
{
{ 1, 1, 251, 255, 213, 255, 128, 128, 128, 128, 128},
{ 203, 1, 248, 255, 255, 128, 128, 128, 128, 128, 128},
{ 137, 1, 177, 255, 224, 255, 128, 128, 128, 128, 128}
}
},
{
{
{ 253, 9, 248, 251, 207, 208, 255, 192, 128, 128, 128},
{ 175, 13, 224, 243, 193, 185, 249, 198, 255, 255, 128},
{ 73, 17, 171, 221, 161, 179, 236, 167, 255, 234, 128}
},
{
{ 1, 95, 247, 253, 212, 183, 255, 255, 128, 128, 128},
{ 239, 90, 244, 250, 211, 209, 255, 255, 128, 128, 128},
{ 155, 77, 195, 248, 188, 195, 255, 255, 128, 128, 128}
},
{
{ 1, 24, 239, 251, 218, 219, 255, 205, 128, 128, 128},
{ 201, 51, 219, 255, 196, 186, 128, 128, 128, 128, 128},
{ 69, 46, 190, 239, 201, 218, 255, 228, 128, 128, 128}
},
{
{ 1, 191, 251, 255, 255, 128, 128, 128, 128, 128, 128},
{ 223, 165, 249, 255, 213, 255, 128, 128, 128, 128, 128},
{ 141, 124, 248, 255, 255, 128, 128, 128, 128, 128, 128}
},
{
{ 1, 16, 248, 255, 255, 128, 128, 128, 128, 128, 128},
{ 190, 36, 230, 255, 236, 255, 128, 128, 128, 128, 128},
{ 149, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 1, 226, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 247, 192, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 240, 128, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 1, 134, 252, 255, 255, 128, 128, 128, 128, 128, 128},
{ 213, 62, 250, 255, 255, 128, 128, 128, 128, 128, 128},
{ 55, 93, 255, 128, 128, 128, 128, 128, 128, 128, 128}
},
{
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128},
{ 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128}
}
},
{
{
{ 202, 24, 213, 235, 186, 191, 220, 160, 240, 175, 255},
{ 126, 38, 182, 232, 169, 184, 228, 174, 255, 187, 128},
{ 61, 46, 138, 219, 151, 178, 240, 170, 255, 216, 128}
},
{
{ 1, 112, 230, 250, 199, 191, 247, 159, 255, 255, 128},
{ 166, 109, 228, 252, 211, 215, 255, 174, 128, 128, 128},
{ 39, 77, 162, 232, 172, 180, 245, 178, 255, 255, 128}
},
{
{ 1, 52, 220, 246, 198, 199, 249, 220, 255, 255, 128},
{ 124, 74, 191, 243, 183, 193, 250, 221, 255, 255, 128},
{ 24, 71, 130, 219, 154, 170, 243, 182, 255, 255, 128}
},
{
{ 1, 182, 225, 249, 219, 240, 255, 224, 128, 128, 128},
{ 149, 150, 226, 252, 216, 205, 255, 171, 128, 128, 128},
{ 28, 108, 170, 242, 183, 194, 254, 223, 255, 255, 128}
},
{
{ 1, 81, 230, 252, 204, 203, 255, 192, 128, 128, 128},
{ 123, 102, 209, 247, 188, 196, 255, 233, 128, 128, 128},
{ 20, 95, 153, 243, 164, 173, 255, 203, 128, 128, 128}
},
{
{ 1, 222, 248, 255, 216, 213, 128, 128, 128, 128, 128},
{ 168, 175, 246, 252, 235, 205, 255, 255, 128, 128, 128},
{ 47, 116, 215, 255, 211, 212, 255, 255, 128, 128, 128}
},
{
{ 1, 121, 236, 253, 212, 214, 255, 255, 128, 128, 128},
{ 141, 84, 213, 252, 201, 202, 255, 219, 128, 128, 128},
{ 42, 80, 160, 240, 162, 185, 255, 205, 128, 128, 128}
},
{
{ 1, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 244, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128},
{ 238, 1, 255, 128, 128, 128, 128, 128, 128, 128, 128}
}
}
};
const uint16_t VP8_C0_TABLE[256] =
{
2047, 2047, 1791, 1641, 1535, 1452, 1385, 1328, 1279, 1235, 1196, 1161, 1129, 1099, 1072, 1046,
1023, 1000, 979, 959, 940, 922, 905, 889, 873, 858, 843, 829, 816, 803, 790, 778,
767, 755, 744, 733, 723, 713, 703, 693, 684, 675, 666, 657, 649, 641, 633, 625,
617, 609, 602, 594, 587, 580, 573, 567, 560, 553, 547, 541, 534, 528, 522, 516,
511, 505, 499, 494, 488, 483, 477, 472, 467, 462, 457, 452, 447, 442, 437, 433,
428, 424, 419, 415, 410, 406, 401, 397, 393, 389, 385, 381, 377, 373, 369, 365,
361, 357, 353, 349, 346, 342, 338, 335, 331, 328, 324, 321, 317, 314, 311, 307,
304, 301, 297, 294, 291, 288, 285, 281, 278, 275, 272, 269, 266, 263, 260, 257,
255, 252, 249, 246, 243, 240, 238, 235, 232, 229, 227, 224, 221, 219, 216, 214,
211, 208, 206, 203, 201, 198, 196, 194, 191, 189, 186, 184, 181, 179, 177, 174,
172, 170, 168, 165, 163, 161, 159, 156, 154, 152, 150, 148, 145, 143, 141, 139,
137, 135, 133, 131, 129, 127, 125, 123, 121, 119, 117, 115, 113, 111, 109, 107,
105, 103, 101, 99, 97, 95, 93, 92, 90, 88, 86, 84, 82, 81, 79, 77,
75, 73, 72, 70, 68, 66, 65, 63, 61, 60, 58, 56, 55, 53, 51, 50,
48, 46, 45, 43, 41, 40, 38, 37, 35, 33, 32, 30, 29, 27, 25, 24,
22, 21, 19, 18, 16, 15, 13, 12, 10, 9, 7, 6, 4, 3, 1, 1
};
extern const uint8_t VP8_PROBABILITY_UPDATE_FLAGS_G10 [VP8_NUM_COEFF_PLANES][VP8_NUM_COEFF_BANDS][VP8_NUM_LOCAL_COMPLEXITIES][VP8_NUM_COEFF_NODES]= {
{
{{0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}},
{{1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,1,0,0,0,0,0,0,0}, {1,1,1,1,1,0,0,0,0,0,0}},
{{0,1,1,1,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}},
{{0,1,1,1,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}},
{{0,1,1,1,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}},
{{0,1,1,1,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}},
{{0,1,1,1,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}},
{{0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}}
},
{
{{1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,1,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}}
},
{
{{1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}}
},
{
{{1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,1,0,0,0,0,0,0,0,0}, {1,1,1,1,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,1,1,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0,0,0,0}},
{{0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}, {0,0,0,0,0,0,0,0,0,0,0}}
}
};
extern const uint8_t VP8_COEFF_UPDATE_PROBS_G10[4][8][3][11] =
{
{
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 176, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 223, 241, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{ 249, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 244, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{ 234, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 246, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 239, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 251, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 251, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 253, 255, 254, 255, 255, 255, 255, 255, 255},
{ 250, 255, 254, 255, 254, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
},
{
{
{ 217, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 225, 252, 241, 253, 255, 255, 254, 255, 255, 255, 255},
{ 234, 250, 241, 250, 253, 255, 253, 254, 255, 255, 255}
},
{
{ 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 223, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 238, 253, 254, 254, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 248, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 249, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 247, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
},
{
{
{ 186, 251, 250, 255, 255, 255, 255, 255, 255, 255, 255},
{ 234, 251, 244, 254, 255, 255, 255, 255, 255, 255, 255},
{ 251, 251, 243, 253, 254, 255, 254, 255, 255, 255, 255}
},
{
{ 255, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 236, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 251, 253, 253, 254, 254, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
},
{
{
{ 248, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 250, 254, 252, 254, 255, 255, 255, 255, 255, 255, 255},
{ 248, 254, 249, 253, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 246, 253, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 252, 254, 251, 254, 254, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 254, 252, 255, 255, 255, 255, 255, 255, 255, 255},
{ 248, 254, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 255, 254, 254, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 251, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 245, 251, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 253, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 251, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 252, 253, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 249, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 254, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 253, 255, 255, 255, 255, 255, 255, 255, 255},
{ 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
},
{
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255},
{ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255}
}
}
};
static const int32_t iMbEncCurbeSize_g10[CODECHAL_ENCODE_VP8_MBENC_IDX_NUM] = {
sizeof(struct MediaObjectVp8MbencIStaticDataG10),
sizeof(struct MediaObjectVp8MbencIStaticDataG10),
sizeof(struct MediaObjectVp8MbencPStaticDataG10)
};
static const int32_t iBrcBtCount_g10[CODECHAL_ENCODE_VP8_BRC_IDX_NUM] = {
CODECHAL_VP8_MBENC_NUM_SURFACES_G10,
CODECHAL_VP8_BRC_INIT_RESET_NUM_SURFACES_G10,
CODECHAL_VP8_BRC_INIT_RESET_NUM_SURFACES_G10,
CODECHAL_VP8_BRC_UPDATE_NUM_SURFACES_G10
};
static const int32_t iBrcCurbeSize_g10[CODECHAL_ENCODE_VP8_BRC_IDX_NUM] = {
sizeof(struct MediaObjectVp8MbencIStaticDataG10),
sizeof(struct MediaObjectVp8BrcInitResetStaticDataG10),
sizeof(struct MediaObjectVp8BrcInitResetStaticDataG10),
sizeof(struct MediaObjectVp8BrcUpdateStaticDataG10)
};
CodechalEncodeVp8G10::CodechalEncodeVp8G10(
CodechalHwInterface* hwInterface,
CodechalDebugInterface* debugInterface,
PCODECHAL_STANDARD_INFO standardInfo)
:CodechalEncodeVp8(hwInterface, debugInterface, standardInfo)
{
CODECHAL_ENCODE_FUNCTION_ENTER;
pfnGetKernelHeaderAndSize = GetKernelHeaderAndSize;
m_kuid = IDR_CODEC_AllVP8Enc;
#ifndef _FULL_OPEN_SOURCE
m_kernelBase = (uint8_t*)IGCODECKRN_G10;
#else
m_kernelBase = nullptr;
#endif
CodecHalGetKernelBinaryAndSize(
m_kernelBase,
m_kuid,
&m_kernelBinary,
&m_combinedKernelSize);
m_hwInterface->GetStateHeapSettings()->dwNumSyncTags = CODECHAL_NUM_VP8_ENC_SYNC_TAGS;
m_hwInterface->GetStateHeapSettings()->dwIshSize +=
MOS_ALIGN_CEIL(m_combinedKernelSize, (1 << MHW_KERNEL_OFFSET_SHIFT));
m_hwInterface->GetStateHeapSettings()->dwDshSize = CODECHAL_INIT_DSH_SIZE_VP8_ENC;
m_brcDistortionBufferSupported = true;
m_brcConstantBufferSupported = true;
m_brcConstantSurfaceWidth = CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_WIDTH;
m_brcConstantSurfaceHeight = CODECHAL_ENCODE_VP8_BRC_CONSTANTSURFACE_HEIGHT;
}
MOS_STATUS CodechalEncodeVp8G10::Initialize(CodechalSetting * codecHalSettings)
{
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
// common initilization
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeVp8::Initialize(codecHalSettings));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelState()
{
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
// Init kernel state
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMe());
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMbEnc());
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateBrc());
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateTpu());
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMpu());
return status;
}
MOS_STATUS CodechalEncodeVp8G10::GetKernelHeaderAndSize(
void *binary,
EncOperation operation,
uint32_t krnStateIdx,
void *krnHeader,
uint32_t *krnSize)
{
struct CodechalVp8KernelHeaderG10 * kernelHeaderTable;
PCODECHAL_KERNEL_HEADER currKrnHeader, invalidEntry, nextKrnHeader;
uint32_t nextKrnOffset;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_CHK_NULL_RETURN(binary);
CODECHAL_ENCODE_CHK_NULL_RETURN(krnHeader);
CODECHAL_ENCODE_CHK_NULL_RETURN(krnSize);
kernelHeaderTable = (struct CodechalVp8KernelHeaderG10*)binary;
invalidEntry = &(kernelHeaderTable->VP8_BRC_FrameEncUpdate) + 1;
nextKrnOffset = *krnSize;
if (operation == ENC_SCALING4X)
{
currKrnHeader = &kernelHeaderTable->PLY_DScale_PLY;
}
else if (operation == ENC_ME)
{
currKrnHeader = &kernelHeaderTable->VP8_ME_P;
}
else if (operation == ENC_BRC)
{
currKrnHeader = &kernelHeaderTable->VP8MBEnc_I_Dist;
}
else if (operation == ENC_MBENC_I_LUMA)
{
currKrnHeader = &kernelHeaderTable->VP8MBEnc_I_Luma;
}
else if (operation == ENC_MBENC)
{
currKrnHeader = &kernelHeaderTable->VP8MBEnc_Norm_Frm_I;
}
else if (operation == ENC_MPU)
{
currKrnHeader = &kernelHeaderTable->VP8_MPU;
}
else if (operation == ENC_TPU)
{
currKrnHeader = &kernelHeaderTable->VP8_TPU;
}
else
{
CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
return MOS_STATUS_INVALID_PARAMETER;
}
currKrnHeader += krnStateIdx;
*((PCODECHAL_KERNEL_HEADER)krnHeader) = *currKrnHeader;
nextKrnHeader = (currKrnHeader + 1);
if (nextKrnHeader < invalidEntry)
{
nextKrnOffset = nextKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT;
}
*krnSize = nextKrnOffset - (currKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelStateHelper(
struct CodechalEncodeVp8InitKernelStateParams * params)
{
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
PMHW_KERNEL_STATE kernelStatePtr;
CODECHAL_KERNEL_HEADER currKrnHeader;
uint32_t kernelSize;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pRenderEngineInterface);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pRenderEngineInterface->GetHwCaps());
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pRenderEngineInterface->m_stateHeapInterface);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pui8Binary);
stateHeapInterface = params->pRenderEngineInterface->m_stateHeapInterface;
kernelStatePtr = params->pKernelState;
kernelSize = params->dwCombinedKernelSize;
CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
params->pui8Binary,
params->Operation,
params->dwKrnStateIdx,
&currKrnHeader,
&kernelSize));
kernelStatePtr->KernelParams.iBTCount = params->iBtCount;
kernelStatePtr->KernelParams.iThreadCount = params->pRenderEngineInterface->GetHwCaps()->dwMaxThreads;
kernelStatePtr->KernelParams.iCurbeLength = params->iCurbeCount;
kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
kernelStatePtr->KernelParams.iIdCount = 1;
kernelStatePtr->dwCurbeOffset = stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
kernelStatePtr->KernelParams.pBinary =
params->pui8Binary +
(currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
kernelStatePtr->KernelParams.iSize = kernelSize;
CODECHAL_ENCODE_CHK_STATUS_RETURN(stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
stateHeapInterface,
kernelStatePtr->KernelParams.iBTCount,
&kernelStatePtr->dwSshSize,
&kernelStatePtr->dwBindingTableSize));
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(stateHeapInterface, kernelStatePtr));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelStateMbEnc()
{
MhwRenderInterface *renderEngineInterface;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
PMHW_KERNEL_STATE kernelStatePtr;
uint32_t combinedKernelSize;
uint32_t krnStateIdx;
struct CodechalBindingTableVp8Mbenc* bindingTable;
uint8_t *binary;
struct CodechalEncodeVp8InitKernelStateParams initKernelStateParams;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
renderEngineInterface = m_hwInterface->GetRenderInterface();
stateHeapInterface = renderEngineInterface->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(
m_kernelBase,
m_kuid,
&binary,
(uint32_t*)&combinedKernelSize));
for (krnStateIdx = 0; krnStateIdx < CODECHAL_ENCODE_VP8_MBENC_IDX_NUM; krnStateIdx++)
{
kernelStatePtr = &m_mbEncKernelStates[krnStateIdx];
MOS_ZeroMemory(&initKernelStateParams, sizeof(initKernelStateParams));
initKernelStateParams.pKernelState = kernelStatePtr;
initKernelStateParams.pRenderEngineInterface = renderEngineInterface;
initKernelStateParams.pui8Binary = binary;
if (krnStateIdx == CODECHAL_ENCODE_VP8_MBENC_IDX_P)
{
initKernelStateParams.Operation = ENC_MBENC;
initKernelStateParams.dwKrnStateIdx = 1; // VP8MBEnc_Norm_Frm_P
}
else
{
initKernelStateParams.dwKrnStateIdx = 0;
if (krnStateIdx == CODECHAL_ENCODE_VP8_MBENC_IDX_I_CHROMA)
{
initKernelStateParams.Operation = ENC_MBENC; // VP8MBEnc_Norm_Frm_I
}
else // CODECHAL_ENCODE_VP8_MBENC_IDX_I_LUMA
{
initKernelStateParams.Operation = ENC_MBENC_I_LUMA; // VP8MBEnc_I_Luma
}
}
initKernelStateParams.dwCombinedKernelSize = combinedKernelSize;
initKernelStateParams.iBtCount = CODECHAL_VP8_MBENC_NUM_SURFACES_G10;
initKernelStateParams.iCurbeCount = iMbEncCurbeSize_g10[krnStateIdx];
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateHelper(
&initKernelStateParams));
if (krnStateIdx != CODECHAL_ENCODE_VP8_MBENC_IDX_P)
{
// I luma and chroma kernels share a single CURBE, so the DSH contains 2 IDs and 1 CURBE
kernelStatePtr->dwCurbeOffset =
stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData() * 2;
if (krnStateIdx == CODECHAL_ENCODE_VP8_MBENC_IDX_I_CHROMA)
{
// The luma kernel ID will occur before the chroma kernel ID
kernelStatePtr->dwIdOffset =
stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
}
}
}
m_mbEncIFrameDshSize =
(stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData() * 2) +
MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_ENCODE_VP8_MBENC_IDX_I_LUMA].KernelParams.iCurbeLength,
stateHeapInterface->pStateHeapInterface->GetCurbeAlignment());
// Until a better way can be found, maintain old binding table structures
bindingTable = &m_mbEncBindingTable;
bindingTable->dwVp8MBEncMBOut = CODECHAL_VP8_MBENC_PER_MB_OUT_G10;
bindingTable->dwVp8MBEncCurrY = CODECHAL_VP8_MBENC_CURR_Y_G10;
bindingTable->dwVp8MBEncCurrUV = CODECHAL_VP8_MBENC_CURR_UV_G10;
bindingTable->dwVp8MBEncMVDataFromME = CODECHAL_VP8_MBENC_MV_DATA_FROM_ME_G10;
bindingTable->dwVp8MBEncIndMVData = CODECHAL_VP8_MBENC_IND_MV_DATA_G10;
bindingTable->dwVp8MBEncRef1Pic = CODECHAL_VP8_MBENC_REF1_PIC_G10;
bindingTable->dwVp8MBEncRef2Pic = CODECHAL_VP8_MBENC_REF2_PIC_G10;
bindingTable->dwVp8MBEncRef3Pic = CODECHAL_VP8_MBENC_REF3_PIC_G10;
bindingTable->dwVp8MBEncRefMBCount = CODECHAL_VP8_MBENC_REF_MB_COUNT_G10;
bindingTable->dwVp8MBEncMBModeCostLuma = CODECHAL_VP8_MBENC_MB_MODE_COST_LUMA_G10;
bindingTable->dwVp8MBEncBlockModeCost = CODECHAL_VP8_MBENC_BLOCK_MODE_COST_G10;
bindingTable->dwVp8MBEncChromaRecon = CODECHAL_VP8_MBENC_CHROMA_RECON_G10;
bindingTable->dwVp8MBEncHistogram = CODECHAL_VP8_MBENC_HISTOGRAM_G10;
bindingTable->dwVp8MBEncSegmentationMap = CODECHAL_VP8_MBENC_SEGMENTATION_MAP_G10;
bindingTable->dwVp8MBEncBRCDist = CODECHAL_VP8_MBENC_IDIST_G10;
bindingTable->dwVp8MbEncCurrYDownscaled = CODECHAL_VP8_MBENC_CURR_Y_DOWNSCALED_G10;
bindingTable->dwVp8MBEncVMECoarseIntra = CODECHAL_VP8_MBENC_VME_Coarse_Intra_G10;
bindingTable->dwVp8InterPredDistortion = CODECHAL_VP8_MBEBC_INTER_PRED_DISTORTION_G10;
bindingTable->dwVp8PerMVDataSurface = CODECHAL_VP8_MBEBC_PER_MV_DATA_G10;
bindingTable->dwVp8MBEncPerMBQuantDataP = CODECHAL_VP8_MBENC_P_PER_MB_QUANT_G10;
bindingTable->dwVp8MBEncVMEInterPred = CODECHAL_VP8_MBENC_INTER_PRED_G10;
bindingTable->dwVp8MBEncVMEDebugStreamoutI = CODECHAL_VP8_MBENC_I_VME_DEBUG_STREAMOUT_G10;
bindingTable->dwVp8MBModeCostUpdateSurface = CODECHAL_VP8_MBENC_MODE_COST_UPDATE_G10;
bindingTable->dwVp8MBEncVMEDebugStreamoutP = CODECHAL_VP8_MBENC_P_VME_DEBUG_STREAMOUT_G10;
bindingTable->dwVp8MBEncVME = CODECHAL_VP8_MBENC_VME_G10;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelStateBrc()
{
MhwRenderInterface *renderEngineInterface;
PMHW_KERNEL_STATE kernelStatePtr;
uint32_t combinedKernelSize;
uint32_t krnStateIdx;
struct CodechalBindingTableVp8BrcUpdate* bindingTable;
uint8_t *binary;
struct CodechalEncodeVp8InitKernelStateParams initKernelStateParams;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
renderEngineInterface = m_hwInterface->GetRenderInterface();
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(
m_kernelBase,
m_kuid,
&binary,
(uint32_t*)&combinedKernelSize));
for (krnStateIdx = 0; krnStateIdx < CODECHAL_ENCODE_VP8_BRC_IDX_NUM; krnStateIdx++)
{
kernelStatePtr = &m_brcKernelStates[krnStateIdx];
MOS_ZeroMemory(&initKernelStateParams, sizeof(initKernelStateParams));
initKernelStateParams.pKernelState = kernelStatePtr;
initKernelStateParams.pRenderEngineInterface = renderEngineInterface;
initKernelStateParams.pui8Binary = binary;
initKernelStateParams.Operation = ENC_BRC;
initKernelStateParams.dwKrnStateIdx = krnStateIdx;
initKernelStateParams.dwCombinedKernelSize = combinedKernelSize;
initKernelStateParams.iBtCount = iBrcBtCount_g10[krnStateIdx];
initKernelStateParams.iCurbeCount = iBrcCurbeSize_g10[krnStateIdx];
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateHelper(
&initKernelStateParams));
}
// Until a better way can be found, maintain old binding table structures
bindingTable = &m_brcUpdateBindingTable;
bindingTable->dwBrcHistoryBuffer = CODECHAL_VP8_BRC_UPDATE_HISTORY_G10;
bindingTable->dwBrcPakStatisticsOutputBuffer = CODECHAL_VP8_BRC_UPDATE_PAK_STATISTICS_OUTPUT_G10;
bindingTable->dwBrcEncoderCfgReadBuffer = CODECHAL_VP8_BRC_UPDATE_MFX_ENCODER_CFG_READ_G10;
bindingTable->dwBrcEncoderCfgWriteBuffer = CODECHAL_VP8_BRC_UPDATE_MFX_ENCODER_CFG_WRITE_G10;
bindingTable->dwBrcMbEncCurbeReadBuffer = CODECHAL_VP8_BRC_UPDATE_MBENC_CURBE_READ_G10;
bindingTable->dwBrcMbEncCurbeWriteData = CODECHAL_VP8_BRC_UPDATE_MBENC_CURBE_WRITE_G10;
bindingTable->dwBrcDistortionBuffer = CODECHAL_VP8_BRC_UPDATE_DISTORTION_SURFACE_G10;
bindingTable->dwBrcConstantData = CODECHAL_VP8_BRC_UPDATE_CONSTANT_DATA_G10;
bindingTable->dwVp8BrcSegmentationMap = CODECHAL_VP8_BRC_UPDATE_SEGMENT_MAP_G10;
bindingTable->dwBrcMpuCurbeReadBuffer = CODECHAL_VP8_BRC_UPDATE_MPU_CURBE_READ_G10;
bindingTable->dwBrcMpuCurbeWriteData = CODECHAL_VP8_BRC_UPDATE_MPU_CURBE_WRITE_G10;
bindingTable->dwBrcTpuCurbeReadBuffer = CODECHAL_VP8_BRC_UPDATE_TPU_CURBE_READ_G10;
bindingTable->dwBrcTpuCurbeWriteData = CODECHAL_VP8_BRC_UPDATE_TPU_CURBE_WRITE_G10;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelStateMe()
{
MhwRenderInterface *renderEngineInterface;
uint32_t combinedKernelSize;
struct CodechalBindingTableVp8Me* bindingTable;
uint8_t *binary;
struct CodechalEncodeVp8InitKernelStateParams initKernelStateParams;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
renderEngineInterface = m_hwInterface->GetRenderInterface();
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(
m_kernelBase,
m_kuid,
&binary,
(uint32_t*)&combinedKernelSize));
MOS_ZeroMemory(&initKernelStateParams, sizeof(initKernelStateParams));
initKernelStateParams.pKernelState = &m_meKernelState;
initKernelStateParams.pRenderEngineInterface = renderEngineInterface;
initKernelStateParams.pui8Binary = binary;
initKernelStateParams.Operation = ENC_ME;
initKernelStateParams.dwCombinedKernelSize = combinedKernelSize;
initKernelStateParams.iBtCount = CODECHAL_VP8_ME_NUM_SURFACES_G10;
initKernelStateParams.iCurbeCount = sizeof(struct MediaObjectVp8MeStaticDataG10);
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateHelper(
&initKernelStateParams));
// Until a better way can be found, maintain old binding table structures
bindingTable = &m_meBindingTable;
bindingTable->dwVp8MEMVDataSurface = CODECHAL_VP8_ME_MV_DATA_G10;
bindingTable->dwVp816xMEMVDataSurface = CODECHAL_VP8_16xME_MV_DATA_G10;
bindingTable->dwVp8MeDist = CODECHAL_VP8_ME_DISTORTION_G10;
bindingTable->dwVp8MeBrcDist = CODECHAL_VP8_ME_MIN_DIST_BRC_DATA_G10;
bindingTable->dwVp8MeCurrPic = CODECHAL_VP8_VME_INTER_PRED_G10;
bindingTable->dwVp8MeRef1Pic = CODECHAL_VP8_ME_REF1_PIC_G10;
bindingTable->dwVp8MeRef2Pic = CODECHAL_VP8_ME_REF2_PIC_G10;
bindingTable->dwVp8MeRef3Pic = CODECHAL_VP8_ME_REF3_PIC_G10;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelStateMpu()
{
MhwRenderInterface *renderEngineInterface;
uint32_t combinedKernelSize;
struct CodechalBindingTableVp8Mpu* bindingTable;
uint8_t *binary;
struct CodechalEncodeVp8InitKernelStateParams initKernelStateParams;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
renderEngineInterface = m_hwInterface->GetRenderInterface();
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(
m_kernelBase,
m_kuid,
&binary,
(uint32_t*)&combinedKernelSize));
MOS_ZeroMemory(&initKernelStateParams, sizeof(initKernelStateParams));
initKernelStateParams.pKernelState = &m_mpuKernelState;
initKernelStateParams.pRenderEngineInterface = renderEngineInterface;
initKernelStateParams.pui8Binary = binary;
initKernelStateParams.Operation = ENC_MPU;
initKernelStateParams.dwCombinedKernelSize = combinedKernelSize;
initKernelStateParams.iBtCount = CODECHAL_VP8_MPU_FHB_NUM_SURFACES_G10;
initKernelStateParams.iCurbeCount = sizeof(struct MediaObjectVp8MpuFhbStaticDataG10);
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateHelper(
&initKernelStateParams));
// Until a better way can be found, maintain old binding table structures
bindingTable = &m_mpuBindingTable;
bindingTable->dwVp8MpuHistogram = CODECHAL_VP8_MPU_FHB_HISTOGRAM_G10;
bindingTable->dwVp8MpuReferenceModeProbability = CODECHAL_VP8_MPU_FHB_REF_MODE_PROBABILITY_G10;
bindingTable->dwVp8MpuModeProbability = CODECHAL_VP8_MPU_FHB_CURR_MODE_PROBABILITY_G10;
bindingTable->dwVp8MpuReferenceTokenProbability = CODECHAL_VP8_MPU_FHB_REF_TOKEN_PROBABILITY_G10;
bindingTable->dwVp8MpuTokenProbability = CODECHAL_VP8_MPU_FHB_CURR_TOKEN_PROBABILITY_G10;
bindingTable->dwVp8MpuFrameHeaderBitstream = CODECHAL_VP8_MPU_FHB_HEADER_BITSTREAM_G10;
bindingTable->dwVp8MpuHeaderMetaData = CODECHAL_VP8_MPU_FHB_HEADER_METADATA_G10;
bindingTable->dwVp8MpuPictureState = CODECHAL_VP8_MPU_FHB_PICTURE_STATE_G10;
bindingTable->dwVp8MpuMpuBitstream = CODECHAL_VP8_MPU_FHB_MPU_BITSTREAM_G10;
bindingTable->dwVp8MpuTokenBitsData = CODECHAL_VP8_MPU_FHB_TOKEN_BITS_DATA_TABLE_G10;
bindingTable->dwVp8MpuKernelDebugDump = CODECHAL_VP8_MPU_FHB_VME_DEBUG_STREAMOUT_G10;
bindingTable->dwVp8MpuEntropyCost = CODECHAL_VP8_MPU_FHB_ENTROPY_COST_TABLE_G10;
bindingTable->dwVp8MpuModeCostUpdateSurface = CODECHAL_VP8_MPU_MODE_COST_UPDATE_G10;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitKernelStateTpu()
{
MhwRenderInterface *renderEngineInterface;
uint32_t combinedKernelSize;
struct CodechalBindingTableVp8Tpu* bindingTable;
uint8_t *binary;
struct CodechalEncodeVp8InitKernelStateParams initKernelStateParams;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
renderEngineInterface = m_hwInterface->GetRenderInterface();
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(
m_kernelBase,
m_kuid,
&binary,
(uint32_t*)&combinedKernelSize));
MOS_ZeroMemory(&initKernelStateParams, sizeof(initKernelStateParams));
initKernelStateParams.pKernelState = &m_tpuKernelState;
initKernelStateParams.pRenderEngineInterface = renderEngineInterface;
initKernelStateParams.pui8Binary = binary;
initKernelStateParams.Operation = ENC_TPU;
initKernelStateParams.dwCombinedKernelSize = combinedKernelSize;
initKernelStateParams.iBtCount = CODECHAL_VP8_TPU_FHB_NUM_SURFACES_G10;
initKernelStateParams.iCurbeCount = sizeof(struct MediaObjectVp8TpuFhbStaticDataG10);
CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateHelper(
&initKernelStateParams));
// Until a better way can be found, maintain old binding table structures
bindingTable = &m_tpuBindingTable;
bindingTable->dwVp8TpuPakTokenStatistics = CODECHAL_VP8_TPU_FHB_PAK_TOKEN_STATISTICS_G10;
bindingTable->dwVp8TpuTokenUpdateFlags = CODECHAL_VP8_TPU_FHB_TOKEN_UPDATE_FLAGS_G10;
bindingTable->dwVp8TpuEntropyCost = CODECHAL_VP8_TPU_FHB_ENTROPY_COST_TABLE_G10;
bindingTable->dwVp8TpuFrameHeaderBitstream = CODECHAL_VP8_TPU_FHB_HEADER_BITSTREAM_G10;
bindingTable->dwVp8TpuDefaultTokenProbability = CODECHAL_VP8_TPU_FHB_DEFAULT_TOKEN_PROBABILITY_G10;
bindingTable->dwVp8TpuPictureState = CODECHAL_VP8_TPU_FHB_PICTURE_STATE_G10;
bindingTable->dwVp8TpuMpuCurbeData = CODECHAL_VP8_TPU_FHB_MPU_CURBE_DATA_G10;
bindingTable->dwVp8TpuHeaderMetaData = CODECHAL_VP8_TPU_FHB_HEADER_METADATA_G10;
bindingTable->dwVp8TpuTokenProbability = CODECHAL_VP8_TPU_FHB_TOKEN_PROBABILITY_G10;
bindingTable->dwVp8TpuPakHardwareTokenProbabilityPass1 = CODECHAL_VP8_TPU_FHB_PAK_HW_PASS1_PROBABILITY_G10;
bindingTable->dwVp8TpuKeyFrameTokenProbability = CODECHAL_VP8_TPU_FHB_KEY_TOKEN_PROBABILITY_G10;
bindingTable->dwVp8TpuUpdatedTokenProbability = CODECHAL_VP8_TPU_FHB_UPDATED_TOKEN_PROBABILITY_G10;
bindingTable->dwVp8TpuPakHardwareTokenProbabilityPass2 = CODECHAL_VP8_TPU_FHB_PAK_HW_PASS2_PROBABILITY_G10;
bindingTable->dwVp8TpuKernelDebugDump = CODECHAL_VP8_TPU_FHB_VME_DEBUG_STREAMOUT_G10;
bindingTable->dwVp8TpuRepakDecision = CODECHAL_VP8_TPU_FHB_REPAK_DECISION_G10;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitBrcConstantBuffer(struct CodechalVp8InitBrcConstantBufferParams* params)
{
uint8_t* data;
MOS_LOCK_PARAMS lockFlags;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pOsInterface);
MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
lockFlags.WriteOnly = 1;
data = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
&params->resBrcConstantDataBuffer,
&lockFlags);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
MOS_ZeroMemory(data, BRC_CONSTANTSURFACE_VP8);
// Fill surface with QP Adjustment table, Distortion threshold table, MaxFrame threshold table, Distortion QP Adjustment Table for I frame
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BRC_QPAdjustment_DistThreshold_MaxFrameThreshold_DistQPAdjustment_IPB_g10),
(void *)VP8_BRC_QPAdjustment_DistThreshold_MaxFrameThreshold_DistQPAdjustment_IPB_g10,
sizeof(VP8_BRC_QPAdjustment_DistThreshold_MaxFrameThreshold_DistQPAdjustment_IPB_g10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
data += sizeof(VP8_BRC_QPAdjustment_DistThreshold_MaxFrameThreshold_DistQPAdjustment_IPB_g10);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BRC_IFRAME_COST_TABLE_G10),
(void *)VP8_BRC_IFRAME_COST_TABLE_G10,
sizeof(VP8_BRC_IFRAME_COST_TABLE_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
data += sizeof(VP8_BRC_IFRAME_COST_TABLE_G10);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BRC_PFRAME_COST_TABLE_G10),
(void *)VP8_BRC_PFRAME_COST_TABLE_G10,
sizeof(VP8_BRC_PFRAME_COST_TABLE_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
data += sizeof(VP8_BRC_PFRAME_COST_TABLE_G10);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BRC_QUANT_DC_TABLE),
(void *)VP8_BRC_QUANT_DC_TABLE,
sizeof(VP8_BRC_QUANT_DC_TABLE));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
data += sizeof(VP8_BRC_QUANT_DC_TABLE);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BRC_QUANT_AC_TABLE),
(void *)VP8_BRC_QUANT_AC_TABLE,
sizeof(VP8_BRC_QUANT_AC_TABLE));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
data += sizeof(VP8_BRC_QUANT_AC_TABLE);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BRC_SKIP_MV_THRESHOLD_TABLE),
(void *)VP8_BRC_SKIP_MV_THRESHOLD_TABLE,
sizeof(VP8_BRC_SKIP_MV_THRESHOLD_TABLE));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
&params->resBrcConstantDataBuffer);
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitBrcDistortionBuffer()
{
uint8_t *data;
MOS_STATUS status = MOS_STATUS_SUCCESS;
MOS_LOCK_PARAMS lockFlagsWriteOnly;
uint32_t size, width, height;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface);
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&(m_brcBuffers.sMeBrcDistortionBuffer.OsResource),
&lockFlagsWriteOnly);
if (data == nullptr)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock ME BRC Distortion Buffer.");
status = MOS_STATUS_UNKNOWN;
return status;
}
width = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64);
height = 2 * MOS_ALIGN_CEIL((m_downscaledHeightInMb4x * 4), 8);
size = width * height;
MOS_ZeroMemory(data,size);
m_osInterface->pfnUnlockResource(
m_osInterface, &m_brcBuffers.sMeBrcDistortionBuffer.OsResource);
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitMBEncConstantBuffer(struct CodechalVp8InitMbencConstantBufferParams* params)
{
uint8_t *data;
MOS_LOCK_PARAMS lockFlagsWriteOnly;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pOsInterface);
MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
lockFlagsWriteOnly.WriteOnly = 1;
/* First copy MB_MODE_COST_LUMA table */
data = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
&params->sMBModeCostLumaBuffer.OsResource,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
MOS_ZeroMemory(data, params->sMBModeCostLumaBuffer.dwPitch * params->sMBModeCostLumaBuffer.dwHeight);
// Fill surface with VP8_MB_MODE_COST_LUMA table for I frame
status = MOS_SecureMemcpy(
data,
sizeof(VP8_MB_MODE_COST_LUMA_G10),
(void *)VP8_MB_MODE_COST_LUMA_G10,
sizeof(VP8_MB_MODE_COST_LUMA_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
&params->sMBModeCostLumaBuffer.OsResource);
/* Now copy BLOCK_MODE_COST table */
data = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
&params->sBlockModeCostBuffer.OsResource,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
MOS_ZeroMemory(data, params->sBlockModeCostBuffer.dwPitch * params->sBlockModeCostBuffer.dwHeight);
// Fill surface with VP8_BLOCK_MODE_COST table for I frame
status = MOS_SecureMemcpy(
data,
sizeof(VP8_BLOCK_MODE_COST_G10),
(void *)VP8_BLOCK_MODE_COST_G10,
sizeof(VP8_BLOCK_MODE_COST_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
&params->sBlockModeCostBuffer.OsResource);
return status;
}
MOS_STATUS CodechalEncodeVp8G10::InitMpuTpuBuffer()
{
uint8_t *data = nullptr;
uint8_t *origData = nullptr;
MOS_LOCK_PARAMS lockFlagsWriteOnly;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface);
MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
lockFlagsWriteOnly.WriteOnly = 1;
// Last 12 bytes of LFDeltas to be initialized by kernel
origData = data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resModeProbs,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
MOS_ZeroMemory(data, MODE_PROPABILITIES_SIZE);
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resModeProbs);
data = nullptr;
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resRefModeProbs,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
MOS_ZeroMemory(data, MODE_PROPABILITIES_SIZE);
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resRefModeProbs);
data = nullptr;
// Fill surface with VP8_DEFAULT_COEFF_PROBS_G10 table
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resRefCoeffProbs,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10),
(void *)VP8_DEFAULT_COEFF_PROBS_G10,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resRefCoeffProbs);
data = nullptr;
// Init Entropy cost surface
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resEntropyCostTable,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_C0_TABLE),
(void *)VP8_C0_TABLE,
sizeof(VP8_C0_TABLE));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resEntropyCostTable);
data = nullptr;
// Init Token update flags surface
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resPakTokenUpdateFlags,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_PROBABILITY_UPDATE_FLAGS_G10),
(void *)VP8_PROBABILITY_UPDATE_FLAGS_G10,
sizeof(VP8_PROBABILITY_UPDATE_FLAGS_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resPakTokenUpdateFlags);
data = nullptr;
// Init Token update flags surface
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resDefaultTokenProbability,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_COEFF_UPDATE_PROBS_G10),
(void *)VP8_COEFF_UPDATE_PROBS_G10,
sizeof(VP8_COEFF_UPDATE_PROBS_G10));
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resDefaultTokenProbability);
data = nullptr;
// Init key frame prob
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resKeyFrameTokenProbability,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10),
(void *)VP8_DEFAULT_COEFF_PROBS_G10,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resKeyFrameTokenProbability);
data = nullptr;
// Init updated frame token probability
data = (uint8_t *)m_osInterface->pfnLockResource(
m_osInterface,
&m_mpuTpuBuffers.resUpdatedTokenProbability,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10),
(void *)VP8_DEFAULT_COEFF_PROBS_G10,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10));
if (status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
m_osInterface->pfnUnlockResource(
m_osInterface,
&m_mpuTpuBuffers.resUpdatedTokenProbability);
data = nullptr;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::KeyFrameUpdateMpuTpuBuffer(struct CodechalVp8UpdateMpuTpuBufferParams* params)
{
uint8_t *data=nullptr;
uint8_t *origData=nullptr;
MOS_LOCK_PARAMS lockFlagsWriteOnly;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pOsInterface);
MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
lockFlagsWriteOnly.WriteOnly = 1;
// Copy Key frame surface to cur probability surface
origData = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
params->presKeyFrameTokenProbability,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(origData);
data = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
params->presCurrFrameTokenProbability,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
params->dwCoeffProbsSize,
origData,
params->dwCoeffProbsSize);
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
params->presCurrFrameTokenProbability);
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
params->presKeyFrameTokenProbability);
data = nullptr;
// Fill surface with VP8_DEFAULT_COEFF_PROBS_G10 table
data = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
params->presHwTokenProbabilityPass1,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10),
(void *)VP8_DEFAULT_COEFF_PROBS_G10,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
params->presHwTokenProbabilityPass1);
data = nullptr;
data = (uint8_t *)params->pOsInterface->pfnLockResource(
params->pOsInterface,
params->presHwTokenProbabilityPass2,
&lockFlagsWriteOnly);
CODECHAL_ENCODE_CHK_NULL_RETURN(data);
status = MOS_SecureMemcpy(
data,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10),
(void *)VP8_DEFAULT_COEFF_PROBS_G10,
sizeof(VP8_DEFAULT_COEFF_PROBS_G10));
if(status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
params->pOsInterface->pfnUnlockResource(
params->pOsInterface,
params->presHwTokenProbabilityPass2);
data = nullptr;
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SetBrcInitResetCurbe(struct CodechalVp8BrcInitResetCurbeParams* params)
{
struct MediaObjectVp8BrcInitResetStaticDataG10 cmd;
PCODEC_VP8_ENCODE_PIC_PARAMS picParams;
PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
double inputBitsPerFrame, bpsRatio;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPicParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
stateHeapInterface = m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
picParams = params->pPicParams;
seqParams = params->pSeqParams;
MOS_ZeroMemory(&cmd, sizeof(cmd));
cmd.DW1.InitBufFullInBits = seqParams->InitVBVBufferFullnessInBit;
cmd.DW2.BufSizeInBits = seqParams->VBVBufferSizeInBit;
cmd.DW3.AverageBitRate = seqParams->TargetBitRate[seqParams->NumTemporalLayersMinus1] * CODECHAL_ENCODE_BRC_KBPS; //DDI in Kbits
cmd.DW4.MaxBitRate = seqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS;
cmd.DW8.GopP = seqParams->GopPicSize - 1;
cmd.DW9.FrameWidthInBytes = params->dwFrameWidth;
cmd.DW10.FrameHeightInBytes = params->dwFrameHeight;
cmd.DW10.AVBRAccuracy = 30;
// change FrameRateD from 1 to 100 instead of dividing FramesPer100Sec by 100 in DDI
// this is needed to handle precision issue with decimal frame rate ex) 29.97 fps
cmd.DW6.FrameRateM = seqParams->FramesPer100Sec[seqParams->NumTemporalLayersMinus1];
cmd.DW7.FrameRateD = 100; // change FrameRateD from 1 to 100 instead of dividing FramesPer100Sec by 100 in DDI
cmd.DW8.BRCFlag = 0;
if (seqParams->RateControlMethod == RATECONTROL_CBR)
{
cmd.DW4.MaxBitRate = cmd.DW3.AverageBitRate;
cmd.DW8.BRCFlag = cmd.DW8.BRCFlag | CODECHAL_ENCODE_BRCINIT_ISCBR;
}
else if (seqParams->RateControlMethod == RATECONTROL_VBR)
{
if (cmd.DW4.MaxBitRate < cmd.DW3.AverageBitRate)
{
cmd.DW4.MaxBitRate = 2 * cmd.DW3.AverageBitRate;
}
cmd.DW8.BRCFlag = cmd.DW8.BRCFlag | CODECHAL_ENCODE_BRCINIT_ISVBR;
}
// Profile & level max frame size
// DW0 is DDI param seq param.
cmd.DW0.ProfileLevelMaxFrame = params->pSeqParams->UserMaxFrameSize;
cmd.DW0.ProfileLevelMaxFrame = params->dwFrameWidth * params->dwFrameHeight;
// Set dynamic thresholds
inputBitsPerFrame =
((double)(cmd.DW4.MaxBitRate) * (double)(cmd.DW7.FrameRateD) /
(double)(cmd.DW6.FrameRateM));
if (cmd.DW2.BufSizeInBits < (uint32_t)inputBitsPerFrame * 4)
{
cmd.DW2.BufSizeInBits = (uint32_t)inputBitsPerFrame * 4;
}
if (cmd.DW1.InitBufFullInBits == 0)
{
cmd.DW1.InitBufFullInBits = 7 * cmd.DW2.BufSizeInBits / 8;
}
if (cmd.DW1.InitBufFullInBits < (uint32_t)(inputBitsPerFrame * 2))
{
cmd.DW1.InitBufFullInBits = (uint32_t)(inputBitsPerFrame * 2);
}
if (cmd.DW1.InitBufFullInBits > cmd.DW2.BufSizeInBits)
{
cmd.DW1.InitBufFullInBits = cmd.DW2.BufSizeInBits;
}
bpsRatio = inputBitsPerFrame / ((double)(cmd.DW2.BufSizeInBits) / 30);
bpsRatio = (bpsRatio < 0.1) ? 0.1 : (bpsRatio > 3.5) ? 3.5 : bpsRatio;
cmd.DW9.FrameWidthInBytes = seqParams->FrameWidth;
cmd.DW10.FrameHeightInBytes = seqParams->FrameHeight;
cmd.DW10.AVBRAccuracy = 30;
cmd.DW11.AVBRConvergence = 150;
cmd.DW11.MinQP = picParams->ClampQindexLow;
cmd.DW12.MaxQP = picParams->ClampQindexHigh;
cmd.DW12.LevelQP = 60;
// DW13 default 100
cmd.DW13.MaxSection_pct = 100;
cmd.DW13.OverShootCBR_pct = 115;
// DW14 default 100
cmd.DW14.MinSection_pct = 100;
cmd.DW14.VBRBias_pct = 100;
cmd.DW15.InstantRateThreshold0ForP = 30;
cmd.DW15.InstantRateThreshold1ForP = 50;
cmd.DW15.InstantRateThreshold2ForP = 70;
cmd.DW15.InstantRateThreshold3ForP = 120;
cmd.DW17.InstantRateThreshold0ForI = 30;
cmd.DW17.InstantRateThreshold1ForI = 50;
cmd.DW17.InstantRateThreshold2ForI = 90;
cmd.DW17.InstantRateThreshold3ForI = 115;
cmd.DW18.DeviationThreshold0ForP = (uint32_t)(-50 * pow(0.9, bpsRatio));
cmd.DW18.DeviationThreshold1ForP = (uint32_t)(-50 * pow(0.66, bpsRatio));
cmd.DW18.DeviationThreshold2ForP = (uint32_t)(-50 * pow(0.46, bpsRatio));
cmd.DW18.DeviationThreshold3ForP = (uint32_t)(-50 * pow(0.3, bpsRatio));
cmd.DW19.DeviationThreshold4ForP = (uint32_t)(50 * pow(0.3, bpsRatio));
cmd.DW19.DeviationThreshold5ForP = (uint32_t)(50 * pow(0.46, bpsRatio));
cmd.DW19.DeviationThreshold6ForP = (uint32_t)(50 * pow(0.7, bpsRatio));
cmd.DW19.DeviationThreshold7ForP = (uint32_t)(50 * pow(0.9, bpsRatio));
cmd.DW20.DeviationThreshold0ForVBR = (uint32_t)(-50 * pow(0.9, bpsRatio));
cmd.DW20.DeviationThreshold1ForVBR = (uint32_t)(-50 * pow(0.7, bpsRatio));
cmd.DW20.DeviationThreshold2ForVBR = (uint32_t)(-50 * pow(0.5, bpsRatio));
cmd.DW20.DeviationThreshold3ForVBR = (uint32_t)(-50 * pow(0.3, bpsRatio));
cmd.DW21.DeviationThreshold4ForVBR = (uint32_t)(100 * pow(0.4, bpsRatio));
cmd.DW21.DeviationThreshold5ForVBR = (uint32_t)(100 * pow(0.5, bpsRatio));
cmd.DW21.DeviationThreshold6ForVBR = (uint32_t)(100 * pow(0.75, bpsRatio));
cmd.DW21.DeviationThreshold7ForVBR = (uint32_t)(100 * pow(0.9, bpsRatio));
cmd.DW22.DeviationThreshold0ForI = (uint32_t)(-50 * pow(0.8, bpsRatio));
cmd.DW22.DeviationThreshold1ForI = (uint32_t)(-50 * pow(0.6, bpsRatio));
cmd.DW22.DeviationThreshold2ForI = (uint32_t)(-50 * pow(0.34, bpsRatio));
cmd.DW22.DeviationThreshold3ForI = (uint32_t)(-50 * pow(0.2, bpsRatio));
cmd.DW23.DeviationThreshold4ForI = (uint32_t)(50 * pow(0.2, bpsRatio));
cmd.DW23.DeviationThreshold5ForI = (uint32_t)(50 * pow(0.4, bpsRatio));
cmd.DW23.DeviationThreshold6ForI = (uint32_t)(50 * pow(0.66, bpsRatio));
cmd.DW23.DeviationThreshold7ForI = (uint32_t)(50 * pow(0.9, bpsRatio));
cmd.DW24.NumTLevels = seqParams->NumTemporalLayersMinus1 + 1;
if( seqParams->NumTemporalLayersMinus1 > 0)
{
uint32_t tempBitRate[NAX_NUM_TEMPORAL_LAYERS];
CODECHAL_ENCODE_CHK_STATUS_RETURN(CalMaxLevelRatioForTL(
seqParams->FramesPer100Sec,
seqParams->TargetBitRate,
(uint32_t)seqParams->NumTemporalLayersMinus1,
tempBitRate));
cmd.DW24.INITBCK_MaxLevel_Ratio_U8_Layer0 = uint32_t(tempBitRate[0]);
cmd.DW24.INITBCK_MaxLevel_Ratio_U8_Layer1 = uint32_t(tempBitRate[1]);
cmd.DW24.INITBCK_MaxLevel_Ratio_U8_Layer2 = uint32_t(tempBitRate[2]);
cmd.DW25.INITBCK_MaxLevel_Ratio_U8_Layer3 = uint32_t(tempBitRate[3]);
}
else
{
cmd.DW24.INITBCK_MaxLevel_Ratio_U8_Layer0 = 0;
cmd.DW24.INITBCK_MaxLevel_Ratio_U8_Layer1 = 0;
cmd.DW24.INITBCK_MaxLevel_Ratio_U8_Layer2 = 0;
cmd.DW25.INITBCK_MaxLevel_Ratio_U8_Layer3 = 0;
}
if (params->bInitBrc)
{
*params->pdBrcInitCurrentTargetBufFullInBits = cmd.DW1.InitBufFullInBits;
}
*params->pdwBrcInitResetBufSizeInBits = cmd.DW2.BufSizeInBits;
*params->pdBrcInitResetInputBitsPerFrame = inputBitsPerFrame;
cmd.DW26.HistoryBufferBTI = CODECHAL_VP8_BRC_INIT_RESET_HISTORY_G10;
cmd.DW27.DistortionBufferBTI = CODECHAL_VP8_BRC_INIT_RESET_DISTORTION_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
&cmd,
params->pKernelState->dwCurbeOffset,
sizeof(cmd)));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SendBrcInitResetSurfaces(
PMOS_COMMAND_BUFFER cmdBuffer,
struct CodechalVp8BrcInitResetSurfaceParams* params)
{
uint32_t size;
PMHW_KERNEL_STATE kernelState;
CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->presBrcHistoryBuffer);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
kernelState = params->pKernelState;
// BRC history buffer
size = ENCODE_VP8_BRC_HISTORY_BUFFER_SIZE;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.bIsWritable = true;
surfaceCodecParams.presBuffer = params->presBrcHistoryBuffer;
surfaceCodecParams.dwSize = size;
surfaceCodecParams.dwBindingTableOffset = CODECHAL_VP8_BRC_INIT_RESET_HISTORY_G10;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Distortion Surface (output)
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.bIs2DSurface = true;
surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.psSurface = params->psMeBrcDistortionBuffer;
surfaceCodecParams.dwBindingTableOffset = CODECHAL_VP8_BRC_INIT_RESET_DISTORTION_G10;
surfaceCodecParams.bIsWritable = true;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SetBrcUpdateCurbe(struct CodechalVp8BrcUpdateCurbeParams* params)
{
struct MediaObjectVp8BrcUpdateStaticDataG10 cmd;
PCODEC_VP8_ENCODE_PIC_PARAMS picParams;
PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams;
PCODEC_VP8_ENCODE_QUANT_DATA vp8QuantData;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
MOS_STATUS status = MOS_STATUS_SUCCESS;
uint32_t i;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPicParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pVp8QuantData);
stateHeapInterface =
m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
picParams = params->pPicParams;
seqParams = params->pSeqParams;
vp8QuantData = params->pVp8QuantData;
MOS_ZeroMemory(&cmd, sizeof(cmd));
cmd.DW0.TargetSize = 0;
cmd.DW2.PictureHeaderSize = 0; // matching kernel value
cmd.DW5.TargetSizeFlag = 0;
if (*params->pdBrcInitCurrentTargetBufFullInBits > (double)params->dwBrcInitResetBufSizeInBits)
{
*params->pdBrcInitCurrentTargetBufFullInBits -= (double)params->dwBrcInitResetBufSizeInBits;
cmd.DW5.TargetSizeFlag = 1;
}
cmd.DW0.TargetSize = (uint32_t)(*params->pdBrcInitCurrentTargetBufFullInBits);
cmd.DW5.CurrFrameType = (params->wPictureCodingType == I_TYPE) ? 2 : 0;
cmd.DW5.BRCFlag = 16 * seqParams->RateControlMethod;
cmd.DW5.MaxNumPAKs = params->dwVp8BrcNumPakPasses;
cmd.DW6.TID = picParams->temporal_id; // Default: 0 - if temporal scalability is not supported
cmd.DW6.NumTLevels = seqParams->NumTemporalLayersMinus1 + 1; // Default: 1 - if temporal scalability is not supported
cmd.DW8.StartGlobalAdjustMult0 = 1;
cmd.DW8.StartGlobalAdjustMult1 = 1;
cmd.DW8.StartGlobalAdjustMult2 = 3;
cmd.DW8.StartGlobalAdjustMult3 = 2;
cmd.DW9.StartGlobalAdjustDiv0 = 40;
cmd.DW9.StartGlobalAdjustDiv1 = 5;
cmd.DW9.StartGlobalAdjustDiv2 = 5;
cmd.DW9.StartGlobalAdjustMult4 = 1;
cmd.DW10.StartGlobalAdjustDiv3 = 3;
cmd.DW10.StartGlobalAdjustDiv4 = 1;
cmd.DW10.QPThreshold0 = 20;//7;
cmd.DW10.QPThreshold1 = 40;//18;
cmd.DW11.QPThreshold2 = 60;//25;
cmd.DW11.QPThreshold3 = 90;//37;
cmd.DW11.gRateRatioThreshold0 = 40;
cmd.DW11.gRateRatioThreshold1 = 75;
cmd.DW12.gRateRatioThreshold2 = 97;
cmd.DW12.gRateRatioThreshold3 = 103;
cmd.DW12.gRateRatioThreshold4 = 125;
cmd.DW12.gRateRatioThreshold5 = 160;
cmd.DW13.gRateRatioThresholdQP0 = MOS_BITFIELD_VALUE((uint32_t)-3, 8);
cmd.DW13.gRateRatioThresholdQP1 = MOS_BITFIELD_VALUE((uint32_t)-2, 8);
cmd.DW13.gRateRatioThresholdQP2 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
cmd.DW13.gRateRatioThresholdQP3 = 0;
cmd.DW14.gRateRatioThresholdQP4 = 1;
cmd.DW14.gRateRatioThresholdQP5 = 2;
cmd.DW14.gRateRatioThresholdQP6 = 3;
cmd.DW14.IndexOfPreviousQP = 0;
*params->pdBrcInitCurrentTargetBufFullInBits += params->dBrcInitResetInputBitsPerFrame;
cmd.DW3.startGAdjFrame0 = 10;
cmd.DW3.startGAdjFrame1 = 50;
cmd.DW4.startGAdjFrame2 = 100;
cmd.DW4.startGAdjFrame3 = 150;
cmd.DW11.gRateRatioThreshold0 = 40;
cmd.DW11.gRateRatioThreshold1 = 75;
cmd.DW12.gRateRatioThreshold2 = 97;
cmd.DW12.gRateRatioThreshold3 = 103;
cmd.DW12.gRateRatioThreshold4 = 125;
cmd.DW12.gRateRatioThreshold5 = 160;
cmd.DW13.gRateRatioThresholdQP0 = MOS_BITFIELD_VALUE((uint32_t)-3, 8);
cmd.DW13.gRateRatioThresholdQP1 = MOS_BITFIELD_VALUE((uint32_t)-2, 8);
cmd.DW13.gRateRatioThresholdQP2 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
cmd.DW13.gRateRatioThresholdQP3 = 0;
cmd.DW14.gRateRatioThresholdQP4 = 1;
cmd.DW14.gRateRatioThresholdQP5 = 2;
cmd.DW14.gRateRatioThresholdQP6 = 3;
cmd.DW14.IndexOfPreviousQP = 0;
// 16bits are used instead of 8bits to fix 4K related issue
cmd.DW15.FrameWidthInMB = params->dwFrameWidthInMB;
cmd.DW15.FrameHeightInMB = params->dwFrameHeightInMB;
cmd.DW16.PFrameQPSeg0 = vp8QuantData->QIndex[0];
cmd.DW16.PFrameQPSeg1 = vp8QuantData->QIndex[1];
cmd.DW16.PFrameQPSeg2 = vp8QuantData->QIndex[2];
cmd.DW16.PFrameQPSeg3 = vp8QuantData->QIndex[3];
cmd.DW17.KeyFrameQPSeg0 = vp8QuantData->QIndex[0];
cmd.DW17.KeyFrameQPSeg1 = vp8QuantData->QIndex[1];
cmd.DW17.KeyFrameQPSeg2 = vp8QuantData->QIndex[2];
cmd.DW17.KeyFrameQPSeg3 = vp8QuantData->QIndex[3];
cmd.DW18.QDeltaPlane0 = vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
cmd.DW18.QDeltaPlane1 = vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_AC];
cmd.DW18.QDeltaPlane2 = vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_DC];
cmd.DW18.QDeltaPlane3 = vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
cmd.DW19.QDeltaPlane4 = vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
// temporal scaliability is enable
cmd.DW19.MainRef = 0;
cmd.DW19.RefFrameFlags = 0;
if (params->wPictureCodingType == P_TYPE) // P frame
{
if (seqParams->NumTemporalLayersMinus1 > 0)
{
uint32_t m_ref_frame_flags = picParams->ref_frame_ctrl;
uint8_t m_rfo[3];
m_rfo[2] = picParams->first_ref;
m_rfo[1] = picParams->second_ref;
m_rfo[0] = 6 - m_rfo[2] - m_rfo[1];
uint32_t MainRef = 0;
uint32_t k = 0;
for (i = 0; i <3; i++)
{
if (m_ref_frame_flags & (0x1 << (m_rfo[i] - 1))) {
MainRef |= (m_rfo[i] << (2 * k));
k++;
}
}
cmd.DW19.MainRef = MainRef;
cmd.DW19.RefFrameFlags = m_ref_frame_flags;
}
else {
// original one for MainRef and RefFlag
cmd.DW19.MainRef = VP8_MAINREF_TABLE_G10[picParams->ref_frame_ctrl];
cmd.DW19.RefFrameFlags = picParams->ref_frame_ctrl;
}
}
cmd.DW20.SegOn = picParams->segmentation_enabled;
cmd.DW20.BRCMethod = seqParams->RateControlMethod;
// DDI Seq Parameter
// 0: Default, decided internally based on target usage.
// 1: MB BRC enabled.
// 2: MB BRC disabled.
// Curbe 1: MBRC on, 0: MBRC off
cmd.DW20.MBRC = (seqParams->MBBRC == 1)? 1 : 0;
cmd.DW20.VMEIntraPrediction = (params->ucKernelMode == encodePerformanceMode) ? 1 : 0;
cmd.DW22.HistorytBufferBTI = CODECHAL_VP8_BRC_UPDATE_HISTORY_G10;
cmd.DW23.PakStatisticsBTI = CODECHAL_VP8_BRC_UPDATE_PAK_STATISTICS_OUTPUT_G10;
cmd.DW24.MfxVp8EncoderCfgReadBTI = CODECHAL_VP8_BRC_UPDATE_MFX_ENCODER_CFG_READ_G10;
cmd.DW25.MfxVp8EncoderCfgWriteBTI = CODECHAL_VP8_BRC_UPDATE_MFX_ENCODER_CFG_WRITE_G10;
cmd.DW26.MBEncCurbeReadBTI = CODECHAL_VP8_BRC_UPDATE_MBENC_CURBE_READ_G10;
cmd.DW27.MBEncCurbeWriteBTI = CODECHAL_VP8_BRC_UPDATE_MBENC_CURBE_WRITE_G10;
cmd.DW28.DistortionBTI = CODECHAL_VP8_BRC_UPDATE_DISTORTION_SURFACE_G10;
cmd.DW29.ConstantDataBTI = CODECHAL_VP8_BRC_UPDATE_CONSTANT_DATA_G10;
cmd.DW30.SegmentMapBTI = CODECHAL_VP8_BRC_UPDATE_SEGMENT_MAP_G10;
cmd.DW31.MpuCurbeReadBTI = CODECHAL_VP8_BRC_UPDATE_MPU_CURBE_READ_G10;
cmd.DW32.MpuCurbeWriteBTI = CODECHAL_VP8_BRC_UPDATE_MPU_CURBE_WRITE_G10;
cmd.DW33.TpuCurbeReadBTI = CODECHAL_VP8_BRC_UPDATE_TPU_CURBE_READ_G10;
cmd.DW34.TpuCurbeWriteBTI = CODECHAL_VP8_BRC_UPDATE_TPU_CURBE_WRITE_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(
m_brcKernelStates[CODECHAL_ENCODE_VP8_BRC_IDX_UPDATE].m_dshRegion.AddData(
&cmd,
m_brcKernelStates[CODECHAL_ENCODE_VP8_BRC_IDX_UPDATE].dwCurbeOffset,
sizeof(cmd)));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SetMbEncCurbe(struct CodechalVp8MbencCurbeParams* params)
{
PCODEC_VP8_ENCODE_PIC_PARAMS picParams;
PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams;
PCODEC_VP8_ENCODE_QUANT_DATA vp8QuantData;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPicParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pVp8QuantData);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
stateHeapInterface =
m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
picParams = params->pPicParams;
seqParams = params->pSeqParams;
vp8QuantData = params->pVp8QuantData;
if (params->wPictureCodingType == I_TYPE)
{
struct MediaObjectVp8MbencIStaticDataG10 cmd;
int16_t usQi_Y_Dc, usQi_UV_Dc, usQi_UV_Ac;
MOS_ZeroMemory(&cmd, sizeof(cmd));
cmd.DW0.FrameWidth = (seqParams->FrameWidth + 15) & (~0xF); /* Kernel require MB boundary aligned dimensions */
cmd.DW0.FrameHeight = (seqParams->FrameHeight + 15) & (~0xF);
cmd.DW1.FrameType = 0; /* key frame I-Frame */
cmd.DW1.EnableSegmentation = picParams->segmentation_enabled;
cmd.DW1.EnableHWIntraPrediction = (params->ucKernelMode == encodePerformanceMode) ? 1 : 0;
cmd.DW1.EnableEnableChromaIPEnhancement = 1; /* Always enabled and cannot be disabled */
cmd.DW1.EnableDebugDumps = 0;
cmd.DW1.EnableMPUHistogramUpdate = 1;
cmd.DW1.VMEDistortionMeasure = 2;
cmd.DW1.VMEEnableTMCheck = 0;
usQi_Y_Dc = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW2.LambdaSegment0 = (uint16_t)((VP8_QUANT_DC_G10[usQi_Y_Dc] * VP8_QUANT_DC_G10[usQi_Y_Dc]) / 4);
if (picParams->segmentation_enabled)
{
usQi_Y_Dc = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW2.LambdaSegment1 = (uint16_t)((VP8_QUANT_DC_G10[usQi_Y_Dc] * VP8_QUANT_DC_G10[usQi_Y_Dc]) / 4);
usQi_Y_Dc = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW3.LambdaSegment2 = (uint16_t)((VP8_QUANT_DC_G10[usQi_Y_Dc] * VP8_QUANT_DC_G10[usQi_Y_Dc]) / 4);
usQi_Y_Dc = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW3.LambdaSegment3 = (uint16_t)((VP8_QUANT_DC_G10[usQi_Y_Dc] * VP8_QUANT_DC_G10[usQi_Y_Dc]) / 4);
}
cmd.DW4.AllDCBiasSegment0 = VP8_ALL_DC_BIAS_DEFAULT;
if (picParams->segmentation_enabled)
{
cmd.DW4.AllDCBiasSegment1 = VP8_ALL_DC_BIAS_DEFAULT;
cmd.DW5.AllDCBiasSegment2 = VP8_ALL_DC_BIAS_DEFAULT;
cmd.DW5.AllDCBiasSegment3 = VP8_ALL_DC_BIAS_DEFAULT;
}
usQi_UV_Dc = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW6.ChromaDCDeQuantSegment0 = VP8_QUANT_DC_G10[usQi_UV_Dc];
if (picParams->segmentation_enabled)
{
usQi_UV_Dc = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW6.ChromaDCDeQuantSegment1 = VP8_QUANT_DC_G10[usQi_UV_Dc];
usQi_UV_Dc = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW7.ChromaDCDeQuantSegment2 = VP8_QUANT_DC_G10[usQi_UV_Dc];
usQi_UV_Dc = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW7.ChromaDCDeQuantSegment3 = VP8_QUANT_DC_G10[usQi_UV_Dc];
}
usQi_UV_Ac = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW8.ChromaACDeQuantSegment0 = VP8_QUANT_AC_G10[usQi_UV_Ac];
cmd.DW10.ChromaAC0Threshold0Segment0 = (uint16_t)((((((1) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
cmd.DW10.ChromaAC0Threshold1Segment0 = (uint16_t)((((((2) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
if (picParams->segmentation_enabled)
{
usQi_UV_Ac = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW8.ChromaACDeQuantSegment1 = VP8_QUANT_AC_G10[usQi_UV_Ac];
cmd.DW11.ChromaAC0Threshold0Segment1 = (uint16_t)((((((1) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
cmd.DW11.ChromaAC0Threshold1Segment1 = (uint16_t)((((((2) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
usQi_UV_Ac = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW9.ChromaACDeQuantSegment2 = VP8_QUANT_AC_G10[usQi_UV_Ac];
cmd.DW12.ChromaAC0Threshold0Segment2 = (uint16_t)((((((1) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
cmd.DW12.ChromaAC0Threshold1Segment2 = (uint16_t)((((((2) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
usQi_UV_Ac = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW9.ChromaACDeQuantSegment3 = VP8_QUANT_AC_G10[usQi_UV_Ac];
cmd.DW13.ChromaAC0Threshold0Segment3 = (uint16_t)((((((1) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
cmd.DW13.ChromaAC0Threshold1Segment3 = (uint16_t)((((((2) << 16) - 1)*1.0 / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7))* (1 << 13) + 3400) / 2217.0);
}
usQi_UV_Dc = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW14.ChromaDCThreshold0Segment0 = (((1) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW14.ChromaDCThreshold1Segment0 = (((2) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW15.ChromaDCThreshold2Segment0 = (((3) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW15.ChromaDCThreshold3Segment0 = (((4) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
if (picParams->segmentation_enabled)
{
usQi_UV_Dc = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW16.ChromaDCThreshold0Segment1 = (((1) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW16.ChromaDCThreshold1Segment1 = (((2) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW17.ChromaDCThreshold2Segment1 = (((3) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW17.ChromaDCThreshold3Segment1 = (((4) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
usQi_UV_Dc = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW18.ChromaDCThreshold0Segment2 = (((1) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW18.ChromaDCThreshold1Segment2 = (((2) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW19.ChromaDCThreshold2Segment2 = (((3) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW19.ChromaDCThreshold3Segment2 = (((4) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
usQi_UV_Dc = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
usQi_UV_Dc = usQi_UV_Dc < 0 ? 0 : (usQi_UV_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Dc);
cmd.DW20.ChromaDCThreshold0Segment3 = (((1) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW20.ChromaDCThreshold1Segment3 = (((2) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW21.ChromaDCThreshold2Segment3 = (((3) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
cmd.DW21.ChromaDCThreshold3Segment3 = (((4) << 16) - 1) / ((1 << 16) / VP8_QUANT_DC_G10[usQi_UV_Dc]) - ((48 * VP8_QUANT_DC_G10[usQi_UV_Dc]) >> 7);
}
usQi_UV_Ac = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW22.ChromaAC1ThresholdSegment0 = ((1 << (16)) - 1) / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7);
if (picParams->segmentation_enabled)
{
usQi_UV_Ac = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW22.ChromaAC1ThresholdSegment1 = ((1 << (16)) - 1) / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7);
usQi_UV_Ac = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW23.ChromaAC1ThresholdSegment2 = ((1 << (16)) - 1) / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7);
usQi_UV_Ac = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
usQi_UV_Ac = usQi_UV_Ac < 0 ? 0 : (usQi_UV_Ac > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_UV_Ac);
cmd.DW23.ChromaAC1ThresholdSegment3 = ((1 << (16)) - 1) / ((1 << 16) / VP8_QUANT_AC_G10[usQi_UV_Ac]) - ((48 * VP8_QUANT_AC_G10[usQi_UV_Ac]) >> 7);
}
usQi_Y_Dc = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW24.VME16x16CostSegment0 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][0];
cmd.DW25.VME4x4CostSegment0 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][1];
cmd.DW26.VME16x16NonDCPenaltySegment0 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][2];
cmd.DW27.VME4x4NonDCPenaltySegment0 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][3];
if (picParams->segmentation_enabled)
{
usQi_Y_Dc = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW24.VME16x16CostSegment1 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][0];
cmd.DW25.VME4x4CostSegment1 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][1];
cmd.DW26.VME16x16NonDCPenaltySegment1 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][2];
cmd.DW27.VME4x4NonDCPenaltySegment1 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][3];
usQi_Y_Dc = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW24.VME16x16CostSegment2 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][0];
cmd.DW25.VME4x4CostSegment2 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][1];
cmd.DW26.VME16x16NonDCPenaltySegment2 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][2];
cmd.DW27.VME4x4NonDCPenaltySegment2 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][3];
usQi_Y_Dc = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc = usQi_Y_Dc < 0 ? 0 : (usQi_Y_Dc > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc);
cmd.DW24.VME16x16CostSegment3 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][0];
cmd.DW25.VME4x4CostSegment3 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][1];
cmd.DW26.VME16x16NonDCPenaltySegment3 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][2];
cmd.DW27.VME4x4NonDCPenaltySegment3 = VP8_IFRAME_VME_COSTS_G10[usQi_Y_Dc & 0x7F][3];
}
cmd.DW32.MBEncPerMBOutDataSurfBTI = CODECHAL_VP8_MBENC_PER_MB_OUT_G10;
/* For CM kernels the Surface index of UV surface gets incremented by 1, so the Luma surface index itself is programmed in the Curbe data */
cmd.DW33.MBEncCurrYBTI = CODECHAL_VP8_MBENC_CURR_Y_G10;
cmd.DW34.MBEncCurrUVBTI = CODECHAL_VP8_MBENC_CURR_Y_G10;//CODECHAL_VP8_MBENC_CURR_UV_G10;
cmd.DW35.MBModeCostLumaBTI = CODECHAL_VP8_MBENC_MB_MODE_COST_LUMA_G10;
cmd.DW36.MBEncBlockModeCostBTI = CODECHAL_VP8_MBENC_BLOCK_MODE_COST_G10;
cmd.DW37.ChromaReconSurfBTI = CODECHAL_VP8_MBENC_CHROMA_RECON_G10;
cmd.DW38.SegmentationMapBTI = CODECHAL_VP8_MBENC_SEGMENTATION_MAP_G10;
cmd.DW39.HistogramBTI = CODECHAL_VP8_MBENC_HISTOGRAM_G10;
cmd.DW40.MBEncVMEDebugStreamOutBTI = CODECHAL_VP8_MBENC_I_VME_DEBUG_STREAMOUT_G10;
cmd.DW41.VmeBTI = CODECHAL_VP8_MBENC_VME_G10;
cmd.DW42.IDistortionSurfaceBTI = CODECHAL_VP8_MBENC_IDIST_G10;
cmd.DW43.MBEncCurrYDownScaledBTI = CODECHAL_VP8_MBENC_CURR_Y_DOWNSCALED_G10;
cmd.DW44.MBEncVMECoarseIntraBTI = CODECHAL_VP8_MBENC_VME_Coarse_Intra_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
&cmd,
params->pKernelState->dwCurbeOffset,
sizeof(cmd)));
}
else
{
//P frame CURBE
struct MediaObjectVp8MbencPStaticDataG10 cmd;
int16_t usQi_Y_Dc_Seg0, usQi_Y_Dc_Seg1, usQi_Y_Dc_Seg2, usQi_Y_Dc_Seg3;
int16_t usQp_Seg0, usQp_Seg1, usQp_Seg2, usQp_Seg3;
MOS_ZeroMemory(&cmd, sizeof(cmd));
usQi_Y_Dc_Seg0 = vp8QuantData->QIndex[0] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];/* TBC */
usQi_Y_Dc_Seg1 = vp8QuantData->QIndex[1] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc_Seg2 = vp8QuantData->QIndex[2] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQi_Y_Dc_Seg3 = vp8QuantData->QIndex[3] + vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
usQp_Seg0 = usQi_Y_Dc_Seg0 < 0 ? 0 : (usQi_Y_Dc_Seg0 > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc_Seg0);
usQp_Seg1 = usQi_Y_Dc_Seg1 < 0 ? 0 : (usQi_Y_Dc_Seg1 > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc_Seg1);
usQp_Seg2 = usQi_Y_Dc_Seg2 < 0 ? 0 : (usQi_Y_Dc_Seg2 > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc_Seg2);
usQp_Seg3 = usQi_Y_Dc_Seg3 < 0 ? 0 : (usQi_Y_Dc_Seg3 > CODECHAL_VP8_QP_MAX ? CODECHAL_VP8_QP_MAX : usQi_Y_Dc_Seg3);
uint8_t MEMethod = (params->ucKernelMode == encodeNormalMode) ? 6 : 4;
//DW0
cmd.DW0.FrameWidth = (seqParams->FrameWidth + 15) & (~0xF); /* Kernel require MB boundary aligned dimensions */
cmd.DW0.FrameHeight = (seqParams->FrameHeight + 15) & (~0xF);
// DW1
cmd.DW1.FrameType = 1; // P-frame
cmd.DW1.MultiplePred = (params->ucKernelMode == encodeNormalMode) ? 1 : ((params->ucKernelMode == encodePerformanceMode) ? 0 : 2);
cmd.DW1.HMEEnable = params->bHmeEnabled;
cmd.DW1.HMECombineOverlap = 1;
cmd.DW1.EnableTemporalScalability = 0;
cmd.DW1.RefFrameFlags = picParams->ref_frame_ctrl;
cmd.DW1.EnableSegmentation = picParams->segmentation_enabled;
cmd.DW1.EnableSegmentationInfoUpdate = 1;//dont care field hardcoding to match kernel- picParams->update_mb_segmentation_map;
cmd.DW1.MultiReferenceQPCheck = false;
cmd.DW1.ModecostEnableFlag = 1;
// temporal scaliability is enable
cmd.DW1.MainRef = 0;
if (seqParams->NumTemporalLayersMinus1 > 0)
{
uint32_t m_ref_frame_flags = picParams->ref_frame_ctrl;
uint8_t m_rfo[3];
m_rfo[2] = picParams->first_ref;
m_rfo[1] = picParams->second_ref;
m_rfo[0] = 6 - m_rfo[2] - m_rfo[1];
uint32_t MainRef = 0;
uint32_t k = 0;
uint32_t i;
for (i = 0; i <3; i++)
{
if (m_ref_frame_flags & (0x1 << (m_rfo[i] - 1))) {
MainRef |= (m_rfo[i] << (2 * k));
k++;
}
}
cmd.DW1.MainRef = MainRef;
}
else {
// original one for MainRef and RefFlag
cmd.DW1.MainRef = VP8_MAINREF_TABLE_G10[picParams->ref_frame_ctrl];
}
//DW2
cmd.DW2.LambdaIntraSegment0 = VP8_QUANT_DC_G10[usQp_Seg0];
cmd.DW2.LambdaInterSegment0 = (VP8_QUANT_DC_G10[usQp_Seg0] >> 2);
//DW3
cmd.DW3.LambdaIntraSegment1 = (VP8_QUANT_DC_G10[usQp_Seg1]);
cmd.DW3.LambdaInterSegment1 = (VP8_QUANT_DC_G10[usQp_Seg1] >> 2);
//DW4
cmd.DW4.LambdaIntraSegment2 = (VP8_QUANT_DC_G10[usQp_Seg2]);
cmd.DW4.LambdaInterSegment2 = (VP8_QUANT_DC_G10[usQp_Seg2] >> 2);
//DW5
cmd.DW5.LambdaIntraSegment3 = (VP8_QUANT_DC_G10[usQp_Seg3]);
cmd.DW5.LambdaInterSegment3 = (VP8_QUANT_DC_G10[usQp_Seg3] >> 2);
//DW6
cmd.DW6.ReferenceFrameSignBias_3 = picParams->sign_bias_golden;
cmd.DW6.ReferenceFrameSignBias_2 = picParams->sign_bias_alternate;
cmd.DW6.ReferenceFrameSignBias_1 = picParams->sign_bias_golden ^ picParams->sign_bias_alternate;
cmd.DW6.ReferenceFrameSignBias_0 = 0;
//DW7
cmd.DW7.RawDistThreshold = (params->ucKernelMode == encodeNormalMode) ? 50 : ((params->ucKernelMode == encodePerformanceMode) ? 0 : 100);
cmd.DW7.TemporalLayerID = picParams->temporal_id;
//DW8
cmd.DW8.EarlyIMESuccessfulStopThreshold = 0;
cmd.DW8.AdaptiveSearchEnable = (params->ucKernelMode != encodePerformanceMode) ? 1 : 0;
cmd.DW8.SkipModeEnable = 1;
cmd.DW8.BidirectionalMixDisbale = 0;
cmd.DW8.Transform8x8FlagForInterEnable = 0;
cmd.DW8.EarlyIMESuccessEnable = 0;
//DW9
cmd.DW9.RefPixelBiasEnable = 0;
cmd.DW9.UnidirectionMixEnable = 0;
cmd.DW9.BidirectionalWeight = 0;
cmd.DW9.RefIDPolarityBits = 0;
cmd.DW9.MaximumNumberOfMotionVectors = 0 /* 32 */; // from BDW
//DW10
cmd.DW10.MaxFixedSearchPathLength = (params->ucKernelMode == encodeNormalMode) ? 25 : ((params->ucKernelMode == encodePerformanceMode) ? 9 : 57);
cmd.DW10.MaximumSearchPathLength = 57;
//DW11
cmd.DW11.SubMacroBlockSubPartitionMask = 0 /* 0x30 */; //from BDW
cmd.DW11.IntraSADMeasureAdjustment = 2;
cmd.DW11.InterSADMeasureAdjustment = 2;
cmd.DW11.BlockBasedSkipEnable = 0;
cmd.DW11.BMEdisableforFBRMessage = 0 /* 1 */; // from BDW
cmd.DW11.ForwardTransformSkipCheckEnable = 0;
cmd.DW11.ProcessInterChromaPixelsMode = 0;
cmd.DW11.DisableFieldCacheAllocation = 0;
cmd.DW11.SkipModeType = 0;
cmd.DW11.SubPelMode = 3;
cmd.DW11.DualSearchPathOption = 0;
cmd.DW11.SearchControl = 0;
cmd.DW11.ReferenceAccess = 0;
cmd.DW11.SourceAccess = 0;
cmd.DW11.InterMbTypeRoadMap = 0;
cmd.DW11.SourceBlockSize = 0;
//DW12
cmd.DW12.ReferenceSearchWindowsHeight = (params->ucKernelMode != encodePerformanceMode) ? 40 : 28;
cmd.DW12.ReferenceSearchWindowsWidth = (params->ucKernelMode != encodePerformanceMode) ? 48 : 28;
//DW13
cmd.DW13.Value = VP8_COST_TABLE_G10[usQp_Seg0][0];
cmd.DW14.Value = VP8_COST_TABLE_G10[usQp_Seg0][1];
cmd.DW15.Value = VP8_COST_TABLE_G10[usQp_Seg0][2];
// which table to load is selected by MEMethod parameter determined by the driver based on the usage model (normal/quality/performance)
switch (MEMethod)
{
case 2:
CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(cmd.DW16), sizeof(VP8_SINGLESU), VP8_SINGLESU, sizeof(VP8_SINGLESU)));
break;
case 3:
CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(cmd.DW16), sizeof(VP8_RASTERSCAN_48x40), VP8_RASTERSCAN_48x40, sizeof(VP8_RASTERSCAN_48x40)));
break;
case 4:
case 5:
CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(cmd.DW16), sizeof(VP8_FULLSPIRAL_48x40), VP8_FULLSPIRAL_48x40, sizeof(VP8_FULLSPIRAL_48x40)));
break;
case 6:
default:
CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(cmd.DW16), sizeof(VP8_DIAMOND), VP8_DIAMOND, sizeof(VP8_DIAMOND)));
break;
}
//DW30
cmd.DW30.Value = VP8_COST_TABLE_G10[usQp_Seg0][3];
//DW31
cmd.DW31.Value = VP8_COST_TABLE_G10[usQp_Seg0][4];
//DW32
cmd.DW32.BilinearEnable = 0;
cmd.DW32.Intra16x16NoDCPenaltySegment0 = VP8_COST_TABLE_G10[usQp_Seg0][5];
cmd.DW32.Intra16x16NoDCPenaltySegment1 = VP8_COST_TABLE_G10[usQp_Seg1][5];
//DW33
cmd.DW33.Intra16x16NoDCPenaltySegment2 = VP8_COST_TABLE_G10[usQp_Seg2][5];
cmd.DW33.Intra16x16NoDCPenaltySegment3 = VP8_COST_TABLE_G10[usQp_Seg3][5];
cmd.DW33.HMECombineLen = 8;//based on target usage part of par file param
//DW34 to DW57
CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(cmd.DW34), 24 * sizeof(uint32_t), VP8_MvRefCostContext_G10, 24 * sizeof(uint32_t)));
//DW58
cmd.DW58.EncCost16x16 = 0;
cmd.DW58.EncCost16x8 = 0x73C;
//DW59
cmd.DW59.EncCost8x8 = 0x365;
cmd.DW59.EncCost4x4 = 0xDC9;
//DW60
cmd.DW60.FrameCountProbabilityRefFrameCost_0 = 516;
cmd.DW60.FrameCountProbabilityRefFrameCost_1 = 106;
//DW61
cmd.DW61.FrameCountProbabilityRefFrameCost_2 = 2407;
cmd.DW61.FrameCountProbabilityRefFrameCost_3 = 2409;
//DW62
switch (m_pFramePositionInGop)
{
case 1:
cmd.DW62.AverageQPOfLastRefFrame = VP8_QUANT_DC_G10[m_averageKeyFrameQp];
cmd.DW62.AverageQPOfGoldRefFrame = cmd.DW62.AverageQPOfLastRefFrame;
cmd.DW62.AverageQPOfAltRefFrame = cmd.DW62.AverageQPOfLastRefFrame;
break;
case 2:
cmd.DW62.AverageQPOfLastRefFrame = VP8_QUANT_DC_G10[m_averagePFrameQp];
cmd.DW62.AverageQPOfGoldRefFrame = VP8_QUANT_DC_G10[m_averageKeyFrameQp];
cmd.DW62.AverageQPOfAltRefFrame = cmd.DW62.AverageQPOfGoldRefFrame;
break;
case 3:
cmd.DW62.AverageQPOfLastRefFrame = VP8_QUANT_DC_G10[m_averagePFrameQp];
cmd.DW62.AverageQPOfGoldRefFrame = VP8_QUANT_DC_G10[m_averagePFrameQp];
cmd.DW62.AverageQPOfAltRefFrame = VP8_QUANT_DC_G10[m_averageKeyFrameQp];
break;
default:
cmd.DW62.AverageQPOfLastRefFrame = VP8_QUANT_DC_G10[m_averagePFrameQp];
cmd.DW62.AverageQPOfGoldRefFrame = cmd.DW62.AverageQPOfLastRefFrame;
cmd.DW62.AverageQPOfAltRefFrame = cmd.DW62.AverageQPOfLastRefFrame;
break;
}
//DW63
cmd.DW63.Intra4x4NoDCPenaltySegment0 = VP8_COST_TABLE_G10[usQp_Seg0][6];
cmd.DW63.Intra4x4NoDCPenaltySegment1 = VP8_COST_TABLE_G10[usQp_Seg1][6];
cmd.DW63.Intra4x4NoDCPenaltySegment2 = VP8_COST_TABLE_G10[usQp_Seg2][6];
cmd.DW63.Intra4x4NoDCPenaltySegment3 = VP8_COST_TABLE_G10[usQp_Seg3][6];
//DW64
cmd.DW64.Value = VP8_COST_TABLE_G10[usQp_Seg1][0];
//DW65
cmd.DW65.Value = VP8_COST_TABLE_G10[usQp_Seg1][1];
//DW66
cmd.DW66.Value = VP8_COST_TABLE_G10[usQp_Seg1][2];
//DW67
cmd.DW67.Value = VP8_COST_TABLE_G10[usQp_Seg1][3];
//DW68
cmd.DW68.Value = VP8_COST_TABLE_G10[usQp_Seg1][4];
//DW69
cmd.DW69.Value = VP8_COST_TABLE_G10[usQp_Seg2][0];
//DW70
cmd.DW70.Value = VP8_COST_TABLE_G10[usQp_Seg2][1];
//DW71
cmd.DW71.Value = VP8_COST_TABLE_G10[usQp_Seg2][2];
//DW72
cmd.DW72.Value = VP8_COST_TABLE_G10[usQp_Seg2][3];
//DW73
cmd.DW73.Value = VP8_COST_TABLE_G10[usQp_Seg2][4];
//DW74
cmd.DW74.Value = VP8_COST_TABLE_G10[usQp_Seg3][0];
//DW75
cmd.DW75.Value = VP8_COST_TABLE_G10[usQp_Seg3][1];
//DW76
cmd.DW76.Value = VP8_COST_TABLE_G10[usQp_Seg3][2];
//DW77
cmd.DW77.Value = VP8_COST_TABLE_G10[usQp_Seg3][3];
//DW78
cmd.DW78.Value = VP8_COST_TABLE_G10[usQp_Seg3][4];
//DW79
cmd.DW79.NewMVSkipThresholdSegment0 = VP8_NewMVSkipThreshold_G10[usQp_Seg0];
cmd.DW79.NewMVSkipThresholdSegment1 = VP8_NewMVSkipThreshold_G10[usQp_Seg1];
//DW80
cmd.DW80.NewMVSkipThresholdSegment2 = VP8_NewMVSkipThreshold_G10[usQp_Seg2];
cmd.DW80.NewMVSkipThresholdSegment3 = VP8_NewMVSkipThreshold_G10[usQp_Seg3];
//setup binding table index entries
cmd.DW81.PerMbOutputDataSurfaceBTI = CODECHAL_VP8_MBENC_PER_MB_OUT_G10;
cmd.DW82.CurrentPictureYSurfaceBTI = CODECHAL_VP8_MBENC_CURR_Y_G10;
cmd.DW83.CurrentPictureInterleavedUVSurfaceBTI = CODECHAL_VP8_MBENC_CURR_Y_G10;
cmd.DW84.HMEMVDataSurfaceBTI = CODECHAL_VP8_MBENC_MV_DATA_FROM_ME_G10;
cmd.DW85.MVDataSurfaceBTI = CODECHAL_VP8_MBENC_IND_MV_DATA_G10;
cmd.DW86.MbCountPerReferenceFrameBTI = CODECHAL_VP8_MBENC_REF_MB_COUNT_G10;
cmd.DW87.VMEInterPredictionBTI = CODECHAL_VP8_MBENC_INTER_PRED_G10;
cmd.DW88.ActiveRef1BTI = CODECHAL_VP8_MBENC_REF1_PIC_G10;
cmd.DW89.ActiveRef2BTI = CODECHAL_VP8_MBENC_REF2_PIC_G10;
cmd.DW90.ActiveRef3BTI = CODECHAL_VP8_MBENC_REF3_PIC_G10;
cmd.DW91.PerMbQuantDataBTI = CODECHAL_VP8_MBENC_P_PER_MB_QUANT_G10;
cmd.DW92.SegmentMapBTI = CODECHAL_VP8_MBENC_SEGMENTATION_MAP_G10;
cmd.DW93.InterPredictionDistortionBTI = CODECHAL_VP8_MBEBC_INTER_PRED_DISTORTION_G10;
cmd.DW94.HistogramBTI = CODECHAL_VP8_MBENC_HISTOGRAM_G10;
cmd.DW95.PredMVDataBTI = CODECHAL_VP8_MBEBC_PER_MV_DATA_G10;
cmd.DW96.ModeCostUpdateBTI = CODECHAL_VP8_MBENC_MODE_COST_UPDATE_G10;
cmd.DW97.KernelDebugDumpBTI = CODECHAL_VP8_MBENC_P_VME_DEBUG_STREAMOUT_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
&cmd,
params->pKernelState->dwCurbeOffset,
sizeof(cmd)));
}
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SetMeCurbe(struct CodechalVp8MeCurbeParams* params)
{
struct MediaObjectVp8MeStaticDataG10 cmd;
PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
CODECHAL_MEDIA_STATE_TYPE encMediaStateType;
uint8_t meMode, meMethod, tableIdx;
uint32_t scaleFactor;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
stateHeapInterface =
m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
seqParams = params->pSeqParams;
MOS_ZeroMemory(&cmd, sizeof(cmd));
meMode = params->b16xMeEnabled ? (params->b16xME ? CODECHAL_ENCODE_ME16X_BEFORE_ME4X : CODECHAL_ENCODE_ME4X_AFTER_ME16X) : CODECHAL_ENCODE_ME4X_ONLY;
scaleFactor = (meMode == CODECHAL_ENCODE_ME16X_BEFORE_ME4X) ? 16 : 4;
encMediaStateType = params->b16xME ? CODECHAL_MEDIA_STATE_16X_ME : CODECHAL_MEDIA_STATE_4X_ME;
CODECHAL_ENCODE_ASSERT(seqParams->TargetUsage < NUM_TARGET_USAGE_MODES);
cmd.DW1.MaxNumMVs = 0x10;
cmd.DW1.BiWeight = 0;
cmd.DW2.MaxNumSU = 57;
// For Enc_P kernel MaxLenSP is supposed to have the following values
// Normal mode = 25
// Perf mode = 9
// Quality mode = 57
// For ME kernel, MaxLenSP is supposed to have the value 57 for all modes
cmd.DW2.MaxLenSP = 57;
cmd.DW3.SubMbPartMask = 0x77;
cmd.DW3.InterSAD = 0;
cmd.DW3.IntraSAD = 0;
cmd.DW3.BMEDisableFBR = 1;
cmd.DW3.SubPelMode = 3;
cmd.DW4.PictureHeightMinus1 = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(params->dwFrameFieldHeight / scaleFactor) - 1;
cmd.DW4.PictureWidth = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(params->dwFrameWidth / scaleFactor);
cmd.DW4.PictureHeightMinus1 = cmd.DW4.PictureHeightMinus1 < 2 ? 2 : cmd.DW4.PictureHeightMinus1;
cmd.DW4.PictureWidth = cmd.DW4.PictureWidth < 3 ? 3 : cmd.DW4.PictureWidth;
cmd.DW5.RefHeight = 40;
cmd.DW5.RefWidth = 48;
cmd.DW6.MEModes = meMode;
cmd.DW6.SuperCombineDist = (params->ucKernelMode == encodeNormalMode) ? 5 : ((params->ucKernelMode == encodePerformanceMode) ? 0 : 1);
cmd.DW6.MaxVmvR = 0x7fc; /* For VP8, Luma MVs in the range -2046 to +2046 (1/8 pel) */
cmd.DW13.NumRefIdxL0MinusOne = VP8_NUM_REFS_G10[params->pPicParams->ref_frame_ctrl] - 1;
cmd.DW13.NumRefIdxL1MinusOne = 0;
tableIdx = 0; /* Only P pictures in VP8, no B pictures */
meMethod = (params->ucKernelMode == encodeNormalMode) ? 6 : 4;
status = MOS_SecureMemcpy((uint32_t*)(&cmd.SpDelta),
14 * sizeof(uint32_t),
m_encodeSearchPath[tableIdx][meMethod],
14 * sizeof(uint32_t));
if (status != MOS_STATUS_SUCCESS)
{
CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
return status;
}
cmd.DW32.VP8MeMVOutputDataBTI = CODECHAL_VP8_ME_MV_DATA_G10;
cmd.DW33.VP8MeMVInputDataBTI = CODECHAL_VP8_16xME_MV_DATA_G10;
cmd.DW34.VP8MeDistortionBTI = CODECHAL_VP8_ME_DISTORTION_G10;
cmd.DW35.VP8MeMinDistBrcBTI = CODECHAL_VP8_ME_MIN_DIST_BRC_DATA_G10;
cmd.DW36.ForwardRefBTI = CODECHAL_VP8_VME_INTER_PRED_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_meKernelState.m_dshRegion.AddData(
&cmd,
m_meKernelState.dwCurbeOffset,
sizeof(cmd)));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SetMpuCurbe(struct CodechalVp8MpuCurbeParams* params)
{
PCODEC_VP8_ENCODE_PIC_PARAMS picParams;
PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams;
PCODEC_VP8_ENCODE_QUANT_DATA vp8QuantData;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
struct MediaObjectVp8MpuFhbStaticDataG10 cmd;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPicParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pVp8QuantData);
stateHeapInterface =
m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
picParams = params->pPicParams;
seqParams = params->pSeqParams;
vp8QuantData = params->pVp8QuantData;
MOS_ZeroMemory(&cmd, sizeof(cmd));
cmd.DW0.FrameWidth = (seqParams->FrameWidth + 15) & (~0xF); /* Kernel require MB boundary aligned dimensions */
cmd.DW0.FrameHeight = (seqParams->FrameHeight + 15) & (~0xF);
cmd.DW1.FrameType = picParams->frame_type;
cmd.DW1.Version = picParams->version;
cmd.DW1.ShowFrame = picParams->show_frame;
cmd.DW1.HorizontalScaleCode = seqParams->FrameWidthScale;
cmd.DW1.VerticalScaleCode = seqParams->FrameHeightScale;
cmd.DW1.ColorSpaceType = picParams->color_space;
cmd.DW1.ClampType = picParams->clamping_type;
cmd.DW1.PartitionNumL2 = picParams->CodedCoeffTokenPartition;
cmd.DW1.EnableSegmentation = picParams->segmentation_enabled;
cmd.DW1.SegMapUpdate =
(picParams->segmentation_enabled) ? picParams->update_mb_segmentation_map : 0;
cmd.DW1.SegmentationFeatureUpdate = picParams->update_segment_feature_data; // setup whenever segmentation is 1
cmd.DW1.SegmentationFeatureMode = 1; // delta mode
cmd.DW1.LoopFilterType = picParams->filter_type;
cmd.DW1.SharpnessLevel = picParams->sharpness_level;
cmd.DW1.LoopFilterAdjustmentOn = picParams->loop_filter_adj_enable;
cmd.DW1.MBNoCoeffiscientSkip = picParams->mb_no_coeff_skip;
// DDI spec is not mapping to codechal directly. It should be mapping as below
if (picParams->refresh_golden_frame == 1)
{
cmd.DW1.GoldenReferenceCopyFlag = 3;
}
else {
cmd.DW1.GoldenReferenceCopyFlag = picParams->copy_buffer_to_golden;
}
if (picParams->refresh_alternate_frame == 1)
{
cmd.DW1.AlternateReferenceCopyFlag = 3;
}
else {
cmd.DW1.AlternateReferenceCopyFlag = picParams->copy_buffer_to_alternate;
}
cmd.DW1.LastFrameUpdate = picParams->refresh_last;
cmd.DW1.SignBiasGolden = picParams->sign_bias_golden;
cmd.DW1.SignBiasAltRef = picParams->sign_bias_alternate;
cmd.DW1.RefreshEntropyP = picParams->refresh_entropy_probs;
cmd.DW2.LoopFilterLevel = picParams->version > 1 ? 0 : picParams->loop_filter_level[0];
cmd.DW2.Qindex = vp8QuantData->QIndex[0];
cmd.DW2.Y1DCQindex = vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
cmd.DW2.Y2DCQindex = vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_DC];
cmd.DW3.Y2ACQindex = vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_AC];
cmd.DW3.UVDCQindex = vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
cmd.DW3.UVACQindex = vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
cmd.DW3.FeatureData0Segment0 = vp8QuantData->QIndex[0];
cmd.DW4.FeatureData0Segment1 = vp8QuantData->QIndex[1];
cmd.DW4.FeatureData0Segment2 = vp8QuantData->QIndex[2];
cmd.DW4.FeatureData0Segment3 = vp8QuantData->QIndex[3];
cmd.DW4.FeatureData1Segment0 = picParams->loop_filter_level[0];
cmd.DW5.FeatureData1Segment1 = picParams->loop_filter_level[1];
cmd.DW5.FeatureData1Segment2 = picParams->loop_filter_level[2];
cmd.DW5.FeatureData1Segment3 = picParams->loop_filter_level[3];
cmd.DW5.RefLFDelta0 = picParams->ref_lf_delta[0];
cmd.DW6.RefLFDelta1 = picParams->ref_lf_delta[1];
cmd.DW6.RefLFDelta2 = picParams->ref_lf_delta[2];
cmd.DW6.RefLFDelta3 = picParams->ref_lf_delta[3];
cmd.DW6.ModeLFDelta0 = picParams->mode_lf_delta[0];
cmd.DW7.ModeLFDelta1 = picParams->mode_lf_delta[1];
cmd.DW7.ModeLFDelta2 = picParams->mode_lf_delta[2];
cmd.DW7.ModeLFDelta3 = picParams->mode_lf_delta[3];
cmd.DW7.MCFilterSelect = picParams->version > 0 ? 1 : 0;
cmd.DW7.ChromaFullPixelMCFilterMode = picParams->version < 3 ? 0 : 1;
cmd.DW7.MaxNumPakPasses = m_hwInterface->GetMfxInterface()->GetBrcNumPakPasses(); // Multi-Pass BRC
cmd.DW7.ForcedTokenSurfaceRead = 1;
cmd.DW7.ModecostEnableFlag = 1;
cmd.DW8.NumTLevels = seqParams->NumTemporalLayersMinus1 + 1;
cmd.DW8.TemporalLayerID = picParams->temporal_id;
cmd.DW12.HistogramBTI = CODECHAL_VP8_MPU_FHB_HISTOGRAM_G10;
cmd.DW13.ReferenceModeProbabilityBTI = CODECHAL_VP8_MPU_FHB_REF_MODE_PROBABILITY_G10;
cmd.DW14.ModeProbabilityBTI = CODECHAL_VP8_MPU_FHB_CURR_MODE_PROBABILITY_G10;
cmd.DW15.ReferenceTokenProbabilityBTI = CODECHAL_VP8_MPU_FHB_REF_TOKEN_PROBABILITY_G10;
cmd.DW16.TokenProbabilityBTI = CODECHAL_VP8_MPU_FHB_CURR_TOKEN_PROBABILITY_G10;
cmd.DW17.FrameHeaderBitstreamBTI = CODECHAL_VP8_MPU_FHB_HEADER_BITSTREAM_G10;
cmd.DW18.HeaderMetaDataBTI = CODECHAL_VP8_MPU_FHB_HEADER_METADATA_G10;
cmd.DW19.PictureStateBTI = CODECHAL_VP8_MPU_FHB_PICTURE_STATE_G10;
cmd.DW20.MPUBitStreamBTI = CODECHAL_VP8_MPU_FHB_MPU_BITSTREAM_G10;
cmd.DW21.TokenBitsDataBTI = CODECHAL_VP8_MPU_FHB_TOKEN_BITS_DATA_TABLE_G10;
cmd.DW22.KernelDebugDumpBTI = CODECHAL_VP8_MPU_FHB_VME_DEBUG_STREAMOUT_G10;
cmd.DW23.EntropyCostBTI = CODECHAL_VP8_MPU_FHB_ENTROPY_COST_TABLE_G10;
cmd.DW24.ModeCostUpdateBTI = CODECHAL_VP8_MPU_MODE_COST_UPDATE_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mpuKernelState.m_dshRegion.AddData(
&cmd,
m_mpuKernelState.dwCurbeOffset,
sizeof(cmd)));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SendMpuSurfaces(
PMOS_COMMAND_BUFFER cmdBuffer,
struct CodechalVp8MpuSurfaceParams* params)
{
uint32_t size;
PMHW_KERNEL_STATE kernelState;
CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
struct CodechalBindingTableVp8Mpu* vp8MpuBindingTable;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
kernelState = params->pKernelState;
vp8MpuBindingTable = &m_mpuBindingTable;
// Histogram
size = params->dwHistogramSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
surfaceCodecParams.presBuffer = params->presHistogram;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuHistogram;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Reference mode probability
size = params->dwModeProbabilitySize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
surfaceCodecParams.presBuffer = params->presRefModeProbability;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuReferenceModeProbability;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Mode probability
size = params->dwModeProbabilitySize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presModeProbability;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuModeProbability;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Reference Token probability
size = params->dwTokenProbabilitySize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presRefTokenProbability;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuReferenceTokenProbability;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Token probability
size = params->dwTokenProbabilitySize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presTokenProbability;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuTokenProbability;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Frame header
size = params->dwFrameHeaderSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presFrameHeader;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuFrameHeaderBitstream;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Header Metadata
size = params->dwHeaderMetadataSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
surfaceCodecParams.dwOffset = params->dwHeaderMetaDataOffset;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presHeaderMetadata;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuHeaderMetaData;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Picture state
size = mhw_vdbox_mfx_g10_X::MFX_VP8_PIC_STATE_CMD::byteSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
surfaceCodecParams.presBuffer = params->presPictureState;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuPictureState;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Mpu Bitstream
size = params->dwMpuBitstreamSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presMpuBitstream;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuMpuBitstream;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Token bits Data Surface
size = params->dwTokenBitsDataSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
surfaceCodecParams.presBuffer = params->presTokenBitsData;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuTokenBitsData;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Entropy cost table
size = params->dwEntropyCostTableSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
//surfaceCodecParams.bMediaBlockRW = true;
surfaceCodecParams.presBuffer = params->presEntropyCostTable;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuEntropyCost;
surfaceCodecParams.bRenderTarget = true;
surfaceCodecParams.bRawSurface = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
//Mode Cost Update Surface
size = sizeof(uint32_t)* 16;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.dwSize = size;
surfaceCodecParams.presBuffer = params->presModeCostUpdateBuffer;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuModeCostUpdateSurface;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
// Kernel Debug Dump surface
if (params->bVMEKernelDump)
{
size = params->dwKernelDumpSize;
MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
surfaceCodecParams.presBuffer = params->presVmeKernelDumpBuffer;
surfaceCodecParams.dwSize = size;
surfaceCodecParams.dwBindingTableOffset = vp8MpuBindingTable->dwVp8MpuKernelDebugDump;
surfaceCodecParams.bRenderTarget = true;
CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
m_hwInterface,
cmdBuffer,
&surfaceCodecParams,
kernelState));
}
return status;
}
MOS_STATUS CodechalEncodeVp8G10::SetTpuCurbe(struct CodechalVp8TpuCurbeParams* params)
{
PCODEC_VP8_ENCODE_PIC_PARAMS picParams;
PCODEC_VP8_ENCODE_SEQUENCE_PARAMS seqParams;
PCODEC_VP8_ENCODE_QUANT_DATA vp8QuantData;
PMHW_STATE_HEAP_INTERFACE stateHeapInterface;
struct MediaObjectVp8TpuFhbStaticDataG10 cmd;
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface());
CODECHAL_ENCODE_CHK_NULL_RETURN(params);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPicParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
CODECHAL_ENCODE_CHK_NULL_RETURN(params->pVp8QuantData);
stateHeapInterface =
m_hwInterface->GetRenderInterface()->m_stateHeapInterface;
CODECHAL_ENCODE_CHK_NULL_RETURN(stateHeapInterface);
picParams = params->pPicParams;
seqParams = params->pSeqParams;
vp8QuantData = params->pVp8QuantData;
MOS_ZeroMemory(&cmd, sizeof(cmd));
cmd.DW0.MBsInFrame = (uint32_t)params->wPicWidthInMb * (uint32_t)params->wFieldFrameHeightInMb;
cmd.DW1.FrameType = picParams->frame_type;
cmd.DW1.EnableSegmentation = picParams->segmentation_enabled;
cmd.DW1.RebinarizationFrameHdr = (params->bRebinarizationFrameHdr ? 1 : 0);
cmd.DW1.RefreshEntropyP = picParams->refresh_entropy_probs;
cmd.DW1.MBNoCoeffiscientSkip = picParams->mb_no_coeff_skip;
cmd.DW3.MaxQP = picParams->ClampQindexHigh;
cmd.DW3.MinQP = picParams->ClampQindexLow;
cmd.DW4.LoopFilterLevelSegment0 = picParams->loop_filter_level[0];
cmd.DW4.LoopFilterLevelSegment1 = picParams->loop_filter_level[1];
cmd.DW4.LoopFilterLevelSegment2 = picParams->loop_filter_level[2];
cmd.DW4.LoopFilterLevelSegment3 = picParams->loop_filter_level[3];
cmd.DW5.QuantizationIndexSegment0 = vp8QuantData->QIndex[0];
cmd.DW5.QuantizationIndexSegment1 = vp8QuantData->QIndex[1];
cmd.DW5.QuantizationIndexSegment2 = vp8QuantData->QIndex[2];
cmd.DW5.QuantizationIndexSegment3 = vp8QuantData->QIndex[3];
// This setup is only used for CQP = 1 << 8 (15:8 bits)
// For BRC, this will be overwritten after Pak execution
cmd.DW6.PakPassNum = m_hwInterface->GetMfxInterface()->GetBrcNumPakPasses() << 8;
if (params->bAdaptiveRePak)
{
cmd.DW7.SkipCostDeltaThreshold = 100;
cmd.DW7.TokenCostDeltaThreshold = 50;
}
else
{
cmd.DW7.SkipCostDeltaThreshold = 0; // change to 1 when temporal scalability is enabled
cmd.DW7.TokenCostDeltaThreshold = 0; // change to 1 when temporal scalability is enabled
}
cmd.DW12.PakTokenStatisticsBTI = CODECHAL_VP8_TPU_FHB_PAK_TOKEN_STATISTICS_G10;
cmd.DW13.TokenUpdateFlagsBTI = CODECHAL_VP8_TPU_FHB_TOKEN_UPDATE_FLAGS_G10;
cmd.DW14.EntropyCostTableBTI = CODECHAL_VP8_TPU_FHB_ENTROPY_COST_TABLE_G10;
cmd.DW15.FrameHeaderBitstreamBTI = CODECHAL_VP8_TPU_FHB_HEADER_BITSTREAM_G10;
cmd.DW16.DefaultTokenProbabilityBTI = CODECHAL_VP8_TPU_FHB_DEFAULT_TOKEN_PROBABILITY_G10;
cmd.DW17.PictureStateBTI = CODECHAL_VP8_TPU_FHB_PICTURE_STATE_G10;
cmd.DW18.MpuCurbeDataBTI = CODECHAL_VP8_TPU_FHB_MPU_CURBE_DATA_G10;
cmd.DW19.HeaderMetaDataBTI = CODECHAL_VP8_TPU_FHB_HEADER_METADATA_G10;
cmd.DW20.TokenProbabilityBTI = CODECHAL_VP8_TPU_FHB_TOKEN_PROBABILITY_G10;
cmd.DW21.PakHardwareTokenProbabilityPass1BTI = CODECHAL_VP8_TPU_FHB_PAK_HW_PASS1_PROBABILITY_G10;
cmd.DW22.KeyFrameTokenProbabilityBTI = CODECHAL_VP8_TPU_FHB_KEY_TOKEN_PROBABILITY_G10;
cmd.DW23.UpdatedTokenProbabilityBTI = CODECHAL_VP8_TPU_FHB_UPDATED_TOKEN_PROBABILITY_G10;
cmd.DW24.PakHardwareTokenProbabilityPass2BTI = CODECHAL_VP8_TPU_FHB_PAK_HW_PASS2_PROBABILITY_G10;
cmd.DW25.KernelDebugDumpBTI = CODECHAL_VP8_TPU_FHB_VME_DEBUG_STREAMOUT_G10;
cmd.DW26.RepakDecisionSurfaceBTI = CODECHAL_VP8_TPU_FHB_REPAK_DECISION_G10;
CODECHAL_ENCODE_CHK_STATUS_RETURN(m_tpuKernelState.m_dshRegion.AddData(
&cmd,
m_tpuKernelState.dwCurbeOffset,
sizeof(cmd)));
return status;
}
MOS_STATUS CodechalEncodeVp8G10::CalMaxLevelRatioForTL(
uint16_t *framesPer100Sec,
uint32_t *targetBitRate,
uint32_t numTemporalLayersMinus1,
uint32_t *tempBitRate)
{
MOS_STATUS status = MOS_STATUS_SUCCESS;
CODECHAL_ENCODE_FUNCTION_ENTER;
uint32_t ti, tj;
uint32_t numLevel[NAX_NUM_TEMPORAL_LAYERS];
uint32_t atempRatios[NAX_NUM_TEMPORAL_LAYERS];
int acculateTempBitRate;
for( ti= 0;ti < numTemporalLayersMinus1+1;ti++)
{
atempRatios[ti]= (uint32_t)framesPer100Sec[numTemporalLayersMinus1]/(uint32_t)framesPer100Sec[ti]; // it should be integer
}
for( ti=0; ti < numTemporalLayersMinus1+1; ti++){
numLevel[ti]= 0;
for( tj=0; tj < atempRatios[0]; tj++)
{
if(tj%atempRatios[ti]==0)
numLevel[ti] += 1; // ratio of framerate
}
}
tempBitRate[0]= targetBitRate[0]*64/targetBitRate[numTemporalLayersMinus1];
acculateTempBitRate= tempBitRate[0];
for (ti=1; ti < (uint32_t)numTemporalLayersMinus1; ti++)
{
tempBitRate[ti]= (targetBitRate[ti] - targetBitRate[ti-1])*64/targetBitRate[numTemporalLayersMinus1];
acculateTempBitRate += tempBitRate[ti];
}
tempBitRate[numTemporalLayersMinus1]= 64-acculateTempBitRate; // The sum of tempBitRate must be 64 because this will affect the QP directly
for( ti=0; ti<numTemporalLayersMinus1+1; ti++)
{
int tem_level;
if(ti==0)
tem_level = numLevel[0];
else
tem_level = numLevel[ti] - numLevel[ti - 1];
tempBitRate[ti] = atempRatios[0] * tempBitRate[ti]/tem_level;
}
return status;
}