Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/av1/features/encode_av1_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_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