Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_encode_hevc_base.cpp

raw
1 /*
2 * Copyright (c) 2017-2018, 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 codechal_encode_hevc_base.cpp
24 //! \brief Defines base class for HEVC encoder.
25 //!
26
27 #include "codechal_encode_hevc_base.h"
28 #include "codechal_vdenc_hevc.h"
29 #include "codechal_encode_hevc.h"
30 #include "encode_hevc_header_packer.h"
31 #if USE_CODECHAL_DEBUG_TOOL
32 #include "codechal_debug.h"
33 #endif
34
35 const uint8_t CodechalEncodeHevcBase::TransformSkipCoeffsTable[4][2][2][2][2] =
36 {
37 { { { { 42, 37 },{ 32, 40 } },{ { 40, 40 },{ 32, 45 } } },{ { { 29, 48 },{ 26, 53 } },{ { 26, 56 },{ 24, 62 } } } },
38 { { { { 42, 40 },{ 32, 45 } },{ { 40, 46 },{ 32, 48 } } },{ { { 26, 53 },{ 24, 58 } },{ { 32, 53 },{ 26, 64 } } } },
39 { { { { 38, 42 },{ 32, 51 } },{ { 43, 43 },{ 35, 46 } } },{ { { 26, 56 },{ 24, 64 } },{ { 35, 50 },{ 32, 57 } } } },
40 { { { { 35, 46 },{ 32, 52 } },{ { 51, 42 },{ 38, 53 } } },{ { { 29, 56 },{ 29, 70 } },{ { 38, 47 },{ 37, 64 } } } },
41 };
42
43 const uint16_t CodechalEncodeHevcBase::TransformSkipLambdaTable[QP_NUM] =
44 {
45 149, 149, 149, 149, 149, 149, 149, 149,
46 149, 149, 149, 149, 149, 149, 149, 149,
47 149, 149, 149, 149, 149, 149, 149, 149,
48 149, 162, 174, 186, 199, 211, 224, 236,
49 249, 261, 273, 286, 298, 298, 298, 298,
50 298, 298, 298, 298, 298, 298, 298, 298,
51 298, 298, 298, 298
52 };
53
54 MOS_STATUS CodechalEncodeHevcBase::InitMmcState()
55 {
56 m_mmcState = MOS_New(CodechalMmcEncodeHevc, m_hwInterface, this);
57 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
58 return MOS_STATUS_SUCCESS;
59 }
60
61 MOS_STATUS CodechalEncodeHevcBase::Initialize(CodechalSetting * settings)
62 {
63 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
64
65 CODECHAL_ENCODE_FUNCTION_ENTER;
66
67 CODECHAL_ENCODE_CHK_NULL_RETURN(settings);
68
69 #ifndef _FULL_OPEN_SOURCE
70 // for HEVC: the Ds+Copy kernel is by default used to do CSC and copy non-aligned surface
71 CODECHAL_ENCODE_CHK_NULL_RETURN(m_cscDsState);
72 m_cscDsState->EnableCopy();
73 m_cscDsState->EnableColor();
74 #endif
75 m_mfeEnabled = settings->isMfeEnabled;
76
77 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::Initialize(settings));
78
79 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitMmcState());
80
81 m_is10BitHevc = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? true : false;
82 m_chromaFormat = settings->chromaFormat;
83 m_bitDepth = (settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_8_BITS) ? 8 : ((settings->lumaChromaDepth & CODECHAL_LUMA_CHROMA_DEPTH_10_BITS) ? 10 : 12);
84 m_frameNum = 0;
85
86 const uint32_t picWidthInLCU = MOS_ROUNDUP_DIVIDE(m_frameWidth, CODECHAL_HEVC_MIN_LCU_SIZE); //assume smallest LCU to get max width
87 const uint32_t picHeightInLCU = MOS_ROUNDUP_DIVIDE(m_frameHeight, CODECHAL_HEVC_MIN_LCU_SIZE); //assume smallest LCU to get max height // MaxNumLcu is when LCU size is min lcu size(16)
88 const uint32_t maxNumLCUs = picWidthInLCU * picHeightInLCU;
89 m_mvOffset = MOS_ALIGN_CEIL((maxNumLCUs * (m_hcpInterface->GetHcpPakObjSize()) * sizeof(uint32_t)), CODECHAL_PAGE_SIZE);
90
91 // MaxNumCuRecords is when LCU size is max lcu size(64)
92 const uint32_t maxNumCuRecords = MOS_ROUNDUP_DIVIDE(m_frameWidth, MAX_LCU_SIZE) *
93 MOS_ROUNDUP_DIVIDE(m_frameHeight, MAX_LCU_SIZE) * 64;
94 m_mbCodeSize =
95 m_mvOffset + MOS_ALIGN_CEIL((maxNumCuRecords * m_hcpInterface->GetHevcEncCuRecordSize()), CODECHAL_PAGE_SIZE);
96
97 m_widthAlignedMaxLcu = MOS_ALIGN_CEIL(m_frameWidth, MAX_LCU_SIZE);
98 m_heightAlignedMaxLcu = MOS_ALIGN_CEIL(m_frameHeight, MAX_LCU_SIZE);
99
100 m_hevcBrcPakStatisticsSize = HEVC_BRC_PAK_STATISTCS_SIZE; // size for sturcture: CODECHAL_ENCODE_HEVC_PAK_STATS_BUFFER
101 m_sizeOfHcpPakFrameStats = 8 * CODECHAL_CACHELINE_SIZE;
102
103 // Initialize kernel State
104 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelState());
105
106 // Get max binding table count
107 m_maxBtCount = GetMaxBtCount();
108
109 // Picture Level Commands
110 CODECHAL_ENCODE_CHK_STATUS_RETURN(CalculatePictureStateCommandSize());
111
112 // Slice Level Commands
113 CODECHAL_ENCODE_CHK_STATUS_RETURN(
114 m_hwInterface->GetHxxPrimitiveCommandSize(
115 CODECHAL_ENCODE_MODE_HEVC,
116 &m_defaultSliceStatesSize,
117 &m_defaultSlicePatchListSize,
118 m_singleTaskPhaseSupported));
119
120 #if (_DEBUG || _RELEASE_INTERNAL)
121 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
122 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
123 MOS_UserFeature_ReadValue_ID(
124 nullptr,
125 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_IFRAME_RDOQ_ENABLE_ID,
126 &userFeatureData,
127 m_osInterface->pOsContext);
128 m_hevcIFrameRdoqEnabled = userFeatureData.i32Data ? true : false;
129
130 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
131 MOS_UserFeature_ReadValue_ID(
132 nullptr,
133 __MEDIA_USER_FEATURE_VALUE_CODECHAL_RDOQ_INTRA_TU_OVERRIDE_ID,
134 &userFeatureData,
135 m_osInterface->pOsContext);
136 m_rdoqIntraTuOverride = (uint32_t)userFeatureData.u32Data;
137
138 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
139 MOS_UserFeature_ReadValue_ID(
140 nullptr,
141 __MEDIA_USER_FEATURE_VALUE_CODECHAL_RDOQ_INTRA_TU_DISABLE_ID,
142 &userFeatureData,
143 m_osInterface->pOsContext);
144 m_rdoqIntraTuDisableOverride = (uint32_t)userFeatureData.u32Data;
145
146 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
147 MOS_UserFeature_ReadValue_ID(
148 nullptr,
149 __MEDIA_USER_FEATURE_VALUE_CODECHAL_RDOQ_INTRA_TU_THRESHOLD_ID,
150 &userFeatureData,
151 m_osInterface->pOsContext);
152 m_rdoqIntraTuThresholdOverride = (uint32_t)userFeatureData.u32Data;
153 #endif
154 return eStatus;
155 }
156
157 MOS_STATUS CodechalEncodeHevcBase::AllocatePakResources()
158 {
159 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
160
161 CODECHAL_ENCODE_FUNCTION_ENTER;
162
163 const uint32_t minLcuSize = 16;
164 const uint32_t picWidthInMinLCU = MOS_ROUNDUP_DIVIDE(m_frameWidth, minLcuSize); //assume smallest LCU to get max width
165 const uint32_t picHeightInMinLCU = MOS_ROUNDUP_DIVIDE(m_frameHeight, minLcuSize); //assume smallest LCU to get max height
166
167 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
168 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
169 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
170 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
171 allocParamsForBufferLinear.Format = Format_Buffer;
172
173 // Deblocking Filter Row Store Scratch data surface
174 const uint32_t formatDenom = 2;
175 uint32_t formatMultiFactor = m_chromaFormat == HCP_CHROMA_FORMAT_YUV444 ? 3 : 2;
176 formatMultiFactor *= m_is10BitHevc ? 2 : 1;
177
178 uint32_t size = ((m_frameWidth + 31) & 0xFFFFFFE0) >> 3;
179 size = MOS_ALIGN_CEIL(MOS_ROUNDUP_DIVIDE(size * formatMultiFactor, formatDenom), 4);
180 size *= CODECHAL_CACHELINE_SIZE;
181 allocParamsForBufferLinear.dwBytes = size;
182 allocParamsForBufferLinear.pBufName = "DeblockingScratchBuffer";
183
184 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
185 m_osInterface,
186 &allocParamsForBufferLinear,
187 &m_resDeblockingFilterRowStoreScratchBuffer);
188
189 if (eStatus != MOS_STATUS_SUCCESS)
190 {
191 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
192 return eStatus;
193 }
194
195 // Deblocking Filter Tile Row Store Scratch data surface
196 allocParamsForBufferLinear.dwBytes = size;
197 allocParamsForBufferLinear.pBufName = "DeblockingTileScratchBuffer";
198
199 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
200 m_osInterface,
201 &allocParamsForBufferLinear,
202 &m_resDeblockingFilterTileRowStoreScratchBuffer);
203
204 if (eStatus != MOS_STATUS_SUCCESS)
205 {
206 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Deblocking Filter Tile Row Store Scratch Buffer.");
207 return eStatus;
208 }
209
210 // Deblocking Filter Column Row Store Scratch data surface
211 size = ((m_frameHeight + picHeightInMinLCU * 6 + 31) & 0xFFFFFFE0) >> 3;
212 size = MOS_ALIGN_CEIL(MOS_ROUNDUP_DIVIDE(size * formatMultiFactor, formatDenom), 4);
213 size *= CODECHAL_CACHELINE_SIZE;
214 allocParamsForBufferLinear.dwBytes = size;
215 allocParamsForBufferLinear.pBufName = "DeblockingColumnScratchBuffer";
216
217 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
218 m_osInterface,
219 &allocParamsForBufferLinear,
220 &m_resDeblockingFilterColumnRowStoreScratchBuffer);
221
222 if (eStatus != MOS_STATUS_SUCCESS)
223 {
224 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Deblocking Filter Column Row Store Scratch Buffer.");
225 return eStatus;
226 }
227
228 // Metadata Line buffer
229 size = MOS_MAX(
230 MOS_ALIGN_CEIL((m_frameWidth + picWidthInMinLCU * 8 + 1023) >> 9, 2) * CODECHAL_CACHELINE_SIZE, // intra-slice
231 MOS_ALIGN_CEIL((((m_frameWidth + 15) >> 4) * 188 + picWidthInMinLCU * 9 + 1023) >> 9, 2) * CODECHAL_CACHELINE_SIZE // inter-slice
232 );
233 allocParamsForBufferLinear.dwBytes = size;
234 allocParamsForBufferLinear.pBufName = "MetadataLineBuffer";
235
236 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
237 m_osInterface,
238 &allocParamsForBufferLinear,
239 &m_resMetadataLineBuffer);
240
241 if (eStatus != MOS_STATUS_SUCCESS)
242 {
243 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Metadata Line Buffer.");
244 return eStatus;
245 }
246
247 // Metadata Tile Line buffer
248 size = MOS_MAX(
249 MOS_ALIGN_CEIL((m_frameWidth + picWidthInMinLCU * 8 + 1023) >> 9, 2) * CODECHAL_CACHELINE_SIZE, // intra-slice
250 MOS_ALIGN_CEIL((((m_frameWidth + 15) >> 4) * 172 + picWidthInMinLCU * 9 + 1023) >> 9, 2) * CODECHAL_CACHELINE_SIZE // inter-slice
251 );
252 allocParamsForBufferLinear.dwBytes = size;
253 allocParamsForBufferLinear.pBufName = "MetadataTileLineBuffer";
254
255 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
256 m_osInterface,
257 &allocParamsForBufferLinear,
258 &m_resMetadataTileLineBuffer);
259
260 if (eStatus != MOS_STATUS_SUCCESS)
261 {
262 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Metadata Tile Line Buffer.");
263 return eStatus;
264 }
265
266 // Metadata Tile Column buffer
267 size = MOS_MAX(
268 MOS_ALIGN_CEIL((m_frameHeight + picHeightInMinLCU * 8 + 1023) >> 9, 2) * CODECHAL_CACHELINE_SIZE, // intra-slice
269 MOS_ALIGN_CEIL((((m_frameHeight + 15) >> 4) * 172 + picHeightInMinLCU * 9 + 1023) >> 9, 2) * CODECHAL_CACHELINE_SIZE // inter-slice
270 );
271 allocParamsForBufferLinear.dwBytes = size;
272 allocParamsForBufferLinear.pBufName = "MetadataTileColumnBuffer";
273
274 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
275 m_osInterface,
276 &allocParamsForBufferLinear,
277 &m_resMetadataTileColumnBuffer);
278
279 if (eStatus != MOS_STATUS_SUCCESS)
280 {
281 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Metadata Tile Column Buffer.");
282 return eStatus;
283 }
284
285 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
286 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
287 hcpBufSizeParam.ucMaxBitDepth = m_bitDepth;
288 hcpBufSizeParam.ucChromaFormat = m_chromaFormat;
289
290 hcpBufSizeParam.dwCtbLog2SizeY = 6; // assume Max LCU size
291 hcpBufSizeParam.dwPicWidth = MOS_ALIGN_CEIL(m_frameWidth, MAX_LCU_SIZE);
292 hcpBufSizeParam.dwPicHeight = MOS_ALIGN_CEIL(m_frameHeight, MAX_LCU_SIZE);
293 // SAO Line buffer
294 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
295 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE,
296 &hcpBufSizeParam);
297
298 if (eStatus != MOS_STATUS_SUCCESS)
299 {
300 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for SAO Line Buffer.");
301 return eStatus;
302 }
303
304 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
305 allocParamsForBufferLinear.pBufName = "SaoLineBuffer";
306 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
307 m_osInterface,
308 &allocParamsForBufferLinear,
309 &m_resSaoLineBuffer);
310
311 if (eStatus != MOS_STATUS_SUCCESS)
312 {
313 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO Line Buffer.");
314 return eStatus;
315 }
316
317 // SAO Tile Line buffer
318 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
319 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE,
320 &hcpBufSizeParam);
321
322 if (eStatus != MOS_STATUS_SUCCESS)
323 {
324 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for SAO Tile Line Buffer.");
325 return eStatus;
326 }
327
328 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
329 allocParamsForBufferLinear.pBufName = "SaoTileLineBuffer";
330
331 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
332 m_osInterface,
333 &allocParamsForBufferLinear,
334 &m_resSaoTileLineBuffer);
335
336 if (eStatus != MOS_STATUS_SUCCESS)
337 {
338 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO Tile Line Buffer.");
339 return eStatus;
340 }
341
342 // SAO Tile Column buffer
343 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
344 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL,
345 &hcpBufSizeParam);
346
347 if (eStatus != MOS_STATUS_SUCCESS)
348 {
349 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for SAO Tile Column Buffer.");
350 return eStatus;
351 }
352
353 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
354 allocParamsForBufferLinear.pBufName = "SaoTileColumnBuffer";
355
356 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
357 m_osInterface,
358 &allocParamsForBufferLinear,
359 &m_resSaoTileColumnBuffer);
360
361 if (eStatus != MOS_STATUS_SUCCESS)
362 {
363 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO Tile Column Buffer.");
364 return eStatus;
365 }
366
367 // Lcu ILDB StreamOut buffer
368 size = 1000000;
369 allocParamsForBufferLinear.dwBytes = size;
370 allocParamsForBufferLinear.pBufName = "LcuILDBStreamOutBuffer";
371
372 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
373 m_osInterface,
374 &allocParamsForBufferLinear,
375 &m_resLcuIldbStreamOutBuffer);
376
377 if (eStatus != MOS_STATUS_SUCCESS)
378 {
379 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate LCU ILDB StreamOut Buffer.");
380 return eStatus;
381 }
382
383 // Lcu Base Address buffer
384 // HEVC Encoder Mode: Slice size is written to this buffer when slice size conformance is enabled.
385 // 1 CL (= 16 DWs = 64 bytes) per slice * Maximum number of dynamic slice = 600
386 // Note that simulation is assigning much larger space for this.
387 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6 * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
388 allocParamsForBufferLinear.pBufName = "LcuBaseAddressBuffer";
389
390 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
391 m_osInterface,
392 &allocParamsForBufferLinear,
393 &m_resLcuBaseAddressBuffer);
394
395 if (eStatus != MOS_STATUS_SUCCESS)
396 {
397 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate LCU Base Address Buffer.");
398 return eStatus;
399 }
400
401 uint32_t mvt_size = MOS_ALIGN_CEIL(((m_frameWidth + 63) >> 6)*((m_frameHeight + 15) >> 4), 2) * CODECHAL_CACHELINE_SIZE;
402 uint32_t mvtb_size = MOS_ALIGN_CEIL(((m_frameWidth + 31) >> 5)*((m_frameHeight + 31) >> 5), 2) * CODECHAL_CACHELINE_SIZE;
403 m_sizeOfMvTemporalBuffer = MOS_MAX(mvt_size, mvtb_size);
404
405 // SAO StreamOut buffer
406 size = MOS_ALIGN_CEIL(picWidthInMinLCU * picHeightInMinLCU * 16, CODECHAL_CACHELINE_SIZE); // 16 bytes per LCU
407 allocParamsForBufferLinear.dwBytes = size;
408 allocParamsForBufferLinear.pBufName = "SaoStreamOutBuffer";
409
410 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
411 m_osInterface,
412 &allocParamsForBufferLinear,
413 &m_resSaoStreamOutBuffer);
414
415 if (eStatus != MOS_STATUS_SUCCESS)
416 {
417 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO StreamOut Buffer.");
418 return eStatus;
419 }
420
421 return eStatus;
422 }
423
424 MOS_STATUS CodechalEncodeHevcBase::AllocateResources()
425 {
426 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
427
428 CODECHAL_ENCODE_FUNCTION_ENTER;
429
430 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::AllocateResources());
431
432 // Allocate Ref Lists
433 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalAllocateDataList(
434 m_refList,
435 CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC));
436
437 // Create the sync objects which will be used by each reference frame
438 for (uint32_t i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_refSync); i++)
439 {
440 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(m_osInterface, &m_refSync[i].resSyncObject));
441 m_refSync[i].bInUsed = false;
442 }
443
444 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(AllocatePakResources(), "Failed to allocate PAK resources.");
445
446 if (m_encEnabled)
447 {
448 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(AllocateEncResources(), "Failed to allocate ENC resources.");
449
450 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(AllocateBrcResources(), "Failed to allocate BRC resources.");
451 }
452
453 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceInfoTable());
454 CreateMhwParams();
455
456 return eStatus;
457 }
458
459 MOS_STATUS CodechalEncodeHevcBase::AllocateBuffer(
460 PCODECHAL_ENCODE_BUFFER buffer,
461 uint32_t size,
462 const char* name,
463 int32_t dwMemType)
464 {
465 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
466
467 CODECHAL_ENCODE_FUNCTION_ENTER;
468
469 CODECHAL_ENCODE_CHK_NULL_RETURN(buffer);
470
471 MOS_ALLOC_GFXRES_PARAMS allocParams;
472 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
473 allocParams.Type = MOS_GFXRES_BUFFER;
474 allocParams.TileType = MOS_TILE_LINEAR;
475 allocParams.Format = Format_Buffer;
476 allocParams.dwBytes = size;
477 allocParams.pBufName = name;
478 allocParams.dwMemType = dwMemType;
479 buffer->dwSize = size;
480
481 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
482 m_osInterface,
483 &allocParams,
484 &buffer->sResource);
485
486 if (eStatus != MOS_STATUS_SUCCESS)
487 {
488 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate %s.", name);
489 return eStatus;
490 }
491
492 MOS_LOCK_PARAMS lockFlags;
493 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
494 lockFlags.WriteOnly = 1;
495
496 uint8_t* data = (uint8_t*)m_osInterface->pfnLockResource(
497 m_osInterface,
498 &buffer->sResource,
499 &lockFlags);
500 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
501
502 MOS_ZeroMemory(data, size);
503
504 m_osInterface->pfnUnlockResource(
505 m_osInterface,
506 &buffer->sResource);
507
508 return eStatus;
509 }
510
511 MOS_STATUS CodechalEncodeHevcBase::AllocateBuffer2D(
512 PMOS_SURFACE surface,
513 uint32_t width,
514 uint32_t height,
515 const char* name,
516 MOS_TILE_TYPE tileType,
517 int32_t dwMemType)
518 {
519 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
520
521 CODECHAL_ENCODE_FUNCTION_ENTER;
522
523 CODECHAL_ENCODE_CHK_NULL_RETURN(surface);
524
525 MOS_ZeroMemory(surface, sizeof(*surface));
526
527 surface->TileType = tileType;
528 surface->bArraySpacing = true;
529 surface->Format = Format_Buffer_2D;
530 surface->dwWidth = MOS_ALIGN_CEIL(width, 64);
531 surface->dwHeight = height;
532 surface->dwPitch = surface->dwWidth;
533
534 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
535 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
536 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
537 allocParamsForBuffer2D.TileType = surface->TileType;
538 allocParamsForBuffer2D.Format = surface->Format;
539 allocParamsForBuffer2D.dwWidth = surface->dwWidth;
540 allocParamsForBuffer2D.dwHeight = surface->dwHeight;
541 allocParamsForBuffer2D.pBufName = name;
542 allocParamsForBuffer2D.dwMemType = dwMemType;
543
544 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
545 m_osInterface,
546 &allocParamsForBuffer2D,
547 &surface->OsResource);
548
549 if (eStatus != MOS_STATUS_SUCCESS)
550 {
551 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate %s.", name);
552 return eStatus;
553 }
554
555 MOS_LOCK_PARAMS lockFlagsWriteOnly;
556 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
557 lockFlagsWriteOnly.WriteOnly = true;
558
559 uint8_t* data = (uint8_t*)m_osInterface->pfnLockResource(
560 m_osInterface,
561 &(surface->OsResource),
562 &lockFlagsWriteOnly);
563
564 if (data == nullptr)
565 {
566 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock 2D Surface.");
567 eStatus = MOS_STATUS_UNKNOWN;
568 return eStatus;
569 }
570
571 MOS_ZeroMemory(data, surface->dwWidth * surface->dwHeight);
572
573 m_osInterface->pfnUnlockResource(m_osInterface, &(surface->OsResource));
574
575 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
576 m_osInterface,
577 surface));
578
579 return eStatus;
580 }
581
582 MOS_STATUS CodechalEncodeHevcBase::AllocateSurface(
583 PMOS_SURFACE surface,
584 uint32_t width,
585 uint32_t height,
586 const char* name,
587 int32_t dwMemType)
588 {
589 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
590
591 CODECHAL_ENCODE_FUNCTION_ENTER;
592
593 CODECHAL_ENCODE_CHK_NULL_RETURN(surface);
594
595 MOS_ALLOC_GFXRES_PARAMS allocParams;
596 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
597 allocParams.Type = MOS_GFXRES_2D;
598 allocParams.TileType = MOS_TILE_Y;
599 allocParams.Format = Format_NV12;
600 allocParams.dwWidth = width;
601 allocParams.dwHeight = height;
602 allocParams.pBufName = name;
603 allocParams.dwMemType = dwMemType;
604
605 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
606 m_osInterface,
607 &allocParams,
608 &surface->OsResource);
609
610 if (eStatus != MOS_STATUS_SUCCESS)
611 {
612 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate %s.", name);
613 return eStatus;
614 }
615
616 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
617 m_osInterface,
618 surface));
619
620 return eStatus;
621 }
622
623 MOS_STATUS CodechalEncodeHevcBase::AllocateBatchBufferForPakSlices(
624 uint32_t numSlices,
625 uint8_t numPakPasses)
626 {
627 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
628
629 CODECHAL_ENCODE_FUNCTION_ENTER;
630
631 MOS_ZeroMemory(
632 &m_batchBufferForPakSlices[m_currPakSliceIdx],
633 sizeof(MHW_BATCH_BUFFER));
634
635 // Get the slice size
636 uint32_t size = (numPakPasses + 1) * numSlices * m_sliceStatesSize;
637
638 m_batchBufferForPakSlices[m_currPakSliceIdx].bSecondLevel = true;
639 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
640 m_osInterface,
641 &m_batchBufferForPakSlices[m_currPakSliceIdx],
642 nullptr,
643 size));
644
645 MOS_LOCK_PARAMS lockFlags;
646 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
647 lockFlags.WriteOnly = 1;
648 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(
649 m_osInterface,
650 &m_batchBufferForPakSlices[m_currPakSliceIdx].OsResource,
651 &lockFlags);
652
653 if (data == nullptr)
654 {
655 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to lock batch buffer for PAK slices.");
656 eStatus = MOS_STATUS_UNKNOWN;
657 return eStatus;
658 }
659
660 MOS_ZeroMemory(data, size);
661 m_osInterface->pfnUnlockResource(
662 m_osInterface,
663 &m_batchBufferForPakSlices[m_currPakSliceIdx].OsResource);
664
665 return eStatus;
666 }
667
668 MOS_STATUS CodechalEncodeHevcBase::ReadSseStatistics(PMOS_COMMAND_BUFFER cmdBuffer)
669 {
670 CODECHAL_ENCODE_FUNCTION_ENTER;
671
672 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
673
674 // encodeStatus is offset by 2 DWs in the resource
675 uint32_t sseOffsetinBytes = (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2 + m_encodeStatusBuf.dwSumSquareErrorOffset;
676 for (auto i = 0; i < 6; i++) // 64 bit SSE values for luma/ chroma channels need to be copied
677 {
678 MHW_MI_COPY_MEM_MEM_PARAMS miCpyMemMemParams;
679 MOS_ZeroMemory(&miCpyMemMemParams, sizeof(miCpyMemMemParams));
680 miCpyMemMemParams.presSrc = &m_resFrameStatStreamOutBuffer;
681 miCpyMemMemParams.dwSrcOffset = (HEVC_PAK_STATISTICS_SSE_OFFSET + i) * sizeof(uint32_t); // SSE luma offset is located at DW32 in Frame statistics, followed by chroma
682 miCpyMemMemParams.presDst = &m_encodeStatusBuf.resStatusBuffer;
683 miCpyMemMemParams.dwDstOffset = sseOffsetinBytes + i * sizeof(uint32_t);
684 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(cmdBuffer, &miCpyMemMemParams));
685 }
686 return eStatus;
687 }
688
689 MOS_STATUS CodechalEncodeHevcBase::CalculatePSNR(
690 EncodeStatus *encodeStatus,
691 EncodeStatusReport *encodeStatusReport)
692 {
693 CODECHAL_ENCODE_FUNCTION_ENTER;
694
695 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
696
697 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatus);
698 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatusReport);
699 uint32_t numLumaPixels = 0, numPixelsPerChromaChannel = 0;
700
701 numLumaPixels = m_frameHeight * m_frameWidth;
702 switch (m_hevcSeqParams->chroma_format_idc)
703 {
704 case HCP_CHROMA_FORMAT_MONOCHROME:
705 numPixelsPerChromaChannel = 0;
706 break;
707 case HCP_CHROMA_FORMAT_YUV420:
708 numPixelsPerChromaChannel = numLumaPixels / 4;
709 break;
710 case HCP_CHROMA_FORMAT_YUV422:
711 numPixelsPerChromaChannel = numLumaPixels / 2;
712 break;
713 case HCP_CHROMA_FORMAT_YUV444:
714 numPixelsPerChromaChannel = numLumaPixels;
715 break;
716 default:
717 numPixelsPerChromaChannel = numLumaPixels / 2;
718 break;
719 }
720
721 double squarePeakPixelValue = pow((1 << (m_hevcSeqParams->bit_depth_luma_minus8 + 8)) - 1, 2);
722
723 for (auto i = 0; i < 3; i++)
724 {
725 uint32_t numPixels = i ? numPixelsPerChromaChannel : numLumaPixels;
726
727 if (m_hevcSeqParams->bit_depth_luma_minus8 == 0)
728 {
729 //8bit pixel data is represented in 10bit format in HW. so SSE should right shift by 4.
730 encodeStatus->sumSquareError[i] >>= 4;
731 }
732 encodeStatusReport->PSNRx100[i] = (uint16_t) CodecHal_Clip3(0, 10000,
733 (uint16_t) (encodeStatus->sumSquareError[i] ? 1000 * log10(squarePeakPixelValue * numPixels / encodeStatus->sumSquareError[i]) : -1));
734
735 CODECHAL_ENCODE_VERBOSEMESSAGE("PSNRx100[%d]:%d.\n", i, encodeStatusReport->PSNRx100[i]);
736 }
737
738 return eStatus;
739 }
740
741 MOS_STATUS CodechalEncodeHevcBase::ReleaseBatchBufferForPakSlices(uint32_t index)
742 {
743 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
744
745 if (m_batchBufferForPakSlices[index].iSize)
746 {
747 Mhw_FreeBb(m_osInterface, &m_batchBufferForPakSlices[index], nullptr);
748 m_batchBufferForPakSlices[index].iSize = 0;
749 }
750
751 return eStatus;
752 }
753
754 MOS_STATUS CodechalEncodeHevcBase::FreePakResources()
755 {
756 CODECHAL_ENCODE_FUNCTION_ENTER;
757
758 for (auto i = 0; i < CODECHAL_HEVC_NUM_PAK_SLICE_BATCH_BUFFERS; i++)
759 {
760 ReleaseBatchBufferForPakSlices(i);
761 }
762
763 m_osInterface->pfnFreeResource(m_osInterface, &m_resDeblockingFilterRowStoreScratchBuffer);
764 m_osInterface->pfnFreeResource(m_osInterface, &m_resDeblockingFilterTileRowStoreScratchBuffer);
765 m_osInterface->pfnFreeResource(m_osInterface, &m_resDeblockingFilterColumnRowStoreScratchBuffer);
766 m_osInterface->pfnFreeResource(m_osInterface, &m_resMetadataLineBuffer);
767 m_osInterface->pfnFreeResource(m_osInterface, &m_resMetadataTileLineBuffer);
768 m_osInterface->pfnFreeResource(m_osInterface, &m_resMetadataTileColumnBuffer);
769 m_osInterface->pfnFreeResource(m_osInterface, &m_resSaoLineBuffer);
770 m_osInterface->pfnFreeResource(m_osInterface, &m_resSaoTileLineBuffer);
771 m_osInterface->pfnFreeResource(m_osInterface, &m_resSaoTileColumnBuffer);
772 m_osInterface->pfnFreeResource(m_osInterface, &m_resLcuIldbStreamOutBuffer);
773 m_osInterface->pfnFreeResource(m_osInterface, &m_resLcuBaseAddressBuffer);
774 m_osInterface->pfnFreeResource(m_osInterface, &m_resSaoStreamOutBuffer);
775
776 return MOS_STATUS_SUCCESS;
777 }
778
779 void CodechalEncodeHevcBase::FreeResources()
780 {
781 CODECHAL_ENCODE_FUNCTION_ENTER;
782
783 CodechalEncoderState::FreeResources();
784
785 FreeEncResources();
786 FreeBrcResources();
787 FreePakResources();
788
789 // Release Ref Lists
790 CodecHalFreeDataList(m_refList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC);
791
792 for (uint32_t i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_refSync); i++)
793 {
794 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_refSync[i].resSyncObject);
795 }
796
797 if (m_sliceStateParams)
798 {
799 MOS_Delete(m_sliceStateParams);
800 m_sliceStateParams = nullptr;
801 }
802 if (m_pipeModeSelectParams)
803 {
804 MOS_Delete(m_pipeModeSelectParams);
805 m_pipeModeSelectParams = nullptr;
806 }
807 if (m_pipeBufAddrParams)
808 {
809 MOS_Delete(m_pipeBufAddrParams);
810 m_pipeBufAddrParams = nullptr;
811 }
812 }
813
814 MOS_STATUS CodechalEncodeHevcBase::SetSequenceStructs()
815 {
816 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
817
818 CODECHAL_ENCODE_FUNCTION_ENTER;
819
820 uint32_t frameWidth = (m_hevcSeqParams->wFrameWidthInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3);
821
822 uint32_t frameHeight = (m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3);
823
824 // check if there is a dynamic resolution change
825 if ((m_oriFrameHeight && (m_oriFrameHeight != frameHeight)) ||
826 (m_oriFrameWidth && (m_oriFrameWidth != frameWidth)))
827 {
828 if (frameHeight > m_createHeight || frameWidth > m_createWidth)
829 {
830 CODECHAL_ENCODE_ASSERTMESSAGE("Resolution reset from lower resolution to higher resolution not supported if it is higher than the resolution of first frame.%d, %d %d, %d", m_createWidth, m_createHeight, frameWidth, frameHeight);
831 eStatus = MOS_STATUS_INVALID_PARAMETER;
832 return eStatus;
833 }
834 m_resolutionChanged = true;
835 m_brcInit = true;
836 }
837 else
838 {
839 m_resolutionChanged = false;
840 }
841
842 // setup internal parameters
843 m_oriFrameWidth = m_frameWidth = frameWidth;
844 m_oriFrameHeight = m_frameHeight = frameHeight;
845
846 m_picWidthInMb = (uint16_t)CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_oriFrameWidth);
847 m_picHeightInMb = (uint16_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_oriFrameHeight);
848
849 if (m_resolutionChanged)
850 {
851 m_widthAlignedMaxLcu = MOS_ALIGN_CEIL(m_frameWidth, MAX_LCU_SIZE);
852 m_heightAlignedMaxLcu = MOS_ALIGN_CEIL(m_frameHeight, MAX_LCU_SIZE);
853 }
854
855 // Get row store cache params: as all the needed information is got here
856 if (m_hcpInterface->IsRowStoreCachingSupported())
857 {
858 MHW_VDBOX_ROWSTORE_PARAMS rowstoreParams = {};
859 rowstoreParams.Mode = m_mode;
860 rowstoreParams.dwPicWidth = m_frameWidth;
861 rowstoreParams.ucChromaFormat = m_chromaFormat;
862 rowstoreParams.ucBitDepthMinus8 = m_hevcSeqParams->bit_depth_luma_minus8;
863 rowstoreParams.ucLCUSize = 1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
864 m_hwInterface->SetRowstoreCachingOffsets(&rowstoreParams);
865 }
866
867 m_brcEnabled = IsRateControlBrc(m_hevcSeqParams->RateControlMethod);
868
869 if (m_brcEnabled)
870 {
871 switch (m_hevcSeqParams->MBBRC)
872 {
873 case mbBrcInternal:
874 m_lcuBrcEnabled = (m_hevcSeqParams->TargetUsage == 1);
875 break;
876 case mbBrcDisabled:
877 m_lcuBrcEnabled = false;
878 break;
879 case mbBrcEnabled:
880 m_lcuBrcEnabled = true;
881 break;
882 }
883
884 if (m_hevcSeqParams->RateControlMethod == RATECONTROL_ICQ ||
885 m_hevcSeqParams->RateControlMethod == RATECONTROL_QVBR ||
886 m_hevcPicParams->NumROI)
887 {
888 // ICQ or ROI must result in LCU-based BRC to be enabled.
889 m_lcuBrcEnabled = true;
890 }
891 }
892
893 if (m_hevcSeqParams->RateControlMethod == RATECONTROL_VCM && m_lcuBrcEnabled)
894 {
895 m_lcuBrcEnabled = false; // when VCM is enabled, only frame-based BRC
896 }
897
898 if (m_hevcSeqParams->RateControlMethod == RATECONTROL_ICQ || m_hevcSeqParams->RateControlMethod == RATECONTROL_QVBR)
899 {
900 if (m_hevcSeqParams->ICQQualityFactor < CODECHAL_ENCODE_HEVC_MIN_ICQ_QUALITYFACTOR ||
901 m_hevcSeqParams->ICQQualityFactor > CODECHAL_ENCODE_HEVC_MAX_ICQ_QUALITYFACTOR)
902 {
903 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid ICQ Quality Factor input (%d)\n", m_hevcSeqParams->ICQQualityFactor);
904 eStatus = MOS_STATUS_INVALID_PARAMETER;
905 return eStatus;
906 }
907 }
908
909 m_usAvbrAccuracy = CODECHAL_ENCODE_HEVC_DEFAULT_AVBR_ACCURACY;
910 m_usAvbrConvergence = CODECHAL_ENCODE_HEVC_DEFAULT_AVBR_CONVERGENCE;
911
912 // Calculate 4x, 16x, 32x dimensions as applicable
913 CODECHAL_ENCODE_CHK_STATUS_RETURN(CalcScaledDimensions());
914
915 // It is assumed to be frame-mode always
916 m_frameFieldHeight = m_frameHeight;
917 m_frameFieldHeightInMb = m_picHeightInMb;
918 m_downscaledFrameFieldHeightInMb16x = m_downscaledHeightInMb16x;
919 m_downscaledFrameFieldHeightInMb4x = m_downscaledHeightInMb4x;
920 m_downscaledFrameFieldHeightInMb32x = m_downscaledHeightInMb32x;
921
922 m_brcReset = m_hevcSeqParams->bResetBRC;
923 m_roiValueInDeltaQp = m_hevcSeqParams->ROIValueInDeltaQP;
924
925 uint32_t lcuInRow = MOS_ALIGN_CEIL(m_frameWidth, (1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3))) >> (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
926 uint32_t lcu2MbRatio = (1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3)) / CODECHAL_MACROBLOCK_WIDTH;
927 if (lcuInRow < 1 || lcu2MbRatio < 1)
928 {
929 eStatus = MOS_STATUS_INVALID_PARAMETER;
930 return eStatus;
931 }
932
933 if (m_brcReset &&
934 (!m_brcEnabled ||
935 m_hevcSeqParams->RateControlMethod == RATECONTROL_ICQ))
936 {
937 CODECHAL_ENCODE_ASSERTMESSAGE("BRC Reset cannot be trigerred in CQP/ICQ modes - invalid BRC parameters.");
938 m_brcReset = false;
939 }
940
941 if (m_hevcSeqParams->TargetUsage == 0x07 && !m_enable26WalkingPattern)
942 {
943 m_enable26WalkingPattern = true; // in the performance mode (TU=7), 26z walking pattern is not supported
944 }
945
946 if (!m_32xMeUserfeatureControl && m_32xMeSupported && m_hevcSeqParams->TargetUsage == 0x07)
947 {
948 m_32xMeSupported = false; // TU7 does not support ultra HME
949 }
950
951 m_encode4KSequence = ((m_frameWidth * m_frameHeight) >=
952 (ENCODE_HEVC_4K_PIC_WIDTH * ENCODE_HEVC_4K_PIC_HEIGHT))
953 ? true
954 : false;
955
956 m_encode16KSequence = ((m_frameWidth * m_frameHeight) >=
957 (ENCODE_HEVC_16K_PIC_WIDTH * ENCODE_HEVC_16K_PIC_HEIGHT))
958 ? true
959 : false;
960
961 // if GOP structure is I-frame only, we use 3 non-ref slots for tracked buffer
962 m_gopIsIdrFrameOnly = (m_hevcSeqParams->GopPicSize == 1);
963
964 // check output Chroma format
965 m_outputChromaFormat = m_hevcSeqParams->chroma_format_idc;
966
967 return eStatus;
968 }
969
970 MOS_STATUS CodechalEncodeHevcBase::SetPictureStructs()
971 {
972 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
973
974 CODECHAL_ENCODE_FUNCTION_ENTER;
975
976 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
977 {
978 m_refIdxMapping[i] = -1;
979 m_currUsedRefPic[i] = false;
980 }
981
982 // To obtain current "used" reference frames. The number of current used reference frames cannot be greater than 8
983 auto slcParams = m_hevcSliceParams;
984 for (uint32_t s = 0; s < m_numSlices; s++, slcParams++)
985 {
986 for (auto ll = 0; ll < 2; ll++)
987 {
988 uint32_t numRef = (ll == 0) ? slcParams->num_ref_idx_l0_active_minus1 :
989 slcParams->num_ref_idx_l1_active_minus1;
990
991 if (numRef > CODEC_MAX_NUM_REF_FRAME_HEVC)
992 {
993 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid number of ref frames for l0 %d or l1 %d", slcParams->num_ref_idx_l0_active_minus1, slcParams->num_ref_idx_l1_active_minus1);
994 eStatus = MOS_STATUS_INVALID_PARAMETER;
995 return eStatus;
996 }
997 for (uint32_t i = 0; i <= numRef; i++)
998 {
999 if (i >= CODEC_MAX_NUM_REF_FRAME_HEVC)
1000 {
1001 return MOS_STATUS_INVALID_PARAMETER;
1002 }
1003 CODEC_PICTURE refPic = slcParams->RefPicList[ll][i];
1004 if (!CodecHal_PictureIsInvalid(refPic) &&
1005 !CodecHal_PictureIsInvalid(m_hevcPicParams->RefFrameList[refPic.FrameIdx]))
1006 {
1007 m_currUsedRefPic[refPic.FrameIdx] = true;
1008 }
1009 }
1010 }
1011 }
1012
1013 for (uint8_t i = 0, RefIdx = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1014 {
1015 if (!m_currUsedRefPic[i])
1016 {
1017 continue;
1018 }
1019
1020 uint8_t index = m_hevcPicParams->RefFrameList[i].FrameIdx;
1021 bool duplicatedIdx = false;
1022 for (unsigned char ii = 0; ii < i; ii++)
1023 {
1024 if (m_currUsedRefPic[i] && index == m_hevcPicParams->RefFrameList[ii].FrameIdx)
1025 {
1026 // We find the same FrameIdx in the ref_frame_list. Multiple reference frames are the same.
1027 // In other words, RefFrameList[i] and RefFrameList[ii] have the same surface Id
1028 duplicatedIdx = true;
1029 m_refIdxMapping[i] = m_refIdxMapping[ii];
1030 break;
1031 }
1032 }
1033
1034 if (duplicatedIdx)
1035 {
1036 continue;
1037 }
1038
1039 if (RefIdx >= CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC)
1040 {
1041 // Total number of distingushing reference frames cannot be geater than 8.
1042 CODECHAL_ENCODE_ASSERT(false);
1043 eStatus = MOS_STATUS_INVALID_PARAMETER;
1044 return eStatus;
1045 }
1046
1047 // Map reference frame index [0-15] into a set of unique IDs within [0-7]
1048 m_refIdxMapping[i] = RefIdx;
1049 RefIdx++;
1050 }
1051
1052 if (m_hevcPicParams->CodingType != I_TYPE && m_hevcPicParams->CollocatedRefPicIndex != 0xFF && m_hevcPicParams->CollocatedRefPicIndex < CODEC_MAX_NUM_REF_FRAME_HEVC)
1053 {
1054 uint8_t frameStoreId = (uint8_t)m_refIdxMapping[m_hevcPicParams->CollocatedRefPicIndex];
1055
1056 if (frameStoreId >= CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC || !m_currUsedRefPic[m_hevcPicParams->CollocatedRefPicIndex])
1057 {
1058 // CollocatedRefPicIndex is wrong in this case for the reference frame is not used be used
1059 eStatus = MOS_STATUS_INVALID_PARAMETER;
1060 return eStatus;
1061 }
1062 }
1063
1064 if (m_hevcPicParams->QpY > CODECHAL_ENCODE_HEVC_MAX_SLICE_QP)
1065 {
1066 return MOS_STATUS_INVALID_PARAMETER;
1067 }
1068
1069 if (Mos_ResourceIsNull(&m_reconSurface.OsResource) &&
1070 (!m_hevcPicParams->bUseRawPicForRef || m_codecFunction != CODECHAL_FUNCTION_ENC))
1071 {
1072 return MOS_STATUS_INVALID_PARAMETER;
1073 }
1074
1075 if (m_hevcSeqParams->scaling_list_enable_flag && !m_hevcPicParams->scaling_list_data_present_flag)
1076 {
1077 CreateDefaultScalingList();
1078 }
1079 else if (!m_hevcSeqParams->scaling_list_enable_flag)
1080 {
1081 CreateFlatScalingList();
1082 }
1083
1084 unsigned char prevRefIdx = m_currReconstructedPic.FrameIdx;
1085 PCODEC_REF_LIST *refListFull = &m_refList[0];
1086
1087 // Sync initialize
1088 if ((m_firstFrame) ||
1089 (!m_brcEnabled && m_hevcPicParams->bUseRawPicForRef) ||
1090 (!m_brcEnabled && (m_hevcPicParams->CodingType == I_TYPE)) ||
1091 (!m_brcEnabled && !refListFull[prevRefIdx]->bUsedAsRef))
1092 {
1093 m_waitForPak = false;
1094 }
1095 else
1096 {
1097 m_waitForPak = true;
1098 }
1099
1100 if (m_brcEnabled || m_hevcPicParams->bUsedAsRef)
1101 {
1102 m_signalEnc = true;
1103 }
1104 else
1105 {
1106 m_signalEnc = false;
1107 }
1108
1109 m_currEncBbSet = MB_ENC_Frame_BB;
1110 m_lastPicInSeq = m_hevcPicParams->bLastPicInSeq;
1111 m_lastPicInStream = m_hevcPicParams->bLastPicInStream;
1112 m_statusReportFeedbackNumber = m_hevcPicParams->StatusReportFeedbackNumber;
1113 m_currOriginalPic = m_hevcPicParams->CurrOriginalPic;
1114 m_currReconstructedPic = m_hevcPicParams->CurrReconstructedPic;
1115
1116 unsigned char currRefIdx = m_hevcPicParams->CurrReconstructedPic.FrameIdx;
1117 refListFull[currRefIdx]->sRefReconBuffer = m_reconSurface;
1118 refListFull[currRefIdx]->sRefRawBuffer = m_rawSurface;
1119 refListFull[currRefIdx]->RefPic = m_hevcPicParams->CurrOriginalPic;
1120 refListFull[currRefIdx]->bUsedAsRef = m_hevcPicParams->bUsedAsRef;
1121 refListFull[currRefIdx]->resBitstreamBuffer = m_resBitstreamBuffer;
1122 refListFull[currRefIdx]->bFormatConversionDone = false;
1123
1124 // P/B frames with empty ref lists are internally encoded as I frames,
1125 // while picture header packing remains the original value
1126 m_pictureCodingType = m_hevcPicParams->CodingType;
1127
1128 bool emptyRefFrmList = true;
1129 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1130 {
1131 if (m_hevcPicParams->RefFrameList[i].PicFlags != PICTURE_INVALID)
1132 {
1133 emptyRefFrmList = false;
1134 break;
1135 }
1136 }
1137
1138 if (emptyRefFrmList && m_pictureCodingType != I_TYPE)
1139 {
1140 // If there is no reference frame in the list, just mark the current picture as the I type
1141 m_pictureCodingType = I_TYPE;
1142 }
1143
1144 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1145 {
1146 m_picIdx[i].bValid = false;
1147 if (m_hevcPicParams->RefFrameList[i].PicFlags != PICTURE_INVALID)
1148 {
1149 uint8_t index = m_hevcPicParams->RefFrameList[i].FrameIdx;
1150 bool duplicatedIdx = false;
1151 for (auto ii = 0; ii < i; ii++)
1152 {
1153 if (m_picIdx[ii].bValid && index == m_hevcPicParams->RefFrameList[ii].FrameIdx)
1154 {
1155 // We find the same FrameIdx in the ref_frame_list. Multiple reference frames are the same.
1156 // In other words, RefFrameList[i] and RefFrameList[ii] have the same surface Id
1157 duplicatedIdx = true;
1158 break;
1159 }
1160 }
1161
1162 if (duplicatedIdx)
1163 {
1164 continue;
1165 }
1166
1167 // this reference frame in unique. Save it into the full reference list with 127 items
1168 refListFull[index]->RefPic.PicFlags =
1169 CodecHal_CombinePictureFlags(refListFull[index]->RefPic, m_hevcPicParams->RefFrameList[i]);
1170 refListFull[index]->iFieldOrderCnt[0] = m_hevcPicParams->RefFramePOCList[i];
1171 refListFull[index]->iFieldOrderCnt[1] = m_hevcPicParams->RefFramePOCList[i];
1172 refListFull[index]->sRefBuffer = m_hevcPicParams->bUseRawPicForRef ? refListFull[index]->sRefRawBuffer : refListFull[index]->sRefReconBuffer;
1173
1174 m_picIdx[i].bValid = true;
1175 m_picIdx[i].ucPicIdx = index;
1176 }
1177 }
1178
1179 // Save the current RefList
1180 uint8_t ii = 0;
1181 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
1182 {
1183 if (m_picIdx[i].bValid)
1184 {
1185 refListFull[currRefIdx]->RefList[ii] = m_hevcPicParams->RefFrameList[i];
1186 ii++;
1187 }
1188 }
1189 refListFull[currRefIdx]->ucNumRef = ii;
1190 m_currRefList = refListFull[currRefIdx];
1191
1192 CodecEncodeHevcFeiPicParams *feiPicParams = (CodecEncodeHevcFeiPicParams *)m_encodeParams.pFeiPicParams;
1193 if ((m_codecFunction == CODECHAL_FUNCTION_ENC_PAK) ||
1194 ((m_codecFunction == CODECHAL_FUNCTION_FEI_ENC_PAK) && (feiPicParams->bCTBCmdCuRecordEnable == false)) ||
1195 (m_codecFunction == CODECHAL_FUNCTION_ENC_VDENC_PAK))
1196 {
1197 m_currMinus2MbCodeIndex = m_lastMbCodeIndex;
1198 m_lastMbCodeIndex = m_currMbCodeIdx;
1199 // the actual MbCode/MvData surface to be allocated later
1200 m_trackedBuf->SetAllocationFlag(true);
1201 }
1202 else if (m_codecFunction == CODECHAL_FUNCTION_ENC)
1203 {
1204 CODECHAL_ENCODE_CHK_NULL_RETURN(m_encodeParams.presMbCodeSurface);
1205 m_resMbCodeSurface = *m_encodeParams.presMbCodeSurface;
1206 }
1207 else if(((m_codecFunction == CODECHAL_FUNCTION_FEI_ENC_PAK) && feiPicParams->bCTBCmdCuRecordEnable) ||
1208 (m_codecFunction == CODECHAL_FUNCTION_FEI_ENC) ||
1209 (m_codecFunction == CODECHAL_FUNCTION_FEI_PAK))
1210 {
1211 if(Mos_ResourceIsNull(&feiPicParams->resCURecord) || Mos_ResourceIsNull(&feiPicParams->resCTBCmd))
1212 {
1213 return MOS_STATUS_INVALID_PARAMETER;
1214 }
1215 }
1216
1217 refListFull[currRefIdx]->iFieldOrderCnt[0] = m_hevcPicParams->CurrPicOrderCnt;
1218 refListFull[currRefIdx]->iFieldOrderCnt[1] = m_hevcPicParams->CurrPicOrderCnt;
1219
1220 m_hmeEnabled = m_hmeSupported && m_pictureCodingType != I_TYPE;
1221 m_b16XMeEnabled = m_16xMeSupported && m_pictureCodingType != I_TYPE;
1222 m_b32XMeEnabled = m_32xMeSupported && m_pictureCodingType != I_TYPE;
1223
1224 CODECHAL_ENCODE_CHK_STATUS_RETURN(CalcLCUMaxCodingSize());
1225
1226 // Screen content flag will come in with PPS on Linux/Android, but in SPS on other platforms,
1227 // we will use screen content flag in PPS for kernel programming, and update
1228 // the PPS screen content flag based on the SPS screen content flag if enabled.
1229 m_hevcPicParams->bScreenContent |= m_hevcSeqParams->bScreenContent;
1230
1231 return eStatus;
1232 }
1233
1234 MOS_STATUS CodechalEncodeHevcBase::CalcLCUMaxCodingSize()
1235 {
1236 CODECHAL_ENCODE_FUNCTION_ENTER;
1237
1238 uint16_t log2_max_coding_block_size = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
1239 uint32_t rawCTUBits = (1 << (2 * log2_max_coding_block_size));
1240
1241 switch (m_hevcSeqParams->chroma_format_idc)
1242 {
1243 // 420
1244 case 1:
1245 rawCTUBits = rawCTUBits * 3 / 2;
1246 break;
1247 // 422
1248 case 2:
1249 rawCTUBits = rawCTUBits * 2;
1250 break;
1251 // 444
1252 case 3:
1253 rawCTUBits = rawCTUBits * 3;
1254 break;
1255 default:
1256 break;
1257 };
1258
1259 rawCTUBits = rawCTUBits * (m_hevcSeqParams->bit_depth_luma_minus8 + 8);
1260 rawCTUBits = (5 * rawCTUBits / 3);
1261
1262 if (m_hevcPicParams->LcuMaxBitsizeAllowed == 0 || m_hevcPicParams->LcuMaxBitsizeAllowed > rawCTUBits)
1263 {
1264 m_hevcPicParams->LcuMaxBitsizeAllowed = rawCTUBits;
1265 }
1266
1267 return MOS_STATUS_SUCCESS;
1268 }
1269
1270 MOS_STATUS CodechalEncodeHevcBase::SetSliceStructs()
1271 {
1272 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1273
1274 CODECHAL_ENCODE_FUNCTION_ENTER;
1275
1276 if (m_numSlices > m_maxNumSlicesSupported)
1277 {
1278 CODECHAL_ENCODE_ASSERTMESSAGE("Number of slice exceeds limit!");
1279 return MOS_STATUS_INVALID_PARAMETER;
1280 }
1281
1282 // first slice must come with slice_segment_address = 0
1283 if (m_hevcSliceParams->slice_segment_address != 0)
1284 {
1285 CODECHAL_ENCODE_ASSERTMESSAGE("First slice segment_address != 0!");
1286 return MOS_STATUS_INVALID_PARAMETER;
1287 }
1288
1289 m_refList[m_currReconstructedPic.FrameIdx]->ucQPValue[0] = m_hevcPicParams->QpY + m_hevcSliceParams->slice_qp_delta;
1290
1291 m_lowDelay = true;
1292 m_sameRefList = true;
1293 m_arbitraryNumMbsInSlice = false;
1294
1295 uint32_t lcuInRow = MOS_ALIGN_CEIL(m_frameWidth, (1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3))) >> (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
1296 auto slcParams = m_hevcSliceParams;
1297 for (uint32_t startLCU = 0, slcCount = 0; slcCount < m_numSlices; slcCount++, slcParams++)
1298 {
1299 CODECHAL_ENCODE_CHK_STATUS_RETURN(ValidateRefFrameData(slcParams));
1300
1301 if ((m_hevcPicParams->QpY + slcParams->slice_qp_delta) > CODECHAL_ENCODE_HEVC_MAX_SLICE_QP)
1302 {
1303 eStatus = MOS_STATUS_INVALID_PARAMETER;
1304 return eStatus;
1305 }
1306
1307 CODECHAL_ENCODE_CHK_STATUS_RETURN(ValidateLowDelayBFrame(slcParams));
1308
1309 CODECHAL_ENCODE_CHK_STATUS_RETURN(ValidateSameRefInL0L1(slcParams));
1310
1311 if (m_arbitraryNumMbsInSlice == false && (slcParams->NumLCUsInSlice % lcuInRow))
1312 {
1313 // Slice number must be multiple of LCU rows
1314 m_arbitraryNumMbsInSlice = true;
1315 }
1316
1317 if (!m_hevcPicParams->tiles_enabled_flag)
1318 {
1319 CODECHAL_ENCODE_ASSERT(slcParams->slice_segment_address == startLCU);
1320 startLCU += slcParams->NumLCUsInSlice;
1321 }
1322 }
1323
1324 if (m_lowDelay && !m_sameRefList)
1325 {
1326 CODECHAL_ENCODE_NORMALMESSAGE("Attention: LDB frame but with different L0/L1 list !");
1327 }
1328
1329 if (m_hevcSeqParams->RateControlMethod == RATECONTROL_VCM && m_pictureCodingType == B_TYPE && !m_lowDelay)
1330 {
1331 CODECHAL_ENCODE_ASSERTMESSAGE("VCM BRC mode does not support regular B-frames\n");
1332 return MOS_STATUS_INVALID_PARAMETER;
1333 }
1334
1335 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySliceSAOState());
1336
1337 #if (_DEBUG || _RELEASE_INTERNAL)
1338 if (!m_vdencEnabled)
1339 {
1340 m_forceSinglePakPass = false;
1341 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
1342 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1343 //read user feature key for pak pass number forcing.
1344 MOS_UserFeature_ReadValue_ID(
1345 nullptr,
1346 __MEDIA_USER_FEATURE_VALUE_FORCE_PAK_PASS_NUM_ID,
1347 &userFeatureData,
1348 m_osInterface->pOsContext);
1349 if (userFeatureData.u32Data > 0 && userFeatureData.u32Data <= m_numPasses)
1350 {
1351 m_numPasses = (uint8_t)userFeatureData.u32Data - 1;
1352 if (m_numPasses == 0)
1353 {
1354 m_forceSinglePakPass = true;
1355 CODECHAL_ENCODE_VERBOSEMESSAGE("Force to single PAK pass\n");
1356 }
1357 }
1358 }
1359 #endif
1360 return eStatus;
1361 }
1362
1363 MOS_STATUS CodechalEncodeHevcBase::ValidateSameRefInL0L1(PCODEC_HEVC_ENCODE_SLICE_PARAMS slcParams)
1364 {
1365 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1366
1367 CODECHAL_ENCODE_FUNCTION_ENTER;
1368
1369 CODECHAL_ENCODE_CHK_NULL_RETURN(slcParams);
1370
1371 if (m_sameRefList &&
1372 slcParams->num_ref_idx_l0_active_minus1 >= slcParams->num_ref_idx_l1_active_minus1)
1373 {
1374 for (int refIdx = 0; refIdx < slcParams->num_ref_idx_l1_active_minus1 + 1; refIdx++)
1375 {
1376 CODEC_PICTURE refPicL0 = slcParams->RefPicList[0][refIdx];
1377 CODEC_PICTURE refPicL1 = slcParams->RefPicList[1][refIdx];
1378
1379 if (!CodecHal_PictureIsInvalid(refPicL0) && !CodecHal_PictureIsInvalid(refPicL1) && refPicL0.FrameIdx != refPicL1.FrameIdx)
1380 {
1381 m_sameRefList = false;
1382 break;
1383 }
1384 }
1385 }
1386
1387 return eStatus;
1388 }
1389
1390 MOS_STATUS CodechalEncodeHevcBase::ValidateLowDelayBFrame(PCODEC_HEVC_ENCODE_SLICE_PARAMS slcParams)
1391 {
1392 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1393
1394 CODECHAL_ENCODE_FUNCTION_ENTER;
1395
1396 CODECHAL_ENCODE_CHK_NULL_RETURN(slcParams);
1397
1398 // Examine if now it is in the low delay mode
1399 if (slcParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE && m_lowDelay)
1400 {
1401 // forward
1402 for (int refIdx = 0; (refIdx < slcParams->num_ref_idx_l0_active_minus1 + 1) && m_lowDelay; refIdx++)
1403 {
1404 if (refIdx >= CODEC_MAX_NUM_REF_FRAME_HEVC)
1405 {
1406 break;
1407 }
1408
1409 CODEC_PICTURE refPic = slcParams->RefPicList[0][refIdx];
1410 if (!CodecHal_PictureIsInvalid(refPic) && m_hevcPicParams->RefFramePOCList[refPic.FrameIdx] > m_hevcPicParams->CurrPicOrderCnt)
1411 {
1412 m_lowDelay = false;
1413 }
1414 }
1415
1416 // backward
1417 for (int refIdx = 0; (refIdx < slcParams->num_ref_idx_l1_active_minus1 + 1) && m_lowDelay; refIdx++)
1418 {
1419 if (refIdx >= CODEC_MAX_NUM_REF_FRAME_HEVC)
1420 {
1421 break;
1422 }
1423
1424 CODEC_PICTURE refPic = slcParams->RefPicList[1][refIdx];
1425 if (!CodecHal_PictureIsInvalid(refPic) && m_hevcPicParams->RefFramePOCList[refPic.FrameIdx] > m_hevcPicParams->CurrPicOrderCnt)
1426 {
1427 m_lowDelay = false;
1428 }
1429 }
1430 }
1431
1432 return eStatus;
1433 }
1434
1435 MOS_STATUS CodechalEncodeHevcBase::VerifySliceSAOState()
1436 {
1437 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1438
1439 CODECHAL_ENCODE_FUNCTION_ENTER;
1440
1441 if (m_hevcSeqParams->SAO_enabled_flag)
1442 {
1443 auto slcParams = m_hevcSliceParams;
1444 uint32_t slcSaoLumaCount = 0, slcSaoChromaCount = 0;
1445
1446 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++, slcParams++)
1447 {
1448 slcSaoLumaCount += slcParams->slice_sao_luma_flag;
1449 slcSaoChromaCount += slcParams->slice_sao_chroma_flag;
1450 }
1451
1452 // For HCP_SLICE_STATE command, slices must have the same SAO setting within a picture for encoder.
1453 if (((slcSaoLumaCount > 0) && (slcSaoLumaCount != m_numSlices)) ||
1454 ((slcSaoChromaCount > 0) && (slcSaoChromaCount != m_numSlices)))
1455 {
1456 m_hevcSeqParams->SAO_enabled_flag = false;
1457 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid SAO parameters in slice. All slices must have the same SAO setting within a picture.");
1458 }
1459 }
1460
1461 m_uc2NdSaoPass = 0; // Assume there is no 2nd SAO pass
1462
1463 if (m_hevcSeqParams->SAO_enabled_flag && m_b2NdSaoPassNeeded)
1464 {
1465 m_numPasses = m_numPasses + 1; // one more pass for the 2nd SAO, i.e., BRC0, BRC1, ..., BRCn, and SAOn+1
1466 m_uc2NdSaoPass = m_numPasses;
1467 }
1468
1469 return eStatus;
1470 }
1471
1472 MOS_STATUS CodechalEncodeHevcBase::UpdateYUY2SurfaceInfo(
1473 PMOS_SURFACE surface,
1474 bool is10Bit)
1475 {
1476 CODECHAL_ENCODE_FUNCTION_ENTER;
1477
1478 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1479
1480 CODECHAL_ENCODE_CHK_NULL_RETURN(surface);
1481
1482 if (Format_YUY2V == surface->Format ||
1483 Format_Y216V == surface->Format)
1484 {
1485 // surface has been updated
1486 return eStatus;
1487 }
1488
1489 surface->Format = is10Bit ? Format_Y216V : Format_YUY2V;
1490 surface->dwWidth = m_oriFrameWidth;
1491 surface->dwHeight = m_oriFrameHeight;
1492
1493 surface->YPlaneOffset.iXOffset = 0;
1494 surface->YPlaneOffset.iYOffset = 0;
1495
1496 surface->UPlaneOffset.iSurfaceOffset = surface->YPlaneOffset.iSurfaceOffset + surface->dwHeight * surface->dwPitch;
1497 surface->UPlaneOffset.iXOffset = 0;
1498 surface->UPlaneOffset.iYOffset = surface->dwHeight;
1499
1500 surface->VPlaneOffset.iSurfaceOffset = surface->UPlaneOffset.iSurfaceOffset;
1501 surface->VPlaneOffset.iXOffset = 0;
1502 surface->VPlaneOffset.iYOffset = surface->dwHeight;
1503
1504 return eStatus;
1505 }
1506
1507 void CodechalEncodeHevcBase::CreateFlatScalingList()
1508 {
1509 CODECHAL_ENCODE_FUNCTION_ENTER;
1510
1511 for (auto i = 0; i < 6; i++)
1512 {
1513 memset(&(m_hevcIqMatrixParams->ucScalingLists0[i][0]),
1514 0x10,
1515 sizeof(m_hevcIqMatrixParams->ucScalingLists0[i]));
1516
1517 memset(&(m_hevcIqMatrixParams->ucScalingLists1[i][0]),
1518 0x10,
1519 sizeof(m_hevcIqMatrixParams->ucScalingLists1[i]));
1520
1521 memset(&(m_hevcIqMatrixParams->ucScalingLists2[i][0]),
1522 0x10,
1523 sizeof(m_hevcIqMatrixParams->ucScalingLists2[i]));
1524 }
1525
1526 memset(&(m_hevcIqMatrixParams->ucScalingLists3[0][0]),
1527 0x10,
1528 sizeof(m_hevcIqMatrixParams->ucScalingLists3[0]));
1529
1530 memset(&(m_hevcIqMatrixParams->ucScalingLists3[1][0]),
1531 0x10,
1532 sizeof(m_hevcIqMatrixParams->ucScalingLists3[1]));
1533
1534 memset(&(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID2[0]),
1535 0x10,
1536 sizeof(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID2));
1537
1538 memset(&(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID3[0]),
1539 0x10,
1540 sizeof(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID3));
1541 }
1542
1543 void CodechalEncodeHevcBase::CreateDefaultScalingList()
1544 {
1545 CODECHAL_ENCODE_FUNCTION_ENTER;
1546
1547 const uint8_t flatScalingList4x4[16] =
1548 {
1549 16,16,16,16,
1550 16,16,16,16,
1551 16,16,16,16,
1552 16,16,16,16
1553 };
1554
1555 const uint8_t defaultScalingList8x8[2][64] =
1556 {
1557 {
1558 16,16,16,16,17,18,21,24,
1559 16,16,16,16,17,19,22,25,
1560 16,16,17,18,20,22,25,29,
1561 16,16,18,21,24,27,31,36,
1562 17,17,20,24,30,35,41,47,
1563 18,19,22,27,35,44,54,65,
1564 21,22,25,31,41,54,70,88,
1565 24,25,29,36,47,65,88,115
1566 },
1567 {
1568 16,16,16,16,17,18,20,24,
1569 16,16,16,17,18,20,24,25,
1570 16,16,17,18,20,24,25,28,
1571 16,17,18,20,24,25,28,33,
1572 17,18,20,24,25,28,33,41,
1573 18,20,24,25,28,33,41,54,
1574 20,24,25,28,33,41,54,71,
1575 24,25,28,33,41,54,71,91
1576 }
1577 };
1578
1579 for (auto i = 0; i < 6; i++)
1580 {
1581 memcpy(&(m_hevcIqMatrixParams->ucScalingLists0[i][0]),
1582 flatScalingList4x4,
1583 sizeof(m_hevcIqMatrixParams->ucScalingLists0[i]));
1584 }
1585
1586 for (auto i = 0; i < 3; i++)
1587 {
1588 memcpy(&(m_hevcIqMatrixParams->ucScalingLists1[i][0]),
1589 defaultScalingList8x8[0],
1590 sizeof(m_hevcIqMatrixParams->ucScalingLists1[i]));
1591
1592 memcpy(&(m_hevcIqMatrixParams->ucScalingLists1[3 + i][0]),
1593 defaultScalingList8x8[1],
1594 sizeof(m_hevcIqMatrixParams->ucScalingLists1[3 + i]));
1595
1596 memcpy(&(m_hevcIqMatrixParams->ucScalingLists2[i][0]),
1597 defaultScalingList8x8[0],
1598 sizeof(m_hevcIqMatrixParams->ucScalingLists2[i]));
1599
1600 memcpy(&(m_hevcIqMatrixParams->ucScalingLists2[3 + i][0]),
1601 defaultScalingList8x8[1],
1602 sizeof(m_hevcIqMatrixParams->ucScalingLists2[3 + i]));
1603 }
1604
1605 memcpy(&(m_hevcIqMatrixParams->ucScalingLists3[0][0]),
1606 defaultScalingList8x8[0],
1607 sizeof(m_hevcIqMatrixParams->ucScalingLists3[0]));
1608
1609 memcpy(&(m_hevcIqMatrixParams->ucScalingLists3[1][0]),
1610 defaultScalingList8x8[1],
1611 sizeof(m_hevcIqMatrixParams->ucScalingLists3[1]));
1612
1613 memset(&(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID2[0]),
1614 0x10,
1615 sizeof(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID2));
1616
1617 memset(&(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID3[0]),
1618 0x10,
1619 sizeof(m_hevcIqMatrixParams->ucScalingListDCCoefSizeID3));
1620 }
1621
1622 MOS_STATUS CodechalEncodeHevcBase::VerifyCommandBufferSize()
1623 {
1624 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1625
1626 CODECHAL_ENCODE_FUNCTION_ENTER;
1627
1628 // resize CommandBuffer Size for every BRC pass
1629 if (!m_singleTaskPhaseSupported)
1630 {
1631 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
1632 }
1633 return eStatus;
1634 }
1635
1636 MOS_STATUS CodechalEncodeHevcBase::GetCommandBuffer(PMOS_COMMAND_BUFFER cmdBuffer)
1637 {
1638 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1639
1640 CODECHAL_ENCODE_FUNCTION_ENTER;
1641
1642 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1643
1644 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, cmdBuffer, 0));
1645
1646 return eStatus;
1647
1648 }
1649
1650 MOS_STATUS CodechalEncodeHevcBase::ReturnCommandBuffer(PMOS_COMMAND_BUFFER cmdBuffer)
1651 {
1652 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1653
1654 CODECHAL_ENCODE_FUNCTION_ENTER;
1655
1656 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1657
1658 m_osInterface->pfnReturnCommandBuffer(m_osInterface, cmdBuffer, 0);
1659 return eStatus;
1660 }
1661
1662 MOS_STATUS CodechalEncodeHevcBase::SubmitCommandBuffer(
1663 PMOS_COMMAND_BUFFER cmdBuffer,
1664 bool bNullRendering)
1665 {
1666 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1667
1668 CODECHAL_ENCODE_FUNCTION_ENTER;
1669
1670 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1671
1672 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, cmdBuffer, bNullRendering));
1673 return eStatus;
1674 }
1675
1676 MOS_STATUS CodechalEncodeHevcBase::SendPrologWithFrameTracking(
1677 PMOS_COMMAND_BUFFER cmdBuffer,
1678 bool frameTrackingRequested,
1679 MHW_MI_MMIOREGISTERS *mmioRegister)
1680 {
1681 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1682
1683 CODECHAL_ENCODE_FUNCTION_ENTER;
1684
1685 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1686
1687 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::SendPrologWithFrameTracking(cmdBuffer, frameTrackingRequested, mmioRegister));
1688
1689 return eStatus;
1690 }
1691
1692 MOS_STATUS CodechalEncodeHevcBase::GetMaxMBPS(uint32_t levelIdc, uint32_t* maxMBPS, uint64_t* maxBytePerPic)
1693 {
1694 CODECHAL_ENCODE_FUNCTION_ENTER;
1695
1696 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1697
1698 CODECHAL_ENCODE_CHK_NULL_RETURN(maxMBPS);
1699 CODECHAL_ENCODE_CHK_NULL_RETURN(maxBytePerPic);
1700
1701 switch (levelIdc)
1702 {
1703 case 30:
1704 *maxMBPS = 552960;
1705 *maxBytePerPic = 36864; break;
1706 case 60:
1707 *maxMBPS = 3686400;
1708 *maxBytePerPic = 122880; break;
1709 case 63:
1710 *maxMBPS = 7372800;
1711 *maxBytePerPic = 245760; break;
1712 case 90:
1713 *maxMBPS = 16588800;
1714 *maxBytePerPic = 552760; break;
1715 case 93:
1716 *maxMBPS = 33177600;
1717 *maxBytePerPic = 983040; break;
1718 case 120:
1719 *maxMBPS = 66846720;
1720 *maxBytePerPic = 2228224; break;
1721 case 123:
1722 *maxMBPS = 133693440;
1723 *maxBytePerPic = 2228224; break;
1724 case 150:
1725 *maxMBPS = 267386880;
1726 *maxBytePerPic = 8912896; break;
1727 case 153:
1728 *maxMBPS = 534773760;
1729 *maxBytePerPic = 8912896; break;
1730 case 156:
1731 *maxMBPS = 1069547520;
1732 *maxBytePerPic = 8912896; break;
1733 case 180:
1734 *maxMBPS = 1069547520;
1735 *maxBytePerPic = 35651584; break;
1736 case 183:
1737 *maxMBPS = 2139095040;
1738 *maxBytePerPic = 35651584; break;
1739 case 186:
1740 *maxMBPS = 4278190080;
1741 *maxBytePerPic = 35651584; break;
1742 default:
1743 *maxMBPS = 16588800;
1744 *maxBytePerPic = 552760; // CModel defaults to level 3.0 value if not found,
1745 // we can do the same, just output that the issue exists and continue
1746 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported LevelIDC setting for HEVC");
1747 break;
1748 }
1749
1750 return eStatus;
1751 }
1752
1753 uint32_t CodechalEncodeHevcBase::GetProfileLevelMaxFrameSize()
1754 {
1755 CODECHAL_ENCODE_FUNCTION_ENTER;
1756
1757 uint8_t minCR = 2;
1758 float_t formatFactor = 1.5;
1759 float_t fminCrScale = 1.0;
1760 uint32_t maxMBPS;
1761 uint64_t maxBytePerPic;
1762 int32_t levelIdc = m_hevcSeqParams->Level * 3;
1763
1764 if (levelIdc == 186 || levelIdc == 150)
1765 {
1766 minCR = 6;
1767 }
1768 else if (levelIdc >150)
1769 {
1770 minCR = 8;
1771 }
1772 else if (levelIdc >93)
1773 {
1774 minCR = 4;
1775 }
1776
1777 if (m_hevcSeqParams->chroma_format_idc == 0)
1778 {
1779 if (m_hevcSeqParams->bit_depth_luma_minus8 == 0)
1780 formatFactor = 1.0;
1781 else if (m_hevcSeqParams->bit_depth_luma_minus8 == 8)
1782 formatFactor = 2.0;
1783 }
1784 else if (m_hevcSeqParams->chroma_format_idc == 1)
1785 {
1786 if (m_hevcSeqParams->bit_depth_luma_minus8 == 2)
1787 {
1788 formatFactor = 1.875;
1789 }
1790 else if (m_hevcSeqParams->bit_depth_luma_minus8 == 4)
1791 {
1792 formatFactor = 2.25;
1793 }
1794 }
1795 else if (m_hevcSeqParams->chroma_format_idc == 2)
1796 {
1797 fminCrScale = 0.5;
1798 if (m_hevcSeqParams->bit_depth_luma_minus8 == 2)
1799 {
1800 formatFactor = 2.5;
1801 }
1802 else if (m_hevcSeqParams->bit_depth_luma_minus8 == 4)
1803 {
1804 formatFactor = 3.0;
1805 }
1806 }
1807 else
1808 {
1809 fminCrScale = 0.5;
1810 formatFactor = 3.0;
1811
1812 if (m_hevcSeqParams->bit_depth_luma_minus8 == 2)
1813 {
1814 formatFactor = 3.75;
1815 }
1816 else if (m_hevcSeqParams->bit_depth_luma_minus8 == 4)
1817 {
1818 formatFactor = 4.5;
1819 }
1820 }
1821
1822 fminCrScale *= minCR;
1823 formatFactor /= fminCrScale;
1824 GetMaxMBPS(levelIdc, &maxMBPS, &maxBytePerPic);
1825 auto maxBytePerPicNot0 = (uint64_t)((((float_t)maxMBPS * (float_t)m_hevcSeqParams->FrameRate.Denominator) / (float_t)m_hevcSeqParams->FrameRate.Numerator) * formatFactor);
1826 uint32_t profileLevelMaxFrame = 0;
1827
1828 uint32_t userMaxFrameSize = m_hevcSeqParams->UserMaxIFrameSize;
1829 if ((m_hevcPicParams->CodingType != I_TYPE) && (m_hevcSeqParams->UserMaxPBFrameSize > 0))
1830 {
1831 userMaxFrameSize = m_hevcSeqParams->UserMaxPBFrameSize;
1832 }
1833
1834 if (userMaxFrameSize != 0)
1835 {
1836 profileLevelMaxFrame = (uint32_t)MOS_MIN(userMaxFrameSize, maxBytePerPic);
1837 profileLevelMaxFrame = (uint32_t)MOS_MIN(maxBytePerPicNot0, profileLevelMaxFrame);
1838 }
1839 else {
1840 profileLevelMaxFrame = (uint32_t)MOS_MIN(maxBytePerPicNot0, maxBytePerPic);
1841 }
1842
1843 profileLevelMaxFrame = (uint32_t)MOS_MIN((m_frameHeight * m_frameWidth), profileLevelMaxFrame);
1844
1845 return profileLevelMaxFrame;
1846 }
1847
1848 void CodechalEncodeHevcBase::CalcTransformSkipParameters(
1849 MHW_VDBOX_ENCODE_HEVC_TRANSFORM_SKIP_PARAMS& params)
1850 {
1851 CODECHAL_ENCODE_FUNCTION_ENTER;
1852
1853 if (!m_hevcPicParams->transform_skip_enabled_flag)
1854 {
1855 return;
1856 }
1857
1858 params.Transformskip_enabled = true;
1859 int sliceQP = CalSliceQp();
1860
1861 int qpIdx = 0;
1862 if (sliceQP <= 22)
1863 {
1864 qpIdx = 0;
1865 }
1866 else if (sliceQP <= 27)
1867 {
1868 qpIdx = 1;
1869 }
1870 else if (sliceQP <= 32)
1871 {
1872 qpIdx = 2;
1873 }
1874 else
1875 {
1876 qpIdx = 3;
1877 }
1878
1879 params.Transformskip_lambda = TransformSkipLambdaTable[sliceQP];
1880
1881 if (m_hevcPicParams->CodingType == I_TYPE)
1882 {
1883 params.Transformskip_Numzerocoeffs_Factor0 = TransformSkipCoeffsTable[qpIdx][0][0][0][0];
1884 params.Transformskip_Numzerocoeffs_Factor1 = TransformSkipCoeffsTable[qpIdx][0][0][1][0];
1885 params.Transformskip_Numnonzerocoeffs_Factor0 = TransformSkipCoeffsTable[qpIdx][0][0][0][1] + 32;
1886 params.Transformskip_Numnonzerocoeffs_Factor1 = TransformSkipCoeffsTable[qpIdx][0][0][1][1] + 32;
1887 }
1888 else
1889 {
1890 params.Transformskip_Numzerocoeffs_Factor0 = TransformSkipCoeffsTable[qpIdx][1][0][0][0];
1891 params.Transformskip_Numzerocoeffs_Factor1 = TransformSkipCoeffsTable[qpIdx][1][0][1][0];
1892 params.Transformskip_Numnonzerocoeffs_Factor0 = TransformSkipCoeffsTable[qpIdx][1][0][0][1] + 32;
1893 params.Transformskip_Numnonzerocoeffs_Factor1 = TransformSkipCoeffsTable[qpIdx][1][0][1][1] + 32;
1894 }
1895 }
1896
1897 MOS_STATUS CodechalEncodeHevcBase::SetSemaphoreMem(
1898 PMOS_RESOURCE semaphoreMem,
1899 PMOS_COMMAND_BUFFER cmdBuffer,
1900 uint32_t value)
1901 {
1902 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1903
1904 CODECHAL_ENCODE_FUNCTION_ENTER;
1905
1906 CODECHAL_ENCODE_CHK_NULL_RETURN(semaphoreMem);
1907 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1908
1909 MHW_MI_STORE_DATA_PARAMS storeDataParams;
1910 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
1911 storeDataParams.pOsResource = semaphoreMem;
1912 storeDataParams.dwResourceOffset = 0;
1913 storeDataParams.dwValue = value;
1914
1915 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
1916 cmdBuffer,
1917 &storeDataParams));
1918
1919 return eStatus;
1920 }
1921
1922 MOS_STATUS CodechalEncodeHevcBase::SendHWWaitCommand(
1923 PMOS_RESOURCE semaphoreMem,
1924 PMOS_COMMAND_BUFFER cmdBuffer,
1925 uint32_t semValue)
1926 {
1927 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1928
1929 CODECHAL_ENCODE_FUNCTION_ENTER;
1930
1931 CODECHAL_ENCODE_CHK_NULL_RETURN(semaphoreMem);
1932 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1933
1934 MHW_MI_SEMAPHORE_WAIT_PARAMS miSemaphoreWaitParams;
1935 MOS_ZeroMemory(&miSemaphoreWaitParams, sizeof(miSemaphoreWaitParams));
1936 miSemaphoreWaitParams.presSemaphoreMem = semaphoreMem;
1937 miSemaphoreWaitParams.bPollingWaitMode = true;
1938 miSemaphoreWaitParams.dwSemaphoreData = semValue;
1939 miSemaphoreWaitParams.CompareOperation = MHW_MI_SAD_EQUAL_SDD;
1940
1941 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiSemaphoreWaitCmd(cmdBuffer, &miSemaphoreWaitParams));
1942
1943 return eStatus;
1944 }
1945
1946 MOS_STATUS CodechalEncodeHevcBase::SendMIAtomicCmd(
1947 PMOS_RESOURCE semaMem,
1948 uint32_t immData,
1949 MHW_COMMON_MI_ATOMIC_OPCODE opCode,
1950 PMOS_COMMAND_BUFFER cmdBuffer
1951 )
1952 {
1953 MHW_MI_ATOMIC_PARAMS atomicParams;
1954 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1955
1956 CODECHAL_ENCODE_FUNCTION_ENTER;
1957
1958 MOS_ZeroMemory((&atomicParams), sizeof(atomicParams));
1959 atomicParams.pOsResource = semaMem;
1960 atomicParams.dwDataSize = sizeof(uint32_t);
1961 atomicParams.Operation = opCode;
1962 atomicParams.bInlineData = true;
1963 atomicParams.dwOperand1Data[0] = immData;
1964 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiAtomicCmd(cmdBuffer, &atomicParams));
1965
1966 return eStatus;
1967 }
1968
1969 MOS_STATUS CodechalEncodeHevcBase::WaitForVDBOX(PMOS_COMMAND_BUFFER cmdBuffer)
1970 {
1971 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1972
1973 CODECHAL_ENCODE_FUNCTION_ENTER;
1974
1975 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1976
1977 if (!m_firstFrame &&
1978 !Mos_ResourceIsNull(&m_refSync[m_lastMbCodeIndex].resSemaphoreMem.sResource))
1979 {
1980 CODECHAL_ENCODE_CHK_STATUS_RETURN(
1981 SendHWWaitCommand(
1982 &m_refSync[m_lastMbCodeIndex].resSemaphoreMem.sResource,
1983 cmdBuffer,
1984 1));
1985 }
1986
1987 //keep these codes here, in case later we need support parallel frame PAK (need more than one set of internal buffers used by PAK HW).
1988 #if 0
1989 if (m_pictureCodingType == I_TYPE)
1990 {
1991 return eStatus;
1992 }
1993
1994 bool refHasBeenWaited[CODEC_NUM_TRACKED_BUFFERS] = { false };
1995
1996 // check all reference frames. If one of them has not be waited, then it needs to be wait and ensure it has been encoded completely.
1997 PCODEC_HEVC_ENCODE_SLICE_PARAMS slcParams = pHevcSliceParams;
1998 for (uint32_t s = 0; s < m_numSlices; s++, slcParams++)
1999 {
2000 for (auto ll = 0; ll < 2; ll++)
2001 {
2002 uint32_t numRef = (ll == 0) ? slcParams->num_ref_idx_l0_active_minus1 :
2003 slcParams->num_ref_idx_l1_active_minus1;
2004
2005 for (uint32_t i = 0; i <= numRef; i++)
2006 {
2007 CODEC_PICTURE refPic = slcParams->RefPicList[ll][i];
2008 if (!CodecHal_PictureIsInvalid(refPic) &&
2009 !CodecHal_PictureIsInvalid(pHevcPicParams->RefFrameList[refPic.FrameIdx]))
2010 {
2011 uint32_t idx = pHevcPicParams->RefFrameList[refPic.FrameIdx].FrameIdx;
2012 uint8_t ucMbCodeIdx = pRefList[idx]->ucMbCodeIdx;
2013
2014 if (ucMbCodeIdx >= CODEC_NUM_TRACKED_BUFFERS)
2015 {
2016 // MB code index is wrong
2017 eStatus = MOS_STATUS_INVALID_PARAMETER;
2018 return eStatus;
2019 }
2020
2021 if (refHasBeenWaited[ucMbCodeIdx] || Mos_ResourceIsNull(&RefSync[ucMbCodeIdx].resSemaphoreMem.sResource))
2022 {
2023 continue;
2024 }
2025
2026 // Use HW wait command
2027 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2028 SendHWWaitCommand(
2029 &RefSync[ucMbCodeIdx].resSemaphoreMem.sResource,
2030 cmdBuffer, 1));
2031
2032 refHasBeenWaited[ucMbCodeIdx] = true;
2033 }
2034 }
2035 }
2036 }
2037 #endif
2038 return eStatus;
2039 }
2040
2041 MOS_STATUS CodechalEncodeHevcBase::ReadBrcPakStatistics(
2042 PMOS_COMMAND_BUFFER cmdBuffer,
2043 EncodeReadBrcPakStatsParams* params)
2044 {
2045 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2046
2047 CODECHAL_ENCODE_FUNCTION_ENTER;
2048
2049 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
2050 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
2051 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presBrcPakStatisticBuffer);
2052 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presStatusBuffer);
2053
2054 if (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()) \
2055 {
2056 CODECHAL_ENCODE_ASSERTMESSAGE("ERROR - vdbox index exceed the maximum");
2057 eStatus = MOS_STATUS_INVALID_PARAMETER;
2058 return eStatus;
2059 }
2060
2061 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(m_vdboxIndex);
2062 CODECHAL_ENCODE_CHK_NULL_RETURN(mmioRegisters);
2063 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
2064 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2065 miStoreRegMemParams.presStoreBuffer = params->presBrcPakStatisticBuffer;
2066 miStoreRegMemParams.dwOffset = CODECHAL_OFFSETOF(CODECHAL_ENCODE_HEVC_PAK_STATS_BUFFER, HCP_BITSTREAM_BYTECOUNT_FRAME);
2067 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset;
2068 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2069
2070 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2071 miStoreRegMemParams.presStoreBuffer = params->presBrcPakStatisticBuffer;
2072 miStoreRegMemParams.dwOffset = CODECHAL_OFFSETOF(CODECHAL_ENCODE_HEVC_PAK_STATS_BUFFER, HCP_BITSTREAM_BYTECOUNT_FRAME_NOHEADER);
2073 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameNoHeaderRegOffset;
2074 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2075
2076 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2077 miStoreRegMemParams.presStoreBuffer = params->presBrcPakStatisticBuffer;
2078 miStoreRegMemParams.dwOffset = CODECHAL_OFFSETOF(CODECHAL_ENCODE_HEVC_PAK_STATS_BUFFER, HCP_IMAGE_STATUS_CONTROL);
2079 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
2080 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2081
2082 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2083 storeDataParams.pOsResource = params->presStatusBuffer;
2084 storeDataParams.dwResourceOffset = params->dwStatusBufNumPassesOffset;
2085 storeDataParams.dwValue = params->ucPass;
2086 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
2087
2088 return eStatus;
2089 }
2090
2091 MOS_STATUS CodechalEncodeHevcBase::ReadHcpStatus(PMOS_COMMAND_BUFFER cmdBuffer)
2092 {
2093 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2094
2095 CODECHAL_ENCODE_FUNCTION_ENTER;
2096
2097 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
2098
2099 EncodeStatusBuffer *encodeStatusBuf = &m_encodeStatusBuf;
2100
2101 uint32_t baseOffset =
2102 (encodeStatusBuf->wCurrIndex * encodeStatusBuf->dwReportSize) +
2103 sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
2104
2105 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2106 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2107 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
2108
2109 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(m_vdboxIndex);
2110 CODECHAL_ENCODE_CHK_NULL_RETURN(mmioRegisters);
2111 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
2112 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2113 miStoreRegMemParams.presStoreBuffer = &encodeStatusBuf->resStatusBuffer;
2114 miStoreRegMemParams.dwOffset = baseOffset + encodeStatusBuf->dwBSByteCountOffset;
2115 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamBytecountFrameRegOffset;
2116 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2117
2118 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2119 miStoreRegMemParams.presStoreBuffer = &encodeStatusBuf->resStatusBuffer;
2120 miStoreRegMemParams.dwOffset = baseOffset + encodeStatusBuf->dwBSSEBitCountOffset;
2121 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncBitstreamSeBitcountFrameRegOffset;
2122 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2123
2124 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2125 miStoreRegMemParams.presStoreBuffer = &encodeStatusBuf->resStatusBuffer;
2126 miStoreRegMemParams.dwOffset = baseOffset + encodeStatusBuf->dwQpStatusCountOffset;
2127 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncQpStatusCountRegOffset;
2128 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2129
2130 return eStatus;
2131 }
2132
2133 MOS_STATUS CodechalEncodeHevcBase::ReadImageStatus(PMOS_COMMAND_BUFFER cmdBuffer)
2134 {
2135 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2136
2137 CODECHAL_ENCODE_FUNCTION_ENTER;
2138
2139 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
2140
2141 EncodeStatusBuffer *encodeStatusBuf = &m_encodeStatusBuf;
2142
2143 uint32_t baseOffset =
2144 (encodeStatusBuf->wCurrIndex * encodeStatusBuf->dwReportSize) +
2145 sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
2146
2147 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(m_vdboxIndex);
2148 CODECHAL_ENCODE_CHK_NULL_RETURN(mmioRegisters);
2149 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
2150 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2151 miStoreRegMemParams.presStoreBuffer = &encodeStatusBuf->resStatusBuffer;
2152 miStoreRegMemParams.dwOffset = baseOffset + encodeStatusBuf->dwImageStatusMaskOffset;
2153 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusMaskRegOffset;
2154 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2155
2156 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2157 miStoreRegMemParams.presStoreBuffer = &encodeStatusBuf->resStatusBuffer;
2158 miStoreRegMemParams.dwOffset = baseOffset + encodeStatusBuf->dwImageStatusCtrlOffset;
2159 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
2160 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2161
2162 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
2163 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
2164 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
2165
2166 return eStatus;
2167 }
2168
2169 MOS_STATUS CodechalEncodeHevcBase::UserFeatureKeyReport()
2170 {
2171 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2172 MediaUserSettingSharedPtr userSettingPtr = nullptr;
2173
2174 CODECHAL_ENCODE_FUNCTION_ENTER;
2175
2176 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::UserFeatureKeyReport())
2177
2178 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_MODE_ID, m_codecFunction, m_osInterface->pOsContext);
2179 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_ME_ENABLE_ID, m_hmeSupported, m_osInterface->pOsContext);
2180 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_16xME_ENABLE_ID, m_16xMeSupported, m_osInterface->pOsContext);
2181 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_32xME_ENABLE_ID, m_32xMeSupported, m_osInterface->pOsContext);
2182 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_26Z_ENABLE_ID, (!m_enable26WalkingPattern), m_osInterface->pOsContext);
2183 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENCODE_RATECONTROL_METHOD_ID, m_hevcSeqParams->RateControlMethod, m_osInterface->pOsContext);
2184
2185 #if (_DEBUG || _RELEASE_INTERNAL)
2186 userSettingPtr = m_osInterface->pfnGetUserSettingInstance(m_osInterface);
2187 ReportUserSettingForDebug(
2188 userSettingPtr,
2189 __MEDIA_USER_FEATURE_VALUE_SIM_IN_USE,
2190 m_osInterface->bSimIsActive,
2191 MediaUserSetting::Group::Device);
2192 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_RDOQ_ENABLE_ID, m_hevcRdoqEnabled, m_osInterface->pOsContext);
2193 #endif
2194
2195 return eStatus;
2196 }
2197
2198 MOS_STATUS CodechalEncodeHevcBase::GetStatusReport(
2199 EncodeStatus *encodeStatus,
2200 EncodeStatusReport *encodeStatusReport)
2201 {
2202 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2203
2204 CODECHAL_ENCODE_FUNCTION_ENTER;
2205
2206 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatus);
2207 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatusReport);
2208
2209 // The last pass of BRC may have a zero value of hcpCumulativeFrameDeltaQp
2210 if (encodeStatus->ImageStatusCtrl.hcpTotalPass && encodeStatus->ImageStatusCtrl.hcpCumulativeFrameDeltaQp == 0)
2211 {
2212 encodeStatus->ImageStatusCtrl.hcpCumulativeFrameDeltaQp = encodeStatus->ImageStatusCtrlOfLastBRCPass.hcpCumulativeFrameDeltaQp;
2213 }
2214 encodeStatus->ImageStatusCtrlOfLastBRCPass.hcpCumulativeFrameDeltaQp = 0;
2215
2216 encodeStatusReport->CodecStatus = CODECHAL_STATUS_SUCCESSFUL;
2217 encodeStatusReport->bitstreamSize = encodeStatus->dwMFCBitstreamByteCountPerFrame + encodeStatus->dwHeaderBytesInserted;
2218
2219 encodeStatusReport->PanicMode = encodeStatus->ImageStatusCtrl.Panic;
2220 encodeStatusReport->AverageQp = 0;
2221 encodeStatusReport->QpY = 0;
2222 encodeStatusReport->SuggestedQpYDelta = encodeStatus->ImageStatusCtrl.hcpCumulativeFrameDeltaQp;
2223 encodeStatusReport->NumberPasses = (unsigned char)encodeStatus->ImageStatusCtrl.hcpTotalPass + 1; //initial pass is considered to be 0,hence +1 to report;
2224 CODECHAL_ENCODE_VERBOSEMESSAGE("Single Pipe Mode Exectued PAK Pass number: %d\n", encodeStatusReport->NumberPasses);
2225
2226 if (m_frameWidth != 0 && m_frameHeight != 0)
2227 {
2228 uint32_t log2LcuSize = 2;
2229
2230 //The CumulativeQp from the PAK has accumulation unit of LCU, so we align and divide height, width by LCU size
2231 if ((m_codecFunction == CODECHAL_FUNCTION_FEI_ENC_PAK) ||
2232 (m_codecFunction == (CODECHAL_FUNCTION_FEI_ENC | CODECHAL_FUNCTION_FEI_ENC_PAK)))
2233 {
2234 log2LcuSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
2235 }
2236
2237 // Based on HW team:
2238 // The CumulativeQp from the PAK accumulated at TU level and normalized to TU4x4
2239 // qp(for TU 8x8) = qp*4
2240 // qp(for TU 16x16) = qp *16
2241 // qp(for TU 32x32) = qp*64
2242 // all these qp are accumulated for entire frame.
2243 // the HW will ceil the CumulativeQp number to max (24 bit)
2244
2245 encodeStatusReport->QpY = encodeStatusReport->AverageQp =
2246 (uint8_t)(((uint32_t)encodeStatus->QpStatusCount.hcpCumulativeQP)
2247 / ((MOS_ALIGN_CEIL(m_frameWidth, (1 << log2LcuSize)) >> log2LcuSize) *
2248 (MOS_ALIGN_CEIL(m_frameHeight, (1 << log2LcuSize)) >> log2LcuSize)));
2249 }
2250
2251 if (!Mos_ResourceIsNull(&m_resFrameStatStreamOutBuffer))
2252 {
2253 CODECHAL_ENCODE_CHK_STATUS_RETURN(CalculatePSNR(encodeStatus, encodeStatusReport));
2254 }
2255 return eStatus;
2256 }
2257
2258 MOS_STATUS CodechalEncodeHevcBase::InitializePicture(const EncoderParams& params)
2259 {
2260 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2261
2262 CODECHAL_ENCODE_FUNCTION_ENTER;
2263
2264 m_hevcSeqParams = (PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS)(params.pSeqParams);
2265 m_hevcPicParams = (PCODEC_HEVC_ENCODE_PICTURE_PARAMS)(params.pPicParams);
2266 m_hevcSliceParams = (PCODEC_HEVC_ENCODE_SLICE_PARAMS)params.pSliceParams;
2267 m_hevcFeiPicParams = (CodecEncodeHevcFeiPicParams *)params.pFeiPicParams;
2268 m_hevcIqMatrixParams = (PCODECHAL_HEVC_IQ_MATRIX_PARAMS)params.pIQMatrixBuffer;
2269 m_nalUnitParams = params.ppNALUnitParams;
2270
2271 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hevcSeqParams);
2272 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hevcPicParams);
2273 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hevcSliceParams);
2274 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hevcIqMatrixParams);
2275 CODECHAL_ENCODE_CHK_NULL_RETURN(m_nalUnitParams);
2276
2277 CODECHAL_ENCODE_CHK_STATUS_RETURN(PlatformCapabilityCheck());
2278
2279 if (CodecHalIsFeiEncode(m_codecFunction))
2280 {
2281 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hevcFeiPicParams);
2282 m_hevcSeqParams->TargetUsage = 0x04;
2283 }
2284
2285 if (m_newSeq)
2286 {
2287 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSequenceStructs());
2288
2289 if (m_hevcSeqParams->log2_min_coding_block_size_minus3)
2290 {
2291 m_cscDsState->SetHcpReconAlignment(1 << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3));
2292 }
2293 }
2294
2295 if (const_cast<EncoderParams *>(&params)->bAcceleratorHeaderPackingCaps)
2296 {
2297 HevcHeaderPacker Packer;
2298 Packer.SliceHeaderPacker(const_cast<EncoderParams *>(&params));
2299 }
2300
2301 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetPictureStructs());
2302 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSliceStructs());
2303
2304 // Scaling occurs when either HME or BRC is enabled
2305 m_scalingEnabled = m_hmeSupported || m_brcEnabled;
2306 m_useRawForRef = m_hevcPicParams->bUseRawPicForRef;
2307
2308 if (m_hevcPicParams->SkipFrameFlag == FRAME_SKIP_NORMAL)
2309 {
2310 m_skipFrameFlag = m_hevcPicParams->SkipFrameFlag;
2311 m_numSkipFrames = m_hevcPicParams->NumSkipFrames;
2312 m_sizeSkipFrames = m_hevcPicParams->SizeSkipFrames;
2313 }
2314
2315 m_pictureStatesSize = m_defaultPictureStatesSize;
2316 m_picturePatchListSize = m_defaultPicturePatchListSize;
2317
2318 m_sliceStatesSize = m_defaultSliceStatesSize;
2319 m_slicePatchListSize = m_defaultSlicePatchListSize;
2320
2321 // Mb Qp data
2322 m_mbQpDataEnabled = params.bMbQpDataEnabled;
2323 if (m_mbQpDataEnabled)
2324 {
2325 m_mbQpDataSurface = *(params.psMbQpDataSurface);
2326 }
2327
2328 CODECHAL_DEBUG_TOOL(
2329 m_debugInterface->m_currPic = m_hevcPicParams->CurrOriginalPic;
2330 m_debugInterface->m_bufferDumpFrameNum = m_storeData;
2331 m_debugInterface->m_frameType = m_pictureCodingType;
2332
2333 if (m_newSeq) {
2334 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpSeqParams(
2335 m_hevcSeqParams));
2336 }
2337
2338 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpPicParams(
2339 m_hevcPicParams));
2340
2341 if (CodecHalIsFeiEncode(m_codecFunction)) {
2342 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpFeiPicParams(
2343 m_hevcFeiPicParams));
2344 }
2345
2346 for (uint32_t i = 0; i < m_numSlices; i++) {
2347 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpSliceParams(
2348 &m_hevcSliceParams[i],
2349 m_hevcPicParams));
2350 })
2351
2352 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetStatusReportParams(
2353 m_refList[m_currReconstructedPic.FrameIdx]));
2354
2355 m_bitstreamUpperBound = m_encodeParams.dwBitstreamSize;
2356
2357 return eStatus;
2358 }
2359
2360 void CodechalEncodeHevcBase::SetHcpPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS& pipeModeSelectParams)
2361 {
2362 pipeModeSelectParams = {};
2363 pipeModeSelectParams.Mode = m_mode;
2364 pipeModeSelectParams.bStreamOutEnabled = m_vdencEnabled;
2365 pipeModeSelectParams.bVdencEnabled = m_vdencEnabled;
2366 pipeModeSelectParams.bRdoqEnable = m_hevcRdoqEnabled ? (m_pictureCodingType == I_TYPE ? m_hevcIFrameRdoqEnabled : 1) : 0;
2367 pipeModeSelectParams.bAdvancedRateControlEnable = m_vdencBrcEnabled;
2368
2369 if (m_hevcSeqParams->SAO_enabled_flag)
2370 {
2371 // uses pipe mode select command to tell if this is the first or second pass of SAO
2372 pipeModeSelectParams.bSaoFirstPass = !IsLastPass();
2373
2374 if (m_singleTaskPhaseSupportedInPak &&
2375 m_b2NdSaoPassNeeded &&
2376 m_brcEnabled)
2377 {
2378 if (GetCurrentPass() == m_uc2NdSaoPass - 1) // the last BRC pass. This separates BRC passes and the 2nd pass SAO into different DMA buffer submissions
2379 {
2380 m_lastTaskInPhase = true;
2381 }
2382 else if (GetCurrentPass() == m_uc2NdSaoPass) // the 2nd SAO pass
2383 {
2384 m_firstTaskInPhase = true;
2385 m_lastTaskInPhase = true;
2386 }
2387 }
2388 }
2389 }
2390
2391 void CodechalEncodeHevcBase::SetHcpSrcSurfaceParams(MHW_VDBOX_SURFACE_PARAMS& srcSurfaceParams)
2392 {
2393 MOS_ZeroMemory(&srcSurfaceParams, sizeof(srcSurfaceParams));
2394 srcSurfaceParams.Mode = m_mode;
2395 srcSurfaceParams.psSurface = m_rawSurfaceToPak;
2396 srcSurfaceParams.ucSurfaceStateId = CODECHAL_HCP_SRC_SURFACE_ID;
2397 srcSurfaceParams.ucBitDepthLumaMinus8 = m_hevcSeqParams->bit_depth_luma_minus8;
2398 srcSurfaceParams.ucBitDepthChromaMinus8 = m_hevcSeqParams->bit_depth_chroma_minus8;
2399 srcSurfaceParams.bDisplayFormatSwizzle = m_hevcPicParams->bDisplayFormatSwizzle;
2400 srcSurfaceParams.ChromaType = m_outputChromaFormat;
2401 srcSurfaceParams.bSrc8Pak10Mode = false; //No usage for 8->10 bit encode
2402 srcSurfaceParams.dwActualHeight = ((m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3));
2403
2404 m_mmcState->SetSurfaceState(&srcSurfaceParams);
2405 }
2406
2407 void CodechalEncodeHevcBase::SetHcpReconSurfaceParams(MHW_VDBOX_SURFACE_PARAMS& reconSurfaceParams)
2408 {
2409 MOS_ZeroMemory(&reconSurfaceParams, sizeof(reconSurfaceParams));
2410 reconSurfaceParams.Mode = m_mode;
2411 reconSurfaceParams.psSurface = &m_reconSurface;
2412 reconSurfaceParams.ucSurfaceStateId = CODECHAL_HCP_DECODED_SURFACE_ID;
2413 reconSurfaceParams.ucBitDepthLumaMinus8 = m_hevcSeqParams->bit_depth_luma_minus8;
2414 reconSurfaceParams.ucBitDepthChromaMinus8 = m_hevcSeqParams->bit_depth_chroma_minus8;
2415 reconSurfaceParams.ChromaType = m_outputChromaFormat;
2416 reconSurfaceParams.dwActualHeight = ((m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3));
2417 reconSurfaceParams.dwReconSurfHeight = m_rawSurfaceToPak->dwHeight;
2418
2419 m_mmcState->SetSurfaceState(&reconSurfaceParams);
2420 }
2421
2422 void CodechalEncodeHevcBase::SetHcpRefSurfaceParams(MHW_VDBOX_SURFACE_PARAMS &refSurfaceParams)
2423 {
2424 MOS_ZeroMemory(&refSurfaceParams, sizeof(refSurfaceParams));
2425 refSurfaceParams.Mode = m_mode;
2426 refSurfaceParams.psSurface = &m_reconSurface;
2427 refSurfaceParams.ucSurfaceStateId = CODECHAL_HCP_REF_SURFACE_ID;
2428 refSurfaceParams.ucBitDepthLumaMinus8 = m_hevcSeqParams->bit_depth_luma_minus8;
2429 refSurfaceParams.ucBitDepthChromaMinus8 = m_hevcSeqParams->bit_depth_chroma_minus8;
2430 refSurfaceParams.ChromaType = m_outputChromaFormat;
2431 refSurfaceParams.dwActualHeight = ((m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3));
2432 refSurfaceParams.dwReconSurfHeight = m_rawSurfaceToPak->dwHeight;
2433
2434 m_mmcState->SetSurfaceState(&refSurfaceParams);
2435 }
2436
2437 void CodechalEncodeHevcBase::SetHcpPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS& pipeBufAddrParams)
2438 {
2439 CODECHAL_ENCODE_FUNCTION_ENTER;
2440
2441 pipeBufAddrParams = {};
2442 pipeBufAddrParams.Mode = m_mode;
2443 pipeBufAddrParams.psPreDeblockSurface = &m_reconSurface;
2444 pipeBufAddrParams.psPostDeblockSurface = &m_reconSurface;
2445 pipeBufAddrParams.psRawSurface = m_rawSurfaceToPak;
2446 pipeBufAddrParams.presStreamOutBuffer = m_vdencEnabled ? &m_resStreamOutBuffer[0] : nullptr;
2447 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resDeblockingFilterRowStoreScratchBuffer;
2448 pipeBufAddrParams.presDeblockingFilterTileRowStoreScratchBuffer = &m_resDeblockingFilterTileRowStoreScratchBuffer;
2449 pipeBufAddrParams.presDeblockingFilterColumnRowStoreScratchBuffer = &m_resDeblockingFilterColumnRowStoreScratchBuffer;
2450
2451 pipeBufAddrParams.presMetadataLineBuffer = &m_resMetadataLineBuffer;
2452 pipeBufAddrParams.presMetadataTileLineBuffer = &m_resMetadataTileLineBuffer;
2453 pipeBufAddrParams.presMetadataTileColumnBuffer = &m_resMetadataTileColumnBuffer;
2454 pipeBufAddrParams.presSaoLineBuffer = &m_resSaoLineBuffer;
2455 pipeBufAddrParams.presSaoTileLineBuffer = &m_resSaoTileLineBuffer;
2456 pipeBufAddrParams.presSaoTileColumnBuffer = &m_resSaoTileColumnBuffer;
2457 pipeBufAddrParams.presCurMvTempBuffer = m_trackedBuf->GetMvTemporalBuffer(CODEC_CURR_TRACKED_BUFFER);
2458 pipeBufAddrParams.presLcuBaseAddressBuffer = &m_resLcuBaseAddressBuffer;
2459 pipeBufAddrParams.dwLcuStreamOutOffset = 0;
2460 pipeBufAddrParams.presLcuILDBStreamOutBuffer = &m_resLcuIldbStreamOutBuffer;
2461 pipeBufAddrParams.presSaoStreamOutBuffer = &m_resSaoStreamOutBuffer;
2462 pipeBufAddrParams.presFrameStatStreamOutBuffer = &m_resFrameStatStreamOutBuffer;
2463 pipeBufAddrParams.dwFrameStatStreamOutOffset = 0;
2464 pipeBufAddrParams.presSseSrcPixelRowStoreBuffer = &m_resSseSrcPixelRowStoreBuffer;
2465 pipeBufAddrParams.presPakCuLevelStreamoutBuffer =
2466 Mos_ResourceIsNull(&m_resPakcuLevelStreamoutData.sResource) ? nullptr : &m_resPakcuLevelStreamoutData.sResource;
2467 pipeBufAddrParams.bRawIs10Bit = m_is10BitHevc;
2468
2469 //add for B frame support
2470 if (m_pictureCodingType != I_TYPE)
2471 {
2472 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
2473 {
2474 if (!m_picIdx[i].bValid || !m_currUsedRefPic[i])
2475 {
2476 continue;
2477 }
2478
2479 uint8_t idx = m_picIdx[i].ucPicIdx;
2480 CodecHalGetResourceInfo(m_osInterface, &(m_refList[idx]->sRefReconBuffer));
2481
2482 uint8_t frameStoreId = (uint8_t)m_refIdxMapping[i];
2483 pipeBufAddrParams.presReferences[frameStoreId] = &(m_refList[idx]->sRefReconBuffer.OsResource);
2484
2485 uint8_t refMbCodeIdx = m_refList[idx]->ucScalingIdx;
2486 pipeBufAddrParams.presColMvTempBuffer[frameStoreId] = m_trackedBuf->GetMvTemporalBuffer(refMbCodeIdx);
2487 }
2488 }
2489 }
2490
2491 void CodechalEncodeHevcBase::SetHcpIndObjBaseAddrParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS& indObjBaseAddrParams)
2492 {
2493 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
2494 indObjBaseAddrParams.Mode = CODECHAL_ENCODE_MODE_HEVC;
2495 indObjBaseAddrParams.presMvObjectBuffer = &m_resMbCodeSurface;
2496 indObjBaseAddrParams.dwMvObjectOffset = m_mvOffset;
2497 indObjBaseAddrParams.dwMvObjectSize = m_mbCodeSize - m_mvOffset;
2498 indObjBaseAddrParams.presPakBaseObjectBuffer = &m_resBitstreamBuffer;
2499 indObjBaseAddrParams.dwPakBaseObjectSize =m_bitstreamUpperBound;
2500 indObjBaseAddrParams.presPakTileSizeStasBuffer = nullptr;
2501 indObjBaseAddrParams.dwPakTileSizeStasBufferSize = 0;
2502 indObjBaseAddrParams.dwPakTileSizeRecordOffset = 0;
2503 }
2504
2505 void CodechalEncodeHevcBase::SetHcpQmStateParams(MHW_VDBOX_QM_PARAMS& fqmParams, MHW_VDBOX_QM_PARAMS& qmParams)
2506 {
2507 MOS_ZeroMemory(&fqmParams, sizeof(fqmParams));
2508 fqmParams.Standard = CODECHAL_HEVC;
2509 fqmParams.pHevcIqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
2510
2511 MOS_ZeroMemory(&qmParams, sizeof(qmParams));
2512 qmParams.Standard = CODECHAL_HEVC;
2513 qmParams.pHevcIqMatrix = (PMHW_VDBOX_HEVC_QM_PARAMS)m_hevcIqMatrixParams;
2514 }
2515
2516 void CodechalEncodeHevcBase::SetHcpPicStateParams(MHW_VDBOX_HEVC_PIC_STATE& picStateParams)
2517 {
2518 CODECHAL_ENCODE_FUNCTION_ENTER;
2519
2520 picStateParams = {};
2521 picStateParams.pHevcEncSeqParams = m_hevcSeqParams;
2522 picStateParams.pHevcEncPicParams = m_hevcPicParams;
2523 picStateParams.bSAOEnable = m_hevcSeqParams->SAO_enabled_flag ? (m_hevcSliceParams->slice_sao_luma_flag || m_hevcSliceParams->slice_sao_chroma_flag) : 0;
2524 picStateParams.bUseVDEnc = m_vdencEnabled;
2525 picStateParams.bNotFirstPass = m_vdencEnabled && !IsFirstPass() ;
2526 picStateParams.bHevcRdoqEnabled = m_hevcRdoqEnabled ? (m_pictureCodingType == I_TYPE ? m_hevcIFrameRdoqEnabled : 1) : 0;
2527 picStateParams.bRDOQIntraTUDisable = m_hevcRdoqEnabled && (1 != m_hevcSeqParams->TargetUsage);
2528 picStateParams.wRDOQIntraTUThreshold = (uint16_t)m_rdoqIntraTuThreshold;
2529 picStateParams.bTransformSkipEnable = m_hevcPicParams->transform_skip_enabled_flag;
2530
2531 #if (_DEBUG || _RELEASE_INTERNAL)
2532 if (m_rdoqIntraTuOverride)
2533 {
2534 int32_t RDOQIntraTUThreshold = 0;
2535
2536 if (m_rdoqIntraTuThresholdOverride >= 100)
2537 {
2538 RDOQIntraTUThreshold = 65535;
2539 }
2540 else if (m_rdoqIntraTuThresholdOverride > 0)
2541 {
2542 uint32_t frameWidth = (m_hevcSeqParams->wFrameWidthInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3);
2543 uint32_t frameHeight = (m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3);
2544 int32_t frameSize = frameWidth * frameHeight;
2545 RDOQIntraTUThreshold = (((frameSize * m_rdoqIntraTuThreshold) / 100) >> 8);
2546
2547 uint16_t numPipe = m_numVdbox;
2548 if ((m_hevcPicParams->num_tile_columns_minus1 + 1) > m_numVdbox)
2549 {
2550 numPipe = 1;
2551 }
2552 if ((m_hevcPicParams->tiles_enabled_flag) && (numPipe > 1))
2553 {
2554 RDOQIntraTUThreshold /= numPipe;
2555 }
2556 if (RDOQIntraTUThreshold > 65535)
2557 {
2558 RDOQIntraTUThreshold = 65535;
2559 }
2560 }
2561
2562 picStateParams.bRDOQIntraTUDisable = m_rdoqIntraTuDisableOverride;
2563 picStateParams.wRDOQIntraTUThreshold = (uint16_t)RDOQIntraTUThreshold;
2564 }
2565 #endif
2566
2567 picStateParams.currPass = m_currPass;
2568 if (CodecHalIsFeiEncode(m_codecFunction) && m_hevcFeiPicParams && m_hevcFeiPicParams->dwMaxFrameSize)
2569 {
2570 picStateParams.deltaQp = m_hevcFeiPicParams->pDeltaQp;
2571 picStateParams.maxFrameSize = m_hevcFeiPicParams->dwMaxFrameSize;
2572 }
2573 }
2574
2575 MOS_STATUS CodechalEncodeHevcBase::SetBatchBufferForPakSlices()
2576 {
2577 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2578
2579 CODECHAL_ENCODE_FUNCTION_ENTER;
2580
2581 m_useBatchBufferForPakSlices = m_singleTaskPhaseSupported && m_singleTaskPhaseSupportedInPak;
2582 m_batchBufferForPakSlicesStartOffset = 0;
2583
2584 if (m_useBatchBufferForPakSlices)
2585 {
2586 if (IsFirstPass())
2587 {
2588 // The same buffer is used for all slices for all passes
2589 uint32_t batchBufferForPakSlicesSize =
2590 (m_numPasses + 1) * m_numSlices * m_sliceStatesSize;
2591
2592 CODECHAL_ENCODE_ASSERT(batchBufferForPakSlicesSize);
2593
2594 if (batchBufferForPakSlicesSize >
2595 (uint32_t)m_batchBufferForPakSlices[m_currPakSliceIdx].iSize)
2596 {
2597 if (m_batchBufferForPakSlices[m_currPakSliceIdx].iSize)
2598 {
2599 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReleaseBatchBufferForPakSlices(m_currPakSliceIdx));
2600 }
2601
2602 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBatchBufferForPakSlices(
2603 m_numSlices,
2604 m_numPasses));
2605 }
2606 }
2607
2608 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_LockBb(
2609 m_osInterface,
2610 &m_batchBufferForPakSlices[m_currPakSliceIdx]));
2611 m_batchBufferForPakSlicesStartOffset = IsFirstPass() ? 0 : (uint32_t)m_batchBufferForPakSlices[m_currPakSliceIdx].iCurrent;
2612 }
2613
2614 return eStatus;
2615 }
2616
2617 void CodechalEncodeHevcBase::CreateMhwParams()
2618 {
2619 m_sliceStateParams = MOS_New(MHW_VDBOX_HEVC_SLICE_STATE);
2620 m_pipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS);
2621 m_pipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS);
2622 }
2623
2624 void CodechalEncodeHevcBase::SetHcpSliceStateCommonParams(MHW_VDBOX_HEVC_SLICE_STATE& sliceStateParams)
2625 {
2626 CODECHAL_ENCODE_FUNCTION_ENTER;
2627
2628 sliceStateParams = {};
2629 sliceStateParams.presDataBuffer = &m_resMbCodeSurface;
2630 sliceStateParams.pHevcPicIdx = &(m_picIdx[0]);
2631 sliceStateParams.pEncodeHevcSeqParams = m_hevcSeqParams;
2632 sliceStateParams.pEncodeHevcPicParams = m_hevcPicParams;
2633 sliceStateParams.pBsBuffer = &m_bsBuffer;
2634 sliceStateParams.ppNalUnitParams = m_nalUnitParams;
2635 sliceStateParams.bBrcEnabled = m_brcEnabled;
2636 sliceStateParams.dwHeaderBytesInserted = 0;
2637 sliceStateParams.dwHeaderDummyBytes = 0;
2638 sliceStateParams.pRefIdxMapping = m_refIdxMapping;
2639 sliceStateParams.bIsLowDelay = m_lowDelay;
2640 sliceStateParams.RoundingIntra = m_roundingIntra;
2641 sliceStateParams.RoundingInter = m_roundingInter;
2642 }
2643
2644 void CodechalEncodeHevcBase::SetHcpSliceStateParams(
2645 MHW_VDBOX_HEVC_SLICE_STATE& sliceStateParams,
2646 PCODEC_ENCODER_SLCDATA slcData,
2647 uint32_t currSlcIdx)
2648 {
2649 CODECHAL_ENCODE_FUNCTION_ENTER;
2650
2651 sliceStateParams.pEncodeHevcSliceParams = &m_hevcSliceParams[currSlcIdx];
2652 sliceStateParams.dwDataBufferOffset = slcData[currSlcIdx].CmdOffset;
2653 sliceStateParams.dwOffset = slcData[currSlcIdx].SliceOffset;
2654 sliceStateParams.dwLength = slcData[currSlcIdx].BitSize;
2655 sliceStateParams.uiSkipEmulationCheckCount = slcData[currSlcIdx].SkipEmulationByteCount;
2656 sliceStateParams.dwSliceIndex = currSlcIdx;
2657 sliceStateParams.bLastSlice = (currSlcIdx == m_numSlices - 1);
2658 sliceStateParams.bFirstPass = IsFirstPass();
2659 sliceStateParams.bLastPass = IsLastPass();
2660 sliceStateParams.bInsertBeforeSliceHeaders = (currSlcIdx == 0);
2661 sliceStateParams.bSaoLumaFlag = (m_hevcSeqParams->SAO_enabled_flag) ? m_hevcSliceParams[currSlcIdx].slice_sao_luma_flag : 0;
2662 sliceStateParams.bSaoChromaFlag = (m_hevcSeqParams->SAO_enabled_flag) ? m_hevcSliceParams[currSlcIdx].slice_sao_chroma_flag : 0;
2663 sliceStateParams.DeblockingFilterDisable = m_hevcSliceParams[currSlcIdx].slice_deblocking_filter_disable_flag;
2664 sliceStateParams.TcOffsetDiv2 = m_hevcSliceParams[currSlcIdx].tc_offset_div2;
2665 sliceStateParams.BetaOffsetDiv2 = m_hevcSliceParams[currSlcIdx].beta_offset_div2;
2666
2667
2668 if (m_useBatchBufferForPakSlices)
2669 {
2670 sliceStateParams.pBatchBufferForPakSlices =
2671 &m_batchBufferForPakSlices[m_currPakSliceIdx];
2672 sliceStateParams.bSingleTaskPhaseSupported = true;
2673 sliceStateParams.dwBatchBufferForPakSlicesStartOffset = m_batchBufferForPakSlicesStartOffset;
2674 }
2675
2676 if (m_hevcPicParams->transform_skip_enabled_flag)
2677 {
2678 CalcTransformSkipParameters(sliceStateParams.EncodeHevcTransformSkipParams);
2679 }
2680 }
2681
2682 MOS_STATUS CodechalEncodeHevcBase::AddHcpRefIdxCmd(
2683 PMOS_COMMAND_BUFFER cmdBuffer,
2684 PMHW_BATCH_BUFFER batchBuffer,
2685 PMHW_VDBOX_HEVC_SLICE_STATE params)
2686 {
2687 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2688
2689 CODECHAL_ENCODE_FUNCTION_ENTER;
2690
2691 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
2692 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pEncodeHevcSliceParams);
2693 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pEncodeHevcPicParams);
2694
2695 if (cmdBuffer == nullptr && batchBuffer == nullptr)
2696 {
2697 CODECHAL_ENCODE_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
2698 return MOS_STATUS_NULL_POINTER;
2699 }
2700
2701 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams = params->pEncodeHevcPicParams;
2702 PCODEC_HEVC_ENCODE_SLICE_PARAMS hevcSlcParams = params->pEncodeHevcSliceParams;
2703
2704 if (hevcSlcParams->slice_type != CODECHAL_ENCODE_HEVC_I_SLICE)
2705 {
2706 MHW_VDBOX_HEVC_REF_IDX_PARAMS refIdxParams;
2707
2708 refIdxParams.CurrPic = hevcPicParams->CurrReconstructedPic;
2709 refIdxParams.isEncode = true;
2710 refIdxParams.ucList = LIST_0;
2711 refIdxParams.ucNumRefForList = hevcSlcParams->num_ref_idx_l0_active_minus1 + 1;
2712 eStatus = MOS_SecureMemcpy(&refIdxParams.RefPicList, sizeof(refIdxParams.RefPicList),
2713 &hevcSlcParams->RefPicList, sizeof(hevcSlcParams->RefPicList));
2714 if (eStatus != MOS_STATUS_SUCCESS)
2715 {
2716 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
2717 return eStatus;
2718 }
2719
2720 refIdxParams.hevcRefList = (void**)m_refList;
2721 refIdxParams.poc_curr_pic = hevcPicParams->CurrPicOrderCnt;
2722 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
2723 {
2724 refIdxParams.poc_list[i] = hevcPicParams->RefFramePOCList[i];
2725 }
2726
2727 refIdxParams.pRefIdxMapping = params->pRefIdxMapping;
2728 refIdxParams.RefFieldPicFlag = 0; // there is no interlaced support in encoder
2729 refIdxParams.RefBottomFieldFlag = 0; // there is no interlaced support in encoder
2730
2731 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(cmdBuffer, batchBuffer, &refIdxParams));
2732
2733 if (hevcSlcParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
2734 {
2735 refIdxParams.ucList = LIST_1;
2736 refIdxParams.ucNumRefForList = hevcSlcParams->num_ref_idx_l1_active_minus1 + 1;
2737 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(cmdBuffer, batchBuffer, &refIdxParams));
2738 }
2739 }
2740
2741 return eStatus;
2742 }
2743
2744 MOS_STATUS CodechalEncodeHevcBase::AddHcpPakInsertNALUs(
2745 PMOS_COMMAND_BUFFER cmdBuffer,
2746 PMHW_BATCH_BUFFER batchBuffer,
2747 PMHW_VDBOX_HEVC_SLICE_STATE params)
2748 {
2749 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2750
2751 CODECHAL_ENCODE_FUNCTION_ENTER;
2752
2753 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
2754 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pBsBuffer);
2755 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ppNalUnitParams);
2756
2757 if (cmdBuffer == nullptr && batchBuffer == nullptr)
2758 {
2759 CODECHAL_ENCODE_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
2760 return MOS_STATUS_NULL_POINTER;
2761 }
2762
2763 //insert AU, SPS, PSP headers before first slice header
2764 if (params->bInsertBeforeSliceHeaders)
2765 {
2766 uint32_t maxBytesInPakInsertObjCmd = ((2 << 11) - 1) * 4; // 12 bits for Length field in PAK_INSERT_OBJ cmd
2767
2768 for (auto i = 0; i < HEVC_MAX_NAL_UNIT_TYPE; i++)
2769 {
2770 uint32_t nalunitPosiSize = params->ppNalUnitParams[i]->uiSize;
2771 uint32_t nalunitPosiOffset = params->ppNalUnitParams[i]->uiOffset;
2772
2773 while (nalunitPosiSize > 0)
2774 {
2775 uint32_t bitSize = MOS_MIN(maxBytesInPakInsertObjCmd * 8, nalunitPosiSize * 8);
2776 uint32_t offSet = nalunitPosiOffset;
2777
2778 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
2779 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
2780 pakInsertObjectParams.bEmulationByteBitsInsert = params->ppNalUnitParams[i]->bInsertEmulationBytes;
2781 pakInsertObjectParams.uiSkipEmulationCheckCount = params->ppNalUnitParams[i]->uiSkipEmulationCheckCount;
2782 pakInsertObjectParams.pBsBuffer = params->pBsBuffer;
2783 pakInsertObjectParams.dwBitSize = bitSize;
2784 pakInsertObjectParams.dwOffset = offSet;
2785 pakInsertObjectParams.pBatchBufferForPakSlices = batchBuffer;
2786 pakInsertObjectParams.bVdencInUse = params->bVdencInUse;
2787
2788 if (nalunitPosiSize > maxBytesInPakInsertObjCmd)
2789 {
2790 nalunitPosiSize -= maxBytesInPakInsertObjCmd;
2791 nalunitPosiOffset += maxBytesInPakInsertObjCmd;
2792 }
2793 else
2794 {
2795 nalunitPosiSize = 0;
2796 }
2797
2798 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(cmdBuffer, &pakInsertObjectParams));
2799 }
2800 }
2801 }
2802
2803 return eStatus;
2804 }
2805
2806 MOS_STATUS CodechalEncodeHevcBase::AddHcpPakInsertSliceHeader(
2807 PMOS_COMMAND_BUFFER cmdBuffer,
2808 PMHW_BATCH_BUFFER batchBuffer,
2809 PMHW_VDBOX_HEVC_SLICE_STATE params)
2810 {
2811 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2812
2813 CODECHAL_ENCODE_FUNCTION_ENTER;
2814
2815 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
2816 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pBsBuffer);
2817
2818 if (cmdBuffer == nullptr && batchBuffer == nullptr)
2819 {
2820 CODECHAL_ENCODE_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
2821 return MOS_STATUS_NULL_POINTER;
2822 }
2823
2824 // Insert slice header
2825 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
2826 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
2827 pakInsertObjectParams.bLastHeader = true;
2828 pakInsertObjectParams.bEmulationByteBitsInsert = true;
2829 pakInsertObjectParams.pBatchBufferForPakSlices = batchBuffer;
2830
2831 // App does the slice header packing, set the skip count passed by the app
2832 pakInsertObjectParams.uiSkipEmulationCheckCount = params->uiSkipEmulationCheckCount;
2833 pakInsertObjectParams.pBsBuffer = params->pBsBuffer;
2834 pakInsertObjectParams.dwBitSize = params->dwLength;
2835 pakInsertObjectParams.dwOffset = params->dwOffset;
2836 pakInsertObjectParams.bVdencInUse = params->bVdencInUse;
2837
2838 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(
2839 cmdBuffer,
2840 &pakInsertObjectParams));
2841
2842 return eStatus;
2843 }
2844
2845 CodechalEncodeHevcBase::CodechalEncodeHevcBase(
2846 CodechalHwInterface* hwInterface,
2847 CodechalDebugInterface* debugInterface,
2848 PCODECHAL_STANDARD_INFO standardInfo)
2849 :CodechalEncoderState(hwInterface, debugInterface, standardInfo)
2850 {
2851 // initialze class members
2852 MOS_ZeroMemory(&m_resDeblockingFilterRowStoreScratchBuffer, sizeof(m_resDeblockingFilterRowStoreScratchBuffer));
2853 MOS_ZeroMemory(&m_resDeblockingFilterTileRowStoreScratchBuffer, sizeof(m_resDeblockingFilterTileRowStoreScratchBuffer));
2854 MOS_ZeroMemory(&m_resDeblockingFilterColumnRowStoreScratchBuffer, sizeof(m_resDeblockingFilterColumnRowStoreScratchBuffer));
2855 MOS_ZeroMemory(&m_resMetadataLineBuffer, sizeof(m_resMetadataLineBuffer));
2856 MOS_ZeroMemory(&m_resMetadataTileLineBuffer, sizeof(m_resMetadataTileLineBuffer));
2857 MOS_ZeroMemory(&m_resMetadataTileColumnBuffer, sizeof(m_resMetadataTileColumnBuffer));
2858 MOS_ZeroMemory(&m_resSaoLineBuffer, sizeof(m_resSaoLineBuffer));
2859 MOS_ZeroMemory(&m_resSaoTileLineBuffer, sizeof(m_resSaoTileLineBuffer));
2860 MOS_ZeroMemory(&m_resSaoTileColumnBuffer, sizeof(m_resSaoTileColumnBuffer));
2861 MOS_ZeroMemory(&m_resLcuBaseAddressBuffer, sizeof(m_resLcuBaseAddressBuffer));
2862 MOS_ZeroMemory(&m_resLcuIldbStreamOutBuffer, sizeof(m_resLcuIldbStreamOutBuffer));
2863 MOS_ZeroMemory(&m_resSaoStreamOutBuffer, sizeof(m_resSaoStreamOutBuffer));
2864 MOS_ZeroMemory(&m_resFrameStatStreamOutBuffer, sizeof(m_resFrameStatStreamOutBuffer));
2865 MOS_ZeroMemory(&m_resSseSrcPixelRowStoreBuffer, sizeof(m_resSseSrcPixelRowStoreBuffer));
2866 MOS_ZeroMemory(m_batchBufferForPakSlices, sizeof(m_batchBufferForPakSlices));
2867
2868 MOS_ZeroMemory(m_refSync, sizeof(m_refSync));
2869 MOS_ZeroMemory(m_refIdxMapping, sizeof(m_refIdxMapping));
2870
2871 MOS_ZeroMemory(m_currUsedRefPic, sizeof(m_currUsedRefPic));
2872 ;
2873 MOS_ZeroMemory(m_picIdx, sizeof(m_picIdx));
2874 MOS_ZeroMemory(m_refList, sizeof(m_refList));
2875
2876 MOS_ZeroMemory(&m_s4XMeMvDataBuffer, sizeof(m_s4XMeMvDataBuffer));
2877 MOS_ZeroMemory(&m_s16XMeMvDataBuffer, sizeof(m_s16XMeMvDataBuffer));
2878 MOS_ZeroMemory(&m_s32XMeMvDataBuffer, sizeof(m_s32XMeMvDataBuffer));
2879 MOS_ZeroMemory(&m_s4XMeDistortionBuffer, sizeof(m_s4XMeDistortionBuffer));
2880 MOS_ZeroMemory(&m_mbQpDataSurface, sizeof(m_mbQpDataSurface));
2881 MOS_ZeroMemory(&m_resPakcuLevelStreamoutData, sizeof(m_resPakcuLevelStreamoutData));
2882
2883 m_fieldScalingOutputInterleaved = false;
2884 m_interlacedFieldDisabled = true;
2885 m_firstField = true; // Each frame is treated as the first field
2886
2887 m_userFeatureKeyReport = true;
2888 m_useCmScalingKernel = true;
2889 m_codecGetStatusReportDefined = true; // Codec specific GetStatusReport is implemented.
2890
2891 m_vdboxOneDefaultUsed = true;
2892 }
2893
2894 MOS_STATUS CodechalEncodeHevcBase::CalculatePictureStateCommandSize()
2895 {
2896 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2897
2898 CODECHAL_ENCODE_FUNCTION_ENTER;
2899
2900 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
2901 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2902 m_hwInterface->GetHxxStateCommandSize(
2903 CODECHAL_ENCODE_MODE_HEVC,
2904 &m_defaultPictureStatesSize,
2905 &m_defaultPicturePatchListSize,
2906 &stateCmdSizeParams));
2907
2908 return eStatus;
2909 }
2910
2911 MOS_STATUS CodechalEncodeHevcBase::AddHcpPipeBufAddrCmd(
2912 PMOS_COMMAND_BUFFER cmdBuffer)
2913 {
2914 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2915
2916 CODECHAL_ENCODE_FUNCTION_ENTER;
2917
2918 *m_pipeBufAddrParams = {};
2919 SetHcpPipeBufAddrParams(*m_pipeBufAddrParams);
2920
2921 m_mmcState->SetPipeBufAddr(m_pipeBufAddrParams);
2922
2923 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(cmdBuffer, m_pipeBufAddrParams));
2924
2925 return eStatus;
2926 }
2927
2928 short CodechalEncodeHevcBase::ComputeTemporalDifferent(CODEC_PICTURE refPic)
2929 {
2930 short diff_poc = 0;
2931
2932 if (!CodecHal_PictureIsInvalid(refPic))
2933 {
2934 diff_poc = m_hevcPicParams->CurrPicOrderCnt - m_hevcPicParams->RefFramePOCList[refPic.FrameIdx];
2935
2936 if (diff_poc < -16)
2937 {
2938 CODECHAL_ENCODE_ASSERTMESSAGE("POC out of range, it will be clipped.");
2939 diff_poc = -16;
2940 }
2941 else
2942 if (diff_poc > 16)
2943 {
2944 CODECHAL_ENCODE_ASSERTMESSAGE("POC out of range, it will be clipped.");
2945 diff_poc = 16;
2946 }
2947 }
2948
2949 return diff_poc;
2950 }
2951
2952 MOS_STATUS CodechalEncodeHevcBase::InitSurfaceCodecParams1D(
2953 PCODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams,
2954 PMOS_RESOURCE buffer,
2955 uint32_t size,
2956 uint32_t offset,
2957 uint32_t cacheabilityControl,
2958 uint32_t bindingTableOffset,
2959 bool isWritable)
2960 {
2961 if (surfaceCodecParams == nullptr)
2962 {
2963 return MOS_STATUS_NULL_POINTER;
2964 }
2965
2966 MOS_ZeroMemory(surfaceCodecParams, sizeof(*surfaceCodecParams));
2967 surfaceCodecParams->presBuffer = buffer;
2968 surfaceCodecParams->dwSize = size;
2969 surfaceCodecParams->dwOffset = offset;
2970 surfaceCodecParams->dwCacheabilityControl = cacheabilityControl;
2971 surfaceCodecParams->dwBindingTableOffset = bindingTableOffset;
2972 surfaceCodecParams->bIsWritable =
2973 surfaceCodecParams->bRenderTarget = isWritable;
2974
2975 return MOS_STATUS_SUCCESS;
2976 }
2977
2978 MOS_STATUS CodechalEncodeHevcBase::InitSurfaceCodecParams2D(
2979 PCODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams,
2980 PMOS_SURFACE surface,
2981 uint32_t cacheabilityControl,
2982 uint32_t bindingTableOffset,
2983 uint32_t verticalLineStride,
2984 bool isWritable)
2985 {
2986 if (surfaceCodecParams == nullptr)
2987 {
2988 return MOS_STATUS_NULL_POINTER;
2989 }
2990
2991 MOS_ZeroMemory(surfaceCodecParams, sizeof(*surfaceCodecParams));
2992 surfaceCodecParams->bIs2DSurface = true;
2993 surfaceCodecParams->bMediaBlockRW = true; // Use media block RW for DP 2D surface access
2994 surfaceCodecParams->psSurface = surface;
2995 surfaceCodecParams->dwCacheabilityControl = cacheabilityControl;
2996 surfaceCodecParams->dwBindingTableOffset = bindingTableOffset;
2997 surfaceCodecParams->dwVerticalLineStride = verticalLineStride;
2998 surfaceCodecParams->bIsWritable =
2999 surfaceCodecParams->bRenderTarget = isWritable;
3000
3001 return MOS_STATUS_SUCCESS;
3002 }
3003
3004 MOS_STATUS CodechalEncodeHevcBase::AllocateResources4xME(
3005 HmeParams *param)
3006 {
3007 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3008
3009 CODECHAL_ENCODE_FUNCTION_ENTER;
3010
3011 CODECHAL_ENCODE_CHK_NULL_RETURN(param);
3012
3013 if (!m_encEnabled || !m_hmeSupported)
3014 {
3015 return eStatus;
3016 }
3017
3018 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
3019 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
3020 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
3021 allocParamsForBuffer2D.TileType = MOS_TILE_LINEAR;
3022 allocParamsForBuffer2D.Format = Format_Buffer_2D;
3023
3024 MOS_ZeroMemory(param->ps4xMeMvDataBuffer, sizeof(MOS_SURFACE));
3025 param->ps4xMeMvDataBuffer->TileType = MOS_TILE_LINEAR;
3026 param->ps4xMeMvDataBuffer->bArraySpacing = true;
3027 param->ps4xMeMvDataBuffer->Format = Format_Buffer_2D;
3028 param->ps4xMeMvDataBuffer->dwWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 32), 64); // MediaBlockRW requires pitch multiple of 64 bytes when linear.
3029 param->ps4xMeMvDataBuffer->dwHeight = (m_downscaledHeightInMb4x * 2 * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER);
3030 param->ps4xMeMvDataBuffer->dwPitch = param->ps4xMeMvDataBuffer->dwWidth;
3031
3032 allocParamsForBuffer2D.dwWidth = param->ps4xMeMvDataBuffer->dwWidth;
3033 allocParamsForBuffer2D.dwHeight = param->ps4xMeMvDataBuffer->dwHeight;
3034 allocParamsForBuffer2D.pBufName = "4xME MV Data Buffer";
3035
3036 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
3037 m_osInterface,
3038 &allocParamsForBuffer2D,
3039 &param->ps4xMeMvDataBuffer->OsResource);
3040
3041 if (eStatus != MOS_STATUS_SUCCESS)
3042 {
3043 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate 4xME MV Data Buffer.");
3044 return eStatus;
3045 }
3046
3047 CleanUpResource(&param->ps4xMeMvDataBuffer->OsResource, &allocParamsForBuffer2D);
3048
3049 if (param->b4xMeDistortionBufferSupported)
3050 {
3051 uint32_t ajustedHeight =
3052 m_downscaledHeightInMb4x * CODECHAL_MACROBLOCK_HEIGHT * SCALE_FACTOR_4x;
3053 uint32_t downscaledFieldHeightInMB4x =
3054 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(((ajustedHeight + 1) >> 1) / 4);
3055
3056 MOS_ZeroMemory(param->ps4xMeDistortionBuffer, sizeof(MOS_SURFACE));
3057 param->ps4xMeDistortionBuffer->TileType = MOS_TILE_LINEAR;
3058 param->ps4xMeDistortionBuffer->bArraySpacing = true;
3059 param->ps4xMeDistortionBuffer->Format = Format_Buffer_2D;
3060 param->ps4xMeDistortionBuffer->dwWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64);
3061 param->ps4xMeDistortionBuffer->dwHeight = 2 * MOS_ALIGN_CEIL((downscaledFieldHeightInMB4x * 4 * 10), 8);
3062 param->ps4xMeDistortionBuffer->dwPitch = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64);
3063
3064 allocParamsForBuffer2D.dwWidth = param->ps4xMeDistortionBuffer->dwWidth;
3065 allocParamsForBuffer2D.dwHeight = param->ps4xMeDistortionBuffer->dwHeight;
3066 allocParamsForBuffer2D.pBufName = "4xME Distortion Buffer";
3067
3068 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
3069 m_osInterface,
3070 &allocParamsForBuffer2D,
3071 &param->ps4xMeDistortionBuffer->OsResource);
3072
3073 if (eStatus != MOS_STATUS_SUCCESS)
3074 {
3075 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate 4xME Distortion Buffer.");
3076 return eStatus;
3077 }
3078 CleanUpResource(&param->ps4xMeDistortionBuffer->OsResource, &allocParamsForBuffer2D);
3079 }
3080
3081 return eStatus;
3082 }
3083
3084 MOS_STATUS CodechalEncodeHevcBase::AllocateResources16xME(
3085 HmeParams *param)
3086 {
3087 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3088
3089 CODECHAL_ENCODE_FUNCTION_ENTER;
3090
3091 CODECHAL_ENCODE_CHK_NULL_RETURN(param);
3092
3093 if (!m_encEnabled || !m_hmeSupported)
3094 {
3095 return eStatus;
3096 }
3097
3098 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
3099 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
3100 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
3101 allocParamsForBuffer2D.TileType = MOS_TILE_LINEAR;
3102 allocParamsForBuffer2D.Format = Format_Buffer_2D;
3103
3104 if (m_16xMeSupported)
3105 {
3106 MOS_ZeroMemory(param->ps16xMeMvDataBuffer, sizeof(MOS_SURFACE));
3107 param->ps16xMeMvDataBuffer->TileType = MOS_TILE_LINEAR;
3108 param->ps16xMeMvDataBuffer->bArraySpacing = true;
3109 param->ps16xMeMvDataBuffer->Format = Format_Buffer_2D;
3110 param->ps16xMeMvDataBuffer->dwWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb16x * 32), 64); // MediaBlockRW requires pitch multiple of 64 bytes when linear
3111 param->ps16xMeMvDataBuffer->dwHeight = (m_downscaledHeightInMb16x * 2 * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER);
3112 param->ps16xMeMvDataBuffer->dwPitch = param->ps16xMeMvDataBuffer->dwWidth;
3113
3114 allocParamsForBuffer2D.dwWidth = param->ps16xMeMvDataBuffer->dwWidth;
3115 allocParamsForBuffer2D.dwHeight = param->ps16xMeMvDataBuffer->dwHeight;
3116 allocParamsForBuffer2D.pBufName = "16xME MV Data Buffer";
3117
3118 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
3119 m_osInterface,
3120 &allocParamsForBuffer2D,
3121 &param->ps16xMeMvDataBuffer->OsResource);
3122
3123 if (eStatus != MOS_STATUS_SUCCESS)
3124 {
3125 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate 16xME MV Data Buffer.");
3126 return eStatus;
3127 }
3128 CleanUpResource(&param->ps16xMeMvDataBuffer->OsResource, &allocParamsForBuffer2D);
3129 }
3130
3131 return eStatus;
3132 }
3133
3134 MOS_STATUS CodechalEncodeHevcBase::AllocateResources32xME(
3135 HmeParams *param)
3136 {
3137 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3138
3139 CODECHAL_ENCODE_FUNCTION_ENTER;
3140
3141 CODECHAL_ENCODE_CHK_NULL_RETURN(param);
3142
3143 if (!m_encEnabled || !m_hmeSupported)
3144 {
3145 return eStatus;
3146 }
3147
3148 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
3149 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
3150 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
3151 allocParamsForBuffer2D.TileType = MOS_TILE_LINEAR;
3152 allocParamsForBuffer2D.Format = Format_Buffer_2D;
3153
3154 if (m_32xMeSupported)
3155 {
3156 MOS_ZeroMemory(param->ps32xMeMvDataBuffer, sizeof(MOS_SURFACE));
3157 param->ps32xMeMvDataBuffer->TileType = MOS_TILE_LINEAR;
3158 param->ps32xMeMvDataBuffer->bArraySpacing = true;
3159 param->ps32xMeMvDataBuffer->Format = Format_Buffer_2D;
3160 param->ps32xMeMvDataBuffer->dwWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb32x * 32), 64); // MediaBlockRW requires pitch multiple of 64 bytes when linear
3161 param->ps32xMeMvDataBuffer->dwHeight = (m_downscaledHeightInMb32x * 2 * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER);
3162 param->ps32xMeMvDataBuffer->dwPitch = param->ps32xMeMvDataBuffer->dwWidth;
3163
3164 allocParamsForBuffer2D.dwWidth = param->ps32xMeMvDataBuffer->dwWidth;
3165 allocParamsForBuffer2D.dwHeight = param->ps32xMeMvDataBuffer->dwHeight;
3166 allocParamsForBuffer2D.pBufName = "32xME MV Data Buffer";
3167
3168 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
3169 m_osInterface,
3170 &allocParamsForBuffer2D,
3171 &param->ps32xMeMvDataBuffer->OsResource);
3172
3173 if (eStatus != MOS_STATUS_SUCCESS)
3174 {
3175 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate 32xME MV Data Buffer\n", __FUNCTION__);
3176 return eStatus;
3177 }
3178 CleanUpResource(&param->ps32xMeMvDataBuffer->OsResource, &allocParamsForBuffer2D);
3179 }
3180
3181 return eStatus;
3182 }
3183
3184 MOS_STATUS CodechalEncodeHevcBase::DestroyMEResources(
3185 HmeParams *param)
3186 {
3187 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3188
3189 CODECHAL_ENCODE_FUNCTION_ENTER;
3190
3191 CODECHAL_ENCODE_CHK_NULL_RETURN(param);
3192
3193 if (nullptr != param->ps16xMeMvDataBuffer)
3194 {
3195 m_osInterface->pfnFreeResource(
3196 m_osInterface,
3197 &param->ps16xMeMvDataBuffer->OsResource);
3198 }
3199
3200 if (nullptr != param->ps32xMeMvDataBuffer)
3201 {
3202 m_osInterface->pfnFreeResource(
3203 m_osInterface,
3204 &param->ps32xMeMvDataBuffer->OsResource);
3205 }
3206
3207 if (nullptr != param->ps4xMeDistortionBuffer)
3208 {
3209 m_osInterface->pfnFreeResource(
3210 m_osInterface,
3211 &param->ps4xMeDistortionBuffer->OsResource);
3212 }
3213
3214 if (nullptr != param->ps4xMeMvDataBuffer)
3215 {
3216 m_osInterface->pfnFreeResource(
3217 m_osInterface,
3218 &param->ps4xMeMvDataBuffer->OsResource);
3219 }
3220
3221 if (nullptr != param->presMvAndDistortionSumSurface)
3222 {
3223 m_osInterface->pfnFreeResource(
3224 m_osInterface,
3225 param->presMvAndDistortionSumSurface);
3226 }
3227
3228 return eStatus;
3229 }
3230
3231 void CodechalEncodeHevcBase::MotionEstimationDisableCheck()
3232 {
3233 CODECHAL_ENCODE_FUNCTION_ENTER;
3234
3235 if (m_downscaledWidth4x < m_minScaledDimension || m_downscaledWidthInMb4x < m_minScaledDimensionInMb ||
3236 m_downscaledHeight4x < m_minScaledDimension || m_downscaledHeightInMb4x < m_minScaledDimensionInMb)
3237 {
3238 if (m_downscaledWidth4x < m_minScaledDimension || m_downscaledWidthInMb4x < m_minScaledDimensionInMb)
3239 {
3240 m_downscaledWidth4x = m_minScaledDimension;
3241 m_downscaledWidthInMb4x = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_downscaledWidth4x);
3242 }
3243 if (m_downscaledHeight4x < m_minScaledDimension || m_downscaledHeightInMb4x < m_minScaledDimensionInMb)
3244 {
3245 m_downscaledHeight4x = m_minScaledDimension;
3246 m_downscaledHeightInMb4x = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_downscaledHeight4x);
3247 }
3248 }
3249
3250 if (m_downscaledWidth16x < m_minScaledDimension || m_downscaledWidthInMb16x < m_minScaledDimensionInMb ||
3251 m_downscaledHeight16x < m_minScaledDimension || m_downscaledHeightInMb16x < m_minScaledDimensionInMb)
3252 {
3253 if (m_downscaledWidth16x < m_minScaledDimension || m_downscaledWidthInMb16x < m_minScaledDimensionInMb)
3254 {
3255 m_downscaledWidth16x = m_minScaledDimension;
3256 m_downscaledWidthInMb16x = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_downscaledWidth16x);
3257 }
3258 if (m_downscaledHeight16x < m_minScaledDimension || m_downscaledHeightInMb16x < m_minScaledDimensionInMb)
3259 {
3260 m_downscaledHeight16x = m_minScaledDimension;
3261 m_downscaledHeightInMb16x = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_downscaledHeight16x);
3262 }
3263 }
3264
3265 if (m_downscaledWidth32x < m_minScaledDimension || m_downscaledWidthInMb32x < m_minScaledDimensionInMb)
3266 {
3267 m_downscaledWidth32x = m_minScaledDimension;
3268 m_downscaledWidthInMb32x = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_downscaledWidth32x);
3269 }
3270 if (m_downscaledHeight32x < m_minScaledDimension || m_downscaledHeightInMb32x < m_minScaledDimensionInMb)
3271 {
3272 m_downscaledHeight32x = m_minScaledDimension;
3273 m_downscaledHeightInMb32x = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_downscaledHeight32x);
3274 }
3275
3276 }
3277
3278 MOS_STATUS CodechalEncodeHevcBase::ExecuteKernelFunctions()
3279 {
3280 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3281
3282 CODECHAL_ENCODE_FUNCTION_ENTER;
3283
3284 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeKernelFunctions());
3285
3286 return eStatus;
3287 }
3288
3289 #if USE_CODECHAL_DEBUG_TOOL
3290 MOS_STATUS CodechalEncodeHevcBase::DumpSeqParams(
3291 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS seqParams)
3292 {
3293 CODECHAL_DEBUG_FUNCTION_ENTER;
3294
3295 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSeqParams))
3296 {
3297 return MOS_STATUS_SUCCESS;
3298 }
3299
3300 CODECHAL_DEBUG_CHK_NULL(seqParams);
3301
3302 std::ostringstream oss;
3303 oss.setf(std::ios::showbase | std::ios::uppercase);
3304
3305 oss << "# DDI Parameters:" << std::endl;
3306 oss << "wFrameWidthInMinCbMinus1 = " << +seqParams->wFrameWidthInMinCbMinus1 << std::endl;
3307 oss << "wFrameHeightInMinCbMinus1 = " << +seqParams->wFrameHeightInMinCbMinus1 << std::endl;
3308 oss << "general_profile_idc = " << +seqParams->general_profile_idc << std::endl;
3309 oss << "Level = " << +seqParams->Level << std::endl;
3310 oss << "general_tier_flag = " << +seqParams->general_tier_flag << std::endl;
3311 oss << "GopPicSize = " << +seqParams->GopPicSize << std::endl;
3312 oss << "GopRefDist = " << +seqParams->GopRefDist << std::endl;
3313 oss << "GopOptFlag = " << +seqParams->GopOptFlag << std::endl;
3314 oss << "TargetUsage = " << +seqParams->TargetUsage << std::endl;
3315 oss << "RateControlMethod = " << +seqParams->RateControlMethod << std::endl;
3316 oss << "TargetBitRate = " << +seqParams->TargetBitRate << std::endl;
3317 oss << "MaxBitRate = " << +seqParams->MaxBitRate << std::endl;
3318 oss << "MinBitRate = " << +seqParams->MinBitRate << std::endl;
3319 oss << "FramesRate.Numerator = " << +seqParams->FrameRate.Numerator << std::endl;
3320 oss << "FramesRate.Denominator = " << +seqParams->FrameRate.Denominator << std::endl;
3321 oss << "InitVBVBufferFullnessInBit = " << +seqParams->InitVBVBufferFullnessInBit << std::endl;
3322 oss << "VBVBufferSizeInBit = " << +seqParams->VBVBufferSizeInBit << std::endl;
3323 oss << "bResetBRC = " << +seqParams->bResetBRC << std::endl;
3324 oss << "GlobalSearch = " << +seqParams->GlobalSearch << std::endl;
3325 oss << "LocalSearch = " << +seqParams->LocalSearch << std::endl;
3326 oss << "EarlySkip = " << +seqParams->EarlySkip << std::endl;
3327 oss << "MBBRC = " << +seqParams->MBBRC << std::endl;
3328 oss << "ParallelBRC = " << +seqParams->ParallelBRC << std::endl;
3329 oss << "SliceSizeControl = " << +seqParams->SliceSizeControl << std::endl;
3330 oss << "SourceFormat = " << +seqParams->SourceFormat << std::endl;
3331 oss << "SourceBitDepth = " << +seqParams->SourceBitDepth << std::endl;
3332 oss << "QpAdjustment = " << +seqParams->QpAdjustment << std::endl;
3333 oss << "ROIValueInDeltaQP = " << +seqParams->ROIValueInDeltaQP << std::endl;
3334 oss << "BlockQPforNonRectROI = " << +seqParams->BlockQPforNonRectROI << std::endl;
3335 oss << "EnableTileBasedEncode = " << +seqParams->EnableTileBasedEncode << std::endl;
3336 oss << "bAutoMaxPBFrameSizeForSceneChange = " << +seqParams->bAutoMaxPBFrameSizeForSceneChange << std::endl;
3337 oss << "EnableStreamingBufferLLC = " << +seqParams->EnableStreamingBufferLLC << std::endl;
3338 oss << "EnableStreamingBufferDDR = " << +seqParams->EnableStreamingBufferDDR << std::endl;
3339 oss << "LowDelayMode = " << +seqParams->LowDelayMode << std::endl;
3340 oss << "DisableHRDConformance = " << +seqParams->DisableHRDConformance << std::endl;
3341 oss << "HierarchicalFlag = " << +seqParams->HierarchicalFlag << std::endl;
3342 oss << "UserMaxIFrameSize = " << +seqParams->UserMaxIFrameSize << std::endl;
3343 oss << "UserMaxPBFrameSize = " << +seqParams->UserMaxPBFrameSize << std::endl;
3344 oss << "ICQQualityFactor = " << +seqParams->ICQQualityFactor << std::endl;
3345 oss << "NumB = " << +seqParams->NumOfBInGop[0] << std::endl;
3346 oss << "NumB1 = " << +seqParams->NumOfBInGop[1] << std::endl;
3347 oss << "NumB2 = " << +seqParams->NumOfBInGop[2] << std::endl;
3348 oss << "UserMaxIFrameSize = " << +seqParams->UserMaxIFrameSize << std::endl;
3349 oss << "UserMaxPBFrameSize = " << +seqParams->UserMaxPBFrameSize << std::endl;
3350 oss << "ICQQualityFactor = " << +seqParams->ICQQualityFactor << std::endl;
3351 oss << "scaling_list_enable_flag = " << +seqParams->scaling_list_enable_flag << std::endl;
3352 oss << "sps_temporal_mvp_enable_flag = " << +seqParams->sps_temporal_mvp_enable_flag << std::endl;
3353 oss << "strong_intra_smoothing_enable_flag = " << +seqParams->strong_intra_smoothing_enable_flag << std::endl;
3354 oss << "amp_enabled_flag = " << +seqParams->amp_enabled_flag << std::endl;
3355 oss << "SAO_enabled_flag = " << +seqParams->SAO_enabled_flag << std::endl;
3356 oss << "pcm_enabled_flag = " << +seqParams->pcm_enabled_flag << std::endl;
3357 oss << "pcm_loop_filter_disable_flag = " << +seqParams->pcm_loop_filter_disable_flag << std::endl;
3358 oss << "chroma_format_idc = " << +seqParams->chroma_format_idc << std::endl;
3359 oss << "separate_colour_plane_flag = " << +seqParams->separate_colour_plane_flag << std::endl;
3360 oss << "palette_mode_enabled_flag = " << +seqParams->palette_mode_enabled_flag << std::endl;
3361 oss << "RGBEncodingEnable = " << +seqParams->RGBEncodingEnable << std::endl;
3362 oss << "PrimaryChannelForRGBEncoding = " << +seqParams->PrimaryChannelForRGBEncoding << std::endl;
3363 oss << "SecondaryChannelForRGBEncoding = " << +seqParams->SecondaryChannelForRGBEncoding << std::endl;
3364
3365 oss << "log2_max_coding_block_size_minus3 = " << +seqParams->log2_max_coding_block_size_minus3 << std::endl;
3366 oss << "log2_min_coding_block_size_minus3 = " << +seqParams->log2_min_coding_block_size_minus3 << std::endl;
3367 oss << "log2_max_transform_block_size_minus2 = " << +seqParams->log2_max_transform_block_size_minus2 << std::endl;
3368 oss << "log2_min_transform_block_size_minus2 = " << +seqParams->log2_min_transform_block_size_minus2 << std::endl;
3369 oss << "max_transform_hierarchy_depth_intra = " << +seqParams->max_transform_hierarchy_depth_intra << std::endl;
3370 oss << "max_transform_hierarchy_depth_inter = " << +seqParams->max_transform_hierarchy_depth_inter << std::endl;
3371 oss << "log2_min_PCM_cb_size_minus3 = " << +seqParams->log2_min_PCM_cb_size_minus3 << std::endl;
3372 oss << "log2_max_PCM_cb_size_minus3 = " << +seqParams->log2_max_PCM_cb_size_minus3 << std::endl;
3373 oss << "bit_depth_luma_minus8 = " << +seqParams->bit_depth_luma_minus8 << std::endl;
3374 oss << "bit_depth_chroma_minus8 = " << +seqParams->bit_depth_chroma_minus8 << std::endl;
3375 oss << "pcm_sample_bit_depth_luma_minus1 = " << +seqParams->pcm_sample_bit_depth_luma_minus1 << std::endl;
3376 oss << "pcm_sample_bit_depth_chroma_minus1 = " << +seqParams->pcm_sample_bit_depth_chroma_minus1 << std::endl;
3377 oss << "Video Surveillance Mode = " << +seqParams->bVideoSurveillance << std::endl;
3378 oss << "Frame Size Tolerance = " << +seqParams->FrameSizeTolerance << std::endl;
3379 oss << "Look Ahead Depth = " << +seqParams->LookaheadDepth << std::endl;
3380
3381 const char *fileName = m_debugInterface->CreateFileName(
3382 "_DDIEnc",
3383 CodechalDbgBufferType::bufSeqParams,
3384 CodechalDbgExtType::txt);
3385
3386 std::ofstream ofs(fileName, std::ios::out);
3387 ofs << oss.str();
3388 ofs.close();
3389
3390 if (m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDriverUltDump))
3391 {
3392 if (!m_debugInterface->m_ddiFileName.empty())
3393 {
3394 std::ofstream ofs(m_debugInterface->m_ddiFileName, std::ios::app);
3395 ofs << "SeqParamFile"
3396 << " = \"" << m_debugInterface->m_fileName << "\"" << std::endl;
3397 ofs.close();
3398 }
3399 }
3400
3401 return MOS_STATUS_SUCCESS;
3402 }
3403
3404 MOS_STATUS CodechalEncodeHevcBase::DumpPicParams(
3405 PCODEC_HEVC_ENCODE_PICTURE_PARAMS picParams)
3406 {
3407 CODECHAL_DEBUG_FUNCTION_ENTER;
3408
3409 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
3410 {
3411 return MOS_STATUS_SUCCESS;
3412 }
3413
3414 CODECHAL_DEBUG_CHK_NULL(picParams);
3415
3416 std::ostringstream oss;
3417 oss.setf(std::ios::showbase | std::ios::uppercase);
3418
3419 oss << "# DDI Parameters:" << std::endl;
3420 oss << "CurrOriginalPic = " << +picParams->CurrOriginalPic.FrameIdx << std::endl;
3421 oss << "CurrReconstructedPic = " << +picParams->CurrReconstructedPic.FrameIdx << std::endl;
3422 oss << "CollocatedRefPicIndex = " << +picParams->CollocatedRefPicIndex << std::endl;
3423
3424 for (uint16_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; ++i)
3425 {
3426 oss << "RefFrameList[" << +i << "] = " << +picParams->RefFrameList[i].FrameIdx << std::endl;
3427 }
3428
3429 oss << "CurrPicOrderCnt = " << +picParams->CurrPicOrderCnt << std::endl;
3430
3431 for (uint16_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; ++i)
3432 {
3433 oss << "RefFramePOCList[" << +i << "] = " << +picParams->RefFramePOCList[i] << std::endl;
3434 }
3435
3436 oss << "CodingType = " << +picParams->CodingType << std::endl;
3437 oss << "HierarchLevelPlus1 = " << +picParams->HierarchLevelPlus1 << std::endl;
3438 oss << "NumSlices = " << +picParams->NumSlices << std::endl;
3439 oss << "tiles_enabled_flag = " << +picParams->tiles_enabled_flag << std::endl;
3440
3441 if (picParams->tiles_enabled_flag)
3442 {
3443 oss << "num_tile_columns = " << +picParams->num_tile_columns_minus1 + 1 << std::endl;
3444 for (uint32_t i = 0; i <= picParams->num_tile_columns_minus1; i++)
3445 {
3446 oss << "tile_column_width[" << +i << "] = " << +picParams->tile_column_width[i] << std::endl;
3447 }
3448 oss << "num_tile_rows = " << +picParams->num_tile_rows_minus1 + 1 << std::endl;
3449 for (uint32_t i = 0; i <= picParams->num_tile_rows_minus1; i++)
3450 {
3451 oss << "tile_row_height[" << +i << "] = " << +picParams->tile_row_height[i] << std::endl;
3452 }
3453 }
3454
3455 oss << "entropy_coding_sync_enabled_flag = " << +picParams->entropy_coding_sync_enabled_flag << std::endl;
3456 oss << "sign_data_hiding_flag = " << +picParams->sign_data_hiding_flag << std::endl;
3457 oss << "constrained_intra_pred_flag = " << +picParams->constrained_intra_pred_flag << std::endl;
3458 oss << "transform_skip_enabled_flag = " << +picParams->transform_skip_enabled_flag << std::endl;
3459 oss << "transquant_bypass_enabled_flag = " << +picParams->transquant_bypass_enabled_flag << std::endl;
3460 oss << "cu_qp_delta_enabled_flag = " << +picParams->cu_qp_delta_enabled_flag << std::endl;
3461 oss << "weighted_pred_flag = " << +picParams->weighted_pred_flag << std::endl;
3462 oss << "weighted_bipred_flag = " << +picParams->weighted_bipred_flag << std::endl;
3463 oss << "bEnableGPUWeightedPrediction = " << +picParams->bEnableGPUWeightedPrediction << std::endl;
3464 oss << "loop_filter_across_slices_flag = " << +picParams->loop_filter_across_slices_flag << std::endl;
3465 oss << "loop_filter_across_tiles_flag = " << +picParams->loop_filter_across_tiles_flag << std::endl;
3466 oss << "scaling_list_data_present_flag = " << +picParams->scaling_list_data_present_flag << std::endl;
3467 oss << "dependent_slice_segments_enabled_flag = " << +picParams->dependent_slice_segments_enabled_flag << std::endl;
3468 oss << "bLastPicInSeq = " << +picParams->bLastPicInSeq << std::endl;
3469 oss << "bLastPicInStream = " << +picParams->bLastPicInStream << std::endl;
3470 oss << "bUseRawPicForRef = " << +picParams->bUseRawPicForRef << std::endl;
3471 oss << "bEmulationByteInsertion = " << +picParams->bEmulationByteInsertion << std::endl;
3472 oss << "bEnableRollingIntraRefresh = " << +picParams->bEnableRollingIntraRefresh << std::endl;
3473 oss << "BRCPrecision = " << +picParams->BRCPrecision << std::endl;
3474 oss << "bScreenContent = " << +picParams->bScreenContent << std::endl;
3475 oss << "QpY = " << +picParams->QpY << std::endl;
3476 oss << "diff_cu_qp_delta_depth = " << +picParams->diff_cu_qp_delta_depth << std::endl;
3477 oss << "pps_cb_qp_offset = " << +picParams->pps_cb_qp_offset << std::endl;
3478 oss << "pps_cr_qp_offset = " << +picParams->pps_cr_qp_offset << std::endl;
3479 oss << "num_tile_columns_minus1 = " << +picParams->num_tile_columns_minus1 << std::endl;
3480 oss << "num_tile_rows_minus1 = " << +picParams->num_tile_rows_minus1 << std::endl;
3481 oss << "log2_parallel_merge_level_minus2 = " << +picParams->log2_parallel_merge_level_minus2 << std::endl;
3482 oss << "num_ref_idx_l0_default_active_minus1 = " << +picParams->num_ref_idx_l0_default_active_minus1 << std::endl;
3483 oss << "num_ref_idx_l1_default_active_minus1 = " << +picParams->num_ref_idx_l1_default_active_minus1 << std::endl;
3484 oss << "LcuMaxBitsizeAllowed = " << +picParams->LcuMaxBitsizeAllowed << std::endl;
3485 oss << "IntraInsertionLocation = " << +picParams->IntraInsertionLocation << std::endl;
3486 oss << "IntraInsertionSize = " << +picParams->IntraInsertionSize << std::endl;
3487 oss << "QpDeltaForInsertedIntra = " << +picParams->QpDeltaForInsertedIntra << std::endl;
3488 oss << "StatusReportFeedbackNumber = " << +picParams->StatusReportFeedbackNumber << std::endl;
3489 oss << "slice_pic_parameter_set_id = " << +picParams->slice_pic_parameter_set_id << std::endl;
3490 oss << "nal_unit_type = " << +picParams->nal_unit_type << std::endl;
3491 oss << "MaxSliceSizeInBytes = " << +picParams->MaxSliceSizeInBytes << std::endl;
3492 oss << "NumROI = " << +picParams->NumROI << std::endl;
3493
3494 for (uint8_t i = 0; i < 16; ++i)
3495 {
3496 oss << "ROI[" << +i << "] = ";
3497 oss << picParams->ROI[i].Top << " ";
3498 oss << picParams->ROI[i].Bottom << " ";
3499 oss << picParams->ROI[i].Left << " ";
3500 oss << picParams->ROI[i].Right << " ";
3501 oss << picParams->ROI[i].PriorityLevelOrDQp << std::endl;
3502 }
3503 oss << "MaxDeltaQp = " << +picParams->MaxDeltaQp << std::endl;
3504 oss << "MinDeltaQp = " << +picParams->MinDeltaQp << std::endl;
3505 oss << "NumDirtyRects = " << +picParams->NumDirtyRects << std::endl;
3506
3507 if ((picParams->NumDirtyRects > 0) && picParams->pDirtyRect)
3508 {
3509 for (uint16_t i = 0; i < picParams->NumDirtyRects; i++)
3510 {
3511 oss << "pDirtyRect[" << +i << "].Bottom = " << +picParams->pDirtyRect[i].Bottom << std::endl;
3512 oss << "pDirtyRect[" << +i << "].Top = " << +picParams->pDirtyRect[i].Top << std::endl;
3513 oss << "pDirtyRect[" << +i << "].Left = " << +picParams->pDirtyRect[i].Left << std::endl;
3514 oss << "pDirtyRect[" << +i << "].Right = " << +picParams->pDirtyRect[i].Right << std::endl;
3515 }
3516 }
3517
3518 oss << "TargetFrameSize = " << +picParams->TargetFrameSize << std::endl;
3519
3520 const char *fileName = m_debugInterface->CreateFileName(
3521 "_DDIEnc",
3522 CodechalDbgBufferType::bufPicParams,
3523 CodechalDbgExtType::txt);
3524
3525 std::ofstream ofs(fileName, std::ios::out);
3526 ofs << oss.str();
3527 ofs.close();
3528
3529 if (m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDriverUltDump))
3530 {
3531 if (!m_debugInterface->m_ddiFileName.empty())
3532 {
3533 std::ofstream ofs(m_debugInterface->m_ddiFileName, std::ios::app);
3534 ofs << "PicNum"
3535 << " = \"" << m_debugInterface->m_bufferDumpFrameNum << "\"" << std::endl;
3536 ofs << "PicParamFile"
3537 << " = \"" << m_debugInterface->m_fileName << "\"" << std::endl;
3538 ofs.close();
3539 }
3540 }
3541
3542 return MOS_STATUS_SUCCESS;
3543 }
3544
3545 MOS_STATUS CodechalEncodeHevcBase::DumpFeiPicParams(
3546 CodecEncodeHevcFeiPicParams *feiPicParams)
3547 {
3548 CODECHAL_DEBUG_FUNCTION_ENTER;
3549
3550 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrFeiPicParams))
3551 {
3552 return MOS_STATUS_SUCCESS;
3553 }
3554
3555 CODECHAL_DEBUG_CHK_NULL(feiPicParams);
3556
3557 std::ostringstream oss;
3558 oss.setf(std::ios::showbase | std::ios::uppercase);
3559
3560 oss << "# DDI Parameters:" << std::endl;
3561 oss << "NumMVPredictorsL0 = " << +feiPicParams->NumMVPredictorsL0 << std::endl;
3562 oss << "NumMVPredictorsL1 = " << +feiPicParams->NumMVPredictorsL1 << std::endl;
3563 oss << "bCTBCmdCuRecordEnable = " << +feiPicParams->bCTBCmdCuRecordEnable << std::endl;
3564 oss << "bDistortionEnable = " << +feiPicParams->bDistortionEnable << std::endl;
3565 oss << "SearchPath = " << +feiPicParams->SearchPath << std::endl;
3566 oss << "LenSP = " << +feiPicParams->LenSP << std::endl;
3567 oss << "MultiPredL0 = " << +feiPicParams->MultiPredL0 << std::endl;
3568 oss << "MultiPredL1 = " << +feiPicParams->MultiPredL1 << std::endl;
3569 oss << "SubPelMode = " << +feiPicParams->SubPelMode << std::endl;
3570 oss << "AdaptiveSearch = " << +feiPicParams->AdaptiveSearch << std::endl;
3571 oss << "MVPredictorInput = " << +feiPicParams->MVPredictorInput << std::endl;
3572 oss << "bPerBlockQP = " << +feiPicParams->bPerBlockQP << std::endl;
3573 oss << "bPerCTBInput = " << +feiPicParams->bPerCTBInput << std::endl;
3574 oss << "bColocatedCTBDistortion = " << +feiPicParams->bColocatedCTBDistortion << std::endl;
3575 oss << "bForceLCUSplit = " << +feiPicParams->bForceLCUSplit << std::endl;
3576 oss << "bEnableCU64Check = " << +feiPicParams->bEnableCU64Check << std::endl;
3577 oss << "bEnableCU64AmpCheck = " << +feiPicParams->bEnableCU64AmpCheck << std::endl;
3578 oss << "bCU64SkipCheckOnly = " << +feiPicParams->bCU64SkipCheckOnly << std::endl;
3579 oss << "RefWidth = " << +feiPicParams->RefWidth << std::endl;
3580 oss << "RefHeight = " << +feiPicParams->RefHeight << std::endl;
3581 oss << "SearchWindow = " << +feiPicParams->SearchWindow << std::endl;
3582 oss << "MaxNumIMESearchCenter = " << +feiPicParams->MaxNumIMESearchCenter << std::endl;
3583 oss << "NumConcurrentEncFramePartition = " << +feiPicParams->NumConcurrentEncFramePartition << std::endl;
3584
3585 const char *fileName = m_debugInterface->CreateFileName(
3586 "_DDIEnc",
3587 CodechalDbgBufferType::bufFeiPicParams,
3588 CodechalDbgExtType::txt);
3589
3590 std::ofstream ofs(fileName, std::ios::out);
3591 ofs << oss.str();
3592 ofs.close();
3593
3594 if (m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDriverUltDump))
3595 {
3596 if (!m_debugInterface->m_ddiFileName.empty())
3597 {
3598 std::ofstream ofs(m_debugInterface->m_ddiFileName, std::ios::app);
3599 ofs << "PicNum"
3600 << " = \"" << m_debugInterface->m_bufferDumpFrameNum << "\"" << std::endl;
3601 ofs << "FeiPicParamFile"
3602 << " = \"" << m_debugInterface->m_fileName << "\"" << std::endl;
3603 ofs.close();
3604 }
3605 }
3606
3607 return MOS_STATUS_SUCCESS;
3608 }
3609
3610 MOS_STATUS CodechalEncodeHevcBase::DumpSliceParams(
3611 PCODEC_HEVC_ENCODE_SLICE_PARAMS sliceParams,
3612 PCODEC_HEVC_ENCODE_PICTURE_PARAMS picParams)
3613 {
3614 CODECHAL_DEBUG_FUNCTION_ENTER;
3615 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
3616 {
3617 return MOS_STATUS_SUCCESS;
3618 }
3619
3620 CODECHAL_DEBUG_CHK_NULL(sliceParams);
3621
3622 m_debugInterface->m_sliceId = sliceParams->slice_id; // set here for constructing debug file name
3623
3624 std::ostringstream oss;
3625 oss.setf(std::ios::showbase | std::ios::uppercase);
3626
3627 oss << "# DDI Parameters:" << std::endl;
3628 oss << "slice_segment_address = " << +sliceParams->slice_segment_address << std::endl;
3629 oss << "NumLCUsInSlice = " << +sliceParams->NumLCUsInSlice << std::endl;
3630
3631 // RefPicList (2 x CODEC_MAX_NUM_REF_FRAME_HEVC)
3632 for (uint8_t i = 0; i < 2; ++i)
3633 {
3634 for (uint8_t j = 0; j < CODEC_MAX_NUM_REF_FRAME_HEVC; ++j)
3635 {
3636 oss << "RefPicList[" << +i << "][" << +j << "] = " << +sliceParams->RefPicList[i][j].PicEntry << std::endl;
3637 }
3638 }
3639
3640 oss << "num_ref_idx_l0_active_minus1 = " << +sliceParams->num_ref_idx_l0_active_minus1 << std::endl;
3641 oss << "num_ref_idx_l1_active_minus1 = " << +sliceParams->num_ref_idx_l1_active_minus1 << std::endl;
3642 oss << "bLastSliceOfPic = " << +sliceParams->bLastSliceOfPic << std::endl;
3643 oss << "dependent_slice_segment_flag = " << +sliceParams->dependent_slice_segment_flag << std::endl;
3644 oss << "slice_temporal_mvp_enable_flag = " << +sliceParams->slice_temporal_mvp_enable_flag << std::endl;
3645 oss << "slice_type = " << +sliceParams->slice_type << std::endl;
3646 oss << "slice_sao_luma_flag = " << +sliceParams->slice_sao_luma_flag << std::endl;
3647 oss << "slice_sao_chroma_flag = " << +sliceParams->slice_sao_chroma_flag << std::endl;
3648 oss << "mvd_l1_zero_flag = " << +sliceParams->mvd_l1_zero_flag << std::endl;
3649 oss << "cabac_init_flag = " << +sliceParams->cabac_init_flag << std::endl;
3650 oss << "slice_deblocking_filter_disable_flag = " << +sliceParams->slice_deblocking_filter_disable_flag << std::endl;
3651 oss << "collocated_from_l0_flag = " << +sliceParams->collocated_from_l0_flag << std::endl;
3652 oss << "slice_qp_delta = " << +sliceParams->slice_qp_delta << std::endl;
3653 oss << "slice_cb_qp_offset = " << +sliceParams->slice_cb_qp_offset << std::endl;
3654 oss << "slice_cr_qp_offset = " << +sliceParams->slice_cr_qp_offset << std::endl;
3655 oss << "beta_offset_div2 = " << +sliceParams->beta_offset_div2 << std::endl;
3656 oss << "tc_offset_div2 = " << +sliceParams->tc_offset_div2 << std::endl;
3657 oss << "luma_log2_weight_denom = " << +sliceParams->luma_log2_weight_denom << std::endl;
3658 oss << "delta_chroma_log2_weight_denom = " << +sliceParams->delta_chroma_log2_weight_denom << std::endl;
3659
3660 for (uint8_t i = 0; i < 2; ++i)
3661 {
3662 for (uint8_t j = 0; j < CODEC_MAX_NUM_REF_FRAME_HEVC; ++j)
3663 {
3664 oss << "luma_offset[" << +i << "][" << +j << "] = " << +sliceParams->luma_offset[i][j] << std::endl;
3665
3666 oss << "delta_luma_weight[" << +i << "][" << +j << "] = " << +sliceParams->delta_luma_weight[i][j] << std::endl;
3667 }
3668 }
3669
3670 for (uint8_t i = 0; i < 2; ++i)
3671 {
3672 for (uint8_t j = 0; j < CODEC_MAX_NUM_REF_FRAME_HEVC; ++j)
3673 {
3674 for (uint8_t k = 0; k < 2; ++k)
3675 {
3676 oss << "chroma_offset[" << +i << "][" << +j << "][" << +k << "] = " << +sliceParams->chroma_offset[i][j][k] << std::endl;
3677 oss << "delta_chroma_weight[" << +i << "][" << +j << "][" << +k << "] = " << +sliceParams->delta_chroma_weight[i][j][k] << std::endl;
3678 }
3679 }
3680 }
3681
3682 oss << "PredWeightTableBitOffset = " << +sliceParams->PredWeightTableBitOffset << std::endl;
3683 oss << "PredWeightTableBitLength = " << +sliceParams->PredWeightTableBitLength << std::endl;
3684 oss << "MaxNumMergeCand = " << +sliceParams->MaxNumMergeCand << std::endl;
3685 oss << "slice_id = " << +sliceParams->slice_id << std::endl;
3686 oss << "SliceHeaderByteOffset = " << +sliceParams->SliceHeaderByteOffset << std::endl;
3687 oss << "BitLengthSliceHeaderStartingPortion = " << +sliceParams->BitLengthSliceHeaderStartingPortion << std::endl;
3688 oss << "SliceSAOFlagBitOffset = " << +sliceParams->SliceSAOFlagBitOffset << std::endl;
3689
3690 const char *fileName = m_debugInterface->CreateFileName(
3691 "_DDIEnc",
3692 CodechalDbgBufferType::bufSlcParams,
3693 CodechalDbgExtType::txt);
3694
3695 std::ofstream ofs(fileName, std::ios::out);
3696 ofs << oss.str();
3697 ofs.close();
3698
3699 if (m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDriverUltDump))
3700 {
3701 if (!m_debugInterface->m_ddiFileName.empty())
3702 {
3703 std::ofstream ofs(m_debugInterface->m_ddiFileName, std::ios::app);
3704 ofs << "SlcParamFile"
3705 << " = \"" << m_debugInterface->m_fileName << "\"" << std::endl;
3706 ofs.close();
3707 }
3708 }
3709
3710 return MOS_STATUS_SUCCESS;
3711 }
3712
3713 MOS_STATUS CodechalEncodeHevcBase::DumpMbEncPakOutput(PCODEC_REF_LIST currRefList, CodechalDebugInterface* debugInterface)
3714 {
3715 CODECHAL_ENCODE_FUNCTION_ENTER;
3716 CODECHAL_ENCODE_CHK_NULL_RETURN(currRefList);
3717 CODECHAL_ENCODE_CHK_NULL_RETURN(debugInterface);
3718
3719 CODECHAL_ENCODE_CHK_STATUS_RETURN(debugInterface->DumpBuffer(
3720 &currRefList->resRefMbCodeBuffer,
3721 CodechalDbgAttr::attrOutput,
3722 "PakObj",
3723 m_mvOffset,
3724 0,
3725 CODECHAL_MEDIA_STATE_ENC_NORMAL));
3726
3727 CODECHAL_ENCODE_CHK_STATUS_RETURN(debugInterface->DumpBuffer(
3728 &currRefList->resRefMbCodeBuffer,
3729 CodechalDbgAttr::attrOutput,
3730 "CuRecord",
3731 m_mbCodeSize - m_mvOffset,
3732 m_mvOffset,
3733 CODECHAL_MEDIA_STATE_ENC_NORMAL));
3734
3735 return MOS_STATUS_SUCCESS;
3736 }
3737
3738 MOS_STATUS CodechalEncodeHevcBase::DumpFrameStatsBuffer(CodechalDebugInterface* debugInterface)
3739 {
3740 CODECHAL_ENCODE_FUNCTION_ENTER;
3741 CODECHAL_ENCODE_CHK_NULL_RETURN(debugInterface);
3742
3743 CODECHAL_ENCODE_CHK_STATUS_RETURN(debugInterface->DumpBuffer(
3744 &m_resFrameStatStreamOutBuffer,
3745 CodechalDbgAttr::attrFrameState,
3746 "FrameStatus",
3747 m_sizeOfHcpPakFrameStats,
3748 0,
3749 CODECHAL_NUM_MEDIA_STATES));
3750
3751 return MOS_STATUS_SUCCESS;
3752 }
3753 #endif