Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/avc/features/encode_avc_brc.cpp

raw
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_avc_brc.cpp
24 //! \brief Defines the common interface for avc brc features
25 //!
26
27 #include "encode_avc_brc.h"
28 #include "encode_avc_vdenc_feature_manager.h"
29 #include "encode_avc_vdenc_const_settings.h"
30 #include "encode_avc_huc_brc_init_packet.h"
31 #include "encode_avc_huc_brc_update_packet.h"
32 #include "encode_avc_basic_feature.h"
33
34 namespace encode
35 {
36
37 #define ENCODE_AVC_BRC_MIN_QP 1
38 #define VDENC_AVC_BRC_MIN_QP 10
39 #define VDENC_AVC_BPS_RATIO_LOW 0.1
40 #define VDENC_AVC_BPS_RATIO_HIGH 3.5
41 #define ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR 11
42
43 //dynamic deviation thresholds calculation
44 #define VDENC_AVC_POS_MULT_I 50
45 #define VDENC_AVC_NEG_MULT_I -50
46 #define VDENC_AVC_POS_MULT_PB 50
47 #define VDENC_AVC_NEG_MULT_PB -50
48 #define VDENC_AVC_POS_MULT_VBR 100
49 #define VDENC_AVC_NEG_MULT_VBR -50
50
51 #define VDENC_AVC_BRC_TOPQPDELTATHRFORADAPT2PASS 2
52 #define VDENC_AVC_BRC_BOTQPDELTATHRFORADAPT2PASS 1
53 #define VDENC_AVC_BRC_TOPFRMSZTHRFORADAPT2PASS 32
54 #define VDENC_AVC_BRC_BOTFRMSZTHRFORADAPT2PASS 24
55
56 #define VDENC_AVC_AVBR_TOPQPDELTATHRFORADAPT2PASS 2
57 #define VDENC_AVC_AVBR_BOTQPDELTATHRFORADAPT2PASS 2
58 #define VDENC_AVC_AVBR_TOPFRMSZTHRFORADAPT2PASS 48
59 #define VDENC_AVC_AVBR_BOTFRMSZTHRFORADAPT2PASS 32
60
61 #define VDENC_AVC_BRC_TOPQPDELTATHRFORADAPT2PASS_4K 5
62 #define VDENC_AVC_BRC_BOTQPDELTATHRFORADAPT2PASS_4K 5
63 #define VDENC_AVC_BRC_TOPFRMSZTHRFORADAPT2PASS_4K 80
64 #define VDENC_AVC_BRC_BOTFRMSZTHRFORADAPT2PASS_4K 80
65
66 // VDEnc BRC Flag in BRC Init Kernel
67 typedef enum _BRCFLAG
68 {
69 BRCFLAG_ISICQ = 0x0000,
70 BRCFLAG_ISCBR = 0x0010,
71 BRCFLAG_ISVBR = 0x0020,
72 BRCFLAG_ISVCM = 0x0040,
73 BRCFLAG_ISLOWDELAY = 0x0080
74 } BRCFLAG;
75
76 AvcEncodeBRC::AvcEncodeBRC(
77 MediaFeatureManager *featureManager,
78 EncodeAllocator *allocator,
79 CodechalHwInterfaceNext *hwInterface,
80 void *constSettings) :
81 MediaFeature(constSettings, hwInterface ? hwInterface->GetOsInterface() : nullptr),
82 m_hwInterface(hwInterface),
83 m_allocator(allocator)
84 {
85 m_featureManager = featureManager;
86 //TODO: can be optimized after move encode parameter to feature manager.
87 auto encFeatureManager = dynamic_cast<EncodeAvcVdencFeatureManager*>(featureManager);
88 ENCODE_CHK_NULL_NO_STATUS_RETURN(encFeatureManager);
89
90 m_basicFeature = dynamic_cast<AvcBasicFeature *>(encFeatureManager->GetFeature(FeatureIDs::basicFeature));
91 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_basicFeature);
92
93 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface);
94 m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(m_hwInterface->GetVdencInterfaceNext());
95 m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(m_hwInterface->GetMfxInterfaceNext());
96 m_miItf = std::static_pointer_cast<mhw::mi::Itf>(m_hwInterface->GetMiInterfaceNext());
97 }
98
99 AvcEncodeBRC::~AvcEncodeBRC()
100 {
101 FreeBrcResources();
102 }
103
104 MOS_STATUS AvcEncodeBRC::Init(void *setting)
105 {
106 ENCODE_FUNC_CALL();
107
108 MediaUserSetting::Value outValue;
109 ReadUserSetting(
110 m_userSettingPtr,
111 outValue,
112 "AVC Encode MB BRC",
113 MediaUserSetting::Group::Sequence);
114
115 int32_t val = outValue.Get<int32_t>();
116 if ((val == 0) || (val == 1))
117 {
118 m_mbBrcUserFeatureKeyControl = true;
119 m_mbBrcEnabled = val ? true : false;
120 }
121
122 outValue = 0;
123
124 ReadUserSetting(
125 m_userSettingPtr,
126 outValue,
127 "VDEnc Single Pass Enable",
128 MediaUserSetting::Group::Sequence);
129
130 m_vdencSinglePassEnable = outValue.Get<int32_t>() == 1;
131
132 #if (_DEBUG || _RELEASE_INTERNAL)
133 auto statusKey = ReadUserSettingForDebug(
134 m_userSettingPtr,
135 outValue,
136 "Lpla TargetBufferFulness Data Address",
137 MediaUserSetting::Group::Sequence);
138 const char *path_buffer = outValue.ConstString().c_str();
139
140 if (statusKey == MOS_STATUS_SUCCESS && strcmp(path_buffer, "") != 0)
141 m_useBufferFulnessData = true;
142
143 if (m_useBufferFulnessData)
144 {
145 std::ifstream fp(path_buffer);
146 if (!fp.is_open())
147 {
148 m_useBufferFulnessData = false;
149 ENCODE_ASSERTMESSAGE("lpla targetBufferFulness data load failed!");
150 }
151 int cnt = 0;
152 std::string line = "";
153 while (getline(fp, line))
154 {
155 m_bufferFulnessData_csv[cnt++] = atoi(line.c_str());
156 }
157 }
158 #endif
159
160 ENCODE_CHK_STATUS_RETURN(AllocateResources());
161
162 return MOS_STATUS_SUCCESS;
163 }
164
165 MOS_STATUS AvcEncodeBRC::Update(void *params)
166 {
167 ENCODE_FUNC_CALL();
168 ENCODE_CHK_NULL_RETURN(params);
169
170 EncoderParams *encodeParams = (EncoderParams *)params;
171
172 ENCODE_CHK_STATUS_RETURN(SetSequenceStructs());
173
174 if (m_basicFeature->m_seqParam->RateControlMethod == RATECONTROL_VCM && m_basicFeature->m_pictureCodingType == B_TYPE)
175 {
176 ENCODE_ASSERTMESSAGE("VCM BRC mode does not support B-frames\n");
177 return MOS_STATUS_INVALID_PARAMETER;
178 }
179
180 if (m_basicFeature->m_seqParam->RateControlMethod == RATECONTROL_VCM &&
181 (m_basicFeature->m_picParam->FieldCodingFlag || m_basicFeature->m_picParam->FieldFrameCodingFlag))
182 {
183 ENCODE_ASSERTMESSAGE("VCM BRC mode does not support interlaced\n");
184 return MOS_STATUS_INVALID_PARAMETER;
185 }
186
187 #if (_DEBUG || _RELEASE_INTERNAL)
188 ReportUserSettingForDebug(
189 m_userSettingPtr,
190 "Encode RateControl Method",
191 m_rcMode,
192 MediaUserSetting::Group::Sequence);
193
194 MediaUserSetting::Value outValue;
195 ReadUserSetting(
196 m_userSettingPtr,
197 outValue,
198 "Adaptive TU Enable",
199 MediaUserSetting::Group::Sequence);
200 m_basicFeature->m_picParam->AdaptiveTUEnabled |= outValue.Get<uint8_t>();
201 #endif
202 return MOS_STATUS_SUCCESS;
203 }
204
205 MOS_STATUS AvcEncodeBRC::AllocateResources()
206 {
207 ENCODE_FUNC_CALL();
208
209 ENCODE_CHK_NULL_RETURN(m_allocator);
210 ENCODE_CHK_NULL_RETURN(m_basicFeature);
211 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_recycleBuf);
212 ENCODE_CHK_NULL_RETURN(m_hwInterface);
213 ENCODE_CHK_NULL_RETURN(m_hwInterface->GetOsInterface());
214
215 auto setting = static_cast<AvcVdencFeatureSettings *>(m_constSettings);
216 ENCODE_CHK_NULL_RETURN(setting);
217
218 auto brcSettings = setting->brcSettings;
219
220 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
221 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
222 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
223 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
224 allocParamsForBufferLinear.Format = Format_Buffer;
225
226 // VDENC Statistics buffer
227 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(brcSettings.vdencBrcStatsBufferSize, CODECHAL_PAGE_SIZE);
228 allocParamsForBufferLinear.pBufName = "VDENC BRC Statistics Buffer";
229 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_WRITE;
230 ENCODE_CHK_STATUS_RETURN(m_basicFeature->m_recycleBuf->RegisterResource(VdencStatsBuffer, allocParamsForBufferLinear, 1));
231
232 // VDENC BRC PAK MMIO buffer
233 allocParamsForBufferLinear.dwBytes = sizeof(VdencBrcPakMmio);
234 allocParamsForBufferLinear.pBufName = "VDENC BRC PAK MMIO Buffer";
235 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
236 ENCODE_CHK_STATUS_RETURN(m_basicFeature->m_recycleBuf->RegisterResource(VdencBrcPakMmioBuffer, allocParamsForBufferLinear, 1));
237
238 // Debug buffer
239 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(brcSettings.vdencBrcDbgBufferSize, CODECHAL_PAGE_SIZE);
240 allocParamsForBufferLinear.pBufName = "VDENC BRC Debug Buffer";
241 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
242 ENCODE_CHK_STATUS_RETURN(m_basicFeature->m_recycleBuf->RegisterResource(VdencBrcDebugBuffer, allocParamsForBufferLinear, 1));
243
244 // BRC history buffer
245 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(brcSettings.vdencBrcHistoryBufferSize, CODECHAL_PAGE_SIZE);
246 allocParamsForBufferLinear.pBufName = "VDENC BRC History Buffer";
247 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
248 ENCODE_CHK_STATUS_RETURN(m_basicFeature->m_recycleBuf->RegisterResource(VdencBRCHistoryBuffer, allocParamsForBufferLinear, 1));
249
250 // VDENC uses second level batch buffer for image state cmds
251 MOS_ZeroMemory(&m_batchBufferForVdencImgStat, sizeof(MHW_BATCH_BUFFER));
252 m_batchBufferForVdencImgStat.bSecondLevel = true;
253 ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
254 m_hwInterface->GetOsInterface(),
255 &m_batchBufferForVdencImgStat,
256 nullptr,
257 GetVdencBRCImgStateBufferSize()));
258
259 return MOS_STATUS_SUCCESS;
260 }
261
262 MOS_STATUS AvcEncodeBRC::SetDmemForInit(void *params)
263 {
264 ENCODE_FUNC_CALL();
265
266 ENCODE_CHK_NULL_RETURN(params);
267 auto hucVdencBrcInitDmem =(VdencAvcHucBrcInitDmem*)params;
268 static_assert(sizeof(VdencAvcHucBrcInitDmem) == 192, "VdencAvcHucBrcInitDmem size MUST be equal to 192");
269
270 auto setting = static_cast<AvcVdencFeatureSettings *>(m_constSettings);
271 ENCODE_CHK_NULL_RETURN(setting);
272
273 auto brcSettings = setting->brcSettings;
274 auto avcSeqParams = m_basicFeature->m_seqParam;
275 auto avcPicParams = m_basicFeature->m_picParam;
276
277 // VDEnc BRC encodes each field as one frame, so for interlaced we double the
278 // value of FramesPer100Sec. Otherwise BRC will spend ~2x the requested bits.
279 uint16_t framesFieldsPer100Sec = avcSeqParams->FramesPer100Sec;
280 if (avcPicParams->CurrOriginalPic.PicFlags == PICTURE_TOP_FIELD || avcPicParams->CurrOriginalPic.PicFlags == PICTURE_BOTTOM_FIELD)
281 framesFieldsPer100Sec *= 2;
282
283 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay Mode
284 {
285 avcSeqParams->MaxBitRate = avcSeqParams->TargetBitRate;
286 }
287
288 m_dBrcInitResetInputBitsPerFrame = avcSeqParams->MaxBitRate * 100.0 / framesFieldsPer100Sec;
289 m_dBrcInitCurrentTargetBufFullInBits = m_dBrcInitResetInputBitsPerFrame;
290 m_dBrcTargetSize = avcSeqParams->InitVBVBufferFullnessInBit;
291
292 hucVdencBrcInitDmem->BRCFunc_U8 = m_brcInit ? 0 : 2; // 0 for init, 2 for reset
293
294 hucVdencBrcInitDmem->INIT_FrameWidth_U16 = (uint16_t)m_basicFeature->m_frameWidth;
295 hucVdencBrcInitDmem->INIT_FrameHeight_U16 = (uint16_t)m_basicFeature->m_frameHeight;
296
297 hucVdencBrcInitDmem->INIT_TargetBitrate_U32 = avcSeqParams->TargetBitRate;
298 hucVdencBrcInitDmem->INIT_MinRate_U32 = avcSeqParams->MinBitRate;
299 hucVdencBrcInitDmem->INIT_MaxRate_U32 = avcSeqParams->MaxBitRate;
300 hucVdencBrcInitDmem->INIT_BufSize_U32 = avcSeqParams->VBVBufferSizeInBit;
301 hucVdencBrcInitDmem->INIT_InitBufFull_U32 = avcSeqParams->InitVBVBufferFullnessInBit;
302
303 if (hucVdencBrcInitDmem->INIT_InitBufFull_U32 > avcSeqParams->VBVBufferSizeInBit)
304 hucVdencBrcInitDmem->INIT_InitBufFull_U32 = avcSeqParams->VBVBufferSizeInBit;
305
306 switch (avcSeqParams->RateControlMethod)
307 {
308 case RATECONTROL_CBR:
309 hucVdencBrcInitDmem->INIT_BRCFlag_U16 |= BRCFLAG_ISCBR;
310 break;
311 case RATECONTROL_VBR:
312 hucVdencBrcInitDmem->INIT_BRCFlag_U16 |= BRCFLAG_ISVBR;
313 break;
314 case RATECONTROL_QVBR:
315 // QVBR will use VBR BRCFlag, triggered when ICQQualityFactor > 10
316 hucVdencBrcInitDmem->INIT_BRCFlag_U16 |= BRCFLAG_ISVBR;
317 break;
318 // Temp solution using AVBR for low delay case, before the BRC flag is added to DDI
319 case RATECONTROL_AVBR:
320 hucVdencBrcInitDmem->INIT_BRCFlag_U16 |= BRCFLAG_ISLOWDELAY;
321 break;
322 case RATECONTROL_ICQ:
323 hucVdencBrcInitDmem->INIT_BRCFlag_U16 |= BRCFLAG_ISICQ;
324 break;
325 case RATECONTROL_VCM:
326 hucVdencBrcInitDmem->INIT_BRCFlag_U16 |= BRCFLAG_ISVCM;
327 break;
328 default:
329 break;
330 }
331
332 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay Mode
333 {
334 hucVdencBrcInitDmem->INIT_BRCFlag_U16 = BRCFLAG_ISLOWDELAY;
335 hucVdencBrcInitDmem->INIT_LowDelayGoldenFrameBoost_U8 = 0; //get from ?
336 }
337
338 hucVdencBrcInitDmem->INIT_FrameRateM_U32 = framesFieldsPer100Sec;
339 hucVdencBrcInitDmem->INIT_FrameRateD_U32 = 100;
340
341 hucVdencBrcInitDmem->INIT_ProfileLevelMaxFrame_U32 = m_basicFeature->GetProfileLevelMaxFrameSize();
342
343 if (avcSeqParams->GopRefDist && (avcSeqParams->GopPicSize > 0))
344 {
345 uint16_t intraPeriod = avcSeqParams->GopPicSize - 1;
346 if (intraPeriod % avcSeqParams->GopRefDist != 0)
347 {
348 // Implement original cmodel behavior: use only complete Gop (for intraPeriod=6, GopRefDist=4 => intraPeriod must be 4)
349 intraPeriod -= intraPeriod % avcSeqParams->GopRefDist;
350 }
351
352 hucVdencBrcInitDmem->INIT_GopP_U16 = intraPeriod / avcSeqParams->GopRefDist;
353 hucVdencBrcInitDmem->INIT_GopB_U16 = (avcSeqParams->GopRefDist - 1) * hucVdencBrcInitDmem->INIT_GopP_U16;
354
355 if (avcSeqParams->GopRefDist >= avcSeqParams->GopPicSize && avcSeqParams->GopPicSize > 1)
356 {
357 hucVdencBrcInitDmem->INIT_ExtGopP_U16 = 1;
358 hucVdencBrcInitDmem->INIT_ExtGopB_U16 = avcSeqParams->GopPicSize - 2;
359 }
360 else if (IsBPyramidWithGoldenBGOP()) // For now AVC support only GOP4 and GOP8 golden gops
361 {
362 auto dmem = hucVdencBrcInitDmem;
363 uint8_t BGopSize = (uint8_t)avcSeqParams->GopRefDist;
364
365 dmem->INIT_ExtGopP_U16 = (uint16_t)(intraPeriod / BGopSize);
366 dmem->INIT_ExtGopB_U16 = BGopSize > 1 ? (uint16_t)dmem->INIT_ExtGopP_U16 : 0;
367
368 uint16_t gopB1Multiplicator = (BGopSize > 2 ? 1 : 0) +
369 (BGopSize == 4 || BGopSize > 5 ? 1 : 0);
370 uint16_t gopB2Multiplicator = (BGopSize > 3 ? 1 : 0);
371
372 dmem->INIT_ExtGopB1_U16 = dmem->INIT_ExtGopP_U16 * gopB1Multiplicator;
373 dmem->INIT_ExtGopB2_U16 = (intraPeriod - dmem->INIT_ExtGopP_U16 - dmem->INIT_ExtGopB_U16 - dmem->INIT_ExtGopB1_U16) * gopB2Multiplicator;
374 dmem->INIT_ExtMaxBrcLevel_U8 = dmem->INIT_ExtGopB1_U16 == 0 ? 2 :
375 (dmem->INIT_ExtGopB2_U16 == 0 ? AvcBrcFrameType::B1_FRAME : AvcBrcFrameType::B2_FRAME);
376 ENCODE_CHK_COND_RETURN(BGopSize != (1 << (dmem->INIT_ExtMaxBrcLevel_U8 - 1)),
377 "'BGopSize' (GopRefDist) must be equal '1 << (dmem->INIT_MaxBrcLevel_U16 - 1)'");
378 }
379 else
380 {
381 hucVdencBrcInitDmem->INIT_ExtGopP_U16 = hucVdencBrcInitDmem->INIT_GopP_U16;
382 hucVdencBrcInitDmem->INIT_ExtGopB_U16 = hucVdencBrcInitDmem->INIT_GopB_U16;
383
384 hucVdencBrcInitDmem->INIT_ExtGopB1_U16 = hucVdencBrcInitDmem->INIT_ExtGopB2_U16 = hucVdencBrcInitDmem->INIT_ExtMaxBrcLevel_U8 = 0;
385 }
386 }
387
388 if (m_basicFeature->m_minMaxQpControlEnabled)
389 {
390 hucVdencBrcInitDmem->INIT_MinQP_U16 = m_basicFeature->m_iMinQp;
391 hucVdencBrcInitDmem->INIT_MaxQP_U16 = m_basicFeature->m_iMaxQp;
392 }
393 else
394 {
395 hucVdencBrcInitDmem->INIT_MinQP_U16 = VDENC_AVC_BRC_MIN_QP; // Setting values from arch spec
396 hucVdencBrcInitDmem->INIT_MaxQP_U16 = CODECHAL_ENCODE_AVC_MAX_SLICE_QP; // Setting values from arch spec
397 }
398
399 //dynamic deviation thresholds
400 double inputBitsPerFrame = avcSeqParams->MaxBitRate * 100.0 / framesFieldsPer100Sec;
401 double bps_ratio = inputBitsPerFrame / (avcSeqParams->VBVBufferSizeInBit * 100.0 / framesFieldsPer100Sec/*DEV_STD_FPS*/);
402 if (bps_ratio < VDENC_AVC_BPS_RATIO_LOW) bps_ratio = VDENC_AVC_BPS_RATIO_LOW;
403 if (bps_ratio > VDENC_AVC_BPS_RATIO_HIGH) bps_ratio = VDENC_AVC_BPS_RATIO_HIGH;
404
405 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay Mode
406 {
407 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_DevThreshPB0_S8, 8 * sizeof(int8_t),
408 brcSettings.BRC_LowDelay_DevThreshPB0_S8, 8 * sizeof(int8_t));
409 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_DevThreshI0_S8, 8 * sizeof(int8_t),
410 brcSettings.BRC_LowDelay_DevThreshI0_S8, 8 * sizeof(int8_t));
411 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_DevThreshVBR0_S8, 8 * sizeof(int8_t),
412 brcSettings.BRC_LowDelay_DevThreshVBR0_S8, 8 * sizeof(int8_t));
413 }
414 else
415 {
416 //dynamic deviation thresholds
417 for (int i = 0; i < AvcVdencBrcConstSettings::m_numDevThreshlds / 2; i++)
418 {
419 hucVdencBrcInitDmem->INIT_DevThreshPB0_S8[i] =
420 (int8_t)(VDENC_AVC_NEG_MULT_PB * pow(brcSettings.BRC_DevThreshPB0_FP_NEG[i], bps_ratio));
421 hucVdencBrcInitDmem->INIT_DevThreshPB0_S8[i + AvcVdencBrcConstSettings::m_numDevThreshlds / 2] =
422 (int8_t)(VDENC_AVC_POS_MULT_PB * pow(brcSettings.BRC_DevThreshPB0_FP_POS[i], bps_ratio));
423
424 hucVdencBrcInitDmem->INIT_DevThreshI0_S8[i] =
425 (int8_t)(VDENC_AVC_NEG_MULT_I * pow(brcSettings.BRC_DevThreshI0_FP_NEG[i], bps_ratio));
426 hucVdencBrcInitDmem->INIT_DevThreshI0_S8[i + AvcVdencBrcConstSettings::m_numDevThreshlds / 2] =
427 (int8_t)(VDENC_AVC_POS_MULT_I * pow(brcSettings.BRC_DevThreshI0_FP_POS[i], bps_ratio));
428
429 hucVdencBrcInitDmem->INIT_DevThreshVBR0_S8[i] =
430 (int8_t)(VDENC_AVC_NEG_MULT_VBR * pow(brcSettings.BRC_DevThreshVBR0_NEG[i], bps_ratio));
431 hucVdencBrcInitDmem->INIT_DevThreshVBR0_S8[i + AvcVdencBrcConstSettings::m_numDevThreshlds / 2] =
432 (int8_t)(VDENC_AVC_POS_MULT_VBR * pow(brcSettings.BRC_DevThreshVBR0_POS[i], bps_ratio));
433 }
434 }
435
436 hucVdencBrcInitDmem->INIT_InitQPIP = (uint8_t)ComputeBRCInitQP(framesFieldsPer100Sec);
437
438 // MBBRC control
439 if (m_mbBrcEnabled)
440 {
441 hucVdencBrcInitDmem->INIT_MbQpCtrl_U8 = 1;
442 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_DistQPDelta_I8, 4 * sizeof(int8_t),
443 brcSettings.BRC_INIT_DistQPDelta_I8, 4 * sizeof(int8_t));
444 }
445
446 hucVdencBrcInitDmem->INIT_SliceSizeCtrlEn_U8 = avcSeqParams->EnableSliceLevelRateCtrl; // Enable slice size control
447
448 hucVdencBrcInitDmem->INIT_OscillationQpDelta_U8 =
449 ((avcSeqParams->RateControlMethod == RATECONTROL_VCM) || (avcSeqParams->RateControlMethod == RATECONTROL_QVBR)) ? 16 : 0;
450 hucVdencBrcInitDmem->INIT_HRDConformanceCheckDisable_U8 =
451 ((avcSeqParams->RateControlMethod == RATECONTROL_VCM) || (avcSeqParams->RateControlMethod == RATECONTROL_AVBR)) ? 1 : 0;
452
453 // Adaptive 2nd re-encode pass
454 if (m_basicFeature->m_picWidthInMb * m_basicFeature->m_picHeightInMb >= ((3840 * 2160) >> 8)) // >= 4K
455 {
456 hucVdencBrcInitDmem->INIT_TopQPDeltaThrForAdapt2Pass_U8 = VDENC_AVC_BRC_TOPQPDELTATHRFORADAPT2PASS_4K;
457 hucVdencBrcInitDmem->INIT_BotQPDeltaThrForAdapt2Pass_U8 = VDENC_AVC_BRC_BOTQPDELTATHRFORADAPT2PASS_4K;
458 hucVdencBrcInitDmem->INIT_TopFrmSzThrForAdapt2Pass_U8 = VDENC_AVC_BRC_TOPFRMSZTHRFORADAPT2PASS_4K;
459 hucVdencBrcInitDmem->INIT_BotFrmSzThrForAdapt2Pass_U8 = VDENC_AVC_BRC_BOTFRMSZTHRFORADAPT2PASS_4K;
460 }
461 else
462 {
463 if (avcSeqParams->RateControlMethod == RATECONTROL_AVBR)
464 {
465 hucVdencBrcInitDmem->INIT_TopQPDeltaThrForAdapt2Pass_U8 = VDENC_AVC_AVBR_TOPQPDELTATHRFORADAPT2PASS;
466 hucVdencBrcInitDmem->INIT_BotQPDeltaThrForAdapt2Pass_U8 = VDENC_AVC_AVBR_BOTQPDELTATHRFORADAPT2PASS;
467 hucVdencBrcInitDmem->INIT_TopFrmSzThrForAdapt2Pass_U8 = VDENC_AVC_AVBR_TOPFRMSZTHRFORADAPT2PASS;
468 hucVdencBrcInitDmem->INIT_BotFrmSzThrForAdapt2Pass_U8 = VDENC_AVC_AVBR_BOTFRMSZTHRFORADAPT2PASS;
469 }
470 else
471 {
472 hucVdencBrcInitDmem->INIT_TopQPDeltaThrForAdapt2Pass_U8 = VDENC_AVC_BRC_TOPQPDELTATHRFORADAPT2PASS;
473 hucVdencBrcInitDmem->INIT_BotQPDeltaThrForAdapt2Pass_U8 = VDENC_AVC_BRC_BOTQPDELTATHRFORADAPT2PASS;
474 hucVdencBrcInitDmem->INIT_TopFrmSzThrForAdapt2Pass_U8 = VDENC_AVC_BRC_TOPFRMSZTHRFORADAPT2PASS;
475 hucVdencBrcInitDmem->INIT_BotFrmSzThrForAdapt2Pass_U8 = VDENC_AVC_BRC_BOTFRMSZTHRFORADAPT2PASS;
476 }
477 }
478
479 hucVdencBrcInitDmem->INIT_QPSelectForFirstPass_U8 = 1;
480 hucVdencBrcInitDmem->INIT_MBHeaderCompensation_U8 = 1;
481 hucVdencBrcInitDmem->INIT_DeltaQP_Adaptation_U8 = 1;
482 hucVdencBrcInitDmem->INIT_MaxCRFQualityFactor_U8 = CODECHAL_ENCODE_AVC_MAX_ICQ_QUALITYFACTOR + 1;
483
484 if (RATECONTROL_QVBR == avcSeqParams->RateControlMethod || RATECONTROL_ICQ == avcSeqParams->RateControlMethod)
485 {
486 hucVdencBrcInitDmem->INIT_CRFQualityFactor_U8 = (uint8_t)avcSeqParams->ICQQualityFactor;
487 hucVdencBrcInitDmem->INIT_ScenarioInfo_U8 = (RATECONTROL_QVBR == avcSeqParams->RateControlMethod) ? 1 : 0;
488 }
489
490 if (m_basicFeature->m_picParam->NumDirtyROI)
491 {
492 hucVdencBrcInitDmem->INIT_ScenarioInfo_U8 = 1; //DISPLAYREMOTING
493 }
494
495 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_LOW) // Sliding Window BRC
496 {
497 hucVdencBrcInitDmem->INIT_SlidingWidowRCEnable_U8 = 1;
498 if (avcSeqParams->RateControlMethod == RATECONTROL_CBR && avcSeqParams->TargetBitRate != 0)
499 {
500 hucVdencBrcInitDmem->INIT_SlidingWindowSize_U8 = MOS_MIN((uint8_t)avcSeqParams->SlidingWindowSize, 60);
501 hucVdencBrcInitDmem->INIT_SlidingWindowMaxRateRatio_U8 = (uint8_t)((uint64_t)avcSeqParams->MaxBitRatePerSlidingWindow * 100 / avcSeqParams->TargetBitRate);
502 }
503 else
504 {
505 hucVdencBrcInitDmem->INIT_SlidingWindowSize_U8 = (uint8_t)(framesFieldsPer100Sec / 100);
506 hucVdencBrcInitDmem->INIT_SlidingWindowMaxRateRatio_U8 = 120;
507 }
508 }
509
510 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_EstRateThreshP0_U8, 7 * sizeof(uint8_t),
511 brcSettings.BRC_EstRateThreshP0_U8, 7 * sizeof(uint8_t));
512 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_EstRateThreshI0_U8, 7 * sizeof(uint8_t),
513 brcSettings.BRC_EstRateThreshI0_U8, 7 * sizeof(uint8_t));
514
515 // fractional QP enable for extended rho domain
516 hucVdencBrcInitDmem->INIT_FracQPEnable_U8 = (uint8_t)m_vdencItf->IsRhoDomainStatsEnabled();
517
518 // force enabling fractional QP and disabling HRD conformance for TCBRC
519 if ((avcPicParams->TargetFrameSize > 0) && (m_basicFeature->m_lookaheadDepth == 0))
520 {
521 hucVdencBrcInitDmem->INIT_FracQPEnable_U8 = 1;
522 hucVdencBrcInitDmem->INIT_HRDConformanceCheckDisable_U8 = 1;
523 }
524
525 hucVdencBrcInitDmem->INIT_SinglePassOnly = (uint8_t)m_vdencSinglePassEnable;
526
527 if (avcSeqParams->ScenarioInfo == ESCENARIO_GAMESTREAMING)
528 {
529 if (avcSeqParams->RateControlMethod == RATECONTROL_VBR)
530 {
531 avcSeqParams->MaxBitRate = avcSeqParams->TargetBitRate;
532 }
533
534 // Disable delta QP adaption for non-VCM/ICQ/LowDelay until we have better algorithm
535 if ((avcSeqParams->RateControlMethod != RATECONTROL_VCM) &&
536 (avcSeqParams->RateControlMethod != RATECONTROL_ICQ) &&
537 (avcSeqParams->FrameSizeTolerance != EFRAMESIZETOL_EXTREMELY_LOW))
538 {
539 hucVdencBrcInitDmem->INIT_DeltaQP_Adaptation_U8 = 0;
540 }
541
542 hucVdencBrcInitDmem->INIT_New_DeltaQP_Adaptation_U8 = 1;
543 }
544
545 if (((avcSeqParams->TargetUsage & 0x07) == TARGETUSAGE_BEST_SPEED) &&
546 (avcSeqParams->FrameWidth >= setting->singlePassMinFrameWidth) &&
547 (avcSeqParams->FrameHeight >= setting->singlePassMinFrameHeight) &&
548 (framesFieldsPer100Sec >= setting->singlePassMinFramePer100s))
549 {
550 hucVdencBrcInitDmem->INIT_SinglePassOnly = true;
551 }
552
553 hucVdencBrcInitDmem->INIT_LookaheadDepth_U8 = m_basicFeature->m_lookaheadDepth;
554
555 //Override the DistQPDelta setting
556 if (m_mbBrcEnabled)
557 {
558 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
559 {
560 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_DistQPDelta_I8, 4 * sizeof(int8_t),
561 brcSettings.brcInitDistQpDeltaI8LowDelay, 4 * sizeof(int8_t));
562 }
563 else
564 {
565 MOS_SecureMemcpy(hucVdencBrcInitDmem->INIT_DistQPDelta_I8, 4 * sizeof(int8_t),
566 brcSettings.brcInitDistQpDeltaI8, 4 * sizeof(int8_t));
567 }
568 }
569
570 return MOS_STATUS_SUCCESS;
571 }
572
573 MOS_STATUS AvcEncodeBRC::SetDmemForUpdate(void *params, uint16_t currPass, bool bIsLastPass)
574 {
575 ENCODE_FUNC_CALL();
576
577 ENCODE_CHK_NULL_RETURN(params);
578 auto hucVdencBrcUpdateDmem =(VdencAvcHucBrcUpdateDmem*)params;
579 static_assert(sizeof(VdencAvcHucBrcUpdateDmem) == 448, "VdencAvcHucBrcUpdateDmem size MUST be equal to 448");
580
581 auto setting = static_cast<AvcVdencFeatureSettings *>(m_constSettings);
582 ENCODE_CHK_NULL_RETURN(setting);
583
584 auto brcSettings = setting->brcSettings;
585 auto avcSeqParams = m_basicFeature->m_seqParam;
586 auto avcPicParams = m_basicFeature->m_picParam;
587
588 hucVdencBrcUpdateDmem->BRCFunc_U8 = 1; // Update:1
589
590 if (!m_brcInit && (currPass == 0))
591 {
592 m_brcInitPreviousTargetBufFullInBits = (uint32_t)(m_dBrcInitCurrentTargetBufFullInBits);
593 m_dBrcInitCurrentTargetBufFullInBits += m_dBrcInitResetInputBitsPerFrame;
594 m_dBrcTargetSize += m_dBrcInitResetInputBitsPerFrame;
595 }
596
597 if (m_dBrcTargetSize > avcSeqParams->VBVBufferSizeInBit)
598 {
599 m_dBrcTargetSize -= avcSeqParams->VBVBufferSizeInBit;
600 }
601
602 hucVdencBrcUpdateDmem->UPD_FRAMENUM_U32 = m_basicFeature->m_frameNum;
603 hucVdencBrcUpdateDmem->UPD_TARGETSIZE_U32 = (uint32_t)(m_dBrcTargetSize);
604 hucVdencBrcUpdateDmem->UPD_PeakTxBitsPerFrame_U32 = (uint32_t)(m_dBrcInitCurrentTargetBufFullInBits - m_brcInitPreviousTargetBufFullInBits);
605
606 //Dynamic slice size control
607 if (avcSeqParams->EnableSliceLevelRateCtrl)
608 {
609 hucVdencBrcUpdateDmem->UPD_SLCSZ_TARGETSLCSZ_U16 = (uint16_t)avcPicParams->SliceSizeInBytes; // target slice size
610 hucVdencBrcUpdateDmem->UPD_TargetSliceSize_U16 = (uint16_t)avcPicParams->SliceSizeInBytes; // set max slice size to be same as target slice size
611 hucVdencBrcUpdateDmem->UPD_MaxNumSliceAllowed_U16 = (uint16_t)m_basicFeature->m_maxNumSlicesAllowed;
612
613 for (uint8_t k = 0; k < 42; k++)
614 {
615 hucVdencBrcUpdateDmem->UPD_SLCSZ_UPD_THRDELTAI_U16[k] = MOS_MIN(avcPicParams->SliceSizeInBytes - 150, setting->SliceSizeThrsholdsI[k + 10]);
616 hucVdencBrcUpdateDmem->UPD_SLCSZ_UPD_THRDELTAP_U16[k] = MOS_MIN(avcPicParams->SliceSizeInBytes - 150, setting->SliceSizeThrsholdsP[k + 10]);
617 }
618 }
619 else
620 {
621 hucVdencBrcUpdateDmem->UPD_SLCSZ_TARGETSLCSZ_U16 = 0;
622 hucVdencBrcUpdateDmem->UPD_TargetSliceSize_U16 = 0;
623 hucVdencBrcUpdateDmem->UPD_MaxNumSliceAllowed_U16 = 0;
624
625 for (uint8_t k = 0; k < 42; k++)
626 {
627 hucVdencBrcUpdateDmem->UPD_SLCSZ_UPD_THRDELTAI_U16[k] = 0;
628 hucVdencBrcUpdateDmem->UPD_SLCSZ_UPD_THRDELTAP_U16[k] = 0;
629 }
630 }
631
632 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_LOW) // Sliding Window BRC
633 {
634 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->UPD_gRateRatioThreshold_U8, 7 * sizeof(uint8_t),
635 brcSettings.BRC_UPD_slwin_global_rate_ratio_threshold, 7 * sizeof(uint8_t));
636 }
637 else
638 {
639 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->UPD_gRateRatioThreshold_U8, 7 * sizeof(uint8_t),
640 brcSettings.BRC_UPD_global_rate_ratio_threshold, 7 * sizeof(uint8_t));
641 }
642
643 SetFrameTypeForUpdate(hucVdencBrcUpdateDmem, currPass);
644
645 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->UPD_startGAdjFrame_U16, 4 * sizeof(uint16_t),
646 brcSettings.BRC_UPD_start_global_adjust_frame, 4 * sizeof(uint16_t));
647 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->UPD_startGAdjMult_U8, 5 * sizeof(uint8_t),
648 brcSettings.BRC_UPD_start_global_adjust_mult, 5 * sizeof(uint8_t));
649 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->UPD_startGAdjDiv_U8, 5 * sizeof(uint8_t),
650 brcSettings.BRC_UPD_start_global_adjust_div, 5 * sizeof(uint8_t));
651 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->UPD_gRateRatioThresholdQP_U8, 8 * sizeof(uint8_t),
652 brcSettings.BRC_UPD_global_rate_ratio_threshold_qp, 8 * sizeof(uint8_t));
653
654 hucVdencBrcUpdateDmem->UPD_PAKPassNum_U8 = (uint8_t)currPass;
655 hucVdencBrcUpdateDmem->UPD_MaxNumPass_U8 = m_featureManager->GetNumPass();
656
657 hucVdencBrcUpdateDmem->UPD_AdaptiveTUEnabled = avcPicParams->AdaptiveTUEnabled;
658
659 uint32_t numP = 0;
660 if (avcSeqParams->GopRefDist && (avcSeqParams->GopPicSize > 0))
661 {
662 numP = (avcSeqParams->GopPicSize - 1) / avcSeqParams->GopRefDist;
663 }
664
665 for (int32_t i = 0; i < 2; i++)
666 {
667 hucVdencBrcUpdateDmem->UPD_SceneChgWidth_U8[i] = (uint8_t)MOS_MIN((numP + 1) / 5, 6);
668 }
669
670 hucVdencBrcUpdateDmem->UPD_SceneChgDetectEn_U8 = 1;
671 hucVdencBrcUpdateDmem->UPD_SceneChgPrevIntraPctThreshold_U8 = 0x60;
672 hucVdencBrcUpdateDmem->UPD_SceneChgCurIntraPctThreshold_U8 = 0xc0;
673
674 hucVdencBrcUpdateDmem->UPD_IPAverageCoeff_U8 = (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) ? 0 : 0x80;
675
676 hucVdencBrcUpdateDmem->UPD_CQP_FracQp_U8 = 0;
677
678 if (avcSeqParams->RateControlMethod == RATECONTROL_ICQ)
679 {
680 hucVdencBrcUpdateDmem->UPD_CQP_QpValue_U8 = 18; //Cmodel suggested a few values to try: 18,20,26,30
681 }
682 else
683 {
684 hucVdencBrcUpdateDmem->UPD_CQP_QpValue_U8 = 0;
685 }
686
687 hucVdencBrcUpdateDmem->UPD_HMEDetectionEnable_U8 = 0;
688
689 if (FRAME_SKIP_NORMAL == m_basicFeature->m_skipFrameFlag)
690 {
691 hucVdencBrcUpdateDmem->UPD_SkipFrameSize_U16 = (uint16_t)avcPicParams->SizeSkipFrames;
692 hucVdencBrcUpdateDmem->UPD_NumOfFramesSkipped_U16 = (uint16_t)avcPicParams->NumSkipFrames;
693 }
694 else
695 {
696 hucVdencBrcUpdateDmem->UPD_SkipFrameSize_U16 = 0;
697 hucVdencBrcUpdateDmem->UPD_NumOfFramesSkipped_U16 = 0;
698 }
699
700 // HMECost enabled by default in CModel V11738+
701 hucVdencBrcUpdateDmem->UPD_HMECostEnable_U8 = 1;
702
703 // ROI and static region pct parameters
704 // must be zero if they are not used
705 hucVdencBrcUpdateDmem->UPD_RoiQpViaForceQp_U8 = 0;
706 hucVdencBrcUpdateDmem->UPD_StaticRegionPct_U16 = 0;
707 hucVdencBrcUpdateDmem->UPD_ROISource_U8 = 0;
708 if (avcPicParams->NumROI)
709 {
710 ENCODE_CHK_COND_RETURN(avcPicParams->NumROIDistinctDeltaQp > sizeof(hucVdencBrcUpdateDmem->UPD_ROIQpDelta_I8) - 1, "Number of ROI is greater that dmem roi array size");
711
712 hucVdencBrcUpdateDmem->UPD_RoiQpViaForceQp_U8 = avcPicParams->bNativeROI ? 0 : 1;
713 for (uint8_t i = 0; i < avcPicParams->NumROIDistinctDeltaQp; i++)
714 {
715 hucVdencBrcUpdateDmem->UPD_ROIQpDelta_I8[i + 1] = avcPicParams->ROIDistinctDeltaQp[i];
716 }
717 }
718 else if (avcPicParams->NumDirtyROI)
719 {
720 //hucVdencBrcUpdateDmem->UPD_StaticRegionPct_U16 = (uint16_t)m_vdencStaticRegionPct;
721 if (m_mbBrcEnabled)
722 {
723 hucVdencBrcUpdateDmem->UPD_ROISource_U8 = 2;
724 }
725 }
726
727 hucVdencBrcUpdateDmem->UPD_SLBB_Size_U16 = (uint16_t)MOS_ALIGN_CEIL(m_hwInterface->m_vdencBrcImgStateBufferSize, CODECHAL_CACHELINE_SIZE);
728
729 hucVdencBrcUpdateDmem->UPD_WidthInMB_U16 = m_basicFeature->m_picWidthInMb;
730 hucVdencBrcUpdateDmem->UPD_HeightInMB_U16 = m_basicFeature->m_picHeightInMb;
731
732 hucVdencBrcUpdateDmem->MOTION_ADAPTIVE_G4 = (avcSeqParams->ScenarioInfo == ESCENARIO_GAMESTREAMING) || ((avcPicParams->TargetFrameSize > 0) && (m_basicFeature->m_lookaheadDepth == 0)); // GS or TCBRC
733 hucVdencBrcUpdateDmem->UPD_CQMEnabled_U8 = avcSeqParams->seq_scaling_matrix_present_flag || avcPicParams->pic_scaling_matrix_present_flag;
734
735 hucVdencBrcUpdateDmem->UPD_LA_TargetSize_U32 = avcPicParams->TargetFrameSize << 3;
736 hucVdencBrcUpdateDmem->UPD_TCBRC_SCENARIO_U8 = 0; // Temporal fix because of DDI flag deprication. Use Cloud Gaming mode by default
737 hucVdencBrcUpdateDmem->UPD_NumSlicesForRounding = GetAdaptiveRoundingNumSlices();
738 hucVdencBrcUpdateDmem->UPD_UserMaxFramePB = avcSeqParams->UserMaxPBFrameSize;
739
740 if (avcSeqParams->LookaheadDepth == 0 && avcPicParams->TargetFrameSize > 0 &&
741 (hucVdencBrcUpdateDmem->UPD_TCBRC_SCENARIO_U8 == 2 || avcSeqParams->UserMaxPBFrameSize <= avcPicParams->TargetFrameSize * 2))
742 {
743 if (avcSeqParams->UserMaxPBFrameSize == 0)
744 {
745 hucVdencBrcUpdateDmem->UPD_UserMaxFramePB = 2 * avcPicParams->TargetFrameSize;
746 }
747
748 uint32_t inputbitsperframe = avcPicParams->TargetFrameSize << 3;
749
750 if (avcPicParams->CodingType == I_TYPE)
751 {
752 hucVdencBrcUpdateDmem->UPD_LA_TargetSize_U32 = inputbitsperframe + inputbitsperframe / 8;
753 }
754 else if (abs((int)(8 * hucVdencBrcUpdateDmem->UPD_UserMaxFramePB - inputbitsperframe)) <= 8)
755 {
756 hucVdencBrcUpdateDmem->UPD_LA_TargetSize_U32 = inputbitsperframe * 9 / 10;
757 }
758 else
759 {
760 hucVdencBrcUpdateDmem->UPD_LA_TargetSize_U32 = inputbitsperframe;
761 }
762 }
763
764 if (m_basicFeature->m_lookaheadDepth > 0)
765 {
766 DeltaQPUpdate(avcPicParams->QpModulationStrength, bIsLastPass);
767 hucVdencBrcUpdateDmem->EnableLookAhead = 1;
768 #if (_DEBUG || _RELEASE_INTERNAL)
769 hucVdencBrcUpdateDmem->UPD_LA_TargetFulness_U32 = m_useBufferFulnessData ? m_bufferFulnessData_csv[m_basicFeature->m_frameNum % m_bufferFulnessDataSize] : m_basicFeature->m_targetBufferFulness;
770 #else
771 hucVdencBrcUpdateDmem->UPD_LA_TargetFulness_U32 = m_basicFeature->m_targetBufferFulness;
772 #endif
773 hucVdencBrcUpdateDmem->UPD_Delta_U8 = m_qpModulationStrength;
774 }
775
776 return MOS_STATUS_SUCCESS;
777 }
778
779 MOS_STATUS AvcEncodeBRC::FillHucConstData(uint8_t *data, uint8_t pictureType)
780 {
781 auto hucConstData = (VdencAvcHucBrcConstantData*)data;
782
783 auto setting = static_cast<AvcVdencFeatureSettings *>(m_constSettings);
784 ENCODE_CHK_NULL_RETURN(setting);
785
786 auto brcSettings = setting->brcSettings;
787 auto avcSeqParams = m_basicFeature->m_seqParam;
788
789 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabI_U8, 64 * sizeof(uint8_t),
790 brcSettings.BRC_UPD_GlobalRateQPAdjTabI_U8, 64 * sizeof(uint8_t));
791 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_LOW) // Sliding Window BRC
792 {
793 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t),
794 brcSettings.BRC_UPD_SlWinGlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t));
795 }
796 else
797 {
798 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t),
799 brcSettings.BRC_UPD_GlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t));
800 }
801 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabB_U8, 64 * sizeof(uint8_t),
802 brcSettings.BRC_UPD_GlobalRateQPAdjTabB_U8, 64 * sizeof(uint8_t));
803
804 MOS_SecureMemcpy(hucConstData->UPD_DistThreshldI_U8, 10 * sizeof(uint8_t),
805 brcSettings.BRC_UPD_DistThreshldI_U8, 10 * sizeof(uint8_t));
806 MOS_SecureMemcpy(hucConstData->UPD_DistThreshldP_U8, 10 * sizeof(uint8_t),
807 brcSettings.BRC_UPD_DistThreshldP_U8, 10 * sizeof(uint8_t));
808 MOS_SecureMemcpy(hucConstData->UPD_DistThreshldB_U8, 10 * sizeof(uint8_t),
809 brcSettings.BRC_UPD_DistThreshldB_U8, 10 * sizeof(uint8_t));
810
811 if (avcSeqParams->RateControlMethod == RATECONTROL_CBR)
812 {
813 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabI_U8, 81 * sizeof(uint8_t),
814 brcSettings.CBR_UPD_DistQPAdjTabI_U8, 81 * sizeof(int8_t));
815 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabP_U8, 81 * sizeof(uint8_t),
816 brcSettings.CBR_UPD_DistQPAdjTabP_U8, 81 * sizeof(int8_t));
817 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabB_U8, 81 * sizeof(uint8_t),
818 brcSettings.CBR_UPD_DistQPAdjTabB_U8, 81 * sizeof(int8_t));
819 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabI_S8, 72 * sizeof(uint8_t),
820 brcSettings.CBR_UPD_FrmSzAdjTabI_S8, 72 * sizeof(int8_t));
821 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t),
822 brcSettings.CBR_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
823 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabB_S8, 72 * sizeof(uint8_t),
824 brcSettings.CBR_UPD_FrmSzAdjTabB_S8, 72 * sizeof(int8_t));
825 }
826 else
827 {
828 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabI_U8, 81 * sizeof(uint8_t),
829 brcSettings.VBR_UPD_DistQPAdjTabI_U8, 81 * sizeof(int8_t));
830 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabP_U8, 81 * sizeof(uint8_t),
831 brcSettings.VBR_UPD_DistQPAdjTabP_U8, 81 * sizeof(int8_t));
832 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabB_U8, 81 * sizeof(uint8_t),
833 brcSettings.VBR_UPD_DistQPAdjTabB_U8, 81 * sizeof(int8_t));
834
835 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay Mode
836 {
837 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabI_S8, 72 * sizeof(uint8_t),
838 brcSettings.LOW_DELAY_UPD_FrmSzAdjTabI_S8, 72 * sizeof(int8_t));
839 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t),
840 brcSettings.LOW_DELAY_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
841 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabB_S8, 72 * sizeof(uint8_t),
842 brcSettings.LOW_DELAY_UPD_FrmSzAdjTabB_S8, 72 * sizeof(int8_t));
843 }
844 else
845 {
846 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabI_S8, 72 * sizeof(uint8_t),
847 brcSettings.VBR_UPD_FrmSzAdjTabI_S8, 72 * sizeof(int8_t));
848
849 if (avcSeqParams->RateControlMethod == RATECONTROL_QVBR)
850 {
851 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t),
852 brcSettings.QVBR_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
853 }
854 else
855 {
856 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t),
857 brcSettings.VBR_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
858 }
859
860 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabB_S8, 72 * sizeof(uint8_t),
861 brcSettings.VBR_UPD_FrmSzAdjTabB_S8, 72 * sizeof(int8_t));
862 }
863 }
864
865 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMinTabP_U8, 9 * sizeof(uint8_t), brcSettings.BRC_UPD_FrmSzMinTabP_U8, 9 * sizeof(uint8_t));
866 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMinTabI_U8, 9 * sizeof(uint8_t), brcSettings.BRC_UPD_FrmSzMinTabI_U8, 9 * sizeof(uint8_t));
867
868 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMaxTabP_U8, 9 * sizeof(uint8_t), brcSettings.BRC_UPD_FrmSzMaxTabP_U8, 9 * sizeof(uint8_t));
869 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMaxTabI_U8, 9 * sizeof(uint8_t), brcSettings.BRC_UPD_FrmSzMaxTabI_U8, 9 * sizeof(uint8_t));
870
871 MOS_SecureMemcpy(hucConstData->UPD_FrmSzSCGTabP_U8, 9 * sizeof(uint8_t), brcSettings.BRC_UPD_FrmSzSCGTabP_U8, 9 * sizeof(uint8_t));
872 MOS_SecureMemcpy(hucConstData->UPD_FrmSzSCGTabI_U8, 9 * sizeof(uint8_t), brcSettings.BRC_UPD_FrmSzSCGTabI_U8, 9 * sizeof(uint8_t));
873
874 MOS_SecureMemcpy(hucConstData->UPD_I_IntraNonPred, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_I_IntraNonPred, 42 * sizeof(uint8_t));
875 MOS_SecureMemcpy(hucConstData->UPD_I_Intra8x8, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_I_Intra8x8, 42 * sizeof(uint8_t));
876 MOS_SecureMemcpy(hucConstData->UPD_I_Intra4x4, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_I_Intra4x4, 42 * sizeof(uint8_t));
877
878 MOS_SecureMemcpy(hucConstData->UPD_P_IntraNonPred, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_IntraNonPred, 42 * sizeof(uint8_t));
879 MOS_SecureMemcpy(hucConstData->UPD_P_Intra16x16, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_Intra16x16, 42 * sizeof(uint8_t));
880 MOS_SecureMemcpy(hucConstData->UPD_P_Intra8x8, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_Intra8x8, 42 * sizeof(uint8_t));
881 MOS_SecureMemcpy(hucConstData->UPD_P_Intra4x4, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_Intra4x4, 42 * sizeof(uint8_t));
882
883 MOS_SecureMemcpy(hucConstData->UPD_P_Inter16x8, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_Inter16x8, 42 * sizeof(uint8_t));
884 MOS_SecureMemcpy(hucConstData->UPD_P_Inter8x8, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_Inter8x8, 42 * sizeof(uint8_t));
885 MOS_SecureMemcpy(hucConstData->UPD_P_Inter16x16, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_Inter16x16, 42 * sizeof(uint8_t));
886 MOS_SecureMemcpy(hucConstData->UPD_P_RefId, 42 * sizeof(uint8_t), brcSettings.BRC_UPD_P_RefId, 42 * sizeof(uint8_t));
887
888 ENCODE_CHK_STATUS_RETURN(LoadConstTable0(hucConstData->VdencAvcHucBrcConstantData_0));
889 ENCODE_CHK_STATUS_RETURN(LoadConstTable3(pictureType, hucConstData->VdencAvcHucBrcConstantData_1));
890 ENCODE_CHK_STATUS_RETURN(LoadConstTable5(pictureType, hucConstData->VdencAvcHucBrcConstantData_2));
891 ENCODE_CHK_STATUS_RETURN(LoadConstTable6(pictureType, hucConstData->VdencAvcHucBrcConstantData_3));
892 ENCODE_CHK_STATUS_RETURN(LoadConstTable7(pictureType, hucConstData->VdencAvcHucBrcConstantData_4));
893 ENCODE_CHK_STATUS_RETURN(LoadConstTable8(pictureType, hucConstData->VdencAvcHucBrcConstantData_5));
894
895 return MOS_STATUS_SUCCESS;
896 }
897
898 MOS_STATUS AvcEncodeBRC::SaveBrcUpdateDmemBufferPtr(
899 PMOS_RESOURCE vdencBrcUpdateDmemBuffer0,
900 PMOS_RESOURCE vdencBrcUpdateDmemBuffer1)
901 {
902 ENCODE_FUNC_CALL();
903
904 m_vdencBrcUpdateDmemBufferPtr[0] = vdencBrcUpdateDmemBuffer0;
905 m_vdencBrcUpdateDmemBufferPtr[1] = vdencBrcUpdateDmemBuffer1;
906
907 return MOS_STATUS_SUCCESS;
908 }
909
910 MOS_STATUS AvcEncodeBRC::SaveHucStatus2Buffer(PMOS_RESOURCE hucStatus2Buffer)
911 {
912 ENCODE_FUNC_CALL();
913
914 m_hucStatus2BufferPtr = hucStatus2Buffer;
915
916 return MOS_STATUS_SUCCESS;
917 }
918
919 MOS_STATUS AvcEncodeBRC::SetMfcStatusParams(EncodeStatusReadParams &params)
920 {
921 ENCODE_FUNC_CALL();
922
923 if (m_vdencBrcEnabled)
924 {
925 params.vdencBrcEnabled = true;
926 params.vdencBrcNumOfSliceOffset = CODECHAL_OFFSETOF(VdencAvcHucBrcUpdateDmem, NumOfSlice);
927 params.resVdencBrcUpdateDmemBufferPtr = m_vdencBrcUpdateDmemBufferPtr;
928 }
929
930 return MOS_STATUS_SUCCESS;
931 }
932
933 MOS_STATUS AvcEncodeBRC::LoadConstTable0(uint8_t constTable[8][42])
934 {
935 ENCODE_FUNC_CALL();
936
937 auto settings = static_cast<AvcVdencFeatureSettings *>(m_featureManager->GetFeatureSettings()->GetConstSettings());
938 ENCODE_CHK_NULL_RETURN(settings);
939
940 const auto &constTable1 = settings->vdencCMD3Table->AvcVdencCMD3ConstSettings_0;
941
942 for (auto i = 0; i < 8; i++)
943 {
944 for (auto j = 0; j < 42; j++)
945 {
946 constTable[i][j] = constTable1[i][j + 10];
947 }
948 }
949
950 return MOS_STATUS_SUCCESS;
951 }
952
953 MOS_STATUS AvcEncodeBRC::LoadConstTable3(uint8_t pictureType, uint8_t ConstTable3[42])
954 {
955 ENCODE_FUNC_CALL();
956
957 auto settings = static_cast<AvcVdencFeatureSettings *>(m_featureManager->GetFeatureSettings()->GetConstSettings());
958 ENCODE_CHK_NULL_RETURN(settings);
959
960 const auto & table = settings->vdencCMD3Table->AvcVdencCMD3ConstSettings_3;
961 const uint8_t codingType = pictureType + 1;
962
963 for (auto i = 0; i < 42; i++)
964 {
965 if (codingType == I_TYPE || codingType == P_TYPE)
966 {
967 ConstTable3[i] = table[pictureType][i + 10];
968 }
969 else // B and Ref B
970 {
971 ConstTable3[i] = 14;
972 }
973 }
974
975 return MOS_STATUS_SUCCESS;
976 }
977
978 MOS_STATUS AvcEncodeBRC::LoadConstTable5(uint8_t pictureType, uint16_t ConstTable5[42])
979 {
980 ENCODE_FUNC_CALL();
981
982 auto settings = static_cast<AvcVdencFeatureSettings *>(m_featureManager->GetFeatureSettings()->GetConstSettings());
983 ENCODE_CHK_NULL_RETURN(settings);
984
985 const auto & table = settings->vdencCMD3Table->AvcVdencCMD3ConstSettings_5;
986 uint8_t isIPGOP = m_basicFeature->m_seqParam->GopRefDist == 1 ? 1 : 0;
987 for (int8_t qp = 10; qp < 52; ++qp)
988 {
989 uint8_t idx = uint8_t(qp > 12 ? qp - 12 : 0);
990 ConstTable5[qp-10] = table[pictureType][isIPGOP][idx];
991 }
992
993 return MOS_STATUS_SUCCESS;
994 }
995
996 MOS_STATUS AvcEncodeBRC::LoadConstTable6(uint8_t pictureType, uint16_t ConstTable6[42])
997 {
998 ENCODE_FUNC_CALL();
999
1000 auto settings = static_cast<AvcVdencFeatureSettings *>(m_featureManager->GetFeatureSettings()->GetConstSettings());
1001 ENCODE_CHK_NULL_RETURN(settings);
1002
1003 const auto & table = settings->vdencCMD3Table->AvcVdencCMD3ConstSettings_6;
1004 uint8_t isIPGOP = m_basicFeature->m_seqParam->GopRefDist == 1 ? 1 : 0;
1005 for (int8_t qp = 10; qp < 52; ++qp)
1006 {
1007 uint8_t idx = uint8_t(qp > 12 ? qp - 12 : 0);
1008 ConstTable6[qp-10] = table[pictureType][isIPGOP][idx];
1009 }
1010
1011 return MOS_STATUS_SUCCESS;
1012 }
1013
1014 MOS_STATUS AvcEncodeBRC::LoadConstTable7(uint8_t pictureType, uint8_t ConstTable7[42])
1015 {
1016 ENCODE_FUNC_CALL();
1017
1018 const uint8_t codingType = pictureType + 1;
1019 if (codingType == I_TYPE)
1020 return MOS_STATUS_SUCCESS;
1021
1022 auto settings = static_cast<AvcVdencFeatureSettings *>(m_featureManager->GetFeatureSettings()->GetConstSettings());
1023 ENCODE_CHK_NULL_RETURN(settings);
1024
1025 uint8_t isIPGOP = m_basicFeature->m_seqParam->GopRefDist == 1;
1026 auto index = (codingType == P_TYPE) ? (isIPGOP ? 3 : 2) : (codingType == B_TYPE ? 0 : 1);
1027
1028 const auto &table = settings->AdaptiveInterRounding[index];
1029 for (int8_t qp = 10; qp < 52; ++qp)
1030 {
1031 ConstTable7[qp - 10] = table[qp];
1032 }
1033
1034 return MOS_STATUS_SUCCESS;
1035 }
1036
1037 MOS_STATUS AvcEncodeBRC::LoadConstTable8(uint8_t pictureType, uint8_t ConstTable8[42])
1038 {
1039 ENCODE_FUNC_CALL();
1040
1041 const uint8_t codingType = pictureType + 1;
1042 if (codingType == I_TYPE)
1043 return MOS_STATUS_SUCCESS;
1044
1045 auto settings = static_cast<AvcVdencFeatureSettings *>(m_featureManager->GetFeatureSettings()->GetConstSettings());
1046 ENCODE_CHK_NULL_RETURN(settings);
1047
1048 uint8_t isIPGOP = m_basicFeature->m_seqParam->GopRefDist == 1;
1049 auto index = (codingType == P_TYPE) ? (isIPGOP ? 3 : 2) : (codingType == B_TYPE ? 0 : 1);
1050
1051 const auto &table = settings->AdaptiveIntraRounding[index];
1052 for (int8_t qp = 10; qp < 52; ++qp)
1053 {
1054 ConstTable8[qp - 10] = table[qp];
1055 }
1056
1057 return MOS_STATUS_SUCCESS;
1058 }
1059
1060
1061 MOS_STATUS AvcEncodeBRC::SetSequenceStructs()
1062 {
1063 ENCODE_FUNC_CALL();
1064
1065 auto seqParams = m_basicFeature->m_seqParam;
1066
1067 m_brcInit = m_basicFeature->m_resolutionChanged;
1068 m_vdencBrcEnabled = IsVdencBrcSupported(seqParams);
1069 m_rcMode = m_vdencBrcEnabled ? seqParams->RateControlMethod : 0;
1070
1071 if (IsRateControlBrc(seqParams->RateControlMethod) && m_vdencBrcEnabled == 0)
1072 {
1073 // Error propagation
1074 return MOS_STATUS_INVALID_PARAMETER;
1075 }
1076
1077 // control MBBRC if the user feature key does not exist
1078 if (m_vdencBrcEnabled && !m_mbBrcUserFeatureKeyControl)
1079 {
1080 SetMbBrc();
1081 }
1082
1083 // BRC Init or Reset
1084 if (seqParams->bInitBRC)
1085 {
1086 m_brcInit = seqParams->bInitBRC;
1087 }
1088 else
1089 {
1090 m_brcReset = seqParams->bResetBRC;
1091 }
1092
1093 if (seqParams->RateControlMethod == RATECONTROL_ICQ || seqParams->RateControlMethod == RATECONTROL_QVBR)
1094 {
1095 if (seqParams->ICQQualityFactor < ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR ||
1096 seqParams->ICQQualityFactor > CODECHAL_ENCODE_AVC_MAX_ICQ_QUALITYFACTOR)
1097 {
1098 ENCODE_ASSERTMESSAGE("Invalid ICQ Quality Factor input\n");
1099 seqParams->ICQQualityFactor = (uint16_t)CodecHal_Clip3(ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR,
1100 CODECHAL_ENCODE_AVC_MAX_ICQ_QUALITYFACTOR,
1101 seqParams->ICQQualityFactor);
1102 }
1103 }
1104
1105 return MOS_STATUS_SUCCESS;
1106 }
1107
1108 void AvcEncodeBRC::SetMbBrc()
1109 {
1110 ENCODE_FUNC_CALL();
1111
1112 auto seqParams = m_basicFeature->m_seqParam;
1113 if (seqParams->RateControlMethod == RATECONTROL_ICQ || seqParams->RateControlMethod == RATECONTROL_QVBR)
1114 {
1115 // If the rate control method is ICQ or QVBR then enable MBBRC by default for all TUs and ignore the app input
1116 m_mbBrcEnabled = true;
1117 ENCODE_NORMALMESSAGE("MBBRC enabled with rate control = %d", seqParams->RateControlMethod);
1118 }
1119 else if (seqParams->RateControlMethod == RATECONTROL_VCM)
1120 {
1121 // If the rate control method is VCM then disable MBBRC by default for all TUs and ignore the app input
1122 m_mbBrcEnabled = false;
1123 }
1124 else
1125 {
1126 switch (seqParams->MBBRC)
1127 {
1128 case mbBrcInternal:
1129 m_mbBrcEnabled = true;
1130 break;
1131 case mbBrcDisabled:
1132 m_mbBrcEnabled = false;
1133 break;
1134 case mbBrcEnabled:
1135 m_mbBrcEnabled = true;
1136 break;
1137 }
1138 }
1139 }
1140
1141 MOS_STATUS AvcEncodeBRC::FreeBrcResources()
1142 {
1143 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1144
1145 ENCODE_FUNC_CALL();
1146 ENCODE_CHK_NULL_RETURN(m_hwInterface);
1147 ENCODE_CHK_NULL_RETURN(m_hwInterface->GetOsInterface());
1148
1149 if (m_batchBufferForVdencImgStat.iSize)
1150 {
1151 ENCODE_CHK_STATUS_RETURN(Mhw_FreeBb(m_hwInterface->GetOsInterface(), &m_batchBufferForVdencImgStat, nullptr));
1152 }
1153
1154 return eStatus;
1155 }
1156
1157 int32_t AvcEncodeBRC::ComputeBRCInitQP(uint16_t framesFieldsPer100Sec)
1158 {
1159 ENCODE_FUNC_CALL();
1160
1161 const float x0 = 0, y0 = 1.19f, x1 = 1.75f, y1 = 1.75f;
1162 uint32_t frameSize;
1163 int32_t QP, deltaQ;
1164
1165 auto seqParams = m_basicFeature->m_seqParam;
1166
1167 // InitQPIP calculation
1168 frameSize = ((m_basicFeature->m_frameWidth * m_basicFeature->m_frameHeight * 3) >> 1);
1169 QP = (int32_t)(1. / 1.2 * pow(10.0, (log10(frameSize * 2. / 3. * ((float)framesFieldsPer100Sec) / ((float)(seqParams->TargetBitRate) * 100)) - x0) * (y1 - y0) / (x1 - x0) + y0) + 0.5);
1170 QP += 2;
1171 //add additional change based on buffer size. It is especially useful for low delay
1172 deltaQ = (int32_t)(9 - (seqParams->VBVBufferSizeInBit * ((float)framesFieldsPer100Sec) / ((float)(seqParams->TargetBitRate) * 100)));
1173 QP += deltaQ < 0 ? 0 : deltaQ;
1174 QP = CodecHal_Clip3(ENCODE_AVC_BRC_MIN_QP, CODECHAL_ENCODE_AVC_MAX_SLICE_QP, QP);
1175 QP--;
1176 if (QP < 0)
1177 QP = 1;
1178
1179 return QP;
1180 }
1181
1182 MOS_STATUS AvcEncodeBRC::DeltaQPUpdate(uint8_t qpModulationStrength, bool bIsLastPass)
1183 {
1184 ENCODE_FUNC_CALL();
1185
1186 uint8_t qpStrength = (uint8_t)(qpModulationStrength + (qpModulationStrength >> 1));
1187 if (!m_isFirstDeltaQPCalculation)
1188 {
1189 if (qpModulationStrength == 0)
1190 {
1191 m_qpModulationStrength = 0;
1192 }
1193 else
1194 {
1195 m_qpModulationStrength = (m_qpModulationStrength + qpStrength + 1) >> 1;
1196 }
1197 }
1198 else
1199 {
1200 m_qpModulationStrength = qpStrength;
1201 if (bIsLastPass)
1202 {
1203 m_isFirstDeltaQPCalculation = false;
1204 }
1205 }
1206
1207 return MOS_STATUS_SUCCESS;
1208 }
1209
1210 void AvcEncodeBRC::SetFrameTypeForUpdate(VdencAvcHucBrcUpdateDmem *dmem, uint16_t currPass)
1211 {
1212 dmem->UPD_CurrFrameType_U8 = (m_basicFeature->m_pictureCodingType + 1) % 3; // I:2, P:0, B:1. Same values in AvcBrcFrameType
1213 if (dmem->UPD_CurrFrameType_U8 == 1 && m_basicFeature->m_picParam->RefPicFlag == 1)
1214 {
1215 dmem->UPD_CurrFrameType_U8 = 3; // separated type for reference B for legacy BRC
1216 }
1217
1218 if (m_basicFeature->m_pictureCodingType == I_TYPE || m_basicFeature->m_pictureCodingType == P_TYPE)
1219 {
1220 m_frameIdxInBGop = 0;
1221 }
1222 else if (currPass == 0)
1223 {
1224 ++m_frameIdxInBGop;
1225 }
1226
1227 //
1228 // Calculate correct ExtCurrFrameType only for Golden GOPs
1229 //
1230 // Calculate B-frame type based on hierarchy level for B-pyramid
1231 if (IsBPyramidWithGoldenBGOP() && m_basicFeature->m_pictureCodingType == B_TYPE)
1232 {
1233 uint16_t curOrder = 0, curLvlInBGop = 0;
1234 CalculateCurLvlInBGop(m_frameIdxInBGop, 1, m_basicFeature->m_seqParam->GopRefDist, 0, curOrder, curLvlInBGop);
1235
1236 dmem->UPD_ExtCurrFrameType = curLvlInBGop == 1 ? AvcBrcFrameType::B1_FRAME : (curLvlInBGop == 2 ? AvcBrcFrameType::B2_FRAME : AvcBrcFrameType::B_FRAME);
1237 }
1238 }
1239
1240 bool AvcEncodeBRC::IsVdencBrcSupported(
1241 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS avcSeqParams)
1242 {
1243 ENCODE_FUNC_CALL();
1244
1245 bool vdencBrcSupported = false;
1246
1247 // HuC based BRC should be used when 1) BRC is requested by App and 2) HuC FW is loaded and HuC is enabled for use.
1248 if (IsRateControlBrc(avcSeqParams->RateControlMethod))
1249 {
1250 if (!MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrEnableMediaKernels))
1251 {
1252 ENCODE_ASSERTMESSAGE("Failed to load HuC firmware!");
1253 }
1254
1255 vdencBrcSupported = MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrEnableMediaKernels);
1256 }
1257
1258 // Simple check for BRC parameters; if error, disable BRC and continue encoding
1259 if ((vdencBrcSupported) &&
1260 (avcSeqParams->RateControlMethod != RATECONTROL_ICQ) &&
1261 (((!avcSeqParams->InitVBVBufferFullnessInBit || !avcSeqParams->VBVBufferSizeInBit || !avcSeqParams->MaxBitRate) &&
1262 (avcSeqParams->RateControlMethod != RATECONTROL_AVBR)) ||
1263 !avcSeqParams->TargetBitRate ||
1264 !avcSeqParams->FramesPer100Sec))
1265 {
1266 ENCODE_ASSERTMESSAGE("Fatal error in AVC Encoding BRC parameters.");
1267 ENCODE_ASSERTMESSAGE("RateControlMethod = %d, InitVBVBufferFullnessInBit = %d, VBVBufferSizeInBit = %d, MaxBitRate = %d, TargetBitRate = %d, FramesPer100Sec = %d",
1268 avcSeqParams->RateControlMethod,
1269 avcSeqParams->InitVBVBufferFullnessInBit,
1270 avcSeqParams->VBVBufferSizeInBit,
1271 avcSeqParams->MaxBitRate,
1272 avcSeqParams->TargetBitRate,
1273 avcSeqParams->FramesPer100Sec);
1274 vdencBrcSupported = false;
1275 }
1276
1277 return vdencBrcSupported;
1278 }
1279
1280 uint32_t AvcEncodeBRC::GetVdencBRCImgStateBufferSize()
1281 {
1282 return MOS_ALIGN_CEIL(MOS_ALIGN_CEIL(m_hwInterface->m_vdencBrcImgStateBufferSize, CODECHAL_CACHELINE_SIZE) +
1283 CODECHAL_ENCODE_AVC_MAX_SLICES_SUPPORTED * GetVdencOneSliceStateSize(),
1284 CODECHAL_PAGE_SIZE);
1285 }
1286
1287 uint32_t AvcEncodeBRC::GetVdencOneSliceStateSize()
1288 {
1289 return m_mfxItf->MHW_GETSIZE_F(MFX_AVC_SLICE_STATE)() +
1290 m_vdencItf->MHW_GETSIZE_F(VDENC_AVC_SLICE_STATE)() +
1291 m_miItf->MHW_GETSIZE_F(MI_BATCH_BUFFER_END)();
1292 }
1293
1294 bool AvcEncodeBRC::IsBPyramidWithGoldenBGOP()
1295 {
1296 return
1297 // Add HierarchicalFlag to condition to not use hierarchy B-Frames when HierarchicalFlag==0
1298 // m_basicFeature->m_seqParam->HierarchicalFlag &&
1299 (m_basicFeature->m_seqParam->GopRefDist == 2 ||
1300 m_basicFeature->m_seqParam->GopRefDist == 4 ||
1301 m_basicFeature->m_seqParam->GopRefDist == 8);
1302 }
1303
1304 void AvcEncodeBRC::CalculateCurLvlInBGop(uint16_t curFrameIdxInBGop, uint16_t begin, uint16_t end, uint16_t curLvl, uint16_t &curOrder, uint16_t &retLvl)
1305 {
1306 curOrder += 1;
1307 if (curOrder == curFrameIdxInBGop)
1308 {
1309 retLvl = curLvl;
1310 return;
1311 }
1312
1313 if (end - begin > 1)
1314 {
1315 uint16_t pivot = (begin + end) >> 1;
1316 CalculateCurLvlInBGop(curFrameIdxInBGop, begin, pivot, curLvl + 1, curOrder, retLvl);
1317
1318 if (pivot + 1 != end)
1319 CalculateCurLvlInBGop(curFrameIdxInBGop, pivot + 1, end, curLvl + 1, curOrder, retLvl);
1320 }
1321 }
1322
1323 MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, AvcEncodeBRC)
1324 {
1325 params.frameStatisticsStreamOut = m_vdencBrcEnabled || m_basicFeature->m_picParam->StatusReportEnable.fields.FrameStats;
1326
1327 return MOS_STATUS_SUCCESS;
1328 }
1329
1330 MHW_SETPAR_DECL_SRC(HUC_VIRTUAL_ADDR_STATE, AvcEncodeBRC)
1331 {
1332 if (params.function == BRC_UPDATE)
1333 {
1334 ENCODE_CHK_NULL_RETURN(m_basicFeature);
1335
1336 // Output regions
1337 params.regionParams[0].presRegion = m_basicFeature->m_recycleBuf->GetBuffer(VdencBRCHistoryBuffer, m_basicFeature->m_frameNum);
1338 params.regionParams[0].isWritable = true;
1339 params.regionParams[6].presRegion = const_cast<PMOS_RESOURCE>(&m_batchBufferForVdencImgStat.OsResource);
1340 params.regionParams[6].isWritable = true;
1341
1342 // region 15 always in clear
1343 params.regionParams[15].presRegion = m_basicFeature->m_recycleBuf->GetBuffer(VdencBrcDebugBuffer, 0);
1344 }
1345
1346 return MOS_STATUS_SUCCESS;
1347 }
1348
1349 } // namespace encode