Debian Codegraph @

media_softlet/agnostic/common/codec/hal/enc/jpeg/packet/encode_jpeg_packet.cpp

raw
1 /*
2 * Copyright (c) 2021, 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 encode_jpeg_packet.cpp
24 //! \brief Defines the interface for jpeg encode packet
25 //!
26
27 #include "encode_jpeg_packet.h"
28 #include "codec_def_encode_jpeg.h"
29 #include "mos_solo_generic.h"
30 #include "media_jpeg_feature_defs.h"
31
32 namespace encode {
33
34 JpegPkt::JpegPkt(
35 MediaPipeline *pipeline,
36 MediaTask *task,
37 CodechalHwInterfaceNext *hwInterface) :
38 CmdPacket(task),
39 m_pipeline(dynamic_cast<JpegPipeline *>(pipeline)),
40 m_hwInterface(dynamic_cast<CodechalHwInterfaceNext *>(hwInterface))
41 {
42 ENCODE_CHK_NULL_NO_STATUS_RETURN(hwInterface);
43 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_pipeline);
44 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface);
45
46 m_osInterface = hwInterface->GetOsInterface();
47 m_statusReport = m_pipeline->GetStatusReportInstance();
48 m_featureManager = m_pipeline->GetFeatureManager();
49 m_encodecp = m_pipeline->GetEncodeCp();
50
51 CODECHAL_DEBUG_TOOL(
52 m_debugInterface = m_pipeline->GetDebugInterface();
53 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_debugInterface);)
54
55 m_mfxItf = std::static_pointer_cast<mhw::vdbox::mfx::Itf>(m_hwInterface->GetMfxInterfaceNext());
56 m_miItf = std::static_pointer_cast<mhw::mi::Itf>(m_hwInterface->GetMiInterfaceNext());
57 }
58
59 MOS_STATUS JpegPkt::Init()
60 {
61 ENCODE_FUNC_CALL();
62 ENCODE_CHK_NULL_RETURN(m_statusReport);
63
64 ENCODE_CHK_STATUS_RETURN(CmdPacket::Init());
65
66 m_basicFeature = dynamic_cast<JpegBasicFeature *>(m_featureManager->GetFeature(FeatureIDs::basicFeature));
67 ENCODE_CHK_NULL_RETURN(m_basicFeature);
68
69 m_jpgPkrFeature = dynamic_cast<JpegPackerFeature *>(m_featureManager->GetFeature(JpegFeatureIDs::jpegPackerFeature));
70 ENCODE_CHK_NULL_RETURN(m_jpgPkrFeature);
71
72 m_mmcState = m_pipeline->GetMmcState();
73 ENCODE_CHK_NULL_RETURN(m_mmcState);
74 m_basicFeature->m_mmcState = m_mmcState;
75
76 ENCODE_CHK_STATUS_RETURN(m_statusReport->RegistObserver(this));
77
78 m_usePatchList = m_osInterface->bUsesPatchList;
79
80 return MOS_STATUS_SUCCESS;
81 }
82
83 MOS_STATUS JpegPkt::Prepare()
84 {
85 ENCODE_FUNC_CALL();
86
87 JpegPipeline *pipeline = dynamic_cast<JpegPipeline *>(m_pipeline);
88 ENCODE_CHK_NULL_RETURN(pipeline);
89
90 m_jpegPicParams = m_basicFeature->m_jpegPicParams;
91 m_jpegScanParams = m_basicFeature->m_jpegScanParams;
92 m_jpegQuantTables = m_basicFeature->m_jpegQuantTables;
93 m_jpegHuffmanTable = m_basicFeature->m_jpegHuffmanTable;
94 m_applicationData = m_basicFeature->m_applicationData;
95 m_numHuffBuffers = m_basicFeature->m_numHuffBuffers;
96
97 return MOS_STATUS_SUCCESS;
98 }
99
100 MOS_STATUS JpegPkt::Destroy()
101 {
102 ENCODE_FUNC_CALL();
103 ENCODE_CHK_STATUS_RETURN(m_statusReport->UnregistObserver(this));
104
105 return MOS_STATUS_SUCCESS;
106 }
107
108 MOS_STATUS JpegPkt::Submit(
109 MOS_COMMAND_BUFFER* commandBuffer,
110 uint8_t packetPhase)
111 {
112 ENCODE_FUNC_CALL();
113
114 MOS_COMMAND_BUFFER &cmdBuffer = *commandBuffer;
115 ENCODE_CHK_STATUS_RETURN(Mos_Solo_PreProcessEncode(m_osInterface, &m_basicFeature->m_resBitstreamBuffer, &m_basicFeature->m_reconSurface));
116
117 // Ensure the input is ready to be read.
118 // Currently, mos RegisterResource has sync limitation for Raw resource.
119 // Temporaly, call Resource Wait to do the sync explicitly.
120 // TODO, Refine it when MOS refactor ready.
121 MOS_SYNC_PARAMS syncParams;
122 syncParams = g_cInitSyncParams;
123 syncParams.GpuContext = m_osInterface->pfnGetGpuContext(m_osInterface);
124 syncParams.presSyncResource = &m_basicFeature->m_rawSurface.OsResource;
125 syncParams.bReadOnly = true;
126 ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
127 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
128
129 ENCODE_CHK_STATUS_RETURN(PatchPictureLevelCommands(packetPhase, cmdBuffer));
130 ENCODE_CHK_STATUS_RETURN(PatchSliceLevelCommands(cmdBuffer, packetPhase));
131
132 ENCODE_CHK_STATUS_RETURN(Mos_Solo_PostProcessEncode(m_osInterface, &m_basicFeature->m_resBitstreamBuffer, &m_basicFeature->m_reconSurface));
133
134 return MOS_STATUS_SUCCESS;
135 }
136
137 MOS_STATUS JpegPkt::Completed(void *mfxStatus, void *rcsStatus, void *statusReport)
138 {
139 ENCODE_FUNC_CALL();
140
141 ENCODE_CHK_NULL_RETURN(mfxStatus);
142 ENCODE_CHK_NULL_RETURN(statusReport);
143
144 EncodeStatusMfx *encodeStatusMfx = (EncodeStatusMfx *)mfxStatus;
145 EncodeStatusReportData *statusReportData = (EncodeStatusReportData *)statusReport;
146
147 if (statusReportData->hwCtr)
148 {
149 m_encodecp->UpdateCpStatusReport(statusReport);
150 }
151
152 statusReportData->codecStatus = CODECHAL_STATUS_SUCCESSFUL;
153
154 CODECHAL_DEBUG_TOOL(
155 ENCODE_CHK_STATUS_RETURN(DumpResources(encodeStatusMfx, statusReportData)););
156
157 return MOS_STATUS_SUCCESS;
158 }
159
160 MOS_STATUS JpegPkt::CalculateCommandSize(
161 uint32_t &commandBufferSize,
162 uint32_t &requestedPatchListSize)
163 {
164 ENCODE_FUNC_CALL();
165
166 ENCODE_CHK_STATUS_RETURN(CalculateMfxCommandsSize());
167 commandBufferSize = CalculateCommandBufferSize();
168 requestedPatchListSize = CalculatePatchListSize();
169 return MOS_STATUS_SUCCESS;
170 }
171
172 MOS_STATUS JpegPkt::CalculateMfxCommandsSize()
173 {
174 ENCODE_FUNC_CALL();
175
176 // Picture Level Commands
177 ENCODE_CHK_STATUS_RETURN(
178 GetMfxStateCommandsDataSize(
179 &m_pictureStatesSize,
180 &m_picturePatchListSize));
181
182 // Slice Level Commands (cannot be placed in 2nd level batch)
183 ENCODE_CHK_STATUS_RETURN(
184 GetMfxPrimitiveCommandsDataSize(
185 &m_sliceStatesSize,
186 &m_slicePatchListSize));
187
188 return MOS_STATUS_SUCCESS;
189 }
190
191 MOS_STATUS JpegPkt::GetMfxPrimitiveCommandsDataSize(
192 uint32_t *commandsSize,
193 uint32_t *patchListSize)
194 {
195 ENCODE_FUNC_CALL()
196 uint32_t cpCmdsize = 0;
197 uint32_t cpPatchListSize = 0;
198
199 if (m_mfxItf)
200 {
201 uint32_t maxSize = 0;
202
203 maxSize =
204 m_mfxItf->MHW_GETSIZE_F(MFX_FQM_STATE)() * 3 +
205 m_mfxItf->MHW_GETSIZE_F(MFC_JPEG_HUFF_TABLE_STATE)() * 2 +
206 m_mfxItf->MHW_GETSIZE_F(MFC_JPEG_SCAN_OBJECT)() +
207 m_mfxItf->MHW_GETSIZE_F(MFX_PAK_INSERT_OBJECT)() * 10;
208
209 *commandsSize = maxSize;
210 *patchListSize = 0;
211
212 m_hwInterface->GetCpInterface()->GetCpSliceLevelCmdSize(cpCmdsize, cpPatchListSize);
213 }
214
215 *commandsSize += cpCmdsize;
216 *patchListSize += cpPatchListSize;
217
218 return MOS_STATUS_SUCCESS;
219 }
220
221 MOS_STATUS JpegPkt::GetMfxStateCommandsDataSize(
222 uint32_t *commandsSize,
223 uint32_t *patchListSize)
224 {
225 ENCODE_FUNC_CALL()
226 ENCODE_CHK_NULL_RETURN(commandsSize);
227 ENCODE_CHK_NULL_RETURN(patchListSize);
228
229 uint32_t cpCmdsize = 0;
230 uint32_t cpPatchListSize = 0;
231
232 if (m_mfxItf && m_miItf)
233 {
234 uint32_t maxSize =
235 m_miItf->MHW_GETSIZE_F(MI_FLUSH_DW)() +
236 m_mfxItf->MHW_GETSIZE_F(MFX_PIPE_MODE_SELECT)() +
237 m_mfxItf->MHW_GETSIZE_F(MFX_SURFACE_STATE)() +
238 m_mfxItf->MHW_GETSIZE_F(MFX_PIPE_BUF_ADDR_STATE)() +
239 m_mfxItf->MHW_GETSIZE_F(MFX_IND_OBJ_BASE_ADDR_STATE)() +
240 2 * m_miItf->MHW_GETSIZE_F(MI_STORE_DATA_IMM)() +
241 2 * m_miItf->MHW_GETSIZE_F(MI_STORE_REGISTER_MEM)() +
242 8 * m_miItf->MHW_GETSIZE_F(MI_LOAD_REGISTER_REG)();
243
244 uint32_t patchListMaxSize =
245 PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_FLUSH_DW_CMD) +
246 PATCH_LIST_COMMAND(mhw::vdbox::mfx::Itf::MFX_PIPE_MODE_SELECT_CMD) +
247 PATCH_LIST_COMMAND(mhw::vdbox::mfx::Itf::MFX_SURFACE_STATE_CMD) +
248 PATCH_LIST_COMMAND(mhw::vdbox::mfx::Itf::MFX_PIPE_BUF_ADDR_STATE_CMD) +
249 PATCH_LIST_COMMAND(mhw::vdbox::mfx::Itf::MFX_IND_OBJ_BASE_ADDR_STATE_CMD) +
250 (2 * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_STORE_DATA_IMM_CMD)) +
251 (2 * PATCH_LIST_COMMAND(mhw::vdbox::huc::Itf::MI_STORE_REGISTER_MEM_CMD));
252
253 *commandsSize = maxSize;
254 *patchListSize = patchListMaxSize;
255
256 m_hwInterface->GetCpInterface()->GetCpStateLevelCmdSize(cpCmdsize, cpPatchListSize);
257 }
258
259 *commandsSize += cpCmdsize;
260 *patchListSize += cpPatchListSize;
261
262 return MOS_STATUS_SUCCESS;
263 }
264
265 MmioRegistersMfx *JpegPkt::SelectVdboxAndGetMmioRegister(
266 MHW_VDBOX_NODE_IND index,
267 PMOS_COMMAND_BUFFER pCmdBuffer)
268 {
269 if (m_hwInterface->m_getVdboxNodeByUMD)
270 {
271 pCmdBuffer->iVdboxNodeIndex = m_osInterface->pfnGetVdboxNodeId(m_osInterface, pCmdBuffer);
272 switch (pCmdBuffer->iVdboxNodeIndex)
273 {
274 case MOS_VDBOX_NODE_1:
275 index = MHW_VDBOX_NODE_1;
276 break;
277 case MOS_VDBOX_NODE_2:
278 index = MHW_VDBOX_NODE_2;
279 break;
280 case MOS_VDBOX_NODE_INVALID:
281 // That's a legal case meaning that we were not assigned with per-bb index because
282 // balancing algorithm can't work (forcedly diabled or miss kernel support).
283 // If that's the case we just proceed with the further static context assignment.
284 break;
285 default:
286 // That's the case when MHW and MOS enumerations mismatch. We again proceed with the
287 // best effort (static context assignment, but provide debug note).
288 MHW_ASSERTMESSAGE("MOS and MHW VDBOX enumerations mismatch! Adjust HW description!");
289 break;
290 }
291 }
292
293 auto vdencItf = m_hwInterface->GetVdencInterfaceNext();
294 if (vdencItf)
295 {
296 return vdencItf->GetMmioRegisters(index);
297 }
298 else
299 {
300 MHW_ASSERTMESSAGE("Get vdenc interface failed!");
301 return nullptr;
302 }
303 }
304
305 void JpegPkt::SetPerfTag(uint16_t type, uint16_t mode, uint16_t picCodingType)
306 {
307 ENCODE_FUNC_CALL();
308
309 PerfTagSetting perfTag;
310 perfTag.Value = 0;
311 perfTag.Mode = mode & CODECHAL_ENCODE_MODE_BIT_MASK;
312 perfTag.CallType = type;
313 perfTag.PictureCodingType = picCodingType > 3 ? 0 : picCodingType;
314 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
315 m_osInterface->pfnIncPerfBufferID(m_osInterface);
316 }
317
318 MOS_STATUS JpegPkt::AddPictureMfxCommands(
319 MOS_COMMAND_BUFFER & cmdBuffer)
320 {
321 ENCODE_FUNC_CALL();
322
323 SETPAR_AND_ADDCMD(MFX_WAIT, m_miItf, &cmdBuffer);
324 SETPAR_AND_ADDCMD(MFX_PIPE_MODE_SELECT, m_mfxItf, &cmdBuffer);
325 SETPAR_AND_ADDCMD(MFX_WAIT, m_miItf, &cmdBuffer);
326
327 SETPAR_AND_ADDCMD(MFX_SURFACE_STATE, m_mfxItf, &cmdBuffer);
328 SETPAR_AND_ADDCMD(MFX_PIPE_BUF_ADDR_STATE, m_mfxItf, &cmdBuffer);
329 SETPAR_AND_ADDCMD(MFX_IND_OBJ_BASE_ADDR_STATE, m_mfxItf, &cmdBuffer);
330 SETPAR_AND_ADDCMD(MFX_JPEG_PIC_STATE, m_mfxItf, &cmdBuffer);
331
332 return MOS_STATUS_SUCCESS;
333 }
334
335 MOS_STATUS JpegPkt::SendPrologCmds(MOS_COMMAND_BUFFER &cmdBuffer)
336 {
337 ENCODE_FUNC_CALL();
338 MOS_GPU_CONTEXT gpuContext = m_osInterface->pfnGetGpuContext(m_osInterface);
339
340 // initialize command buffer attributes
341 cmdBuffer.Attributes.bTurboMode = m_hwInterface->m_turboMode;
342 cmdBuffer.Attributes.bMediaPreemptionEnabled = 0;
343 cmdBuffer.Attributes.dwNumRequestedEUSlices = m_hwInterface->m_numRequestedEuSlices;
344 cmdBuffer.Attributes.dwNumRequestedSubSlices = m_hwInterface->m_numRequestedSubSlices;
345 cmdBuffer.Attributes.dwNumRequestedEUs = m_hwInterface->m_numRequestedEus;
346 cmdBuffer.Attributes.bValidPowerGatingRequest = true;
347
348 ENCODE_CHK_NULL_RETURN(m_mmcState);
349 ENCODE_CHK_STATUS_RETURN(m_mmcState->SendPrologCmd(&cmdBuffer, false));
350
351 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
352 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
353 genericPrologParams.pOsInterface = m_osInterface;
354 genericPrologParams.pvMiInterface = nullptr;
355 genericPrologParams.bMmcEnabled = m_mmcState ? m_mmcState->IsMmcEnabled() : false;
356 ENCODE_CHK_STATUS_RETURN(Mhw_SendGenericPrologCmdNext(&cmdBuffer, &genericPrologParams, m_miItf));
357
358 return MOS_STATUS_SUCCESS;
359 }
360
361 MOS_STATUS JpegPkt::StartStatusReport(
362 uint32_t srType,
363 MOS_COMMAND_BUFFER *cmdBuffer)
364 {
365 ENCODE_FUNC_CALL();
366 ENCODE_CHK_NULL_RETURN(cmdBuffer);
367
368 ENCODE_CHK_STATUS_RETURN(MediaPacket::StartStatusReportNext(srType, cmdBuffer));
369 m_encodecp->StartCpStatusReport(cmdBuffer);
370
371 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
372 ENCODE_CHK_NULL_RETURN(perfProfiler);
373 ENCODE_CHK_STATUS_RETURN(perfProfiler->AddPerfCollectStartCmd(
374 (void *)m_pipeline, m_osInterface, m_miItf, cmdBuffer));
375
376 return MOS_STATUS_SUCCESS;
377 }
378
379 MOS_STATUS JpegPkt::ReadMfcStatus(MOS_COMMAND_BUFFER &cmdBuffer)
380 {
381 ENCODE_FUNC_CALL();
382
383 ENCODE_CHK_NULL_RETURN(m_hwInterface);
384
385 MOS_RESOURCE *osResource = nullptr;
386 uint32_t offset = 0;
387
388 EncodeStatusReadParams params;
389 MOS_ZeroMemory(&params, sizeof(params));
390
391 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(encode::statusReportMfxBitstreamByteCountPerFrame, osResource, offset));
392 params.resBitstreamByteCountPerFrame = osResource;
393 params.bitstreamByteCountPerFrameOffset = offset;
394
395 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(encode::statusReportMfxBitstreamSyntaxElementOnlyBitCount, osResource, offset));
396 params.resBitstreamSyntaxElementOnlyBitCount = osResource;
397 params.bitstreamSyntaxElementOnlyBitCountOffset = offset;
398
399 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(encode::statusReportQPStatusCount, osResource, offset));
400 params.resQpStatusCount = osResource;
401 params.qpStatusCountOffset = offset;
402
403 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(encode::statusReportImageStatusMask, osResource, offset));
404 params.resImageStatusMask = osResource;
405 params.imageStatusMaskOffset = offset;
406
407 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(encode::statusReportImageStatusCtrl, osResource, offset));
408 params.resImageStatusCtrl = osResource;
409 params.imageStatusCtrlOffset = offset;
410
411 ENCODE_CHK_STATUS_RETURN(m_statusReport->GetAddress(encode::statusReportNumSlices, osResource, offset));
412 params.resNumSlices = osResource;
413 params.numSlicesOffset = offset;
414
415 ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxItf->GetMaxVdboxIndex()), "ERROR - vdbox index exceeds the maximum");
416
417 SETPAR_AND_ADDCMD(MI_FLUSH_DW, m_miItf, &cmdBuffer);
418
419 MmioRegistersMfx *mmioRegisters = SelectVdboxAndGetMmioRegister(m_vdboxIndex, &cmdBuffer);
420 CODEC_HW_CHK_NULL_RETURN(mmioRegisters);
421 m_pResource = params.resBitstreamByteCountPerFrame;
422 m_dwOffset = params.bitstreamByteCountPerFrameOffset;
423 m_dwValue = mmioRegisters->mfcBitstreamBytecountFrameRegOffset;
424 SETPAR_AND_ADDCMD(MI_STORE_REGISTER_MEM, m_miItf, &cmdBuffer);
425
426 m_pResource = params.resBitstreamSyntaxElementOnlyBitCount;
427 m_dwOffset = params.bitstreamSyntaxElementOnlyBitCountOffset;
428 m_dwValue = mmioRegisters->mfcBitstreamSeBitcountFrameRegOffset;
429 SETPAR_AND_ADDCMD(MI_STORE_REGISTER_MEM, m_miItf, &cmdBuffer);
430
431 m_pResource = params.resQpStatusCount;
432 m_dwOffset = params.qpStatusCountOffset;
433 m_dwValue = mmioRegisters->mfcQPStatusCountOffset;
434 SETPAR_AND_ADDCMD(MI_STORE_REGISTER_MEM, m_miItf, &cmdBuffer);
435
436 ENCODE_CHK_STATUS_RETURN(ReadImageStatus(params, &cmdBuffer))
437 return MOS_STATUS_SUCCESS;
438 }
439
440 MOS_STATUS JpegPkt::ReadImageStatus(
441 const EncodeStatusReadParams &params,
442 PMOS_COMMAND_BUFFER cmdBuffer)
443 {
444 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
445
446 CODEC_HW_FUNCTION_ENTER;
447
448 CODEC_HW_CHK_NULL_RETURN(cmdBuffer);
449
450 CODEC_HW_CHK_COND_RETURN((m_vdboxIndex > m_mfxItf->GetMaxVdboxIndex()), "ERROR - vdbox index exceeds the maximum");
451
452 MmioRegistersMfx *mmioRegisters = SelectVdboxAndGetMmioRegister(m_vdboxIndex, cmdBuffer);
453 CODEC_HW_CHK_NULL_RETURN(mmioRegisters);
454 m_pResource = params.resImageStatusMask;
455 m_dwOffset = params.imageStatusMaskOffset;
456 m_dwValue = mmioRegisters->mfcImageStatusMaskRegOffset;
457 SETPAR_AND_ADDCMD(MI_STORE_REGISTER_MEM, m_miItf, cmdBuffer);
458
459 m_pResource = params.resImageStatusCtrl;
460 m_dwOffset = params.imageStatusCtrlOffset;
461 m_dwValue = mmioRegisters->mfcImageStatusCtrlRegOffset;
462 SETPAR_AND_ADDCMD(MI_STORE_REGISTER_MEM, m_miItf, cmdBuffer);
463
464 SETPAR_AND_ADDCMD(MI_FLUSH_DW, m_miItf, cmdBuffer);
465
466 return eStatus;
467 }
468
469 MOS_STATUS JpegPkt::EndStatusReport(
470 uint32_t srType,
471 MOS_COMMAND_BUFFER *cmdBuffer)
472 {
473 ENCODE_FUNC_CALL();
474 ENCODE_CHK_NULL_RETURN(cmdBuffer);
475
476 ENCODE_CHK_STATUS_RETURN(MediaPacket::EndStatusReportNext(srType, cmdBuffer));
477
478 MediaPerfProfiler *perfProfiler = MediaPerfProfiler::Instance();
479 ENCODE_CHK_NULL_RETURN(perfProfiler);
480 ENCODE_CHK_STATUS_RETURN(perfProfiler->AddPerfCollectEndCmd(
481 (void *)m_pipeline, m_osInterface, m_miItf, cmdBuffer));
482
483 return MOS_STATUS_SUCCESS;
484 }
485
486 MOS_STATUS JpegPkt::PatchPictureLevelCommands(const uint8_t &packetPhase, MOS_COMMAND_BUFFER &cmdBuffer)
487 {
488 ENCODE_FUNC_CALL();
489
490 ENCODE_CHK_STATUS_RETURN(m_miItf->SetWatchdogTimerThreshold(m_basicFeature->m_frameWidth, m_basicFeature->m_frameHeight, true));
491
492 SetPerfTag(CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE, (uint16_t)m_basicFeature->m_mode, m_basicFeature->m_pictureCodingType);
493
494 SETPAR_AND_ADDCMD(MI_FORCE_WAKEUP, m_miItf, &cmdBuffer);
495
496 // Send command buffer header at the beginning (OS dependent)
497 ENCODE_CHK_STATUS_RETURN(SendPrologCmds(cmdBuffer));
498
499 if (m_pipeline->IsFirstPipe())
500 {
501 ENCODE_CHK_STATUS_RETURN(StartStatusReport(statusReportMfx, &cmdBuffer));
502 }
503
504 ENCODE_CHK_STATUS_RETURN(AddPictureMfxCommands(cmdBuffer));
505
506 return MOS_STATUS_SUCCESS;
507 }
508
509 MOS_STATUS JpegPkt::PatchSliceLevelCommands(MOS_COMMAND_BUFFER &cmdBuffer, uint8_t packetPhase)
510 {
511 ENCODE_FUNC_CALL();
512
513 if (m_basicFeature->m_numSlices != 1)
514 {
515 ENCODE_ASSERTMESSAGE("JPEG encode only one scan is supported.");
516 }
517
518 static_assert(JPEG_MAX_NUM_QUANT_TABLE_INDEX <= JPEG_MAX_NUM_OF_QUANTMATRIX,
519 "access to CodecJpegQuantMatrix is controlled by numQuantTables");
520
521 for (uint32_t scanCount = 0; scanCount < m_basicFeature->m_numSlices; scanCount++)
522 {
523 m_numQuantTables = JPEG_MAX_NUM_QUANT_TABLE_INDEX;
524 ENCODE_CHK_STATUS_RETURN(InitMissedQuantTables());
525
526 ENCODE_CHK_STATUS_RETURN(InitQuantMatrix());
527
528 ENCODE_CHK_STATUS_RETURN(AddAllCmds_MFX_FQM_STATE(&cmdBuffer));
529
530 ENCODE_CHK_STATUS_RETURN(InitHuffTable());
531
532 ENCODE_CHK_STATUS_RETURN(AddAllCmds_MFC_JPEG_HUFF_TABLE_STATE(&cmdBuffer));
533
534 SETPAR_AND_ADDCMD(MFC_JPEG_SCAN_OBJECT, m_mfxItf, &cmdBuffer);
535
536 ENCODE_CHK_STATUS_RETURN(AddAllCmds_MFX_PAK_INSERT_OBJECT(&cmdBuffer));
537 }
538
539 ENCODE_CHK_STATUS_RETURN(ReadMfcStatus(cmdBuffer));
540
541 if (m_pipeline->IsFirstPipe())
542 {
543 ENCODE_CHK_STATUS_RETURN(EndStatusReport(statusReportMfx, &cmdBuffer));
544 }
545
546 if (!m_pipeline->IsSingleTaskPhaseSupported() || m_pipeline->IsLastPass())
547 {
548 ENCODE_CHK_STATUS_RETURN(UpdateStatusReportNext(statusReportGlobalCount, &cmdBuffer));
549 }
550
551 ENCODE_CHK_STATUS_RETURN(m_miItf->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
552
553 std::string pakPassName = "PAK_PASS" + std::to_string(static_cast<uint32_t>(m_pipeline->GetCurrentPass()));
554 CODECHAL_DEBUG_TOOL(
555 CodechalDebugInterface *debugInterface = m_pipeline->GetDebugInterface();
556 ENCODE_CHK_NULL_RETURN(debugInterface);
557 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpCmdBuffer(
558 &cmdBuffer,
559 CODECHAL_NUM_MEDIA_STATES,
560 pakPassName.data()));
561 )
562
563 return MOS_STATUS_SUCCESS;
564 }
565
566 MOS_STATUS JpegPkt::InitMissedQuantTables()
567 {
568 ENCODE_FUNC_CALL();
569
570 MOS_SURFACE *surface = m_basicFeature->m_rawSurfaceToPak;
571 bool useSingleDefaultQuantTable = (m_basicFeature->m_jpegQuantMatrixSent == false &&
572 ((surface->Format == Format_A8R8G8B8) ||
573 (surface->Format == Format_X8R8G8B8) ||
574 (surface->Format == Format_A8B8G8R8) ||
575 (surface->Format == Format_X8B8G8R8)));
576
577 // For monochrome inputs there will be only 1 quantization table and huffman table sent
578 if (m_jpegPicParams->m_inputSurfaceFormat == codechalJpegY8)
579 {
580 m_numQuantTables = 1;
581 m_numHuffBuffers = 2; //for Y8 only 2 huff tables
582 }
583 // If there is only 1 quantization table copy over the table to 2nd and 3rd table in JPEG state (used for frame header)
584 // OR For RGB input surfaces, if the app does not send quantization tables, then use luma quant table for all 3 components
585 else if (m_jpegPicParams->m_numQuantTable == 1 || useSingleDefaultQuantTable)
586 {
587 for (auto i = 1; i < JPEG_MAX_NUM_QUANT_TABLE_INDEX; i++)
588 {
589 m_jpegQuantTables->m_quantTable[i].m_precision = m_jpegQuantTables->m_quantTable[0].m_precision;
590 m_jpegQuantTables->m_quantTable[i].m_tableID = m_jpegQuantTables->m_quantTable[0].m_tableID;
591
592 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
593 &m_jpegQuantTables->m_quantTable[i].m_qm[0],
594 JPEG_NUM_QUANTMATRIX * sizeof(uint16_t),
595 &m_jpegQuantTables->m_quantTable[0].m_qm[0],
596 JPEG_NUM_QUANTMATRIX * sizeof(uint16_t)));
597 }
598 }
599 // If there are 2 quantization tables copy over the second table to 3rd table in JPEG state since U and V share the same table (used for frame header)
600 else if (m_jpegPicParams->m_numQuantTable == 2)
601 {
602 m_jpegQuantTables->m_quantTable[2].m_precision = m_jpegQuantTables->m_quantTable[1].m_precision;
603 m_jpegQuantTables->m_quantTable[2].m_tableID = m_jpegQuantTables->m_quantTable[1].m_tableID;
604
605 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
606 &m_jpegQuantTables->m_quantTable[2].m_qm[0],
607 JPEG_NUM_QUANTMATRIX * sizeof(uint16_t),
608 &m_jpegQuantTables->m_quantTable[1].m_qm[0],
609 JPEG_NUM_QUANTMATRIX * sizeof(uint16_t)));
610 }
611 // else 3 quantization tables are sent by the application for non monochrome input formats. In that case, do nothing.
612
613 return MOS_STATUS_SUCCESS;
614 }
615
616 MOS_STATUS JpegPkt::InitQuantMatrix()
617 {
618 ENCODE_FUNC_CALL();
619
620 m_jpegQuantMatrix = {};
621
622 for (uint8_t i = 0; i < m_numQuantTables; i++)
623 {
624 for (auto j = 0; j < JPEG_NUM_QUANTMATRIX; j++)
625 {
626 uint32_t k = jpeg_qm_scan_8x8[j];
627
628 // copy over Quant matrix in raster order from zig zag
629 m_jpegQuantMatrix.m_quantMatrix[i][k] = (uint8_t)m_jpegQuantTables->m_quantTable[i].m_qm[j];
630 }
631 }
632
633 return MOS_STATUS_SUCCESS;
634 }
635
636 MOS_STATUS JpegPkt::InitHuffTable()
637 {
638 ENCODE_FUNC_CALL();
639
640 for (uint32_t i = 0; i < m_numHuffBuffers; i++)
641 {
642 EncodeJpegHuffTable huffmanTable; // intermediate table for each AC/DC component which will be copied to m_huffTableParams
643 MOS_ZeroMemory(&huffmanTable, sizeof(huffmanTable));
644
645 ENCODE_CHK_STATUS_RETURN(ConvertHuffDataToTable(m_jpegHuffmanTable->m_huffmanData[i], &huffmanTable));
646
647 m_huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].HuffTableID = m_jpegHuffmanTable->m_huffmanData[i].m_tableID;
648
649 if (m_jpegHuffmanTable->m_huffmanData[i].m_tableClass == 0) // DC table
650 {
651 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
652 m_huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pDCCodeValues,
653 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint16_t),
654 &huffmanTable.m_huffCode,
655 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint16_t)));
656
657 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(m_huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pDCCodeLength,
658 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint8_t),
659 &huffmanTable.m_huffSize,
660 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint8_t)));
661 }
662 else // AC Table
663 {
664 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(m_huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pACCodeValues,
665 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t),
666 &huffmanTable.m_huffCode,
667 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t)));
668
669 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(m_huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pACCodeLength,
670 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t),
671 &huffmanTable.m_huffSize,
672 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t)));
673 }
674 }
675
676 // Send 2 huffman table commands - 1 for Luma and one for chroma for non-monchrome input formats
677 // If only one table is sent by the app (2 buffers), send the same table for Luma and chroma
678 m_repeatHuffTable = false;
679 if ((m_numHuffBuffers / 2 < JPEG_MAX_NUM_HUFF_TABLE_INDEX) && (m_jpegPicParams->m_inputSurfaceFormat != codechalJpegY8))
680 {
681 m_repeatHuffTable = true;
682
683 // Copy over huffman data to the other two data buffers for JPEG picture header
684 for (uint32_t i = 0; i < m_numHuffBuffers; i++)
685 {
686 if ((i + 2) >= JPEG_NUM_ENCODE_HUFF_BUFF)
687 {
688 return MOS_STATUS_INVALID_PARAMETER;
689 }
690 m_jpegHuffmanTable->m_huffmanData[i + 2].m_tableClass = m_jpegHuffmanTable->m_huffmanData[i].m_tableClass;
691 m_jpegHuffmanTable->m_huffmanData[i + 2].m_tableID = m_jpegHuffmanTable->m_huffmanData[i].m_tableID;
692
693 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&m_jpegHuffmanTable->m_huffmanData[i + 2].m_bits[0],
694 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_BITS,
695 &m_jpegHuffmanTable->m_huffmanData[i].m_bits[0],
696 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_BITS));
697
698 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&m_jpegHuffmanTable->m_huffmanData[i + 2].m_huffVal[0],
699 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_HUFFVAL,
700 &m_jpegHuffmanTable->m_huffmanData[i].m_huffVal[0],
701 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_HUFFVAL));
702 }
703 }
704
705 return MOS_STATUS_SUCCESS;
706 }
707
708 MOS_STATUS JpegPkt::AddSOI(PMOS_COMMAND_BUFFER cmdBuffer) const
709 {
710 ENCODE_FUNC_CALL();
711 ENCODE_CHK_NULL_RETURN(cmdBuffer);
712
713 BSBuffer bsBuffer = {};
714 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackSOI(&bsBuffer));
715
716 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
717 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
718 if (dataBitsInLastDw == 0)
719 {
720 dataBitsInLastDw = 32;
721 }
722
723 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
724 params = {};
725 params.dwPadding = ((byteSize + 3) >> 2);
726 params.bitstreamstartresetResetbitstreamstartingpos = 1;
727 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
728
729 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
730
731 // Add actual data
732 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
733 MOS_STATUS eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
734
735 MOS_SafeFreeMemory(bsBuffer.pBase);
736
737 return eStatus;
738 }
739
740 MOS_STATUS JpegPkt::AddApplicationData(PMOS_COMMAND_BUFFER cmdBuffer) const
741 {
742 ENCODE_FUNC_CALL();
743 ENCODE_CHK_NULL_RETURN(cmdBuffer);
744
745 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
746
747 BSBuffer bsBuffer = {};
748 uint32_t appDataChunkSize = m_basicFeature->m_appDataSize;
749 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
750
751 // We can write a maximum of 1020 words per command, so if the size of the app data is
752 // more than 1020 we need to send multiple commands for writing out app data
753 uint32_t numAppDataCmdsNeeded = 1;
754 uint32_t appDataCmdSizeResidue = 0;
755 if (m_basicFeature->m_appDataSize > 1020)
756 {
757 numAppDataCmdsNeeded = m_basicFeature->m_appDataSize / 1020;
758 appDataCmdSizeResidue = m_basicFeature->m_appDataSize % 1020;
759
760 appDataChunkSize = 1020;
761 }
762
763 uint8_t *appDataChunk = (uint8_t *)MOS_AllocAndZeroMemory(appDataChunkSize);
764 ENCODE_CHK_NULL_RETURN(appDataChunk)
765
766 for (uint32_t i = 0; i < numAppDataCmdsNeeded; i++)
767 {
768 uint8_t *copyAddress = (uint8_t *)(m_applicationData) + (i * appDataChunkSize);
769
770 MOS_SecureMemcpy(appDataChunk, appDataChunkSize, copyAddress, appDataChunkSize);
771 eStatus = m_jpgPkrFeature->PackApplicationData(&bsBuffer, appDataChunk, appDataChunkSize);
772 if (eStatus != MOS_STATUS_SUCCESS)
773 {
774 MOS_SafeFreeMemory(appDataChunk);
775 ENCODE_CHK_STATUS_RETURN(eStatus);
776 }
777
778 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
779 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
780 if (dataBitsInLastDw == 0)
781 {
782 dataBitsInLastDw = 32;
783 }
784
785 params = {};
786 params.dwPadding = ((byteSize + 3) >> 2);
787 params.bitstreamstartresetResetbitstreamstartingpos = 1;
788 //if full header is included in application data, it will be the last header to insert and last chunk of it should be marked with EndOfSlice
789 if ((appDataCmdSizeResidue == 0) && m_basicFeature->m_fullHeaderInAppData && (i == numAppDataCmdsNeeded - 1))
790 {
791 params.endofsliceflagLastdstdatainsertcommandflag = true;
792 params.lastheaderflagLastsrcheaderdatainsertcommandflag = true;
793 }
794 else
795 {
796 params.endofsliceflagLastdstdatainsertcommandflag = false;
797 params.lastheaderflagLastsrcheaderdatainsertcommandflag = false;
798 }
799 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
800
801 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
802
803 // Add actual data
804 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
805 eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
806 if (eStatus != MOS_STATUS_SUCCESS)
807 {
808 MOS_SafeFreeMemory(appDataChunk);
809 ENCODE_CHK_STATUS_RETURN(eStatus);
810 }
811 }
812
813 if (appDataCmdSizeResidue != 0)
814 {
815 uint8_t *lastAddress = (uint8_t *)(m_applicationData) + (numAppDataCmdsNeeded * appDataChunkSize);
816 appDataChunkSize = appDataCmdSizeResidue;
817
818 MOS_SecureMemcpy(appDataChunk, appDataChunkSize, lastAddress, appDataChunkSize);
819
820 eStatus = m_jpgPkrFeature->PackApplicationData(&bsBuffer, appDataChunk, appDataChunkSize);
821 if (eStatus != MOS_STATUS_SUCCESS)
822 {
823 MOS_SafeFreeMemory(appDataChunk);
824 ENCODE_CHK_STATUS_RETURN(eStatus);
825 }
826
827 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
828 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
829 if (dataBitsInLastDw == 0)
830 {
831 dataBitsInLastDw = 32;
832 }
833
834 params = {};
835 params.dwPadding = ((byteSize + 3) >> 2);
836 params.bitstreamstartresetResetbitstreamstartingpos = 1;
837 //if full header is included in application data, it will be the last insert headers
838 if (m_basicFeature->m_fullHeaderInAppData)
839 {
840 params.endofsliceflagLastdstdatainsertcommandflag = true;
841 params.lastheaderflagLastsrcheaderdatainsertcommandflag = true;
842 }
843 else
844 {
845 params.endofsliceflagLastdstdatainsertcommandflag = false;
846 params.lastheaderflagLastsrcheaderdatainsertcommandflag = false;
847 }
848 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
849
850 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
851
852 // Add actual data
853 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
854 eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
855 if (eStatus != MOS_STATUS_SUCCESS)
856 {
857 MOS_SafeFreeMemory(appDataChunk);
858 ENCODE_CHK_STATUS_RETURN(eStatus);
859 }
860 }
861
862 MOS_FreeMemory(appDataChunk);
863
864 return eStatus;
865 }
866
867 MOS_STATUS JpegPkt::AddQuantTable(PMOS_COMMAND_BUFFER cmdBuffer, bool useSingleDefaultQuantTable) const
868 {
869 ENCODE_FUNC_CALL();
870 ENCODE_CHK_NULL_RETURN(cmdBuffer);
871
872 // Add Quant Table for Y
873 BSBuffer bsBuffer = {};
874 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackQuantTable(&bsBuffer, jpegComponentY));
875
876 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
877 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
878 if (dataBitsInLastDw == 0)
879 {
880 dataBitsInLastDw = 32;
881 }
882
883 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
884 params = {};
885 params.dwPadding = ((byteSize + 3) >> 2);
886 params.bitstreamstartresetResetbitstreamstartingpos = 1;
887 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
888
889 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
890
891 // Add actual data
892 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
893 MOS_STATUS eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
894
895 MOS_SafeFreeMemory(bsBuffer.pBase);
896
897 ENCODE_CHK_STATUS_RETURN(eStatus);
898
899 if (!useSingleDefaultQuantTable)
900 {
901 // Since there is no U and V in monochrome format, donot add Quantization table header for U and V components
902 if (m_jpegPicParams->m_inputSurfaceFormat != codechalJpegY8)
903 {
904 // Add quant table for U
905 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackQuantTable(&bsBuffer, jpegComponentU));
906
907 byteSize = (bsBuffer.BufferSize + 7) >> 3;
908 dataBitsInLastDw = bsBuffer.BufferSize % 32;
909 if (dataBitsInLastDw == 0)
910 {
911 dataBitsInLastDw = 32;
912 }
913
914 params = {};
915 params.dwPadding = ((byteSize + 3) >> 2);
916 params.bitstreamstartresetResetbitstreamstartingpos = 1;
917 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
918
919 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
920
921 // Add actual data
922 data = (uint8_t*)(bsBuffer.pBase);
923 eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
924
925 MOS_SafeFreeMemory(bsBuffer.pBase);
926
927 ENCODE_CHK_STATUS_RETURN(eStatus);
928
929 // Add quant table for V
930 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackQuantTable(&bsBuffer, jpegComponentV));
931
932 byteSize = (bsBuffer.BufferSize + 7) >> 3;
933 dataBitsInLastDw = bsBuffer.BufferSize % 32;
934 if (dataBitsInLastDw == 0)
935 {
936 dataBitsInLastDw = 32;
937 }
938
939 params = {};
940 params.dwPadding = ((byteSize + 3) >> 2);
941 params.bitstreamstartresetResetbitstreamstartingpos = 1;
942 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
943
944 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
945
946 // Add actual data
947 data = (uint8_t*)(bsBuffer.pBase);
948 eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
949
950 MOS_SafeFreeMemory(bsBuffer.pBase);
951
952 ENCODE_CHK_STATUS_RETURN(eStatus);
953 }
954 }
955
956 return eStatus;
957 }
958
959 MOS_STATUS JpegPkt::AddFrameHeader(PMOS_COMMAND_BUFFER cmdBuffer, bool useSingleDefaultQuantTable) const
960 {
961 ENCODE_FUNC_CALL();
962 ENCODE_CHK_NULL_RETURN(cmdBuffer);
963
964 BSBuffer bsBuffer = {};
965 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackFrameHeader(&bsBuffer, useSingleDefaultQuantTable));
966
967 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
968 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
969 if (dataBitsInLastDw == 0)
970 {
971 dataBitsInLastDw = 32;
972 }
973
974 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
975 params = {};
976 params.dwPadding = ((byteSize + 3) >> 2);
977 params.bitstreamstartresetResetbitstreamstartingpos = 1;
978 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
979
980 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
981
982 // Add actual data
983 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
984 MOS_STATUS eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
985
986 MOS_SafeFreeMemory(bsBuffer.pBase);
987
988 return eStatus;
989 }
990
991 MOS_STATUS JpegPkt::AddHuffmanTable(PMOS_COMMAND_BUFFER cmdBuffer, uint32_t tblInd) const
992 {
993 ENCODE_FUNC_CALL();
994 ENCODE_CHK_NULL_RETURN(cmdBuffer);
995
996 BSBuffer bsBuffer = {};
997 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackHuffmanTable(&bsBuffer, tblInd));
998
999 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
1000 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
1001 if (dataBitsInLastDw == 0)
1002 {
1003 dataBitsInLastDw = 32;
1004 }
1005
1006 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
1007 params = {};
1008 params.dwPadding = ((byteSize + 3) >> 2);
1009 params.bitstreamstartresetResetbitstreamstartingpos = 1;
1010 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
1011
1012 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
1013
1014 // Add actual data
1015 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
1016 MOS_STATUS eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
1017
1018 MOS_SafeFreeMemory(bsBuffer.pBase);
1019
1020 return eStatus;
1021 }
1022
1023 MOS_STATUS JpegPkt::AddRestartInterval(PMOS_COMMAND_BUFFER cmdBuffer) const
1024 {
1025 ENCODE_FUNC_CALL();
1026 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1027
1028 BSBuffer bsBuffer = {};
1029 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackRestartInterval(&bsBuffer));
1030
1031 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
1032 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
1033 if (dataBitsInLastDw == 0)
1034 {
1035 dataBitsInLastDw = 32;
1036 }
1037
1038 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
1039 params = {};
1040 params.dwPadding = ((byteSize + 3) >> 2);
1041 params.bitstreamstartresetResetbitstreamstartingpos = 1;
1042 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
1043
1044 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
1045
1046 // Add actual data
1047 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
1048 MOS_STATUS eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
1049
1050 MOS_SafeFreeMemory(bsBuffer.pBase);
1051
1052 return eStatus;
1053 }
1054
1055 MOS_STATUS JpegPkt::AddScanHeader(PMOS_COMMAND_BUFFER cmdBuffer) const
1056 {
1057 ENCODE_FUNC_CALL();
1058 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1059
1060 BSBuffer bsBuffer = {};
1061 ENCODE_CHK_STATUS_RETURN(m_jpgPkrFeature->PackScanHeader(&bsBuffer));
1062
1063 uint32_t byteSize = (bsBuffer.BufferSize + 7) >> 3;
1064 uint32_t dataBitsInLastDw = bsBuffer.BufferSize % 32;
1065 if (dataBitsInLastDw == 0)
1066 {
1067 dataBitsInLastDw = 32;
1068 }
1069
1070 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_PAK_INSERT_OBJECT)();
1071 params = {};
1072 params.dwPadding = ((byteSize + 3) >> 2);
1073 params.bitstreamstartresetResetbitstreamstartingpos = 1;
1074 params.endofsliceflagLastdstdatainsertcommandflag = true;
1075 params.lastheaderflagLastsrcheaderdatainsertcommandflag = true;
1076 params.databitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
1077
1078 m_mfxItf->MHW_ADDCMD_F(MFX_PAK_INSERT_OBJECT)(cmdBuffer);
1079
1080 // Add actual data
1081 uint8_t* data = (uint8_t*)(bsBuffer.pBase);
1082 MOS_STATUS eStatus = Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, nullptr, data, byteSize);
1083
1084 MOS_SafeFreeMemory(bsBuffer.pBase);
1085
1086 return eStatus;
1087 }
1088
1089 // Implemented based on table K.5 in JPEG spec
1090 uint8_t JpegPkt::MapHuffValIndex(uint8_t huffValIndex)
1091 {
1092 ENCODE_FUNC_CALL();
1093
1094 uint8_t mappedIndex = 0;
1095
1096 if (huffValIndex < 0xF0)
1097 {
1098 mappedIndex = (((huffValIndex >> 4) & 0x0F) * 0xA) + (huffValIndex & 0x0F);
1099 }
1100 else
1101 {
1102 mappedIndex = (((huffValIndex >> 4) & 0x0F) * 0xA) + (huffValIndex & 0x0F) + 1;
1103 }
1104
1105 return mappedIndex;
1106 }
1107
1108 // Implemented based on Flowchart in figure C.1 in JPEG spec
1109 MOS_STATUS JpegPkt::GenerateSizeTable(
1110 uint8_t bits[],
1111 uint8_t huffSize[],
1112 uint8_t &lastK)
1113 {
1114 ENCODE_FUNC_CALL();
1115
1116 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1117
1118 uint8_t i = 1, j = 1;
1119 uint8_t k = 0;
1120 while (i <= 16)
1121 {
1122 while (j <= (int8_t)bits[i - 1]) // bits index is from 0 to 15
1123 {
1124 huffSize[k] = i;
1125 k = k + 1;
1126 j = j + 1;
1127 }
1128
1129 i++;
1130 j = 1;
1131 }
1132
1133 huffSize[k] = 0;
1134 lastK = k;
1135
1136 return eStatus;
1137 }
1138
1139 // Implemented based on Flowchart in figure C.2 in JPEG spec
1140 MOS_STATUS JpegPkt::GenerateCodeTable(
1141 uint8_t huffSize[],
1142 uint16_t huffCode[])
1143 {
1144 ENCODE_FUNC_CALL();
1145
1146 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1147
1148 uint8_t k = 0;
1149 uint8_t si = huffSize[0];
1150 uint16_t code = 0;
1151 while (huffSize[k] != 0)
1152 {
1153 while (huffSize[k] == si)
1154 {
1155 if (code == 0xFFFF)
1156 {
1157 // Invalid code generated - replace with all zeroes
1158 code = 0x0000;
1159 }
1160
1161 huffCode[k] = code;
1162 code = code + 1;
1163 k = k + 1;
1164 }
1165
1166 code <<= 1;
1167 si = si + 1;
1168 }
1169
1170 return eStatus;
1171 }
1172
1173 // Implemented based on Flowchart in figure C.3 in JPEG spec
1174 MOS_STATUS JpegPkt::OrderCodes(
1175 uint8_t huffVal[],
1176 uint8_t huffSize[],
1177 uint16_t huffCode[],
1178 uint8_t lastK)
1179 {
1180 ENCODE_FUNC_CALL();
1181
1182 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1183
1184 uint16_t eHuffCo[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL];
1185 uint8_t eHuffSi[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL];
1186 MOS_ZeroMemory(&eHuffCo[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t));
1187 MOS_ZeroMemory(&eHuffSi[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t));
1188
1189 uint8_t k = 0;
1190 do
1191 {
1192 uint8_t i = MapHuffValIndex((uint8_t)huffVal[k]);
1193 if (i >= JPEG_NUM_HUFF_TABLE_AC_HUFFVAL)
1194 {
1195 ENCODE_ASSERT(false);
1196 return MOS_STATUS_UNKNOWN;
1197 }
1198 eHuffCo[i] = huffCode[k];
1199 eHuffSi[i] = huffSize[k];
1200 k++;
1201 } while (k < lastK);
1202
1203 // copy over the first 162 values of reordered arrays to Huffman Code and size arrays
1204 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&huffCode[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t), &eHuffCo[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t)));
1205 ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&huffSize[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t), &eHuffSi[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t)));
1206
1207 return eStatus;
1208 }
1209
1210 MOS_STATUS JpegPkt::ConvertHuffDataToTable(
1211 CodecEncodeJpegHuffData huffmanData,
1212 EncodeJpegHuffTable * huffmanTable)
1213 {
1214 ENCODE_FUNC_CALL();
1215
1216 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1217
1218 huffmanTable->m_tableClass = huffmanData.m_tableClass;
1219 huffmanTable->m_tableID = huffmanData.m_tableID;
1220
1221 uint8_t lastK = 0;
1222
1223 // Step 1 : Generate size table
1224 ENCODE_CHK_STATUS_RETURN(GenerateSizeTable(huffmanData.m_bits, huffmanTable->m_huffSize, lastK));
1225
1226 // Step2: Generate code table
1227 ENCODE_CHK_STATUS_RETURN(GenerateCodeTable(huffmanTable->m_huffSize, huffmanTable->m_huffCode));
1228
1229 // Step 3: Order codes
1230 ENCODE_CHK_STATUS_RETURN(OrderCodes(huffmanData.m_huffVal, huffmanTable->m_huffSize, huffmanTable->m_huffCode, lastK));
1231
1232 return eStatus;
1233 }
1234
1235 uint32_t JpegPkt::CalculateCommandBufferSize()
1236 {
1237 ENCODE_FUNC_CALL();
1238 uint32_t commandBufferSize =
1239 m_pictureStatesSize +
1240 (m_sliceStatesSize * m_basicFeature->m_numSlices);
1241
1242 // For JPEG encoder, add the size of PAK_INSERT_OBJ commands which is also part of command buffer
1243 if (m_basicFeature->m_standard == CODECHAL_JPEG)
1244 {
1245 // Add PAK_INSERT_OBJ for app data
1246 // PAK_INSERT_OBJ contains 2 DWORDS + bytes of payload data
1247 // There is a max of 1024 payload bytes of app data per PAK_INSERT_OBJ command, so adding 2 DWORDS for each of them
1248 // Total payload data is the same size as app data
1249 commandBufferSize += (m_basicFeature->m_appDataSize + (2 * sizeof(uint32_t) * (m_basicFeature->m_appDataSize / 1020 + 1))); //to be consistent with how we split app data into chunks.
1250
1251 // Add number of bytes of data added through PAK_INSERT_OBJ command
1252 commandBufferSize += (2 + // SOI = 2 bytes
1253 // Frame header - add sizes of each component of CodechalEncodeJpegFrameHeader
1254 (2 * sizeof(uint8_t)) + (4 * sizeof(uint16_t)) + 3 * sizeof(uint8_t)* jpegNumComponent +
1255 // AC and DC Huffman tables - 2 Huffman tables for each component, and 3 components
1256 (2 * 3 * sizeof(EncodeJpegHuffmanHeader)) +
1257 // Quant tables - 1 for Quant table of each component, so 3 quant tables per frame
1258 (3 * sizeof(EncodeJpegQuantHeader)) +
1259 // Restart interval - 1 per frame
1260 sizeof(EncodeJpegRestartHeader) +
1261 // Scan header - 1 per frame
1262 sizeof(EncodeJpegScanHeader));
1263 }
1264
1265 if (m_pipeline->IsSingleTaskPhaseSupported())
1266 {
1267 commandBufferSize *= (m_pipeline->GetPassNum() + 1);
1268 }
1269
1270 // 4K align since allocation is in chunks of 4K bytes.
1271 commandBufferSize = MOS_ALIGN_CEIL(commandBufferSize, 0x1000);
1272
1273 return commandBufferSize;
1274 }
1275
1276 uint32_t JpegPkt::CalculatePatchListSize()
1277 {
1278 ENCODE_FUNC_CALL();
1279 uint32_t requestedPatchListSize = 0;
1280 if (m_usePatchList)
1281 {
1282 requestedPatchListSize =
1283 m_picturePatchListSize +
1284 (m_slicePatchListSize * m_basicFeature->m_numSlices);
1285
1286 if (m_pipeline->IsSingleTaskPhaseSupported())
1287 {
1288 requestedPatchListSize *= m_pipeline->GetPassNum();
1289 }
1290 }
1291 return requestedPatchListSize;
1292 }
1293
1294 MOS_STATUS JpegPkt::AddAllCmds_MFX_FQM_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const
1295 {
1296 ENCODE_FUNC_CALL();
1297 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1298
1299 auto &params = m_mfxItf->MHW_GETPAR_F(MFX_FQM_STATE)();
1300
1301 for (uint8_t i = 0; i < m_numQuantTables; i++)
1302 {
1303 params = {};
1304 params.qmType = i;
1305
1306 auto j = 0;
1307 // Copy over 32 uint32_t worth of values - Each uint32_t will contain 2 16 bit quantizer values
1308 // where for the DWordx Bits [15: 0] = 1/QM[0][x] Bits[32:16] = 1/QM[1][x]
1309 for (auto k = 0; k < 8; k++)
1310 {
1311 for (auto l = k; l < 64; l += 16)
1312 {
1313 params.quantizermatrix[j] = ((GetReciprocalScalingValue(m_jpegQuantMatrix.m_quantMatrix[i][l + 8]) << 16) |
1314 GetReciprocalScalingValue(m_jpegQuantMatrix.m_quantMatrix[i][l]));
1315 j++;
1316 }
1317 }
1318
1319 m_mfxItf->MHW_ADDCMD_F(MFX_FQM_STATE)(cmdBuffer);
1320 }
1321
1322 return MOS_STATUS_SUCCESS;
1323 }
1324
1325 MOS_STATUS JpegPkt::AddAllCmds_MFC_JPEG_HUFF_TABLE_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const
1326 {
1327 ENCODE_FUNC_CALL();
1328 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1329
1330 auto &params = m_mfxItf->MHW_GETPAR_F(MFC_JPEG_HUFF_TABLE_STATE)();
1331
1332 // the number of huffman commands is half of the huffman buffers sent by the app, since AC and DC buffers are combined into one command
1333 for (uint32_t i = 0; i < m_numHuffBuffers / 2; i++)
1334 {
1335 params = {};
1336 params.huffTableId = (uint8_t)m_huffTableParams[i].HuffTableID;
1337
1338 // cmd DWORDS 2:13 for DC Table
1339 // Format- 3Bytes: Byte0 for Code length, Byte1 and Byte2 for Code word, and Byte3 for dummy
1340 for (auto j = 0; j < JPEG_NUM_HUFF_TABLE_DC_HUFFVAL; j++)
1341 {
1342 params.dcTable[j] = 0;
1343 params.dcTable[j] = (m_huffTableParams[i].pDCCodeLength[j] & 0xFF) |
1344 ((m_huffTableParams[i].pDCCodeValues[j] & 0xFFFF) << 8);
1345 }
1346
1347 // cmd DWORDS 14:175 for AC table
1348 // Format- 3Bytes: Byte0 for Code length, Byte1 and Byte2 for Code word, and Byte3 for dummy
1349 for (auto j = 0; j < JPEG_NUM_HUFF_TABLE_AC_HUFFVAL; j++)
1350 {
1351 params.acTable[j] = 0;
1352 params.acTable[j] = (m_huffTableParams[i].pACCodeLength[j] & 0xFF) |
1353 ((m_huffTableParams[i].pACCodeValues[j] & 0xFFFF) << 8);
1354 }
1355
1356 if (m_repeatHuffTable)
1357 {
1358 m_mfxItf->MHW_ADDCMD_F(MFC_JPEG_HUFF_TABLE_STATE)(cmdBuffer);
1359 }
1360 m_mfxItf->MHW_ADDCMD_F(MFC_JPEG_HUFF_TABLE_STATE)(cmdBuffer);
1361 }
1362
1363 return MOS_STATUS_SUCCESS;
1364 }
1365
1366 MOS_STATUS JpegPkt::AddAllCmds_MFX_PAK_INSERT_OBJECT(PMOS_COMMAND_BUFFER cmdBuffer) const
1367 {
1368 ENCODE_FUNC_CALL();
1369 ENCODE_CHK_NULL_RETURN(cmdBuffer);
1370
1371 MOS_SURFACE *surface = m_basicFeature->m_rawSurfaceToPak;
1372 bool useSingleDefaultQuantTable = (m_basicFeature->m_jpegQuantMatrixSent == false &&
1373 ((surface->Format == Format_A8R8G8B8) ||
1374 (surface->Format == Format_X8R8G8B8) ||
1375 (surface->Format == Format_A8B8G8R8) ||
1376 (surface->Format == Format_X8B8G8R8)));
1377
1378 if (!m_basicFeature->m_fullHeaderInAppData)
1379 {
1380 // Add SOI (0xFFD8) (only if it was sent by the application)
1381 ENCODE_CHK_STATUS_RETURN(AddSOI(cmdBuffer));
1382 }
1383 // Add Application data if it was sent by application
1384 if (m_applicationData != nullptr)
1385 {
1386 ENCODE_CHK_STATUS_RETURN(AddApplicationData(cmdBuffer));
1387 }
1388 if (!m_basicFeature->m_fullHeaderInAppData)
1389 {
1390 ENCODE_CHK_STATUS_RETURN(AddQuantTable(cmdBuffer, useSingleDefaultQuantTable));
1391
1392 ENCODE_CHK_STATUS_RETURN(AddFrameHeader(cmdBuffer, useSingleDefaultQuantTable));
1393
1394 // Add Huffman Table for Y - DC table, Y- AC table, U/V - DC table, U/V - AC table
1395 for (uint32_t i = 0; i < m_numHuffBuffers; i++)
1396 {
1397 ENCODE_CHK_STATUS_RETURN(AddHuffmanTable(cmdBuffer, i));
1398 }
1399
1400 // Restart Interval - Add only if the restart interval is not zero
1401 if (m_jpegScanParams->m_restartInterval != 0)
1402 {
1403 ENCODE_CHK_STATUS_RETURN(AddRestartInterval(cmdBuffer));
1404 }
1405
1406 ENCODE_CHK_STATUS_RETURN(AddScanHeader(cmdBuffer));
1407 }
1408
1409 return MOS_STATUS_SUCCESS;
1410 }
1411
1412 MHW_SETPAR_DECL_SRC(MI_STORE_REGISTER_MEM, JpegPkt)
1413 {
1414 params.presStoreBuffer = m_pResource;
1415 params.dwOffset = m_dwOffset;
1416 params.dwRegister = m_dwValue;
1417
1418 return MOS_STATUS_SUCCESS;
1419 }
1420
1421 #if USE_CODECHAL_DEBUG_TOOL
1422 MOS_STATUS JpegPkt::DumpResources(
1423 EncodeStatusMfx * encodeStatusMfx,
1424 EncodeStatusReportData *statusReportData)
1425 {
1426 ENCODE_FUNC_CALL();
1427
1428 ENCODE_CHK_NULL_RETURN(encodeStatusMfx);
1429 ENCODE_CHK_NULL_RETURN(statusReportData);
1430 ENCODE_CHK_NULL_RETURN(m_pipeline);
1431 ENCODE_CHK_NULL_RETURN(m_statusReport);
1432 ENCODE_CHK_NULL_RETURN(m_basicFeature);
1433 ENCODE_CHK_NULL_RETURN(m_basicFeature->m_trackedBuf);
1434
1435 if (m_jpegPicParams)
1436 {
1437 ENCODE_CHK_STATUS_RETURN(DumpPicParams(
1438 m_jpegPicParams));
1439 }
1440
1441 if (m_jpegScanParams)
1442 {
1443 ENCODE_CHK_STATUS_RETURN(DumpScanParams(
1444 m_jpegScanParams));
1445 }
1446
1447 if (m_jpegHuffmanTable)
1448 {
1449 ENCODE_CHK_STATUS_RETURN(DumpHuffmanTable(
1450 m_jpegHuffmanTable));
1451 }
1452
1453 if (m_jpegQuantTables)
1454 {
1455 ENCODE_CHK_STATUS_RETURN(DumpQuantTables(
1456 m_jpegQuantTables));
1457 }
1458
1459 CodechalDebugInterface *debugInterface = m_pipeline->GetStatusReportDebugInterface();
1460 ENCODE_CHK_NULL_RETURN(debugInterface);
1461
1462 CODEC_REF_LIST currRefList = *((CODEC_REF_LIST *)statusReportData->currRefList);
1463 currRefList.RefPic = statusReportData->currOriginalPic;
1464
1465 debugInterface->m_currPic = statusReportData->currOriginalPic;
1466 debugInterface->m_bufferDumpFrameNum = m_statusReport->GetReportedCount() + 1; // ToDo: for debug purpose
1467 debugInterface->m_frameType = encodeStatusMfx->pictureCodingType;
1468
1469 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpBuffer(
1470 &currRefList.resBitstreamBuffer,
1471 CodechalDbgAttr::attrBitstream,
1472 "_PAK",
1473 statusReportData->bitstreamSize,
1474 0,
1475 CODECHAL_NUM_MEDIA_STATES));
1476
1477 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpData(
1478 statusReportData,
1479 sizeof(EncodeStatusReportData),
1480 CodechalDbgAttr::attrStatusReport,
1481 "EncodeStatusReport_Buffer"));
1482
1483 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpYUVSurface(
1484 &currRefList.sRefRawBuffer,
1485 CodechalDbgAttr::attrEncodeRawInputSurface,
1486 "SrcSurf"))
1487
1488 ENCODE_CHK_STATUS_RETURN(debugInterface->DumpEncodeStatusReport(
1489 statusReportData));
1490
1491 return MOS_STATUS_SUCCESS;
1492 }
1493
1494 MOS_STATUS JpegPkt::DumpHuffmanTable(
1495 CodecEncodeJpegHuffmanDataArray *huffmanTable)
1496 {
1497 ENCODE_FUNC_CALL();
1498
1499 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrHuffmanTbl))
1500 {
1501 return MOS_STATUS_SUCCESS;
1502 }
1503
1504 ENCODE_CHK_NULL_RETURN(huffmanTable);
1505
1506 std::ostringstream oss;
1507 oss.setf(std::ios::showbase | std::ios::uppercase);
1508
1509 //Dump HuffTable[JPEG_MAX_NUM_HUFF_TABLE_INDEX]
1510 for (uint32_t i = 0; i < JPEG_NUM_ENCODE_HUFF_BUFF; ++i)
1511 {
1512 // Dump Table Class
1513 oss << "TableClass: " << +huffmanTable->m_huffmanData[i].m_tableClass << std::endl;
1514 // Dump Table ID
1515 oss << "TableID: " << +huffmanTable->m_huffmanData[i].m_tableID << std::endl;
1516 //Dump ucBits[JPEG_NUM_HUFF_TABLE_AC_BITS]
1517 oss << "HuffTable[" << +i << "].ucBits[0-" << (JPEG_NUM_HUFF_TABLE_AC_BITS - 1) << "]: " << std::endl;
1518
1519 for (uint32_t j = 0; j < JPEG_NUM_HUFF_TABLE_AC_BITS; ++j)
1520 {
1521 oss << +huffmanTable->m_huffmanData[i].m_bits[j];
1522 if (j % 6 == 5 || j == JPEG_NUM_HUFF_TABLE_AC_BITS - 1)
1523 {
1524 oss << std::endl;
1525 }
1526 }
1527
1528 //Dump ucHuffVal[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL]
1529 oss << "HuffTable[" << +i << "].ucHuffVal[0-" << (JPEG_NUM_HUFF_TABLE_AC_HUFFVAL - 1) << "]: " << std::endl;
1530
1531 for (uint32_t j = 0; j < JPEG_NUM_HUFF_TABLE_AC_HUFFVAL; ++j)
1532 {
1533 oss << +huffmanTable->m_huffmanData[i].m_huffVal[j];
1534 if (j % 6 == 5 || j == JPEG_NUM_HUFF_TABLE_AC_HUFFVAL - 1)
1535 {
1536 oss << std::endl;
1537 }
1538 }
1539 }
1540
1541 const char *fileName = m_debugInterface->CreateFileName(
1542 "_ENC",
1543 CodechalDbgBufferType::bufHuffmanTbl,
1544 CodechalDbgExtType::txt);
1545
1546 std::ofstream ofs(fileName, std::ios::out);
1547 ofs << oss.str();
1548 ofs.close();
1549 return MOS_STATUS_SUCCESS;
1550 }
1551
1552 MOS_STATUS JpegPkt::DumpPicParams(
1553 CodecEncodeJpegPictureParams *picParams)
1554 {
1555 ENCODE_FUNC_CALL();
1556 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
1557 {
1558 return MOS_STATUS_SUCCESS;
1559 }
1560
1561 ENCODE_CHK_NULL_RETURN(picParams);
1562
1563 std::ostringstream oss;
1564 oss.setf(std::ios::showbase | std::ios::uppercase);
1565
1566 oss << "Profile: " << +picParams->m_profile << std::endl;
1567 oss << "Progressive: " << +picParams->m_progressive << std::endl;
1568 oss << "Huffman: " << +picParams->m_huffman << std::endl;
1569 oss << "Interleaved: " << +picParams->m_interleaved << std::endl;
1570 oss << "Differential: " << +picParams->m_differential << std::endl;
1571 oss << "PicWidth: " << +picParams->m_picWidth << std::endl;
1572 oss << "PicHeight: " << +picParams->m_picHeight << std::endl;
1573 oss << "InputSurfaceFormat: " << +picParams->m_inputSurfaceFormat << std::endl;
1574 oss << "SampleBitDepth: " << +picParams->m_sampleBitDepth << std::endl;
1575 oss << "uiNumComponent: " << +picParams->m_numComponent << std::endl;
1576
1577 //Dump componentIdentifier[jpegNumComponent]
1578 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1579 {
1580 oss << "ComponentIdentifier[" << +i << "]: " << +picParams->m_componentID[i] << std::endl;
1581 }
1582
1583 //Dump quantTableSelector[jpegNumComponent]
1584 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1585 {
1586 oss << "QuantTableSelector[" << +i << "]: " << +picParams->m_quantTableSelector[i] << std::endl;
1587 }
1588 oss << "Quality: " << +picParams->m_quality << std::endl;
1589 oss << "NumScan: " << +picParams->m_numScan << std::endl;
1590 oss << "NumQuantTable: " << +picParams->m_numQuantTable << std::endl;
1591 oss << "NumCodingTable: " << +picParams->m_numCodingTable << std::endl;
1592 oss << "StatusReportFeedbackNumber: " << +picParams->m_statusReportFeedbackNumber << std::endl;
1593
1594 const char *fileName = m_debugInterface->CreateFileName(
1595 "_ENC",
1596 CodechalDbgBufferType::bufPicParams,
1597 CodechalDbgExtType::txt);
1598
1599 std::ofstream ofs(fileName, std::ios::out);
1600 ofs << oss.str();
1601 ofs.close();
1602 return MOS_STATUS_SUCCESS;
1603 }
1604
1605 MOS_STATUS JpegPkt::DumpScanParams(
1606 CodecEncodeJpegScanHeader *scanParams)
1607 {
1608 ENCODE_FUNC_CALL();
1609
1610 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrScanParams))
1611 {
1612 return MOS_STATUS_SUCCESS;
1613 }
1614
1615 ENCODE_CHK_NULL_RETURN(scanParams);
1616
1617 std::ostringstream oss;
1618 oss.setf(std::ios::showbase | std::ios::uppercase);
1619
1620 oss << "RestartInterval: " << +scanParams->m_restartInterval << std::endl;
1621 oss << "NumComponents: " << +scanParams->m_numComponent << std::endl;
1622
1623 //Dump ComponentSelector[jpegNumComponent]
1624 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1625 {
1626 oss << "ComponentSelector[" << +i << "]: " << +scanParams->m_componentSelector[i] << std::endl;
1627 }
1628
1629 //Dump DcHuffTblSelector[jpegNumComponent]
1630 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1631 {
1632 oss << "DcHuffTblSelector[" << +i << "]: " << +scanParams->m_dcCodingTblSelector[i] << std::endl;
1633 }
1634
1635 //Dump AcHuffTblSelector[jpegNumComponent]
1636 for (uint32_t i = 0; i < jpegNumComponent; ++i)
1637 {
1638 oss << "AcHuffTblSelector[" << +i << "]: " << +scanParams->m_acCodingTblSelector[i] << std::endl;
1639 }
1640
1641 const char *fileName = m_debugInterface->CreateFileName(
1642 "_ENC",
1643 CodechalDbgBufferType::bufScanParams,
1644 CodechalDbgExtType::txt);
1645
1646 std::ofstream ofs(fileName, std::ios::out);
1647 ofs << oss.str();
1648 ofs.close();
1649
1650 return MOS_STATUS_SUCCESS;
1651 }
1652
1653 MOS_STATUS JpegPkt::DumpQuantTables(
1654 CodecEncodeJpegQuantTable *quantTable)
1655 {
1656 ENCODE_FUNC_CALL();
1657
1658 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrIqParams))
1659 {
1660 return MOS_STATUS_SUCCESS;
1661 }
1662
1663 ENCODE_CHK_NULL_RETURN(quantTable);
1664
1665 std::ostringstream oss;
1666 oss.setf(std::ios::showbase | std::ios::uppercase);
1667
1668 //Dump quantTable[JPEG_MAX_NUM_QUANT_TABLE_INDEX]
1669 for (uint32_t i = 0; i < JPEG_MAX_NUM_QUANT_TABLE_INDEX; ++i)
1670 {
1671 // Dump Table ID
1672 oss << "TableID: " << +quantTable->m_quantTable[i].m_tableID << std::endl;
1673 // Dump Precision
1674 oss << "TableID: " << +quantTable->m_quantTable[i].m_precision << std::endl;
1675 //Dump usQm[JPEG_NUM_QUANTMATRIX];
1676 oss << "quantTable[" << +i << "].usQm[0-" << (JPEG_NUM_QUANTMATRIX - 1) << "]: " << std::endl;
1677
1678 for (uint32_t j = 0; j < JPEG_NUM_QUANTMATRIX; ++j)
1679 {
1680 oss << +quantTable->m_quantTable[i].m_qm[j];
1681 if (j % 6 == 5 || j == JPEG_NUM_QUANTMATRIX - 1)
1682 {
1683 oss << std::endl;
1684 }
1685 }
1686 }
1687 const char *fileName = m_debugInterface->CreateFileName(
1688 "_ENC",
1689 CodechalDbgBufferType::bufIqParams,
1690 CodechalDbgExtType::txt);
1691
1692 std::ofstream ofs(fileName, std::ios::out);
1693 ofs << oss.str();
1694 ofs.close();
1695
1696 return MOS_STATUS_SUCCESS;
1697 }
1698 #endif
1699
1700 }