| 1 |
/* |
| 2 |
* Copyright (c) 2020-2023, Intel Corporation |
| 3 |
* |
| 4 |
* Permission is hereby granted, free of charge, to any person obtaining a |
| 5 |
* copy of this software and associated documentation files (the "Software"), |
| 6 |
* to deal in the Software without restriction, including without limitation |
| 7 |
* the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 8 |
* and/or sell copies of the Software, and to permit persons to whom the |
| 9 |
* Software is furnished to do so, subject to the following conditions: |
| 10 |
* |
| 11 |
* The above copyright notice and this permission notice shall be included |
| 12 |
* in all copies or substantial portions of the Software. |
| 13 |
* |
| 14 |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| 15 |
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 16 |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 17 |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR |
| 18 |
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| 19 |
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR |
| 20 |
* OTHER DEALINGS IN THE SOFTWARE. |
| 21 |
*/ |
| 22 |
//! |
| 23 |
//! \file encode_av1_brc.cpp |
| 24 |
//! \brief Defines the common interface for av1 brc features |
| 25 |
//! |
| 26 |
#include "encode_av1_basic_feature.h" |
| 27 |
#include "encode_av1_brc.h" |
| 28 |
#include "encode_av1_vdenc_feature_manager.h" |
| 29 |
#include "encode_av1_vdenc_const_settings.h" |
| 30 |
#include "encode_av1_brc_init_packet.h" |
| 31 |
#include "encode_av1_brc_update_packet.h" |
| 32 |
namespace encode |
| 33 |
{ |
| 34 |
Av1Brc::Av1Brc( |
| 35 |
MediaFeatureManager *featureManager, |
| 36 |
EncodeAllocator *allocator, |
| 37 |
CodechalHwInterfaceNext *hwInterface, |
| 38 |
void *constSettings) : |
| 39 |
MediaFeature(constSettings, hwInterface ? hwInterface->GetOsInterface() : nullptr), |
| 40 |
m_hwInterface(hwInterface), |
| 41 |
m_allocator(allocator) |
| 42 |
{ |
| 43 |
m_featureManager = featureManager; |
| 44 |
|
| 45 |
ENCODE_CHK_NULL_NO_STATUS_RETURN(featureManager); |
| 46 |
m_basicFeature = dynamic_cast<Av1BasicFeature*>(featureManager->GetFeature(Av1FeatureIDs::basicFeature)); |
| 47 |
ENCODE_CHK_NULL_NO_STATUS_RETURN(m_basicFeature); |
| 48 |
|
| 49 |
ENCODE_CHK_NULL_NO_STATUS_RETURN(hwInterface); |
| 50 |
} |
| 51 |
|
| 52 |
Av1Brc::~Av1Brc() |
| 53 |
{ |
| 54 |
FreeBrcResources(); |
| 55 |
} |
| 56 |
|
| 57 |
MOS_STATUS Av1Brc::Init(void *setting) |
| 58 |
{ |
| 59 |
ENCODE_FUNC_CALL(); |
| 60 |
|
| 61 |
ENCODE_CHK_STATUS_RETURN(AllocateResources()); |
| 62 |
|
| 63 |
return MOS_STATUS_SUCCESS; |
| 64 |
} |
| 65 |
|
| 66 |
MOS_STATUS Av1Brc::Update(void *params) |
| 67 |
{ |
| 68 |
ENCODE_FUNC_CALL(); |
| 69 |
ENCODE_CHK_NULL_RETURN(params); |
| 70 |
|
| 71 |
EncoderParams *encodeParams = (EncoderParams *)params; |
| 72 |
|
| 73 |
// If new seq, need to set sequence structs |
| 74 |
// If RATECONTROL_CQL, need to update quality and bitrate .etc |
| 75 |
if (encodeParams->bNewSeq || m_basicFeature->m_av1SeqParams->RateControlMethod == RATECONTROL_CQL) |
| 76 |
{ |
| 77 |
ENCODE_CHK_STATUS_RETURN(SetSequenceStructs()); |
| 78 |
} |
| 79 |
|
| 80 |
const auto& seqParams = *m_basicFeature->m_av1SeqParams; |
| 81 |
|
| 82 |
#if (_DEBUG || _RELEASE_INTERNAL) |
| 83 |
ReportUserSetting( |
| 84 |
m_userSettingPtr, |
| 85 |
"Encode RateControl Method", |
| 86 |
m_rcMode, |
| 87 |
MediaUserSetting::Group::Sequence); |
| 88 |
|
| 89 |
ENCODE_CHK_NULL_RETURN(m_basicFeature->m_av1PicParams); |
| 90 |
MediaUserSetting::Value outValue; |
| 91 |
ReadUserSetting( |
| 92 |
m_userSettingPtr, |
| 93 |
outValue, |
| 94 |
"Adaptive TU Enable", |
| 95 |
MediaUserSetting::Group::Sequence); |
| 96 |
m_basicFeature->m_av1PicParams->AdaptiveTUEnabled |= outValue.Get<uint8_t>(); |
| 97 |
#endif |
| 98 |
return MOS_STATUS_SUCCESS; |
| 99 |
} |
| 100 |
|
| 101 |
MOS_STATUS Av1Brc::AllocateResources() |
| 102 |
{ |
| 103 |
ENCODE_FUNC_CALL(); |
| 104 |
|
| 105 |
ENCODE_CHK_NULL_RETURN(m_allocator); |
| 106 |
ENCODE_CHK_NULL_RETURN(m_basicFeature); |
| 107 |
ENCODE_CHK_NULL_RETURN(m_basicFeature->m_recycleBuf); |
| 108 |
|
| 109 |
MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear; |
| 110 |
MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS)); |
| 111 |
allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER; |
| 112 |
allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR; |
| 113 |
allocParamsForBufferLinear.Format = Format_Buffer; |
| 114 |
|
| 115 |
// BRC history buffer |
| 116 |
allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_brcHistoryBufSize, CODECHAL_PAGE_SIZE); |
| 117 |
allocParamsForBufferLinear.pBufName = "VDENC BRC History Buffer"; |
| 118 |
allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE; |
| 119 |
m_basicFeature->m_recycleBuf->RegisterResource(VdencBRCHistoryBuffer, allocParamsForBufferLinear, 1); |
| 120 |
|
| 121 |
// VDENC BRC PAK MMIO buffer |
| 122 |
allocParamsForBufferLinear.dwBytes = sizeof(Av1BrcPakMmio); |
| 123 |
allocParamsForBufferLinear.pBufName = "VDENC BRC PAK MMIO Buffer"; |
| 124 |
allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE; |
| 125 |
m_basicFeature->m_recycleBuf->RegisterResource(VdencBrcPakMmioBuffer, allocParamsForBufferLinear, 1); |
| 126 |
|
| 127 |
// BRC HuC Data Buffer |
| 128 |
allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(BRC_DATA_SIZE, CODECHAL_PAGE_SIZE); |
| 129 |
allocParamsForBufferLinear.pBufName = "BRC HuC Data Buffer"; |
| 130 |
allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ; |
| 131 |
MOS_RESOURCE* brcDataBuffer = m_allocator->AllocateResource( |
| 132 |
allocParamsForBufferLinear, |
| 133 |
true); |
| 134 |
ENCODE_CHK_NULL_RETURN(brcDataBuffer); |
| 135 |
m_resBrcDataBuffer = *brcDataBuffer; |
| 136 |
|
| 137 |
for (auto j = 0; j < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; j++) |
| 138 |
{ |
| 139 |
// VDENC uses second level batch buffer |
| 140 |
MOS_ZeroMemory(&m_vdenc2ndLevelBatchBuffer[j], sizeof(MHW_BATCH_BUFFER)); |
| 141 |
m_vdenc2ndLevelBatchBuffer[j].bSecondLevel = true; |
| 142 |
ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb( |
| 143 |
m_hwInterface->GetOsInterface(), |
| 144 |
&m_vdenc2ndLevelBatchBuffer[j], |
| 145 |
nullptr, |
| 146 |
m_hwInterface->m_vdenc2ndLevelBatchBufferSize)); |
| 147 |
|
| 148 |
// VDENC uses second level batch buffer |
| 149 |
MOS_ZeroMemory(&m_pakInsertOutputBatchBuffer[j], sizeof(MHW_BATCH_BUFFER)); |
| 150 |
m_pakInsertOutputBatchBuffer[j].bSecondLevel = true; |
| 151 |
ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb( |
| 152 |
m_hwInterface->GetOsInterface(), |
| 153 |
&m_pakInsertOutputBatchBuffer[j], |
| 154 |
nullptr, |
| 155 |
CODECHAL_PAGE_SIZE)); |
| 156 |
} |
| 157 |
|
| 158 |
return MOS_STATUS_SUCCESS; |
| 159 |
} |
| 160 |
|
| 161 |
MOS_STATUS Av1Brc::GetBrcDataBuffer(MOS_RESOURCE *&buffer) |
| 162 |
{ |
| 163 |
ENCODE_FUNC_CALL(); |
| 164 |
buffer = &m_resBrcDataBuffer; |
| 165 |
return MOS_STATUS_SUCCESS; |
| 166 |
} |
| 167 |
|
| 168 |
inline uint8_t MapTCBRCScenarioInfo(ENCODE_SCENARIO& scenarioInfo) |
| 169 |
{ |
| 170 |
uint8_t TCBRCScenarioInfo = 0; |
| 171 |
switch (scenarioInfo) |
| 172 |
{ |
| 173 |
case ESCENARIO_REMOTEGAMING: |
| 174 |
TCBRCScenarioInfo = 0; |
| 175 |
break; |
| 176 |
case ESCENARIO_VIDEOCONFERENCE: |
| 177 |
TCBRCScenarioInfo = 1; |
| 178 |
break; |
| 179 |
default: |
| 180 |
ENCODE_ASSERTMESSAGE("TCBRC mode not supported!"); |
| 181 |
break; |
| 182 |
} |
| 183 |
return TCBRCScenarioInfo; |
| 184 |
} |
| 185 |
|
| 186 |
MOS_STATUS Av1Brc::SetDmemForUpdate(VdencAv1HucBrcUpdateDmem *dmem) const |
| 187 |
{ |
| 188 |
ENCODE_FUNC_CALL(); |
| 189 |
ENCODE_CHK_NULL_RETURN(dmem); |
| 190 |
|
| 191 |
ENCODE_CHK_NULL_RETURN(m_basicFeature); |
| 192 |
ENCODE_CHK_NULL_RETURN(m_basicFeature->m_av1SeqParams); |
| 193 |
auto seqParams = m_basicFeature->m_av1SeqParams; |
| 194 |
ENCODE_CHK_NULL_RETURN(m_basicFeature->m_av1PicParams); |
| 195 |
auto picParams = m_basicFeature->m_av1PicParams; |
| 196 |
auto setting = static_cast<Av1VdencFeatureSettings*>(m_constSettings); |
| 197 |
ENCODE_CHK_NULL_RETURN(setting); |
| 198 |
|
| 199 |
auto brcSettings = setting->brcSettings; |
| 200 |
|
| 201 |
// BRC update setting |
| 202 |
if (m_curTargetFullness > seqParams->VBVBufferSizeInBit && dmem->UPD_PAKPassNum == 0) |
| 203 |
{ |
| 204 |
dmem->UPD_OverflowFlag = 0x1; |
| 205 |
m_curTargetFullness -= seqParams->VBVBufferSizeInBit; |
| 206 |
} |
| 207 |
|
| 208 |
dmem->UPD_TARGET_BUF_FULLNESS = (uint32_t)m_curTargetFullness; |
| 209 |
dmem->UPD_CDF_BufferSize = MOS_ALIGN_CEIL(m_basicFeature->m_cdfMaxNumBytes, CODECHAL_CACHELINE_SIZE); |
| 210 |
dmem->UPD_FRAMENUM = m_basicFeature->m_frameNum; // frame number |
| 211 |
dmem->UPD_HRD_BUFF_FULLNESS = m_delay; |
| 212 |
dmem->UPD_HRD_BUFF_FULLNESS_LOWER = seqParams->LowerVBVBufferLevelThresholdInBit; |
| 213 |
dmem->UPD_HRD_BUFF_FULLNESS_UPPER = seqParams->UpperVBVBufferLevelThresholdInBit; |
| 214 |
|
| 215 |
auto CalculatedMaxFrame = m_basicFeature->m_frameHeight * m_basicFeature->m_frameWidth; |
| 216 |
dmem->UPD_UserMaxFrame = seqParams->UserMaxIFrameSize > 0 ? MOS_MIN(seqParams->UserMaxIFrameSize, CalculatedMaxFrame) : CalculatedMaxFrame; |
| 217 |
dmem->UPD_UserMaxFramePB = seqParams->UserMaxPBFrameSize > 0 ? MOS_MIN(seqParams->UserMaxPBFrameSize, CalculatedMaxFrame) : CalculatedMaxFrame; |
| 218 |
|
| 219 |
dmem->UPD_CurWidth = (uint16_t)m_basicFeature->m_oriFrameWidth; |
| 220 |
dmem->UPD_CurHeight = (uint16_t)m_basicFeature->m_oriFrameHeight; |
| 221 |
dmem->UPD_Asyn = 0; |
| 222 |
dmem->UPD_EnableAdaptiveRounding = m_basicFeature->m_roundingMethod; |
| 223 |
dmem->UPD_AdaptiveTUEnabled = picParams->AdaptiveTUEnabled; |
| 224 |
dmem->UPD_EnableDeltaQP = picParams->PicFlags.fields.EnableDeltaQP; |
| 225 |
|
| 226 |
if (seqParams->GopRefDist == 16 && m_rcMode == RATECONTROL_CQL) |
| 227 |
dmem->UPD_MaxBRCLevel = 4; |
| 228 |
else if (seqParams->GopRefDist == 8) |
| 229 |
dmem->UPD_MaxBRCLevel = 3; |
| 230 |
else if (seqParams->GopRefDist == 4) |
| 231 |
dmem->UPD_MaxBRCLevel = 2; |
| 232 |
else if (seqParams->GopRefDist == 2) |
| 233 |
dmem->UPD_MaxBRCLevel = 1; |
| 234 |
else |
| 235 |
dmem->UPD_MaxBRCLevel = 0; |
| 236 |
|
| 237 |
if (m_basicFeature->m_pictureCodingType == I_TYPE) |
| 238 |
{ |
| 239 |
dmem->UPD_CurrFrameType = AV1_BRC_FRAME_TYPE_I; |
| 240 |
} |
| 241 |
else if (seqParams->SeqFlags.fields.HierarchicalFlag) |
| 242 |
{ |
| 243 |
if (picParams->HierarchLevelPlus1 > 0) |
| 244 |
{ |
| 245 |
std::map<int, AV1_BRC_FRAME_TYPE> hierchLevelPlus1_to_brclevel{ |
| 246 |
{1, AV1_BRC_FRAME_TYPE_P_OR_LB}, |
| 247 |
{2, AV1_BRC_FRAME_TYPE_B}, |
| 248 |
{3, AV1_BRC_FRAME_TYPE_B1}, |
| 249 |
{4, AV1_BRC_FRAME_TYPE_B2}, |
| 250 |
{5, AV1_BRC_FRAME_TYPE_B3}}; |
| 251 |
dmem->UPD_CurrFrameType = hierchLevelPlus1_to_brclevel.count(picParams->HierarchLevelPlus1) ? hierchLevelPlus1_to_brclevel[picParams->HierarchLevelPlus1] : AV1_BRC_FRAME_TYPE_INVALID; |
| 252 |
//Invalid HierarchLevelPlus1 or LBD frames at level 3 eror check. |
| 253 |
if ((dmem->UPD_CurrFrameType == AV1_BRC_FRAME_TYPE_INVALID) || |
| 254 |
(m_basicFeature->m_ref.IsLowDelay() && dmem->UPD_CurrFrameType == AV1_BRC_FRAME_TYPE_B2) || |
| 255 |
(m_rcMode != RATECONTROL_CQL && dmem->UPD_CurrFrameType == AV1_BRC_FRAME_TYPE_B3)) |
| 256 |
{ |
| 257 |
ENCODE_VERBOSEMESSAGE("AV1_BRC_FRAME_TYPE_INVALID or LBD picture doesn't support Level 4, or AV1_BRC_FRAME_TYPE_B3 only supported in RATECONTROL_CQL mode\n"); |
| 258 |
dmem->UPD_CurrFrameType = AV1_BRC_FRAME_TYPE_B2; |
| 259 |
} |
| 260 |
} |
| 261 |
else |
| 262 |
{ |
| 263 |
dmem->UPD_CurrFrameType = AV1_BRC_FRAME_TYPE_P_OR_LB; //No Hierarchical info, treated as flat case |
| 264 |
} |
| 265 |
} |
| 266 |
else |
| 267 |
{ |
| 268 |
dmem->UPD_CurrFrameType = m_basicFeature->m_ref.IsLowDelay() ? AV1_BRC_FRAME_TYPE_P_OR_LB : AV1_BRC_FRAME_TYPE_B; |
| 269 |
} |
| 270 |
|
| 271 |
#define MEMCPY_CONST(D, S) MOS_SecureMemcpy(dmem->D, sizeof(dmem->D), brcSettings.S.data, brcSettings.S.size); |
| 272 |
MEMCPY_CONST(UPD_startGAdjFrame, startGlobalAdjustFrame); |
| 273 |
MEMCPY_CONST(UPD_QPThreshold, QPThresholds); |
| 274 |
MEMCPY_CONST(UPD_gRateRatioThreshold, globalRateRatioThreshold); |
| 275 |
MEMCPY_CONST(UPD_gRateRatioThresholdQP, globalRateRatioThresholdQP); |
| 276 |
MEMCPY_CONST(UPD_startGAdjMult, startGlobalAdjustMult); |
| 277 |
MEMCPY_CONST(UPD_startGAdjDiv, startGlobalAdjustDiv); |
| 278 |
MEMCPY_CONST(UPD_DistThreshldI, distortionThresh); |
| 279 |
MEMCPY_CONST(UPD_DistThreshldP, distortionThresh); |
| 280 |
MEMCPY_CONST(UPD_DistThreshldB, distortionThreshB); |
| 281 |
MEMCPY_CONST(UPD_MaxFrameThreshI, maxFrameMultI); |
| 282 |
MEMCPY_CONST(UPD_MaxFrameThreshP, maxFrameMultP); |
| 283 |
MEMCPY_CONST(UPD_MaxFrameThreshB, maxFrameMultP); |
| 284 |
#undef MEMCPY_CONST |
| 285 |
|
| 286 |
dmem->UPD_Temporal_Level = m_basicFeature->m_av1PicParams->temporal_id; |
| 287 |
dmem->UPD_Lowdelay = seqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW ? 1 : 0; |
| 288 |
// To handle ultra-low-delay situation inside driver |
| 289 |
dmem->UPD_Lowdelay = (dmem->UPD_Lowdelay || seqParams->InitVBVBufferFullnessInBit <= m_inputbitsperframe * 2) ? 1 : 0; |
| 290 |
|
| 291 |
dmem->UPD_TR_TargetSize = picParams->TargetFrameSize << 3; |
| 292 |
|
| 293 |
if (picParams->TargetFrameSize > 0) |
| 294 |
{ |
| 295 |
dmem->UPD_TCBRC_SCENARIO = MapTCBRCScenarioInfo(seqParams->ScenarioInfo); |
| 296 |
} |
| 297 |
|
| 298 |
dmem->UPD_LA_TargetFULNESS = 0; |
| 299 |
dmem->UPD_Delta = 0; |
| 300 |
dmem->UPD_LALength = 0; |
| 301 |
|
| 302 |
//SLBB related fields. |
| 303 |
dmem->UPD_SLBBSize = m_slbData.slbSize; |
| 304 |
dmem->UPD_AVPPiCStateCmdNum = m_slbData.avpPicStateCmdNum; |
| 305 |
dmem->UPD_AVPSegmentStateOffset = m_slbData.avpSegmentStateOffset; |
| 306 |
dmem->UPD_AVPInloopFilterStateOffset = m_slbData.avpInloopFilterStateOffset; |
| 307 |
dmem->UPD_VDEncCmd1Offset = m_slbData.vdencCmd1Offset; |
| 308 |
dmem->UPD_VDEncCmd2Offset = m_slbData.vdencCmd2Offset; |
| 309 |
dmem->UPD_AVPPicStateOffset = m_slbData.avpPicStateOffset; |
| 310 |
dmem->UPD_VDEncTileSliceStateOffset = m_slbData.vdencTileSliceStateOffset; |
| 311 |
dmem->UPD_TileNum = m_slbData.tileNum; |
| 312 |
|
| 313 |
// BA start |
| 314 |
dmem->UPD_LoopFilterParamsBitOffset = (uint16_t)m_basicFeature->m_av1PicParams->LoopFilterParamsBitOffset; |
| 315 |
dmem->UPD_QIndexBitOffset = (uint16_t)m_basicFeature->m_av1PicParams->QIndexBitOffset; |
| 316 |
dmem->UPD_SegmentationBitOffset = (uint16_t)m_basicFeature->m_av1PicParams->SegmentationBitOffset; // after SegOn flag bit. |
| 317 |
dmem->UPD_FrameHdrOBUSizeInBits = (uint16_t)m_basicFeature->m_av1PicParams->FrameHdrOBUSizeInBits; // excluding frame_header_obu's trailing_bits() and frame_obu's byte_alignment() |
| 318 |
dmem->UPD_FrameHdrOBUSizeInBytes = (uint16_t)((m_basicFeature->m_av1PicParams->FrameHdrOBUSizeInBits + 7) >> 3); |
| 319 |
dmem->UPD_FrameHdrOBUSizeByteOffset = (uint16_t)(m_basicFeature->m_av1PicParams->FrameHdrOBUSizeByteOffset - m_basicFeature->GetAppHdrSizeInBytes(true)); |
| 320 |
dmem->UPD_FrameType = 0; |
| 321 |
dmem->UPD_ErrorResilientMode = m_basicFeature->m_av1PicParams->PicFlags.fields.error_resilient_mode; |
| 322 |
dmem->UPD_IntraOnly = 0; |
| 323 |
dmem->UPD_PrimaryRefFrame = 0; |
| 324 |
dmem->UPD_SegOn = m_basicFeature->m_av1PicParams->stAV1Segments.SegmentFlags.fields.segmentation_enabled; |
| 325 |
dmem->UPD_SegMapUpdate = 0; |
| 326 |
dmem->UPD_SegTemporalUpdate = 0; |
| 327 |
dmem->UPD_SegUpdateData = 0; |
| 328 |
dmem->UPD_IsFrameOBU = m_basicFeature->m_av1PicParams->PicFlags.fields.EnableFrameOBU; |
| 329 |
dmem->UPD_EnableCDEFUpdate = m_basicFeature->m_av1SeqParams->CodingToolFlags.fields.enable_cdef; |
| 330 |
dmem->UPD_CDEFParamsBitOffset = (uint16_t)m_basicFeature->m_av1PicParams->CDEFParamsBitOffset; |
| 331 |
dmem->UPD_CDEFParamsSizeInBits = (uint16_t)m_basicFeature->m_av1PicParams->CDEFParamsSizeInBits; |
| 332 |
dmem->UPD_EnableLFUpdate = 1; |
| 333 |
dmem->UPD_DisableCdfUpdate = (m_basicFeature->m_av1PicParams->primary_ref_frame != av1PrimaryRefNone); |
| 334 |
dmem->UPD_EnableDMAForCdf = 1; |
| 335 |
dmem->UPD_AdditionalHrdSizeByteCount = 0 - m_basicFeature->m_av1PicParams->FrameSizeReducedInBytes; |
| 336 |
dmem->UPD_PaletteOn = m_basicFeature->m_av1PicParams->PicFlags.fields.PaletteModeEnable; |
| 337 |
|
| 338 |
if (dmem->UPD_PAKPassNum == 1) |
| 339 |
m_curTargetFullness += m_inputbitsperframe; |
| 340 |
|
| 341 |
if (picParams->PicFlags.fields.allow_intrabc && AV1_KEY_OR_INRA_FRAME(picParams->PicFlags.fields.frame_type)) |
| 342 |
{ |
| 343 |
dmem->UPD_EnableCDEFUpdate = 0; |
| 344 |
dmem->UPD_EnableLFUpdate = 0; |
| 345 |
} |
| 346 |
dmem->UPD_QMatrixEnabled = picParams->wQMatrixFlags.fields.using_qmatrix; |
| 347 |
dmem->UPD_LADsRatio = seqParams->SeqFlags.fields.LADsRatio; |
| 348 |
|
| 349 |
return MOS_STATUS_SUCCESS; |
| 350 |
} |
| 351 |
|
| 352 |
MOS_STATUS Av1Brc::SetConstForUpdate(VdencAv1HucBrcConstantData *params) const |
| 353 |
{ |
| 354 |
ENCODE_FUNC_CALL(); |
| 355 |
ENCODE_CHK_NULL_RETURN(params); |
| 356 |
auto constData = (VdencAv1HucBrcConstantData *)params; |
| 357 |
|
| 358 |
auto setting = static_cast<Av1VdencFeatureSettings *>(m_constSettings); |
| 359 |
ENCODE_CHK_NULL_RETURN(setting); |
| 360 |
|
| 361 |
auto brcSettings = setting->brcSettings; |
| 362 |
|
| 363 |
#define MEMCPY_CONST(D, S) MOS_SecureMemcpy(constData->D, sizeof(constData->D), brcSettings.S.data, brcSettings.S.size); |
| 364 |
MEMCPY_CONST(CONST_QPAdjTabI, av1DeltaQpI); |
| 365 |
MEMCPY_CONST(CONST_QPAdjTabP, av1DeltaQpP); |
| 366 |
MEMCPY_CONST(CONST_QPAdjTabB, av1DeltaQpP); |
| 367 |
MEMCPY_CONST(CONST_DistQPAdjTabI, av1DistortionsDeltaQpI); |
| 368 |
MEMCPY_CONST(CONST_DistQPAdjTabP, av1DistortionsDeltaQpP); |
| 369 |
MEMCPY_CONST(CONST_DistQPAdjTabB, av1DistortionsDeltaQpP); |
| 370 |
MEMCPY_CONST(CONST_LoopFilterLevelTabLuma, loopFilterLevelTabLuma); |
| 371 |
MEMCPY_CONST(CONST_LoopFilterLevelTabChroma, loopFilterLevelTabChroma); |
| 372 |
|
| 373 |
// ModeCosts depends on frame type |
| 374 |
if (m_basicFeature->m_pictureCodingType == I_TYPE) |
| 375 |
{ |
| 376 |
MEMCPY_CONST(CONST_ModeCosts, hucModeCostsIFrame); |
| 377 |
} |
| 378 |
else |
| 379 |
{ |
| 380 |
MEMCPY_CONST(CONST_ModeCosts, hucModeCostsPFrame); |
| 381 |
} |
| 382 |
#undef MEMCPY_CONST |
| 383 |
return MOS_STATUS_SUCCESS; |
| 384 |
} |
| 385 |
|
| 386 |
inline uint16_t SwitchFlag(uint8_t rc) |
| 387 |
{ |
| 388 |
uint16_t brcFlag = 0; |
| 389 |
switch (rc) |
| 390 |
{ |
| 391 |
case RATECONTROL_CBR: |
| 392 |
brcFlag = 0x10; // BRC flag 0: ACQP, 0x10: CBR, 0x20: VBR, 0x40: AVBR, 0x80: CQL |
| 393 |
break; |
| 394 |
case RATECONTROL_VBR: |
| 395 |
brcFlag = 0x20; |
| 396 |
break; |
| 397 |
case RATECONTROL_CQP: |
| 398 |
brcFlag = 0; |
| 399 |
break; |
| 400 |
case RATECONTROL_CQL: |
| 401 |
brcFlag = 0x80; |
| 402 |
break; |
| 403 |
default: |
| 404 |
ENCODE_ASSERTMESSAGE("BRC mode not supported!"); |
| 405 |
break; |
| 406 |
} |
| 407 |
return brcFlag; |
| 408 |
} |
| 409 |
|
| 410 |
static uint32_t CalculateNormalizedDenominator(FRAMERATE* frameRates, uint16_t numberOfLayers, uint32_t normalizedDenominator) |
| 411 |
{ |
| 412 |
ENCODE_FUNC_CALL(); |
| 413 |
|
| 414 |
// If pointer to the list of FrameRates is null, return the current Normalized Denominator. |
| 415 |
if (!frameRates) |
| 416 |
{ |
| 417 |
return normalizedDenominator; |
| 418 |
} |
| 419 |
|
| 420 |
if (numberOfLayers == 0) |
| 421 |
{ |
| 422 |
return normalizedDenominator; |
| 423 |
} |
| 424 |
|
| 425 |
normalizedDenominator = normalizedDenominator * frameRates[numberOfLayers - 1].Denominator / MosUtilities::MosGCD(normalizedDenominator, frameRates[numberOfLayers - 1].Denominator); |
| 426 |
|
| 427 |
return CalculateNormalizedDenominator(frameRates, numberOfLayers - 1, normalizedDenominator); |
| 428 |
} |
| 429 |
|
| 430 |
inline uint32_t GetProfileLevelMaxFrameSize(uint32_t width, uint32_t height, uint32_t userMaxFrameSize) |
| 431 |
{ |
| 432 |
ENCODE_FUNC_CALL(); |
| 433 |
uint32_t profileLevelMaxFrame = 0; |
| 434 |
|
| 435 |
// Might need calculate max frame size base on profile and level, confirm with arch. |
| 436 |
|
| 437 |
profileLevelMaxFrame = width * height; |
| 438 |
if (userMaxFrameSize > 0) |
| 439 |
{ |
| 440 |
profileLevelMaxFrame = (uint32_t)MOS_MIN(userMaxFrameSize, profileLevelMaxFrame); |
| 441 |
} |
| 442 |
|
| 443 |
return profileLevelMaxFrame; |
| 444 |
} |
| 445 |
|
| 446 |
inline int32_t ComputeVDEncInitQPI(uint32_t width, uint32_t height, FRAMERATE frameRate, uint32_t targetBitRate, uint16_t gopPicSize, bool is10Bit, uint8_t chromaFormat, uint16_t n_p) |
| 447 |
{ |
| 448 |
ENCODE_FUNC_CALL(); |
| 449 |
|
| 450 |
uint32_t frameSize = ((width * height * 3) >> 1); |
| 451 |
if (chromaFormat == AVP_CHROMA_FORMAT_YUV444) |
| 452 |
{ |
| 453 |
frameSize *= 2; |
| 454 |
} |
| 455 |
if (is10Bit) |
| 456 |
{ |
| 457 |
frameSize = (frameSize * 10) >> 3; |
| 458 |
} |
| 459 |
|
| 460 |
const float x0 = 0, y0 = 1.19f, x1 = 1.75f, y1 = 1.75f; |
| 461 |
|
| 462 |
int32_t qpP = (int32_t)(1. / 1.2 * pow(10.0, (log10(frameSize * 2. / 3. * ((float)frameRate.Numerator) / ((float)targetBitRate * BRC_KBPS * frameRate.Denominator)) - x0) * (y1 - y0) / (x1 - x0) + y0) + 0.5); |
| 463 |
qpP = (int32_t)((float)qpP * (5.0)); |
| 464 |
qpP -= 20; |
| 465 |
qpP = MOS_CLAMP_MIN_MAX(qpP, 1, 200); |
| 466 |
|
| 467 |
int32_t qpI = (qpP > 4) ? (qpP - 4) : qpP; |
| 468 |
int16_t qiboost = n_p / 30 - 1; |
| 469 |
qiboost = MOS_CLAMP_MIN_MAX(qiboost, 10, 20); |
| 470 |
|
| 471 |
qpI -= qiboost; |
| 472 |
qpI = MOS_CLAMP_MIN_MAX(qpI, 1, 200); |
| 473 |
|
| 474 |
return qpI; |
| 475 |
} |
| 476 |
|
| 477 |
static std::tuple<uint32_t, uint32_t> GetFrameRate(CODEC_AV1_ENCODE_SEQUENCE_PARAMS const &seqParams) |
| 478 |
{ |
| 479 |
if ((seqParams.FrameRate->Numerator != 0) && (seqParams.FrameRate->Denominator != 0)) |
| 480 |
{ |
| 481 |
return std::make_tuple(seqParams.FrameRate->Numerator, seqParams.FrameRate->Denominator); |
| 482 |
} |
| 483 |
else |
| 484 |
{ |
| 485 |
return std::make_tuple(30, 1); |
| 486 |
} |
| 487 |
} |
| 488 |
|
| 489 |
MOS_STATUS Av1Brc::SetDmemForInit(VdencAv1HucBrcInitDmem *dmem) const |
| 490 |
{ |
| 491 |
ENCODE_FUNC_CALL(); |
| 492 |
ENCODE_CHK_NULL_RETURN(dmem); |
| 493 |
ENCODE_CHK_NULL_RETURN(m_basicFeature); |
| 494 |
|
| 495 |
auto setting = static_cast<Av1VdencFeatureSettings*>(m_constSettings); |
| 496 |
ENCODE_CHK_NULL_RETURN(setting); |
| 497 |
|
| 498 |
auto brcSettings = setting->brcSettings; |
| 499 |
|
| 500 |
auto seqParams = m_basicFeature->m_av1SeqParams; |
| 501 |
ENCODE_CHK_NULL_RETURN(seqParams); |
| 502 |
|
| 503 |
dmem->BRCFunc = IsBRCResetRequired() ? 2 : 0; |
| 504 |
dmem->INIT_ProfileLevelMaxFrame = GetProfileLevelMaxFrameSize(m_basicFeature->m_frameWidth, m_basicFeature->m_frameHeight, seqParams->UserMaxIFrameSize); |
| 505 |
dmem->INIT_TargetBitrate = seqParams->TargetBitRate[seqParams->NumTemporalLayersMinus1] * BRC_KBPS; |
| 506 |
dmem->INIT_MaxRate = seqParams->MaxBitRate * BRC_KBPS; |
| 507 |
dmem->INIT_MinRate = seqParams->MinBitRate * BRC_KBPS; |
| 508 |
|
| 509 |
std::tie(dmem->INIT_FrameRateM, dmem->INIT_FrameRateD) = GetFrameRate(*seqParams); |
| 510 |
|
| 511 |
dmem->INIT_InitBufFullness = MOS_MIN(seqParams->InitVBVBufferFullnessInBit, seqParams->VBVBufferSizeInBit); |
| 512 |
dmem->INIT_BufSize = m_vbvSize; |
| 513 |
dmem->INIT_BRCFlag = SwitchFlag(seqParams->RateControlMethod); |
| 514 |
m_curTargetFullness = seqParams->InitVBVBufferFullnessInBit; |
| 515 |
|
| 516 |
auto BGOPSize = seqParams->GopRefDist; |
| 517 |
int32_t intraPeriod = seqParams->GopPicSize - 1; |
| 518 |
|
| 519 |
if (BGOPSize > 1) |
| 520 |
{ |
| 521 |
if (intraPeriod > 0) |
| 522 |
{ |
| 523 |
intraPeriod = ((intraPeriod + (BGOPSize - 1)) / BGOPSize) * BGOPSize; |
| 524 |
} |
| 525 |
if (intraPeriod != -1) |
| 526 |
{ |
| 527 |
dmem->INIT_GopP = intraPeriod / BGOPSize; |
| 528 |
dmem->INIT_GopB = intraPeriod / BGOPSize; |
| 529 |
dmem->INIT_GopB1 = (dmem->INIT_GopP + dmem->INIT_GopB == intraPeriod)? 0 : dmem->INIT_GopP * 2; |
| 530 |
dmem->INIT_GopB2 = intraPeriod - dmem->INIT_GopP - dmem->INIT_GopB - dmem->INIT_GopB1; |
| 531 |
if (m_rcMode == RATECONTROL_CQL && seqParams->GopRefDist == 16) |
| 532 |
{ |
| 533 |
dmem->INIT_GopB2 = (dmem->INIT_GopP + dmem->INIT_GopB + dmem->INIT_GopB1 == intraPeriod) ? 0 : dmem->INIT_GopB1 * 2; |
| 534 |
dmem->INIT_GopB3 = intraPeriod - dmem->INIT_GopP - dmem->INIT_GopB - dmem->INIT_GopB1 - dmem->INIT_GopB2; |
| 535 |
} |
| 536 |
} |
| 537 |
else |
| 538 |
{ |
| 539 |
dmem->INIT_GopP = 9999; |
| 540 |
dmem->INIT_GopB = 9999; |
| 541 |
} |
| 542 |
} |
| 543 |
else |
| 544 |
{ |
| 545 |
dmem->INIT_GopP = seqParams->GopPicSize - 1; |
| 546 |
dmem->INIT_GopB = 0; |
| 547 |
} |
| 548 |
|
| 549 |
dmem->INIT_FrameWidth = (uint16_t)m_basicFeature->m_oriFrameWidth; |
| 550 |
dmem->INIT_FrameHeight = (uint16_t)m_basicFeature->m_oriFrameHeight; |
| 551 |
dmem->INIT_MinQP = m_basicFeature->m_av1PicParams->MinBaseQIndex; |
| 552 |
dmem->INIT_MaxQP = m_basicFeature->m_av1PicParams->MaxBaseQIndex == 0 ? 255 : m_basicFeature->m_av1PicParams->MaxBaseQIndex; |
| 553 |
dmem->INIT_LevelQP = seqParams->ICQQualityFactor; |
| 554 |
dmem->INIT_GoldenFrameInterval = 14; |
| 555 |
dmem->INIT_EnableScaling = false; |
| 556 |
dmem->INIT_OvershootCBR_pct = 0; //sliding window related. |
| 557 |
|
| 558 |
#define MEMCPY_CONST(D, S) MOS_SecureMemcpy(dmem->D, sizeof(dmem->D), brcSettings.S.data, brcSettings.S.size); |
| 559 |
MEMCPY_CONST(INIT_InstRateThreshI0, instRateThresholdI); |
| 560 |
MEMCPY_CONST(INIT_InstRateThreshP0, instRateThresholdP); |
| 561 |
#undef MEMCPY_CONST |
| 562 |
|
| 563 |
if (dmem->INIT_FrameRateM == 0) |
| 564 |
{ |
| 565 |
return MOS_STATUS_INVALID_PARAMETER; |
| 566 |
} |
| 567 |
double inputBitsPerFrame = ((double)dmem->INIT_MaxRate * (double)dmem->INIT_FrameRateD) / (double)dmem->INIT_FrameRateM; |
| 568 |
double bpsRatio = inputBitsPerFrame / ((double)dmem->INIT_BufSize / brcSettings.devStdFPS); |
| 569 |
bpsRatio = MOS_CLAMP_MIN_MAX(bpsRatio, brcSettings.bpsRatioLow, brcSettings.bpsRatioHigh); |
| 570 |
for (uint32_t i = 0; i < brcSettings.numDevThreshlds / 2; i++) |
| 571 |
{ |
| 572 |
dmem->INIT_DevThreshPB0[i] = (int8_t)(brcSettings.negMultPB * pow(((double *)(brcSettings.devThresholdFpNegPB.data))[i], bpsRatio)); |
| 573 |
dmem->INIT_DevThreshPB0[i + brcSettings.numDevThreshlds / 2] = (int8_t)(brcSettings.postMultPB * pow(((double *)(brcSettings.devThresholdFpPosPB.data))[i], bpsRatio)); |
| 574 |
|
| 575 |
dmem->INIT_DevThreshI0[i] = (int8_t)(brcSettings.negMultPB * pow(((double *)(brcSettings.devThresholdFpNegI.data))[i], bpsRatio)); |
| 576 |
dmem->INIT_DevThreshI0[i + brcSettings.numDevThreshlds / 2] = (int8_t)(brcSettings.postMultPB * pow(((double *)(brcSettings.devThresholdFpPosI.data))[i], bpsRatio)); |
| 577 |
|
| 578 |
dmem->INIT_DevThreshVBR0[i] = (int8_t)(brcSettings.negMultVBR * pow(((double *)(brcSettings.devThresholdVbrNeg.data))[i], bpsRatio)); |
| 579 |
dmem->INIT_DevThreshVBR0[i + brcSettings.numDevThreshlds / 2] = (int8_t)(brcSettings.posMultVBR * pow(((double *)(brcSettings.devThresholdVbrPos.data))[i], bpsRatio)); |
| 580 |
} |
| 581 |
|
| 582 |
int32_t qpI = 0, qpP = 0; |
| 583 |
qpI = ComputeVDEncInitQPI( |
| 584 |
m_basicFeature->m_oriFrameWidth, |
| 585 |
m_basicFeature->m_oriFrameHeight, |
| 586 |
m_basicFeature->m_av1SeqParams->FrameRate[0], |
| 587 |
m_basicFeature->m_av1SeqParams->TargetBitRate[0], |
| 588 |
m_basicFeature->m_av1SeqParams->GopPicSize, |
| 589 |
m_basicFeature->m_is10Bit, |
| 590 |
m_basicFeature->m_chromaFormat, |
| 591 |
dmem->INIT_GopP); |
| 592 |
|
| 593 |
qpP = qpI + 20; |
| 594 |
|
| 595 |
dmem->INIT_InitQPI = (uint8_t)qpI; |
| 596 |
dmem->INIT_InitQPP = (uint8_t)qpP; |
| 597 |
|
| 598 |
dmem->INIT_SegMapGenerating = false; |
| 599 |
dmem->INIT_Total_Level = seqParams->NumTemporalLayersMinus1 + 1; |
| 600 |
if (dmem->INIT_Total_Level > 1) |
| 601 |
{ |
| 602 |
return MOS_STATUS_INVALID_PARAMETER; |
| 603 |
} |
| 604 |
|
| 605 |
dmem->INIT_SLIDINGWINDOW_ENABLE = seqParams->SlidingWindowSize != 0; |
| 606 |
dmem->INIT_SLIDINGWINDOW_SIZE = (uint8_t)seqParams->SlidingWindowSize; |
| 607 |
if (dmem->INIT_SLIDINGWINDOW_ENABLE && seqParams->TargetBitRate[0] > 0) |
| 608 |
{ |
| 609 |
dmem->INIT_OvershootCBR_pct = (uint16_t)(seqParams->MaxBitRatePerSlidingWindow * 100 / seqParams->TargetBitRate[0]); |
| 610 |
} |
| 611 |
dmem->INIT_GopPicSize = seqParams->GopPicSize; |
| 612 |
|
| 613 |
return MOS_STATUS_SUCCESS; |
| 614 |
} |
| 615 |
|
| 616 |
MOS_STATUS Av1Brc::SetSequenceStructs() |
| 617 |
{ |
| 618 |
MOS_STATUS eStatus = MOS_STATUS_SUCCESS; |
| 619 |
|
| 620 |
ENCODE_FUNC_CALL(); |
| 621 |
|
| 622 |
if (m_basicFeature->m_av1SeqParams->RateControlMethod == RATECONTROL_CQL) |
| 623 |
{ |
| 624 |
const uint8_t ICQFactorLookup[52] = { |
| 625 |
0, 1, 1, 1, 1, 2, 3, 4, 6, 7, 9, 11, 13, 16, 18, 23, |
| 626 |
26, 30, 34, 39, 46, 52, 59, 68, 77, 87, 98, 104,112,120,127,134, |
| 627 |
142,149,157,164,171,178,186,193,200,207,213,219,225,230,235,240, |
| 628 |
245,249,252,255 |
| 629 |
}; |
| 630 |
|
| 631 |
uint32_t TargetBitRate = m_basicFeature->m_frameWidth * m_basicFeature->m_frameHeight * 8 / 1000; |
| 632 |
m_basicFeature->m_av1SeqParams->ICQQualityFactor = ICQFactorLookup[m_basicFeature->m_av1SeqParams->ICQQualityFactor]; |
| 633 |
m_basicFeature->m_av1SeqParams->TargetBitRate[0] = TargetBitRate; |
| 634 |
m_basicFeature->m_av1SeqParams->MaxBitRate = (TargetBitRate << 4) / 10; |
| 635 |
m_basicFeature->m_av1SeqParams->MinBitRate = 0; |
| 636 |
m_basicFeature->m_av1SeqParams->InitVBVBufferFullnessInBit = 8000 * (TargetBitRate << 3) / 10; |
| 637 |
m_basicFeature->m_av1SeqParams->VBVBufferSizeInBit = 8000 * (TargetBitRate << 1); |
| 638 |
} |
| 639 |
|
| 640 |
m_brcEnabled = IsRateControlBrc(m_basicFeature->m_av1SeqParams->RateControlMethod); |
| 641 |
|
| 642 |
m_brcInit = m_brcEnabled && m_basicFeature->m_resolutionChanged; |
| 643 |
|
| 644 |
m_rcMode = m_brcEnabled? m_basicFeature->m_av1SeqParams->RateControlMethod : 0; |
| 645 |
|
| 646 |
if (m_rcMode == RATECONTROL_CQL || m_rcMode == RATECONTROL_QVBR) |
| 647 |
{ |
| 648 |
if (m_basicFeature->m_av1SeqParams->ICQQualityFactor > ENCODE_AV1_MAX_ICQ_QUALITYFACTOR) |
| 649 |
{ |
| 650 |
ENCODE_ASSERTMESSAGE("Invalid ICQ Quality Factor input (%d)\n", m_basicFeature->m_av1SeqParams->ICQQualityFactor); |
| 651 |
eStatus = MOS_STATUS_INVALID_PARAMETER; |
| 652 |
return eStatus; |
| 653 |
} |
| 654 |
} |
| 655 |
|
| 656 |
m_brcReset = m_basicFeature->m_av1SeqParams->SeqFlags.fields.ResetBRC; |
| 657 |
|
| 658 |
if (m_brcReset && |
| 659 |
(!m_brcEnabled || |
| 660 |
m_rcMode == RATECONTROL_CQL)) |
| 661 |
{ |
| 662 |
ENCODE_ASSERTMESSAGE("BRC Reset cannot be trigerred in CQP/ICQ modes - invalid BRC parameters."); |
| 663 |
m_brcReset = false; |
| 664 |
} |
| 665 |
|
| 666 |
if (IsBRCInitRequired()) |
| 667 |
{ |
| 668 |
auto seqParams = m_basicFeature->m_av1SeqParams; |
| 669 |
ENCODE_CHK_NULL_RETURN(seqParams); |
| 670 |
|
| 671 |
m_delay = seqParams->InitVBVBufferFullnessInBit; |
| 672 |
m_vbvSize = seqParams->VBVBufferSizeInBit; |
| 673 |
|
| 674 |
uint32_t nom = 0; |
| 675 |
uint32_t denom = 1; |
| 676 |
std::tie(nom, denom) = GetFrameRate(*seqParams); |
| 677 |
|
| 678 |
if (denom == 0) |
| 679 |
{ |
| 680 |
denom = 1; |
| 681 |
} |
| 682 |
|
| 683 |
m_frameRate = (int32_t)((double)nom * 100. / (double)denom); |
| 684 |
|
| 685 |
//average frame size in bits based on bit rate and frame rate. |
| 686 |
const uint32_t maxBitrate = seqParams->MaxBitRate * BRC_KBPS; |
| 687 |
m_inputbitsperframe = maxBitrate * 100. / m_frameRate; |
| 688 |
|
| 689 |
//make sure the buffer size can contain at least 4 frames in average |
| 690 |
if (m_vbvSize < (int32_t)(m_inputbitsperframe * 4)) |
| 691 |
{ |
| 692 |
m_vbvSize = (int32_t)(m_inputbitsperframe * 4); |
| 693 |
} |
| 694 |
//make sure the initial buffer size is larger than 2 average frames and smaller than the max buffer size. |
| 695 |
if (m_delay == 0) |
| 696 |
m_delay = 7 * m_vbvSize / 8; |
| 697 |
if (m_delay < (int32_t)(m_inputbitsperframe * 2)) |
| 698 |
m_delay = (int32_t)(m_inputbitsperframe * 2); |
| 699 |
if (m_delay > m_vbvSize) |
| 700 |
m_delay = m_vbvSize; |
| 701 |
} |
| 702 |
|
| 703 |
return eStatus; |
| 704 |
} |
| 705 |
|
| 706 |
MOS_STATUS Av1Brc::FreeBrcResources() |
| 707 |
{ |
| 708 |
MOS_STATUS eStatus = MOS_STATUS_SUCCESS; |
| 709 |
|
| 710 |
ENCODE_FUNC_CALL(); |
| 711 |
ENCODE_CHK_NULL_RETURN(m_hwInterface); |
| 712 |
|
| 713 |
for (auto j = 0; j < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; j++) |
| 714 |
{ |
| 715 |
eStatus = Mhw_FreeBb(m_hwInterface->GetOsInterface(), &m_vdenc2ndLevelBatchBuffer[j], nullptr); |
| 716 |
ENCODE_ASSERT(eStatus == MOS_STATUS_SUCCESS); |
| 717 |
eStatus = Mhw_FreeBb(m_hwInterface->GetOsInterface(), &m_pakInsertOutputBatchBuffer[j], nullptr); |
| 718 |
ENCODE_ASSERT(eStatus == MOS_STATUS_SUCCESS); |
| 719 |
} |
| 720 |
|
| 721 |
return eStatus; |
| 722 |
} |
| 723 |
|
| 724 |
MHW_SETPAR_DECL_SRC(HUC_DMEM_STATE, Av1Brc) |
| 725 |
{ |
| 726 |
ENCODE_FUNC_CALL(); |
| 727 |
ENCODE_CHK_NULL_RETURN(params.hucDataSource); |
| 728 |
|
| 729 |
switch (params.function) |
| 730 |
{ |
| 731 |
case BRC_INIT: { |
| 732 |
auto dmem = (VdencAv1HucBrcInitDmem *)m_allocator->LockResourceForWrite(params.hucDataSource); |
| 733 |
|
| 734 |
ENCODE_CHK_NULL_RETURN(dmem); |
| 735 |
MOS_ZeroMemory(dmem, sizeof(VdencAv1HucBrcInitDmem)); |
| 736 |
|
| 737 |
SetDmemForInit(dmem); |
| 738 |
|
| 739 |
ENCODE_CHK_STATUS_RETURN(m_allocator->UnLock(params.hucDataSource)); |
| 740 |
break; |
| 741 |
} |
| 742 |
case BRC_UPDATE: { |
| 743 |
auto dmem = (VdencAv1HucBrcUpdateDmem *)m_allocator->LockResourceForWrite(params.hucDataSource); |
| 744 |
|
| 745 |
ENCODE_CHK_NULL_RETURN(dmem); |
| 746 |
MOS_ZeroMemory(dmem, sizeof(VdencAv1HucBrcUpdateDmem)); |
| 747 |
|
| 748 |
dmem->UPD_MaxNumPAKs = params.passNum; |
| 749 |
dmem->UPD_PAKPassNum = params.currentPass; |
| 750 |
dmem->UPD_SegMapGenerating = 0; |
| 751 |
|
| 752 |
SetDmemForUpdate(dmem); |
| 753 |
|
| 754 |
ENCODE_CHK_STATUS_RETURN(m_allocator->UnLock(params.hucDataSource)); |
| 755 |
|
| 756 |
break; |
| 757 |
} |
| 758 |
case PAK_INTEGRATE: { |
| 759 |
// nothing need to be done within brc feature for pak int |
| 760 |
break; |
| 761 |
} |
| 762 |
default: |
| 763 |
ENCODE_ASSERTMESSAGE("AV1 BRC feature supports only PAK_INTEGRATE, BRC_INIT and BRC_UPDATE HUC functions"); |
| 764 |
return MOS_STATUS_INVALID_PARAMETER; |
| 765 |
} |
| 766 |
|
| 767 |
return MOS_STATUS_SUCCESS; |
| 768 |
} |
| 769 |
|
| 770 |
MHW_SETPAR_DECL_SRC(HUC_VIRTUAL_ADDR_STATE, Av1Brc) |
| 771 |
{ |
| 772 |
ENCODE_FUNC_CALL(); |
| 773 |
if (params.function == BRC_UPDATE) |
| 774 |
{ |
| 775 |
const PMOS_RESOURCE brcConstDataBuffer = params.regionParams[5].presRegion; |
| 776 |
|
| 777 |
auto hucConstData = (VdencAv1HucBrcConstantData *)m_allocator->LockResourceForWrite(brcConstDataBuffer); |
| 778 |
ENCODE_CHK_NULL_RETURN(hucConstData); |
| 779 |
|
| 780 |
SetConstForUpdate(hucConstData); |
| 781 |
|
| 782 |
m_allocator->UnLock(brcConstDataBuffer); |
| 783 |
} |
| 784 |
|
| 785 |
return MOS_STATUS_SUCCESS; |
| 786 |
} |
| 787 |
|
| 788 |
MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, Av1Brc) |
| 789 |
{ |
| 790 |
ENCODE_FUNC_CALL(); |
| 791 |
if (m_brcEnabled) |
| 792 |
{ |
| 793 |
params.frameStatisticsStreamOut = true; |
| 794 |
} |
| 795 |
|
| 796 |
return MOS_STATUS_SUCCESS; |
| 797 |
} |
| 798 |
|
| 799 |
} // namespace encode |