Debian Codegraph @

media_driver/agnostic/gen11/codec/hal/codechal_decode_jpeg_g11.cpp

raw
1 /*
2 * Copyright (c) 2011-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_decode_jpeg_g11.cpp
24 //! \brief Implements the decode interface extension for JPEG.
25 //! \details Implements all functions and constants required by CodecHal for JPEG decoding.
26 //!
27
28 #include "codechal_decoder.h"
29 #include "codechal_decode_jpeg_g11.h"
30 #include "mhw_vdbox_mfx_g11_X.h"
31 #include "hal_oca_interface.h"
32
33 CodechalDecodeJpegG11::~CodechalDecodeJpegG11()
34 {
35 CODECHAL_DECODE_FUNCTION_ENTER;
36
37 if (m_veState != nullptr)
38 {
39 MOS_FreeMemAndSetNull(m_veState);
40 m_veState = nullptr;
41 }
42 }
43
44 MOS_STATUS CodechalDecodeJpegG11::SetGpuCtxCreatOption(
45 CodechalSetting * codecHalSetting)
46 {
47 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
48
49 CODECHAL_DECODE_FUNCTION_ENTER;
50
51 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
52 {
53 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
54 }
55 else
56 {
57 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
58
59 bool sfcInUse = IsSfcInUse(codecHalSetting);
60
61 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
62 m_veState,
63 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
64 sfcInUse));
65
66 if (sfcInUse)
67 {
68 m_videoContext = MOS_GPU_CONTEXT_VIDEO4;
69
70 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateGpuContext(
71 m_osInterface,
72 m_videoContext,
73 MOS_GPU_NODE_VIDEO,
74 m_gpuCtxCreatOpt));
75
76 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
77 }
78 else
79 {
80 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
81 }
82 }
83
84 return eStatus;
85 }
86
87 MOS_STATUS CodechalDecodeJpegG11::SetFrameStates()
88 {
89 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
90
91 CODECHAL_DECODE_FUNCTION_ENTER;
92
93 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeJpeg::SetFrameStates());
94
95 if ( MOS_VE_SUPPORTED(m_osInterface))
96 {
97 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
98 {
99 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
100
101 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
102 #ifdef _DECODE_PROCESSING_SUPPORTED
103 vesetParams.bSFCInUse = m_sfcState->m_sfcPipeOut;
104 #else
105 vesetParams.bSFCInUse = false;
106 #endif
107 vesetParams.bNeedSyncWithPrevious = true;
108 vesetParams.bSameEngineAsLastSubmission = false;
109 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(
110 m_veState,
111 &vesetParams));
112 }
113 }
114
115 return eStatus;
116 }
117
118 MOS_STATUS CodechalDecodeJpegG11::DecodeStateLevel()
119 {
120 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
121
122 CODECHAL_DECODE_FUNCTION_ENTER;
123
124 MHW_VDBOX_JPEG_DECODE_PIC_STATE jpegPicState;
125 jpegPicState.dwOutputFormat = m_decodeParams.m_destSurface->Format;
126
127 #ifdef _DECODE_PROCESSING_SUPPORTED
128 if (m_sfcState->m_sfcPipeOut)
129 {
130 jpegPicState.dwOutputFormat = m_sfcState->m_sfcInSurface.Format;
131 }
132 #endif
133
134 //Three new formats from HSW C0,HSW ULT can only be supported in specific conditions.
135 if (jpegPicState.dwOutputFormat == Format_NV12 ||
136 jpegPicState.dwOutputFormat == Format_YUY2 ||
137 jpegPicState.dwOutputFormat == Format_UYVY)
138 {
139 //Only interleaved single scan are supported.
140 if (m_jpegPicParams->m_totalScans != 1 ||
141 m_jpegPicParams->m_interleavedData == 0)
142 {
143 return MOS_STATUS_UNKNOWN;
144 }
145
146 switch (m_jpegPicParams->m_chromaType)
147 {
148 case jpegYUV420:
149 case jpegYUV422H2Y:
150 case jpegYUV422H4Y:
151 break;
152 case jpegYUV422V2Y:
153 case jpegYUV422V4Y:
154 if (GFX_IS_GEN_8_OR_LATER(m_hwInterface->GetPlatform()) &&
155 jpegPicState.dwOutputFormat == Format_NV12)
156 {
157 break;
158 }
159 default:
160 return MOS_STATUS_UNKNOWN;
161 }
162 }
163
164 if (m_decodeParams.m_destSurface->Format == Format_A8R8G8B8)
165 {
166 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
167 m_osInterface,
168 MOS_GPU_CONTEXT_VIDEO4));
169 m_videoContext = MOS_GPU_CONTEXT_VIDEO4;
170 }
171 else
172 {
173 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
174 m_osInterface,
175 MOS_GPU_CONTEXT_VIDEO));
176 m_videoContext = MOS_GPU_CONTEXT_VIDEO;
177 }
178
179 MOS_COMMAND_BUFFER cmdBuffer;
180 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
181 m_osInterface,
182 &cmdBuffer,
183 0));
184
185 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
186 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
187
188 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
189 &cmdBuffer, true));
190
191 // Set PIPE_MODE_SELECT
192 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
193 pipeModeSelectParams.Mode = CODECHAL_DECODE_MODE_JPEG;
194 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
195 pipeModeSelectParams.bDeblockerStreamOutEnable = false;
196 pipeModeSelectParams.bPostDeblockOutEnable = false;
197 pipeModeSelectParams.bPreDeblockOutEnable = true;
198
199 // Set CMD_MFX_SURFACE_STATE
200 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
201 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
202 surfaceParams.Mode = CODECHAL_DECODE_MODE_JPEG;
203 surfaceParams.psSurface = &m_destSurface;
204 surfaceParams.ChromaType = m_jpegPicParams->m_chromaType;
205
206 #ifdef _DECODE_PROCESSING_SUPPORTED
207 if (m_sfcState->m_sfcPipeOut)
208 {
209 surfaceParams.psSurface = &m_sfcState->m_sfcInSurface;
210 }
211 #endif
212
213 // Set MFX_PIPE_BUF_ADDR_STATE_CMD
214 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
215 pipeBufAddrParams.Mode = CODECHAL_DECODE_MODE_JPEG;
216 // Predeblock surface is the same as destination surface here because there is no deblocking for JPEG
217 pipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
218
219 pipeBufAddrParams.pDecodedReconParam = &surfaceParams;
220 pipeBufAddrParams.psRawSurface = nullptr;
221
222 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams, &cmdBuffer));
223
224 pipeBufAddrParams.pDecodedReconParam = nullptr;
225
226 // Set MFX_IND_OBJ_BASE_ADDR_STATE_CMD
227 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
228 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
229 indObjBaseAddrParams.Mode = CODECHAL_DECODE_MODE_JPEG;
230 indObjBaseAddrParams.dwDataSize = m_copiedDataBufferInUse ? m_nextCopiedDataOffset : m_dataSize;
231 indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;
232
233 // Set MFX_JPEG_PIC_STATE_CMD
234 jpegPicState.pJpegPicParams = m_jpegPicParams;
235 if ((m_jpegPicParams->m_rotation == jpegRotation90) || (m_jpegPicParams->m_rotation == jpegRotation270))
236 {
237 jpegPicState.dwWidthInBlocks = (m_destSurface.dwHeight / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
238 jpegPicState.dwHeightInBlocks = (m_destSurface.dwWidth / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
239 }
240 else
241 {
242 jpegPicState.dwWidthInBlocks = (m_destSurface.dwWidth / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
243 jpegPicState.dwHeightInBlocks = (m_destSurface.dwHeight / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
244 }
245
246 // Add commands to command buffer
247 // MI_FLUSH_DW command -> must be before to MFX_PIPE_MODE_SELECT
248 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
249 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
250 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
251 &cmdBuffer,
252 &flushDwParams));
253
254 if (m_statusQueryReportingEnabled)
255 {
256 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(
257 &cmdBuffer));
258 }
259
260 // MFX_PIPE_MODE_SELECT_CMD
261 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(
262 &cmdBuffer,
263 &pipeModeSelectParams));
264
265 #ifdef _DECODE_PROCESSING_SUPPORTED
266 // Output decode result through SFC
267 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->AddSfcCommands(&cmdBuffer));
268 #endif
269
270 // CMD_MFX_SURFACE_STATE
271 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(
272 &cmdBuffer,
273 &surfaceParams));
274
275 // MFX_PIPE_BUF_ADDR_STATE_CMD
276 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(
277 &cmdBuffer,
278 &pipeBufAddrParams));
279
280 // MFX_IND_OBJ_BASE_ADDR_STATE_CMD
281 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(
282 &cmdBuffer,
283 &indObjBaseAddrParams));
284
285 // MFX_JPEG_PIC_STATE_CMD
286 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegPicCmd(
287 &cmdBuffer,
288 &jpegPicState));
289
290 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
291
292 return eStatus;
293 }
294
295 MOS_STATUS CodechalDecodeJpegG11::DecodePrimitiveLevel()
296 {
297 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
298
299 CODECHAL_DECODE_FUNCTION_ENTER;
300
301 // if the bitstream is not complete, don't do any decoding work.
302 if (m_incompletePicture)
303 {
304 return MOS_STATUS_SUCCESS;
305
306 }
307
308 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
309
310 MOS_COMMAND_BUFFER cmdBuffer;
311 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
312 m_osInterface,
313 &cmdBuffer,
314 0));
315
316 // MFX_QM_STATE_CMD
317 MHW_VDBOX_QM_PARAMS qmParams;
318 MOS_ZeroMemory(&qmParams, sizeof(qmParams));
319 qmParams.Standard = CODECHAL_JPEG;
320 qmParams.pJpegQuantMatrix = m_jpegQMatrix;
321
322 // Swapping QM(x,y) to QM(y,x) for 90/270 degree rotation
323 if ((m_jpegPicParams->m_rotation == jpegRotation90) ||
324 (m_jpegPicParams->m_rotation == jpegRotation270))
325 {
326 qmParams.bJpegQMRotation = true;
327 }
328 else
329 {
330 qmParams.bJpegQMRotation = false;
331 }
332
333 for (uint16_t scanCount = 0; scanCount < m_jpegPicParams->m_numCompInFrame; scanCount++)
334 {
335 // Using scanCount here because the same command is used for JPEG decode and encode
336 uint32_t quantTableSelector = m_jpegPicParams->m_quantTableSelector[scanCount];
337 qmParams.pJpegQuantMatrix->m_jpegQMTableType[quantTableSelector] = scanCount;
338 qmParams.JpegQMTableSelector = quantTableSelector;
339 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(
340 &cmdBuffer,
341 &qmParams));
342 }
343
344 uint32_t dcCurHuffTblIndex[2] = { 0xff, 0xff };
345 uint32_t acCurHuffTblIndex[2] = { 0xff, 0xff };
346
347 for (uint16_t scanCount = 0; scanCount < m_jpegScanParams->NumScans; scanCount++)
348 {
349 // MFX_JPEG_HUFF_TABLE
350 uint16_t numComponents = m_jpegScanParams->ScanHeader[scanCount].NumComponents;
351 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
352 {
353 // Determine which huffman table we will be writing to
354 // For gray image, componentIdentifier[jpegComponentU] and componentIdentifier[jpegComponentV] are initialized to 0,
355 // and when componentSelector[scanComponent] is equal 0, variable huffTableID is set to 1, and wrong Huffman table is used,
356 // so it is more reasonable to use componentIdentifier[jpegComponentY] to determine which huffman table we will be writing to.
357 uint8_t componentSelector =
358 m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
359 uint16_t huffTableID = 0;
360 if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
361 {
362 huffTableID = 0;
363 }
364 else
365 {
366 huffTableID = 1;
367 }
368
369 int32_t acTableSelector =
370 m_jpegScanParams->ScanHeader[scanCount].AcHuffTblSelector[scanComponent];
371 int32_t dcTableSelector =
372 m_jpegScanParams->ScanHeader[scanCount].DcHuffTblSelector[scanComponent];
373
374 // Send the huffman table state command only if the table changed
375 if ((dcTableSelector != dcCurHuffTblIndex[huffTableID]) ||
376 (acTableSelector != acCurHuffTblIndex[huffTableID]))
377 {
378 MHW_VDBOX_HUFF_TABLE_PARAMS huffmanTableParams;
379 MOS_ZeroMemory(&huffmanTableParams, sizeof(huffmanTableParams));
380
381 huffmanTableParams.HuffTableID = huffTableID;
382
383 huffmanTableParams.pACBits = &m_jpegHuffmanTable->HuffTable[acTableSelector].AC_BITS[0];
384 huffmanTableParams.pDCBits = &m_jpegHuffmanTable->HuffTable[dcTableSelector].DC_BITS[0];
385 huffmanTableParams.pACValues = &m_jpegHuffmanTable->HuffTable[acTableSelector].AC_HUFFVAL[0];
386 huffmanTableParams.pDCValues = &m_jpegHuffmanTable->HuffTable[dcTableSelector].DC_HUFFVAL[0];
387
388 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegHuffTableCmd(
389 &cmdBuffer,
390 &huffmanTableParams));
391
392 // Set the current huffman table indices for the next scan
393 dcCurHuffTblIndex[huffTableID] = dcTableSelector;
394 acCurHuffTblIndex[huffTableID] = acTableSelector;
395 }
396 }
397
398 MHW_VDBOX_JPEG_BSD_PARAMS jpegBsdObject;
399 MOS_ZeroMemory(&jpegBsdObject, sizeof(jpegBsdObject));
400
401 // MFX_JPEG_BSD_OBJECT
402 jpegBsdObject.dwIndirectDataLength = m_jpegScanParams->ScanHeader[scanCount].DataLength;
403 jpegBsdObject.dwDataStartAddress = m_jpegScanParams->ScanHeader[scanCount].DataOffset;
404 jpegBsdObject.dwScanHorizontalPosition = m_jpegScanParams->ScanHeader[scanCount].ScanHoriPosition;
405 jpegBsdObject.dwScanVerticalPosition = m_jpegScanParams->ScanHeader[scanCount].ScanVertPosition;
406 jpegBsdObject.bInterleaved = (numComponents > 1) ? 1 : 0;
407 jpegBsdObject.dwMCUCount = m_jpegScanParams->ScanHeader[scanCount].MCUCount;
408 jpegBsdObject.dwRestartInterval = m_jpegScanParams->ScanHeader[scanCount].RestartInterval;
409
410 uint16_t scanComponentIndex = 0;
411
412 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
413 {
414 uint8_t componentSelector =
415 m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
416
417 if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
418 {
419 scanComponentIndex = 0;
420 }
421 else if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentU])
422 {
423 scanComponentIndex = 1;
424 }
425 else if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentV])
426 {
427 scanComponentIndex = 2;
428 }
429 // Add logic for component identifier JPEG_A
430
431 jpegBsdObject.sScanComponent |= (1 << scanComponentIndex);
432 }
433
434 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegBsdObjCmd(
435 &cmdBuffer,
436 &jpegBsdObject));
437 }
438
439 // Check if destination surface needs to be synchronized
440 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
441 syncParams.GpuContext = m_videoContext;
442 syncParams.presSyncResource = &m_destSurface.OsResource;
443 syncParams.bReadOnly = false;
444 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
445 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
446
447 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
448 m_osInterface,
449 &syncParams));
450 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
451 m_osInterface,
452 &syncParams));
453
454 // Update the resource tag (s/w tag) for On-Demand Sync
455 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
456
457 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
458 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
459 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
460 &cmdBuffer,
461 &flushDwParams));
462
463 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
464 if (m_osInterface->bTagResourceSync)
465 {
466 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
467 &cmdBuffer,
468 &syncParams));
469 }
470
471 if (m_statusQueryReportingEnabled)
472 {
473 CodechalDecodeStatusReport decodeStatusReport;
474 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
475 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
476 decodeStatusReport.m_currDecodedPicRes = m_destSurface.OsResource;
477
478 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
479 decodeStatusReport,
480 &cmdBuffer));
481 }
482
483 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
484 &cmdBuffer,
485 nullptr));
486
487 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
488
489 CODECHAL_DEBUG_TOOL(
490 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
491 &cmdBuffer,
492 CODECHAL_NUM_MEDIA_STATES,
493 "_DEC"));
494 )
495
496 if (m_copiedDataBufferInUse)
497 {
498 //Sync up complete frame
499 syncParams = g_cInitSyncParams;
500 syncParams.GpuContext = m_videoContextForWa;
501 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
502
503 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(
504 m_osInterface,
505 &syncParams));
506
507 syncParams = g_cInitSyncParams;
508 syncParams.GpuContext = m_videoContext;
509 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
510
511 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(
512 m_osInterface,
513 &syncParams));
514 }
515
516 if ( MOS_VE_SUPPORTED(m_osInterface))
517 {
518 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, true);
519 }
520
521 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
522
523 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
524 m_osInterface,
525 &cmdBuffer,
526 m_videoContextUsesNullHw));
527
528 CODECHAL_DEBUG_TOOL(
529 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
530
531 if (m_statusQueryReportingEnabled)
532 {
533 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
534 m_videoContextUsesNullHw));
535 }
536
537 // Set output surface layout
538 SetOutputSurfaceLayout(&m_decodeParams.m_outputSurfLayout);
539
540 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
541 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(
542 m_osInterface,
543 &syncParams));
544
545 CODECHAL_DEBUG_TOOL(
546 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
547 &m_destSurface,
548 CodechalDbgAttr::attrDecodeOutputSurface,
549 "DstSurf"));)
550 return eStatus;
551
552 }
553
554 MOS_STATUS CodechalDecodeJpegG11::AllocateStandard(
555 CodechalSetting * settings)
556 {
557 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
558
559 CODECHAL_DECODE_FUNCTION_ENTER;
560
561 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
562
563 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeJpeg::AllocateStandard(settings));
564
565 if ( MOS_VE_SUPPORTED(m_osInterface))
566 {
567 static_cast<MhwVdboxMfxInterfaceG11*>(m_mfxInterface)->DisableScalabilitySupport();
568
569 //single pipe VE initialize
570 m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
571 CODECHAL_DECODE_CHK_NULL_RETURN(m_veState);
572 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState));
573 }
574
575 return eStatus;
576 }
577
578 CodechalDecodeJpegG11::CodechalDecodeJpegG11(
579 CodechalHwInterface *hwInterface,
580 CodechalDebugInterface* debugInterface,
581 PCODECHAL_STANDARD_INFO standardInfo) :
582 CodechalDecodeJpeg(hwInterface, debugInterface, standardInfo)
583 {
584 CODECHAL_DECODE_FUNCTION_ENTER;
585
586 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
587
588 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
589 }
590