Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_decode_jpeg.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.cpp
24 //! \brief Implements the decode interface extension for JPEG.
25 //! \details Implements all functions required by CodecHal for JPEG decoding.
26 //!
27
28 #include "codechal_decode_jpeg.h"
29 #include "codechal_mmc_decode_jpeg.h"
30 #include "hal_oca_interface.h"
31 #include "mos_interface.h"
32 #if USE_CODECHAL_DEBUG_TOOL
33 #include <sstream>
34 #include "codechal_debug.h"
35 #endif
36
37 #define CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE 8
38 #define CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X2 16
39 #define CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X4 32
40 #define CODECHAL_DECODE_JPEG_ERR_FRAME_WIDTH 32
41 #define CODECHAL_DECODE_JPEG_ERR_FRAME_HEIGHT 32
42
43 CodechalDecodeJpeg::~CodechalDecodeJpeg()
44 {
45 CODECHAL_DECODE_FUNCTION_ENTER;
46
47 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObjectWaContextInUse);
48 m_osInterface->pfnDestroySyncResource(m_osInterface, &m_resSyncObjectVideoContextInUse);
49
50 if (!Mos_ResourceIsNull(&m_resCopiedDataBuffer))
51 {
52 m_osInterface->pfnFreeResource(
53 m_osInterface,
54 &m_resCopiedDataBuffer);
55 }
56
57 #ifdef _DECODE_PROCESSING_SUPPORTED
58 if (m_sfcState)
59 {
60 MOS_Delete(m_sfcState);
61 m_sfcState = nullptr;
62 }
63 #endif
64
65 return;
66 }
67
68 CodechalDecodeJpeg::CodechalDecodeJpeg(
69 CodechalHwInterface * hwInterface,
70 CodechalDebugInterface *debugInterface,
71 PCODECHAL_STANDARD_INFO standardInfo) : CodechalDecode(hwInterface, debugInterface, standardInfo),
72 m_dataSize(0),
73 m_dataOffset(0),
74 m_copiedDataBufferSize(0),
75 m_nextCopiedDataOffset(0),
76 m_totalDataLength(0),
77 m_preNumScans(0),
78 m_copiedDataBufferInUse(false)
79
80 {
81 CODECHAL_DECODE_FUNCTION_ENTER;
82
83 MOS_ZeroMemory(&m_resCopiedDataBuffer, sizeof(m_resCopiedDataBuffer));
84 MOS_ZeroMemory(&m_destSurface, sizeof(m_destSurface));
85 MOS_ZeroMemory(&m_jpegHuffmanTable, sizeof(m_jpegHuffmanTable));
86 MOS_ZeroMemory(&m_resDataBuffer, sizeof(m_resDataBuffer));
87 MOS_ZeroMemory(&m_resSyncObjectWaContextInUse, sizeof(m_resSyncObjectWaContextInUse));
88 MOS_ZeroMemory(&m_resSyncObjectVideoContextInUse, sizeof(m_resSyncObjectVideoContextInUse));
89 #if (_DEBUG || _RELEASE_INTERNAL)
90 m_reportFrameCrc = true;
91 #endif
92 m_hwInterface = hwInterface;
93 }
94
95 MOS_STATUS CodechalDecodeJpeg::InitializeBeginFrame()
96 {
97 CODECHAL_DECODE_FUNCTION_ENTER;
98
99 m_incompletePicture = false;
100 m_incompleteJpegScan = false;
101 m_copiedDataBufferInUse = false;
102 m_nextCopiedDataOffset = 0;
103 m_totalDataLength = 0;
104 m_preNumScans = 0;
105
106 return MOS_STATUS_SUCCESS;
107 }
108
109 MOS_STATUS CodechalDecodeJpeg::CopyDataSurface()
110 {
111 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
112
113 CODECHAL_DECODE_FUNCTION_ENTER;
114
115 if (m_hwInterface->m_noHuC)
116 {
117 uint32_t alignedSize = MOS_ALIGN_CEIL(m_dataSize, 16); // 16 byte aligned
118 CodechalDataCopyParams dataCopyParams;
119 MOS_ZeroMemory(&dataCopyParams, sizeof(CodechalDataCopyParams));
120 dataCopyParams.srcResource = &m_resDataBuffer;
121 dataCopyParams.srcSize = alignedSize;
122 dataCopyParams.srcOffset = 0;
123 dataCopyParams.dstResource = &m_resCopiedDataBuffer;
124 dataCopyParams.dstSize = alignedSize;
125 dataCopyParams.dstOffset = m_nextCopiedDataOffset;
126
127 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->CopyDataSourceWithDrv(
128 &dataCopyParams));
129
130 m_nextCopiedDataOffset += MOS_ALIGN_CEIL(m_dataSize, MHW_CACHELINE_SIZE); // 64-byte aligned
131 return MOS_STATUS_SUCCESS;
132 }
133
134 CODECHAL_DECODE_CHK_COND_RETURN(
135 ((m_nextCopiedDataOffset + m_dataSize) > m_copiedDataBufferSize),
136 "Copied data buffer is not large enough.");
137
138 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
139 m_osInterface,
140 m_videoContextForWa));
141 m_osInterface->pfnResetOsStates(m_osInterface);
142
143 m_osInterface->pfnSetPerfTag(
144 m_osInterface,
145 (uint16_t)(((m_mode << 4) & 0xF0) | COPY_TYPE));
146 m_osInterface->pfnResetPerfBufferID(m_osInterface);
147
148 MOS_COMMAND_BUFFER cmdBuffer;
149 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
150 m_osInterface,
151 &cmdBuffer,
152 0));
153
154 // Send command buffer header at the beginning (OS dependent)
155 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
156 &cmdBuffer,
157 false));
158
159 // Use huc stream out to do the copy
160 CODECHAL_DECODE_CHK_STATUS_RETURN(HucCopy(
161 &cmdBuffer, // pCmdBuffer
162 &m_resDataBuffer, // presSrc
163 &m_resCopiedDataBuffer, // presDst
164 m_dataSize, // u32CopyLength
165 0, // u32CopyInputOffset
166 m_nextCopiedDataOffset)); // u32CopyOutputOffset
167
168 m_nextCopiedDataOffset += MOS_ALIGN_CEIL(m_dataSize, MHW_CACHELINE_SIZE);
169
170 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
171 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
172 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
173 &cmdBuffer,
174 &flushDwParams));
175
176 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
177 &cmdBuffer,
178 nullptr));
179
180 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
181
182 if (!m_incompletePicture)
183 {
184 MOS_SYNC_PARAMS syncParams;
185 syncParams = g_cInitSyncParams;
186 syncParams.GpuContext = m_videoContext;
187 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
188
189 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(
190 m_osInterface,
191 &syncParams));
192
193 syncParams = g_cInitSyncParams;
194 syncParams.GpuContext = m_videoContextForWa;
195 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
196
197 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(
198 m_osInterface,
199 &syncParams));
200 }
201
202 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
203 m_osInterface,
204 &cmdBuffer,
205 m_videoContextForWaUsesNullHw));
206
207 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSetGpuContext(
208 m_osInterface,
209 m_videoContext));
210
211 return eStatus;
212 }
213
214 MOS_STATUS CodechalDecodeJpeg::CheckAndCopyIncompleteBitStream()
215 {
216 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
217
218 uint32_t maxBufferSize =
219 MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth * m_jpegPicParams->m_frameHeight * 3, 64);
220
221 if (m_jpegPicParams->m_totalScans == 1) // Single scan
222 {
223 if (!m_incompleteJpegScan) // The first bitstream buffer
224 {
225 m_totalDataLength =
226 m_jpegScanParams->ScanHeader[0].DataOffset + m_jpegScanParams->ScanHeader[0].DataLength;
227
228 if (m_dataSize < m_totalDataLength) // if the bitstream data is incomplete
229 {
230 CODECHAL_DECODE_CHK_COND_RETURN(
231 m_totalDataLength > maxBufferSize,
232 "The bitstream size exceeds the copied data buffer size.");
233
234 CODECHAL_DECODE_CHK_COND_RETURN(
235 m_dataSize & 0x3f,
236 "The data size of the incomplete bitstream is not aligned with 64.");
237
238 // Allocate the copy data buffer.
239 if (Mos_ResourceIsNull(&m_resCopiedDataBuffer))
240 {
241 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
242 &m_resCopiedDataBuffer,
243 maxBufferSize,
244 "CopiedDataBuffer"),
245 "Failed to allocate copied data Buffer.");
246 }
247 m_copiedDataBufferSize = maxBufferSize;
248
249 // copy the bitstream buffer
250 if (m_dataSize)
251 {
252 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface());
253 m_copiedDataBufferInUse = true;
254 }
255
256 m_incompleteJpegScan = true;
257 m_incompletePicture = true;
258 }
259 else //the bitstream data is complete
260 {
261 m_incompleteJpegScan = false;
262 m_incompletePicture = false;
263 }
264 }
265 else // the next bitstream buffers
266 {
267 CODECHAL_DECODE_CHK_COND_RETURN(
268 m_nextCopiedDataOffset + m_dataSize > m_copiedDataBufferSize,
269 "The bitstream size exceeds the copied data buffer size.")
270
271 CODECHAL_DECODE_CHK_COND_RETURN(
272 (m_nextCopiedDataOffset + m_dataSize < m_totalDataLength) && (m_dataSize & 0x3f),
273 "The data size of the incomplete bitstream is not aligned with 64.");
274
275 // copy the bitstream
276 if (m_dataSize)
277 {
278 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface());
279 }
280
281 if (m_nextCopiedDataOffset >= m_totalDataLength)
282 {
283 m_incompleteJpegScan = false;
284 m_incompletePicture = false;
285 }
286
287 }
288 }
289 else // multi-scans
290 {
291 if (!m_incompleteJpegScan) // The first bitstream buffer of each scan;
292 {
293 for (uint32_t idxScan = m_preNumScans; idxScan < m_jpegScanParams->NumScans; idxScan++)
294 {
295 m_jpegScanParams->ScanHeader[idxScan].DataOffset += m_nextCopiedDataOffset; // modify the data offset for the new incoming scan data
296 }
297 m_totalDataLength = m_jpegScanParams->ScanHeader[m_jpegScanParams->NumScans - 1].DataOffset + m_jpegScanParams->ScanHeader[m_jpegScanParams->NumScans - 1].DataLength;
298 m_preNumScans = m_jpegScanParams->NumScans;
299
300 // judge whether the bitstream is complete in the first execute() call
301 if (IsFirstExecuteCall() &&
302 m_dataSize <= m_jpegScanParams->ScanHeader[0].DataOffset + m_jpegScanParams->ScanHeader[0].DataLength)
303 {
304 CODECHAL_DECODE_CHK_COND_RETURN(
305 (m_nextCopiedDataOffset + m_dataSize < m_totalDataLength) && (m_dataSize & 0x3f),
306 "The buffer size of the incomplete bitstream is not aligned with 64.");
307
308 // Allocate the copy data buffer.
309 if (Mos_ResourceIsNull(&m_resCopiedDataBuffer))
310 {
311 CODECHAL_DECODE_CHK_STATUS_MESSAGE_RETURN(AllocateBuffer(
312 &m_resCopiedDataBuffer,
313 maxBufferSize,
314 "CopiedDataBuffer"),
315 "Failed to allocate copied data Buffer.");
316 }
317 m_copiedDataBufferSize = maxBufferSize;
318
319 // copy the bitstream buffer
320 if (m_dataSize)
321 {
322 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface());
323 m_copiedDataBufferInUse = true;
324 }
325
326 m_incompleteJpegScan = m_nextCopiedDataOffset < m_totalDataLength;
327 m_incompletePicture = m_incompleteJpegScan || m_jpegScanParams->NumScans < m_jpegPicParams->m_totalScans;
328 }
329 else // the bitstream is complete
330 {
331 m_incompleteJpegScan = false;
332 if (m_jpegScanParams->NumScans == m_jpegPicParams->m_totalScans)
333 {
334 m_incompletePicture = false;
335 }
336 else
337 {
338 m_incompletePicture = true;
339 }
340 }
341 }
342 else //The next bitstream buffer of each scan
343 {
344 CODECHAL_DECODE_CHK_COND_RETURN(
345 m_nextCopiedDataOffset + m_dataSize > m_copiedDataBufferSize,
346 "The bitstream size exceeds the copied data buffer size.")
347
348 CODECHAL_DECODE_CHK_COND_RETURN(
349 (m_nextCopiedDataOffset + m_dataSize < m_totalDataLength) && (m_dataSize & 0x3f),
350 "The data size of the incomplete bitstream is not aligned with 64.");
351
352 // copy the bitstream buffer
353 if (m_dataSize)
354 {
355 CODECHAL_DECODE_CHK_STATUS_RETURN(CopyDataSurface());
356 }
357
358 if (m_nextCopiedDataOffset >= m_totalDataLength)
359 {
360 m_incompleteJpegScan = false;
361 if (m_jpegScanParams->NumScans >= m_jpegPicParams->m_totalScans)
362 {
363 m_incompletePicture = false;
364 }
365 }
366
367 }
368 }
369
370 return eStatus;
371 }
372
373 MOS_STATUS CodechalDecodeJpeg::CheckSupportedFormat(
374 PMOS_FORMAT format)
375 {
376 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
377
378 // App must use 420_OPAQUE as DecodeRT for other JPEG output formats except NV12 and YUY2 due to runtime
379 // restriction, so the real JPEG format is passed to driver in PPS data. The code here is just to get the real output format.
380 // On SKL+, app would use AYUV (instead of 420_OPAQUE) as DecodeRT for direct YUV to ARGB8888 conversion; in such case,
381 // real output format (ARGB8888) should also be from JPEG PPS; MSDK would handle the details of treating AYUV as ARGB.
382 if (*format == Format_420O || *format == Format_AYUV)
383 {
384 CODECHAL_DECODE_CHK_NULL_RETURN(m_osInterface);
385 *format = m_osInterface->pfnOsFmtToMosFmt(m_jpegPicParams->m_renderTargetFormat);
386 }
387
388 //No support for RGBP/BGRP channel swap or YUV/RGB conversion!
389 switch (*format)
390 {
391 case Format_BGRP:
392 if (m_jpegPicParams->m_chromaType == jpegRGB ||
393 m_jpegPicParams->m_chromaType == jpegYUV444)
394 {
395 eStatus = MOS_STATUS_PLATFORM_NOT_SUPPORTED;
396 }
397 break;
398 case Format_RGBP:
399 if (m_jpegPicParams->m_chromaType == jpegYUV444)
400 {
401 eStatus = MOS_STATUS_PLATFORM_NOT_SUPPORTED;
402 }
403 break;
404 case Format_Y416:
405 case Format_AYUV:
406 case Format_AUYV:
407 case Format_Y410:
408 if (m_jpegPicParams->m_chromaType == jpegRGB ||
409 m_jpegPicParams->m_chromaType == jpegBGR)
410 {
411 eStatus = MOS_STATUS_PLATFORM_NOT_SUPPORTED;
412 }
413 break;
414 default:
415 break;
416 }
417
418 return eStatus;
419 }
420
421 MOS_STATUS CodechalDecodeJpeg::SetFrameStates()
422 {
423 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
424
425 CODECHAL_DECODE_FUNCTION_ENTER;
426
427 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_destSurface);
428 CODECHAL_DECODE_CHK_NULL_RETURN(m_decodeParams.m_dataBuffer);
429
430 //Set wPerfType as I_TYPE so that PerTag can be recognized by performance reportor
431 m_perfType = I_TYPE;
432
433 m_dataSize = m_decodeParams.m_dataSize;
434 m_dataOffset = m_decodeParams.m_dataOffset;
435 m_resDataBuffer = *(m_decodeParams.m_dataBuffer);
436 m_jpegPicParams = (CodecDecodeJpegPicParams *)m_decodeParams.m_picParams;
437 m_jpegQMatrix = (CodecJpegQuantMatrix *)m_decodeParams.m_iqMatrixBuffer;
438 m_jpegHuffmanTable = (PCODECHAL_DECODE_JPEG_HUFFMAN_TABLE)m_decodeParams.m_huffmanTable;
439 m_jpegScanParams = (CodecDecodeJpegScanParameter *)m_decodeParams.m_sliceParams;
440
441 CODECHAL_DECODE_CHK_NULL_RETURN(m_jpegPicParams);
442
443 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckSupportedFormat(
444 &m_decodeParams.m_destSurface->Format));
445
446 m_hwInterface->GetCpInterface()->SetCpSecurityType();
447
448 if (IsFirstExecuteCall())
449 {
450 CODECHAL_DECODE_CHK_STATUS_RETURN(InitializeBeginFrame());
451 }
452
453 // Check whether the bitstream buffer is completed. If not, allocate a larger buffer and copy the bitstream.
454 CODECHAL_DECODE_CHK_STATUS_RETURN(CheckAndCopyIncompleteBitStream());
455
456 // if the bitstream is not completed, don't do any decoding work.
457 if (m_incompletePicture)
458 {
459 return MOS_STATUS_SUCCESS;
460 }
461
462 uint32_t widthAlign = 0;
463 uint32_t heightAlign = 0;
464
465 // Overwriting surface width and height of destination surface, so it comes from Picture Parameters struct
466 if (!m_jpegPicParams->m_interleavedData)
467 {
468 widthAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
469 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
470 }
471 else
472 {
473 switch (m_jpegPicParams->m_chromaType)
474 {
475 case jpegYUV400:
476 case jpegYUV444:
477 case jpegRGB:
478 case jpegBGR:
479 widthAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
480 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
481 break;
482 case jpegYUV422V2Y:
483 widthAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
484 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X2);
485 break;
486 case jpegYUV422H2Y:
487 widthAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X2);
488 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
489 break;
490 case jpegYUV411:
491 widthAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X4);
492 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE);
493 break;
494 default: // YUV422H_4Y, YUV422V_4Y & YUV420
495 widthAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameWidth, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X2);
496 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X2);
497 break;
498 }
499 }
500
501 //BDW has a limitation:Height should aligned by 16 when input is YUV422H_2Y and output is NV12.
502 if (MEDIA_IS_WA(m_waTable, WaJPEGHeightAlignYUV422H2YToNV12) &&
503 m_jpegPicParams->m_chromaType == jpegYUV422H2Y &&
504 m_decodeParams.m_destSurface->Format == Format_NV12)
505 {
506 heightAlign = MOS_ALIGN_CEIL(m_jpegPicParams->m_frameHeight, CODECHAL_DECODE_JPEG_BLOCK_ALIGN_SIZE_X2);
507 }
508
509 if ((m_jpegPicParams->m_rotation == jpegRotation90) || (m_jpegPicParams->m_rotation == jpegRotation270))
510 {
511 // Interchanging picture width and height for 90/270 degree rotation
512 m_decodeParams.m_destSurface->dwWidth = heightAlign;
513 m_decodeParams.m_destSurface->dwHeight = widthAlign;
514 }
515 else
516 {
517 m_decodeParams.m_destSurface->dwWidth = widthAlign;
518 m_decodeParams.m_destSurface->dwHeight = heightAlign;
519 }
520
521 m_destSurface = *(m_decodeParams.m_destSurface);
522 if (m_copiedDataBufferInUse)
523 {
524 m_resDataBuffer = m_resCopiedDataBuffer; // set resDataBuffer to copy data buffer
525 }
526
527 m_statusReportFeedbackNumber = m_jpegPicParams->m_statusReportFeedbackNumber;
528
529 #ifdef _DECODE_PROCESSING_SUPPORTED
530 m_sfcState->CheckAndInitialize(&m_destSurface, m_jpegPicParams);
531 #endif
532
533 CODECHAL_DEBUG_TOOL(
534 if (m_jpegPicParams) {
535 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpPicParams(m_jpegPicParams))
536 }
537
538 if (m_jpegScanParams) {
539 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpScanParams(m_jpegScanParams))
540 }
541
542 if (m_jpegHuffmanTable) {
543 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpHuffmanTable(m_jpegHuffmanTable))
544 }
545
546 if (m_jpegQMatrix) {
547 CODECHAL_DECODE_CHK_STATUS_RETURN(DumpIQParams(m_jpegQMatrix))
548 }
549
550 if (&(m_resDataBuffer)) {
551 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
552 &m_resDataBuffer,
553 CodechalDbgAttr::attrDecodeBitstream,
554 "_DEC",
555 (m_copiedDataBufferInUse ? m_nextCopiedDataOffset : m_dataSize),
556 0,
557 CODECHAL_NUM_MEDIA_STATES));
558 })
559
560 return eStatus;
561 }
562
563 MOS_STATUS CodechalDecodeJpeg::AllocateResources()
564 {
565 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
566
567 CODECHAL_DECODE_FUNCTION_ENTER;
568
569 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
570 m_osInterface,
571 &m_resSyncObjectWaContextInUse));
572 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnCreateSyncResource(
573 m_osInterface,
574 &m_resSyncObjectVideoContextInUse));
575
576 return eStatus;
577 }
578
579 void CodechalDecodeJpeg::SetOutputSurfaceLayout(
580 CodecDecodeJpegImageLayout *outputSurfLayout)
581 {
582 uint32_t ucbOffset = MOS_ALIGN_CEIL(m_destSurface.UPlaneOffset.iYOffset, MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY);
583 uint32_t vcrOffset = MOS_ALIGN_CEIL(m_destSurface.VPlaneOffset.iYOffset, MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY);
584
585 uint32_t ucbOffsetInBytes = ucbOffset * m_destSurface.dwPitch;
586 uint32_t vcrOffsetInBytes = vcrOffset * m_destSurface.dwPitch;
587
588 outputSurfLayout->m_pitch = m_destSurface.dwPitch;
589
590 for (uint32_t scanCount = 0; scanCount < m_jpegScanParams->NumScans; scanCount++)
591 {
592 for (uint32_t scanComponent = 0; scanComponent < m_jpegScanParams->ScanHeader[scanCount].NumComponents; scanComponent++)
593 {
594 if (m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent] == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
595 {
596 outputSurfLayout->m_componentDataOffset[jpegComponentY] = 0;
597 }
598 else if (m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent] == m_jpegPicParams->m_componentIdentifier[jpegComponentU])
599 {
600 outputSurfLayout->m_componentDataOffset[jpegComponentU] = ucbOffsetInBytes;
601 }
602 else if (m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent] == m_jpegPicParams->m_componentIdentifier[jpegComponentV])
603 {
604 outputSurfLayout->m_componentDataOffset[jpegComponentV] = vcrOffsetInBytes;
605 }
606 }
607 }
608 }
609
610 MOS_STATUS CodechalDecodeJpeg::DecodeStateLevel()
611 {
612 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
613
614 CODECHAL_DECODE_FUNCTION_ENTER;
615
616 MHW_VDBOX_JPEG_DECODE_PIC_STATE jpegPicState;
617 jpegPicState.dwOutputFormat = m_decodeParams.m_destSurface->Format;
618
619 #ifdef _DECODE_PROCESSING_SUPPORTED
620 if (m_sfcState->m_sfcPipeOut)
621 {
622 jpegPicState.dwOutputFormat = m_sfcState->m_sfcInSurface.Format;
623 }
624 #endif
625
626 //Three new formats from HSW C0,HSW ULT can only be supported in specific conditions.
627 if (jpegPicState.dwOutputFormat == Format_NV12 ||
628 jpegPicState.dwOutputFormat == Format_YUY2 ||
629 jpegPicState.dwOutputFormat == Format_UYVY)
630 {
631 //Only interleaved single scan are supported.
632 if (m_jpegPicParams->m_totalScans != 1 ||
633 m_jpegPicParams->m_interleavedData == 0)
634 {
635 return MOS_STATUS_UNKNOWN;
636 }
637
638 switch (m_jpegPicParams->m_chromaType)
639 {
640 case jpegYUV420:
641 case jpegYUV422H2Y:
642 case jpegYUV422H4Y:
643 break;
644 case jpegYUV422V2Y:
645 case jpegYUV422V4Y:
646 if (GFX_IS_GEN_8_OR_LATER(m_hwInterface->GetPlatform()) &&
647 jpegPicState.dwOutputFormat == Format_NV12)
648 {
649 break;
650 }
651 default:
652 return MOS_STATUS_UNKNOWN;
653 }
654 }
655
656 MOS_COMMAND_BUFFER cmdBuffer;
657 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
658 m_osInterface,
659 &cmdBuffer,
660 0));
661
662 auto mmioRegisters = m_hwInterface->GetMfxInterface()->GetMmioRegisters(m_vdboxIndex);
663 HalOcaInterface::On1stLevelBBStart(cmdBuffer, *m_osInterface->pOsContext, m_osInterface->CurrentGpuContextHandle, *m_miInterface, *mmioRegisters);
664
665 CODECHAL_DECODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
666 &cmdBuffer, true));
667
668 // Set PIPE_MODE_SELECT
669 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
670 pipeModeSelectParams.Mode = CODECHAL_DECODE_MODE_JPEG;
671 pipeModeSelectParams.bStreamOutEnabled = m_streamOutEnabled;
672 pipeModeSelectParams.bDeblockerStreamOutEnable = false;
673 pipeModeSelectParams.bPostDeblockOutEnable = false;
674 pipeModeSelectParams.bPreDeblockOutEnable = true;
675
676 // Set CMD_MFX_SURFACE_STATE
677 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
678 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
679 surfaceParams.Mode = CODECHAL_DECODE_MODE_JPEG;
680 surfaceParams.psSurface = &m_destSurface;
681 surfaceParams.ChromaType = m_jpegPicParams->m_chromaType;
682
683 #ifdef _DECODE_PROCESSING_SUPPORTED
684 if (m_sfcState->m_sfcPipeOut)
685 {
686 surfaceParams.psSurface = &m_sfcState->m_sfcInSurface;
687 }
688 #endif
689
690 // Set MFX_PIPE_BUF_ADDR_STATE_CMD
691 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
692 pipeBufAddrParams.Mode = CODECHAL_DECODE_MODE_JPEG;
693 // Predeblock surface is the same as destination surface here because there is no deblocking for JPEG
694 pipeBufAddrParams.psPreDeblockSurface = &m_destSurface;
695
696 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mmc->SetPipeBufAddr(&pipeBufAddrParams));
697
698 // Set MFX_IND_OBJ_BASE_ADDR_STATE_CMD
699 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
700 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
701 indObjBaseAddrParams.Mode = CODECHAL_DECODE_MODE_JPEG;
702 indObjBaseAddrParams.dwDataSize = m_copiedDataBufferInUse ? m_nextCopiedDataOffset : m_dataSize;
703 indObjBaseAddrParams.presDataBuffer = &m_resDataBuffer;
704
705 // Set MFX_JPEG_PIC_STATE_CMD
706 jpegPicState.pJpegPicParams = m_jpegPicParams;
707 if ((m_jpegPicParams->m_rotation == jpegRotation90) || (m_jpegPicParams->m_rotation == jpegRotation270))
708 {
709 jpegPicState.dwWidthInBlocks = (m_destSurface.dwHeight / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
710 jpegPicState.dwHeightInBlocks = (m_destSurface.dwWidth / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
711 }
712 else
713 {
714 jpegPicState.dwWidthInBlocks = (m_destSurface.dwWidth / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
715 jpegPicState.dwHeightInBlocks = (m_destSurface.dwHeight / CODECHAL_DECODE_JPEG_BLOCK_SIZE) - 1;
716 }
717
718 // Add commands to command buffer
719 // MI_FLUSH_DW command -> must be before to MFX_PIPE_MODE_SELECT
720 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
721 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
722 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
723 &cmdBuffer,
724 &flushDwParams));
725
726 if (m_statusQueryReportingEnabled)
727 {
728 CODECHAL_DECODE_CHK_STATUS_RETURN(StartStatusReport(
729 &cmdBuffer));
730 }
731
732 // MFX_PIPE_MODE_SELECT_CMD
733 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(
734 &cmdBuffer,
735 &pipeModeSelectParams));
736
737 #ifdef _DECODE_PROCESSING_SUPPORTED
738 // Output decode result through SFC
739 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->AddSfcCommands(&cmdBuffer));
740 #endif
741
742 // CMD_MFX_SURFACE_STATE
743 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(
744 &cmdBuffer,
745 &surfaceParams));
746
747 // MFX_PIPE_BUF_ADDR_STATE_CMD
748 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(
749 &cmdBuffer,
750 &pipeBufAddrParams));
751
752 // MFX_IND_OBJ_BASE_ADDR_STATE_CMD
753 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(
754 &cmdBuffer,
755 &indObjBaseAddrParams));
756
757 // MFX_JPEG_PIC_STATE_CMD
758 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegPicCmd(
759 &cmdBuffer,
760 &jpegPicState));
761
762 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
763
764 return eStatus;
765 }
766
767 MOS_STATUS CodechalDecodeJpeg::DecodePrimitiveLevel()
768 {
769 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
770
771 CODECHAL_DECODE_FUNCTION_ENTER;
772
773 // if the bitstream is not complete, don't do any decoding work.
774 if (m_incompletePicture)
775 {
776 return MOS_STATUS_SUCCESS;
777
778 }
779
780 MOS_COMMAND_BUFFER cmdBuffer;
781 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
782 m_osInterface,
783 &cmdBuffer,
784 0));
785
786 // MFX_QM_STATE_CMD
787 MHW_VDBOX_QM_PARAMS qmParams;
788 MOS_ZeroMemory(&qmParams, sizeof(qmParams));
789 qmParams.Standard = CODECHAL_JPEG;
790 qmParams.pJpegQuantMatrix = m_jpegQMatrix;
791
792 // Swapping QM(x,y) to QM(y,x) for 90/270 degree rotation
793 if ((m_jpegPicParams->m_rotation == jpegRotation90) ||
794 (m_jpegPicParams->m_rotation == jpegRotation270))
795 {
796 qmParams.bJpegQMRotation = true;
797 }
798 else
799 {
800 qmParams.bJpegQMRotation = false;
801 }
802
803 for (uint16_t scanCount = 0; scanCount < m_jpegPicParams->m_numCompInFrame; scanCount++)
804 {
805 // Using scanCount here because the same command is used for JPEG decode and encode
806 uint32_t quantTableSelector = m_jpegPicParams->m_quantTableSelector[scanCount];
807 if (quantTableSelector >= JPEG_MAX_NUM_OF_QUANTMATRIX)
808 {
809 CODECHAL_DECODE_ASSERTMESSAGE("Unsupported QuantTableSelector in JPEG Picture parameter.");
810 return MOS_STATUS_INVALID_PARAMETER;
811 }
812 qmParams.pJpegQuantMatrix->m_jpegQMTableType[quantTableSelector] = scanCount;
813 qmParams.JpegQMTableSelector = quantTableSelector;
814 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(
815 &cmdBuffer,
816 &qmParams));
817 }
818
819 uint32_t dcCurHuffTblIndex[2] = { 0xff, 0xff };
820 uint32_t acCurHuffTblIndex[2] = { 0xff, 0xff };
821
822 for (uint16_t scanCount = 0; scanCount < m_jpegScanParams->NumScans; scanCount++)
823 {
824 // MFX_JPEG_HUFF_TABLE
825 uint16_t numComponents = m_jpegScanParams->ScanHeader[scanCount].NumComponents;
826 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
827 {
828 // Determine which huffman table we will be writing to
829 // For gray image, componentIdentifier[jpegComponentU] and componentIdentifier[jpegComponentV] are initialized to 0,
830 // and when ComponentSelector[scanComponent] is equal 0, variable huffTableID is set to 1, and wrong Huffman table is used,
831 // so it is more reasonable to use componentIdentifier[jpegComponentY] to determine which huffman table we will be writing to.
832 uint8_t ComponentSelector =
833 m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
834 uint16_t huffTableID = 0;
835 if (ComponentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
836 {
837 huffTableID = 0;
838 }
839 else
840 {
841 huffTableID = 1;
842 }
843
844 uint32_t AcTableSelector =
845 m_jpegScanParams->ScanHeader[scanCount].AcHuffTblSelector[scanComponent];
846 uint32_t DcTableSelector =
847 m_jpegScanParams->ScanHeader[scanCount].DcHuffTblSelector[scanComponent];
848
849 // Send the huffman table state command only if the table changed
850 if ((DcTableSelector != dcCurHuffTblIndex[huffTableID]) ||
851 (AcTableSelector != acCurHuffTblIndex[huffTableID]))
852 {
853 MHW_VDBOX_HUFF_TABLE_PARAMS huffmanTableParams;
854 MOS_ZeroMemory(&huffmanTableParams, sizeof(huffmanTableParams));
855
856 huffmanTableParams.HuffTableID = huffTableID;
857
858 huffmanTableParams.pACBits = &m_jpegHuffmanTable->HuffTable[AcTableSelector].AC_BITS[0];
859 huffmanTableParams.pDCBits = &m_jpegHuffmanTable->HuffTable[DcTableSelector].DC_BITS[0];
860 huffmanTableParams.pACValues = &m_jpegHuffmanTable->HuffTable[AcTableSelector].AC_HUFFVAL[0];
861 huffmanTableParams.pDCValues = &m_jpegHuffmanTable->HuffTable[DcTableSelector].DC_HUFFVAL[0];
862
863 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegHuffTableCmd(
864 &cmdBuffer,
865 &huffmanTableParams));
866
867 // Set the current huffman table indices for the next scan
868 dcCurHuffTblIndex[huffTableID] = DcTableSelector;
869 acCurHuffTblIndex[huffTableID] = AcTableSelector;
870 }
871 }
872
873 MHW_VDBOX_JPEG_BSD_PARAMS jpegBsdObject;
874 MOS_ZeroMemory(&jpegBsdObject, sizeof(jpegBsdObject));
875
876 // MFX_JPEG_BSD_OBJECT
877 jpegBsdObject.dwIndirectDataLength = m_jpegScanParams->ScanHeader[scanCount].DataLength;
878 jpegBsdObject.dwDataStartAddress = m_jpegScanParams->ScanHeader[scanCount].DataOffset;
879 jpegBsdObject.dwScanHorizontalPosition = m_jpegScanParams->ScanHeader[scanCount].ScanHoriPosition;
880 jpegBsdObject.dwScanVerticalPosition = m_jpegScanParams->ScanHeader[scanCount].ScanVertPosition;
881 jpegBsdObject.bInterleaved = (numComponents > 1) ? 1 : 0;
882 jpegBsdObject.dwMCUCount = m_jpegScanParams->ScanHeader[scanCount].MCUCount;
883 jpegBsdObject.dwRestartInterval = m_jpegScanParams->ScanHeader[scanCount].RestartInterval;
884
885 uint16_t scanComponentIndex = 0;
886
887 for (uint16_t scanComponent = 0; scanComponent < numComponents; scanComponent++)
888 {
889 uint8_t ComponentSelector =
890 m_jpegScanParams->ScanHeader[scanCount].ComponentSelector[scanComponent];
891
892 if (ComponentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentY])
893 {
894 scanComponentIndex = 0;
895 }
896 else if (ComponentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentU])
897 {
898 scanComponentIndex = 1;
899 }
900 else if (ComponentSelector == m_jpegPicParams->m_componentIdentifier[jpegComponentV])
901 {
902 scanComponentIndex = 2;
903 }
904 // Add logic for component identifier JPEG_A
905
906 jpegBsdObject.sScanComponent |= (1 << scanComponentIndex);
907 }
908
909 CODECHAL_DECODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegBsdObjCmd(
910 &cmdBuffer,
911 &jpegBsdObject));
912 }
913
914 // Check if destination surface needs to be synchronized
915 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
916 syncParams.GpuContext = m_videoContext;
917 syncParams.presSyncResource = &m_destSurface.OsResource;
918 syncParams.bReadOnly = false;
919 syncParams.bDisableDecodeSyncLock = m_disableDecodeSyncLock;
920 syncParams.bDisableLockForTranscode = m_disableLockForTranscode;
921
922 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnPerformOverlaySync(
923 m_osInterface,
924 &syncParams));
925 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(
926 m_osInterface,
927 &syncParams));
928
929 // Update the resource tag (s/w tag) for On-Demand Sync
930 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
931
932 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
933 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
934 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
935 &cmdBuffer,
936 &flushDwParams));
937
938 // Update the tag in GPU Sync eStatus buffer (H/W Tag) to match the current S/W tag
939 if (m_osInterface->bTagResourceSync)
940 {
941 CODECHAL_DECODE_CHK_STATUS_RETURN(m_hwInterface->WriteSyncTagToResource(
942 &cmdBuffer,
943 &syncParams));
944 }
945
946 if (m_statusQueryReportingEnabled)
947 {
948 CodechalDecodeStatusReport decodeStatusReport;
949 decodeStatusReport.m_statusReportNumber = m_statusReportFeedbackNumber;
950 decodeStatusReport.m_codecStatus = CODECHAL_STATUS_UNAVAILABLE;
951 decodeStatusReport.m_currDecodedPicRes = m_destSurface.OsResource;
952
953 CODECHAL_DECODE_CHK_STATUS_RETURN(EndStatusReport(
954 decodeStatusReport,
955 &cmdBuffer));
956 }
957
958 CODECHAL_DECODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
959 &cmdBuffer,
960 nullptr));
961
962 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
963
964 CODECHAL_DEBUG_TOOL(
965 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
966 &cmdBuffer,
967 CODECHAL_NUM_MEDIA_STATES,
968 "_DEC"));
969 )
970
971 if (m_copiedDataBufferInUse)
972 {
973 //Sync up complete frame
974 syncParams = g_cInitSyncParams;
975 syncParams.GpuContext = m_videoContextForWa;
976 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
977
978 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(
979 m_osInterface,
980 &syncParams));
981
982 syncParams = g_cInitSyncParams;
983 syncParams.GpuContext = m_videoContext;
984 syncParams.presSyncResource = &m_resSyncObjectWaContextInUse;
985
986 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(
987 m_osInterface,
988 &syncParams));
989 }
990
991 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
992
993 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
994 m_osInterface,
995 &cmdBuffer,
996 m_videoContextUsesNullHw));
997
998 CODECHAL_DEBUG_TOOL(
999 m_mmc->UpdateUserFeatureKey(&m_destSurface);)
1000
1001 if (m_statusQueryReportingEnabled)
1002 {
1003 CODECHAL_DECODE_CHK_STATUS_RETURN(ResetStatusReport(
1004 m_videoContextUsesNullHw));
1005 }
1006
1007 // Set output surface layout
1008 SetOutputSurfaceLayout(&m_decodeParams.m_outputSurfLayout);
1009
1010 // Send the signal to indicate decode completion, in case On-Demand Sync is not present
1011 CODECHAL_DECODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceSignal(
1012 m_osInterface,
1013 &syncParams));
1014
1015 CODECHAL_DEBUG_TOOL(
1016 CODECHAL_DECODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
1017 &m_destSurface,
1018 CodechalDbgAttr::attrDecodeOutputSurface,
1019 "DstSurf"));)
1020 return eStatus;
1021 }
1022
1023 MOS_STATUS CodechalDecodeJpeg::InitMmcState()
1024 {
1025 m_mmc = MOS_New(CodechalMmcDecodeJpeg, m_hwInterface, this);
1026 CODECHAL_DECODE_CHK_NULL_RETURN(m_mmc);
1027
1028 return MOS_STATUS_SUCCESS;
1029 }
1030
1031 #ifdef _DECODE_PROCESSING_SUPPORTED
1032 MOS_STATUS CodechalDecodeJpeg::InitSfcState()
1033 {
1034 m_sfcState = MOS_New(CodechalJpegSfcState);
1035 CODECHAL_DECODE_CHK_NULL_RETURN(m_sfcState);
1036
1037 return MOS_STATUS_SUCCESS;
1038 }
1039 #endif
1040
1041 MOS_STATUS CodechalDecodeJpeg::AllocateStandard(
1042 CodechalSetting *settings)
1043 {
1044 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1045
1046 CODECHAL_DECODE_FUNCTION_ENTER;
1047
1048 CODECHAL_DECODE_CHK_NULL_RETURN(settings);
1049
1050 CODECHAL_DECODE_CHK_STATUS_RETURN(InitMmcState());
1051 #ifdef _DECODE_PROCESSING_SUPPORTED
1052 CODECHAL_DECODE_CHK_STATUS_RETURN(InitSfcState());
1053 #endif
1054
1055 m_width = settings->width;
1056 m_height = settings->height;
1057
1058 #ifdef _DECODE_PROCESSING_SUPPORTED
1059 CODECHAL_DECODE_CHK_STATUS_RETURN(m_sfcState->InitializeSfcState(
1060 this,
1061 m_hwInterface,
1062 m_osInterface));
1063 #endif
1064
1065 CODECHAL_DECODE_CHK_STATUS_RETURN(AllocateResources());
1066
1067 return eStatus;
1068 }
1069
1070 #if USE_CODECHAL_DEBUG_TOOL
1071 MOS_STATUS CodechalDecodeJpeg::DumpIQParams(
1072 CodecJpegQuantMatrix *matrixData)
1073 {
1074 CODECHAL_DEBUG_FUNCTION_ENTER;
1075
1076 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
1077 {
1078 return MOS_STATUS_SUCCESS;
1079 }
1080
1081 CODECHAL_DEBUG_CHK_NULL(matrixData);
1082
1083 std::ostringstream oss;
1084 oss.setf(std::ios::showbase | std::ios::uppercase);
1085
1086 for (uint32_t j = 0; j < jpegNumComponent; j++)
1087 {
1088 oss << "Qmatrix " << std::dec << +j << ": " << std::endl;
1089
1090 for (int8_t i = 0; i < 56; i += 8)
1091 {
1092 oss << "Qmatrix[" << std::dec << +i / 8 << "]:";
1093 for (uint8_t k = 0; k < 8; k++)
1094 oss << std::hex << +matrixData->m_quantMatrix[j][i + k]<< " ";
1095 oss << std::endl;
1096 }
1097 }
1098
1099 const char *fileName = m_debugInterface->CreateFileName(
1100 "_DEC",
1101 CodechalDbgBufferType::bufIqParams,
1102 CodechalDbgExtType::txt);
1103
1104 std::ofstream ofs(fileName, std::ios::out);
1105 ofs << oss.str();
1106 ofs.close();
1107
1108 return MOS_STATUS_SUCCESS;
1109 }
1110
1111 MOS_STATUS CodechalDecodeJpeg::DumpPicParams(
1112 CodecDecodeJpegPicParams *picParams)
1113 {
1114 CODECHAL_DEBUG_FUNCTION_ENTER;
1115
1116 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
1117 {
1118 return MOS_STATUS_SUCCESS;
1119 }
1120
1121 CODECHAL_DEBUG_CHK_NULL(picParams);
1122
1123 std::ostringstream oss;
1124 oss.setf(std::ios::showbase | std::ios::uppercase);
1125 oss.setf(std::ios::hex, std::ios::basefield);
1126
1127 oss << "destPic.FrameIdx: " << +picParams->m_destPic.FrameIdx << std::endl;
1128 oss << "destPic.PicFlags: " << +picParams->m_destPic.PicFlags << std::endl;
1129 oss << "frameWidth: " << +picParams->m_frameWidth << std::endl;
1130 oss << "frameHeight: " << +picParams->m_frameHeight << std::endl;
1131 oss << "numCompInFrame: " << +picParams->m_numCompInFrame << std::endl;
1132
1133 //Dump componentIdentifier[jpegNumComponent]
1134 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1135 {
1136 oss << "componentIdentifier[" << +i << "]: " << +picParams->m_componentIdentifier[i] << std::endl;
1137 }
1138
1139 //Dump quantTableSelector[jpegNumComponent]
1140 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1141 {
1142 oss << "quantTableSelector[" << +i << "]: " << +picParams->m_quantTableSelector[i] << std::endl;
1143 }
1144 oss << "chromaType: " << +picParams->m_chromaType << std::endl;
1145 oss << "rotation: " << +picParams->m_rotation << std::endl;
1146 oss << "totalScans: " << +picParams->m_totalScans << std::endl;
1147 oss << "interleavedData: " << +picParams->m_interleavedData << std::endl;
1148 oss << "reserved: " << +picParams->m_reserved << std::endl;
1149 oss << "statusReportFeedbackNumber: " << +picParams->m_statusReportFeedbackNumber << std::endl;
1150
1151 const char *fileName = m_debugInterface->CreateFileName(
1152 "_DEC",
1153 CodechalDbgBufferType::bufPicParams,
1154 CodechalDbgExtType::txt);
1155
1156 std::ofstream ofs(fileName, std::ios::out);
1157 ofs << oss.str();
1158 ofs.close();
1159
1160 return MOS_STATUS_SUCCESS;
1161 }
1162
1163 MOS_STATUS CodechalDecodeJpeg::DumpScanParams(
1164 CodecDecodeJpegScanParameter *scanParams)
1165 {
1166 CODECHAL_DEBUG_FUNCTION_ENTER;
1167
1168 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrScanParams))
1169 {
1170 return MOS_STATUS_SUCCESS;
1171 }
1172 CODECHAL_DEBUG_CHK_NULL(scanParams);
1173
1174 std::ostringstream oss;
1175 oss.setf(std::ios::showbase | std::ios::uppercase);
1176
1177 //Dump ScanHeader[jpegNumComponent]
1178 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1179 {
1180 oss << "ScanHeader[" << +i << "].NumComponents: " << +scanParams->ScanHeader[i].NumComponents << std::endl;
1181 //Dump ComponentSelector[jpegNumComponent]
1182 for (uint32_t j = 0; j < jpegNumComponent; ++j)
1183 {
1184 oss << "ScanHeader[" << +i << "].ComponentSelector[" << +j << "]: " << +scanParams->ScanHeader[i].ComponentSelector[j] << std::endl;
1185 }
1186
1187 //Dump DcHuffTblSelector[jpegNumComponent]
1188 for (uint32_t j = 0; j < jpegNumComponent; ++j)
1189 {
1190 oss << "ScanHeader[" << +i << "].DcHuffTblSelector[" << +j << "]: " << +scanParams->ScanHeader[i].DcHuffTblSelector[j] << std::endl;
1191 }
1192
1193 //Dump AcHuffTblSelector[jpegNumComponent]
1194 for (uint32_t j = 0; j < jpegNumComponent; ++j)
1195 {
1196 oss << "ScanHeader[" << +i << "].AcHuffTblSelector[" << +j << "]: " << +scanParams->ScanHeader[i].AcHuffTblSelector[j] << std::endl;
1197 }
1198 oss << "ScanHeader[" << +i << "].RestartInterval: " << +scanParams->ScanHeader[i].RestartInterval << std::endl;
1199 oss << "ScanHeader[" << +i << "].MCUCount: " << +scanParams->ScanHeader[i].MCUCount << std::endl;
1200 oss << "ScanHeader[" << +i << "].ScanHoriPosition: " << +scanParams->ScanHeader[i].ScanHoriPosition << std::endl;
1201 oss << "ScanHeader[" << +i << "].ScanVertPosition: " << +scanParams->ScanHeader[i].ScanVertPosition << std::endl;
1202 oss << "ScanHeader[" << +i << "].DataOffset: " << +scanParams->ScanHeader[i].DataOffset << std::endl;
1203 oss << "ScanHeader[" << +i << "].DataLength: " << +scanParams->ScanHeader[i].DataLength << std::endl;
1204 }
1205
1206 oss << "NumScans: " << +scanParams->NumScans << std::endl;
1207
1208 const char *fileName = m_debugInterface->CreateFileName(
1209 "_DEC",
1210 CodechalDbgBufferType::bufScanParams,
1211 CodechalDbgExtType::txt);
1212
1213 std::ofstream ofs(fileName, std::ios::out);
1214 ofs << oss.str();
1215 ofs.close();
1216 return MOS_STATUS_SUCCESS;
1217 }
1218
1219 MOS_STATUS CodechalDecodeJpeg::DumpHuffmanTable(
1220 PCODECHAL_DECODE_JPEG_HUFFMAN_TABLE huffmanTable)
1221 {
1222 CODECHAL_DEBUG_FUNCTION_ENTER;
1223 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrHuffmanTbl))
1224 {
1225 return MOS_STATUS_SUCCESS;
1226 }
1227 CODECHAL_DEBUG_CHK_NULL(huffmanTable);
1228
1229 std::ostringstream oss;
1230 oss.setf(std::ios::showbase | std::ios::uppercase);
1231
1232 //Dump HuffTable[JPEG_MAX_NUM_HUFF_TABLE_INDEX]
1233 for (uint32_t i = 0; i < JPEG_MAX_NUM_HUFF_TABLE_INDEX; ++i)
1234 {
1235 //Dump DC_BITS[JPEG_NUM_HUFF_TABLE_DC_BITS]
1236 oss << "HuffTable[" << +i << "].DC_BITS[0-" << (JPEG_NUM_HUFF_TABLE_DC_BITS - 1) << "]: " << std::endl;
1237
1238 for (uint32_t j = 0; j < JPEG_NUM_HUFF_TABLE_DC_BITS; ++j)
1239 {
1240 oss << +huffmanTable->HuffTable[i].DC_BITS[j] << " ";
1241 if (j % 6 == 5 || j == JPEG_NUM_HUFF_TABLE_DC_BITS - 1)
1242 {
1243 oss << std::endl;
1244 }
1245 }
1246 //Dump DC_HUFFVAL[JPEG_NUM_HUFF_TABLE_DC_HUFFVAL]
1247 oss << "HuffTable[" << +i << "].DC_HUFFVAL[0-" << (JPEG_NUM_HUFF_TABLE_DC_HUFFVAL - 1) << "]: " << std::endl;
1248 for (uint32_t j = 0; j < JPEG_NUM_HUFF_TABLE_DC_HUFFVAL; ++j)
1249 {
1250 oss << +huffmanTable->HuffTable[i].DC_HUFFVAL[j] << ' ';
1251 if (j % 6 == 5 || j == JPEG_NUM_HUFF_TABLE_DC_HUFFVAL - 1)
1252 {
1253 oss << std::endl;
1254 }
1255 }
1256 //Dump AC_BITS[JPEG_NUM_HUFF_TABLE_AC_BITS]
1257 oss << "HuffTable[" << +i << "].AC_BITS[0-" << (JPEG_NUM_HUFF_TABLE_AC_BITS - 1) << "]: " << std::endl;
1258
1259 for (uint32_t j = 0; j < JPEG_NUM_HUFF_TABLE_AC_BITS; ++j)
1260 {
1261 oss << +huffmanTable->HuffTable[i].AC_BITS[j] << ' ';
1262 if (j % 8 == 7 || j == JPEG_NUM_HUFF_TABLE_AC_BITS - 1)
1263 {
1264 oss << std::endl;
1265 }
1266 }
1267
1268 //Dump AC_HUFFVAL[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL]
1269 oss << "HuffTable[" << +i << "].AC_HUFFVAL[0-" << (JPEG_NUM_HUFF_TABLE_AC_HUFFVAL - 1) << "]: " << std::endl;
1270
1271 for (uint32_t j = 0; j < JPEG_NUM_HUFF_TABLE_AC_HUFFVAL; ++j)
1272 {
1273 oss << +huffmanTable->HuffTable[i].AC_HUFFVAL[j] << ' ';
1274 if (j % 9 == 8 || j == JPEG_NUM_HUFF_TABLE_AC_HUFFVAL - 1)
1275 {
1276 oss << std::endl;
1277 }
1278 }
1279 }
1280
1281 const char *fileName = m_debugInterface->CreateFileName(
1282 "_DEC",
1283 CodechalDbgBufferType::bufHuffmanTbl,
1284 CodechalDbgExtType::txt);
1285
1286 std::ofstream ofs(fileName, std::ios::out);
1287 ofs << oss.str();
1288 ofs.close();
1289 return MOS_STATUS_SUCCESS;
1290 }
1291
1292 #endif