Debian Codegraph @

media_softlet/linux/common/codec/ddi/dec/ddi_decode_mpeg2_specific.cpp

raw
1 /*
2 * Copyright (c) 2022-2023, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file ddi_decode_mpeg2_specific.cpp
24 //! \brief Implements class for DDI media MPEG2 decode
25 //!
26
27 #include "media_libva_util_next.h"
28 #include "media_libva_caps_next.h"
29 #include "media_libva_interface_next.h"
30 #include "ddi_decode_mpeg2_specific.h"
31
32 namespace decode
33 {
34
35 void DdiDecodeMpeg2::ParseNumMbsForSlice(
36 int32_t numSlices)
37 {
38 DDI_CODEC_FUNC_ENTER;
39
40 CodecDecodeMpeg2PicParams *picParam = (CodecDecodeMpeg2PicParams *)(m_decodeCtx->DecodeParams.m_picParams);
41
42 CodecDecodeMpeg2SliceParams *sliceParam = (CodecDecodeMpeg2SliceParams *)(m_decodeCtx->DecodeParams.m_sliceParams);
43
44 uint16_t widthInMB = 0, heightInMB = 0, numMBInSlc = 0;
45 widthInMB = m_picWidthInMB;
46 heightInMB = m_picHeightInMB;
47
48 int32_t slcIndex = 0;
49 CodecDecodeMpeg2SliceParams *nextSlc = nullptr;
50 for (slcIndex = 0; slcIndex < numSlices; slcIndex++)
51 {
52 if (slcIndex == numSlices - 1) // last slice
53 {
54 numMBInSlc = widthInMB - sliceParam->m_sliceHorizontalPosition;
55 }
56 else
57 {
58 nextSlc = sliceParam + 1;
59 numMBInSlc = (nextSlc->m_sliceVerticalPosition * widthInMB + nextSlc->m_sliceHorizontalPosition) -
60 (sliceParam->m_sliceVerticalPosition * widthInMB + sliceParam->m_sliceHorizontalPosition);
61 }
62
63 sliceParam->m_numMbsForSlice = numMBInSlc & 0x007f;
64
65 if (sliceParam->m_numMbsForSlice < numMBInSlc)
66 {
67 sliceParam->m_numMbsForSlice = widthInMB - sliceParam->m_sliceHorizontalPosition;
68 }
69
70 sliceParam++;
71 }
72 return;
73 }
74
75 VAStatus DdiDecodeMpeg2::ParseSliceParams(
76 DDI_MEDIA_CONTEXT *mediaCtx,
77 VASliceParameterBufferMPEG2 *slcParam,
78 uint32_t numSlices)
79 {
80 DDI_CODEC_FUNC_ENTER;
81
82 CodecDecodeMpeg2PicParams *picParams = (CodecDecodeMpeg2PicParams *)(m_decodeCtx->DecodeParams.m_picParams);
83 CodecDecodeMpeg2SliceParams *codecSlcParams = (CodecDecodeMpeg2SliceParams *)(m_decodeCtx->DecodeParams.m_sliceParams);
84 codecSlcParams += m_decodeCtx->DecodeParams.m_numSlices;
85
86 if ((slcParam == nullptr) ||
87 (codecSlcParams == nullptr) ||
88 (picParams == nullptr))
89 {
90 DDI_CODEC_ASSERTMESSAGE("Invalid Parameter for Parsing Mpeg2 Slice parameter\n");
91 return VA_STATUS_ERROR_INVALID_PARAMETER;
92 }
93
94 uint32_t isField;
95 if ((picParams->m_currPic.PicFlags == PICTURE_TOP_FIELD) || (picParams->m_currPic.PicFlags == PICTURE_BOTTOM_FIELD))
96 {
97 isField = 1;
98 }
99 else
100 {
101 isField = 0;
102 }
103
104 uint32_t sliceBaseOffset = GetBsBufOffset(m_groupIndex);
105 uint32_t slcCount;
106 for (slcCount = 0; slcCount < numSlices; slcCount++)
107 {
108 codecSlcParams->m_sliceHorizontalPosition = slcParam->slice_horizontal_position;
109 codecSlcParams->m_sliceVerticalPosition = slcParam->slice_vertical_position;
110
111 codecSlcParams->m_sliceDataSize = (slcParam->slice_data_size) * 8;
112 codecSlcParams->m_sliceDataOffset = slcParam->slice_data_offset + sliceBaseOffset;
113 if (slcParam->slice_data_flag)
114 {
115 DDI_CODEC_NORMALMESSAGE("The whole slice is not in the bitstream buffer for this Execute call");
116 }
117 codecSlcParams->m_macroblockOffset = slcParam->macroblock_offset;
118 codecSlcParams->m_quantiserScaleCode = slcParam->quantiser_scale_code;
119 codecSlcParams->m_reservedBits = 0;
120 slcParam++;
121 codecSlcParams++;
122 }
123
124 return VA_STATUS_SUCCESS;
125 }
126
127 VAStatus DdiDecodeMpeg2::ParseIQMatrix(
128 DDI_MEDIA_CONTEXT *mediaCtx,
129 VAIQMatrixBufferMPEG2 *matrix)
130 {
131 DDI_CODEC_FUNC_ENTER;
132
133 CodecMpeg2IqMatrix *iqMatrix = (CodecMpeg2IqMatrix *)(m_decodeCtx->DecodeParams.m_iqMatrixBuffer);
134
135 if ((iqMatrix == nullptr) || (matrix == nullptr))
136 {
137 DDI_CODEC_ASSERTMESSAGE("Invalid Parameter for Parsing Mpeg2 IQ Matrix parameter\n");
138 return VA_STATUS_ERROR_INVALID_PARAMETER;
139 }
140
141 iqMatrix->m_loadIntraQuantiserMatrix = matrix->load_intra_quantiser_matrix;
142 iqMatrix->m_loadNonIntraQuantiserMatrix = matrix->load_non_intra_quantiser_matrix;
143 iqMatrix->m_loadChromaIntraQuantiserMatrix = matrix->load_chroma_intra_quantiser_matrix;
144 iqMatrix->m_loadChromaNonIntraQuantiserMatrix = matrix->load_chroma_non_intra_quantiser_matrix;
145
146 MOS_SecureMemcpy(iqMatrix->m_intraQuantiserMatrix,
147 64,
148 matrix->intra_quantiser_matrix,
149 64);
150 MOS_SecureMemcpy(iqMatrix->m_nonIntraQuantiserMatrix,
151 64,
152 matrix->non_intra_quantiser_matrix,
153 64);
154 MOS_SecureMemcpy(iqMatrix->m_chromaIntraQuantiserMatrix,
155 64,
156 matrix->chroma_intra_quantiser_matrix,
157 64);
158 MOS_SecureMemcpy(iqMatrix->m_chromaNonIntraQuantiserMatrix,
159 64,
160 matrix->chroma_non_intra_quantiser_matrix,
161 64);
162 return VA_STATUS_SUCCESS;
163 }
164
165 #define INTRA_CODED 0x1
166 #define PREDICTIVE_CODED 0x2
167 #define BIDIRECTIONAL_CODED 0x3
168
169 // S-(GMC) VOP coding used for MPEG4 part 2
170 //
171 #define S_CODED 0x4
172
173 VAStatus DdiDecodeMpeg2::ParsePicParams(
174 DDI_MEDIA_CONTEXT *mediaCtx,
175 VAPictureParameterBufferMPEG2 *picParam)
176 {
177 DDI_CODEC_FUNC_ENTER;
178
179 CodecDecodeMpeg2PicParams *codecPicParam = (CodecDecodeMpeg2PicParams *)(m_decodeCtx->DecodeParams.m_picParams);
180 if ((codecPicParam == nullptr) || (picParam == nullptr))
181 {
182 DDI_CODEC_ASSERTMESSAGE("Invalid Parameter for Parsing Mpeg2 Picture Parameter\n");
183 return VA_STATUS_ERROR_INVALID_PARAMETER;
184 }
185
186 codecPicParam->m_currPic.FrameIdx = GetRenderTargetID(&(m_decodeCtx->RTtbl), m_decodeCtx->RTtbl.pCurrentRT);
187 switch (picParam->picture_coding_extension.bits.picture_structure)
188 {
189 case TOP_FIELD:
190 codecPicParam->m_currPic.PicFlags = PICTURE_TOP_FIELD;
191 break;
192 case BOTTOM_FIELD:
193 codecPicParam->m_currPic.PicFlags = PICTURE_BOTTOM_FIELD;
194 break;
195 case FRAME_PICTURE:
196 codecPicParam->m_currPic.PicFlags = PICTURE_FRAME;
197 break;
198 default:
199 break;
200 }
201 codecPicParam->m_topFieldFirst = picParam->picture_coding_extension.bits.top_field_first;
202 codecPicParam->m_secondField = !(picParam->picture_coding_extension.bits.is_first_field);
203 codecPicParam->m_pictureCodingType = picParam->picture_coding_type;
204
205 if (picParam->picture_coding_extension.bits.is_first_field)
206 {
207 if (codecPicParam->m_currPic.PicFlags == PICTURE_TOP_FIELD)
208 codecPicParam->m_topFieldFirst = 1;
209 if (codecPicParam->m_currPic.PicFlags == PICTURE_BOTTOM_FIELD)
210 codecPicParam->m_topFieldFirst = 0;
211 }
212 else
213 {
214 if (codecPicParam->m_currPic.PicFlags == PICTURE_TOP_FIELD)
215 codecPicParam->m_topFieldFirst = 0;
216
217 if (codecPicParam->m_currPic.PicFlags == PICTURE_BOTTOM_FIELD)
218 codecPicParam->m_topFieldFirst = 1;
219 }
220 if (picParam->picture_coding_type == INTRA_CODED)
221 {
222 codecPicParam->m_forwardRefIdx = codecPicParam->m_currPic.FrameIdx;
223 codecPicParam->m_backwardRefIdx = codecPicParam->m_currPic.FrameIdx;
224 }
225 else if (picParam->picture_coding_type == PREDICTIVE_CODED)
226 {
227 if (picParam->forward_reference_picture != VA_INVALID_SURFACE)
228 {
229 if (UpdateRegisteredRTSurfaceFlag(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->forward_reference_picture)) != VA_STATUS_SUCCESS)
230 {
231 DDI_CODEC_CHK_RET(RegisterRTSurfaces(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->forward_reference_picture)), "RegisterRTSurfaces failed!");
232 }
233
234 codecPicParam->m_forwardRefIdx = GetRenderTargetID(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->forward_reference_picture)); //(unsigned char)GetMPEG2SurfaceIdx(&(pRTtbl->pRT[0]), picParam->forward_reference_picture);
235 }
236 else
237 {
238 codecPicParam->m_forwardRefIdx = codecPicParam->m_currPic.FrameIdx;
239 }
240
241 if (codecPicParam->m_secondField)
242 {
243 codecPicParam->m_backwardRefIdx = codecPicParam->m_currPic.FrameIdx;
244 }
245 else
246 {
247 codecPicParam->m_backwardRefIdx = codecPicParam->m_forwardRefIdx;
248 }
249 }
250 else
251 {
252 if (picParam->forward_reference_picture != VA_INVALID_SURFACE)
253 {
254 if (UpdateRegisteredRTSurfaceFlag(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->forward_reference_picture)) != VA_STATUS_SUCCESS)
255 {
256 DDI_CODEC_CHK_RET(RegisterRTSurfaces(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->forward_reference_picture)), "RegisterRTSurfaces failed!");
257 }
258 codecPicParam->m_forwardRefIdx = GetRenderTargetID(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->forward_reference_picture)); //(unsigned char)GetMPEG2SurfaceIdx(&(pRTtbl->pRT[0]), picParam->forward_reference_picture);
259 }
260 else
261 {
262 codecPicParam->m_forwardRefIdx = codecPicParam->m_currPic.FrameIdx;
263 }
264 if (picParam->backward_reference_picture != VA_INVALID_SURFACE)
265 {
266 if (UpdateRegisteredRTSurfaceFlag(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->backward_reference_picture)) != VA_STATUS_SUCCESS)
267 {
268 DDI_CODEC_CHK_RET(RegisterRTSurfaces(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->backward_reference_picture)), "RegisterRTSurfaces failed!");
269 }
270 codecPicParam->m_backwardRefIdx = GetRenderTargetID(&(m_decodeCtx->RTtbl), MediaLibvaCommonNext::GetSurfaceFromVASurfaceID(mediaCtx, picParam->backward_reference_picture)); //(unsigned char)GetMPEG2SurfaceIdx(&(pRTtbl->pRT[0]), picParam->backward_reference_picture);
271 }
272 else
273 {
274 codecPicParam->m_backwardRefIdx = codecPicParam->m_currPic.FrameIdx;
275 }
276 }
277
278 // add protection checking to prevent ref pic index larger than DPB size
279 if (codecPicParam->m_forwardRefIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
280 {
281 codecPicParam->m_forwardRefIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2 - 1;
282 }
283
284 if (codecPicParam->m_backwardRefIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
285 {
286 codecPicParam->m_backwardRefIdx = CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2 - 1;
287 }
288
289 codecPicParam->W0.m_scanOrder = picParam->picture_coding_extension.bits.alternate_scan;
290 codecPicParam->W0.m_intraVlcFormat = picParam->picture_coding_extension.bits.intra_vlc_format;
291 codecPicParam->W0.m_quantizerScaleType = picParam->picture_coding_extension.bits.q_scale_type;
292 codecPicParam->W0.m_concealmentMVFlag = picParam->picture_coding_extension.bits.concealment_motion_vectors;
293 codecPicParam->W0.m_frameDctPrediction = picParam->picture_coding_extension.bits.frame_pred_frame_dct;
294 codecPicParam->W0.m_topFieldFirst = picParam->picture_coding_extension.bits.top_field_first;
295 codecPicParam->W0.m_intraDCPrecision = picParam->picture_coding_extension.bits.intra_dc_precision;
296 codecPicParam->W1.m_value = 0;
297 codecPicParam->W1.m_fcode11 = (picParam->f_code) & 0xf;
298 codecPicParam->W1.m_fcode10 = (picParam->f_code >> 4) & 0xf;
299 codecPicParam->W1.m_fcode01 = (picParam->f_code >> 8) & 0xf;
300 codecPicParam->W1.m_fcode00 = (picParam->f_code >> 12) & 0xf;
301 codecPicParam->m_horizontalSize = picParam->horizontal_size;
302 codecPicParam->m_verticalSize = picParam->vertical_size;
303
304 if (picParam->picture_coding_type == INTRA_CODED)
305 {
306 m_picWidthInMB = (int16_t)(DDI_CODEC_NUM_MACROBLOCKS_WIDTH(picParam->horizontal_size));
307 m_picHeightInMB = (int16_t)(DDI_CODEC_NUM_MACROBLOCKS_WIDTH(picParam->vertical_size));
308 }
309
310 if ((codecPicParam->m_currPic.PicFlags == PICTURE_TOP_FIELD) || (codecPicParam->m_currPic.PicFlags == PICTURE_BOTTOM_FIELD))
311 {
312 codecPicParam->m_verticalSize = picParam->vertical_size >> 1;
313 }
314
315 codecPicParam->m_statusReportFeedbackNumber = 0;
316
317 DDI_CODEC_CHK_NULL(mediaCtx, "Null mediaCtx", VA_STATUS_ERROR_INVALID_CONTEXT);
318 if (codecPicParam->m_horizontalSize > CODEC_2K_MAX_PIC_WIDTH ||
319 codecPicParam->m_verticalSize > CODEC_2K_MAX_PIC_HEIGHT)
320 {
321 return VA_STATUS_ERROR_RESOLUTION_NOT_SUPPORTED;
322 }
323
324 return VA_STATUS_SUCCESS;
325 }
326
327 VAStatus DdiDecodeMpeg2::RenderPicture(
328 VADriverContextP ctx,
329 VAContextID context,
330 VABufferID *buffers,
331 int32_t numBuffers)
332 {
333 DDI_CODEC_FUNC_ENTER;
334
335 VAStatus va = VA_STATUS_SUCCESS;
336 PDDI_MEDIA_CONTEXT mediaCtx;
337
338 mediaCtx = GetMediaContext(ctx);
339
340 void *data = nullptr;
341 for (int32_t i = 0; i < numBuffers; i++)
342 {
343 if (!buffers || (buffers[i] == VA_INVALID_ID))
344 {
345 return VA_STATUS_ERROR_INVALID_BUFFER;
346 }
347
348 DDI_MEDIA_BUFFER *buf = MediaLibvaCommonNext::GetBufferFromVABufferID(mediaCtx, buffers[i]);
349 if (nullptr == buf)
350 {
351 return VA_STATUS_ERROR_INVALID_BUFFER;
352 }
353
354 uint32_t dataSize = buf->iSize;
355 MediaLibvaInterfaceNext::MapBuffer(ctx, buffers[i], &data);
356
357 if (data == nullptr)
358 {
359 return VA_STATUS_ERROR_INVALID_BUFFER;
360 }
361
362 switch ((int32_t)buf->uiType)
363 {
364 case VASliceDataBufferType:
365 {
366 int32_t index = GetBitstreamBufIndexFromBuffer(&m_decodeCtx->BufMgr, buf);
367 if (index == DDI_CODEC_INVALID_BUFFER_INDEX)
368 {
369 return VA_STATUS_ERROR_INVALID_BUFFER;
370 }
371
372 MediaLibvaCommonNext::MediaBufferToMosResource(m_decodeCtx->BufMgr.pBitStreamBuffObject[index], &m_decodeCtx->BufMgr.resBitstreamBuffer);
373 m_decodeCtx->DecodeParams.m_dataSize += dataSize;
374 break;
375 }
376 case VASliceParameterBufferType:
377 {
378 if (buf->uiNumElements == 0)
379 {
380 return VA_STATUS_ERROR_INVALID_BUFFER;
381 }
382
383 VASliceParameterBufferMPEG2 *slcInfoMpeg2 = (VASliceParameterBufferMPEG2 *)data;
384 uint32_t numSlices = buf->uiNumElements;
385 DDI_CODEC_CHK_RET(AllocSliceParamContext(numSlices),"AllocSliceParamContext failed!");
386 DDI_CODEC_CHK_RET(ParseSliceParams(mediaCtx, slcInfoMpeg2, numSlices),"ParseSliceParams failed!");
387 m_decodeCtx->DecodeParams.m_numSlices += numSlices;
388 m_groupIndex++;
389 break;
390 }
391 case VAPictureParameterBufferType:
392 {
393 VAPictureParameterBufferMPEG2 *picParam = (VAPictureParameterBufferMPEG2 *)data;
394 DDI_CODEC_CHK_RET(ParsePicParams(mediaCtx, picParam),"ParsePicParams failed!");
395 break;
396 }
397 case VAIQMatrixBufferType:
398 {
399 VAIQMatrixBufferMPEG2 *imxBuf = (VAIQMatrixBufferMPEG2 *)data;
400 DDI_CODEC_CHK_RET(ParseIQMatrix(mediaCtx, imxBuf),"ParseIQMatrix failed!");
401 break;
402 }
403 case VADecodeStreamoutBufferType:
404 {
405 MediaLibvaCommonNext::MediaBufferToMosResource(buf, &m_decodeCtx->BufMgr.resExternalStreamOutBuffer);
406 m_streamOutEnabled = true;
407 break;
408 }
409 default:
410 va = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
411 break;
412 }
413 MediaLibvaInterfaceNext::UnmapBuffer(ctx, buffers[i]);
414 }
415
416 return va;
417 }
418
419 VAStatus DdiDecodeMpeg2::SetDecodeParams()
420 {
421 DDI_CODEC_FUNC_ENTER;
422
423 DDI_CODEC_CHK_RET(DdiDecodeBase::SetDecodeParams(),"SetDecodeParams failed!");
424 ParseNumMbsForSlice((&m_decodeCtx->DecodeParams)->m_numSlices);
425 return VA_STATUS_SUCCESS;
426 }
427
428 VAStatus DdiDecodeMpeg2::AllocSliceParamContext(
429 uint32_t numSlices)
430 {
431 DDI_CODEC_FUNC_ENTER;
432
433 uint32_t baseSize = sizeof(CodecDecodeMpeg2SliceParams);
434
435 if (m_sliceParamBufNum < (m_decodeCtx->DecodeParams.m_numSlices + numSlices))
436 {
437 // in order to avoid that the buffer is reallocated multi-times,
438 // extra 10 slices are added.
439 uint32_t extraSlices = numSlices + 10;
440
441 m_decodeCtx->DecodeParams.m_sliceParams = realloc(m_decodeCtx->DecodeParams.m_sliceParams,
442 baseSize * (m_sliceParamBufNum + extraSlices));
443
444 if (m_decodeCtx->DecodeParams.m_sliceParams == nullptr)
445 {
446 return VA_STATUS_ERROR_ALLOCATION_FAILED;
447 }
448
449 memset((void *)((uint8_t *)m_decodeCtx->DecodeParams.m_sliceParams + baseSize * m_sliceParamBufNum), 0, baseSize * extraSlices);
450 m_sliceParamBufNum += extraSlices;
451 }
452
453 return VA_STATUS_SUCCESS;
454 }
455
456 void DdiDecodeMpeg2::DestroyContext(
457 VADriverContextP ctx)
458 {
459 DDI_CODEC_FUNC_ENTER;
460
461 FreeResourceBuffer();
462 // explicitly call the base function to do the further clean-up
463 DdiDecodeBase::DestroyContext(ctx);
464
465 return;
466 }
467
468 uint8_t* DdiDecodeMpeg2::GetPicParamBuf(
469 DDI_CODEC_COM_BUFFER_MGR *bufMgr)
470 {
471 DDI_CODEC_FUNC_ENTER;
472
473 return (uint8_t*)(&(bufMgr->Codec_Param.Codec_Param_MPEG2.PicParamMPEG2));
474 }
475
476 VAStatus DdiDecodeMpeg2::AllocSliceControlBuffer(
477 DDI_MEDIA_BUFFER *buf)
478 {
479 DDI_CODEC_FUNC_ENTER;
480
481 DDI_CODEC_COM_BUFFER_MGR *bufMgr = nullptr;
482 uint32_t availSize = 0;
483 uint32_t newSize = 0;
484
485 bufMgr = &(m_decodeCtx->BufMgr);
486 availSize = m_sliceCtrlBufNum - bufMgr->dwNumSliceControl;
487 if(availSize < buf->uiNumElements)
488 {
489 newSize = sizeof(VASliceParameterBufferMPEG2) * (m_sliceCtrlBufNum - availSize + buf->uiNumElements);
490 bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2 = (VASliceParameterBufferMPEG2 *)realloc(bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2, newSize);
491 if (bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2 == nullptr)
492 {
493 return VA_STATUS_ERROR_ALLOCATION_FAILED;
494 }
495 MOS_ZeroMemory(bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2 + m_sliceCtrlBufNum, sizeof(VASliceParameterBufferMPEG2) * (buf->uiNumElements - availSize));
496 m_sliceCtrlBufNum = m_sliceCtrlBufNum - availSize + buf->uiNumElements;
497 }
498 buf->pData = (uint8_t*)bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2;
499 buf->uiOffset = sizeof(VASliceParameterBufferMPEG2) * bufMgr->dwNumSliceControl;
500
501 bufMgr->dwNumSliceControl += buf->uiNumElements;
502
503 return VA_STATUS_SUCCESS;
504 }
505
506 void DdiDecodeMpeg2::ContextInit(
507 int32_t picWidth,
508 int32_t picHeight)
509 {
510 DDI_CODEC_FUNC_ENTER;
511
512 // call the function in base class to initialize it.
513 DdiDecodeBase::ContextInit(picWidth, picHeight);
514
515 m_decodeCtx->wMode = CODECHAL_DECODE_MODE_MPEG2VLD;
516
517 return;
518 }
519
520 VAStatus DdiDecodeMpeg2::InitResourceBuffer()
521 {
522 DDI_CODEC_FUNC_ENTER;
523
524 VAStatus vaStatus = VA_STATUS_SUCCESS;
525 DDI_CODEC_COM_BUFFER_MGR *bufMgr = &(m_decodeCtx->BufMgr);
526
527 bufMgr->pSliceData = nullptr;
528
529 bufMgr->ui64BitstreamOrder = 0;
530 bufMgr->dwMaxBsSize = m_width * m_height * 3 / 2;
531 // minimal 10k bytes for some special case. Will refractor this later
532 if (bufMgr->dwMaxBsSize < DDI_CODEC_MIN_VALUE_OF_MAX_BS_SIZE)
533 {
534 bufMgr->dwMaxBsSize = DDI_CODEC_MIN_VALUE_OF_MAX_BS_SIZE;
535 }
536
537 int32_t i;
538 // init decode bitstream buffer object
539 for (i = 0; i < DDI_CODEC_MAX_BITSTREAM_BUFFER; i++)
540 {
541 bufMgr->pBitStreamBuffObject[i] = (DDI_MEDIA_BUFFER *)MOS_AllocAndZeroMemory(sizeof(DDI_MEDIA_BUFFER));
542 if (bufMgr->pBitStreamBuffObject[i] == nullptr)
543 {
544 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
545 FreeResourceBuffer();
546 return vaStatus;
547 }
548 bufMgr->pBitStreamBuffObject[i]->iSize = bufMgr->dwMaxBsSize;
549 bufMgr->pBitStreamBuffObject[i]->uiType = VASliceDataBufferType;
550 bufMgr->pBitStreamBuffObject[i]->format = Media_Format_Buffer;
551 bufMgr->pBitStreamBuffObject[i]->uiOffset = 0;
552 bufMgr->pBitStreamBuffObject[i]->bo = nullptr;
553 bufMgr->pBitStreamBase[i] = nullptr;
554 }
555
556 // Most Mpeg2 clips are based on row.
557 // As the pSliceData can be allocated on demand, the default size is based on wPicHeightInMB.
558 bufMgr->m_maxNumSliceData = m_picHeightInMB;
559 bufMgr->pSliceData = (DDI_CODEC_BITSTREAM_BUFFER_INFO *)MOS_AllocAndZeroMemory(sizeof(bufMgr->pSliceData[0]) * bufMgr->m_maxNumSliceData);
560
561 if (bufMgr->pSliceData == nullptr)
562 {
563 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
564 FreeResourceBuffer();
565 return vaStatus;
566 }
567
568 bufMgr->dwNumSliceData = 0;
569 bufMgr->dwNumSliceControl = 0;
570
571 m_sliceCtrlBufNum = m_picHeightInMB;
572 bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2 = (VASliceParameterBufferMPEG2 *)MOS_AllocAndZeroMemory(sizeof(VASliceParameterBufferMPEG2) * m_sliceCtrlBufNum);
573 if (bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2 == nullptr)
574 {
575 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
576 FreeResourceBuffer();
577 return vaStatus;
578 }
579
580 return VA_STATUS_SUCCESS;
581 }
582
583 void DdiDecodeMpeg2::FreeResourceBuffer()
584 {
585 DDI_CODEC_FUNC_ENTER;
586
587 DDI_CODEC_COM_BUFFER_MGR *bufMgr = &(m_decodeCtx->BufMgr);
588
589 int32_t i = 0;
590 for (i = 0; i < DDI_CODEC_MAX_BITSTREAM_BUFFER; i++)
591 {
592 if (bufMgr->pBitStreamBase[i])
593 {
594 MediaLibvaUtilNext::UnlockBuffer(bufMgr->pBitStreamBuffObject[i]);
595 bufMgr->pBitStreamBase[i] = nullptr;
596 }
597 if (bufMgr->pBitStreamBuffObject[i])
598 {
599 MediaLibvaUtilNext::FreeBuffer(bufMgr->pBitStreamBuffObject[i]);
600 MOS_FreeMemory(bufMgr->pBitStreamBuffObject[i]);
601 bufMgr->pBitStreamBuffObject[i] = nullptr;
602 }
603 }
604
605 if (bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2)
606 {
607 MOS_FreeMemory(bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2);
608 bufMgr->Codec_Param.Codec_Param_MPEG2.pVASliceParaBufMPEG2 = nullptr;
609 }
610
611 // free decode bitstream buffer object
612 MOS_FreeMemory(bufMgr->pSliceData);
613 bufMgr->pSliceData = nullptr;
614
615 return;
616 }
617
618 VAStatus DdiDecodeMpeg2::CodecHalInit(
619 DDI_MEDIA_CONTEXT *mediaCtx,
620 void *ptr)
621 {
622 DDI_CODEC_FUNC_ENTER;
623
624 VAStatus vaStatus = VA_STATUS_SUCCESS;
625 MOS_CONTEXT *mosCtx = (MOS_CONTEXT *)ptr;
626
627 CODECHAL_FUNCTION codecFunction = CODECHAL_FUNCTION_DECODE;
628 m_decodeCtx->pCpDdiInterfaceNext->SetCpParams(m_ddiDecodeAttr->componentData.data.encryptType, m_codechalSettings);
629
630 CODECHAL_STANDARD_INFO standardInfo;
631 memset(&standardInfo, 0, sizeof(standardInfo));
632
633 standardInfo.CodecFunction = codecFunction;
634 standardInfo.Mode = (CODECHAL_MODE)m_decodeCtx->wMode;
635
636 m_codechalSettings->codecFunction = codecFunction;
637 m_codechalSettings->width = m_width;
638 m_codechalSettings->height = m_height;
639 m_codechalSettings->intelEntrypointInUse = false;
640
641 m_codechalSettings->lumaChromaDepth = CODECHAL_LUMA_CHROMA_DEPTH_8_BITS;
642
643 m_codechalSettings->shortFormatInUse = m_decodeCtx->bShortFormatInUse;
644
645 m_codechalSettings->mode = CODECHAL_DECODE_MODE_MPEG2VLD;
646 m_codechalSettings->standard = CODECHAL_MPEG2;
647
648 m_decodeCtx->DecodeParams.m_iqMatrixBuffer = MOS_AllocAndZeroMemory(sizeof(CodecMpeg2IqMatrix));
649 if (m_decodeCtx->DecodeParams.m_iqMatrixBuffer == nullptr)
650 {
651 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
652 FreeResource();
653 return vaStatus;
654 }
655 m_decodeCtx->DecodeParams.m_picParams = MOS_AllocAndZeroMemory(sizeof(CodecDecodeMpeg2PicParams));
656 if (m_decodeCtx->DecodeParams.m_picParams == nullptr)
657 {
658 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
659 FreeResource();
660 return vaStatus;
661 }
662
663 m_sliceParamBufNum = m_picHeightInMB;
664 m_decodeCtx->DecodeParams.m_sliceParams = MOS_AllocAndZeroMemory(m_sliceParamBufNum * sizeof(CodecDecodeMpeg2SliceParams));
665 if (m_decodeCtx->DecodeParams.m_sliceParams == nullptr)
666 {
667 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
668 FreeResource();
669 return vaStatus;
670 }
671
672 vaStatus = CreateCodecHal(mediaCtx,
673 ptr,
674 &standardInfo);
675
676 if (vaStatus != VA_STATUS_SUCCESS)
677 {
678 FreeResource();
679 return vaStatus;
680 }
681
682 if (InitResourceBuffer() != VA_STATUS_SUCCESS)
683 {
684 vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
685 FreeResource();
686 return vaStatus;
687 }
688
689 return vaStatus;
690 }
691
692 void DdiDecodeMpeg2::FreeResource()
693 {
694 DDI_CODEC_FUNC_ENTER;
695
696 FreeResourceBuffer();
697
698 if (m_decodeCtx->pCodecHal)
699 {
700 m_decodeCtx->pCodecHal->Destroy();
701 MOS_Delete(m_decodeCtx->pCodecHal);
702 m_decodeCtx->pCodecHal = nullptr;
703 }
704
705 MOS_FreeMemory(m_decodeCtx->DecodeParams.m_iqMatrixBuffer);
706 m_decodeCtx->DecodeParams.m_iqMatrixBuffer = nullptr;
707 MOS_FreeMemory(m_decodeCtx->DecodeParams.m_picParams);
708 m_decodeCtx->DecodeParams.m_picParams = nullptr;
709 MOS_FreeMemory(m_decodeCtx->DecodeParams.m_huffmanTable);
710 m_decodeCtx->DecodeParams.m_huffmanTable = nullptr;
711 MOS_FreeMemory(m_decodeCtx->DecodeParams.m_sliceParams);
712 m_decodeCtx->DecodeParams.m_sliceParams = nullptr;
713
714 return;
715 }
716
717 } // namespace decode