Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/hevc/features/encode_hevc_brc.cpp

raw
1 /*
2 * Copyright (c) 2018-2021, 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_hevc_brc.cpp
24 //! \brief Defines the common interface for hevc brc features
25 //!
26
27 #include "encode_hevc_basic_feature.h"
28 #include "encode_hevc_brc.h"
29 #include "encode_hevc_vdenc_feature_manager.h"
30 #include "encode_hevc_vdenc_const_settings.h"
31 #include "encode_huc_brc_init_packet.h"
32 #include "encode_huc_brc_update_packet.h"
33 namespace encode
34 {
35 HEVCEncodeBRC::HEVCEncodeBRC(
36 MediaFeatureManager *featureManager,
37 EncodeAllocator *allocator,
38 CodechalHwInterfaceNext *hwInterface,
39 void *constSettings) :
40 MediaFeature(constSettings, hwInterface ? hwInterface->GetOsInterface() : nullptr),
41 m_hwInterface(hwInterface),
42 m_allocator(allocator)
43 {
44 m_featureManager = featureManager;
45 // can be optimized after move encode parameter to feature manager.
46 auto encFeatureManager = dynamic_cast<EncodeHevcVdencFeatureManager*>(featureManager);
47 ENCODE_CHK_NULL_NO_STATUS_RETURN(encFeatureManager);
48
49 m_basicFeature = dynamic_cast<HevcBasicFeature *>(encFeatureManager->GetFeature(FeatureIDs::basicFeature));
50 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_basicFeature);
51
52 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface);
53 }
54
55 HEVCEncodeBRC::~HEVCEncodeBRC()
56 {
57 FreeBrcResources();
58 }
59
60 MOS_STATUS HEVCEncodeBRC::Init(void *setting)
61 {
62 ENCODE_FUNC_CALL();
63
64 #if (_DEBUG || _RELEASE_INTERNAL)
65 MediaUserSetting::Value outValue;
66 ReadUserSettingForDebug(
67 m_userSettingPtr,
68 outValue,
69 "FAST PAK ENABLE",
70 MediaUserSetting::Group::Sequence);
71 m_fastPakEnable = outValue.Get<bool>();
72
73 ReadUserSetting(
74 m_userSettingPtr,
75 outValue,
76 "HEVC VDEnc ACQP Enable",
77 MediaUserSetting::Group::Sequence);
78 m_hevcVDEncAcqpEnabled = outValue.Get<bool>();
79 #endif
80
81 ENCODE_CHK_STATUS_RETURN(AllocateResources());
82
83 return MOS_STATUS_SUCCESS;
84 }
85
86 MOS_STATUS HEVCEncodeBRC::Update(void *params)
87 {
88 ENCODE_FUNC_CALL();
89 ENCODE_CHK_NULL_RETURN(params);
90
91 EncoderParams *encodeParams = (EncoderParams *)params;
92
93 ENCODE_CHK_STATUS_RETURN(SetSequenceStructs());
94 ENCODE_CHK_STATUS_RETURN(UpdateBrcResources(encodeParams));
95
96 #if (_DEBUG || _RELEASE_INTERNAL)
97 ReportUserSettingForDebug(
98 m_userSettingPtr,
99 "Encode RateControl Method",
100 m_rcMode,
101 MediaUserSetting::Group::Sequence);
102 ReportUserSettingForDebug(
103 m_userSettingPtr,
104 "HEVC VDEnc ACQP Enable",
105 m_hevcVDEncAcqpEnabled,
106 MediaUserSetting::Group::Sequence);
107
108 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_hevcPicParams);
109 MediaUserSetting::Value outValue;
110 ReadUserSetting(
111 m_userSettingPtr,
112 outValue,
113 "Adaptive TU Enable",
114 MediaUserSetting::Group::Sequence);
115 m_basicFeature->m_hevcPicParams->AdaptiveTUEnabled |= outValue.Get<uint8_t>();
116 #endif
117 return MOS_STATUS_SUCCESS;
118 }
119
120 MOS_STATUS HEVCEncodeBRC::AllocateResources()
121 {
122 ENCODE_FUNC_CALL();
123 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
124
125 ENCODE_CHK_NULL_RETURN(m_allocator);
126 ENCODE_CHK_NULL_RETURN(m_basicFeature);
127 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_recycleBuf);
128 ENCODE_CHK_NULL_RETURN(m_hwInterface);
129 ENCODE_CHK_NULL_RETURN(m_hwInterface->GetOsInterface());
130
131 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
132 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
133 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
134 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
135 allocParamsForBufferLinear.Format = Format_Buffer;
136
137 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(sizeof(CodechalVdencHevcPakInfo), CODECHAL_PAGE_SIZE);
138 allocParamsForBufferLinear.pBufName = "VDENC BRC PakInfo";
139 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
140 m_basicFeature->m_recycleBuf->RegisterResource(PakInfo, allocParamsForBufferLinear, 6);
141
142 // Allocate Frame Statistics Streamout Data Destination Buffer. DW98-100 in HCP PipeBufAddr command
143 HevcBasicFeature *hevcBasicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
144 ENCODE_CHK_NULL_RETURN(hevcBasicFeature);
145
146 // BRC history buffer
147 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_brcHistoryBufSize, CODECHAL_PAGE_SIZE);
148 allocParamsForBufferLinear.pBufName = "VDENC BRC History Buffer";
149 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
150 m_basicFeature->m_recycleBuf->RegisterResource(VdencBRCHistoryBuffer, allocParamsForBufferLinear, 1);
151
152 for (auto j = 0; j < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; j++)
153 {
154 // VDENC uses second level batch buffer
155 MOS_ZeroMemory(&m_vdenc2ndLevelBatchBuffer[j], sizeof(MHW_BATCH_BUFFER));
156 m_vdenc2ndLevelBatchBuffer[j].bSecondLevel = true;
157 ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
158 m_hwInterface->GetOsInterface(),
159 &m_vdenc2ndLevelBatchBuffer[j],
160 nullptr,
161 m_hwInterface->m_vdenc2ndLevelBatchBufferSize));
162 }
163
164 // Lcu Base Address buffer
165 // HEVC Encoder Mode: Slice size is written to this buffer when slice size conformance is enabled.
166 // 1 CL (= 16 DWs = 64 bytes) per slice * Maximum number of slices in a frame.
167 // Align to page for HUC requirement
168 const uint32_t picWidthInMinLCU = MOS_ROUNDUP_DIVIDE(m_basicFeature->m_frameWidth, CODECHAL_HEVC_MIN_LCU_SIZE); //assume smallest LCU to get max width
169 const uint32_t picHeightInMinLCU = MOS_ROUNDUP_DIVIDE(m_basicFeature->m_frameHeight, CODECHAL_HEVC_MIN_LCU_SIZE); //assume smallest LCU to get max height
170 uint32_t maxLcu = picWidthInMinLCU * picHeightInMinLCU;
171 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(maxLcu * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
172 allocParamsForBufferLinear.pBufName = "LcuBaseAddressBuffer";
173 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
174 m_basicFeature->m_recycleBuf->RegisterResource(LcuBaseAddressBuffer, allocParamsForBufferLinear, 1);
175
176 // VDENC BRC PAK MMIO buffer
177 allocParamsForBufferLinear.dwBytes = sizeof(VdencBrcPakMmio);
178 allocParamsForBufferLinear.pBufName = "VDENC BRC PAK MMIO Buffer";
179 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
180 m_basicFeature->m_recycleBuf->RegisterResource(VdencBrcPakMmioBuffer, allocParamsForBufferLinear, 1);
181
182 // Debug buffer
183 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_brcDebugBufSize, CODECHAL_PAGE_SIZE);
184 allocParamsForBufferLinear.pBufName = "VDENC BRC Debug Buffer";
185 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
186 m_basicFeature->m_recycleBuf->RegisterResource(VdencBrcDebugBuffer, allocParamsForBufferLinear, 1);
187
188 allocParamsForBufferLinear.dwBytes = HEVC_BRC_PAK_STATISTCS_SIZE;
189 allocParamsForBufferLinear.pBufName = "BRC PAK Statistics Buffer";
190 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
191 m_basicFeature->m_recycleBuf->RegisterResource(BrcPakStatisticBuffer, allocParamsForBufferLinear, CODECHAL_ENCODE_RECYCLED_BUFFER_NUM);
192
193 for (auto i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
194 {
195 MOS_RESOURCE *allocatedresource = m_basicFeature->m_recycleBuf->GetBuffer(BrcPakStatisticBuffer,i);
196 ENCODE_CHK_NULL_RETURN(allocatedresource);
197 m_vdencBrcBuffers.resBrcPakStatisticBuffer[i] = allocatedresource;
198 }
199
200 m_rdLambdaArray = MOS_NewArray(uint16_t, HUC_QP_RANGE);
201 ENCODE_CHK_NULL_RETURN(m_rdLambdaArray);
202 m_sadLambdaArray = MOS_NewArray(uint16_t, HUC_QP_RANGE);
203 ENCODE_CHK_NULL_RETURN(m_sadLambdaArray);
204
205 return eStatus;
206 }
207
208 MOS_STATUS HEVCEncodeBRC::UpdateBrcResources(void *params)
209 {
210 ENCODE_FUNC_CALL();
211 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
212
213 ENCODE_CHK_NULL_RETURN(m_allocator);
214 ENCODE_CHK_NULL_RETURN(params);
215
216 EncoderParams *encodeParams = (EncoderParams *)params;
217 ENCODE_CHK_NULL_RETURN(encodeParams);
218
219 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams =
220 static_cast<PCODEC_HEVC_ENCODE_PICTURE_PARAMS>(encodeParams->pPicParams);
221 ENCODE_CHK_NULL_RETURN(hevcPicParams);
222
223 auto num_tile_rows = hevcPicParams->num_tile_rows_minus1 + 1;
224 auto num_tile_columns = hevcPicParams->num_tile_columns_minus1 + 1;
225 auto num_tiles = num_tile_rows * num_tile_columns;
226
227 if (Mos_ResourceIsNull(&m_resBrcDataBuffer))
228 {
229 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
230 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
231 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
232 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
233 allocParamsForBufferLinear.Format = Format_Buffer;
234 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(num_tiles * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
235 allocParamsForBufferLinear.pBufName = "BRC Data Buffer";
236 allocParamsForBufferLinear.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_CACHE;
237 auto resource = m_allocator->AllocateResource(allocParamsForBufferLinear, true);
238 ENCODE_CHK_NULL_RETURN(resource);
239 m_resBrcDataBuffer = *resource;
240 }
241 // BRC Data Buffer
242
243 return eStatus;
244 }
245
246 MOS_STATUS HEVCEncodeBRC::GetBrcDataBuffer(MOS_RESOURCE *&buffer)
247 {
248 ENCODE_FUNC_CALL();
249 buffer = &m_resBrcDataBuffer;
250 return MOS_STATUS_SUCCESS;
251 }
252
253 MOS_STATUS HEVCEncodeBRC::SetDmemForUpdate(void* params)
254 {
255 ENCODE_FUNC_CALL();
256 ENCODE_CHK_NULL_RETURN(params);
257 auto hucVdencBrcUpdateDmem =
258 (VdencHevcHucBrcUpdateDmem *)params;
259
260 auto setting = static_cast<HevcVdencFeatureSettings *>(m_constSettings);
261 ENCODE_CHK_NULL_RETURN(setting);
262
263 auto brcSettings = setting->brcSettings;
264
265 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->startGAdjFrame_U16, 4 * sizeof(uint16_t), brcSettings.startGAdjFrame.data, 4 * sizeof(uint16_t));
266 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->gRateRatioThreshold_U8, 7 * sizeof(uint8_t), brcSettings.rateRatioThreshold.data, 7 * sizeof(uint8_t));
267 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->startGAdjMult_U8, 5 * sizeof(uint8_t), brcSettings.startGAdjMult.data, 5 * sizeof(uint8_t));
268 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->startGAdjDiv_U8, 5 * sizeof(uint8_t), brcSettings.startGAdjDiv.data, 5 * sizeof(uint8_t));
269 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->gRateRatioThresholdQP_U8, 8 * sizeof(uint8_t), brcSettings.rateRatioThresholdQP.data, 8 * sizeof(uint8_t));
270
271 if ((IsACQPEnabled() && m_basicFeature->m_hevcSeqParams->QpAdjustment) || (IsBRCEnabled() && (m_basicFeature->m_hevcSeqParams->MBBRC != 2)))
272 {
273 hucVdencBrcUpdateDmem->DeltaQPForSadZone0_S8 = brcSettings.deltaQPForSadZone0_S8;
274 hucVdencBrcUpdateDmem->DeltaQPForSadZone1_S8 = brcSettings.deltaQPForSadZone1_S8;
275 hucVdencBrcUpdateDmem->DeltaQPForSadZone2_S8 = brcSettings.deltaQPForSadZone2_S8;
276 hucVdencBrcUpdateDmem->DeltaQPForSadZone3_S8 = brcSettings.deltaQPForSadZone3_S8;
277 hucVdencBrcUpdateDmem->DeltaQPForMvZero_S8 = brcSettings.deltaQPForMvZero_S8;
278 hucVdencBrcUpdateDmem->DeltaQPForMvZone0_S8 = brcSettings.deltaQPForMvZone0_S8;
279 hucVdencBrcUpdateDmem->DeltaQPForMvZone1_S8 = brcSettings.deltaQPForMvZone1_S8;
280 hucVdencBrcUpdateDmem->DeltaQPForMvZone2_S8 = brcSettings.deltaQPForMvZone2_S8;
281 }
282
283 if (m_fastPakEnable)
284 {
285 hucVdencBrcUpdateDmem->ReEncodePositiveQPDeltaThr_S8 = brcSettings.reEncodePositiveQPDeltaThr_S8;
286 hucVdencBrcUpdateDmem->ReEncodeNegativeQPDeltaThr_S8 = brcSettings.reEncodeNegativeQPDeltaThr_S8;
287 }
288 else
289 {
290 hucVdencBrcUpdateDmem->ReEncodePositiveQPDeltaThr_S8 = 0;
291 hucVdencBrcUpdateDmem->ReEncodeNegativeQPDeltaThr_S8 = 0;
292 }
293 hucVdencBrcUpdateDmem->SceneChgPrevIntraPctThreshold_U8 = brcSettings.sceneChgPrevIntraPctThreshold_U8;
294 hucVdencBrcUpdateDmem->SceneChgCurIntraPctThreshold_U8 = brcSettings.sceneChgCurIntraPctThreshold_U8;
295
296 hucVdencBrcUpdateDmem->UPD_Randomaccess = m_basicFeature->m_hevcSeqParams->LowDelayMode == 1 ? 0 : 1;
297
298 hucVdencBrcUpdateDmem->UPD_AdaptiveTUEnabled = m_basicFeature->m_hevcPicParams->AdaptiveTUEnabled;
299
300 return MOS_STATUS_SUCCESS;
301 }
302
303 MOS_STATUS HEVCEncodeBRC::SetHevcDepthBasedLambda(
304 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams,
305 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams,
306 uint8_t qp,
307 uint16_t& SADQPLambda,
308 uint16_t& RDQPLambda)
309 {
310 ENCODE_FUNC_CALL();
311
312 ENCODE_CHK_NULL_RETURN(hevcSeqParams);
313 ENCODE_CHK_NULL_RETURN(hevcPicParams);
314
315 double QPScale = (hevcPicParams->CodingType == I_TYPE) ? 0.60 : 0.65;
316 uint32_t bGopSize = hevcSeqParams->GopRefDist;
317 int32_t depth = hevcPicParams->HierarchLevelPlus1 ? hevcPicParams->HierarchLevelPlus1 - 1 : 0;
318
319 std::vector<double> qpFactors;
320 uint32_t lambdaType = 1;
321
322 if (hevcSeqParams->LowDelayMode)
323 {
324 lambdaType = 1;
325 bGopSize = 4; // LDB set bGopSize as 4
326 qpFactors = {0.578, 0.3524, 0.3524};
327 }
328 else
329 {
330 lambdaType = 2;
331 qpFactors = {0.442, 0.3536, 0.3536, 0.68}; // seems not used;
332 }
333
334 if (lambdaType != 1)
335 {
336 if (hevcPicParams->CodingType == B_TYPE && lambdaType != 0 && ((bGopSize == 4) || (bGopSize == 8)))
337 {
338 const double LambdaScaleForRA[2][4] =
339 {
340 //Base, Depth0, Depth1, Depth2
341 {1.8f, 0.9f, 1.7f, 1.0f}, // GOP 4
342 {2.0f, 0.9f, 1.4f, 0.8f} // GOP 8
343 };
344
345 double raLambdaScale = 1.0;
346 if (bGopSize == 4)
347 {
348 if (depth == 2)
349 {
350 raLambdaScale = 1.0 * LambdaScaleForRA[0][3];
351 }
352 else if (depth == 1) // depth is 1 //modification for LTR
353 {
354 raLambdaScale = 0.52 * LambdaScaleForRA[0][2];
355 }
356 else if (depth == 0) // depth is 0 //modification for LTR
357 {
358 raLambdaScale = 0.65 * LambdaScaleForRA[0][1];
359 }
360
361 QPScale *= raLambdaScale * LambdaScaleForRA[0][0];
362 }
363 else if (bGopSize == 8)
364 {
365 if (depth == 3)
366 {
367 raLambdaScale = 1.0 * LambdaScaleForRA[1][3];
368 }
369 else if (depth == 2 || depth == 1)
370 {
371 raLambdaScale = 0.52 * LambdaScaleForRA[1][2];
372 }
373 else if (depth == 0)
374 {
375 raLambdaScale = 0.65 * LambdaScaleForRA[1][1];
376 }
377
378 QPScale *= raLambdaScale * LambdaScaleForRA[1][0];
379 }
380 }
381 }
382 else if (bGopSize > 0)
383 {
384 auto Clip3 = [&](double min, double max, double x) {
385 return ((x < min) ? min : ((x > max) ? max : x));
386 };
387
388 if (hevcPicParams->CodingType == I_TYPE)
389 {
390 QPScale = 0.57 * (1.0 - Clip3(0, 0.5, 0.05 * (bGopSize - 1)));
391 }
392 else
393 {
394 int size = qpFactors.size();
395 QPScale = qpFactors[CodecHal_Clip3(0, size - 1, depth)];
396 if (depth > 0)
397 {
398 QPScale *= Clip3(2.0, 4.0, ((qp - 12) / 6.0));
399 }
400 }
401 }
402
403 double realLambda = QPScale * pow(2.0, MOS_MAX(0, qp - 12) / 3.0);
404 RDQPLambda = (uint16_t)(MOS_MIN(65535, realLambda * 4 + 0.5)); //U14.2
405
406 realLambda = sqrt(realLambda);
407 SADQPLambda = (uint16_t)(MOS_MIN(65535, realLambda * 4 + 0.5)); //U8.2
408
409 return MOS_STATUS_SUCCESS;
410 }
411
412 MOS_STATUS HEVCEncodeBRC::SetConstLambdaForUpdate(void *params, bool lambdaType)
413 {
414 ENCODE_FUNC_CALL();
415 ENCODE_CHK_NULL_RETURN(params);
416 auto hucConstData =
417 (VdencHevcHucBrcConstantData *)params;
418
419 auto setting = static_cast<HevcVdencFeatureSettings *>(m_constSettings);
420 ENCODE_CHK_NULL_RETURN(setting);
421
422 auto brcSettings = setting->brcSettings;
423
424 if (lambdaType)
425 {
426 ENCODE_CHK_NULL_RETURN(m_basicFeature);
427 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_hevcSeqParams);
428 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_hevcPicParams);
429
430 for (uint8_t qp = 0; qp < HUC_QP_RANGE; qp++)
431 {
432 ENCODE_CHK_STATUS_RETURN(SetHevcDepthBasedLambda(m_basicFeature->m_hevcSeqParams, m_basicFeature->m_hevcPicParams,
433 qp, m_sadLambdaArray[qp], m_rdLambdaArray[qp]));
434 }
435
436 if (m_basicFeature->m_hevcPicParams->CodingType == I_TYPE)
437 {
438 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_2, brcSettings.HevcVdencBrcSettings_0.size, m_rdLambdaArray, brcSettings.HevcVdencBrcSettings_0.size);
439 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_0, brcSettings.HevcVdencBrcSettings_2.size, m_sadLambdaArray, brcSettings.HevcVdencBrcSettings_2.size);
440 }
441 else
442 {
443 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_3, brcSettings.HevcVdencBrcSettings_1.size, m_rdLambdaArray, brcSettings.HevcVdencBrcSettings_1.size);
444 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_1, brcSettings.HevcVdencBrcSettings_3.size, m_sadLambdaArray, brcSettings.HevcVdencBrcSettings_3.size);
445 }
446 }
447 else
448 {
449 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_2, brcSettings.HevcVdencBrcSettings_0.size, brcSettings.HevcVdencBrcSettings_0.data, brcSettings.HevcVdencBrcSettings_0.size);
450 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_3, brcSettings.HevcVdencBrcSettings_1.size, brcSettings.HevcVdencBrcSettings_1.data, brcSettings.HevcVdencBrcSettings_1.size);
451
452 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_0, brcSettings.HevcVdencBrcSettings_2.size, brcSettings.HevcVdencBrcSettings_2.data, brcSettings.HevcVdencBrcSettings_2.size);
453 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_1, brcSettings.HevcVdencBrcSettings_3.size, brcSettings.HevcVdencBrcSettings_3.data, brcSettings.HevcVdencBrcSettings_3.size);
454 }
455
456 return MOS_STATUS_SUCCESS;
457 }
458
459 MOS_STATUS HEVCEncodeBRC::SetConstForUpdate(void *params)
460 {
461 ENCODE_FUNC_CALL();
462 ENCODE_CHK_NULL_RETURN(params);
463 auto hucConstData =
464 (VdencHevcHucBrcConstantData *)params;
465
466 auto setting = static_cast<HevcVdencFeatureSettings *>(m_constSettings);
467 ENCODE_CHK_NULL_RETURN(setting);
468
469 auto brcSettings = setting->brcSettings;
470
471 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_4, brcSettings.hucConstantData.size, brcSettings.hucConstantData.data, brcSettings.hucConstantData.size);
472
473 if (m_basicFeature->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
474 {
475 const int numEstrateThreshlds = 7;
476
477 for (int i = 0; i < numEstrateThreshlds + 1; i++)
478 {
479 for (uint32_t j = 0; j < brcSettings.numDevThreshlds + 1; j++)
480 {
481 hucConstData->VdencHevcHucBrcConstantData_5[(numEstrateThreshlds + 1)*j + i] = *brcSettings.HevcVdencBrcSettings_4[j][i];
482 hucConstData->VdencHevcHucBrcConstantData_6[(numEstrateThreshlds + 1)*j + i] = *brcSettings.HevcVdencBrcSettings_5[j][i];
483 hucConstData->VdencHevcHucBrcConstantData_7[(numEstrateThreshlds + 1)*j + i] = *brcSettings.HevcVdencBrcSettings_6[j][i];
484 }
485 }
486 }
487
488 // ModeCosts depends on frame type
489 if (m_basicFeature->m_pictureCodingType == I_TYPE)
490 {
491 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_8, brcSettings.HevcVdencBrcSettings_7.size, brcSettings.HevcVdencBrcSettings_7.data, brcSettings.HevcVdencBrcSettings_7.size);
492 }
493 else
494 {
495 MOS_SecureMemcpy(hucConstData->VdencHevcHucBrcConstantData_8, brcSettings.HevcVdencBrcSettings_8.size, brcSettings.HevcVdencBrcSettings_8.data, brcSettings.HevcVdencBrcSettings_8.size);
496 }
497
498 return MOS_STATUS_SUCCESS;
499 }
500
501 MOS_STATUS HEVCEncodeBRC::SetDmemForInit(void *params)
502 {
503 ENCODE_FUNC_CALL();
504 ENCODE_CHK_NULL_RETURN(params);
505 auto hucVdencBrcInitDmem =
506 (VdencHevcHucBrcInitDmem *)params;
507
508 auto setting = static_cast<HevcVdencFeatureSettings *>(m_constSettings);
509 ENCODE_CHK_NULL_RETURN(setting);
510
511 auto brcSettings = setting->brcSettings;
512
513 hucVdencBrcInitDmem->TargetBitrate_U32 = m_basicFeature->m_hevcSeqParams->TargetBitRate * m_brc_kbps;
514 hucVdencBrcInitDmem->MaxRate_U32 = m_basicFeature->m_hevcSeqParams->MaxBitRate * m_brc_kbps;
515
516 if (hucVdencBrcInitDmem->LowDelayMode_U8 = (m_basicFeature->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW))
517 {
518 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshPB0_S8, 8 * sizeof(int8_t), brcSettings.lowdelayDevThreshPB.data, 8 * sizeof(int8_t));
519 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshVBR0_S8, 8 * sizeof(int8_t), brcSettings.lowdelayDevThreshVBR.data, 8 * sizeof(int8_t));
520 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshI0_S8, 8 * sizeof(int8_t), brcSettings.lowdelayDevThreshI.data, 8 * sizeof(int8_t));
521 }
522 else
523 {
524 int8_t DevThreshPB0_S8[8] = {};
525 int8_t DevThreshVBR0_S8[8] = {};
526 int8_t DevThreshI0_S8[8] = {};
527
528 uint64_t inputbitsperframe = uint64_t(hucVdencBrcInitDmem->MaxRate_U32*100. / (hucVdencBrcInitDmem->FrameRateM_U32 * 100.0 / hucVdencBrcInitDmem->FrameRateD_U32));
529 if (m_brcEnabled && (m_rcMode != RATECONTROL_ICQ) && !hucVdencBrcInitDmem->BufSize_U32)
530 {
531 ENCODE_ASSERTMESSAGE("VBV BufSize should not be 0 for BRC case\n");
532 return MOS_STATUS_INVALID_PARAMETER;
533 }
534
535 uint64_t vbvsz = hucVdencBrcInitDmem->BufSize_U32;
536 double bps_ratio = inputbitsperframe / (vbvsz / brcSettings.devStdFPS);
537 if (bps_ratio < brcSettings.bpsRatioLow) bps_ratio = brcSettings.bpsRatioLow;
538 if (bps_ratio > brcSettings.bpsRatioHigh) bps_ratio = brcSettings.bpsRatioHigh;
539
540 auto devThreshIFPNEG = (double *)brcSettings.devThreshIFPNEG.data;
541 auto devThreshPBFPNEG = (double *)brcSettings.devThreshPBFPNEG.data;
542 auto devThreshIFPPOS = (double *)brcSettings.devThreshIFPPOS.data;
543 auto devThreshPBFPPOS = (double *)brcSettings.devThreshPBFPPOS.data;
544 auto devThreshVBRPOS = (double *)brcSettings.devThreshVBRPOS.data;
545 auto devThreshVBRNEG = (double *)brcSettings.devThreshVBRNEG.data;
546
547 for (uint32_t i = 0; i < brcSettings.numDevThreshlds / 2; i++) {
548 DevThreshPB0_S8[i] = (signed char)(brcSettings.negMultPB*pow(devThreshPBFPNEG[i], bps_ratio));
549 DevThreshPB0_S8[i + brcSettings.numDevThreshlds / 2] = (signed char)(brcSettings.postMultPB*pow(devThreshPBFPPOS[i], bps_ratio));
550
551 DevThreshI0_S8[i] = (signed char)(brcSettings.negMultPB*pow(devThreshIFPNEG[i], bps_ratio));
552 DevThreshI0_S8[i + brcSettings.numDevThreshlds / 2] = (signed char)(brcSettings.postMultPB*pow(devThreshIFPPOS[i], bps_ratio));
553
554 DevThreshVBR0_S8[i] = (signed char)(brcSettings.negMultPB*pow(devThreshVBRNEG[i], bps_ratio));
555 DevThreshVBR0_S8[i + brcSettings.numDevThreshlds / 2] = (signed char)(brcSettings.posMultVBR*pow(devThreshVBRPOS[i], bps_ratio));
556 }
557
558 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshPB0_S8, 8 * sizeof(int8_t), (void*)DevThreshPB0_S8, 8 * sizeof(int8_t));
559 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshVBR0_S8, 8 * sizeof(int8_t), (void*)DevThreshVBR0_S8, 8 * sizeof(int8_t));
560 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshI0_S8, 8 * sizeof(int8_t), (void*)DevThreshI0_S8, 8 * sizeof(int8_t));
561 }
562
563 MOS_SecureMemcpy(hucVdencBrcInitDmem->InstRateThreshP0_S8, 4 * sizeof(int8_t), brcSettings.instRateThreshP0.data, 4 * sizeof(int8_t));
564 MOS_SecureMemcpy(hucVdencBrcInitDmem->InstRateThreshB0_S8, 4 * sizeof(int8_t), brcSettings.instRateThreshB0.data, 4 * sizeof(int8_t));
565 MOS_SecureMemcpy(hucVdencBrcInitDmem->InstRateThreshI0_S8, 4 * sizeof(int8_t), brcSettings.instRateThreshI0.data, 4 * sizeof(int8_t));
566
567 hucVdencBrcInitDmem->TopFrmSzThrForAdapt2Pass_U8 = brcSettings.topFrmSzThrForAdapt2Pass_U8;
568 hucVdencBrcInitDmem->BotFrmSzThrForAdapt2Pass_U8 = brcSettings.botFrmSzThrForAdapt2Pass_U8;
569
570 hucVdencBrcInitDmem->TopQPDeltaThrForAdapt2Pass_U8 = brcSettings.topQPDeltaThrForAdapt2Pass_U8;
571 hucVdencBrcInitDmem->BotQPDeltaThrForAdapt2Pass_U8 = brcSettings.botQPDeltaThrForAdapt2Pass_U8;
572
573 MOS_SecureMemcpy(hucVdencBrcInitDmem->EstRateThreshP0_U8, 7 * sizeof(uint8_t), brcSettings.estRateThreshP0.data, 7 * sizeof(uint8_t));
574 MOS_SecureMemcpy(hucVdencBrcInitDmem->EstRateThreshB0_U8, 7 * sizeof(uint8_t), brcSettings.estRateThreshB0.data, 7 * sizeof(uint8_t));
575 MOS_SecureMemcpy(hucVdencBrcInitDmem->EstRateThreshI0_U8, 7 * sizeof(uint8_t), brcSettings.estRateThreshI0.data, 7 * sizeof(uint8_t));
576
577 if (m_brcEnabled)
578 {
579 ENCODE_CHK_STATUS_RETURN(SetBrcSettings(hucVdencBrcInitDmem));
580 }
581 else if (m_hevcVDEncAcqpEnabled)
582 {
583 ENCODE_CHK_STATUS_RETURN(SetAcqpSettings(hucVdencBrcInitDmem));
584 }
585
586 return MOS_STATUS_SUCCESS;
587 }
588
589 MOS_STATUS HEVCEncodeBRC::SetVdencBatchBufferState(
590 const uint32_t currRecycledBufIdx,
591 const uint32_t slcIdx,
592 PMHW_BATCH_BUFFER &vdencBatchBuffer,
593 bool & vdencHucUsed)
594 {
595 ENCODE_FUNC_CALL();
596
597 vdencHucUsed = m_vdencHucUsed;
598 vdencBatchBuffer = &m_vdenc2ndLevelBatchBuffer[currRecycledBufIdx];
599
600 vdencBatchBuffer->dwOffset =
601 m_hwInterface->m_vdencBatchBuffer1stGroupSize + m_hwInterface->m_vdencBatchBuffer2ndGroupSize;
602
603 auto basicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
604 ENCODE_CHK_NULL_RETURN(basicFeature);
605
606 for (uint32_t j = 0; j < slcIdx; j++)
607 {
608 vdencBatchBuffer->dwOffset +=
609 (m_hwInterface->m_vdencBatchBufferPerSliceConstSize + basicFeature->m_vdencBatchBufferPerSliceVarSize[j]);
610 }
611
612 return MOS_STATUS_SUCCESS;
613 }
614
615 MOS_STATUS HEVCEncodeBRC::SetSequenceStructs()
616 {
617 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
618
619 ENCODE_FUNC_CALL();
620
621 m_brcInit = m_basicFeature->m_resolutionChanged;
622
623 m_brcEnabled = IsRateControlBrc(m_basicFeature->m_hevcSeqParams->RateControlMethod);
624
625 m_rcMode = m_brcEnabled ? m_basicFeature->m_hevcSeqParams->RateControlMethod : 0;
626
627 SetLcuBrc();
628
629 if (m_rcMode == RATECONTROL_ICQ || m_rcMode == RATECONTROL_QVBR)
630 {
631 if (m_basicFeature->m_hevcSeqParams->ICQQualityFactor < CODECHAL_ENCODE_HEVC_MIN_ICQ_QUALITYFACTOR ||
632 m_basicFeature->m_hevcSeqParams->ICQQualityFactor > CODECHAL_ENCODE_HEVC_MAX_ICQ_QUALITYFACTOR)
633 {
634 ENCODE_ASSERTMESSAGE("Invalid ICQ Quality Factor input (%d)\n", m_basicFeature->m_hevcSeqParams->ICQQualityFactor);
635 eStatus = MOS_STATUS_INVALID_PARAMETER;
636 return eStatus;
637 }
638 }
639
640 m_brcReset = m_basicFeature->m_hevcSeqParams->bResetBRC;
641
642 if (m_brcReset &&
643 (!m_brcEnabled ||
644 m_rcMode == RATECONTROL_ICQ))
645 {
646 ENCODE_ASSERTMESSAGE("BRC Reset cannot be trigerred in CQP/ICQ modes - invalid BRC parameters.");
647 m_brcReset = false;
648 }
649
650 // ACQP is also considered as BRC (special version of ICQ)
651 if (m_brcEnabled)
652 {
653 m_vdencBrcEnabled = true;
654 m_hevcVDEncAcqpEnabled = false; // when BRC is enabled, ACQP has to be turned off
655 }
656
657 m_vdencHucUsed = m_hevcVDEncAcqpEnabled || m_vdencBrcEnabled;
658
659 // Check VBVBufferSize
660 if (m_brcEnabled)
661 {
662 if (m_basicFeature->m_hevcSeqParams->VBVBufferSizeInBit < m_basicFeature->m_hevcSeqParams->InitVBVBufferFullnessInBit)
663 {
664 ENCODE_NORMALMESSAGE(
665 "VBVBufferSizeInBit is less than InitVBVBufferFullnessInBit, \
666 min(VBVBufferSizeInBit, InitVBVBufferFullnessInBit) will set to \
667 hucVdencBrcInitDmem->InitBufFull_U32 and hucVdencBrcUpdateDmem->TARGETSIZE_U32(except Low Delay BRC).\n");
668 }
669 }
670
671 return eStatus;
672 }
673
674 MOS_STATUS HEVCEncodeBRC::FreeBrcResources()
675 {
676 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
677
678 ENCODE_FUNC_CALL();
679 ENCODE_CHK_NULL_RETURN(m_hwInterface);
680
681 for (auto j = 0; j < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; j++)
682 {
683 eStatus = Mhw_FreeBb(m_hwInterface->GetOsInterface(), &m_vdenc2ndLevelBatchBuffer[j], nullptr);
684 ENCODE_ASSERT(eStatus == MOS_STATUS_SUCCESS);
685 }
686
687 if (m_rdLambdaArray)
688 {
689 MOS_DeleteArray(m_rdLambdaArray);
690 }
691 if (m_sadLambdaArray)
692 {
693 MOS_DeleteArray(m_sadLambdaArray);
694 }
695
696 return eStatus;
697 }
698
699 MOS_STATUS HEVCEncodeBRC::SetBrcSettings(void *params)
700 {
701 ENCODE_FUNC_CALL();
702 ENCODE_CHK_NULL_RETURN(params);
703 auto hucVdencBrcInitDmem =
704 (VdencHevcHucBrcInitDmem *)params;
705
706 switch (m_rcMode)
707 {
708 case RATECONTROL_ICQ:
709 hucVdencBrcInitDmem->BRCFlag = 0;
710 hucVdencBrcInitDmem->ACQP_U32 = m_basicFeature->m_hevcSeqParams->ICQQualityFactor;
711 break;
712 case RATECONTROL_CBR:
713 hucVdencBrcInitDmem->BRCFlag = 1;
714 break;
715 case RATECONTROL_VBR:
716 hucVdencBrcInitDmem->BRCFlag = 2;
717 hucVdencBrcInitDmem->ACQP_U32 = 0;
718 break;
719 case RATECONTROL_VCM:
720 hucVdencBrcInitDmem->BRCFlag = 3;
721 break;
722 case RATECONTROL_QVBR:
723 hucVdencBrcInitDmem->BRCFlag = 2;
724 hucVdencBrcInitDmem->ACQP_U32 = m_basicFeature->m_hevcSeqParams->ICQQualityFactor;
725 break;
726 default:
727 break;
728 }
729
730 // Low Delay BRC
731 if (m_basicFeature->m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
732 {
733 hucVdencBrcInitDmem->BRCFlag = 4;
734 }
735
736 switch (m_basicFeature->m_hevcSeqParams->MBBRC)
737 {
738 case mbBrcInternal:
739 case mbBrcEnabled:
740 hucVdencBrcInitDmem->CuQpCtrl_U8 = 3;
741 break;
742 case mbBrcDisabled:
743 hucVdencBrcInitDmem->CuQpCtrl_U8 = 0;
744 break;
745 default:
746 break;
747 }
748
749 // initQPIP, initQPB values will be used for BRC in the future
750 int32_t initQPIP = 0, initQPB = 0;
751 ComputeVDEncInitQP(initQPIP, initQPB);
752 hucVdencBrcInitDmem->InitQPIP_U8 = (uint8_t)initQPIP;
753 hucVdencBrcInitDmem->InitQPB_U8 = (uint8_t)initQPB;
754
755 return MOS_STATUS_SUCCESS;
756 }
757
758 MOS_STATUS HEVCEncodeBRC::SetAcqpSettings(void *params)
759 {
760 ENCODE_FUNC_CALL();
761 ENCODE_CHK_NULL_RETURN(params);
762 auto hucVdencBrcInitDmem =
763 (VdencHevcHucBrcInitDmem *)params;
764
765 hucVdencBrcInitDmem->BRCFlag = 0;
766
767 // 0=No CUQP; 1=CUQP for I-frame; 2=CUQP for P/B-frame
768 // bit operation, bit 1 for I-frame, bit 2 for P/B frame
769 // In VDENC mode, the field "Cu_Qp_Delta_Enabled_Flag" should always be set to 1.
770 if (m_basicFeature->m_hevcSeqParams->QpAdjustment)
771 {
772 hucVdencBrcInitDmem->CuQpCtrl_U8 = 3; // wPictureCodingType I:0, P:1, B:2
773 }
774 else
775 {
776 hucVdencBrcInitDmem->CuQpCtrl_U8 = 0; // wPictureCodingType I:0, P:1, B:2
777 }
778
779 hucVdencBrcInitDmem->InitQPIP_U8 = m_basicFeature->m_hevcPicParams->QpY + m_basicFeature->m_hevcSliceParams->slice_qp_delta;
780 hucVdencBrcInitDmem->InitQPB_U8 = m_basicFeature->m_hevcPicParams->QpY + m_basicFeature->m_hevcSliceParams->slice_qp_delta;
781
782 return MOS_STATUS_SUCCESS;
783 }
784
785 void HEVCEncodeBRC::ComputeVDEncInitQP(int32_t& initQPIP, int32_t& initQPB)
786 {
787 ENCODE_FUNC_CALL();
788
789 const float x0 = 0, y0 = 1.19f, x1 = 1.75f, y1 = 1.75f;
790 uint32_t frameSize = ((m_basicFeature->m_frameWidth * m_basicFeature->m_frameHeight * 3) >> 1);
791
792 initQPIP = (int)(1. / 1.2 * pow(10.0, (log10(frameSize * 2. / 3. * ((float)m_basicFeature->m_hevcSeqParams->FrameRate.Numerator / ((float)m_basicFeature->m_hevcSeqParams->FrameRate.Denominator * (float)m_basicFeature->m_hevcSeqParams->TargetBitRate * m_brc_kbps))) - x0) * (y1 - y0) / (x1 - x0) + y0) + 0.5);
793
794 initQPIP += 2;
795
796 int32_t gopP = (m_basicFeature->m_hevcSeqParams->GopRefDist) ? ((m_basicFeature->m_hevcSeqParams->GopPicSize - 1) / m_basicFeature->m_hevcSeqParams->GopRefDist) : 0;
797 int32_t gopB = m_basicFeature->m_hevcSeqParams->GopPicSize - 1 - gopP;
798 int32_t gopB1 = 0;
799 int32_t gopB2 = 0;
800 int32_t gopSize = 1 + gopP + gopB + gopB1 + gopB2;
801
802 if (gopSize == 1)
803 {
804 initQPIP += 12;
805 }
806 else if (gopSize < 15)
807 {
808 initQPIP += ((14 - gopSize) >> 1);
809 }
810
811 initQPIP = CodecHal_Clip3((int32_t)m_basicFeature->m_hevcPicParams->BRCMinQp, (int32_t)m_basicFeature->m_hevcPicParams->BRCMaxQp, initQPIP);
812 initQPIP--;
813
814 if (initQPIP < 0)
815 {
816 initQPIP = 1;
817 }
818
819 initQPB = ((initQPIP + initQPIP) * 563 >> 10) + 1;
820 initQPB = CodecHal_Clip3((int32_t)m_basicFeature->m_hevcPicParams->BRCMinQp, (int32_t)m_basicFeature->m_hevcPicParams->BRCMaxQp, initQPB);
821
822 if (gopSize > 300) //if intra frame is not inserted frequently
823 {
824 initQPIP -= 8;
825 initQPB -= 8;
826 }
827 else
828 {
829 initQPIP -= 2;
830 initQPB -= 2;
831 }
832
833 initQPIP = CodecHal_Clip3((int32_t)m_basicFeature->m_hevcPicParams->BRCMinQp, (int32_t)m_basicFeature->m_hevcPicParams->BRCMaxQp, initQPIP);
834 initQPB = CodecHal_Clip3((int32_t)m_basicFeature->m_hevcPicParams->BRCMinQp, (int32_t)m_basicFeature->m_hevcPicParams->BRCMaxQp, initQPB);
835 }
836
837 void HEVCEncodeBRC::SetLcuBrc()
838 {
839 ENCODE_FUNC_CALL();
840
841 if (m_brcEnabled)
842 {
843 switch (m_basicFeature->m_hevcSeqParams->MBBRC)
844 {
845 case mbBrcInternal:
846 m_lcuBrcEnabled = (m_basicFeature->m_hevcSeqParams->TargetUsage == 1);
847 break;
848 case mbBrcDisabled:
849 m_lcuBrcEnabled = false;
850 break;
851 case mbBrcEnabled:
852 m_lcuBrcEnabled = true;
853 break;
854 }
855
856 if (m_rcMode == RATECONTROL_ICQ ||
857 m_rcMode == RATECONTROL_QVBR ||
858 m_basicFeature->m_hevcPicParams->NumROI)
859 {
860 // ICQ or ROI must result in LCU-based BRC to be enabled.
861 m_lcuBrcEnabled = true;
862 }
863 }
864
865 if (m_rcMode == RATECONTROL_VCM && m_lcuBrcEnabled)
866 {
867 m_lcuBrcEnabled = false; // when VCM is enabled, only frame-based BRC
868 }
869 }
870
871 MOS_STATUS HEVCEncodeBRC::SetReadBrcPakStatsParams(
872 uint8_t ucPass,
873 uint32_t offset,
874 PMOS_RESOURCE osResource,
875 EncodeReadBrcPakStatsParams &readBrcPakStatsParams)
876 {
877 ENCODE_FUNC_CALL();
878
879 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
880
881 readBrcPakStatsParams.pHwInterface = m_hwInterface;
882 readBrcPakStatsParams.presBrcPakStatisticBuffer = m_vdencBrcBuffers.resBrcPakStatisticBuffer[m_vdencBrcBuffers.currBrcPakStasIdxForWrite];
883 readBrcPakStatsParams.presStatusBuffer = osResource;
884 readBrcPakStatsParams.dwStatusBufNumPassesOffset = offset;
885 readBrcPakStatsParams.ucPass = ucPass;
886
887 return eStatus;
888 }
889
890 MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, HEVCEncodeBRC)
891 {
892 ENCODE_FUNC_CALL();
893 params.frameStatisticsStreamOut |= m_hevcVDEncAcqpEnabled || m_vdencBrcEnabled;
894
895 return MOS_STATUS_SUCCESS;
896 }
897
898 MHW_SETPAR_DECL_SRC(VDENC_CMD2, HEVCEncodeBRC)
899 {
900 ENCODE_FUNC_CALL();
901 auto basicFeature = dynamic_cast<HevcBasicFeature *>(m_basicFeature);
902 ENCODE_CHK_NULL_RETURN(basicFeature);
903
904 bool useDefaultQpDeltas = (m_hevcVDEncAcqpEnabled && basicFeature->m_hevcSeqParams->QpAdjustment) ||
905 (m_brcEnabled && basicFeature->m_hevcSeqParams->MBBRC != 2 /*mbBrcDisabled*/);
906
907 if (useDefaultQpDeltas)
908 {
909 #if !(_MEDIA_RESERVED)
910 params.extSettings.emplace_back(
911 [this, basicFeature](uint32_t *data) {
912 data[13] |= 0xf0120000;
913 if (basicFeature->m_hevcPicParams->CodingType == I_TYPE)
914 {
915 data[14] |= 0x000021db;
916 data[16] |= 0x00010000;
917 }
918 else
919 {
920 data[14] |= 0x000021ed;
921 data[16] |= 0xd0010000;
922 data[18] |= 0x0060010f;
923 data[19] |= 0x000000c0;
924 }
925 return MOS_STATUS_SUCCESS;
926 });
927 #else
928 params.vdencCmd2Par44[0] = 2;
929 params.vdencCmd2Par44[1] = 1;
930 params.vdencCmd2Par44[2] = 0;
931 params.vdencCmd2Par44[3] = -1;
932 if (basicFeature->m_hevcPicParams->CodingType == I_TYPE)
933 {
934 params.vdencCmd2Par45[0] = -5;
935 params.vdencCmd2Par45[1] = -3;
936 params.vdencCmd2Par45[2] = 1;
937 params.vdencCmd2Par45[3] = 2;
938 params.vdencCmd2Par47 = 1;
939 params.vdencCmd2Par48 = 0;
940 params.vdencCmd2Par50 = 0;
941 params.vdencCmd2Par52[0] = 0;
942 params.vdencCmd2Par52[1] = 0;
943 params.vdencCmd2Par52[2] = 0;
944 params.vdencCmd2Par53[0] = 0;
945 params.vdencCmd2Par53[1] = 0;
946 }
947 else
948 {
949 params.vdencCmd2Par45[0] = -3;
950 params.vdencCmd2Par45[1] = -2;
951 params.vdencCmd2Par45[2] = 1;
952 params.vdencCmd2Par45[3] = 2;
953 params.vdencCmd2Par47 = 1;
954 params.vdencCmd2Par48 = 0;
955 params.vdencCmd2Par50 = -3;
956 params.vdencCmd2Par52[0] = -1;
957 params.vdencCmd2Par52[1] = 0;
958 params.vdencCmd2Par52[2] = 1;
959 params.vdencCmd2Par53[0] = 96;
960 params.vdencCmd2Par53[1] = 192;
961 }
962 #endif // !(_MEDIA_RESERVED)
963 }
964
965 return MOS_STATUS_SUCCESS;
966 }
967
968 MHW_SETPAR_DECL_SRC(HCP_PIPE_MODE_SELECT, HEVCEncodeBRC)
969 {
970 ENCODE_FUNC_CALL();
971
972 params.bAdvancedRateControlEnable = m_brcEnabled;
973 params.bBRCEnabled = m_hevcVDEncAcqpEnabled || m_vdencBrcEnabled;
974
975 return MOS_STATUS_SUCCESS;
976 }
977
978 MHW_SETPAR_DECL_SRC(HUC_VIRTUAL_ADDR_STATE, HEVCEncodeBRC)
979 {
980 ENCODE_FUNC_CALL();
981
982 if (params.function == BRC_UPDATE)
983 {
984 params.regionParams[0].presRegion = m_basicFeature->m_recycleBuf->GetBuffer(VdencBRCHistoryBuffer, 0); // Region 0 - History Buffer (Input/Output)
985 params.regionParams[0].isWritable = true;
986
987 params.regionParams[5].presRegion = const_cast<MOS_RESOURCE*>(&m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].OsResource); // Region 5 - Output SLB Buffer (Output)
988 params.regionParams[5].isWritable = true;
989
990 // region 15 always in clear
991 params.regionParams[15].presRegion = m_basicFeature->m_recycleBuf->GetBuffer(VdencBrcDebugBuffer, 0); // Region 15 - Debug Buffer (Output)
992 params.regionParams[15].isWritable = true;
993 }
994
995 return MOS_STATUS_SUCCESS;
996 }
997
998 MOS_STATUS HEVCEncodeBRC::SetCurrRecycledBufIdx(const uint8_t index)
999 {
1000 ENCODE_FUNC_CALL();
1001
1002 m_currRecycledBufIdx = index;
1003 return MOS_STATUS_SUCCESS;
1004 }
1005
1006 } // namespace encode