1 /*
2 * Copyright (c) 2021-2024, 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 decode_jpeg_picture_packet.cpp
24 //! \brief Defines the interface for jpeg decode picture packet
25 //!
26 #include "decode_jpeg_picture_packet.h"
27 #include "codechal_debug.h"
28 #include "decode_common_feature_defs.h"
29
30 namespace decode{
31
GetJpegDecodeFormat(MOS_FORMAT format)32 static MHW_VDBOX_DECODE_JPEG_FORMAT_CODE GetJpegDecodeFormat(MOS_FORMAT format)
33 {
34 switch (format)
35 {
36 case Format_NV12:
37 return MHW_VDBOX_DECODE_JPEG_FORMAT_NV12;
38 case Format_UYVY:
39 return MHW_VDBOX_DECODE_JPEG_FORMAT_UYVY;
40 case Format_YUY2:
41 return MHW_VDBOX_DECODE_JPEG_FORMAT_YUY2;
42 default:
43 return MHW_VDBOX_DECODE_JPEG_FORMAT_SEPARATE_PLANE;
44 }
45
46 return MHW_VDBOX_DECODE_JPEG_FORMAT_SEPARATE_PLANE;
47 }
48
IsVPlanePresent(MOS_FORMAT format)49 static bool IsVPlanePresent(MOS_FORMAT format)
50 {
51 switch (format)
52 {
53 case Format_NV12:
54 case Format_NV11:
55 case Format_P208:
56 case Format_IMC1:
57 case Format_IMC3:
58 case Format_YUY2:
59 case Format_YUYV:
60 case Format_YVYU:
61 case Format_UYVY:
62 case Format_VYUY:
63 case Format_422H:
64 case Format_422V:
65 // Adding RGB formats because RGB is treated like YUV for JPEG encode and decode
66 case Format_RGBP:
67 case Format_BGRP:
68 case Format_A8R8G8B8:
69 case Format_X8R8G8B8:
70 case Format_A8B8G8R8:
71 case Format_411P:
72 case Format_411R:
73 case Format_444P:
74 case Format_IMC2:
75 case Format_IMC4:
76 return true;
77 default:
78 return false;
79 }
80 }
81
~JpegDecodePicPkt()82 JpegDecodePicPkt::~JpegDecodePicPkt()
83 {
84 FreeResources();
85 }
86
FreeResources()87 MOS_STATUS JpegDecodePicPkt::FreeResources()
88 {
89 DECODE_FUNC_CALL();
90
91 return MOS_STATUS_SUCCESS;
92 }
93
Init()94 MOS_STATUS JpegDecodePicPkt::Init()
95 {
96 DECODE_FUNC_CALL();
97
98 DECODE_CHK_NULL(m_featureManager);
99 DECODE_CHK_NULL(m_hwInterface);
100 DECODE_CHK_NULL(m_osInterface);
101 DECODE_CHK_NULL(m_miItf);
102 DECODE_CHK_NULL(m_jpegPipeline);
103 DECODE_CHK_NULL(m_mfxItf);
104
105 m_jpegBasicFeature = dynamic_cast<JpegBasicFeature*>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
106 DECODE_CHK_NULL(m_jpegBasicFeature);
107
108 #ifdef _DECODE_PROCESSING_SUPPORTED
109 m_downSamplingFeature = dynamic_cast<DecodeDownSamplingFeature *>(m_featureManager->GetFeature(DecodeFeatureIDs::decodeDownSampling));
110 DecodeSubPacket *subPacket = m_jpegPipeline->GetSubPacket(DecodePacketId(m_jpegPipeline, downSamplingSubPacketId));
111 m_downSamplingPkt = dynamic_cast<DecodeDownSamplingPkt *>(subPacket);
112 #endif
113
114 m_allocator = m_pipeline ->GetDecodeAllocator();
115 DECODE_CHK_NULL(m_allocator);
116
117 DECODE_CHK_STATUS(AllocateFixedResources());
118
119 return MOS_STATUS_SUCCESS;
120 }
121
Prepare()122 MOS_STATUS JpegDecodePicPkt::Prepare()
123 {
124 DECODE_FUNC_CALL();
125
126 m_jpegPicParams = m_jpegBasicFeature->m_jpegPicParams;
127 DECODE_CHK_NULL(m_jpegPicParams);
128
129 #ifdef _MMC_SUPPORTED
130 m_mmcState = m_jpegPipeline->GetMmcState();
131 DECODE_CHK_NULL(m_mmcState);
132 #endif
133
134 return MOS_STATUS_SUCCESS;
135 }
136
AllocateFixedResources()137 MOS_STATUS JpegDecodePicPkt::AllocateFixedResources()
138 {
139 DECODE_FUNC_CALL();
140
141 return MOS_STATUS_SUCCESS;
142 }
143
CalculateCommandSize(uint32_t & commandBufferSize,uint32_t & requestedPatchListSize)144 MOS_STATUS JpegDecodePicPkt::CalculateCommandSize(uint32_t &commandBufferSize, uint32_t &requestedPatchListSize)
145 {
146 DECODE_FUNC_CALL();
147
148 commandBufferSize = m_pictureStatesSize;
149 requestedPatchListSize = m_picturePatchListSize;
150
151 return MOS_STATUS_SUCCESS;
152 }
153
MHW_SETPAR_DECL_SRC(MFX_PIPE_MODE_SELECT,JpegDecodePicPkt)154 MHW_SETPAR_DECL_SRC(MFX_PIPE_MODE_SELECT, JpegDecodePicPkt)
155 {
156 params.Mode = m_jpegBasicFeature->m_mode;
157 params.streamOutEnable = false;
158 params.deblockerStreamOutEnable = false;
159 params.preDeblockingOutputEnablePredeblockoutenable = true;
160 params.postDeblockingOutputEnablePostdeblockoutenable = false;
161
162 params.codecSelect = 0;
163 if (CodecHalIsDecodeModeVLD(params.Mode))
164 {
165 params.decoderModeSelect = 0;
166 }
167 else if (CodecHalIsDecodeModeIT(params.Mode))
168 {
169 params.decoderModeSelect = 1;
170 }
171 params.standardSelect = CodecHal_GetStandardFromMode(params.Mode);
172 params.decoderShortFormatMode = 1;
173 return MOS_STATUS_SUCCESS;
174 }
175
MHW_SETPAR_DECL_SRC(MFX_SURFACE_STATE,JpegDecodePicPkt)176 MHW_SETPAR_DECL_SRC(MFX_SURFACE_STATE, JpegDecodePicPkt)
177 {
178 params.psSurface = &m_jpegBasicFeature->m_destSurface;
179 uint32_t uvPlaneAlignment = MHW_VDBOX_MFX_RECON_UV_PLANE_ALIGNMENT;
180
181 params.tilemode = m_mfxItf->MosGetHWTileType(params.psSurface->TileType, params.psSurface->TileModeGMM, params.psSurface->bGMMTileEnabled);
182
183 params.height = params.psSurface->dwHeight - 1;
184 params.width = params.psSurface->dwWidth - 1;
185 params.surfacePitch = params.psSurface->dwPitch - 1;
186
187 if (params.surfaceId == CODECHAL_MFX_SRC_SURFACE_ID)
188 {
189 uvPlaneAlignment = MHW_VDBOX_MFX_RAW_UV_PLANE_ALIGNMENT_GEN9;
190 }
191 else if ((params.surfaceId == CODECHAL_MFX_REF_SURFACE_ID) || params.surfaceId == CODECHAL_MFX_DSRECON_SURFACE_ID)
192 {
193 uvPlaneAlignment = params.uvPlaneAlignment ? params.uvPlaneAlignment : MHW_VDBOX_MFX_RECON_UV_PLANE_ALIGNMENT;
194 }
195 else
196 {
197 uvPlaneAlignment = MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY;
198 }
199
200 params.interleaveChroma = 0;
201 params.surfaceFormat = GetJpegDecodeFormat(params.psSurface->Format);
202
203 if (params.psSurface->Format == Format_P8)
204 {
205 params.interleaveChroma = 0;
206 }
207
208 params.yOffsetForUCb = params.yOffsetForVCr =
209 MOS_ALIGN_CEIL((params.psSurface->UPlaneOffset.iSurfaceOffset - params.psSurface->dwOffset) / params.psSurface->dwPitch + params.psSurface->RenderOffset.YUV.U.YOffset, uvPlaneAlignment);
210 if (IsVPlanePresent(params.psSurface->Format))
211 {
212 params.yOffsetForVCr =
213 MOS_ALIGN_CEIL((params.psSurface->VPlaneOffset.iSurfaceOffset - params.psSurface->dwOffset) / params.psSurface->dwPitch + params.psSurface->RenderOffset.YUV.V.YOffset, uvPlaneAlignment);
214 }
215
216 #ifdef _MMC_SUPPORTED
217 DECODE_CHK_STATUS(m_mmcState->SetSurfaceMmcState(&(m_jpegBasicFeature->m_destSurface)));
218 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(params.psSurface, ¶ms.mmcState));
219 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcFormat(&m_jpegBasicFeature->m_destSurface, ¶ms.compressionFormat));
220 #endif
221 return MOS_STATUS_SUCCESS;
222 }
223
MHW_SETPAR_DECL_SRC(MFX_PIPE_BUF_ADDR_STATE,JpegDecodePicPkt)224 MHW_SETPAR_DECL_SRC(MFX_PIPE_BUF_ADDR_STATE, JpegDecodePicPkt)
225 {
226 params.decodeInUse = true;
227 params.Mode = m_jpegBasicFeature->m_mode;
228 params.psPreDeblockSurface = &m_jpegBasicFeature->m_destSurface;
229
230 params.references = params.presReferences;
231 #ifdef _MMC_SUPPORTED
232 DECODE_CHK_STATUS(m_mmcState->GetSurfaceMmcState(params.psPreDeblockSurface, ¶ms.PreDeblockSurfMmcState));
233 #endif
234 return MOS_STATUS_SUCCESS;
235 }
236
MHW_SETPAR_DECL_SRC(MFX_IND_OBJ_BASE_ADDR_STATE,JpegDecodePicPkt)237 MHW_SETPAR_DECL_SRC(MFX_IND_OBJ_BASE_ADDR_STATE, JpegDecodePicPkt)
238 {
239 params.Mode = m_jpegBasicFeature->m_mode;
240 params.dwDataSize = m_jpegBasicFeature->m_dataSize;
241 params.presDataBuffer = &(m_jpegBasicFeature->m_resDataBuffer.OsResource);
242
243 return MOS_STATUS_SUCCESS;
244 }
245
MHW_SETPAR_DECL_SRC(MFX_JPEG_PIC_STATE,JpegDecodePicPkt)246 MHW_SETPAR_DECL_SRC(MFX_JPEG_PIC_STATE, JpegDecodePicPkt)
247 {
248 params.decodeInUse = true;
249 params.Mode = m_jpegBasicFeature->m_mode;
250 params.pJpegPicParams = m_jpegBasicFeature->m_jpegPicParams;
251 params.dwOutputFormat = m_jpegBasicFeature->m_destSurface.Format;
252
253 if (m_jpegBasicFeature->m_jpegPicParams->m_rotation == jpegRotation90 || m_jpegBasicFeature->m_jpegPicParams->m_rotation == jpegRotation270)
254 {
255 params.dwWidthInBlocks = (m_jpegBasicFeature->m_destSurface.dwHeight / CODEC_DECODE_JPEG_BLOCK_SIZE) - 1;
256 params.dwHeightInBlocks = (m_jpegBasicFeature->m_destSurface.dwWidth / CODEC_DECODE_JPEG_BLOCK_SIZE) - 1;
257 }
258 else
259 {
260 params.dwWidthInBlocks = (m_jpegBasicFeature->m_destSurface.dwWidth / CODEC_DECODE_JPEG_BLOCK_SIZE) - 1;
261 params.dwHeightInBlocks = (m_jpegBasicFeature->m_destSurface.dwHeight / CODEC_DECODE_JPEG_BLOCK_SIZE) - 1;
262 }
263
264 auto picParams = params.pJpegPicParams;
265
266 if (picParams->m_chromaType == jpegRGB || picParams->m_chromaType == jpegBGR)
267 {
268 params.inputFormatYuv = jpegYUV444;
269 }
270 else
271 {
272 params.inputFormatYuv = picParams->m_chromaType;
273 }
274 params.rotation = picParams->m_rotation;
275 params.outputFormatYuv = GetJpegDecodeFormat((MOS_FORMAT)params.dwOutputFormat);
276
277 if (params.dwOutputFormat == Format_NV12)
278 {
279 if (picParams->m_chromaType == jpegYUV422H2Y ||
280 picParams->m_chromaType == jpegYUV422H4Y)
281 {
282 params.verticalDownSamplingEnable = 1;
283 }
284 else if (picParams->m_chromaType == jpegYUV422V2Y ||
285 picParams->m_chromaType == jpegYUV422V4Y)
286 {
287 params.horizontalDownSamplingEnable = 1;
288 }
289 }
290 else if (params.dwOutputFormat == Format_UYVY ||
291 params.dwOutputFormat == Format_YUY2)
292 {
293 if (picParams->m_chromaType == jpegYUV420)
294 {
295 params.verticalUpSamplingEnable = 1;
296 }
297 }
298 params.frameWidthInBlocksMinus1 = params.dwWidthInBlocks;
299 params.frameHeightInBlocksMinus1 = params.dwHeightInBlocks;
300
301 return MOS_STATUS_SUCCESS;
302 }
303
AddAllCmds_MFX_QM_STATE(PMOS_COMMAND_BUFFER cmdBuffer)304 MOS_STATUS JpegDecodePicPkt::AddAllCmds_MFX_QM_STATE(PMOS_COMMAND_BUFFER cmdBuffer)
305 {
306 auto pJpegQuantMatrix = m_jpegBasicFeature->m_jpegQMatrix;
307 MHW_MI_CHK_NULL(pJpegQuantMatrix);
308
309 auto ¶ms = m_mfxItf->MHW_GETPAR_F(MFX_QM_STATE)();
310 params = {};
311 bool bJpegQMRotation = false;
312 // Swapping QM(x,y) to QM(y,x) for 90/270 degree rotation
313 if (m_jpegBasicFeature->m_jpegPicParams->m_rotation == jpegRotation90 ||
314 m_jpegBasicFeature->m_jpegPicParams->m_rotation == jpegRotation270)
315 {
316 bJpegQMRotation = true;
317 }
318 else
319 {
320 bJpegQMRotation = false;
321 }
322
323 if (m_jpegPicParams->m_numCompInFrame > jpegNumComponent)
324 {
325 DECODE_ASSERTMESSAGE("Unsupported Component Number in JPEG Picture parameter.");
326 return MOS_STATUS_INVALID_PARAMETER;
327 }
328
329 for (uint16_t scanCount = 0; scanCount < m_jpegPicParams->m_numCompInFrame; scanCount++)
330 {
331 // Using scanCount here because the same command is used for JPEG decode and encode
332 uint32_t quantTableSelector = m_jpegPicParams->m_quantTableSelector[scanCount];
333 if (quantTableSelector >= JPEG_MAX_NUM_OF_QUANTMATRIX)
334 {
335 DECODE_ASSERTMESSAGE("Unsupported QuantTableSelector in JPEG Picture parameter.");
336 return MOS_STATUS_INVALID_PARAMETER;
337 }
338 pJpegQuantMatrix->m_jpegQMTableType[quantTableSelector] = scanCount;
339 auto JpegQMTableSelector = quantTableSelector;
340
341 uint8_t *qMatrix = (uint8_t *)params.quantizermatrix;
342
343 params.qmType = pJpegQuantMatrix->m_jpegQMTableType[JpegQMTableSelector];
344
345 if (bJpegQMRotation)
346 {
347 for (auto i = 0; i < 8; i++)
348 {
349 for (auto ii = 0; ii < 8; ii++)
350 {
351 qMatrix[i + 8 * ii] = pJpegQuantMatrix->m_quantMatrix[JpegQMTableSelector][i * 8 + ii];
352 }
353 }
354 }
355 else
356 {
357 for (auto i = 0; i < 64; i++)
358 {
359 qMatrix[i] = pJpegQuantMatrix->m_quantMatrix[JpegQMTableSelector][i];
360 }
361 }
362
363 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFX_QM_STATE)(cmdBuffer));
364 }
365
366 return MOS_STATUS_SUCCESS;
367 }
368
AddAllCmds_MFX_JPEG_HUFF_TABLE_STATE(PMOS_COMMAND_BUFFER cmdBuffer)369 MOS_STATUS JpegDecodePicPkt::AddAllCmds_MFX_JPEG_HUFF_TABLE_STATE(PMOS_COMMAND_BUFFER cmdBuffer)
370 {
371 auto ¶ms = m_mfxItf->MHW_GETPAR_F(MFX_JPEG_HUFF_TABLE_STATE)();
372 params = {};
373
374 uint32_t dcCurHuffTblIndex[2] = {0xff, 0xff};
375 uint32_t acCurHuffTblIndex[2] = {0xff, 0xff};
376
377 if (m_jpegBasicFeature->m_jpegScanParams->NumScans > jpegNumComponent)
378 {
379 DECODE_ASSERTMESSAGE("Unsupported Components Number in JPEG scan parameter.");
380 return MOS_STATUS_INVALID_PARAMETER;
381 }
382
383 for (uint16_t scanCount = 0; scanCount < m_jpegBasicFeature->m_jpegScanParams->NumScans; scanCount++)
384 {
385 // MFX_JPEG_HUFF_TABLE
386 uint16_t numComponents = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].NumComponents;
387 if (numComponents > jpegNumComponent)
388 {
389 DECODE_ASSERTMESSAGE("Unsupported Components Number in JPEG scan parameter.");
390 return MOS_STATUS_INVALID_PARAMETER;
391 }
392
393 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
394 {
395 // Determine which huffman table we will be writing to
396 // For gray image, componentIdentifier[jpegComponentU] and componentIdentifier[jpegComponentV] are initialized to 0,
397 // and when componentSelector[scanComponent] is equal 0, variable huffTableID is set to 1, and wrong Huffman table is used,
398 // so it is more reasonable to use componentIdentifier[jpegComponentY] to determine which huffman table we will be writing to.
399 uint8_t componentSelector =
400 m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
401 uint16_t huffTableID = 0;
402 if (componentSelector == m_jpegBasicFeature->m_jpegPicParams->m_componentIdentifier[jpegComponentY])
403 {
404 huffTableID = 0;
405 }
406 else
407 {
408 huffTableID = 1;
409 }
410
411 int32_t acTableSelector =
412 m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].AcHuffTblSelector[scanComponent];
413 int32_t dcTableSelector =
414 m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].DcHuffTblSelector[scanComponent];
415
416 // Send the huffman table state command only if the table changed
417 if ((dcTableSelector != dcCurHuffTblIndex[huffTableID]) ||
418 (acTableSelector != acCurHuffTblIndex[huffTableID]))
419 {
420 //MHW_VDBOX_HUFF_TABLE_PARAMS huffmanTableParams;
421 //MOS_ZeroMemory(&huffmanTableParams, sizeof(huffmanTableParams));
422 params.huffTableID = huffTableID;
423
424 params.pACBits = &m_jpegBasicFeature->m_jpegHuffmanTable->HuffTable[acTableSelector].AC_BITS[0];
425 params.pDCBits = &m_jpegBasicFeature->m_jpegHuffmanTable->HuffTable[dcTableSelector].DC_BITS[0];
426 params.pACValues = &m_jpegBasicFeature->m_jpegHuffmanTable->HuffTable[acTableSelector].AC_HUFFVAL[0];
427 params.pDCValues = &m_jpegBasicFeature->m_jpegHuffmanTable->HuffTable[dcTableSelector].DC_HUFFVAL[0];
428
429 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFX_JPEG_HUFF_TABLE_STATE)(cmdBuffer));
430
431 // Set the current huffman table indices for the next scan
432 dcCurHuffTblIndex[huffTableID] = dcTableSelector;
433 acCurHuffTblIndex[huffTableID] = acTableSelector;
434 }
435 }
436 }
437 return MOS_STATUS_SUCCESS;
438 }
439
AddAllCmds_MFD_JPEG_BSD_OBJECT(PMOS_COMMAND_BUFFER cmdBuffer)440 MOS_STATUS JpegDecodePicPkt::AddAllCmds_MFD_JPEG_BSD_OBJECT(PMOS_COMMAND_BUFFER cmdBuffer)
441 {
442 auto ¶ms = m_mfxItf->MHW_GETPAR_F(MFD_JPEG_BSD_OBJECT)();
443 params = {};
444 for (uint16_t scanCount = 0; scanCount < m_jpegBasicFeature->m_jpegScanParams->NumScans; scanCount++)
445 {
446 uint16_t numComponents = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].NumComponents;
447 MOS_ZeroMemory(¶ms, sizeof(params));
448
449 params.indirectDataLength = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].DataLength;
450 params.dataStartAddress = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].DataOffset;
451 params.scanHorizontalPosition = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].ScanHoriPosition;
452 params.scanVerticalPosition = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].ScanVertPosition;
453 params.interleaved = (numComponents > 1) ? 1 : 0;
454 params.mcuCount = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].MCUCount;
455 params.restartInterval = m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].RestartInterval;
456
457 uint16_t scanComponentIndex = 0;
458
459 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
460 {
461 uint8_t componentSelector =
462 m_jpegBasicFeature->m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
463
464 if (componentSelector == m_jpegBasicFeature->m_jpegPicParams->m_componentIdentifier[jpegComponentY])
465 {
466 scanComponentIndex = 0;
467 }
468 else if (componentSelector == m_jpegBasicFeature->m_jpegPicParams->m_componentIdentifier[jpegComponentU])
469 {
470 scanComponentIndex = 1;
471 }
472 else if (componentSelector == m_jpegBasicFeature->m_jpegPicParams->m_componentIdentifier[jpegComponentV])
473 {
474 scanComponentIndex = 2;
475 }
476 // Add logic for component identifier JPEG_A
477
478 params.scanComponent |= (1 << scanComponentIndex);
479 }
480
481 DECODE_CHK_STATUS(m_mfxItf->MHW_ADDCMD_F(MFD_JPEG_BSD_OBJECT)(cmdBuffer));
482 }
483 return MOS_STATUS_SUCCESS;
484 }
485
486 #if USE_CODECHAL_DEBUG_TOOL
DumpResources(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS & pipeBufAddrParams)487 MOS_STATUS JpegDecodePicPkt::DumpResources(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS& pipeBufAddrParams)
488 {
489 DECODE_FUNC_CALL();
490
491 return MOS_STATUS_SUCCESS;
492 }
493
494 #endif
495
496 }
497