| 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 |