Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_decode_jpeg_g12.cpp

raw
1 /*
2 * Copyright (c) 2017-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_g12.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_g12.h"
30 #include "mhw_vdbox_mfx_g12_X.h"
31 #include "codechal_mmc_decode_jpeg_g12.h"
32 #include "codechal_decode_sfc_jpeg_g12.h"
33 #include "hal_oca_interface.h"
34
35
36 CodechalDecodeJpegG12::~CodechalDecodeJpegG12()
37 {
38 CODECHAL_DECODE_FUNCTION_ENTER;
39
40 if (m_veState != nullptr)
41 {
42 MOS_FreeMemAndSetNull(m_veState);
43 m_veState = nullptr;
44 }
45 }
46
47 MOS_STATUS CodechalDecodeJpegG12::InitMmcState()
48 {
49 m_mmc = MOS_New(CodechalMmcDecodeJpegG12, m_hwInterface, this);
50 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
51
52 return MOS_STATUS_SUCCESS;
53 }
54
55 #ifdef _DECODE_PROCESSING_SUPPORTED
56 MOS_STATUS CodechalDecodeJpegG12::InitSfcState()
57 {
58 m_sfcState = MOS_New(CodechalJpegSfcStateG12);
59 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
60 return MOS_STATUS_SUCCESS;
61 }
62 #endif
63
64 MOS_STATUS CodechalDecodeJpegG12::SetGpuCtxCreatOption(
65 CodechalSetting *codecHalSetting)
66 {
67 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
68
69 CODECHAL_DECODE_FUNCTION_ENTER;
70
71 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
72 {
73 CodechalDecode::SetGpuCtxCreatOption(codecHalSetting);
74 }
75 else
76 {
77 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
78 bool sfcInUse = codecHalSetting->sfcInUseHinted && IsSfcInUse(codecHalSetting);
79 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_ConstructParmsForGpuCtxCreation(
80 m_veState,
81 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt,
82 sfcInUse));
83 }
84
85 return eStatus;
86 }
87
88 MOS_STATUS CodechalDecodeJpegG12::SetFrameStates()
89 {
90 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
91
92 CODECHAL_DECODE_FUNCTION_ENTER;
93
94 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeJpeg::SetFrameStates());
95
96 if (MOS_VE_SUPPORTED(m_osInterface) && !MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
97 {
98 MOS_VIRTUALENGINE_SET_PARAMS vesetParams;
99
100 MOS_ZeroMemory(&vesetParams, sizeof(vesetParams));
101 #ifdef _DECODE_PROCESSING_SUPPORTED
102 vesetParams.bSFCInUse = m_sfcState->m_sfcPipeOut;
103 #else
104 vesetParams.bSFCInUse = false;
105 #endif
106 vesetParams.bNeedSyncWithPrevious = true;
107 vesetParams.bSameEngineAsLastSubmission = false;
108 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_SetHintParams(
109 m_veState,
110 &vesetParams));
111 }
112
113 return eStatus;
114 }
115
116 MOS_STATUS CodechalDecodeJpegG12::DecodeStateLevel()
117 {
118 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
119
120 CODECHAL_DECODE_FUNCTION_ENTER;
121
122 // To WA invalid aux data caused HW issue when MMC on
123 // Add disable Clear CCS WA due to green corruption issue
124 if (m_mmc->IsMmcEnabled() && !Mos_ResourceIsNull(&m_destSurface.OsResource) &&
125 m_destSurface.OsResource.bConvertedFromDDIResource)
126 {
127 if (MEDIA_IS_WA(m_waTable, Wa_1408785368) || MEDIA_IS_WA(m_waTable, Wa_22010493002) && (!MEDIA_IS_WA(m_waTable, WaDisableClearCCS)))
128 {
129 CODECHAL_DECODE_VERBOSEMESSAGE("Clear CCS by VE resolve before frame %d submission", m_frameNum);
130 CODECHAL_DECODE_CHK_STATUS_RETURN(static_cast<CodecHalMmcStateG12 *>(m_mmc)->ClearAuxSurf(
131 this, m_miInterface, &m_destSurface.OsResource, m_veState));
132 }
133 }
134
135 MHW_VDBOX_JPEG_DECODE_PIC_STATE jpegPicState;
136 jpegPicState.dwOutputFormat = m_decodeParams.m_destSurface->Format;
137
138 #ifdef _DECODE_PROCESSING_SUPPORTED
139 if (m_sfcState->m_sfcPipeOut)
140 {
141 jpegPicState.dwOutputFormat = m_sfcState->m_sfcInSurface.Format;
142 }
143 #endif
144
145 //Three new formats from HSW C0,HSW ULT can only be supported in specific conditions.
146 if (jpegPicState.dwOutputFormat == Format_NV12 ||
147 jpegPicState.dwOutputFormat == Format_YUY2 ||
148 jpegPicState.dwOutputFormat == Format_UYVY)
149 {
150 //Only interleaved single scan are supported.
151 if (m_jpegPicParams->m_totalScans != 1 ||
152 m_jpegPicParams->m_interleavedData == 0)
153 {
154 return MOS_STATUS_UNKNOWN;
155 }
156
157 switch (m_jpegPicParams->m_chromaType)
158 {
159 case jpegYUV420:
160 case jpegYUV422H2Y:
161 case jpegYUV422H4Y:
162 break;
163 case jpegYUV422V2Y:
164 case jpegYUV422V4Y:
165 if (jpegPicState.dwOutputFormat == Format_NV12)
166 {
167 break;
168 }
169 default:
170 return MOS_STATUS_UNKNOWN;
171 }
172 }
173
174 MOS_COMMAND_BUFFER cmdBuffer;
175 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
176 m_osInterface,
177 &cmdBuffer,
178 0));
179
180 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
181 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
182
183 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
184 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
185 forceWakeupParams.bMFXPowerWellControl = true;
186 forceWakeupParams.bMFXPowerWellControlMask = true;
187 forceWakeupParams.bHEVCPowerWellControl = false;
188 forceWakeupParams.bHEVCPowerWellControlMask = true;
189 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
190 &cmdBuffer,
191 &forceWakeupParams));
192
193 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
194 &cmdBuffer, true));
195
196 // Set PIPE_MODE_SELECT
197 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
198 pipeModeSelectParams.Mode = CODECHAL_DECODE_MODE_JPEG;
199 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
200 pipeModeSelectParams.bDeblockerStreamOutEnable = false;
201 pipeModeSelectParams.bPostDeblockOutEnable = false;
202 pipeModeSelectParams.bPreDeblockOutEnable = true;
203
204 // Set CMD_MFX_SURFACE_STATE
205 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
206 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
207 surfaceParams.Mode = CODECHAL_DECODE_MODE_JPEG;
208 surfaceParams.psSurface = &m_destSurface;
209 surfaceParams.ChromaType = m_jpegPicParams->m_chromaType;
210
211 #ifdef _DECODE_PROCESSING_SUPPORTED
212 if (m_sfcState->m_sfcPipeOut)
213 {
214 surfaceParams.psSurface = &m_sfcState->m_sfcInSurface;
215 }
216 #endif
217
218 // Set MFX_PIPE_BUF_ADDR_STATE_CMD
219 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
220 pipeBufAddrParams.Mode = CODECHAL_DECODE_MODE_JPEG;
221 // Predeblock surface is the same as destination surface here because there is no deblocking for JPEG
222 pipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
223
224 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));
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_mmc->SetSurfaceState(&surfaceParams)); //class CodechalMmcDecodeJpegG12
272
273 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(
274 &cmdBuffer,
275 &surfaceParams));
276
277 // MFX_PIPE_BUF_ADDR_STATE_CMD
278 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(
279 &cmdBuffer,
280 &pipeBufAddrParams));
281
282 // MFX_IND_OBJ_BASE_ADDR_STATE_CMD
283 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(
284 &cmdBuffer,
285 &indObjBaseAddrParams));
286
287 // MFX_JPEG_PIC_STATE_CMD
288 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegPicCmd(
289 &cmdBuffer,
290 &jpegPicState));
291
292 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
293
294 return eStatus;
295 }
296
297 MOS_STATUS CodechalDecodeJpegG12::DecodePrimitiveLevel()
298 {
299 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
300
301 CODECHAL_DECODE_FUNCTION_ENTER;
302
303 // if the bitstream is not complete, don't do any decoding work.
304 if (m_incompletePicture)
305 {
306 return MOS_STATUS_SUCCESS;
307
308 }
309
310 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
311
312 MOS_COMMAND_BUFFER cmdBuffer;
313 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
314 m_osInterface,
315 &cmdBuffer,
316 0));
317
318 // MFX_QM_STATE_CMD
319 MHW_VDBOX_QM_PARAMS qmParams;
320 MOS_ZeroMemory(&qmParams, sizeof(qmParams));
321 qmParams.Standard = CODECHAL_JPEG;
322 qmParams.pJpegQuantMatrix = m_jpegQMatrix;
323
324 // Swapping QM(x,y) to QM(y,x) for 90/270 degree rotation
325 if ((m_jpegPicParams->m_rotation == jpegRotation90) ||
326 (m_jpegPicParams->m_rotation == jpegRotation270))
327 {
328 qmParams.bJpegQMRotation = true;
329 }
330 else
331 {
332 qmParams.bJpegQMRotation = false;
333 }
334
335 for (uint16_t scanCount = 0; scanCount < m_jpegPicParams->m_numCompInFrame; scanCount++)
336 {
337 // Using scanCount here because the same command is used for JPEG decode and encode
338 uint32_t quantTableSelector = m_jpegPicParams->m_quantTableSelector[scanCount];
339 if (quantTableSelector >= JPEG_MAX_NUM_OF_QUANTMATRIX)
340 {
341 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported QuantTableSelector in JPEG Picture parameter.");
342 return MOS_STATUS_INVALID_PARAMETER;
343 }
344 qmParams.pJpegQuantMatrix->m_jpegQMTableType[quantTableSelector] = scanCount;
345 qmParams.JpegQMTableSelector = quantTableSelector;
346 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(
347 &cmdBuffer,
348 &qmParams));
349 }
350
351 uint32_t dcCurHuffTblIndex[2] = { 0xff, 0xff };
352 uint32_t acCurHuffTblIndex[2] = { 0xff, 0xff };
353
354 for (uint16_t scanCount = 0; scanCount < m_jpegScanParams->NumScans; scanCount++)
355 {
356 // MFX_JPEG_HUFF_TABLE
357 uint16_t numComponents = m_jpegScanParams->ScanHeader[scanCount].NumComponents;
358 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
359 {
360 // Determine which huffman table we will be writing to
361 // For gray image, componentIdentifier[jpegComponentU] and componentIdentifier[jpegComponentV] are initialized to 0,
362 // and when componentSelector[scanComponent] is equal 0, variable huffTableID is set to 1, and wrong Huffman table is used,
363 // so it is more reasonable to use componentIdentifier[jpegComponentY] to determine which huffman table we will be writing to.
364 uint8_t componentSelector =
365 m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
366 uint16_t huffTableID = 0;
367 if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
368 {
369 huffTableID = 0;
370 }
371 else
372 {
373 huffTableID = 1;
374 }
375
376 int32_t acTableSelector =
377 m_jpegScanParams->ScanHeader[scanCount].AcHuffTblSelector[scanComponent];
378 int32_t dcTableSelector =
379 m_jpegScanParams->ScanHeader[scanCount].DcHuffTblSelector[scanComponent];
380
381 // Send the huffman table state command only if the table changed
382 if ((dcTableSelector != dcCurHuffTblIndex[huffTableID]) ||
383 (acTableSelector != acCurHuffTblIndex[huffTableID]))
384 {
385 MHW_VDBOX_HUFF_TABLE_PARAMS huffmanTableParams;
386 MOS_ZeroMemory(&huffmanTableParams, sizeof(huffmanTableParams));
387
388 huffmanTableParams.HuffTableID = huffTableID;
389 if (acTableSelector >= JPEG_MAX_NUM_HUFF_TABLE_INDEX || dcTableSelector >= JPEG_MAX_NUM_HUFF_TABLE_INDEX)
390 return MOS_STATUS_INVALID_PARAMETER;
391
392 huffmanTableParams.pACBits = &m_jpegHuffmanTable->HuffTable[acTableSelector].AC_BITS[0];
393 huffmanTableParams.pDCBits = &m_jpegHuffmanTable->HuffTable[dcTableSelector].DC_BITS[0];
394 huffmanTableParams.pACValues = &m_jpegHuffmanTable->HuffTable[acTableSelector].AC_HUFFVAL[0];
395 huffmanTableParams.pDCValues = &m_jpegHuffmanTable->HuffTable[dcTableSelector].DC_HUFFVAL[0];
396
397 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegHuffTableCmd(
398 &cmdBuffer,
399 &huffmanTableParams));
400
401 // Set the current huffman table indices for the next scan
402 dcCurHuffTblIndex[huffTableID] = dcTableSelector;
403 acCurHuffTblIndex[huffTableID] = acTableSelector;
404 }
405 }
406
407 MHW_VDBOX_JPEG_BSD_PARAMS jpegBsdObject;
408 MOS_ZeroMemory(&jpegBsdObject, sizeof(jpegBsdObject));
409
410 // MFX_JPEG_BSD_OBJECT
411 jpegBsdObject.dwIndirectDataLength = m_jpegScanParams->ScanHeader[scanCount].DataLength;
412 jpegBsdObject.dwDataStartAddress = m_jpegScanParams->ScanHeader[scanCount].DataOffset;
413 jpegBsdObject.dwScanHorizontalPosition = m_jpegScanParams->ScanHeader[scanCount].ScanHoriPosition;
414 jpegBsdObject.dwScanVerticalPosition = m_jpegScanParams->ScanHeader[scanCount].ScanVertPosition;
415 jpegBsdObject.bInterleaved = (numComponents > 1) ? 1 : 0;
416 jpegBsdObject.dwMCUCount = m_jpegScanParams->ScanHeader[scanCount].MCUCount;
417 jpegBsdObject.dwRestartInterval = m_jpegScanParams->ScanHeader[scanCount].RestartInterval;
418
419 uint16_t scanComponentIndex = 0;
420
421 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
422 {
423 uint8_t componentSelector =
424 m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
425
426 if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
427 {
428 scanComponentIndex = 0;
429 }
430 else if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentU])
431 {
432 scanComponentIndex = 1;
433 }
434 else if (componentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentV])
435 {
436 scanComponentIndex = 2;
437 }
438 // Add logic for component identifier JPEG_A
439
440 jpegBsdObject.sScanComponent |= (1 << scanComponentIndex);
441 }
442
443 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegBsdObjCmd(
444 &cmdBuffer,
445 &jpegBsdObject));
446 }
447
448 // Check if destination surface needs to be synchronized
449 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
450 syncParams.GpuContext = m_videoContext;
451 syncParams.presSyncResource = &m_destSurface.OsResource;
452 syncParams.bReadOnly = false;
453 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
454 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
455
456 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
457 m_osInterface,
458 &syncParams));
459 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
460 m_osInterface,
461 &syncParams));
462
463 // Update the resource tag (s/w tag) for On-Demand Sync
464 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
465
466 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
467 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
468 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
469 &cmdBuffer,
470 &flushDwParams));
471
472 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
473 if (m_osInterface->bTagResourceSync)
474 {
475 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
476 &cmdBuffer,
477 &syncParams));
478 }
479
480 if (m_statusQueryReportingEnabled)
481 {
482 CodechalDecodeStatusReport decodeStatusReport;
483 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
484 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
485 decodeStatusReport.m_currDecodedPicRes = m_destSurface.OsResource;
486
487 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
488 decodeStatusReport,
489 &cmdBuffer));
490 }
491
492 #if (_DEBUG || _RELEASE_INTERNAL)
493 uint32_t curIdx = (GetDecodeStatusBuf()->m_currIndex + CODECHAL_DECODE_STATUS_NUM - 1) % CODECHAL_DECODE_STATUS_NUM;
494 uint32_t frameCrcOffset = curIdx * sizeof(CodechalDecodeStatus) + GetDecodeStatusBuf()->m_decFrameCrcOffset + sizeof(uint32_t) * 2;
495 std::vector<MOS_RESOURCE> vSemaResource{GetDecodeStatusBuf()->m_statusBuffer};
496 m_debugInterface->DetectCorruptionHw(m_hwInterface, &m_frameCountTypeBuf, curIdx, frameCrcOffset, vSemaResource, &cmdBuffer, m_frameNum);
497 #endif
498
499 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
500 &cmdBuffer,
501 nullptr));
502
503 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
504
505 CODECHAL_DEBUG_TOOL(
506 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
507 &cmdBuffer,
508 CODECHAL_NUM_MEDIA_STATES,
509 "_JPEG_DECODE_0"));
510 )
511
512 if (m_copiedDataBufferInUse)
513 {
514 //Sync up complete frame
515 syncParams = g_cInitSyncParams;
516 syncParams.GpuContext = m_videoContextForWa;
517 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
518
519 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(
520 m_osInterface,
521 &syncParams));
522
523 syncParams = g_cInitSyncParams;
524 syncParams.GpuContext = m_videoContext;
525 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
526
527 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(
528 m_osInterface,
529 &syncParams));
530 }
531
532 if ( MOS_VE_SUPPORTED(m_osInterface))
533 {
534 CodecHalDecodeSinglePipeVE_PopulateHintParams(m_veState, &cmdBuffer, false);
535 }
536
537 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
538
539 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
540 m_osInterface,
541 &cmdBuffer,
542 m_videoContextUsesNullHw));
543
544 CODECHAL_DEBUG_TOOL(
545 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
546
547 if (m_statusQueryReportingEnabled)
548 {
549 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
550 m_videoContextUsesNullHw));
551 }
552
553 // Set output surface layout
554 SetOutputSurfaceLayout(&m_decodeParams.m_outputSurfLayout);
555
556 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
557 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(
558 m_osInterface,
559 &syncParams));
560
561 CODECHAL_DEBUG_TOOL(
562 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
563 &m_destSurface,
564 CodechalDbgAttr::attrDecodeOutputSurface,
565 "DstSurf"));)
566 return eStatus;
567 }
568
569 MOS_STATUS CodechalDecodeJpegG12::AllocateStandard(
570 CodechalSetting * settings)
571 {
572 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
573
574 CODECHAL_DECODE_FUNCTION_ENTER;
575
576 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
577
578 CODECHAL_DECODE_CHK_STATUS_RETURN(CodechalDecodeJpeg::AllocateStandard(settings));
579
580 // To WA invalid aux data caused HW issue when MMC on
581 // Add disable Clear CCS WA due to green corruption issue
582 if (m_mmc->IsMmcEnabled())
583 {
584 if (MEDIA_IS_WA(m_waTable, Wa_1408785368) || MEDIA_IS_WA(m_waTable, Wa_22010493002) && (!MEDIA_IS_WA(m_waTable, WaDisableClearCCS)))
585 {
586 MHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams;
587
588 //Add HUC STATE Commands
589 m_hwInterface->GetHucStateCommandSize(
590 CODECHAL_DECODE_MODE_JPEG,
591 &m_HucStateCmdBufferSizeNeeded,
592 &m_HucPatchListSizeNeeded,
593 &stateCmdSizeParams);
594 }
595 }
596
597 if ( MOS_VE_SUPPORTED(m_osInterface))
598 {
599 static_cast<MhwVdboxMfxInterfaceG12*>(m_mfxInterface)->DisableScalabilitySupport();
600
601 //single pipe VE initialize
602 m_veState = (PCODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_DECODE_SINGLEPIPE_VIRTUALENGINE_STATE));
603 CODECHAL_DECODE_CHK_NULL_RETURN(m_veState);
604 CODECHAL_DECODE_CHK_STATUS_RETURN(CodecHalDecodeSinglePipeVE_InitInterface(m_osInterface, m_veState));
605 }
606
607 return eStatus;
608 }
609
610 CodechalDecodeJpegG12::CodechalDecodeJpegG12(
611 CodechalHwInterface *hwInterface,
612 CodechalDebugInterface* debugInterface,
613 PCODECHAL_STANDARD_INFO standardInfo) :
614 CodechalDecodeJpeg(hwInterface, debugInterface, standardInfo)
615 {
616 CODECHAL_DECODE_FUNCTION_ENTER;
617
618 CODECHAL_DECODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
619
620 m_osInterface->pfnVirtualEngineSupported(m_osInterface, true, true);
621 }
622
623 void CodechalDecodeJpegG12::CalcRequestedSpace(
624 uint32_t &requestedSize,
625 uint32_t &additionalSizeNeeded,
626 uint32_t &requestedPatchListSize)
627 {
628 CODECHAL_DECODE_FUNCTION_ENTER;
629
630 requestedSize = m_commandBufferSizeNeeded + m_HucStateCmdBufferSizeNeeded +
631 (m_standardDecodeSizeNeeded * (m_decodeParams.m_numSlices + 1));
632 requestedPatchListSize = m_commandPatchListSizeNeeded + m_HucPatchListSizeNeeded +
633 (m_standardDecodePatchListSizeNeeded * (m_decodeParams.m_numSlices + 1));
634 additionalSizeNeeded = COMMAND_BUFFER_RESERVED_SPACE;
635 }
636