1 /*
2 * Copyright (c) 2019-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_basic_feature.cpp
24 //! \brief Defines the common interface for encode av1 parameter
25 //!
26
27 #include "encode_av1_basic_feature.h"
28 #include "encode_utils.h"
29 #include "encode_allocator.h"
30 #include "encode_av1_vdenc_const_settings.h"
31 #include "mos_solo_generic.h"
32
33 namespace encode
34 {
Init(void * setting)35 MOS_STATUS Av1BasicFeature::Init(void *setting)
36 {
37 ENCODE_FUNC_CALL();
38 ENCODE_CHK_NULL_RETURN(setting);
39
40 EncodeBasicFeature::Init(setting);
41 CodechalSetting *codecSettings = (CodechalSetting*)setting;
42
43 ENCODE_CHK_STATUS_RETURN(m_ref.Init(this));
44
45 MEDIA_WA_TABLE* waTable = GetWaTable();
46 ENCODE_CHK_NULL_RETURN(waTable);
47
48 MediaUserSetting::Value outValue;
49
50 #if (_DEBUG || _RELEASE_INTERNAL)
51 ReadUserSettingForDebug(
52 m_userSettingPtr,
53 outValue,
54 "AV1 Enable SW Back Annotation",
55 MediaUserSetting::Group::Sequence);
56 m_enableSWBackAnnotation = outValue.Get<bool>();
57
58 ReadUserSettingForDebug(
59 m_userSettingPtr,
60 outValue,
61 "AV1 Enable SW Stitching",
62 MediaUserSetting::Group::Sequence,
63 m_osInterface->pOsContext);
64 m_enableSWStitching = outValue.Get<bool>();
65 m_enableTileStitchByHW = !m_enableSWStitching;
66
67 ReadUserSettingForDebug(
68 m_userSettingPtr,
69 outValue,
70 "Encode Enable NonDefault Mapping",
71 MediaUserSetting::Group::Sequence);
72 m_enableNonDefaultMapping = outValue.Get<bool>();
73 #endif
74
75 if (MEDIA_IS_WA(waTable, WaEnableOnlyASteppingFeatures))
76 {
77 m_enableNonDefaultMapping = false;
78 }
79
80 #if (_DEBUG || _RELEASE_INTERNAL)
81 ReadUserSettingForDebug(
82 m_userSettingPtr,
83 outValue,
84 "AV1 Encode Adaptive Rounding Enable",
85 MediaUserSetting::Group::Sequence);
86 bool adaptiveRounding = outValue.Get<bool>();
87 if (adaptiveRounding)
88 m_roundingMethod = RoundingMethod::adaptiveRounding;
89 #endif
90 return MOS_STATUS_SUCCESS;
91 }
92
CheckLrParams(const CODEC_AV1_ENCODE_PICTURE_PARAMS & m_av1PicParams)93 static MOS_STATUS CheckLrParams(const CODEC_AV1_ENCODE_PICTURE_PARAMS &m_av1PicParams)
94 {
95 auto lr = m_av1PicParams.LoopRestorationFlags.fields;
96 if (lr.cbframe_restoration_type || lr.crframe_restoration_type || lr.yframe_restoration_type)
97 {
98 // Check whether coding size for Luma is 64x64, and Chroma's coding size is half of Luma's
99 if ((lr.lr_unit_shift != 0) || (lr.lr_uv_shift != 1))
100 {
101 ENCODE_ASSERTMESSAGE("Invalid Coding Size");
102 return MOS_STATUS_INVALID_PARAMETER;
103 }
104 }
105 return MOS_STATUS_SUCCESS;
106 }
107
Update(void * params)108 MOS_STATUS Av1BasicFeature::Update(void *params)
109 {
110 ENCODE_FUNC_CALL();
111 ENCODE_CHK_NULL_RETURN(params);
112
113 ENCODE_CHK_STATUS_RETURN(EncodeBasicFeature::Update(params));
114
115 EncoderParamsAV1 *encodeParams = (EncoderParamsAV1 *)params;
116
117 m_av1SeqParams = static_cast<PCODEC_AV1_ENCODE_SEQUENCE_PARAMS>(encodeParams->pSeqParams);
118 ENCODE_CHK_NULL_RETURN(m_av1SeqParams);
119 m_av1PicParams = static_cast<PCODEC_AV1_ENCODE_PICTURE_PARAMS>(encodeParams->pPicParams);
120 ENCODE_CHK_NULL_RETURN(m_av1PicParams);
121
122 m_nalUnitParams = encodeParams->ppNALUnitParams;
123 ENCODE_CHK_NULL_RETURN(m_nalUnitParams);
124 m_NumNalUnits = encodeParams->uiNumNalUnits;
125 if (m_NumNalUnits >= MAX_NUM_OBU_TYPES)
126 {
127 ENCODE_ASSERTMESSAGE("The num of OBU header exceeds the max value.");
128 return MOS_STATUS_USER_CONTROL_MAX_DATA_SIZE;
129 }
130 m_AV1metaDataOffset = encodeParams->AV1metaDataOffset;
131
132 m_appHdrSize = m_appHdrSizeExcludeFrameHdr = 0;
133 m_targetUsage = m_av1SeqParams->TargetUsage;
134 m_currOriginalPic = m_av1PicParams->CurrOriginalPic;
135
136 if (IsRateControlBrc(m_av1SeqParams->RateControlMethod))
137 {
138 // As adaptive rounding need to lock statistics buffer, for CQP case, it was done in driver(check Av1EncodeTile's set VDENC_CMD2)
139 // The lock operation will bring functional issue under "asyc != 1" condition, as well as pref issue need to be considered.
140 // So we choose to by default disable adaptive rounding for CQP, but for BRC, statistics read operation will move to HuC. it's all
141 // fine by nature. so we will open adaptive rounding for BRC all the time as it will bring quality gain.
142 m_roundingMethod = RoundingMethod::adaptiveRounding;
143 }
144
145 for (uint32_t i = 0; i < m_NumNalUnits; i++)
146 {
147 m_appHdrSize += m_nalUnitParams[i]->uiSize;
148 if (IsFrameHeader(*(m_bsBuffer.pBase + m_nalUnitParams[i]->uiOffset)))
149 {
150 break;
151 }
152 m_appHdrSizeExcludeFrameHdr += m_nalUnitParams[i]->uiSize;
153 }
154
155 switch (m_av1PicParams->PicFlags.fields.frame_type)
156 {
157 case keyFrame:
158 case intraOnlyFrame:
159 {
160 m_pictureCodingType = I_TYPE;
161 break;
162 }
163 case interFrame:
164 case sFrame:
165 {
166 m_pictureCodingType = P_TYPE;
167 break;
168 }
169 default:
170 {
171 m_pictureCodingType = 0;
172 break;
173 }
174 }
175
176 uint32_t frameWidth = m_av1PicParams->frame_width_minus1 + 1;
177
178 uint32_t frameHeight = m_av1PicParams->frame_height_minus1 + 1;
179
180 // super block with 128x128 is not supported
181 m_isSb128x128 = false;
182 int32_t mibSizeLog2 = m_isSb128x128 ? av1MaxMibSizeLog2 : av1MinMibSizeLog2;
183 int32_t miCols = MOS_ALIGN_CEIL(frameWidth, 8) >> av1MiSizeLog2;
184 int32_t miRows = MOS_ALIGN_CEIL(frameHeight, 8) >> av1MiSizeLog2;
185
186 m_miCols = MOS_ALIGN_CEIL(miCols, 1 << mibSizeLog2);
187 m_miRows = MOS_ALIGN_CEIL(miRows, 1 << mibSizeLog2);
188
189 m_picWidthInSb = m_miCols >> mibSizeLog2;
190 m_picHeightInSb = m_miRows >> mibSizeLog2;
191
192 // EnableFrameOBU thread safety
193 if (m_av1PicParams->PicFlags.fields.EnableFrameOBU)
194 {
195 m_frameHdrOBUSizeByteOffset = m_av1PicParams->FrameHdrOBUSizeByteOffset;
196 }
197
198 // Only for first frame
199 if (m_frameNum == 0)
200 {
201 m_oriFrameHeight = frameHeight;
202 m_oriFrameWidth = frameWidth;
203 m_resolutionChanged = true;
204 }
205 else
206 {
207 // check if there is a dynamic resolution change
208 if ((m_oriFrameHeight && (m_oriFrameHeight != frameHeight)) ||
209 (m_oriFrameWidth && (m_oriFrameWidth != frameWidth)))
210 {
211 m_resolutionChanged = true;
212 m_oriFrameHeight = frameHeight;
213 m_oriFrameWidth = frameWidth;
214 }
215 else
216 {
217 m_resolutionChanged = false;
218 }
219 }
220
221 if (m_resolutionChanged)
222 {
223 m_picWidthInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_oriFrameWidth);
224 m_picHeightInMb = (uint16_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_oriFrameHeight);
225 m_frameWidth = m_picWidthInMb * CODECHAL_MACROBLOCK_WIDTH;
226 m_frameHeight = m_picHeightInMb * CODECHAL_MACROBLOCK_HEIGHT;
227 ENCODE_CHK_STATUS_RETURN(UpdateTrackedBufferParameters());
228 }
229
230 ENCODE_CHK_STATUS_RETURN(CheckLrParams(*m_av1PicParams));
231
232 m_enableCDEF = !(IsFrameLossless(*m_av1PicParams)
233 || m_av1PicParams->PicFlags.fields.allow_intrabc
234 || !(m_av1SeqParams->CodingToolFlags.fields.enable_cdef));
235
236 // Update reference frames
237 ENCODE_CHK_STATUS_RETURN(m_ref.Update());
238
239 // Reset stream in
240 // N.B. Update for Stream In will be called by features which use it
241 m_streamIn.Reset();
242
243 ENCODE_CHK_STATUS_RETURN(UpdateDefaultCdfTable());
244
245 ENCODE_CHK_STATUS_RETURN(GetTrackedBuffers());
246
247 return MOS_STATUS_SUCCESS;
248 }
249
UpdateTrackedBufferParameters()250 MOS_STATUS Av1BasicFeature::UpdateTrackedBufferParameters()
251 {
252 ENCODE_FUNC_CALL();
253
254 m_trackedBuf->OnSizeChange();
255
256 // The MB code size here, it is from Arch's suggestion
257 const uint32_t numOfCU = MOS_ROUNDUP_DIVIDE(m_frameWidth, 8) * MOS_ROUNDUP_DIVIDE(m_frameHeight, 8);
258
259 m_mbCodeSize = MOS_ALIGN_CEIL((numOfCU * CODECHAL_PAK_OBJ_EACH_CU), CODECHAL_PAGE_SIZE);
260 m_mvDataSize = 0;
261
262 uint32_t downscaledWidthInMb4x =
263 CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_frameWidth / SCALE_FACTOR_4x);
264 uint32_t downscaledHeightInMb4x =
265 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameHeight / SCALE_FACTOR_4x);
266
267 m_downscaledWidth4x =
268 downscaledWidthInMb4x * CODECHAL_MACROBLOCK_WIDTH;
269
270 // Account for field case, offset needs to be 4K aligned if tiled for DI surface state.
271 // Width will be allocated tile Y aligned, so also tile align height.
272 uint32_t downscaledSurfaceHeight4x = ((downscaledHeightInMb4x + 1) >> 1) * CODECHAL_MACROBLOCK_HEIGHT;
273
274 m_downscaledHeight4x = MOS_ALIGN_CEIL(downscaledSurfaceHeight4x, MOS_YTILE_H_ALIGNMENT) << 1;
275
276 MOS_ALLOC_GFXRES_PARAMS allocParams;
277 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
278 allocParams.Type = MOS_GFXRES_BUFFER;
279 allocParams.TileType = MOS_TILE_LINEAR;
280 allocParams.Format = Format_Buffer;
281 allocParams.Flags.bNotLockable = !m_lockableResource;
282
283 uint32_t totalSbPerFrame = m_picWidthInSb * m_picHeightInSb;
284
285 const uint16_t num4x4BlocksIn64x64Sb = 256;
286 const uint16_t num4x4BlocksIn128x128Sb = 1024;
287 const uint32_t sizeOfSegmentIdMap = ((m_isSb128x128) ? num4x4BlocksIn128x128Sb : num4x4BlocksIn64x64Sb) * totalSbPerFrame;
288
289 if (sizeOfSegmentIdMap > 0)
290 {
291 allocParams.dwBytes = sizeOfSegmentIdMap;
292 allocParams.pBufName = "segmentIdStreamOutBuffer";
293 allocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
294
295 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::segmentIdStreamOutBuffer, allocParams));
296 }
297
298 allocParams.dwBytes = MOS_ALIGN_CEIL(m_cdfMaxNumBytes, CODECHAL_PAGE_SIZE);
299 allocParams.pBufName = "bwdAdaptCdfBuffer";
300 allocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
301 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::bwdAdaptCdfBuffer, allocParams));
302
303 uint32_t sizeOfMvTemporalbuffer = CODECHAL_CACHELINE_SIZE * ((m_isSb128x128) ? 16 : 4) * totalSbPerFrame;
304 if (sizeOfMvTemporalbuffer > 0)
305 {
306 allocParams.dwBytes = sizeOfMvTemporalbuffer;
307 allocParams.pBufName = "mvTemporalBuffer";
308 allocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ_WRITE_NOCACHE;
309
310 ENCODE_CHK_STATUS_RETURN(m_trackedBuf->RegisterParam(encode::BufferType::mvTemporalBuffer, allocParams));
311 }
312
313 ENCODE_CHK_STATUS_RETURN(EncodeBasicFeature::UpdateTrackedBufferParameters());
314
315 return MOS_STATUS_SUCCESS;
316 }
317
GetProfileLevelMaxFrameSize()318 uint32_t Av1BasicFeature::GetProfileLevelMaxFrameSize()
319 {
320 ENCODE_FUNC_CALL();
321
322 //TBD
323
324 return MOS_STATUS_SUCCESS;
325 }
326
GetAppHdrSizeInBytes(bool excludeFrameHdr) const327 uint32_t Av1BasicFeature::GetAppHdrSizeInBytes(bool excludeFrameHdr) const
328 {
329 return excludeFrameHdr ? m_appHdrSizeExcludeFrameHdr : m_appHdrSize;
330 }
331
UpdateFormat(void * params)332 MOS_STATUS Av1BasicFeature::UpdateFormat(void *params)
333 {
334 ENCODE_FUNC_CALL();
335 ENCODE_CHK_NULL_RETURN(params);
336 EncoderParams* encodeParams = (EncoderParams*)params;
337
338 PCODEC_VP9_ENCODE_SEQUENCE_PARAMS vp9SeqParams = nullptr;
339 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams = nullptr;
340 PCODEC_AV1_ENCODE_SEQUENCE_PARAMS av1SeqParams = nullptr;
341
342 av1SeqParams = static_cast<PCODEC_AV1_ENCODE_SEQUENCE_PARAMS>(encodeParams->pSeqParams);
343 ENCODE_CHK_NULL_RETURN(av1SeqParams);
344
345 if (m_chromaFormat != AVP_CHROMA_FORMAT_YUV420)
346 {
347 ENCODE_ASSERTMESSAGE("Invalid output chromat format!");
348 return MOS_STATUS_INVALID_PARAMETER;
349 }
350 m_outputChromaFormat = m_chromaFormat;
351
352 // Set surface bit info according to surface format.
353 switch(m_rawSurface.Format)
354 {
355 case Format_P010:
356 case Format_R10G10B10A2:
357 m_is10Bit = true;
358 m_bitDepth = 10;
359 break;
360 case Format_NV12:
361 m_is10Bit = false;
362 m_bitDepth = 8;
363 break;
364 default:
365 m_is10Bit = false;
366 m_bitDepth = 8;
367 break;
368 }
369
370 return MOS_STATUS_SUCCESS;
371 }
372
UpdateDefaultCdfTable()373 MOS_STATUS Av1BasicFeature::UpdateDefaultCdfTable()
374 {
375 ENCODE_FUNC_CALL();
376 ENCODE_CHK_NULL_RETURN(m_av1PicParams);
377
378 uint32_t cdfTableSize = MOS_ALIGN_CEIL(m_cdfMaxNumBytes, CODECHAL_CACHELINE_SIZE);
379
380 if (!m_defaultFcInitialized)
381 {
382 MOS_ALLOC_GFXRES_PARAMS allocParams;
383 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
384 allocParams.Type = MOS_GFXRES_BUFFER;
385 allocParams.TileType = MOS_TILE_LINEAR;
386 allocParams.Format = Format_Buffer;
387 allocParams.dwBytes = cdfTableSize * 4; // totally 4 cdf tables according to spec
388 allocParams.pBufName = "Av1CdfTablesBuffer";
389 allocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ;
390 m_defaultCdfBuffers = m_allocator->AllocateResource(allocParams, true);
391
392 auto data = (uint16_t *)m_allocator->LockResourceForWrite(m_defaultCdfBuffers);
393 ENCODE_CHK_NULL_RETURN(data);
394 for (uint8_t index = 0; index < 4; index++)
395 {
396 ENCODE_CHK_STATUS_RETURN(InitDefaultFrameContextBuffer(data + cdfTableSize * index / sizeof(uint16_t), index));
397 }
398 ENCODE_CHK_STATUS_RETURN(m_allocator->UnLock(m_defaultCdfBuffers));
399
400 if (!IsRateControlBrc(m_av1SeqParams->RateControlMethod))
401 {
402 m_defaultCdfBufferInUse = m_defaultCdfBuffers;
403 }
404 else
405 {
406 allocParams.dwBytes = cdfTableSize;
407 allocParams.pBufName = "ActiveAv1CdfTableBuffer";
408 allocParams.ResUsageType = MOS_HW_RESOURCE_USAGE_ENCODE_INTERNAL_READ;
409 m_defaultCdfBufferInUse = m_allocator->AllocateResource(allocParams, true);
410 m_defaultCdfBufferInUseOffset = 0;
411 }
412
413 m_defaultFcInitialized = true;//set only once, won't set again
414 }
415
416 if (m_av1PicParams->primary_ref_frame == av1PrimaryRefNone && !IsRateControlBrc(m_av1SeqParams->RateControlMethod))
417 {
418 //Calculate the current frame's Coeff CDF Q Context ID, that is the Coeff CDF Buffer index
419 uint32_t curCoeffCdfQCtx = 0;
420 if (m_av1PicParams->base_qindex <= 20) curCoeffCdfQCtx = 0;
421 else if (m_av1PicParams->base_qindex <= 60) curCoeffCdfQCtx = 1;
422 else if (m_av1PicParams->base_qindex <= 120) curCoeffCdfQCtx = 2;
423 else curCoeffCdfQCtx = 3;
424 m_defaultCdfBufferInUseOffset = curCoeffCdfQCtx * cdfTableSize;
425 }
426
427 return MOS_STATUS_SUCCESS;
428 }
429
GetTrackedBuffers()430 MOS_STATUS Av1BasicFeature::GetTrackedBuffers()
431 {
432 ENCODE_FUNC_CALL();
433 ENCODE_CHK_NULL_RETURN(m_trackedBuf);
434 ENCODE_CHK_NULL_RETURN(m_av1PicParams);
435 ENCODE_CHK_NULL_RETURN(m_allocator);
436
437 auto currRefList = m_ref.GetCurrRefList();
438 m_trackedBuf->Acquire(currRefList, false);
439
440 m_resMbCodeBuffer = m_trackedBuf->GetBuffer(BufferType::mbCodedBuffer, m_trackedBuf->GetCurrIndex());
441 ENCODE_CHK_NULL_RETURN(m_resMbCodeBuffer);
442
443 m_4xDSSurface = m_trackedBuf->GetSurface(BufferType::ds4xSurface, m_trackedBuf->GetCurrIndex());
444 ENCODE_CHK_NULL_RETURN(m_4xDSSurface);
445 ENCODE_CHK_STATUS_RETURN(m_allocator->GetSurfaceInfo(m_4xDSSurface));
446
447 m_8xDSSurface = m_trackedBuf->GetSurface(BufferType::ds8xSurface, m_trackedBuf->GetCurrIndex());
448 ENCODE_CHK_NULL_RETURN(m_8xDSSurface);
449 ENCODE_CHK_STATUS_RETURN(m_allocator->GetSurfaceInfo(m_8xDSSurface));
450
451 m_resMvTemporalBuffer = m_trackedBuf->GetBuffer(BufferType::mvTemporalBuffer, m_trackedBuf->GetCurrIndex());
452 ENCODE_CHK_NULL_RETURN(m_resMvTemporalBuffer);
453
454 return MOS_STATUS_SUCCESS;
455 }
456
GetStreamIn()457 Av1StreamIn *Av1BasicFeature::GetStreamIn()
458 {
459 m_streamIn.Init(this, this->m_allocator, this->m_osInterface);
460 return &m_streamIn;
461 }
462
GetSurfaceMmcInfo(PMOS_SURFACE surface,MOS_MEMCOMP_STATE & mmcState,uint32_t & compressionFormat) const463 MOS_STATUS Av1BasicFeature::GetSurfaceMmcInfo(PMOS_SURFACE surface, MOS_MEMCOMP_STATE& mmcState, uint32_t& compressionFormat) const
464 {
465 ENCODE_FUNC_CALL();
466
467 ENCODE_CHK_NULL_RETURN(surface);
468
469 #ifdef _MMC_SUPPORTED
470 ENCODE_CHK_NULL_RETURN(m_mmcState);
471 if (m_mmcState->IsMmcEnabled())
472 {
473 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcState(surface, &mmcState));
474 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcFormat(surface, &compressionFormat));
475 }
476 else
477 {
478 mmcState = MOS_MEMCOMP_DISABLED;
479 }
480 #endif
481
482 return MOS_STATUS_SUCCESS;
483 }
484
InitDefaultFrameContextBuffer(uint16_t * ctxBuffer,uint8_t index,Av1CdfTableSyntaxElement begin,Av1CdfTableSyntaxElement end)485 MOS_STATUS InitDefaultFrameContextBuffer(
486 uint16_t *ctxBuffer,
487 uint8_t index,
488 Av1CdfTableSyntaxElement begin,
489 Av1CdfTableSyntaxElement end)
490 {
491 ENCODE_FUNC_CALL();
492 ENCODE_CHK_NULL_RETURN(ctxBuffer);
493
494 //initialize the layout and default table info for each syntax element
495 struct SyntaxElementCdfTableLayout syntaxElementsLayout[syntaxElementMax] =
496 {
497 //m_entryCountPerCL, m_entryCountTotal, m_startCL, *m_srcInitBuffer
498 //PartI: Intra
499 { 30, 12 , 0 , (uint16_t *)&defaultPartitionCdf8x8[0][0] }, // partition_8x8
500 { 27, 108 , 1 , (uint16_t *)&defaultPartitionCdfNxN[0][0] }, // partition
501 { 28, 28 , 5 , (uint16_t *)&defaultPartitionCdf128x128[0][0] }, // partition_128x128
502 { 32, 3 , 6 , (uint16_t *)&defaultSkipCdfs[0][0] }, // skip
503 { 30, 3 , 7 , (uint16_t *)&defaultDeltaQCdf[0] }, // delta_q
504 { 30, 3 , 8 , (uint16_t *)&defaultDeltaLfCdf[0] }, // delta_lf
505 { 30, 12 , 9 , (uint16_t *)&defaultDeltaLfMultiCdf[0][0] }, // delta_lf_multi
506 { 28, 21 , 10 , (uint16_t *)&defaultSpatialPredSegTreeCdf[0][0] }, // segment_id
507 { 24, 300 , 11 , (uint16_t *)&defaultKfYModeCdf[0][0][0] }, // intra_y_mode
508 { 24, 156 , 24 , (uint16_t *)&defaultUvModeCdf0[0][0] }, // uv_mode_0
509 { 26, 169 , 31 , (uint16_t *)&defaultUvModeCdf1[0][0] }, // uv_mode_1
510 { 32, 21 , 38 , (uint16_t *)&defaultPaletteYModeCdf[0][0][0] }, // palette_y_mode
511 { 32, 2 , 39 , (uint16_t *)&defaultPaletteUvModeCdf[0][0] }, // palette_uv_mode
512 { 30, 42 , 40 , (uint16_t *)&defaultPaletteYSizeCdf[0][0] }, // palette_y_size
513 { 30, 42 , 42 , (uint16_t *)&defaultPaletteUvSizeCdf[0][0] }, // palette_uv_size
514 { 30, 312 , 44 , (uint16_t *)&defaultIntraExtTxCdf1[0][0][0] }, // intra_tx_type_1
515 { 32, 208 , 55 , (uint16_t *)&defaultIntraExtTxCdf2[0][0][0] }, // intra_tx_type_2
516 { 32, 3 , 62 , (uint16_t *)&defaultTxSizeCdf0[0][0] }, // depth_0
517 { 32, 18 , 63 , (uint16_t *)&defaultTxSizeCdf[0][0][0] }, // depth
518 { 28, 7 , 64 , (uint16_t *)&defaultCflSignCdf[0] }, // cfl_joint_sign
519 { 30, 90 , 65 , (uint16_t *)&defaultCflAlphaCdf[0][0] }, // cdf_alpha
520 { 30, 48 , 68 , (uint16_t *)&defaultAngleDeltaCdf[0][0] }, // angle_delta
521 { 32, 5 , 70 , (uint16_t *)&defaultPaletteYColorIndexCdf0[0][0] }, // palette_y_color_idx_0
522 { 32, 10 , 71 , (uint16_t *)&defaultPaletteYColorIndexCdf1[0][0] }, // palette_y_color_idx_1
523 { 30, 15 , 72 , (uint16_t *)&defaultPaletteYColorIndexCdf2[0][0] }, // palette_y_color_idx_2
524 { 32, 20 , 73 , (uint16_t *)&defaultPaletteYColorIndexCdf3[0][0] }, // palette_y_color_idx_3
525 { 30, 25 , 74 , (uint16_t *)&defaultPaletteYColorIndexCdf4[0][0] }, // palette_y_color_idx_4
526 { 30, 30 , 75 , (uint16_t *)&defaultPaletteYColorIndexCdf5[0][0] }, // palette_y_color_idx_5
527 { 28, 35 , 76 , (uint16_t *)&defaultPaletteYColorIndexCdf6[0][0] }, // palette_y_color_idx_6
528 { 32, 5 , 78 , (uint16_t *)&defaultPaletteUvColorIndexCdf0[0][0] }, // palette_uv_color_idx_0
529 { 32, 10 , 79 , (uint16_t *)&defaultPaletteUvColorIndexCdf1[0][0] }, // palette_uv_color_idx_1
530 { 30, 15 , 80 , (uint16_t *)&defaultPaletteUvColorIndexCdf2[0][0] }, // palette_uv_color_idx_2
531 { 32, 20 , 81 , (uint16_t *)&defaultPaletteUvColorIndexCdf3[0][0] }, // palette_uv_color_idx_3
532 { 30, 25 , 82 , (uint16_t *)&defaultPaletteUvColorIndexCdf4[0][0] }, // palette_uv_color_idx_4
533 { 30, 30 , 83 , (uint16_t *)&defaultPaletteUvColorIndexCdf5[0][0] }, // palette_uv_color_idx_5
534 { 28, 35 , 84 , (uint16_t *)&defaultPaletteUvColorIndexCdf6[0][0] }, // palette_uv_color_idx_6
535 //coeff cdfs addressed by index
536 { 32, 65 , 86 , (uint16_t *)&av1DefaultTxbSkipCdfs[index][0][0][0] }, // txb_skip
537 { 32, 16 , 89 , (uint16_t *)&av1DefaultEobMulti16Cdfs[index][0][0][0] }, // eob_pt_0
538 { 30, 20 , 90 , (uint16_t *)&av1DefaultEobMulti32Cdfs[index][0][0][0] }, // eob_pt_1
539 { 30, 24 , 91 , (uint16_t *)&av1DefaultEobMulti64Cdfs[index][0][0][0] }, // eob_pt_2
540 { 28, 28 , 92 , (uint16_t *)&av1DefaultEobMulti128Cdfs[index][0][0][0] }, // eob_pt_3
541 { 32, 32 , 93 , (uint16_t *)&av1DefaultEobMulti256Cdfs[index][0][0][0] }, // eob_pt_4
542 { 27, 36 , 94 , (uint16_t *)&av1DefaultEobMulti512Cdfs[index][0][0][0] }, // eob_pt_5
543 { 30, 40 , 96 , (uint16_t *)&av1DefaultEobMulti1024Cdfs[index][0][0][0] }, // eob_pt_6
544 { 32, 90 , 98 , (uint16_t *)&av1DefaultEobExtraCdfs[index][0][0][0][0] }, // eob_extra
545 { 32, 80 , 101, (uint16_t *)&av1DefaultCoeffBaseEobMultiCdfs[index][0][0][0][0] }, // coeff_base_eob
546 { 30, 1260, 104, (uint16_t *)&av1DefaultCoeffBaseMultiCdfs[index][0][0][0][0] }, // coeff_base
547 { 32, 6 , 146, (uint16_t *)&av1DefaultDcSignCdfs[index][0][0][0] }, // dc_sign
548 { 30, 630 , 147, (uint16_t *)&av1DefaultCoeffLpsMultiCdfs[index][0][0][0][0] }, // coeff_br
549 { 32, 2 , 168, (uint16_t *)&defaultSwitchableRestoreCdf[0] }, // switchable_restore
550 { 32, 1 , 169, (uint16_t *)&defaultWienerRestoreCdf[0] }, // wiener_restore
551 { 32, 1 , 170, (uint16_t *)&defaultSgrprojRestoreCdf[0] }, // sgrproj_restore
552 { 32, 1 , 171, (uint16_t *)&defaultIntrabcCdf[0] }, // use_intrabc
553 { 32, 22 , 172, (uint16_t *)&default_filter_intra_cdfs[0][0] }, // use_filter_intra
554 { 32, 4 , 173, (uint16_t *)&defaultFilterIntraModeCdf[0] }, // filter_intra_mode
555 { 30, 3 , 174, (uint16_t *)&defaultJointCdf[0] }, // dv_joint_type
556 { 32, 2 , 175, (uint16_t *)&defaultSignCdf[0][0] }, // dv_sign
557 { 32, 20 , 176, (uint16_t *)&defaultBitsCdf[0][0][0] }, // dv_sbits
558 { 30, 20 , 177, (uint16_t *)&defaultClassesCdf[0][0] }, // dv_class
559 { 32, 2 , 178, (uint16_t *)&defaultClass0Cdf[0][0] }, // dv_class0
560 { 30, 6 , 179, (uint16_t *)&defaultFpCdf[0][0] }, // dv_fr
561 { 30, 12 , 180, (uint16_t *)&defaultClass0FpCdf[0][0][0] }, // dv_class0_fr
562 { 32, 2 , 181, (uint16_t *)&defaultHpCdf[0][0] }, // dv_hp
563 { 32, 2 , 182, (uint16_t *)&defaultClass0HpCdf[0][0] }, // dv_class0_hp
564 //PartII: Inter
565 { 32, 3 , 183, (uint16_t *)&defaultSkipModeCdfs[0][0] }, // skip_mode
566 { 32, 3 , 184, (uint16_t *)&defaultSegmentPredCdf[0][0] }, // pred_seg_id
567 { 24, 48 , 185, (uint16_t *)&defaultIfYModeCdf[0][0] }, // y_mode
568 { 30, 60 , 187, (uint16_t *)&defaultInterExtTxCdf1[0][0] }, // inter_tx_type_1
569 { 22, 44 , 189, (uint16_t *)&defaultInterExtTxCdf2[0][0] }, // inter_tx_type_2
570 { 32, 4 , 191, (uint16_t *)&defaultInterExtTxCdf3[0][0] }, // inter_tx_type_3
571 { 32, 4 , 192, (uint16_t *)&defaultIntraInterCdf[0][0] }, // is_inter
572 { 32, 21 , 193, (uint16_t *)&defaultTxfmPartitionCdf[0][0] }, // tx_split
573 { 32, 5 , 194, (uint16_t *)&defaultCompInterCdf[0][0] }, // ref_mode
574 { 32, 5 , 195, (uint16_t *)&defaultCompRefTypeCdf[0][0] }, // comp_ref_type
575 { 32, 9 , 196, (uint16_t *)&defaultUniCompRefCdf[0][0][0] }, // unidir_comp_ref
576 { 32, 9 , 197, (uint16_t *)&defaultCompRefCdf[0][0][0] }, // ref_bit
577 { 32, 6 , 198, (uint16_t *)&defaultCompBwdrefCdf[0][0][0] }, // ref_bit_bwd
578 { 32, 18 , 199, (uint16_t *)&defaultSingleRefCdf[0][0][0] }, // single_ref_bit
579 { 28, 56 , 200, (uint16_t *)&defaultInterCompoundModeCdf[0][0] }, // inter_compound_mode
580 { 32, 6 , 202, (uint16_t *)&defaultNewmvCdf[0][0] }, // is_newmv
581 { 32, 2 , 203, (uint16_t *)&defaultZeromvCdf[0][0] }, // is_zeromv
582 { 32, 6 , 204, (uint16_t *)&defaultRefmvCdf[0][0] }, // is_refmv
583 { 30, 3 , 205, (uint16_t *)&defaultJointCdf[0] }, // mv_joint_type
584 { 32, 2 , 206, (uint16_t *)&defaultSignCdf[0][0] }, // mv_sign
585 { 32, 20 , 207, (uint16_t *)&defaultBitsCdf[0][0][0] }, // mv_sbits
586 { 30, 20 , 208, (uint16_t *)&defaultClassesCdf[0][0] }, // mv_class
587 { 32, 2 , 209, (uint16_t *)&defaultClass0Cdf[0][0] }, // mv_class0
588 { 30, 6 , 210, (uint16_t *)&defaultFpCdf[0][0] }, // mv_fr
589 { 30, 12 , 211, (uint16_t *)&defaultClass0FpCdf[0][0][0] }, // mv_class0_fr
590 { 32, 2 , 212, (uint16_t *)&defaultHpCdf[0][0] }, // mv_hp
591 { 32, 2 , 213, (uint16_t *)&defaultClass0HpCdf[0][0] }, // mv_class0_hp
592 { 32, 4 , 214, (uint16_t *)&defaultInterintraCdf[0][0] }, // interintra
593 { 30, 12 , 215, (uint16_t *)&defaultInterintraModeCdf[0][0] }, // interintra_mode
594 { 32, 22 , 216, (uint16_t *)&defaultWedgeInterintraCdf[0][0] }, // use_wedge_interintra
595 { 30, 330 , 217, (uint16_t *)&defaultWedgeIdxCdf[0][0] }, // wedge_index
596 { 32, 3 , 228, (uint16_t *)&defaultDrlCdf[0][0] }, // drl_idx
597 { 32, 22 , 229, (uint16_t *)&defaultObmcCdf[0][0] }, // obmc_motion_mode
598 { 32, 44 , 230, (uint16_t *)&defaultMotionModeCdf[0][0] }, // non_obmc_motion_mode
599 { 32, 6 , 232, (uint16_t *)&defaultCompGroupIdxCdfs[0][0] }, // comp_group_idx
600 { 32, 6 , 233, (uint16_t *)&defaultCompoundIdxCdfs[0][0] }, // compound_idx
601 { 32, 22 , 234, (uint16_t *)&defaultCompoundTypeCdf[0][0] }, // interinter_compound_type
602 { 32, 32 , 235, (uint16_t *)&defaultSwitchableInterpCdf[0][0] }, // switchable_interp
603 };
604
605 for (auto idx = (uint32_t)begin; idx < (uint32_t)end; idx++)
606 {
607 ENCODE_CHK_STATUS_RETURN(SyntaxElementCdfTableInit(
608 ctxBuffer,
609 syntaxElementsLayout[idx]));
610 }
611
612 return MOS_STATUS_SUCCESS;
613 }
614
SyntaxElementCdfTableInit(uint16_t * ctxBuffer,SyntaxElementCdfTableLayout SyntaxElement)615 MOS_STATUS SyntaxElementCdfTableInit(
616 uint16_t *ctxBuffer,
617 SyntaxElementCdfTableLayout SyntaxElement)
618 {
619 ENCODE_CHK_NULL_RETURN(ctxBuffer);
620 ENCODE_CHK_NULL_RETURN(SyntaxElement.m_srcInitBuffer);
621
622 uint16_t entryCountPerCL = SyntaxElement.m_entryCountPerCL; //one entry means one uint16_t value
623 uint16_t entryCountTotal = SyntaxElement.m_entryCountTotal; //total number of entrie for this Syntax element's CDF tables
624 uint16_t startCL = SyntaxElement.m_startCL;
625
626 uint16_t *src = SyntaxElement.m_srcInitBuffer;
627 uint16_t *dst = ctxBuffer + startCL * 32; //one CL equals to 32 uint16_t
628 uint16_t entryCountLeft = entryCountTotal;
629 while (entryCountLeft >= entryCountPerCL)
630 {
631 //copy one CL
632 MOS_SecureMemcpy(dst, entryCountPerCL * sizeof(uint16_t), src, entryCountPerCL * sizeof(uint16_t));
633 entryCountLeft -= entryCountPerCL;
634
635 //go to next CL
636 src += entryCountPerCL;
637 dst += 32;
638 };
639 //copy the remaining which are less than a CL
640 if (entryCountLeft > 0)
641 {
642 MOS_SecureMemcpy(dst, entryCountLeft * sizeof(uint16_t), src, entryCountLeft * sizeof(uint16_t));
643 }
644
645 return MOS_STATUS_SUCCESS;
646 }
647
MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT,Av1BasicFeature)648 MHW_SETPAR_DECL_SRC(VDENC_PIPE_MODE_SELECT, Av1BasicFeature)
649 {
650 params.standardSelect = 3; // av1
651 params.chromaType = m_outputChromaFormat;
652 params.bitDepthMinus8 = m_is10Bit ? 2 : 0;
653 params.wirelessSessionId = 0;
654 params.streamIn = false;
655 params.randomAccess = !m_ref.IsLowDelay();
656
657 params.rgbEncodingMode = m_rgbEncodingEnable;
658 params.bt2020RGB2YUV = m_av1SeqParams->InputColorSpace == ECOLORSPACE_P2020;
659 params.rgbInputStudioRange = params.bt2020RGB2YUV ? m_av1SeqParams->SeqFlags.fields.RGBInputStudioRange : 0;
660 params.convertedYUVStudioRange = params.bt2020RGB2YUV ? m_av1SeqParams->SeqFlags.fields.ConvertedYUVStudioRange : 0;
661 if (m_captureModeEnable)
662 {
663 params.captureMode = 1;
664 params.tailPointerReadFrequency = 0x50;
665 }
666
667 if (m_dualEncEnable)
668 {
669 params.scalabilityMode = true;
670 params.tileBasedReplayMode = true;
671 }
672
673 params.frameStatisticsStreamOut = IsRateControlBrc(m_av1SeqParams->RateControlMethod) || m_roundingMethod == RoundingMethod::adaptiveRounding;
674
675 return MOS_STATUS_SUCCESS;
676 }
677
MHW_SETPAR_DECL_SRC(VDENC_SRC_SURFACE_STATE,Av1BasicFeature)678 MHW_SETPAR_DECL_SRC(VDENC_SRC_SURFACE_STATE, Av1BasicFeature)
679 {
680 params.pitch = m_rawSurfaceToEnc->dwPitch;
681 params.tileType = m_rawSurfaceToEnc->TileType;
682 params.tileModeGmm = m_rawSurfaceToEnc->TileModeGMM;
683 params.format = m_rawSurfaceToEnc->Format;
684 params.gmmTileEn = m_rawSurfaceToEnc->bGMMTileEnabled;
685 params.uOffset = m_rawSurfaceToEnc->YoffsetForUplane;
686 params.vOffset = m_rawSurfaceToEnc->YoffsetForVplane;
687 params.displayFormatSwizzle = m_av1SeqParams->SeqFlags.fields.DisplayFormatSwizzle;
688 params.height = m_oriFrameHeight;
689 params.width = m_oriFrameWidth;
690 params.colorSpaceSelection = (m_av1SeqParams->InputColorSpace == ECOLORSPACE_P709) ? true : false;
691 params.chromaDownsampleFilterControl = 7; // confirmed with arch, this should apply to all platforms
692
693 return MOS_STATUS_SUCCESS;
694 }
695
MHW_SETPAR_DECL_SRC(VDENC_REF_SURFACE_STATE,Av1BasicFeature)696 MHW_SETPAR_DECL_SRC(VDENC_REF_SURFACE_STATE, Av1BasicFeature)
697 {
698 auto surface = &m_reconSurface;
699 if (!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->PicFlags.fields.frame_type))
700 {
701 surface = m_ref.GetEncRefSurface().front();
702 }
703
704 params.pitch = surface->dwPitch;
705 params.tileType = surface->TileType;
706 params.tileModeGmm = surface->TileModeGMM;
707 params.format = surface->Format;
708 params.gmmTileEn = surface->bGMMTileEnabled;
709 params.uOffset = surface->YoffsetForUplane;
710 params.vOffset = surface->YoffsetForVplane;
711 params.height = m_oriFrameHeight;
712 params.width = m_oriFrameWidth;
713
714 // For 10 bit case, app may still allocates NV12 buffer but with doubled width, need to change it to P010
715 if (m_is10Bit && params.format == Format_NV12)
716 {
717 params.format = Format_P010;
718 }
719
720 if (m_reconSurface.Format == Format_Y410 || m_reconSurface.Format == Format_444P || m_reconSurface.Format == Format_AYUV)
721 {
722 if (m_reconSurface.Format == Format_Y410)
723 {
724 params.pitch = m_reconSurface.dwPitch / 2;
725 }
726 else
727 {
728 params.pitch = m_reconSurface.dwPitch / 4;
729 }
730 params.uOffset = MOS_ALIGN_CEIL(m_rawSurfaceToPak->dwHeight, 8);
731 params.vOffset = MOS_ALIGN_CEIL(m_rawSurfaceToPak->dwHeight, 8) << 1;
732 }
733 else if (m_reconSurface.Format == Format_Y216 || m_reconSurface.Format == Format_Y210 || m_reconSurface.Format == Format_YUY2)
734 {
735 params.uOffset = MOS_ALIGN_CEIL(m_rawSurfaceToPak->dwHeight, 8);
736 params.vOffset = MOS_ALIGN_CEIL(m_rawSurfaceToPak->dwHeight, 8);
737 }
738
739 return MOS_STATUS_SUCCESS;
740 }
741
MHW_SETPAR_DECL_SRC(VDENC_DS_REF_SURFACE_STATE,Av1BasicFeature)742 MHW_SETPAR_DECL_SRC(VDENC_DS_REF_SURFACE_STATE, Av1BasicFeature)
743 {
744 auto surface8x = m_8xDSSurface;
745 if (!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->PicFlags.fields.frame_type))
746 {
747 surface8x = m_ref.GetEnc8xRefSurface().front();
748 }
749
750 params.pitchStage1 = surface8x->dwPitch;
751 params.tileTypeStage1 = surface8x->TileType;
752 params.tileModeGmmStage1 = surface8x->TileModeGMM;
753 params.gmmTileEnStage1 = surface8x->bGMMTileEnabled;
754 params.uOffsetStage1 = surface8x->YoffsetForUplane;
755 params.vOffsetStage1 = surface8x->YoffsetForVplane;
756 params.heightStage1 = surface8x->dwHeight;
757 params.widthStage1 = surface8x->dwWidth;
758
759 auto surface4x = m_4xDSSurface;
760 if (!AV1_KEY_OR_INRA_FRAME(m_av1PicParams->PicFlags.fields.frame_type))
761 {
762 surface4x = m_ref.GetEnc4xRefSurface().front();
763 }
764
765 params.pitchStage2 = surface4x->dwPitch;
766 params.tileTypeStage2 = surface4x->TileType;
767 params.tileModeGmmStage2 = surface4x->TileModeGMM;
768 params.gmmTileEnStage2 = surface4x->bGMMTileEnabled;
769 params.uOffsetStage2 = surface4x->YoffsetForUplane;
770 params.vOffsetStage2 = surface4x->YoffsetForVplane;
771 params.heightStage2 = surface4x->dwHeight;
772 params.widthStage2 = surface4x->dwWidth;
773
774 return MOS_STATUS_SUCCESS;
775 }
776
MHW_SETPAR_DECL_SRC(VDENC_PIPE_BUF_ADDR_STATE,Av1BasicFeature)777 MHW_SETPAR_DECL_SRC(VDENC_PIPE_BUF_ADDR_STATE, Av1BasicFeature)
778 {
779 #ifdef _MMC_SUPPORTED
780 ENCODE_CHK_NULL_RETURN(m_mmcState);
781 if (m_mmcState->IsMmcEnabled())
782 {
783 params.mmcEnabled = true;
784 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(m_rawSurfaceToEnc), ¶ms.mmcStateRaw));
785 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcFormat(const_cast<PMOS_SURFACE>(m_rawSurfaceToEnc), ¶ms.compressionFormatRaw));
786 }
787 else
788 {
789 params.mmcEnabled = false;
790 params.mmcStateRaw = MOS_MEMCOMP_DISABLED;
791 params.compressionFormatRaw = GMM_FORMAT_INVALID;
792 }
793 #endif
794
795 params.surfaceRaw = m_rawSurfaceToEnc;
796 params.surfaceDsStage1 = m_8xDSSurface;
797 params.surfaceDsStage2 = m_4xDSSurface;
798 params.pakObjCmdStreamOutBuffer = m_resMbCodeBuffer;
799 params.streamOutBuffer = m_recycleBuf->GetBuffer(VdencStatsBuffer, 0);
800 params.streamOutOffset = 0;
801 params.mfdIntraRowStoreScratchBuffer = m_resMfdIntraRowStoreScratchBuffer;
802
803 // it's better to make m_ref and m_streamIn a feature
804 m_ref.MHW_SETPAR_F(VDENC_PIPE_BUF_ADDR_STATE)(params);
805 m_streamIn.MHW_SETPAR_F(VDENC_PIPE_BUF_ADDR_STATE)(params);
806
807 return MOS_STATUS_SUCCESS;
808 }
809
MHW_SETPAR_DECL_SRC(VDENC_WEIGHTSOFFSETS_STATE,Av1BasicFeature)810 MHW_SETPAR_DECL_SRC(VDENC_WEIGHTSOFFSETS_STATE, Av1BasicFeature)
811 {
812 int8_t size = sizeof(params.weightsLuma) / sizeof(int8_t);
813 memset(params.weightsLuma, 1, size);
814 memset(params.offsetsLuma, 0, size);
815
816 size = sizeof(params.weightsChroma) / sizeof(int8_t);
817 memset(params.weightsChroma, 1, size);
818 memset(params.offsetsChroma, 0, size);
819
820 return MOS_STATUS_SUCCESS;
821 }
822
MHW_SETPAR_DECL_SRC(VDENC_CMD1,Av1BasicFeature)823 MHW_SETPAR_DECL_SRC(VDENC_CMD1, Av1BasicFeature)
824 {
825
826 auto setting = static_cast<Av1VdencFeatureSettings*>(m_constSettings);
827 ENCODE_CHK_NULL_RETURN(setting);
828
829 for (const auto &lambda : setting->vdencCmd1Settings)
830 {
831 ENCODE_CHK_STATUS_RETURN(lambda(params, m_ref.IsLowDelay()));
832 }
833
834 return MOS_STATUS_SUCCESS;
835 }
836
MHW_SETPAR_DECL_SRC(VDENC_HEVC_VP9_TILE_SLICE_STATE,Av1BasicFeature)837 MHW_SETPAR_DECL_SRC(VDENC_HEVC_VP9_TILE_SLICE_STATE, Av1BasicFeature)
838 {
839 params.tileWidth = m_oriFrameWidth;
840 params.tileHeight = m_oriFrameHeight;
841
842 return MOS_STATUS_SUCCESS;
843 }
844
MHW_SETPAR_DECL_SRC(VDENC_CMD2,Av1BasicFeature)845 MHW_SETPAR_DECL_SRC(VDENC_CMD2, Av1BasicFeature)
846 {
847 ENCODE_FUNC_CALL();
848
849 params.width = m_oriFrameWidth;
850 params.height = m_oriFrameHeight;
851 params.qpPrimeYDc = (uint8_t)CodecHal_Clip3(0, 255, m_av1PicParams->base_qindex + m_av1PicParams->y_dc_delta_q);
852 params.qpPrimeYAc = (uint8_t)m_av1PicParams->base_qindex;
853 params.tiling = m_av1PicParams->tile_cols > 1 || m_av1PicParams->tile_rows > 1;
854 params.temporalMvp = false;
855
856 ENCODE_CHK_STATUS_RETURN(m_ref.MHW_SETPAR_F(VDENC_CMD2)(params));
857 ENCODE_CHK_STATUS_RETURN(m_streamIn.MHW_SETPAR_F(VDENC_CMD2)(params));
858
859 auto setting = static_cast<Av1VdencFeatureSettings*>(m_constSettings);
860 ENCODE_CHK_NULL_RETURN(setting);
861
862 for (const auto& lambda : setting->vdencCmd2Settings)
863 {
864 ENCODE_CHK_STATUS_RETURN(lambda(params, m_ref.IsLowDelay()));
865 }
866
867 auto waTable = m_osInterface->pfnGetWaTable(m_osInterface);
868 ENCODE_CHK_NULL_RETURN(waTable);
869 if (MEDIA_IS_WA(waTable, Wa_22011549751) &&
870 !m_osInterface->bSimIsActive &&
871 !Mos_Solo_Extension((MOS_CONTEXT_HANDLE)m_osInterface->pOsContext) &&
872 m_av1PicParams->PicFlags.fields.frame_type == keyFrame)
873 {
874 params.pictureType = 1;
875 }
876
877 return MOS_STATUS_SUCCESS;
878 }
879
MHW_SETPAR_DECL_SRC(AVP_PIC_STATE,Av1BasicFeature)880 MHW_SETPAR_DECL_SRC(AVP_PIC_STATE, Av1BasicFeature)
881 {
882 // (1) from seq ddi params
883 params.enableOrderHint = m_av1SeqParams->CodingToolFlags.fields.enable_order_hint ? true : false;
884 params.orderHintBitsMinus1 = m_av1SeqParams->order_hint_bits_minus_1;
885 params.enableRestoration = m_av1SeqParams->CodingToolFlags.fields.enable_restoration;
886
887 // (2) from pic ddi params
888 params.frameWidthMinus1 = m_av1PicParams->frame_width_minus1;
889 params.frameHeightMinus1 = m_av1PicParams->frame_height_minus1;
890 params.frameType = m_av1PicParams->PicFlags.fields.frame_type;
891 params.primaryRefFrame = m_av1PicParams->primary_ref_frame;
892 params.deltaQPresentFlag = m_av1PicParams->dwModeControlFlags.fields.delta_q_present_flag ? true : false;
893 params.log2DeltaQRes = m_av1PicParams->dwModeControlFlags.fields.log2_delta_q_res;
894 params.codedLossless = IsFrameLossless(*m_av1PicParams);
895 params.baseQindex = static_cast<uint8_t>(m_av1PicParams->base_qindex);
896 params.yDcDeltaQ = m_av1PicParams->y_dc_delta_q;
897 params.uDcDeltaQ = m_av1PicParams->u_dc_delta_q;
898 params.uAcDeltaQ = m_av1PicParams->u_ac_delta_q;
899 params.vDcDeltaQ = m_av1PicParams->v_dc_delta_q;
900 params.vAcDeltaQ = m_av1PicParams->v_ac_delta_q;
901 params.allowHighPrecisionMV = m_av1PicParams->PicFlags.fields.allow_high_precision_mv ? true : false;
902 params.referenceSelect = m_av1PicParams->dwModeControlFlags.fields.reference_mode == referenceModeSelect;
903 params.interpFilter = m_av1PicParams->interp_filter;
904 params.currentOrderHint = m_av1PicParams->order_hint;
905 params.reducedTxSetUsed = m_av1PicParams->PicFlags.fields.reduced_tx_set_used ? true : false;
906 params.txMode = m_av1PicParams->dwModeControlFlags.fields.tx_mode;
907 params.skipModePresent = m_av1PicParams->dwModeControlFlags.fields.skip_mode_present ? true : false;
908 params.enableCDEF = m_enableCDEF;
909
910 for (uint8_t i = 0; i < 7; i++)
911 params.globalMotionType[i] = static_cast<uint8_t>(m_av1PicParams->wm[i].wmtype);
912
913 params.frameLevelGlobalMotionInvalidFlags =
914 (m_av1PicParams->wm[0].invalid << 1) |
915 (m_av1PicParams->wm[1].invalid << 2) |
916 (m_av1PicParams->wm[2].invalid << 3) |
917 (m_av1PicParams->wm[3].invalid << 4) |
918 (m_av1PicParams->wm[4].invalid << 5) |
919 (m_av1PicParams->wm[5].invalid << 6) |
920 (m_av1PicParams->wm[6].invalid << 7);
921
922 for (uint8_t i = 0; i < 8; i++)
923 params.refFrameIdx[i] = m_av1PicParams->RefFrameList[i].FrameIdx == 0xff ? 0 : m_av1PicParams->RefFrameList[i].FrameIdx;
924
925 // (3) from other sources
926 params.skipModeFrame[0] = 0;
927 params.skipModeFrame[1] = 0;
928
929 params.bitDepthIdc = (m_bitDepth - 8) >> 1;
930 params.chromaFormat = m_chromaFormat;
931
932 params.vdencPackOnlyPass = false;
933
934 params.frameBitRateMaxReportMask = false;
935 params.frameBitRateMinReportMask = false;
936 params.frameBitRateMaxUnit = 0;
937 params.frameBitRateMax = 0;
938 params.frameBitRateMinUnit = 0;
939 params.frameBitRateMin = 0;
940
941 params.frameDeltaQindexMax[0] = 0;
942 params.frameDeltaQindexMax[1] = 0;
943 params.frameDeltaQindexMin = 0;
944 params.frameDeltaLFMax[0] = 0;
945 params.frameDeltaLFMax[1] = 0;
946 params.frameDeltaLFMin = 0;
947 params.frameDeltaQindexLFMaxRange[0] = 0;
948 params.frameDeltaQindexLFMaxRange[1] = 0;
949 params.frameDeltaQindexLFMinRange = 0;
950
951 const auto minFrameBytes = 512 / 8 + m_appHdrSize + m_tileGroupHeaderSize;
952 params.minFramSizeUnits = 3;
953 params.minFramSize = MOS_ALIGN_CEIL(minFrameBytes, 16) / 16;
954
955 auto waTable = m_osInterface->pfnGetWaTable(m_osInterface);
956 if (MEDIA_IS_WA(waTable, Wa_15013355402))
957 {
958 params.minFramSize = MOS_ALIGN_CEIL(13 * 64, 16) / 16;
959 }
960
961 params.bitOffsetForFirstPartitionSize = 0;
962
963 params.class0_SSE_Threshold0 = 0;
964 params.class0_SSE_Threshold1 = 0;
965
966 params.sbMaxSizeReportMask = false;
967 params.sbMaxBitSizeAllowed = 0;
968
969 params.autoBistreamStitchingInHardware = !m_enableSWStitching && !m_dualEncEnable;
970
971 // special fix to avoid zero padding for low resolution/bitrates and restore up to 20% BdRate quality
972 if ((m_av1PicParams->tile_cols * m_av1PicParams->tile_rows == 1) || m_dualEncEnable || m_enableSWStitching)
973 {
974 params.minFramSize = 0;
975 params.minFramSizeUnits = 0;
976 params.autoBistreamStitchingInHardware = false;
977 }
978
979 MHW_CHK_STATUS_RETURN(m_ref.MHW_SETPAR_F(AVP_PIC_STATE)(params));
980
981 return MOS_STATUS_SUCCESS;
982 }
983
MHW_SETPAR_DECL_SRC(AVP_INLOOP_FILTER_STATE,Av1BasicFeature)984 MHW_SETPAR_DECL_SRC(AVP_INLOOP_FILTER_STATE, Av1BasicFeature)
985 {
986 params.loopFilterLevel[0] = m_av1PicParams->filter_level[0];
987 params.loopFilterLevel[1] = m_av1PicParams->filter_level[1];
988 params.loopFilterLevel[2] = m_av1PicParams->filter_level_u;
989 params.loopFilterLevel[3] = m_av1PicParams->filter_level_v;
990
991 params.loopFilterSharpness = m_av1PicParams->cLoopFilterInfoFlags.fields.sharpness_level;
992 params.loopFilterDeltaEnabled = m_av1PicParams->cLoopFilterInfoFlags.fields.mode_ref_delta_enabled ? true : false;
993 params.deltaLfRes = m_av1PicParams->dwModeControlFlags.fields.log2_delta_lf_res;
994 params.deltaLfMulti = m_av1PicParams->dwModeControlFlags.fields.delta_lf_multi;
995 params.loopFilterDeltaUpdate = m_av1PicParams->dwModeControlFlags.fields.delta_lf_present_flag ? true : false;
996
997 for (uint8_t i = 0; i < AV1_NUM_OF_REF_LF_DELTAS; i++)
998 params.loopFilterRefDeltas[i] = m_av1PicParams->ref_deltas[i];
999
1000 for (uint8_t i = 0; i < AV1_NUM_OF_MODE_LF_DELTAS; i++)
1001 params.loopFilterModeDeltas[i] = m_av1PicParams->mode_deltas[i];
1002
1003 for (uint8_t i = 0; i < 8; i++)
1004 {
1005 params.cdefYStrength[i] = m_av1PicParams->cdef_y_strengths[i];
1006 params.cdefUVStrength[i] = m_av1PicParams->cdef_uv_strengths[i];
1007 }
1008
1009 params.cdefBits = m_av1PicParams->cdef_bits;
1010 params.cdefDampingMinus3 = m_av1PicParams->cdef_damping_minus_3;
1011
1012 params.LoopRestorationType[0] = m_av1PicParams->LoopRestorationFlags.fields.yframe_restoration_type;
1013 params.LoopRestorationType[1] = m_av1PicParams->LoopRestorationFlags.fields.cbframe_restoration_type;
1014 params.LoopRestorationType[2] = m_av1PicParams->LoopRestorationFlags.fields.crframe_restoration_type;
1015 params.UseSameLoopRestorationSizeForChroma = m_av1PicParams->LoopRestorationFlags.fields.lr_uv_shift ? false: true;
1016
1017 if (params.LoopRestorationType[0] == 0 &&
1018 params.LoopRestorationType[1] == 0 &&
1019 params.LoopRestorationType[2] == 0)
1020 {
1021 params.LoopRestorationSizeLuma = 0;
1022 params.UseSameLoopRestorationSizeForChroma = false;
1023 }
1024 else
1025 {
1026 // Intel Encoder PAK only support LRU size = SuperBlock size = 64x64 pixels.
1027 params.LoopRestorationSizeLuma = 1;
1028 }
1029
1030 return MOS_STATUS_SUCCESS;
1031 }
1032
MHW_SETPAR_DECL_SRC(AVP_PIPE_BUF_ADDR_STATE,Av1BasicFeature)1033 MHW_SETPAR_DECL_SRC(AVP_PIPE_BUF_ADDR_STATE, Av1BasicFeature)
1034 {
1035 params.bsLineRowstoreBuffer = m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer;
1036 params.intraPredLineRowstoreBuffer = m_resMfdIntraRowStoreScratchBuffer;
1037 params.intraPredTileLineRowstoreBuffer = m_intraPredictionTileLineRowstoreReadWriteBuffer;
1038 params.spatialMVLineBuffer = m_spatialMotionVectorLineReadWriteBuffer;
1039 params.spatialMVCodingTileLineBuffer = m_spatialMotionVectorCodingTileLineReadWriteBuffer;
1040 params.lrMetaTileColumnBuffer = m_loopRestorationMetaTileColumnReadWriteBuffer;
1041 params.lrTileLineYBuffer = m_loopRestorationFilterTileReadWriteLineYBuffer;
1042 params.lrTileLineUBuffer = m_loopRestorationFilterTileReadWriteLineUBuffer;
1043 params.lrTileLineVBuffer = m_loopRestorationFilterTileReadWriteLineVBuffer;
1044 params.lrTileColumnYBuffer = m_loopRestorationFilterTileColumnReadWriteYBuffer;
1045 params.lrTileColumnUBuffer = m_loopRestorationFilterTileColumnReadWriteUBuffer;
1046 params.lrTileColumnVBuffer = m_loopRestorationFilterTileColumnReadWriteVBuffer;
1047 params.lrTileColumnAlignBuffer = m_loopRestorationFilterTileColumnAlignmentBuf;
1048 params.deblockLineYBuffer = m_deblockerFilterLineReadWriteYBuffer;
1049 params.deblockLineUBuffer = m_deblockerFilterLineReadWriteUBuffer;
1050 params.deblockLineVBuffer = m_deblockerFilterLineReadWriteVBuffer;
1051 params.superResTileColumnYBuffer = m_superResTileColumnReadWriteYBuffer;
1052 params.superResTileColumnUBuffer = m_superResTileColumnReadWriteUBuffer;
1053 params.superResTileColumnVBuffer = m_superResTileColumnReadWriteVBuffer;
1054 params.decodedFrameStatusErrorBuffer = m_decodedFrameStatusErrorBuffer;
1055 params.decodedBlockDataStreamoutBuffer = m_decodedBlockDataStreamoutBuffer;
1056
1057 params.tileStatisticsPakStreamoutBuffer = m_tileStatisticsPakStreamoutBuffer;
1058 params.cuStreamoutBuffer = m_cuStreamoutBuffer;
1059 params.sseLineBuffer = m_sseLineReadWriteBuffer;
1060 params.sseTileLineBuffer = m_sseTileLineReadWriteBuffer;
1061
1062 CODEC_REF_LIST currRefList = *m_ref.GetCurrRefList();
1063 MOS_SURFACE * postCdefSurface = m_trackedBuf->GetSurface(
1064 BufferType::postCdefReconSurface, currRefList.ucScalingIdx);
1065 params.postCDEFpixelsBuffer = postCdefSurface;
1066
1067 // code from SetAvpPipeBufAddr
1068 #ifdef _MMC_SUPPORTED
1069 ENCODE_CHK_NULL_RETURN(m_mmcState);
1070 if (m_mmcState->IsMmcEnabled())
1071 {
1072 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(&m_reconSurface), ¶ms.mmcStatePreDeblock));
1073 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(&m_rawSurface), ¶ms.mmcStateRawSurf));
1074 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcState(postCdefSurface, ¶ms.postCdefSurfMmcState));
1075 }
1076 else
1077 {
1078 params.mmcStatePreDeblock = MOS_MEMCOMP_DISABLED;
1079 params.mmcStateRawSurf = MOS_MEMCOMP_DISABLED;
1080 params.postCdefSurfMmcState = MOS_MEMCOMP_DISABLED;
1081 }
1082 #endif
1083
1084 params.decodedPic = const_cast<PMOS_SURFACE>(&m_reconSurface);
1085 params.decodedPic->MmcState = params.mmcStatePreDeblock; // This is for MMC report only
1086 params.curMvTempBuffer = m_resMvTemporalBuffer;
1087 params.originalPicSourceBuffer = const_cast<PMOS_RESOURCE>(&m_rawSurfaceToPak->OsResource);
1088 params.dsPictureSourceBuffer = const_cast<PMOS_RESOURCE>(&m_rawSurfaceToEnc->OsResource);
1089
1090 MHW_CHK_STATUS_RETURN(m_ref.MHW_SETPAR_F(AVP_PIPE_BUF_ADDR_STATE)(params));
1091
1092 return MOS_STATUS_SUCCESS;
1093 }
1094
MHW_SETPAR_DECL_SRC(AVP_INTER_PRED_STATE,Av1BasicFeature)1095 MHW_SETPAR_DECL_SRC(AVP_INTER_PRED_STATE, Av1BasicFeature)
1096 {
1097 MHW_CHK_STATUS_RETURN(m_ref.MHW_SETPAR_F(AVP_INTER_PRED_STATE)(params));
1098
1099 return MOS_STATUS_SUCCESS;
1100 }
1101
MHW_SETPAR_DECL_SRC(AVP_IND_OBJ_BASE_ADDR_STATE,Av1BasicFeature)1102 MHW_SETPAR_DECL_SRC(AVP_IND_OBJ_BASE_ADDR_STATE, Av1BasicFeature)
1103 {
1104 params.Mode = codechalEncodeModeAv1;
1105 params.mvObjectBuffer = m_resMbCodeBuffer;
1106 params.pakBaseObjectBuffer = const_cast<PMOS_RESOURCE>(&m_resBitstreamBuffer);
1107 params.pakBaseObjectSize = m_bitstreamSize;
1108
1109 return MOS_STATUS_SUCCESS;
1110 }
1111
MHW_SETPAR_DECL_SRC(AVP_SURFACE_STATE,Av1BasicFeature)1112 MHW_SETPAR_DECL_SRC(AVP_SURFACE_STATE, Av1BasicFeature)
1113 {
1114 MOS_MEMCOMP_STATE mmcState = {};
1115 switch (params.surfaceStateId)
1116 {
1117 case srcInputPic:
1118 params.pitch = m_rawSurfaceToEnc->dwPitch;
1119 params.uOffset = m_rawSurfaceToEnc->YoffsetForUplane;
1120 params.vOffset = m_rawSurfaceToEnc->YoffsetForVplane;
1121 GetSurfaceMmcInfo(m_rawSurfaceToEnc, mmcState, params.compressionFormat);
1122 std::fill(std::begin(params.mmcState), std::end(params.mmcState), mmcState);
1123 break;
1124 case origUpscaledSrc:
1125 params.pitch = m_rawSurfaceToPak->dwPitch;
1126 params.uOffset = m_rawSurfaceToPak->YoffsetForUplane;
1127 params.vOffset = m_rawSurfaceToPak->YoffsetForVplane;
1128 GetSurfaceMmcInfo(m_rawSurfaceToPak, mmcState, params.compressionFormat);
1129 std::fill(std::begin(params.mmcState), std::end(params.mmcState), mmcState);
1130 break;
1131 case reconPic:
1132 params.pitch = m_reconSurface.dwPitch;
1133 params.uOffset = m_reconSurface.YoffsetForUplane;
1134 params.vOffset = m_reconSurface.YoffsetForVplane;
1135 GetSurfaceMmcInfo(const_cast<PMOS_SURFACE>(&m_reconSurface), mmcState, params.compressionFormat);
1136 std::fill(std::begin(params.mmcState), std::end(params.mmcState), mmcState);
1137 break;
1138 case av1CdefPixelsStreamout:
1139 {
1140 CODEC_REF_LIST_AV1 currRefList = *m_ref.GetCurrRefList();
1141 MOS_SURFACE * postCdefSurface = m_trackedBuf->GetSurface(
1142 BufferType::postCdefReconSurface, currRefList.ucScalingIdx);
1143 MHW_CHK_NULL_RETURN(postCdefSurface);
1144 params.pitch = postCdefSurface->dwPitch;
1145 params.uOffset = postCdefSurface->YoffsetForUplane;
1146 params.vOffset = postCdefSurface->YoffsetForVplane;
1147 GetSurfaceMmcInfo(postCdefSurface, mmcState, params.compressionFormat);
1148 std::fill(std::begin(params.mmcState), std::end(params.mmcState), mmcState);
1149 break;
1150 }
1151 case av1IntraFrame:
1152 case av1LastRef:
1153 case av1Last2Ref:
1154 case av1Last3Ref:
1155 case av1GoldRef:
1156 case av1BwdRef:
1157 case av1AltRef2:
1158 case av1AltRef:
1159 params.uvPlaneAlignment = 8;
1160 MHW_CHK_STATUS_RETURN(m_ref.MHW_SETPAR_F(AVP_SURFACE_STATE)(params));
1161 break;
1162 }
1163
1164 params.bitDepthLumaMinus8 = m_is10Bit ? 2 : 0;
1165
1166 return MOS_STATUS_SUCCESS;
1167 }
1168
1169 enum CODEC_SELECT
1170 {
1171 CODEC_SELECT_DECODE = 0,
1172 CODEC_SELECT_ENCODE = 1,
1173 };
1174
1175 enum CODEC_STANDARD_SELECT
1176 {
1177 CODEC_STANDARD_SELECT_HEVC = 0,
1178 CODEC_STANDARD_SELECT_VP9 = 1,
1179 CODEC_STANDARD_SELECT_AV1 = 2,
1180 };
1181
MHW_SETPAR_DECL_SRC(AVP_PIPE_MODE_SELECT,Av1BasicFeature)1182 MHW_SETPAR_DECL_SRC(AVP_PIPE_MODE_SELECT, Av1BasicFeature)
1183 {
1184 params.codecSelect = CODEC_SELECT_ENCODE;
1185 params.codecStandardSelect = CODEC_STANDARD_SELECT_AV1;
1186 params.vdencMode = true;
1187
1188 params.cdefOutputStreamoutEnableFlag = false;
1189 params.lrOutputStreamoutEnableFlag = false;
1190
1191 params.frameReconDisable = m_av1PicParams->PicFlags.fields.DisableFrameRecon;
1192 params.tileStatsStreamoutEnable = IsRateControlBrc(m_av1SeqParams->RateControlMethod);
1193 params.pakFrameLevelStreamOutEnable = IsRateControlBrc(m_av1SeqParams->RateControlMethod);
1194
1195 params.picStatusErrorReportEnable = false;
1196 params.picStatusErrorReportId = false;
1197
1198 params.phaseIndicator = 0;
1199
1200 params.frameReconDisable = false;
1201
1202 params.motionCompMemoryTrackerCntEnable = false;
1203 params.motionCompMemTrackerCounterEnable = false;
1204
1205 params.srcPixelPrefetchEnable = true;
1206 params.srcPixelPrefetchLen = 4;
1207 params.sseEnable = false;
1208
1209 return MOS_STATUS_SUCCESS;
1210 }
1211
MHW_SETPAR_DECL_SRC(AVP_TILE_CODING,Av1BasicFeature)1212 MHW_SETPAR_DECL_SRC(AVP_TILE_CODING, Av1BasicFeature)
1213 {
1214 params.tileRowIndependentFlag = false;
1215 params.disableCdfUpdateFlag = m_av1PicParams->PicFlags.fields.disable_cdf_update ? 1 : 0;
1216 params.numOfActiveBePipes = 1;
1217 params.numOfTileColumnsInFrame = m_av1PicParams->tile_cols;
1218 params.numOfTileRowsInFrame = m_av1PicParams->tile_rows;
1219
1220 return MOS_STATUS_SUCCESS;
1221 }
1222
MHW_SETPAR_DECL_SRC(HUC_PIPE_MODE_SELECT,Av1BasicFeature)1223 MHW_SETPAR_DECL_SRC(HUC_PIPE_MODE_SELECT, Av1BasicFeature)
1224 {
1225 params.mode = m_mode;
1226
1227 return MOS_STATUS_SUCCESS;
1228 }
1229
MHW_SETPAR_DECL_SRC(MFX_WAIT,Av1BasicFeature)1230 MHW_SETPAR_DECL_SRC(MFX_WAIT, Av1BasicFeature)
1231 {
1232 params.iStallVdboxPipeline = true;
1233
1234 return MOS_STATUS_SUCCESS;
1235 }
1236
1237 } // namespace encode
1238