Debian Codegraph @

media_softlet/linux/common/codec/ddi/enc/ddi_encode_hevc_specific.cpp

raw
1 /*
2 * Copyright (c) 2022, 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 ddi_encode_hevc_specific.cpp
24 //! \brief HEVC class definition for DDI media encoder.
25 //!
26
27 #include "media_ddi_base.h"
28 #include "ddi_encode_base_specific.h"
29 #include "ddi_encode_hevc_specific.h"
30 #include "media_libva_util_next.h"
31 #include "media_ddi_encode_const.h"
32 #include "media_ddi_factory.h"
33 #include "codechal_encoder_base.h"
34 #include "media_libva_interface_next.h"
35
36
37 namespace encode
38 {
39
40 DdiEncodeHevc::~DdiEncodeHevc()
41 {
42 if (m_encodeCtx == nullptr)
43 {
44 return;
45 }
46
47 MOS_FreeMemory(m_encodeCtx->pSeqParams);
48 m_encodeCtx->pSeqParams = nullptr;
49
50 MOS_FreeMemory(((PCODEC_HEVC_ENCODE_PICTURE_PARAMS)m_encodeCtx->pPicParams)->pDirtyRect);
51 ((PCODEC_HEVC_ENCODE_PICTURE_PARAMS)m_encodeCtx->pPicParams)->pDirtyRect = nullptr;
52 MOS_FreeMemory(m_encodeCtx->pPicParams);
53 m_encodeCtx->pPicParams = nullptr;
54
55 if (m_encodeCtx->ppNALUnitParams)
56 {
57 // Allocate one contiguous memory for the NALUnitParams buffers
58 // only need to free one time
59 MOS_FreeMemory(m_encodeCtx->ppNALUnitParams[0]);
60 m_encodeCtx->ppNALUnitParams[0] = nullptr;
61
62 MOS_FreeMemory(m_encodeCtx->ppNALUnitParams);
63 m_encodeCtx->ppNALUnitParams = nullptr;
64 }
65
66 MOS_FreeMemory(m_encodeCtx->pSliceParams);
67 m_encodeCtx->pSliceParams = nullptr;
68
69 MOS_FreeMemory(m_encodeCtx->pEncodeStatusReport);
70 m_encodeCtx->pEncodeStatusReport = nullptr;
71
72 MOS_FreeMemory(m_encodeCtx->pSEIFromApp->pSEIBuffer);
73 m_encodeCtx->pSEIFromApp->pSEIBuffer = nullptr;
74 MOS_FreeMemory(m_encodeCtx->pSEIFromApp);
75 m_encodeCtx->pSEIFromApp = nullptr;
76
77 MOS_FreeMemory(m_encodeCtx->pSliceHeaderData);
78 m_encodeCtx->pSliceHeaderData = nullptr;
79
80 MOS_FreeMemory(m_encodeCtx->pQmatrixParams);
81 m_encodeCtx->pQmatrixParams = nullptr;
82
83 if (m_encodeCtx->pbsBuffer)
84 {
85 MOS_FreeMemory(m_encodeCtx->pbsBuffer->pBase);
86 m_encodeCtx->pbsBuffer->pBase = nullptr;
87
88 MOS_FreeMemory(m_encodeCtx->pbsBuffer);
89 m_encodeCtx->pbsBuffer = nullptr;
90 }
91 }
92
93 VAStatus DdiEncodeHevc::ContextInitialize(
94 CodechalSetting *codecHalSettings)
95 {
96 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx.", VA_STATUS_ERROR_INVALID_CONTEXT);
97 DDI_CODEC_CHK_NULL(m_encodeCtx->pCpDdiInterfaceNext, "nullptr m_encodeCtx->pCpDdiInterfaceNext.", VA_STATUS_ERROR_INVALID_CONTEXT);
98 DDI_CODEC_CHK_NULL(codecHalSettings, "nullptr codecHalSettings.", VA_STATUS_ERROR_INVALID_CONTEXT);
99
100 codecHalSettings->codecFunction = CODECHAL_FUNCTION_ENC_VDENC_PAK;
101 codecHalSettings->disableUltraHME = false;
102 codecHalSettings->disableSuperHME = false;
103 codecHalSettings->height = m_encodeCtx->dworiFrameHeight;
104 codecHalSettings->width = m_encodeCtx->dworiFrameWidth;
105 codecHalSettings->mode = m_encodeCtx->wModeType;
106 codecHalSettings->standard = CODECHAL_HEVC;
107
108 if(m_encodeCtx->vaProfile==VAProfileHEVCMain || m_encodeCtx->vaProfile==VAProfileHEVCSccMain)
109 {
110 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV420;
111 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_8_BITS;
112 }
113 else if(m_encodeCtx->vaProfile==VAProfileHEVCMain10 || m_encodeCtx->vaProfile==VAProfileHEVCSccMain10)
114 {
115 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV420;
116 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_10_BITS;
117 }
118 else if(m_encodeCtx->vaProfile == VAProfileHEVCMain12)
119 {
120 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV420;
121 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_12_BITS;
122 }
123 else if(m_encodeCtx->vaProfile == VAProfileHEVCMain422_10)
124 {
125 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV422;
126 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_10_BITS;
127 }
128 else if(m_encodeCtx->vaProfile == VAProfileHEVCMain422_12)
129 {
130 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV422;
131 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_12_BITS;
132 }
133 else if (m_encodeCtx->vaProfile == VAProfileHEVCMain444 || m_encodeCtx->vaProfile==VAProfileHEVCSccMain444)
134 {
135 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV444;
136 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_8_BITS;
137 }
138 else if (m_encodeCtx->vaProfile == VAProfileHEVCMain444_10 || m_encodeCtx->vaProfile==VAProfileHEVCSccMain444_10)
139 {
140 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV444;
141 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_10_BITS;
142 }
143 else if (m_encodeCtx->vaProfile == VAProfileHEVCMain444_12)
144 {
145 codecHalSettings->chromaFormat = HCP_CHROMA_FORMAT_YUV444;
146 codecHalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_12_BITS;
147 }
148 codecHalSettings->isSCCEnabled = IsSccProfile();
149
150 VAStatus eStatus = VA_STATUS_SUCCESS;
151
152 // Allocate sequence params
153 m_encodeCtx->pSeqParams = (void *)MOS_AllocAndZeroMemory(sizeof(CODEC_HEVC_ENCODE_SEQUENCE_PARAMS));
154 DDI_CODEC_CHK_NULL(m_encodeCtx->pSeqParams, "nullptr m_encodeCtx->pSeqParams.", VA_STATUS_ERROR_ALLOCATION_FAILED);
155
156 // Allocate picture params
157 m_encodeCtx->pPicParams = (void *)MOS_AllocAndZeroMemory(sizeof(CODEC_HEVC_ENCODE_PICTURE_PARAMS));
158 DDI_CODEC_CHK_NULL(m_encodeCtx->pPicParams, "nullptr m_encodeCtx->pPicParams.", VA_STATUS_ERROR_ALLOCATION_FAILED);
159
160 // Allocate NAL unit params
161 m_encodeCtx->ppNALUnitParams = (PCODECHAL_NAL_UNIT_PARAMS *)MOS_AllocAndZeroMemory(sizeof(PCODECHAL_NAL_UNIT_PARAMS) * HEVC_MAX_NAL_UNIT_TYPE);
162 DDI_CODEC_CHK_NULL(m_encodeCtx->ppNALUnitParams, "nullptr m_encodeCtx->ppNALUnitParams.", VA_STATUS_ERROR_ALLOCATION_FAILED);
163
164 PCODECHAL_NAL_UNIT_PARAMS nalUnitParams = (CODECHAL_NAL_UNIT_PARAMS *)MOS_AllocAndZeroMemory(sizeof(CODECHAL_NAL_UNIT_PARAMS) * HEVC_MAX_NAL_UNIT_TYPE);
165 DDI_CODEC_CHK_NULL(nalUnitParams, "nullptr nalUnitParams.", VA_STATUS_ERROR_ALLOCATION_FAILED);
166
167 for (uint32_t i = 0; i < HEVC_MAX_NAL_UNIT_TYPE; i++)
168 {
169 m_encodeCtx->ppNALUnitParams[i] = &(nalUnitParams[i]);
170 }
171
172 // Allocate SliceParams
173 uint32_t picSizeInMb = m_encodeCtx->wPicHeightInMB * m_encodeCtx->wPicWidthInMB;
174 // Supports one LCU per slice, with minimum LCU size of 16x16
175 m_encodeCtx->pSliceParams = (void *)MOS_AllocAndZeroMemory(picSizeInMb * sizeof(CODEC_HEVC_ENCODE_SLICE_PARAMS));
176 DDI_CODEC_CHK_NULL(m_encodeCtx->pSliceParams, "nullptr m_encodeCtx->pSliceParams.", VA_STATUS_ERROR_ALLOCATION_FAILED);
177
178 // Allocate Encode Status Report
179 m_encodeCtx->pEncodeStatusReport = (void *)MOS_AllocAndZeroMemory(CODECHAL_ENCODE_STATUS_NUM * sizeof(EncodeStatusReportData));
180 DDI_CODEC_CHK_NULL(m_encodeCtx->pEncodeStatusReport, "nullptr m_encodeCtx->pEncodeStatusReport.", VA_STATUS_ERROR_ALLOCATION_FAILED);
181
182 // Allocate SEI structure
183 m_encodeCtx->pSEIFromApp = (CodechalEncodeSeiData *)MOS_AllocAndZeroMemory(sizeof(CodechalEncodeSeiData));
184 DDI_CODEC_CHK_NULL(m_encodeCtx->pSEIFromApp, "nullptr m_encodeCtx->pSEIFromApp.", VA_STATUS_ERROR_ALLOCATION_FAILED);
185
186 // Allocate Qmatrix structure
187 m_encodeCtx->pQmatrixParams = (void *)MOS_AllocAndZeroMemory(sizeof(CODECHAL_HEVC_IQ_MATRIX_PARAMS));
188 DDI_CODEC_CHK_NULL(m_encodeCtx->pQmatrixParams, "nullptr QMatrixParams", VA_STATUS_ERROR_ALLOCATION_FAILED);
189
190 // for slice header from application
191 m_encodeCtx->pSliceHeaderData = (CODEC_ENCODER_SLCDATA *)MOS_AllocAndZeroMemory(picSizeInMb * sizeof(CODEC_ENCODER_SLCDATA));
192 DDI_CODEC_CHK_NULL(m_encodeCtx->pSliceHeaderData, "nullptr m_encodeCtx->pSliceHeaderData.", VA_STATUS_ERROR_ALLOCATION_FAILED);
193
194 // Create the bit stream buffer to hold the packed headers from application
195 m_encodeCtx->pbsBuffer = (BSBuffer *)MOS_AllocAndZeroMemory(sizeof(BSBuffer));
196 DDI_CODEC_CHK_NULL(m_encodeCtx->pbsBuffer, "nullptr m_encodeCtx->pbsBuffer.", VA_STATUS_ERROR_ALLOCATION_FAILED);
197
198 m_encodeCtx->pbsBuffer->BufferSize = picSizeInMb * PACKED_HEADER_SIZE_PER_ROW;
199 m_encodeCtx->pbsBuffer->pBase = (uint8_t *)MOS_AllocAndZeroMemory(m_encodeCtx->pbsBuffer->BufferSize);
200 DDI_CODEC_CHK_NULL(m_encodeCtx->pbsBuffer->pBase, "nullptr m_encodeCtx->pbsBuffer->pBase.", VA_STATUS_ERROR_ALLOCATION_FAILED);
201
202 return eStatus;
203 }
204
205 VAStatus DdiEncodeHevc::RenderPicture(VADriverContextP ctx, VAContextID context, VABufferID *buffers, int32_t numBuffers)
206 {
207 VAStatus vaStatus = VA_STATUS_SUCCESS;
208
209 DDI_CODEC_FUNC_ENTER;
210
211 DDI_CODEC_CHK_NULL(ctx, "nullptr context", VA_STATUS_ERROR_INVALID_CONTEXT);
212
213 DDI_MEDIA_CONTEXT *mediaCtx = GetMediaContext(ctx);
214 DDI_CODEC_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
215
216 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
217
218 for (int32_t i = 0; i < numBuffers; i++)
219 {
220 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, buffers[i]);
221 DDI_CODEC_CHK_NULL(buf, "Invalid buffer.", VA_STATUS_ERROR_INVALID_BUFFER);
222 if (buf->uiType == VAEncMacroblockDisableSkipMapBufferType)
223 {
224 MediaLibvaCommonNext::MediaBufferToMosResource(buf, &(m_encodeCtx->resPerMBSkipMapBuffer));
225 m_encodeCtx->bMbDisableSkipMapEnabled = true;
226 continue;
227 }
228 uint32_t dataSize = buf->iSize;
229 // can use internal function instead of MapBuffer here?
230 void *data = nullptr;
231 MediaLibvaInterfaceNext::MapBuffer(ctx, buffers[i], &data);
232
233 DDI_CODEC_CHK_NULL(data, "nullptr data.", VA_STATUS_ERROR_INVALID_BUFFER);
234
235 switch (buf->uiType)
236 {
237 case VAQMatrixBufferType:
238 DDI_CHK_STATUS(Qmatrix(data), VA_STATUS_ERROR_INVALID_BUFFER);
239 break;
240
241 case VAEncSequenceParameterBufferType:
242 DDI_CHK_STATUS(ParseSeqParams(data), VA_STATUS_ERROR_INVALID_BUFFER);
243 m_encodeCtx->bNewSeq = true;
244 break;
245
246 case VAEncPictureParameterBufferType:
247 DDI_CHK_STATUS(ParsePicParams(mediaCtx, data), VA_STATUS_ERROR_INVALID_BUFFER);
248 DDI_CHK_STATUS(
249 AddToStatusReportQueue((void *)m_encodeCtx->resBitstreamBuffer.bo),
250 VA_STATUS_ERROR_INVALID_BUFFER);
251 break;
252
253 case VAEncSliceParameterBufferType:
254 {
255 uint32_t numSlices = buf->uiNumElements;
256 DDI_CHK_STATUS(ParseSlcParams(mediaCtx, data, numSlices), VA_STATUS_ERROR_INVALID_BUFFER);
257 break;
258 }
259
260 case VAEncPackedHeaderParameterBufferType:
261 vaStatus = ParsePackedHeaderParams(data);
262 break;
263
264 case VAEncPackedHeaderDataBufferType:
265 vaStatus = ParsePackedHeaderData(data);
266 break;
267
268 case VAEncMiscParameterBufferType:
269 DDI_CHK_STATUS(ParseMiscParams(data), VA_STATUS_ERROR_INVALID_BUFFER);
270 break;
271
272 case VAEncQPBufferType:
273 MediaLibvaCommonNext::MediaBufferToMosResource(buf, &m_encodeCtx->resMBQpBuffer);
274 m_encodeCtx->bMBQpEnable = true;
275 break;
276
277 default:
278 DDI_CODEC_ASSERTMESSAGE("not supported buffer type.");
279 break;
280 }
281 MediaLibvaInterfaceNext::UnmapBuffer(ctx, buffers[i]);
282 }
283
284 return vaStatus;
285 }
286
287 VAStatus DdiEncodeHevc::EncodeInCodecHal(uint32_t numSlices)
288 {
289 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
290 DDI_CODEC_CHK_NULL(m_encodeCtx->pCodecHal, "nullptr m_encodeCtx->pCodecHal", VA_STATUS_ERROR_INVALID_PARAMETER);
291
292 DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_encodeCtx->RTtbl);
293
294 EncoderParams encodeParams;
295 MOS_ZeroMemory(&encodeParams, sizeof(encodeParams));
296
297 encodeParams.ExecCodecFunction = CODECHAL_FUNCTION_ENC_VDENC_PAK;
298
299 // Raw Surface
300 MOS_SURFACE rawSurface;
301 MOS_ZeroMemory(&rawSurface, sizeof(rawSurface));
302 rawSurface.dwOffset = 0;
303
304 MediaLibvaCommonNext::MediaSurfaceToMosResource(rtTbl->pCurrentRT, &(rawSurface.OsResource));
305
306 // Recon Surface
307 MOS_SURFACE reconSurface;
308 MOS_ZeroMemory(&reconSurface, sizeof(reconSurface));
309 reconSurface.dwOffset = 0;
310
311 MediaLibvaCommonNext::MediaSurfaceToMosResource(rtTbl->pCurrentReconTarget, &(reconSurface.OsResource));
312
313 //clear registered recon/ref surface flags
314 DDI_CODEC_CHK_RET(ClearRefList(&m_encodeCtx->RTtbl, true), "ClearRefList failed!");
315
316 // Bitstream surface
317 MOS_RESOURCE bitstreamSurface;
318 MOS_ZeroMemory(&bitstreamSurface, sizeof(bitstreamSurface));
319 bitstreamSurface = m_encodeCtx->resBitstreamBuffer; // in render picture
320 bitstreamSurface.Format = Format_Buffer;
321
322 encodeParams.psRawSurface = &rawSurface;
323 encodeParams.psReconSurface = &reconSurface;
324 encodeParams.presBitstreamBuffer = &bitstreamSurface;
325
326 MOS_SURFACE mbQpSurface;
327 if (m_encodeCtx->bMBQpEnable)
328 {
329 // MBQp surface
330 MOS_ZeroMemory(&mbQpSurface, sizeof(mbQpSurface));
331 mbQpSurface.Format = Format_Buffer_2D;
332 mbQpSurface.dwOffset = 0;
333 mbQpSurface.OsResource = m_encodeCtx->resMBQpBuffer;
334
335 encodeParams.psMbQpDataSurface = &mbQpSurface;
336 encodeParams.bMbQpDataEnabled = true;
337 }
338
339 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams = (PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS)((uint8_t *)m_encodeCtx->pSeqParams);
340 if (m_encodeCtx->bNewSeq)
341 {
342 hevcSeqParams->TargetUsage = m_encodeCtx->targetUsage;
343 }
344 encodeParams.pSeqParams = m_encodeCtx->pSeqParams;
345 encodeParams.pVuiParams = m_encodeCtx->pVuiParams;
346 encodeParams.pPicParams = m_encodeCtx->pPicParams;
347 encodeParams.pSliceParams = m_encodeCtx->pSliceParams;
348 encodeParams.pIQMatrixBuffer = m_encodeCtx->pQmatrixParams;
349
350 // Sequence data
351 encodeParams.bNewSeq = m_encodeCtx->bNewSeq;
352
353 // VUI
354 encodeParams.bNewVuiData = m_encodeCtx->bNewVuiData;
355
356 // Slice level data
357 encodeParams.dwNumSlices = numSlices;
358
359 // IQmatrix params
360 encodeParams.bNewQmatrixData = m_encodeCtx->bNewQmatrixData;
361 encodeParams.bPicQuant = m_encodeCtx->bPicQuant;
362 encodeParams.ppNALUnitParams = m_encodeCtx->ppNALUnitParams;
363 encodeParams.uiNumNalUnits = m_encodeCtx->indexNALUnit;
364 encodeParams.pSeiData = m_encodeCtx->pSEIFromApp;
365 encodeParams.pSeiParamBuffer = m_encodeCtx->pSEIFromApp->pSEIBuffer;
366 encodeParams.dwSEIDataOffset = 0;
367
368 // whether driver need to pack slice header
369 if (m_encodeCtx->bHavePackedSliceHdr)
370 {
371 encodeParams.bAcceleratorHeaderPackingCaps = false;
372 }
373 else
374 {
375 encodeParams.bAcceleratorHeaderPackingCaps = true;
376 }
377
378 encodeParams.pBSBuffer = m_encodeCtx->pbsBuffer;
379 encodeParams.pSlcHeaderData = (void *)m_encodeCtx->pSliceHeaderData;
380
381 MOS_STATUS status = m_encodeCtx->pCodecHal->Execute(&encodeParams);
382 if (MOS_STATUS_SUCCESS != status)
383 {
384 DDI_CODEC_ASSERTMESSAGE("DDI:Failed in Codechal!");
385 return VA_STATUS_ERROR_ENCODING_ERROR;
386 }
387
388 return VA_STATUS_SUCCESS;
389 }
390
391 VAStatus DdiEncodeHevc::ResetAtFrameLevel()
392 {
393 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
394
395 // Assume there is only one SPS parameter
396 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams = (PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS)(m_encodeCtx->pSeqParams);
397 hevcSeqParams->bResetBRC = 0x0;
398
399 m_encodeCtx->dwNumSlices = 0x0;
400 m_encodeCtx->indexNALUnit = 0x0;
401 m_encodeCtx->uiSliceHeaderCnt = 0x0;
402
403 // reset bsbuffer every frame
404 m_encodeCtx->pbsBuffer->pCurrent = m_encodeCtx->pbsBuffer->pBase;
405 m_encodeCtx->pbsBuffer->SliceOffset = 0x0;
406 m_encodeCtx->pbsBuffer->BitOffset = 0x0;
407 m_encodeCtx->pbsBuffer->BitSize = 0x0;
408
409 // clear the packed header information
410 if (nullptr != m_encodeCtx->ppNALUnitParams)
411 {
412 MOS_ZeroMemory(m_encodeCtx->ppNALUnitParams[0], sizeof(CODECHAL_NAL_UNIT_PARAMS) * HEVC_MAX_NAL_UNIT_TYPE);
413 }
414
415 m_encodeCtx->bHavePackedSliceHdr = false;
416 m_encodeCtx->bLastPackedHdrIsSlice = false;
417 m_encodeCtx->bMBQpEnable = false;
418
419 return VA_STATUS_SUCCESS;
420 }
421
422 VAStatus DdiEncodeHevc::ParseSeqParams(void *ptr)
423 {
424 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
425 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER);
426
427 VAEncSequenceParameterBufferHEVC *seqParams = (VAEncSequenceParameterBufferHEVC *)ptr;
428
429 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams = (PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS)((uint8_t *)m_encodeCtx->pSeqParams);
430 DDI_CODEC_CHK_NULL(hevcSeqParams, "nullptr hevcSeqParams", VA_STATUS_ERROR_INVALID_PARAMETER);
431 //MOS_ZeroMemory(hevcSeqParams, sizeof(CODEC_HEVC_ENCODE_SEQUENCE_PARAMS));
432
433 uint8_t log2MinCUSize = seqParams->log2_min_luma_coding_block_size_minus3 + 3;
434
435 hevcSeqParams->wFrameWidthInMinCbMinus1 = (seqParams->pic_width_in_luma_samples >> log2MinCUSize) - 1;
436 hevcSeqParams->wFrameHeightInMinCbMinus1 = (seqParams->pic_height_in_luma_samples >> log2MinCUSize) - 1;
437 hevcSeqParams->general_profile_idc = seqParams->general_profile_idc;
438 hevcSeqParams->Level = seqParams->general_level_idc / 3; // App sends (30*level), we track as (10*level)
439 hevcSeqParams->general_tier_flag = seqParams->general_tier_flag;
440 hevcSeqParams->GopPicSize = seqParams->intra_period;
441 hevcSeqParams->GopRefDist = seqParams->ip_period;
442 hevcSeqParams->chroma_format_idc = seqParams->seq_fields.bits.chroma_format_idc;
443
444 hevcSeqParams->RateControlMethod = VARC2HalRC(m_encodeCtx->uiRCMethod);
445
446 hevcSeqParams->TargetBitRate = MOS_ROUNDUP_DIVIDE(seqParams->bits_per_second, CODECHAL_ENCODE_BRC_KBPS);
447 hevcSeqParams->MaxBitRate = MOS_ROUNDUP_DIVIDE(seqParams->bits_per_second, CODECHAL_ENCODE_BRC_KBPS);
448 hevcSeqParams->MinBitRate = MOS_ROUNDUP_DIVIDE(seqParams->bits_per_second, CODECHAL_ENCODE_BRC_KBPS);
449 // if didn't setting FrameRate, set to 30 by default, can be overwritten by misc paramter
450 if (!hevcSeqParams->FrameRate.Numerator) {
451 hevcSeqParams->FrameRate.Numerator = 3000;
452 hevcSeqParams->FrameRate.Denominator = 100;
453 }
454
455 // set default same as application, can be overwritten by HRD params
456 hevcSeqParams->InitVBVBufferFullnessInBit = (uint32_t)seqParams->bits_per_second;
457 hevcSeqParams->VBVBufferSizeInBit = (uint32_t)seqParams->bits_per_second << 1;
458
459 hevcSeqParams->scaling_list_enable_flag = seqParams->seq_fields.bits.scaling_list_enabled_flag;
460 hevcSeqParams->sps_temporal_mvp_enable_flag = seqParams->seq_fields.bits.sps_temporal_mvp_enabled_flag;
461 hevcSeqParams->strong_intra_smoothing_enable_flag = seqParams->seq_fields.bits.strong_intra_smoothing_enabled_flag;
462 hevcSeqParams->amp_enabled_flag = seqParams->seq_fields.bits.amp_enabled_flag;
463 hevcSeqParams->SAO_enabled_flag = seqParams->seq_fields.bits.sample_adaptive_offset_enabled_flag;
464 hevcSeqParams->pcm_enabled_flag = seqParams->seq_fields.bits.pcm_enabled_flag;
465 hevcSeqParams->pcm_loop_filter_disable_flag = seqParams->seq_fields.bits.pcm_loop_filter_disabled_flag;
466 hevcSeqParams->LowDelayMode = seqParams->seq_fields.bits.low_delay_seq;
467 hevcSeqParams->HierarchicalFlag = seqParams->seq_fields.bits.hierachical_flag;
468
469 hevcSeqParams->log2_max_coding_block_size_minus3 = seqParams->log2_diff_max_min_luma_coding_block_size +
470 seqParams->log2_min_luma_coding_block_size_minus3;
471 hevcSeqParams->log2_min_coding_block_size_minus3 = seqParams->log2_min_luma_coding_block_size_minus3;
472 hevcSeqParams->log2_max_transform_block_size_minus2 = seqParams->log2_diff_max_min_transform_block_size +
473 seqParams->log2_min_transform_block_size_minus2;
474 hevcSeqParams->log2_min_transform_block_size_minus2 = seqParams->log2_min_transform_block_size_minus2;
475 hevcSeqParams->max_transform_hierarchy_depth_intra = seqParams->max_transform_hierarchy_depth_intra;
476 hevcSeqParams->max_transform_hierarchy_depth_inter = seqParams->max_transform_hierarchy_depth_inter;
477 hevcSeqParams->log2_min_PCM_cb_size_minus3 = seqParams->log2_min_pcm_luma_coding_block_size_minus3;
478 hevcSeqParams->log2_max_PCM_cb_size_minus3 = seqParams->log2_max_pcm_luma_coding_block_size_minus3;
479 hevcSeqParams->bit_depth_luma_minus8 = seqParams->seq_fields.bits.bit_depth_luma_minus8;
480 hevcSeqParams->bit_depth_chroma_minus8 = seqParams->seq_fields.bits.bit_depth_chroma_minus8;
481
482 if (m_codechalSettings->isSCCEnabled)
483 {
484 hevcSeqParams->palette_mode_enabled_flag = seqParams->scc_fields.bits.palette_mode_enabled_flag;
485 hevcSeqParams->motion_vector_resolution_control_idc = 0;
486 }
487
488 return VA_STATUS_SUCCESS;
489 }
490
491 VAStatus DdiEncodeHevc::ParsePicParams(
492 DDI_MEDIA_CONTEXT *mediaCtx,
493 void *ptr)
494 {
495 DDI_CODEC_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
496 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER);
497 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
498
499 VAEncPictureParameterBufferHEVC *picParams = (VAEncPictureParameterBufferHEVC *)ptr;
500
501 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams = (PCODEC_HEVC_ENCODE_PICTURE_PARAMS)((uint8_t *)m_encodeCtx->pPicParams);
502 DDI_CODEC_CHK_NULL(hevcPicParams, "nullptr hevcPicParams", VA_STATUS_ERROR_INVALID_PARAMETER);
503 MOS_ZeroMemory(hevcPicParams, sizeof(CODEC_HEVC_ENCODE_PICTURE_PARAMS));
504
505 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS hevcSeqParams = (PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS)((uint8_t *)m_encodeCtx->pSeqParams);
506
507 DDI_MEDIA_SURFACE *surface;
508 if(picParams->decoded_curr_pic.picture_id != VA_INVALID_SURFACE)
509 {
510 surface = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParams->decoded_curr_pic.picture_id);
511
512 if(m_encodeCtx->vaProfile == VAProfileHEVCMain444
513 || m_encodeCtx->vaProfile == VAProfileHEVCMain444_10
514 || m_encodeCtx->vaProfile == VAProfileHEVCMain444_12
515 || m_encodeCtx->vaProfile == VAProfileHEVCMain422_10
516 || m_encodeCtx->vaProfile == VAProfileHEVCMain422_12
517 || m_encodeCtx->vaProfile == VAProfileHEVCMain10
518 || m_encodeCtx->vaProfile == VAProfileHEVCMain12
519 || m_encodeCtx->vaProfile == VAProfileHEVCSccMain10
520 || m_encodeCtx->vaProfile == VAProfileHEVCSccMain444
521 || m_encodeCtx->vaProfile == VAProfileHEVCSccMain444_10)
522 {
523 surface = MediaLibvaCommonNext::ReplaceSurfaceWithVariant(surface, m_encodeCtx->vaEntrypoint);
524 }
525 DDI_CODEC_CHK_RET(RegisterRTSurfaces(&(m_encodeCtx->RTtbl),surface), "RegisterRTSurfaces failed!");
526 }
527
528 // Curr Recon Pic
529 SetupCodecPicture(
530 mediaCtx,
531 &(m_encodeCtx->RTtbl),
532 &hevcPicParams->CurrReconstructedPic,
533 picParams->decoded_curr_pic,
534 false,
535 false);
536
537 DDI_CODEC_RENDER_TARGET_TABLE *rtTbl = &(m_encodeCtx->RTtbl);
538 rtTbl->pCurrentReconTarget = MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParams->decoded_curr_pic.picture_id);
539 // The surface for reconstructed frame is not registered, return error to app
540 if (nullptr == rtTbl->pCurrentReconTarget)
541 {
542 DDI_CODEC_ASSERTMESSAGE("invalid surface for reconstructed frame");
543 return VA_STATUS_ERROR_INVALID_PARAMETER;
544 }
545
546 // curr orig pic
547 hevcPicParams->CurrOriginalPic.FrameIdx = (uint8_t)GetRenderTargetID(rtTbl, rtTbl->pCurrentReconTarget);
548 hevcPicParams->CurrOriginalPic.PicFlags = hevcPicParams->CurrReconstructedPic.PicFlags;
549 hevcPicParams->CurrOriginalPic.PicEntry = hevcPicParams->CurrReconstructedPic.PicEntry;
550 hevcPicParams->CollocatedRefPicIndex = picParams->collocated_ref_pic_index;
551
552 // RefFrame List
553 for (uint32_t i = 0; i < numMaxRefFrame; i++)
554 {
555 if(picParams->reference_frames[i].picture_id != VA_INVALID_SURFACE)
556 {
557 DDI_CODEC_CHK_RET(UpdateRegisteredRTSurfaceFlag(&(m_encodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParams->reference_frames[i].picture_id)), "RegisterRTSurfaces failed!");
558 }
559 SetupCodecPicture(
560 mediaCtx,
561 &(m_encodeCtx->RTtbl),
562 &(hevcPicParams->RefFrameList[i]),
563 picParams->reference_frames[i],
564 true,
565 false);
566
567 hevcPicParams->RefFramePOCList[i] = picParams->reference_frames[i].pic_order_cnt;
568 }
569
570 hevcPicParams->CurrPicOrderCnt = picParams->decoded_curr_pic.pic_order_cnt;
571
572 /* picParams->coding_type; App is always setting this to 0 */
573 hevcPicParams->CodingType = picParams->pic_fields.bits.coding_type;
574
575 /* CodingType may be updated in slice processing. Do below to save pyramid level info */
576 hevcPicParams->ppsCodingType = picParams->pic_fields.bits.coding_type;
577
578 hevcPicParams->HierarchLevelPlus1 = picParams->hierarchical_level_plus1;
579
580 /* Reset it to zero now */
581 hevcPicParams->NumSlices = 0;
582
583 hevcPicParams->sign_data_hiding_flag = picParams->pic_fields.bits.sign_data_hiding_enabled_flag;
584 hevcPicParams->constrained_intra_pred_flag = picParams->pic_fields.bits.constrained_intra_pred_flag;
585 hevcPicParams->transform_skip_enabled_flag = picParams->pic_fields.bits.transform_skip_enabled_flag;
586 hevcPicParams->transquant_bypass_enabled_flag = picParams->pic_fields.bits.transquant_bypass_enabled_flag;
587 hevcPicParams->tiles_enabled_flag = picParams->pic_fields.bits.tiles_enabled_flag;
588 hevcPicParams->cu_qp_delta_enabled_flag = picParams->pic_fields.bits.cu_qp_delta_enabled_flag;
589 hevcPicParams->weighted_pred_flag = picParams->pic_fields.bits.weighted_pred_flag;
590 hevcPicParams->weighted_bipred_flag = picParams->pic_fields.bits.weighted_bipred_flag;
591 hevcPicParams->loop_filter_across_slices_flag = picParams->pic_fields.bits.pps_loop_filter_across_slices_enabled_flag;
592 hevcPicParams->loop_filter_across_tiles_flag = picParams->pic_fields.bits.loop_filter_across_tiles_enabled_flag;
593 hevcPicParams->scaling_list_data_present_flag = picParams->pic_fields.bits.scaling_list_data_present_flag;
594 hevcPicParams->bLastPicInSeq = (picParams->last_picture & HEVC_LAST_PICTURE_EOSEQ) ? 1 : 0;
595 hevcPicParams->bLastPicInStream = (picParams->last_picture & HEVC_LAST_PICTURE_EOSTREAM) ? 1 : 0;
596 hevcPicParams->bUseRawPicForRef = false;
597 hevcPicParams->bScreenContent = picParams->pic_fields.bits.screen_content_flag;
598 hevcPicParams->bEmulationByteInsertion = true;
599
600 hevcPicParams->QpY = picParams->pic_init_qp;
601 hevcPicParams->diff_cu_qp_delta_depth = picParams->diff_cu_qp_delta_depth;
602 hevcPicParams->pps_cb_qp_offset = picParams->pps_cb_qp_offset;
603 hevcPicParams->pps_cr_qp_offset = picParams->pps_cr_qp_offset;
604 hevcPicParams->num_tile_columns_minus1 = picParams->num_tile_columns_minus1;
605 hevcPicParams->num_tile_rows_minus1 = picParams->num_tile_rows_minus1;
606 hevcPicParams->log2_parallel_merge_level_minus2 = picParams->log2_parallel_merge_level_minus2;
607 hevcPicParams->LcuMaxBitsizeAllowed = picParams->ctu_max_bitsize_allowed;
608 hevcPicParams->bUsedAsRef = picParams->pic_fields.bits.reference_pic_flag;
609 hevcPicParams->slice_pic_parameter_set_id = picParams->slice_pic_parameter_set_id;
610 hevcPicParams->nal_unit_type = picParams->nal_unit_type;
611 hevcPicParams->no_output_of_prior_pics_flag = picParams->pic_fields.bits.no_output_of_prior_pics_flag;
612 #if VA_CHECK_VERSION(1, 10, 0)
613 hevcPicParams->bEnableGPUWeightedPrediction = picParams->pic_fields.bits.enable_gpu_weighted_prediction;
614 #endif
615 hevcPicParams->bDisplayFormatSwizzle = NeedDisapayFormatSwizzle(rtTbl->pCurrentRT, rtTbl->pCurrentReconTarget);
616
617 // Correct Input color space of Sequence parameter here
618 hevcSeqParams->InputColorSpace = hevcPicParams->bDisplayFormatSwizzle ? ECOLORSPACE_P601 : ECOLORSPACE_P709;
619
620 if (hevcPicParams->tiles_enabled_flag)
621 {
622 uint16_t shift = hevcSeqParams->log2_max_coding_block_size_minus3 -
623 hevcSeqParams->log2_min_coding_block_size_minus3;
624 uint16_t frameWidthAligedInLCU = MOS_ROUNDUP_SHIFT((hevcSeqParams->wFrameWidthInMinCbMinus1 + 1), shift);
625 uint16_t frameHeightAligedInLCU = MOS_ROUNDUP_SHIFT((hevcSeqParams->wFrameHeightInMinCbMinus1 + 1), shift);
626
627 if(hevcPicParams->num_tile_columns_minus1 > CODECHAL_GET_ARRAY_LENGTH(picParams->column_width_minus1) ||
628 hevcPicParams->num_tile_rows_minus1 > CODECHAL_GET_ARRAY_LENGTH(picParams->row_height_minus1))
629 {
630 // app passed wrong parameters
631 DDI_CODEC_ASSERTMESSAGE("invalid tile parameters!");
632 return VA_STATUS_ERROR_INVALID_PARAMETER;
633 }
634
635 for(uint32_t i = 0; i < (uint32_t)(hevcPicParams->num_tile_columns_minus1); i++)
636 {
637 hevcPicParams->tile_column_width[i] = picParams->column_width_minus1[i] + 1;
638 frameWidthAligedInLCU -= hevcPicParams->tile_column_width[i];
639 }
640
641 if(frameWidthAligedInLCU > 0)
642 {
643 hevcPicParams->tile_column_width[hevcPicParams->num_tile_columns_minus1] = frameWidthAligedInLCU;
644 }
645 else
646 {
647 // app passed wrong parameters
648 DDI_CODEC_ASSERTMESSAGE("invalid tile parameters!");
649 return VA_STATUS_ERROR_INVALID_PARAMETER;
650 }
651
652 for(uint32_t i = 0; i < (uint32_t)(hevcPicParams->num_tile_rows_minus1); i++)
653 {
654 hevcPicParams->tile_row_height[i] = picParams->row_height_minus1[i] + 1;
655 frameHeightAligedInLCU -= hevcPicParams->tile_row_height[i];
656 }
657
658 if(frameHeightAligedInLCU > 0)
659 {
660 hevcPicParams->tile_row_height[hevcPicParams->num_tile_rows_minus1] = frameHeightAligedInLCU;
661 }
662 else
663 {
664 // app passed wrong parameters
665 DDI_CODEC_ASSERTMESSAGE("invalid tile parameters!");
666 return VA_STATUS_ERROR_INVALID_PARAMETER;
667 }
668 }
669
670 if (m_codechalSettings->isSCCEnabled)
671 {
672 // SCC
673 hevcPicParams->pps_curr_pic_ref_enabled_flag = picParams->scc_fields.bits.pps_curr_pic_ref_enabled_flag;
674 hevcPicParams->residual_adaptive_colour_transform_enabled_flag = 0;
675 hevcPicParams->pps_slice_act_qp_offsets_present_flag = 0;
676 // GEN12 HW only can support the initial palette size 0
677 hevcPicParams->PredictorPaletteSize = 0;
678 }
679
680 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, picParams->coded_buf);
681 if (nullptr == buf)
682 {
683 return VA_STATUS_ERROR_INVALID_PARAMETER;
684 }
685
686 //Application may re-use the buffer so need to remove before adding to status report again
687 RemoveFromStatusReportQueue(buf);
688 MediaLibvaCommonNext::MediaBufferToMosResource(buf, &(m_encodeCtx->resBitstreamBuffer));
689
690 return VA_STATUS_SUCCESS;
691 }
692
693 VAStatus DdiEncodeHevc::ParseSlcParams(
694 DDI_MEDIA_CONTEXT *mediaCtx,
695 void *ptr,
696 uint32_t numSlices)
697 {
698 DDI_CODEC_CHK_NULL(mediaCtx, "nullptr mediaCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
699 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
700 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER);
701
702 VAEncSliceParameterBufferHEVC *vaEncSlcParamsHEVC = (VAEncSliceParameterBufferHEVC *)ptr;
703
704 PCODEC_HEVC_ENCODE_SLICE_PARAMS hevcSlcParams = (PCODEC_HEVC_ENCODE_SLICE_PARAMS)m_encodeCtx->pSliceParams;
705 DDI_CODEC_CHK_NULL(hevcSlcParams, "nullptr hevcSlcParams", VA_STATUS_ERROR_INVALID_PARAMETER);
706
707 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams = (PCODEC_HEVC_ENCODE_PICTURE_PARAMS)(m_encodeCtx->pPicParams);
708 DDI_CODEC_CHK_NULL(hevcPicParams, "nullptr hevcPicParams", VA_STATUS_ERROR_INVALID_PARAMETER);
709
710 hevcPicParams->CodingType = CodechalPicTypeFromVaSlcType(vaEncSlcParamsHEVC->slice_type);
711
712 if (vaEncSlcParamsHEVC->slice_segment_address == 0)
713 {
714 hevcPicParams->NumSlices = 0;
715 }
716 else
717 {
718 hevcSlcParams += hevcPicParams->NumSlices;
719 }
720
721 MOS_ZeroMemory(
722 hevcSlcParams,
723 numSlices * sizeof(CODEC_HEVC_ENCODE_SLICE_PARAMS));
724
725 for (uint32_t slcCount = 0; slcCount < numSlices; slcCount++, hevcSlcParams++)
726 {
727 hevcSlcParams->slice_segment_address = vaEncSlcParamsHEVC->slice_segment_address;
728 hevcSlcParams->NumLCUsInSlice = vaEncSlcParamsHEVC->num_ctu_in_slice;
729
730 hevcSlcParams->num_ref_idx_l0_active_minus1 = vaEncSlcParamsHEVC->num_ref_idx_l0_active_minus1;
731 hevcSlcParams->num_ref_idx_l1_active_minus1 = vaEncSlcParamsHEVC->num_ref_idx_l1_active_minus1;
732 hevcSlcParams->bLastSliceOfPic = vaEncSlcParamsHEVC->slice_fields.bits.last_slice_of_pic_flag;
733 hevcSlcParams->dependent_slice_segment_flag = vaEncSlcParamsHEVC->slice_fields.bits.dependent_slice_segment_flag;
734 hevcSlcParams->slice_temporal_mvp_enable_flag = vaEncSlcParamsHEVC->slice_fields.bits.slice_temporal_mvp_enabled_flag;
735 hevcSlcParams->slice_type = vaEncSlcParamsHEVC->slice_type;
736 hevcSlcParams->slice_sao_luma_flag = vaEncSlcParamsHEVC->slice_fields.bits.slice_sao_luma_flag;
737 hevcSlcParams->slice_sao_chroma_flag = vaEncSlcParamsHEVC->slice_fields.bits.slice_sao_chroma_flag;
738 hevcSlcParams->mvd_l1_zero_flag = vaEncSlcParamsHEVC->slice_fields.bits.mvd_l1_zero_flag;
739 hevcSlcParams->cabac_init_flag = vaEncSlcParamsHEVC->slice_fields.bits.cabac_init_flag;
740 hevcSlcParams->slice_deblocking_filter_disable_flag = vaEncSlcParamsHEVC->slice_fields.bits.slice_deblocking_filter_disabled_flag;
741 hevcSlcParams->collocated_from_l0_flag = vaEncSlcParamsHEVC->slice_fields.bits.collocated_from_l0_flag;
742
743 hevcSlcParams->slice_qp_delta = vaEncSlcParamsHEVC->slice_qp_delta;
744 hevcSlcParams->slice_cb_qp_offset = vaEncSlcParamsHEVC->slice_cb_qp_offset;
745 hevcSlcParams->slice_cr_qp_offset = vaEncSlcParamsHEVC->slice_cr_qp_offset;
746 hevcSlcParams->beta_offset_div2 = vaEncSlcParamsHEVC->slice_beta_offset_div2;
747 hevcSlcParams->tc_offset_div2 = vaEncSlcParamsHEVC->slice_tc_offset_div2;
748 hevcSlcParams->MaxNumMergeCand = vaEncSlcParamsHEVC->max_num_merge_cand;
749 hevcSlcParams->luma_log2_weight_denom = vaEncSlcParamsHEVC->luma_log2_weight_denom;
750 hevcSlcParams->delta_chroma_log2_weight_denom = vaEncSlcParamsHEVC->delta_chroma_log2_weight_denom;
751 #if VA_CHECK_VERSION(1, 10, 0)
752 hevcSlcParams->PredWeightTableBitOffset = vaEncSlcParamsHEVC->pred_weight_table_bit_offset;
753 hevcSlcParams->PredWeightTableBitLength = vaEncSlcParamsHEVC->pred_weight_table_bit_length;
754 #endif
755 hevcSlcParams->slice_id = hevcPicParams->NumSlices + slcCount;
756 hevcSlcParams->BitLengthSliceHeaderStartingPortion = 40;
757
758 hevcSlcParams->bLastSliceOfPic = (slcCount == numSlices - 1) ? 1 : 0;
759 // If either stored slice count or current count in this buffer are non-zero, then verify
760 // that previous slice is not marked as last slice (it will be marked as last if it was last
761 // slice in previous buffer, which is not necessarily last slice in picture).
762 if (slcCount || hevcPicParams->NumSlices)
763 {
764 hevcSlcParams--;
765 hevcSlcParams->bLastSliceOfPic = false;
766 hevcSlcParams++;
767 }
768
769 for (uint32_t i = 0; i < numMaxRefFrame; i++)
770 {
771 // list 0
772 hevcSlcParams->luma_offset[0][i] = vaEncSlcParamsHEVC->luma_offset_l0[i];
773 hevcSlcParams->delta_luma_weight[0][i] = vaEncSlcParamsHEVC->delta_luma_weight_l0[i];
774
775 hevcSlcParams->chroma_offset[0][i][0] = MOS_CLAMP_MIN_MAX(vaEncSlcParamsHEVC->chroma_offset_l0[i][0], minChromaOffset, maxChromaOffset);
776 hevcSlcParams->delta_chroma_weight[0][i][0] = vaEncSlcParamsHEVC->delta_chroma_weight_l0[i][0];
777
778 hevcSlcParams->chroma_offset[0][i][1] = MOS_CLAMP_MIN_MAX(vaEncSlcParamsHEVC->chroma_offset_l0[i][1], minChromaOffset, maxChromaOffset);
779 hevcSlcParams->delta_chroma_weight[0][i][1] = vaEncSlcParamsHEVC->delta_chroma_weight_l0[i][1];
780
781 // list 1
782 hevcSlcParams->luma_offset[1][i] = vaEncSlcParamsHEVC->luma_offset_l1[i];
783 hevcSlcParams->delta_luma_weight[1][i] = vaEncSlcParamsHEVC->delta_luma_weight_l1[i];
784
785 hevcSlcParams->chroma_offset[1][i][0] = MOS_CLAMP_MIN_MAX(vaEncSlcParamsHEVC->chroma_offset_l1[i][0], minChromaOffset, maxChromaOffset);
786 hevcSlcParams->delta_chroma_weight[1][i][0] = vaEncSlcParamsHEVC->delta_chroma_weight_l1[i][0];
787
788 hevcSlcParams->chroma_offset[1][i][1] = MOS_CLAMP_MIN_MAX(vaEncSlcParamsHEVC->chroma_offset_l1[i][1], minChromaOffset, maxChromaOffset);
789 hevcSlcParams->delta_chroma_weight[1][i][1] = vaEncSlcParamsHEVC->delta_chroma_weight_l1[i][1];
790 }
791 for (uint32_t i = 0; i < numMaxRefFrame; i++)
792 {
793 if(i > hevcSlcParams->num_ref_idx_l0_active_minus1)
794 {
795 hevcSlcParams->RefPicList[0][i].FrameIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC;
796 hevcSlcParams->RefPicList[0][i].PicFlags = PICTURE_INVALID;
797 hevcSlcParams->RefPicList[0][i].PicEntry = 0xFF;
798 }
799 else
800 {
801 SetupCodecPicture(
802 mediaCtx,
803 &(m_encodeCtx->RTtbl),
804 &(hevcSlcParams->RefPicList[0][i]),
805 vaEncSlcParamsHEVC->ref_pic_list0[i],
806 false,
807 true);
808 GetSlcRefIdx(&(hevcPicParams->RefFrameList[0]), &(hevcSlcParams->RefPicList[0][i]));
809 }
810 }
811
812 for (uint32_t i = 0; i < numMaxRefFrame; i++)
813 {
814 if(i > hevcSlcParams->num_ref_idx_l1_active_minus1)
815 {
816 hevcSlcParams->RefPicList[1][i].FrameIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC;
817 hevcSlcParams->RefPicList[1][i].PicFlags = PICTURE_INVALID;
818 hevcSlcParams->RefPicList[1][i].PicEntry = 0xFF;
819 }
820 else
821 {
822 SetupCodecPicture(
823 mediaCtx,
824 &(m_encodeCtx->RTtbl),
825 &(hevcSlcParams->RefPicList[1][i]),
826 vaEncSlcParamsHEVC->ref_pic_list1[i],
827 false,
828 true);
829 GetSlcRefIdx(&(hevcPicParams->RefFrameList[0]), &(hevcSlcParams->RefPicList[1][i]));
830 }
831 }
832
833 vaEncSlcParamsHEVC++;
834 }
835
836 hevcPicParams->NumSlices += numSlices;
837 m_encodeCtx->dwNumSlices = hevcPicParams->NumSlices;
838
839 return VA_STATUS_SUCCESS;
840 }
841
842 VAStatus DdiEncodeHevc::Qmatrix(void *ptr)
843 {
844 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
845 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER);
846
847 PCODECHAL_HEVC_IQ_MATRIX_PARAMS QmatrixParams = (PCODECHAL_HEVC_IQ_MATRIX_PARAMS)(m_encodeCtx->pQmatrixParams);
848 DDI_CODEC_CHK_NULL(QmatrixParams, "nullptr hevcPicParams", VA_STATUS_ERROR_INVALID_PARAMETER);
849
850 VAQMatrixBufferHEVC *vaQMatrixHEVC = (VAQMatrixBufferHEVC *)ptr;
851
852 for (uint8_t j = 0; j < 2; j++)
853 {
854 for (uint8_t i = 0; i < 3; i++)
855 {
856 MOS_SecureMemcpy((void *)&QmatrixParams->ucScalingLists0[3 * j + i][0], sizeof(QmatrixParams->ucScalingLists0[3 * j + i]),
857 (void *)&vaQMatrixHEVC->scaling_lists_4x4[i][j][0], sizeof(vaQMatrixHEVC->scaling_lists_4x4[i][j]));
858 MOS_SecureMemcpy((void *)&QmatrixParams->ucScalingLists1[3 * j + i][0], sizeof(QmatrixParams->ucScalingLists1[3 * j + i]),
859 (void *)&vaQMatrixHEVC->scaling_lists_8x8[i][j][0], sizeof(vaQMatrixHEVC->scaling_lists_8x8[i][j]));
860 MOS_SecureMemcpy((void *)&QmatrixParams->ucScalingLists2[3 * j + i][0], sizeof(QmatrixParams->ucScalingLists2[3 * j + i]),
861 (void *)&vaQMatrixHEVC->scaling_lists_16x16[i][j][0], sizeof(vaQMatrixHEVC->scaling_lists_16x16[i][j]));
862 QmatrixParams->ucScalingListDCCoefSizeID2[3 * j + i] = vaQMatrixHEVC->scaling_list_dc_16x16[i][j];
863 }
864 }
865
866 MOS_SecureMemcpy((void *)&QmatrixParams->ucScalingLists3[0][0], sizeof(QmatrixParams->ucScalingLists3),
867 (void *)&vaQMatrixHEVC->scaling_lists_32x32[0][0], sizeof(vaQMatrixHEVC->scaling_lists_32x32));
868 MOS_SecureMemcpy((void *)&QmatrixParams->ucScalingListDCCoefSizeID3[0], sizeof(QmatrixParams->ucScalingListDCCoefSizeID3),
869 (void *)&vaQMatrixHEVC->scaling_list_dc_32x32[0], sizeof(QmatrixParams->ucScalingListDCCoefSizeID3));
870
871 return VA_STATUS_SUCCESS;
872 }
873
874 VAStatus DdiEncodeHevc::FindNalUnitStartCodes(
875 uint8_t * buf,
876 uint32_t size,
877 uint32_t * startCodesOffset,
878 uint32_t * startCodesLength)
879 {
880 uint8_t i = 0;
881
882 while (((i + 3) < size) &&
883 (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01) &&
884 (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0 || buf[i+3] != 0x01))
885 {
886 i++;
887 }
888
889 if ((i + 3) == size)
890 {
891 if (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01)
892 {
893 return VA_STATUS_ERROR_INVALID_BUFFER; //NALU start codes doesn't exit
894 }
895 else
896 {
897 *startCodesOffset = size - 3;
898 *startCodesLength = 3;
899 return VA_STATUS_SUCCESS;
900 }
901 }
902
903 if (buf[i] != 0 || buf[i+1] != 0 || buf[i+2] != 0x01)
904 {
905 *startCodesOffset = i;
906 *startCodesLength = 4;
907 }
908 else
909 {
910 *startCodesOffset = i;
911 *startCodesLength = 3;
912 }
913
914 return VA_STATUS_SUCCESS;
915 }
916
917 VAStatus DdiEncodeHevc::ParsePackedHeaderParams(void *ptr)
918 {
919 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx.", VA_STATUS_ERROR_INVALID_PARAMETER);
920 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr.", VA_STATUS_ERROR_INVALID_PARAMETER);
921
922 VAEncPackedHeaderParameterBuffer *encPackedHeaderParamBuf = (VAEncPackedHeaderParameterBuffer *)ptr;
923 m_encodeCtx->bLastPackedHdrIsSlice = false;
924 if (encPackedHeaderParamBuf->type == VAEncPackedHeaderHEVC_Slice)
925 {
926 m_encodeCtx->bLastPackedHdrIsSlice = true;
927 m_encodeCtx->bHavePackedSliceHdr = true;
928
929 // Current minimum LCU size for HEVC is 16x16. Minimum 1 LCU per slice.
930 if (m_encodeCtx->uiSliceHeaderCnt >= m_encodeCtx->wPicHeightInMB * m_encodeCtx->wPicWidthInMB)
931 {
932 return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
933 }
934
935 // get the packed header size
936 m_encodeCtx->pSliceHeaderData[m_encodeCtx->uiSliceHeaderCnt].BitSize = encPackedHeaderParamBuf->bit_length;
937 // don't know NALU start codes now, assign to 4 here when has_emulation_bytes is 0 and later will correct it
938 m_encodeCtx->pSliceHeaderData[m_encodeCtx->uiSliceHeaderCnt].SkipEmulationByteCount = (encPackedHeaderParamBuf->has_emulation_bytes) ? (encPackedHeaderParamBuf->bit_length + 7) / 8 : 4;
939 }
940 else
941 {
942 /* App does not indicate the type, using PPS in general for headers */
943 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiNalUnitType = HEVC_NAL_UT_PPS;
944 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->bInsertEmulationBytes = (encPackedHeaderParamBuf->has_emulation_bytes) ? false : true;
945 // don't know NALU start codes now, assign to 4 here when has_emulation_bytes is 0 and later will correct it
946 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiSkipEmulationCheckCount = (encPackedHeaderParamBuf->has_emulation_bytes) ? (encPackedHeaderParamBuf->bit_length + 7) / 8 : 4;
947 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiSize = (encPackedHeaderParamBuf->bit_length + 7) / 8;
948 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiOffset = 0;
949 }
950
951 return VA_STATUS_SUCCESS;
952 }
953
954 VAStatus DdiEncodeHevc::ParsePackedHeaderData(void *ptr)
955 {
956 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx.", VA_STATUS_ERROR_INVALID_PARAMETER);
957 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr.", VA_STATUS_ERROR_INVALID_PARAMETER);
958
959 BSBuffer *bsBuffer = m_encodeCtx->pbsBuffer;
960 DDI_CODEC_CHK_NULL(bsBuffer, "nullptr bsBuffer.", VA_STATUS_ERROR_INVALID_PARAMETER);
961
962 if (m_encodeCtx->indexNALUnit == 0 && m_encodeCtx->uiSliceHeaderCnt == 0)
963 {
964 bsBuffer->pCurrent = bsBuffer->pBase;
965 bsBuffer->SliceOffset = 0;
966 bsBuffer->BitOffset = 0;
967 bsBuffer->BitSize = 0;
968 }
969
970 uint32_t hdrDataSize = 0;
971 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
972 if (true == m_encodeCtx->bLastPackedHdrIsSlice)
973 {
974 hdrDataSize = (m_encodeCtx->pSliceHeaderData[m_encodeCtx->uiSliceHeaderCnt].BitSize + 7) / 8;
975
976 eStatus = MOS_SecureMemcpy(bsBuffer->pCurrent, bsBuffer->BufferSize - bsBuffer->SliceOffset, (uint8_t *)ptr, hdrDataSize);
977 if (MOS_STATUS_SUCCESS != eStatus)
978 {
979 DDI_CODEC_ASSERTMESSAGE("DDI:packed slice header size is too large to be supported!");
980 return VA_STATUS_ERROR_INVALID_PARAMETER;
981 }
982
983 m_encodeCtx->pSliceHeaderData[m_encodeCtx->uiSliceHeaderCnt].SliceOffset = bsBuffer->pCurrent - bsBuffer->pBase;
984
985 // correct SkipEmulationByteCount
986 // according to LibVA principle, one packed header buffer should only contain one NALU,
987 // so when has_emulation_bytes is 0, SkipEmulationByteCount only needs to skip the NALU start codes
988 if (m_encodeCtx->pSliceHeaderData[m_encodeCtx->uiSliceHeaderCnt].SkipEmulationByteCount != hdrDataSize)
989 {
990 uint32_t startCodesOffset = 0;
991 uint32_t startCodesLength = 0;
992 VAStatus vaSts = VA_STATUS_SUCCESS;
993 vaSts = FindNalUnitStartCodes((uint8_t *)ptr, hdrDataSize, &startCodesOffset, &startCodesLength);
994 if (VA_STATUS_SUCCESS != vaSts)
995 {
996 DDI_CODEC_ASSERTMESSAGE("DDI: packed slice header doesn't include NAL unit start codes!");
997 return vaSts;
998 }
999 m_encodeCtx->pSliceHeaderData[m_encodeCtx->uiSliceHeaderCnt].SkipEmulationByteCount = MOS_MIN(15, (startCodesOffset + startCodesLength));
1000 }
1001
1002 m_encodeCtx->uiSliceHeaderCnt++;
1003 m_encodeCtx->bLastPackedHdrIsSlice = false;
1004 }
1005 else
1006 {
1007 // copy sps and pps header data
1008 hdrDataSize = m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiSize;
1009
1010 eStatus = MOS_SecureMemcpy(bsBuffer->pCurrent, bsBuffer->BufferSize - bsBuffer->SliceOffset, (uint8_t *)ptr, hdrDataSize);
1011 if (MOS_STATUS_SUCCESS != eStatus)
1012 {
1013 DDI_CODEC_ASSERTMESSAGE("DDI:packed header size is too large to be supported!");
1014 return VA_STATUS_ERROR_INVALID_PARAMETER;
1015 }
1016
1017 // correct uiSkipEmulationCheckCount
1018 // according to LibVA principle, one packed header buffer should only contain one NALU,
1019 // so when has_emulation_bytes is 0, uiSkipEmulationCheckCount only needs to skip the NALU start codes
1020 if (m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiSkipEmulationCheckCount != hdrDataSize)
1021 {
1022 uint32_t startCodesOffset = 0;
1023 uint32_t startCodesLength = 0;
1024 VAStatus vaSts = VA_STATUS_SUCCESS;
1025 vaSts = FindNalUnitStartCodes((uint8_t *)ptr, hdrDataSize, &startCodesOffset, &startCodesLength);
1026 if (VA_STATUS_SUCCESS != vaSts)
1027 {
1028 DDI_CODEC_ASSERTMESSAGE("DDI: packed header doesn't include NAL unit start codes!");
1029 return vaSts;
1030 }
1031 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiSkipEmulationCheckCount = MOS_MIN(15, (startCodesOffset + startCodesLength));
1032 }
1033
1034 m_encodeCtx->ppNALUnitParams[m_encodeCtx->indexNALUnit]->uiOffset = bsBuffer->pCurrent - bsBuffer->pBase;
1035 m_encodeCtx->indexNALUnit++;
1036 }
1037
1038 bsBuffer->pCurrent += hdrDataSize;
1039 bsBuffer->SliceOffset += hdrDataSize;
1040 bsBuffer->BitSize += hdrDataSize * 8;
1041
1042 return VA_STATUS_SUCCESS;
1043 }
1044
1045 VAStatus DdiEncodeHevc::ParseMiscParams(void *ptr)
1046 {
1047 DDI_CODEC_CHK_NULL(m_encodeCtx, "nullptr m_encodeCtx", VA_STATUS_ERROR_INVALID_PARAMETER);
1048 DDI_CODEC_CHK_NULL(ptr, "nullptr ptr", VA_STATUS_ERROR_INVALID_PARAMETER);
1049 DDI_CODEC_CHK_NULL(m_encodeCtx->pSeqParams, "nullptr m_encodeCtx->pSeqParams", VA_STATUS_ERROR_INVALID_PARAMETER);
1050 DDI_CODEC_CHK_NULL(m_encodeCtx->pPicParams, "nullptr m_encodeCtx->pPicParams", VA_STATUS_ERROR_INVALID_PARAMETER);
1051
1052 PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS seqParams = (PCODEC_HEVC_ENCODE_SEQUENCE_PARAMS)(m_encodeCtx->pSeqParams);
1053 PCODEC_HEVC_ENCODE_PICTURE_PARAMS picParams = (PCODEC_HEVC_ENCODE_PICTURE_PARAMS)(m_encodeCtx->pPicParams);
1054
1055 VAEncMiscParameterBuffer *miscParamBuf = (VAEncMiscParameterBuffer *)ptr;
1056 DDI_CODEC_CHK_NULL(miscParamBuf->data, "nullptr miscParamBuf->data", VA_STATUS_ERROR_INVALID_PARAMETER);
1057
1058 switch ((int32_t)(miscParamBuf->type))
1059 {
1060 case VAEncMiscParameterTypeQualityLevel:
1061 {
1062 VAEncMiscParameterBufferQualityLevel *vaEncMiscParamQualityLevel = (VAEncMiscParameterBufferQualityLevel *)miscParamBuf->data;
1063 m_encodeCtx->targetUsage = (uint8_t)vaEncMiscParamQualityLevel->quality_level;
1064 break;
1065 }
1066 case VAEncMiscParameterTypeHRD:
1067 {
1068 VAEncMiscParameterHRD *vaEncMiscParamHRD = (VAEncMiscParameterHRD *)miscParamBuf->data;
1069 seqParams->VBVBufferSizeInBit = vaEncMiscParamHRD->buffer_size;
1070 seqParams->InitVBVBufferFullnessInBit = vaEncMiscParamHRD->initial_buffer_fullness;
1071 break;
1072 }
1073 case VAEncMiscParameterTypeFrameRate:
1074 {
1075 VAEncMiscParameterFrameRate *vaEncMiscParamFR = (VAEncMiscParameterFrameRate *)miscParamBuf->data;
1076 uint32_t vaFRnumerator = vaEncMiscParamFR->framerate & 0xffff;
1077
1078 #if (VA_MAJOR_VERSION < 1)
1079 uint32_t vaFRDenominator = 100;
1080 #else
1081 uint32_t vaFRDenominator = (vaEncMiscParamFR->framerate >> 16) & 0xffff;
1082 #endif
1083
1084 if(vaFRDenominator == 0)
1085 {
1086 vaFRDenominator = 1;
1087 }
1088 // Pass frame rate value to seqParams and set BRC reset flag and bNewSeq to true while dynamic BRC occures
1089 seqParams->FrameRate.Numerator = vaFRnumerator;
1090 seqParams->FrameRate.Denominator = vaFRDenominator;
1091 if(m_previousFRvalue != 0)
1092 {
1093 uint16_t seqFRvalue = (uint16_t)(seqParams->FrameRate.Numerator / seqParams->FrameRate.Denominator);
1094 if(m_previousFRvalue != seqFRvalue)
1095 {
1096 seqParams->bResetBRC = 0x1;
1097 m_encodeCtx->bNewSeq = true;
1098 }
1099 }
1100 m_previousFRvalue = (uint16_t)(vaFRnumerator / vaFRDenominator);
1101 break;
1102 }
1103 case VAEncMiscParameterTypeRateControl:
1104 {
1105 // Assume only one SPS here, modify when enable multiple SPS support
1106 VAEncMiscParameterRateControl *vaEncMiscParamRC = (VAEncMiscParameterRateControl *)miscParamBuf->data;
1107
1108 if(vaEncMiscParamRC->bits_per_second > 0)
1109 {
1110 seqParams->TargetBitRate = MOS_ROUNDUP_DIVIDE(vaEncMiscParamRC->bits_per_second, CODECHAL_ENCODE_BRC_KBPS);
1111 }
1112 if (VA_RC_CQP != m_encodeCtx->uiRCMethod && (VA_RC_MB & m_encodeCtx->uiRCMethod) && vaEncMiscParamRC->rc_flags.bits.mb_rate_control <= mbBrcDisabled)
1113 {
1114 seqParams->MBBRC = vaEncMiscParamRC->rc_flags.bits.mb_rate_control;
1115 }
1116 else
1117 {
1118 seqParams->MBBRC = mbBrcDisabled;
1119 }
1120 //enable parallelBRC for Android and Linux
1121 seqParams->ParallelBRC = vaEncMiscParamRC->rc_flags.bits.enable_parallel_brc;
1122
1123 picParams->BRCMaxQp = (vaEncMiscParamRC->max_qp == 0) ? 51 : (uint8_t)CodecHal_Clip3(1, 51, (int8_t)vaEncMiscParamRC->max_qp);
1124 picParams->BRCMinQp = (vaEncMiscParamRC->min_qp == 0) ? 1 : (uint8_t)CodecHal_Clip3(1, picParams->BRCMaxQp, (int8_t)vaEncMiscParamRC->min_qp);
1125 #if VA_CHECK_VERSION(1, 10, 0)
1126 picParams->TargetFrameSize = vaEncMiscParamRC->target_frame_size;
1127 #endif
1128
1129 if (VA_RC_NONE == m_encodeCtx->uiRCMethod || VA_RC_CQP == m_encodeCtx->uiRCMethod)
1130 {
1131 seqParams->RateControlMethod = RATECONTROL_CQP;
1132 seqParams->MBBRC = 0;
1133 }
1134 else if (VA_RC_CBR & m_encodeCtx->uiRCMethod )
1135 {
1136 seqParams->MaxBitRate = seqParams->TargetBitRate;
1137 seqParams->MinBitRate = seqParams->TargetBitRate;
1138 seqParams->RateControlMethod = RATECONTROL_CBR;
1139 }
1140 else if (VA_RC_ICQ & m_encodeCtx->uiRCMethod)
1141 {
1142 seqParams->ICQQualityFactor = vaEncMiscParamRC->ICQ_quality_factor;
1143 seqParams->RateControlMethod = RATECONTROL_ICQ;
1144 }
1145 else if(VA_RC_VCM & m_encodeCtx->uiRCMethod)
1146 {
1147 seqParams->RateControlMethod = RATECONTROL_VCM;
1148 seqParams->MBBRC = 0;
1149 }
1150 else if(VA_RC_VBR & m_encodeCtx->uiRCMethod)
1151 {
1152 seqParams->RateControlMethod = RATECONTROL_VBR;
1153 }
1154 else if (VA_RC_QVBR & m_encodeCtx->uiRCMethod)
1155 {
1156 seqParams->RateControlMethod = RATECONTROL_QVBR;
1157 seqParams->ICQQualityFactor = vaEncMiscParamRC->quality_factor;
1158 }
1159 else
1160 {
1161 DDI_CODEC_ASSERTMESSAGE("invalid RC method.");
1162 return VA_STATUS_ERROR_INVALID_PARAMETER;
1163 }
1164 if((RATECONTROL_VCM == seqParams->RateControlMethod)
1165 || (RATECONTROL_VBR == seqParams->RateControlMethod)
1166 || (RATECONTROL_CBR == seqParams->RateControlMethod)
1167 || (RATECONTROL_QVBR == seqParams->RateControlMethod))
1168 {
1169 seqParams->MaxBitRate = seqParams->TargetBitRate;
1170 seqParams->MinBitRate = seqParams->TargetBitRate * (2 * vaEncMiscParamRC->target_percentage - 100) / 100;
1171 seqParams->TargetBitRate = seqParams->TargetBitRate * vaEncMiscParamRC->target_percentage / 100;
1172
1173 if ((m_encodeCtx->uiTargetBitRate != seqParams->TargetBitRate) ||
1174 (m_encodeCtx->uiMaxBitRate != seqParams->MaxBitRate))
1175 {
1176 if ((m_encodeCtx->uiTargetBitRate != 0) && (m_encodeCtx->uiMaxBitRate != 0))
1177 {
1178 seqParams->bResetBRC = 0x1;
1179 m_encodeCtx->bNewSeq = true;
1180 }
1181 m_encodeCtx->uiTargetBitRate = seqParams->TargetBitRate;
1182 m_encodeCtx->uiMaxBitRate = seqParams->MaxBitRate;
1183 }
1184 }
1185 #ifndef ANDROID
1186 seqParams->FrameSizeTolerance = static_cast<ENCODE_FRAMESIZE_TOLERANCE>(vaEncMiscParamRC->rc_flags.bits.frame_tolerance_mode);
1187 #endif
1188 break;
1189 }
1190 case VAEncMiscParameterTypeParallelBRC:
1191 {
1192 VAEncMiscParameterParallelRateControl *vaEncMiscParameterParallel = (VAEncMiscParameterParallelRateControl *)miscParamBuf->data;
1193
1194 seqParams->NumOfBInGop[0] = vaEncMiscParameterParallel->num_b_in_gop[0];
1195 seqParams->NumOfBInGop[1] = vaEncMiscParameterParallel->num_b_in_gop[1];
1196 seqParams->NumOfBInGop[2] = vaEncMiscParameterParallel->num_b_in_gop[2];
1197
1198 break;
1199 }
1200 case VAEncMiscParameterTypeRIR:
1201 {
1202 VAEncMiscParameterRIR *vaEncMiscParamRIR = (VAEncMiscParameterRIR *)miscParamBuf->data;
1203 picParams->bEnableRollingIntraRefresh = vaEncMiscParamRIR->rir_flags.value & 0x3; //only lower two bits are valid
1204
1205 // Set for all frames since pic type is not known yet. Disable in slice params if its I or B type.
1206 if ((ROLLING_I_COLUMN == picParams->bEnableRollingIntraRefresh) || (ROLLING_I_ROW == picParams->bEnableRollingIntraRefresh))
1207 {
1208 picParams->IntraInsertionLocation = (uint16_t)vaEncMiscParamRIR->intra_insertion_location;
1209 picParams->IntraInsertionSize = (uint8_t)vaEncMiscParamRIR->intra_insert_size;
1210 picParams->QpDeltaForInsertedIntra = vaEncMiscParamRIR->qp_delta_for_inserted_intra;
1211 }
1212 else if ((ROLLING_I_ROW | ROLLING_I_COLUMN) == picParams->bEnableRollingIntraRefresh) // cannot have row and column rolling
1213 {
1214 picParams->bEnableRollingIntraRefresh = ROLLING_I_DISABLED;
1215 return VA_STATUS_ERROR_INVALID_PARAMETER;
1216 }
1217
1218 break;
1219 }
1220 case VAEncMiscParameterTypeROI:
1221 {
1222 VAEncMiscParameterBufferROI *vaEncMiscParamROI = (VAEncMiscParameterBufferROI *)miscParamBuf->data;
1223 uint8_t blockSize = vdencRoiBlockSize;
1224
1225 uint32_t frameWidth = (seqParams->wFrameWidthInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3);
1226 uint32_t frameHeight = (seqParams->wFrameHeightInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3);
1227 uint16_t rightBorder = (uint16_t)CODECHAL_GET_WIDTH_IN_BLOCKS(frameWidth, blockSize) - 1;
1228 uint16_t bottomBorder = (uint16_t)CODECHAL_GET_HEIGHT_IN_BLOCKS(frameHeight, blockSize) - 1;
1229
1230 if(vaEncMiscParamROI->num_roi > CODECHAL_ENCODE_HEVC_MAX_NUM_ROI)
1231 {
1232 DDI_CODEC_ASSERTMESSAGE("The number of ROI rect is greater than %d", CODECHAL_ENCODE_HEVC_MAX_NUM_ROI);
1233 return VA_STATUS_ERROR_INVALID_PARAMETER;
1234 }
1235
1236 if (vaEncMiscParamROI->num_roi)
1237 {
1238 for (uint32_t i = 0; i < vaEncMiscParamROI->num_roi; ++i)
1239 {
1240 auto &pic_param_roi = picParams->ROI[i];
1241 auto &va_roi = vaEncMiscParamROI->roi[i];
1242
1243 pic_param_roi.Top = va_roi.roi_rectangle.y;
1244 pic_param_roi.Left = va_roi.roi_rectangle.x;
1245 pic_param_roi.Right = va_roi.roi_rectangle.x + va_roi.roi_rectangle.width - 1;
1246 pic_param_roi.Bottom = va_roi.roi_rectangle.y+va_roi.roi_rectangle.height - 1;
1247
1248 pic_param_roi.PriorityLevelOrDQp = va_roi.roi_value;
1249
1250 if( pic_param_roi.Left > pic_param_roi.Right){
1251 DDI_CODEC_ASSERTMESSAGE("ROI left > ROI Right.");
1252 return VA_STATUS_ERROR_INVALID_PARAMETER;
1253 }
1254
1255 // check frame boundary
1256 if( pic_param_roi.Top > pic_param_roi.Bottom){
1257 DDI_CODEC_ASSERTMESSAGE("ROI Top > ROI Bottom.");
1258 return VA_STATUS_ERROR_INVALID_PARAMETER;
1259 }
1260
1261 // Convert from pixel units to block size units
1262 pic_param_roi.Left /= blockSize;
1263 pic_param_roi.Right /= blockSize;
1264 pic_param_roi.Top /= blockSize;
1265 pic_param_roi.Bottom /= blockSize;
1266
1267 // check frame boundary
1268 pic_param_roi.Left = pic_param_roi.Left > rightBorder ? rightBorder : pic_param_roi.Left;
1269 pic_param_roi.Right = pic_param_roi.Right > rightBorder ? rightBorder : pic_param_roi.Right;
1270 pic_param_roi.Top = pic_param_roi.Top > bottomBorder ? bottomBorder : pic_param_roi.Top;
1271 pic_param_roi.Bottom = pic_param_roi.Bottom > bottomBorder ? bottomBorder : pic_param_roi.Bottom;
1272
1273 // DDI defination for right and bottom parameters is inclusive whereas
1274 // the defination in BRC kernel input is exclusive. So adding 1 to right & bottom.
1275 pic_param_roi.Right += 1;
1276 pic_param_roi.Bottom += 1;
1277
1278 }
1279 picParams->NumROI = vaEncMiscParamROI->num_roi;
1280 }
1281 #ifndef ANDROID
1282 // support DeltaQP based ROI by default
1283 seqParams->ROIValueInDeltaQP = vaEncMiscParamROI->roi_flags.bits.roi_value_is_qp_delta;
1284 if(picParams->NumROI != 0 && seqParams->ROIValueInDeltaQP == 0)
1285 {
1286 DDI_CODEC_ASSERTMESSAGE("ROI does not support priority level now.");
1287 return VA_STATUS_ERROR_INVALID_PARAMETER;
1288 }
1289 #endif
1290 break;
1291 }
1292 case VAEncMiscParameterTypeDirtyRect:
1293 {
1294 VAEncMiscParameterBufferDirtyRect *vaEncMiscDirtyRect = (VAEncMiscParameterBufferDirtyRect *)miscParamBuf->data;
1295
1296 uint8_t blockSize = vdencRoiBlockSize;
1297 uint32_t rightBorder = CODECHAL_GET_WIDTH_IN_BLOCKS(m_encodeCtx->dwFrameWidth, blockSize) - 1;
1298 uint32_t bottomBorder = CODECHAL_GET_HEIGHT_IN_BLOCKS(m_encodeCtx->dwFrameHeight, blockSize) - 1;
1299
1300 DDI_CODEC_CHK_NULL(vaEncMiscDirtyRect->roi_rectangle, "nullptr dirty rect", VA_STATUS_ERROR_INVALID_PARAMETER);
1301 if(vaEncMiscDirtyRect->num_roi_rectangle > ENCODE_VDENC_HEVC_MAX_DIRTYRECT_G10)
1302 {
1303 DDI_CODEC_ASSERTMESSAGE("The number of dirty rect is greater than %d", ENCODE_VDENC_HEVC_MAX_DIRTYRECT_G10);
1304 return VA_STATUS_ERROR_INVALID_PARAMETER;
1305 }
1306 picParams->pDirtyRect = m_pDirtyRect;
1307
1308 if (vaEncMiscDirtyRect->num_roi_rectangle > m_numDirtyRects)
1309 {
1310 picParams->pDirtyRect = (PCODEC_ROI)MOS_ReallocMemory(picParams->pDirtyRect, vaEncMiscDirtyRect->num_roi_rectangle * sizeof(CODEC_ROI));
1311 if (!picParams->pDirtyRect)
1312 {
1313 picParams->NumDirtyRects = 0;
1314 DDI_CODEC_ASSERTMESSAGE("Allocation of pDirtyRect failed!");
1315 return VA_STATUS_ERROR_ALLOCATION_FAILED;
1316 }
1317 m_pDirtyRect = picParams->pDirtyRect;
1318 m_numDirtyRects = vaEncMiscDirtyRect->num_roi_rectangle;
1319 }
1320
1321 if(vaEncMiscDirtyRect->num_roi_rectangle > 0)
1322 {
1323 MOS_ZeroMemory(picParams->pDirtyRect, vaEncMiscDirtyRect->num_roi_rectangle * sizeof(CODEC_ROI));
1324 picParams->NumDirtyRects = 0;
1325
1326 for (int32_t i = 0; i < vaEncMiscDirtyRect->num_roi_rectangle; i++)
1327 {
1328 auto &rect = picParams->pDirtyRect[i];
1329 auto &va_rect = vaEncMiscDirtyRect->roi_rectangle[i];
1330 rect.Left = va_rect.x;
1331 rect.Top = va_rect.y;
1332 rect.Right = va_rect.x + va_rect.width - 1;
1333 rect.Bottom = va_rect.y + va_rect.height - 1;
1334
1335 // Convert from pixel units to block units
1336 rect.Left /= blockSize;
1337 rect.Right /= blockSize;
1338 rect.Top /= blockSize;
1339 rect.Bottom /= blockSize;
1340
1341 // Check and adjust if rect not within frame boundaries
1342 rect.Left = MOS_MIN(rect.Left, rightBorder);
1343 rect.Right = MOS_MIN(rect.Right, rightBorder);
1344 rect.Top = MOS_MIN(rect.Top, bottomBorder);
1345 rect.Bottom = MOS_MIN(rect.Bottom, bottomBorder);
1346 if (rect.Left > rect.Right || rect.Top > rect.Bottom)
1347 {
1348 DDI_CODEC_ASSERTMESSAGE("Invalid rect region parameter.");
1349 return VA_STATUS_ERROR_INVALID_PARAMETER;
1350 }
1351 picParams->NumDirtyRects ++;
1352 }
1353 }
1354 break;
1355 }
1356 case VAEncMiscParameterTypeSkipFrame:
1357 {
1358 VAEncMiscParameterSkipFrame *vaEncMiscParamSkipFrame = (VAEncMiscParameterSkipFrame *)miscParamBuf->data;
1359 // populate skipped frame params from DDI
1360 if (FRAME_SKIP_NORMAL != vaEncMiscParamSkipFrame->skip_frame_flag)
1361 {
1362 DDI_CODEC_ASSERTMESSAGE("unsupported misc parameter type.");
1363 return VA_STATUS_ERROR_INVALID_PARAMETER;
1364 }
1365 picParams->SkipFrameFlag = vaEncMiscParamSkipFrame->skip_frame_flag;
1366 picParams->NumSkipFrames = vaEncMiscParamSkipFrame->num_skip_frames;
1367 picParams->SizeSkipFrames = vaEncMiscParamSkipFrame->size_skip_frames;
1368 break;
1369 }
1370 case VAEncMiscParameterTypeMaxSliceSize:
1371 {
1372 VAEncMiscParameterMaxSliceSize *vaEncMiscParamMaxSliceSize = (VAEncMiscParameterMaxSliceSize *)miscParamBuf->data;
1373 m_encodeCtx->EnableSliceLevelRateCtrl = true;
1374 seqParams->SliceSizeControl = (vaEncMiscParamMaxSliceSize->max_slice_size > 0) ? true : false;;
1375 picParams->MaxSliceSizeInBytes = vaEncMiscParamMaxSliceSize->max_slice_size;
1376 break;
1377 }
1378 case VAEncMiscParameterTypeEncQuality:
1379 {
1380 VAEncMiscParameterEncQuality *vaEncMiscParamPrivate = (VAEncMiscParameterEncQuality *)miscParamBuf->data;
1381 picParams->bUseRawPicForRef = vaEncMiscParamPrivate->useRawPicForRef;
1382 break;
1383 }
1384 case VAEncMiscParameterTypeMaxFrameSize:
1385 {
1386 VAEncMiscParameterBufferMaxFrameSize *vaEncData = (VAEncMiscParameterBufferMaxFrameSize *)miscParamBuf->data;
1387 seqParams->UserMaxIFrameSize = vaEncData->max_frame_size>>3; // convert to bytes
1388 seqParams->UserMaxPBFrameSize = vaEncData->max_frame_size>>3; // convert to bytes
1389 break;
1390 }
1391 default:
1392 DDI_CODEC_ASSERTMESSAGE("unsupported misc parameter type.");
1393 return VA_STATUS_ERROR_INVALID_PARAMETER;
1394 }
1395
1396 return VA_STATUS_SUCCESS;
1397 }
1398
1399 uint8_t DdiEncodeHevc::CodechalPicTypeFromVaSlcType(uint8_t vaSliceType)
1400 {
1401 switch (vaSliceType)
1402 {
1403 case sliceTypeI:
1404 return I_TYPE;
1405 case sliceTypeP:
1406 if (m_codechalSettings->isSCCEnabled)
1407 {
1408 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams = (PCODEC_HEVC_ENCODE_PICTURE_PARAMS)((uint8_t *)m_encodeCtx->pPicParams);
1409 if (hevcPicParams->CodingType == I_TYPE && hevcPicParams->pps_curr_pic_ref_enabled_flag)
1410 {
1411 return I_TYPE;
1412 }
1413 }
1414 return P_TYPE;
1415 case sliceTypeB:
1416 return B_TYPE;
1417 default:
1418 return 0;
1419 }
1420 }
1421
1422 void DdiEncodeHevc::GetSlcRefIdx(CODEC_PICTURE *picReference, CODEC_PICTURE *slcReference)
1423 {
1424 if (nullptr == picReference || nullptr == slcReference)
1425 {
1426 return;
1427 }
1428
1429 int32_t i = 0;
1430 if (CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC != slcReference->FrameIdx)
1431 {
1432 for (i = 0; i < numMaxRefFrame; i++)
1433 {
1434 if (slcReference->FrameIdx == picReference[i].FrameIdx)
1435 {
1436 slcReference->FrameIdx = i;
1437 slcReference->PicEntry = i;
1438 break;
1439 }
1440 }
1441 if (numMaxRefFrame == i)
1442 {
1443 slcReference->FrameIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC;
1444 slcReference->PicFlags = PICTURE_INVALID;
1445 slcReference->PicEntry = 0xFF;
1446 }
1447 }
1448 }
1449
1450 void DdiEncodeHevc::SetupCodecPicture(
1451 DDI_MEDIA_CONTEXT *mediaCtx,
1452 DDI_CODEC_RENDER_TARGET_TABLE *rtTbl,
1453 CODEC_PICTURE *codecHalPic,
1454 VAPictureHEVC vaPicHEVC,
1455 bool picReference,
1456 bool sliceReference)
1457 {
1458 DDI_UNUSED(sliceReference);
1459
1460 if (DDI_CODEC_INVALID_FRAME_INDEX != vaPicHEVC.picture_id)
1461 {
1462 codecHalPic->FrameIdx = GetRenderTargetID(rtTbl, MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, vaPicHEVC.picture_id));
1463 codecHalPic->PicEntry = codecHalPic->FrameIdx;
1464 }
1465 else
1466 {
1467 codecHalPic->FrameIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC;
1468 codecHalPic->PicFlags = PICTURE_INVALID;
1469 codecHalPic->PicEntry = 0xFF;
1470 }
1471
1472 if (PICTURE_INVALID != codecHalPic->PicFlags)
1473 {
1474 codecHalPic->PicFlags = PICTURE_FRAME;
1475 if (picReference)
1476 {
1477 if ((vaPicHEVC.flags & VA_PICTURE_HEVC_LONG_TERM_REFERENCE) == VA_PICTURE_HEVC_LONG_TERM_REFERENCE)
1478 {
1479 codecHalPic->PicFlags = (CODEC_PICTURE_FLAG)(codecHalPic->PicFlags | PICTURE_LONG_TERM_REFERENCE);
1480 codecHalPic->PicEntry |= 0x80;
1481 }
1482 else
1483 {
1484 codecHalPic->PicFlags = (CODEC_PICTURE_FLAG)(codecHalPic->PicFlags | PICTURE_SHORT_TERM_REFERENCE);
1485 }
1486 }
1487 }
1488 }
1489
1490 uint32_t DdiEncodeHevc::getSliceParameterBufferSize()
1491 {
1492 return sizeof(VAEncSliceParameterBufferHEVC);
1493 }
1494
1495 uint32_t DdiEncodeHevc::getSequenceParameterBufferSize()
1496 {
1497 return sizeof(VAEncSequenceParameterBufferHEVC);
1498 }
1499
1500 uint32_t DdiEncodeHevc::getPictureParameterBufferSize()
1501 {
1502 return sizeof(VAEncPictureParameterBufferHEVC);
1503 }
1504
1505 uint32_t DdiEncodeHevc::getQMatrixBufferSize()
1506 {
1507 return sizeof(VAQMatrixBufferHEVC);
1508 }
1509
1510 bool DdiEncodeHevc::IsSccProfile()
1511 {
1512 return (m_encodeCtx->vaProfile==VAProfileHEVCSccMain
1513 || m_encodeCtx->vaProfile==VAProfileHEVCSccMain10
1514 || m_encodeCtx->vaProfile==VAProfileHEVCSccMain444
1515 || m_encodeCtx->vaProfile==VAProfileHEVCSccMain444_10);
1516 }
1517
1518 CODECHAL_FUNCTION DdiEncodeHevc::GetEncodeCodecFunction(VAProfile profile, VAEntrypoint entrypoint, bool bVDEnc)
1519 {
1520 CODECHAL_FUNCTION codecFunction = CODECHAL_FUNCTION_INVALID;
1521 if (bVDEnc)
1522 {
1523 codecFunction = CODECHAL_FUNCTION_ENC_VDENC_PAK;
1524 }
1525 else
1526 {
1527 DDI_CODEC_ASSERTMESSAGE("Unsuported CODECHAL_FUNCTION");
1528 }
1529 return codecFunction;
1530 }
1531
1532 CODECHAL_MODE DdiEncodeHevc::GetEncodeCodecMode(
1533 VAProfile profile,
1534 VAEntrypoint entrypoint)
1535 {
1536 switch (profile)
1537 {
1538 case VAProfileHEVCMain:
1539 case VAProfileHEVCMain10:
1540 case VAProfileHEVCMain422_10:
1541 case VAProfileHEVCMain444:
1542 case VAProfileHEVCMain444_10:
1543 case VAProfileHEVCSccMain:
1544 case VAProfileHEVCSccMain10:
1545 case VAProfileHEVCSccMain444:
1546 case VAProfileHEVCSccMain444_10:
1547 return CODECHAL_ENCODE_MODE_HEVC;
1548 default:
1549 DDI_CODEC_ASSERTMESSAGE("Unsuported CODECHAL_MODE");
1550 return CODECHAL_UNSUPPORTED_MODE;
1551 }
1552 }
1553
1554 } // namespace encode