GSaha567/seq_level_training_data
052
1text,length,is_long_context,metric_val,label_metric2"/*3* Copyright (c) 2017-2018, Intel Corporation4*5* Permission is hereby granted, free of charge, to any person obtaining a6* copy of this software and associated documentation files (the ""Software""),7* to deal in the Software without restriction, including without limitation8* the rights to use, copy, modify, merge, publish, distribute, sublicense,9* and/or sell copies of the Software, and to permit persons to whom the10* Software is furnished to do so, subject to the following conditions:11*12* The above copyright notice and this permission notice shall be included13* in all copies or substantial portions of the Software.14*15* THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS16* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,17* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL18* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR19* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,20* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR21* OTHER DEALINGS IN THE SOFTWARE.22*/23//!24//! \\file codechal_encode_jpeg.cpp25//! \\brief Defines state class for JPEG encoder.26//!27 28#include ""codechal_encode_jpeg.h""29#if USE_CODECHAL_DEBUG_TOOL30#include ""codechal_debug.h""31#endif32 33MOS_STATUS CodechalEncodeJpegState::Initialize(CodechalSetting *settings)34{35 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;36 37 CODECHAL_ENCODE_FUNCTION_ENTER;38 39 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface);40 CODECHAL_ENCODE_CHK_NULL_RETURN(m_miInterface);41 CODECHAL_ENCODE_CHK_NULL_RETURN(settings);42 43 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::Initialize(settings));44 45 // Picture Level Commands46 CODECHAL_ENCODE_CHK_STATUS_RETURN(47 m_hwInterface->GetMfxStateCommandsDataSize(48 CODECHAL_ENCODE_MODE_JPEG,49 &m_pictureStatesSize,50 &m_picturePatchListSize,51 0));52 53 // Slice Level Commands (cannot be placed in 2nd level batch)54 CODECHAL_ENCODE_CHK_STATUS_RETURN(55 m_hwInterface->GetMfxPrimitiveCommandsDataSize(56 CODECHAL_ENCODE_MODE_JPEG,57 &m_sliceStatesSize,58 &m_slicePatchListSize,59 0));60 61 return eStatus;62}63 64MOS_STATUS CodechalEncodeJpegState::AllocateResources()65{66 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;67 68 CODECHAL_ENCODE_FUNCTION_ENTER;69 70 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::AllocateResources());71 72 // Allocate Ref Lists73 CodecHalAllocateDataList(74 m_refList,75 CODECHAL_NUM_UNCOMPRESSED_SURFACE_JPEG);76 77 return eStatus;78}79 80void CodechalEncodeJpegState::FreeResources()81{82 CODECHAL_ENCODE_FUNCTION_ENTER;83 84 CodechalEncoderState::FreeResources();85 86 // Release Ref Lists87 CodecHalFreeDataList(m_refList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_JPEG);88}89 90MOS_STATUS CodechalEncodeJpegState::InitializePicture(const EncoderParams& params)91{92 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;93 94 CODECHAL_ENCODE_FUNCTION_ENTER;95 96 m_bitstreamUpperBound = params.dwBitstreamSize;97 98 m_jpegPicParams = (CodecEncodeJpegPictureParams *)(params.pPicParams);99 m_jpegScanParams = (CodecEncodeJpegScanHeader *)(params.pSliceParams);100 m_jpegQuantTables = (CodecEncodeJpegQuantTable *)(params.pQuantizationTable);101 m_jpegHuffmanTable = (CodecEncodeJpegHuffmanDataArray *)(params.pHuffmanTable);102 m_applicationData = params.pApplicationData;103 m_appDataSize = params.dwAppDataSize;104 m_jpegQuantMatrixSent = params.bJpegQuantMatrixSent;105 m_fullHeaderInAppData = params.fullHeaderInAppData;106 107 CODECHAL_ENCODE_CHK_NULL_RETURN(m_jpegPicParams);108 CODECHAL_ENCODE_CHK_NULL_RETURN(m_jpegScanParams);109 CODECHAL_ENCODE_CHK_NULL_RETURN(m_jpegQuantTables);110 CODECHAL_ENCODE_CHK_NULL_RETURN(m_jpegHuffmanTable);111 112 // Set Status Report Feedback Number113 m_statusReportFeedbackNumber = m_jpegPicParams->m_statusReportFeedbackNumber;114 m_currRefList = m_refList[m_currOriginalPic.FrameIdx];115 116 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetStatusReportParams(m_refList[m_currOriginalPic.FrameIdx]));117 118 m_currRefList->resBitstreamBuffer = m_resBitstreamBuffer;119 m_currRefList->sRefRawBuffer = m_rawSurface;120 121 CODECHAL_DEBUG_TOOL(122 CODECHAL_ENCODE_CHK_NULL_RETURN(m_debugInterface);123 124 if (m_jpegPicParams)125 {126 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpPicParams(127 m_jpegPicParams));128 }129 130 if (m_jpegScanParams)131 {132 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpScanParams(133 m_jpegScanParams));134 }135 136 if (m_jpegHuffmanTable)137 {138 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpHuffmanTable(139 m_jpegHuffmanTable));140 }141 142 if (m_jpegQuantTables)143 {144 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpQuantTables(145 m_jpegQuantTables));146 }147 )148 149 return eStatus;150}151 152MOS_STATUS CodechalEncodeJpegState::CheckResChangeAndCsc()153{154 return MOS_STATUS_SUCCESS;155}156 157// Implemented based on table K.5 in JPEG spec158uint8_t CodechalEncodeJpegState::MapHuffValIndex(uint8_t huffValIndex)159{160 CODECHAL_ENCODE_FUNCTION_ENTER;161 162 uint8_t mappedIndex = 0;163 164 if (huffValIndex < 0xF0)165 {166 mappedIndex = (((huffValIndex >> 4) & 0x0F) * 0xA) + (huffValIndex & 0x0F);167 }168 else169 {170 mappedIndex = (((huffValIndex >> 4) & 0x0F) * 0xA) + (huffValIndex & 0x0F) + 1;171 }172 173 return mappedIndex;174}175 176// Implemented based on Flowchart in figure C.1 in JPEG spec177MOS_STATUS CodechalEncodeJpegState::GenerateSizeTable(178 uint8_t bits[],179 uint8_t huffSize[],180 uint8_t& lastK)181{182 CODECHAL_ENCODE_FUNCTION_ENTER;183 184 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;185 186 uint8_t i = 1, j = 1;187 uint8_t k = 0;188 while (i <= 16)189 {190 while (j <= (int8_t)bits[i - 1]) // bits index is from 0 to 15191 {192 huffSize[k] = i;193 k = k + 1;194 j = j + 1;195 }196 197 i++;198 j = 1;199 };200 201 huffSize[k] = 0;202 lastK = k;203 204 return eStatus;205}206 207// Implemented based on Flowchart in figure C.2 in JPEG spec208MOS_STATUS CodechalEncodeJpegState::GenerateCodeTable(209 uint8_t huffSize[],210 uint16_t huffCode[])211{212 CODECHAL_ENCODE_FUNCTION_ENTER;213 214 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;215 216 uint8_t k = 0;217 uint8_t si = huffSize[0];218 uint16_t code = 0;219 while (huffSize[k] != 0)220 {221 while (huffSize[k] == si)222 {223 if (code == 0xFFFF)224 {225 // Invalid code generated - replace with all zeroes226 code = 0x0000;227 }228 229 huffCode[k] = code;230 code = code + 1;231 k = k + 1;232 };233 234 code <<= 1;235 si = si + 1;236 }237 238 return eStatus;239}240 241// Implemented based on Flowchart in figure C.3 in JPEG spec242MOS_STATUS CodechalEncodeJpegState::OrderCodes(243 uint8_t huffVal[],244 uint8_t huffSize[],245 uint16_t huffCode[],246 uint8_t lastK)247{248 CODECHAL_ENCODE_FUNCTION_ENTER;249 250 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;251 252 uint16_t eHuffCo[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL];253 uint8_t eHuffSi[JPEG_NUM_HUFF_TABLE_AC_HUFFVAL];254 MOS_ZeroMemory(&eHuffCo[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t));255 MOS_ZeroMemory(&eHuffSi[0], JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t));256 257 uint8_t k = 0;258 do259 {260 uint8_t i = MapHuffValIndex((uint8_t)huffVal[k]);261 if (i >= JPEG_NUM_HUFF_TABLE_AC_HUFFVAL)262 {263 CODECHAL_ENCODE_ASSERT(false);264 return MOS_STATUS_UNKNOWN;265 }266 eHuffCo[i] = huffCode[k];267 eHuffSi[i] = huffSize[k];268 k++;269 } while (k < lastK);270 271 // copy over the first 162 values of reordered arrays to Huffman Code and size arrays272 CODECHAL_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)));273 CODECHAL_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)));274 275 return eStatus;276}277 278MOS_STATUS CodechalEncodeJpegState::ConvertHuffDataToTable(279 CodecEncodeJpegHuffData huffmanData,280 CodechalEncodeJpegHuffTable *huffmanTable)281{282 CODECHAL_ENCODE_FUNCTION_ENTER;283 284 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;285 286 huffmanTable->m_tableClass = huffmanData.m_tableClass;287 huffmanTable->m_tableID = huffmanData.m_tableID;288 289 uint8_t lastK = 0;290 291 // Step 1 : Generate size table292 CODECHAL_ENCODE_CHK_STATUS_RETURN(GenerateSizeTable(huffmanData.m_bits, huffmanTable->m_huffSize, lastK));293 294 // Step2: Generate code table295 CODECHAL_ENCODE_CHK_STATUS_RETURN(GenerateCodeTable(huffmanTable->m_huffSize, huffmanTable->m_huffCode));296 297 // Step 3: Order codes298 CODECHAL_ENCODE_CHK_STATUS_RETURN(OrderCodes(huffmanData.m_huffVal, huffmanTable->m_huffSize, huffmanTable->m_huffCode, lastK));299 300 return eStatus;301}302 303MOS_STATUS CodechalEncodeJpegState::PackSOI(BSBuffer *buffer)304{305 CODECHAL_ENCODE_FUNCTION_ENTER;306 307 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;308 309 CODECHAL_ENCODE_CHK_NULL_RETURN(buffer);310 // Add SOI = 0xFFD8311 buffer->pBase = (uint8_t*)MOS_AllocAndZeroMemory(2);312 CODECHAL_ENCODE_CHK_NULL_RETURN(buffer->pBase);313 314 *(buffer->pBase) = (m_jpegEncodeSoi >> 8) & 0xFF;315 *(buffer->pBase + 1) = (m_jpegEncodeSoi & 0xFF);316 buffer->BitOffset = 0;317 buffer->BufferSize = 16;318 319 return eStatus;320}321 322MOS_STATUS CodechalEncodeJpegState::PackApplicationData(323 BSBuffer *buffer,324 uint8_t *appDataChunk,325 uint32_t size)326{327 CODECHAL_ENCODE_FUNCTION_ENTER;328 329 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;330 331 CODECHAL_ENCODE_CHK_NULL_RETURN(appDataChunk);332 333 buffer->pBase = appDataChunk;334 buffer->BitOffset = 0;335 buffer->BufferSize = (size * sizeof(uint8_t) * 8);336 337 return eStatus;338}339 340MOS_STATUS CodechalEncodeJpegState::PackFrameHeader(341 BSBuffer *buffer,342 bool useSingleDefaultQuantTable)343{344 CODECHAL_ENCODE_FUNCTION_ENTER;345 346 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;347 348 CodechalEncodeJpegFrameHeader *frameHeader = (CodechalEncodeJpegFrameHeader *)MOS_AllocAndZeroMemory(sizeof(CodechalEncodeJpegFrameHeader));349 CODECHAL_ENCODE_CHK_NULL_RETURN(frameHeader);350 351 frameHeader->m_sof = 0xC0FF;352 frameHeader->m_nf = (uint8_t)m_jpegPicParams->m_numComponent;353 354 // Calculate lf - switch btes to match with simulation355 uint16_t value = 8 + (3 * frameHeader->m_nf); // does not include sof356 frameHeader->m_lf = ((value & 0xFF) << 8) | ((value & 0xFF00) >> 8);357 358 frameHeader->m_p = 8;359 frameHeader->m_y = ((m_jpegPicParams->m_picHeight & 0xFF) << 8) | ((m_jpegPicParams->m_picHeight & 0xFF00) >> 8);360 frameHeader->m_x = ((m_jpegPicParams->m_picWidth & 0xFF) << 8) | ((m_jpegPicParams->m_picWidth & 0xFF00) >> 8);361 362 for (uint8_t i = 0; i < frameHeader->m_nf; i++)363 {364 frameHeader->m_codechalJpegFrameComponent[i].m_ci = (uint8_t)m_jpegPicParams->m_componentID[i];365 366 if (useSingleDefaultQuantTable)367 {368 frameHeader->m_codechalJpegFrameComponent[i].m_tqi = 0; // 0/1/2 based on Y/U/V369 }370 else371 {372 frameHeader->m_codechalJpegFrameComponent[i].m_tqi = i; // 0/1/2 based on Y/U/V373 }374 375 // For all supported formats on JPEG encode, U and V vertical and horizontal sampling is 1376 uint32_t horizontalSamplingFactor = 0, verticalSamplingFactor = 0;377 if (i == 0)378 {379 horizontalSamplingFactor = m_mfxInterface->GetJpegHorizontalSamplingFactorForY((CodecEncodeJpegInputSurfaceFormat)m_jpegPicParams->m_inputSurfaceFormat);380 verticalSamplingFactor = m_mfxInterface->GetJpegVerticalSamplingFactorForY((CodecEncodeJpegInputSurfaceFormat)m_jpegPicParams->m_inputSurfaceFormat);381 }382 else383 {384 horizontalSamplingFactor = 1;385 verticalSamplingFactor = 1;386 }387 388 frameHeader->m_codechalJpegFrameComponent[i].m_samplingFactori = 0;389 frameHeader->m_codechalJpegFrameComponent[i].m_samplingFactori = ((horizontalSamplingFactor & 0xF) << 4) | (verticalSamplingFactor & 0xF);390 }391 392 buffer->pBase = (uint8_t*)frameHeader;393 buffer->BitOffset = 0;394 buffer->BufferSize = (2 * sizeof(uint8_t) * 8) + (4 * sizeof(uint16_t) * 8) + (sizeof(frameHeader->m_codechalJpegFrameComponent[0]) * 8 * m_jpegPicParams->m_numComponent);395 396 return eStatus;397}398 399MOS_STATUS CodechalEncodeJpegState::PackHuffmanTable(400 BSBuffer *buffer,401 uint32_t tableIndex)402{403 CODECHAL_ENCODE_FUNCTION_ENTER;404 405 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;406 407 CodechalJpegHuffmanHeader *huffmanHeader = (CodechalJpegHuffmanHeader *)MOS_AllocAndZeroMemory(sizeof(CodechalJpegHuffmanHeader));408 CODECHAL_ENCODE_CHK_NULL_RETURN(huffmanHeader);409 410 huffmanHeader->m_dht = 0xC4FF;411 huffmanHeader->m_tableClassAndDestn =412 ((m_jpegHuffmanTable->m_huffmanData[tableIndex].m_tableClass & 0xF) << 4) | ((tableIndex / 2) & 0xF);413 414 uint16_t totalHuffValues = 0;415 for (auto i = 0; i < JPEG_NUM_HUFF_TABLE_AC_BITS; i++)416 {417 huffmanHeader->m_li[i] = (uint8_t)m_jpegHuffmanTable->m_huffmanData[tableIndex].m_bits[i];418 totalHuffValues += huffmanHeader->m_li[i];419 }420 421 uint16_t hdrSize = 19 + totalHuffValues;422 huffmanHeader->m_lh = ((hdrSize & 0xFF) << 8) | ((hdrSize & 0xFF00) >> 8);423 424 for (auto i = 0; i < totalHuffValues; i++)425 {426 huffmanHeader->m_vij[i] = (uint8_t)m_jpegHuffmanTable->m_huffmanData[tableIndex].m_huffVal[i];427 }428 429 buffer->pBase = (uint8_t*)huffmanHeader;430 buffer->BitOffset = 0;431 432 if (m_jpegHuffmanTable->m_huffmanData[tableIndex].m_tableClass == 0) // DC table433 {434 buffer->BufferSize = (2 * sizeof(uint16_t) * 8) + (sizeof(uint8_t) * 8) + (JPEG_NUM_HUFF_TABLE_AC_BITS * 8) + (totalHuffValues * sizeof(uint8_t) * 8);435 }436 else437 {438 buffer->BufferSize = (2 * sizeof(uint16_t) * 8) + (sizeof(uint8_t) * 8) + (JPEG_NUM_HUFF_TABLE_AC_BITS * 8) + (totalHuffValues * sizeof(uint8_t) * 8);439 }440 441 return eStatus;442}443 444MOS_STATUS CodechalEncodeJpegState::PackQuantTable(445 BSBuffer *buffer,446 CodecJpegComponents componentType)447{448 CODECHAL_ENCODE_FUNCTION_ENTER;449 450 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;451 452 CodechalEncodeJpegQuantHeader *quantHeader = (CodechalEncodeJpegQuantHeader *)MOS_AllocAndZeroMemory(sizeof(CodechalEncodeJpegQuantHeader));453 CODECHAL_ENCODE_CHK_NULL_RETURN(quantHeader);454 455 quantHeader->m_dqt = 0xDBFF;456 // Header size including marker457 uint16_t hdrSize = sizeof(uint16_t) * 2 + sizeof(uint8_t) + sizeof(uint8_t) * JPEG_NUM_QUANTMATRIX;458 quantHeader->m_lq = (((hdrSize - 2) & 0xFF) << 8) | (((hdrSize - 2) & 0xFF00) >> 8);459 quantHeader->m_tablePrecisionAndDestination460 = ((m_jpegQuantTables->m_quantTable[componentType].m_precision & 0xF) << 4)461 | (componentType & 0xF);462 463 for (auto i = 0; i < JPEG_NUM_QUANTMATRIX; i++)464 {465 quantHeader->m_qk[i] = (uint8_t)m_jpegQuantTables->m_quantTable[componentType].m_qm[i];466 }467 468 buffer->pBase = (uint8_t*)quantHeader;469 buffer->BitOffset = 0;470 buffer->BufferSize = hdrSize * 8;471 472 return eStatus;473}474 475MOS_STATUS CodechalEncodeJpegState::PackRestartInterval(476 BSBuffer *buffer)477{478 CODECHAL_ENCODE_FUNCTION_ENTER;479 480 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;481 482 CodechalEncodeJpegRestartHeader *restartHeader = (CodechalEncodeJpegRestartHeader *)MOS_AllocAndZeroMemory(sizeof(CodechalEncodeJpegRestartHeader));483 CODECHAL_ENCODE_CHK_NULL_RETURN(restartHeader);484 485 restartHeader->m_dri = 0xDDFF;486 uint16_t hdrSize = sizeof(uint16_t) * 3;487 restartHeader->m_lr = (((hdrSize - 2) & 0xFF) << 8) | (((hdrSize - 2) & 0xFF00) >> 8);488 restartHeader->m_ri = (uint16_t)(((m_jpegScanParams->m_restartInterval & 0xFF) << 8) |489 ((m_jpegScanParams->m_restartInterval & 0xFF00) >> 8));490 491 buffer->pBase = (uint8_t*)restartHeader;492 buffer->BitOffset = 0;493 buffer->BufferSize = hdrSize * 8;494 495 return eStatus;496}497 498MOS_STATUS CodechalEncodeJpegState::PackScanHeader(499 BSBuffer *buffer)500{501 CODECHAL_ENCODE_FUNCTION_ENTER;502 503 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;504 505 // Size of Scan header in bytes = sos (2 bytes) + ls (2 bytes) + ns (1 byte)506 // + ss (1 byte) + se (1 byte) + ahl (1 byte) + scanComponent (2 bytes) * Number of scan components507 uint16_t hdrSize = 8 + 2 * m_jpegPicParams->m_numComponent;508 509 uint8_t *scanHeader = (uint8_t*)MOS_AllocAndZeroMemory(hdrSize);510 CODECHAL_ENCODE_CHK_NULL_RETURN(scanHeader);511 512 buffer->pBase = (uint8_t*)scanHeader;513 514 // scanHeader->sos515 *scanHeader = (m_jpegEncodeSos >> 8) & 0xFF;516 scanHeader += 1;517 *scanHeader = (m_jpegEncodeSos & 0xFF);518 scanHeader += 1;519 520 // scanHeader->ls521 *scanHeader = ((hdrSize - 2) >> 8) & 0xFF;522 scanHeader += 1;523 *scanHeader = (hdrSize - 2) & 0xFF;524 scanHeader += 1;525 526 // scanHeader->ns527 *scanHeader = (uint8_t)m_jpegPicParams->m_numComponent;528 scanHeader += 1;529 530 for (uint32_t j = 0; j < m_jpegPicParams->m_numComponent; j++)531 {532 *scanHeader = (uint8_t)m_jpegPicParams->m_componentID[j];533 scanHeader += 1;534 535 // For Y8 image format there is only one scan component, so scanComponent[1] and scanComponent[2] should not be added to the header536 // scanHeader->scanComponent[j].Tdaj537 if (j == 0)538 {539 *scanHeader = (uint8_t)(((m_jpegHuffmanTable->m_huffmanData[0].m_tableID & 0x0F) << 4)540 | ((m_jpegHuffmanTable->m_huffmanData[1].m_tableID & 0x0F)));541 scanHeader += 1;542 }543 else544 {545 *scanHeader = (uint8_t)(((m_jpegHuffmanTable->m_huffmanData[2].m_tableID & 0x0F) << 4)546 | ((m_jpegHuffmanTable->m_huffmanData[3].m_tableID & 0x0F)));547 scanHeader += 1;548 }549 550 }551 552 // scanHeader->ss553 *scanHeader = 0;554 scanHeader += 1;555 // scanHeader->se556 *scanHeader = 63;557 scanHeader += 1;558 // scanHeader->ahl559 *scanHeader = 0;560 scanHeader += 1;561 562 buffer->BitOffset = 0;563 // Buffer size in bits564 buffer->BufferSize = hdrSize * 8;565 566 return eStatus;567}568 569MOS_STATUS CodechalEncodeJpegState::ExecutePictureLevel()570{571 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;572 573 CODECHAL_ENCODE_FUNCTION_ENTER;574 575 PerfTagSetting perfTag;576 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE);577 578 MOS_COMMAND_BUFFER cmdBuffer;579 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));580 581 m_mode = CODECHAL_ENCODE_MODE_JPEG;582 583 // set MFX_PIPE_MODE_SELECT584 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;585 pipeModeSelectParams.Mode = m_mode;586 pipeModeSelectParams.bStreamOutEnabled = false;587 pipeModeSelectParams.bShortFormatInUse = false;588 pipeModeSelectParams.bPreDeblockOutEnable = false;589 pipeModeSelectParams.bPostDeblockOutEnable = false;590 591 // set MFX_SURFACE_STATE592 MHW_VDBOX_SURFACE_PARAMS surfaceParams;593 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));594 surfaceParams.Mode = m_mode;595 surfaceParams.psSurface = &m_rawSurface; // original picture to be encoded596 surfaceParams.ucSurfaceStateId = CODECHAL_MFX_SRC_SURFACE_ID;597 598 // set MFX_PIPE_BUF_ADDR_STATE599 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;600 pipeBufAddrParams.Mode = m_mode;601 pipeBufAddrParams.psRawSurface = &m_rawSurface; // original picture to be encoded602 pipeBufAddrParams.pRawSurfParam = &surfaceParams;603 604 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);605 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetPipeBufAddr(&pipeBufAddrParams, &cmdBuffer));606 607 CODECHAL_DEBUG_TOOL(608 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(609 &m_rawSurface,610 CodechalDbgAttr::attrEncodeRawInputSurface,611 ""SrcSurf""))612 );613 614 // No references for JPEG615 // Setting invalid entries to nullptr616 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)617 {618 pipeBufAddrParams.presReferences[i] = nullptr;619 }620 621 // set MFX_IND_OBJ_BASE_ADDR_STATE622 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;623 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));624 indObjBaseAddrParams.Mode = m_mode;625 indObjBaseAddrParams.presPakBaseObjectBuffer = &m_resBitstreamBuffer;626 indObjBaseAddrParams.dwPakBaseObjectSize = m_bitstreamUpperBound;627 628 // set MFX_JPEG_PIC_STATE629 MhwVdboxJpegEncodePicState jpegPicState;630 MOS_ZeroMemory(&jpegPicState, sizeof(jpegPicState));631 jpegPicState.pJpegEncodePicParams = m_jpegPicParams;632 jpegPicState.mode = m_mode;633 634 // Send command buffer header at the beginning (OS dependent)635 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, true));636 637 CODECHAL_ENCODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));638 639 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));640 641 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));642 643 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));644 645 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams));646 647 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxJpegEncodePicStateCmd(&cmdBuffer, &jpegPicState));648 649 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);650 651 return eStatus;652}653 654MOS_STATUS CodechalEncodeJpegState::ExecuteSliceLevel()655{656 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;657 658 CODECHAL_ENCODE_FUNCTION_ENTER;659 660 MOS_COMMAND_BUFFER cmdBuffer;661 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));662 663 if (m_encodeParams.dwNumSlices != 1)664 {665 CODECHAL_ENCODE_ASSERTMESSAGE(""JPEG encode only one scan is supported."");666 }667 668 MOS_SURFACE *surface = &m_rawSurface;669 670 bool useSingleDefaultQuantTable = (m_jpegQuantMatrixSent == false &&671 ((surface->Format == Format_A8R8G8B8) ||672 (surface->Format == Format_X8R8G8B8) ||673 (surface->Format == Format_A8B8G8R8) ||674 (surface->Format == Format_X8B8G8R8)));675 676 CodecJpegQuantMatrix *tempJpegQuantMatrix = (CodecJpegQuantMatrix *)MOS_AllocAndZeroMemory(sizeof(CodecJpegQuantMatrix));677 CODECHAL_ENCODE_CHK_NULL_RETURN(tempJpegQuantMatrix);678 679 static_assert(JPEG_MAX_NUM_QUANT_TABLE_INDEX <= JPEG_MAX_NUM_OF_QUANTMATRIX,680 ""access to CodecJpegQuantMatrix is controlled by numQuantTables"");681 682 uint32_t numQuantTables = JPEG_MAX_NUM_QUANT_TABLE_INDEX;683 for (uint32_t scanCount = 0; scanCount < m_encodeParams.dwNumSlices; scanCount++)684 {685 MHW_VDBOX_QM_PARAMS fqmParams;686 MOS_ZeroMemory(&fqmParams, sizeof(fqmParams));687 688 // set MFX_FQM_STATE689 fqmParams.pJpegQuantMatrix = tempJpegQuantMatrix;690 691 // For monochrome inputs there will be only 1 quantization table and huffman table sent692 if (m_jpegPicParams->m_inputSurfaceFormat == codechalJpegY8)693 {694 numQuantTables = 1;695 m_encodeParams.dwNumHuffBuffers = 2; //for Y8 only 2 huff tables696 }697 // If there is only 1 quantization table copy over the table to 2nd and 3rd table in JPEG state (used for frame header)698 // OR For RGB input surfaces, if the app does not send quantization tables, then use luma quant table for all 3 components699 else if (m_jpegPicParams->m_numQuantTable == 1 || useSingleDefaultQuantTable)700 {701 for (auto i = 1; i < JPEG_MAX_NUM_QUANT_TABLE_INDEX; i++)702 {703 m_jpegQuantTables->m_quantTable[i].m_precision = m_jpegQuantTables->m_quantTable[0].m_precision;704 m_jpegQuantTables->m_quantTable[i].m_tableID = m_jpegQuantTables->m_quantTable[0].m_tableID;705 706 eStatus = MOS_SecureMemcpy(&m_jpegQuantTables->m_quantTable[i].m_qm[0], JPEG_NUM_QUANTMATRIX * sizeof(uint16_t),707 &m_jpegQuantTables->m_quantTable[0].m_qm[0], JPEG_NUM_QUANTMATRIX * sizeof(uint16_t));708 if (eStatus != MOS_STATUS_SUCCESS)709 {710 CODECHAL_ENCODE_ASSERTMESSAGE(""Failed to copy memory."");711 MOS_SafeFreeMemory(tempJpegQuantMatrix);712 return eStatus;713 }714 }715 }716 // 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)717 else if (m_jpegPicParams->m_numQuantTable == 2)718 {719 m_jpegQuantTables->m_quantTable[2].m_precision = m_jpegQuantTables->m_quantTable[1].m_precision;720 m_jpegQuantTables->m_quantTable[2].m_tableID = m_jpegQuantTables->m_quantTable[1].m_tableID;721 722 eStatus = MOS_SecureMemcpy(&m_jpegQuantTables->m_quantTable[2].m_qm[0], JPEG_NUM_QUANTMATRIX * sizeof(uint16_t),723 &m_jpegQuantTables->m_quantTable[1].m_qm[0], JPEG_NUM_QUANTMATRIX * sizeof(uint16_t));724 if (eStatus != MOS_STATUS_SUCCESS)725 {726 CODECHAL_ENCODE_ASSERTMESSAGE(""Failed to copy memory."");727 MOS_SafeFreeMemory(tempJpegQuantMatrix);728 return eStatus;729 }730 731 }732 // else 3 quantization tables are sent by the application for non monochrome input formats. In that case, do nothing.733 734 for (uint32_t i = 0; i < numQuantTables; i++)735 {736 fqmParams.pJpegQuantMatrix->m_jpegQMTableType[i] = m_jpegQuantTables->m_quantTable[i].m_tableID; // Used to distinguish between Y,U,V quantization tables for the same scan737 738 for (auto j = 0; j < JPEG_NUM_QUANTMATRIX; j++)739 {740 uint32_t k = jpeg_qm_scan_8x8[j];741 742 // copy over Quant matrix in raster order from zig zag743 fqmParams.pJpegQuantMatrix->m_quantMatrix[i][k] = (uint8_t)m_jpegQuantTables->m_quantTable[i].m_qm[j];744 }745 }746 747 eStatus = (MOS_STATUS) m_mfxInterface->AddMfxJpegFqmCmd(&cmdBuffer, &fqmParams, numQuantTables);748 if (eStatus != MOS_STATUS_SUCCESS)749 {750 MOS_SafeFreeMemory(tempJpegQuantMatrix);751 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);752 }753 754 // set MFC_JPEG_HUFF_TABLE - Convert encoded huffman table to actual table for HW755 // We need a different params struct for JPEG Encode Huffman table because JPEG decode huffman table has Bits and codes,756 // whereas JPEG encode huffman table has huffman code lengths and values757 MHW_VDBOX_ENCODE_HUFF_TABLE_PARAMS huffTableParams[JPEG_MAX_NUM_HUFF_TABLE_INDEX];758 for (uint32_t i = 0; i < m_encodeParams.dwNumHuffBuffers; i++)759 {760 CodechalEncodeJpegHuffTable huffmanTable;// intermediate table for each AC/DC component which will be copied to huffTableParams761 MOS_ZeroMemory(&huffmanTable, sizeof(huffmanTable));762 763 eStatus = (MOS_STATUS) ConvertHuffDataToTable(m_jpegHuffmanTable->m_huffmanData[i], &huffmanTable);764 if (eStatus != MOS_STATUS_SUCCESS)765 {766 MOS_SafeFreeMemory(tempJpegQuantMatrix);767 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);768 }769 770 huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].HuffTableID = m_jpegHuffmanTable->m_huffmanData[i].m_tableID;771 772 if (m_jpegHuffmanTable->m_huffmanData[i].m_tableClass == 0) // DC table773 {774 eStatus = (MOS_STATUS) MOS_SecureMemcpy(775 huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pDCCodeValues,776 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint16_t),777 &huffmanTable.m_huffCode,778 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint16_t));779 if (eStatus != MOS_STATUS_SUCCESS)780 {781 MOS_SafeFreeMemory(tempJpegQuantMatrix);782 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);783 }784 785 eStatus = (MOS_STATUS) MOS_SecureMemcpy(huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pDCCodeLength,786 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint8_t),787 &huffmanTable.m_huffSize,788 JPEG_NUM_HUFF_TABLE_DC_HUFFVAL * sizeof(uint8_t));789 if (eStatus != MOS_STATUS_SUCCESS)790 {791 MOS_SafeFreeMemory(tempJpegQuantMatrix);792 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);793 }794 }795 else // AC Table796 {797 eStatus = (MOS_STATUS) MOS_SecureMemcpy(huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pACCodeValues,798 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t),799 &huffmanTable.m_huffCode,800 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint16_t));801 if (eStatus != MOS_STATUS_SUCCESS)802 {803 MOS_SafeFreeMemory(tempJpegQuantMatrix);804 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);805 }806 807 eStatus = (MOS_STATUS) MOS_SecureMemcpy(huffTableParams[m_jpegHuffmanTable->m_huffmanData[i].m_tableID].pACCodeLength,808 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t),809 &huffmanTable.m_huffSize,810 JPEG_NUM_HUFF_TABLE_AC_HUFFVAL * sizeof(uint8_t));811 if (eStatus != MOS_STATUS_SUCCESS)812 {813 MOS_SafeFreeMemory(tempJpegQuantMatrix);814 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);815 }816 }817 }818 819 // Send 2 huffman table commands - 1 for Luma and one for chroma for non-monchrome input formats820 // If only one table is sent by the app (2 buffers), send the same table for Luma and chroma821 bool repeatHuffTable = false;822 if ((m_encodeParams.dwNumHuffBuffers / 2 < JPEG_MAX_NUM_HUFF_TABLE_INDEX)823 && (m_jpegPicParams->m_inputSurfaceFormat != codechalJpegY8))824 {825 repeatHuffTable = true;826 827 // Copy over huffman data to the other two data buffers for JPEG picture header828 for (uint32_t i = 0; i < m_encodeParams.dwNumHuffBuffers; i++)829 {830 m_jpegHuffmanTable->m_huffmanData[i + 2].m_tableClass = m_jpegHuffmanTable->m_huffmanData[i].m_tableClass;831 m_jpegHuffmanTable->m_huffmanData[i + 2].m_tableID = m_jpegHuffmanTable->m_huffmanData[i].m_tableID;832 833 eStatus = MOS_SecureMemcpy(&m_jpegHuffmanTable->m_huffmanData[i + 2].m_bits[0],834 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_BITS,835 &m_jpegHuffmanTable->m_huffmanData[i].m_bits[0],836 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_BITS);837 if (eStatus != MOS_STATUS_SUCCESS)838 {839 CODECHAL_ENCODE_ASSERTMESSAGE(""Failed to copy memory."");840 MOS_SafeFreeMemory(tempJpegQuantMatrix);841 return eStatus;842 }843 844 eStatus = MOS_SecureMemcpy(&m_jpegHuffmanTable->m_huffmanData[i + 2].m_huffVal[0],845 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_HUFFVAL,846 &m_jpegHuffmanTable->m_huffmanData[i].m_huffVal[0],847 sizeof(uint8_t) * JPEG_NUM_HUFF_TABLE_AC_HUFFVAL);848 if (eStatus != MOS_STATUS_SUCCESS)849 {850 CODECHAL_ENCODE_ASSERTMESSAGE(""Failed to copy memory."");851 MOS_SafeFreeMemory(tempJpegQuantMatrix);852 return eStatus;853 }854 }855 }856 857 // the number of huffman commands is half of the huffman buffers sent by the app, since AC and DC buffers are combined into one command858 for (uint32_t i = 0; i < m_encodeParams.dwNumHuffBuffers / 2; i++)859 {860 if (repeatHuffTable)861 {862 eStatus = (MOS_STATUS) (m_mfxInterface->AddMfcJpegHuffTableStateCmd(&cmdBuffer, &huffTableParams[i]));863 if (eStatus != MOS_STATUS_SUCCESS)864 {865 MOS_SafeFreeMemory(tempJpegQuantMatrix);866 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);867 }868 }869 870 eStatus = (MOS_STATUS) m_mfxInterface->AddMfcJpegHuffTableStateCmd(&cmdBuffer, &huffTableParams[i]);871 if (eStatus != MOS_STATUS_SUCCESS)872 {873 MOS_SafeFreeMemory(tempJpegQuantMatrix);874 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);875 }876 }877 878 // set MFC_JPEG_SCAN_OBJECT879 MhwVdboxJpegScanParams scanObjectParams;880 scanObjectParams.mode = m_mode;881 scanObjectParams.inputSurfaceFormat = (CodecEncodeJpegInputSurfaceFormat)m_jpegPicParams->m_inputSurfaceFormat;882 scanObjectParams.dwPicWidth = m_jpegPicParams->m_picWidth;883 scanObjectParams.dwPicHeight = m_jpegPicParams->m_picHeight;884 scanObjectParams.pJpegEncodeScanParams = m_jpegScanParams;885 886 eStatus = (MOS_STATUS) m_mfxInterface->AddMfcJpegScanObjCmd(&cmdBuffer, &scanObjectParams);887 if (eStatus != MOS_STATUS_SUCCESS)888 {889 MOS_SafeFreeMemory(tempJpegQuantMatrix);890 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);891 }892 // set MFC_JPEG_PAK_INSERT_OBJECT893 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;894 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));895 896 // The largest component written through the MFC_JPEG_PAK_INSERT_OBJECT command is Huffman table897 pakInsertObjectParams.pBsBuffer = (BSBuffer *)MOS_AllocAndZeroMemory(sizeof(CodechalEncodeJpegFrameHeader));898 if (pakInsertObjectParams.pBsBuffer == nullptr)899 {900 MOS_SafeFreeMemory(tempJpegQuantMatrix);901 CODECHAL_ENCODE_CHK_NULL_RETURN(nullptr);902 }903 if(!m_fullHeaderInAppData)904 {905 // Add SOI (0xFFD8) (only if it was sent by the application)906 eStatus = (MOS_STATUS)PackSOI(pakInsertObjectParams.pBsBuffer);907 if (eStatus != MOS_STATUS_SUCCESS)908 {909 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);910 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);911 MOS_SafeFreeMemory(tempJpegQuantMatrix);912 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);913 }914 pakInsertObjectParams.dwOffset = 0;915 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;916 pakInsertObjectParams.bLastHeader = false;917 pakInsertObjectParams.bEndOfSlice = false;918 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect919 eStatus = (MOS_STATUS) m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr, &pakInsertObjectParams);920 if (eStatus != MOS_STATUS_SUCCESS)921 {922 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);923 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);924 MOS_SafeFreeMemory(tempJpegQuantMatrix);925 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);926 }927 MOS_FreeMemory(pakInsertObjectParams.pBsBuffer->pBase);928 }929 // Add Application data if it was sent by application930 if (m_applicationData != nullptr)931 {932 uint8_t* appDataChunk = nullptr;933 uint32_t appDataChunkSize = m_appDataSize;934 935 // We can write a maximum of 1020 words per command, so if the size of the app data is936 // more than 1020 we need to send multiple commands for writing out app data937 uint32_t numAppDataCmdsNeeded = 1;938 uint32_t appDataCmdSizeResidue = 0;939 if (m_appDataSize > 1020)940 {941 numAppDataCmdsNeeded = m_appDataSize / 1020;942 appDataCmdSizeResidue = m_appDataSize % 1020;943 944 appDataChunkSize = 1020;945 }946 947 appDataChunk = (uint8_t*)MOS_AllocAndZeroMemory(appDataChunkSize);948 if (appDataChunk == nullptr)949 {950 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);951 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);952 MOS_SafeFreeMemory(tempJpegQuantMatrix);953 CODECHAL_ENCODE_CHK_NULL_RETURN(nullptr);954 }955 956 for (uint32_t i = 0; i < numAppDataCmdsNeeded; i++)957 {958 uint8_t *copyAddress = (uint8_t*)(m_applicationData) + (i * appDataChunkSize);959 960 MOS_SecureMemcpy(appDataChunk, appDataChunkSize,961 copyAddress, appDataChunkSize);962 963 eStatus = (MOS_STATUS)PackApplicationData(pakInsertObjectParams.pBsBuffer, appDataChunk, appDataChunkSize);964 if (eStatus != MOS_STATUS_SUCCESS)965 {966 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);967 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);968 MOS_SafeFreeMemory(tempJpegQuantMatrix);969 MOS_SafeFreeMemory(appDataChunk);970 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);971 }972 pakInsertObjectParams.dwOffset = 0;973 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;974 //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 EndOfSlice975 if((appDataCmdSizeResidue == 0) && m_fullHeaderInAppData && (i == numAppDataCmdsNeeded - 1))976 {977 pakInsertObjectParams.bLastHeader = true;978 pakInsertObjectParams.bEndOfSlice = true;979 }980 else981 {982 pakInsertObjectParams.bLastHeader = false;983 pakInsertObjectParams.bEndOfSlice = false;984 }985 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect986 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,987 &pakInsertObjectParams);988 if (eStatus != MOS_STATUS_SUCCESS)989 {990 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);991 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);992 MOS_SafeFreeMemory(tempJpegQuantMatrix);993 MOS_SafeFreeMemory(appDataChunk);994 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);995 }996 }997 998 if (appDataCmdSizeResidue != 0)999 {1000 uint8_t* lastAddress = (uint8_t*)(m_applicationData) + (numAppDataCmdsNeeded * appDataChunkSize);1001 appDataChunkSize = appDataCmdSizeResidue;1002 1003 MOS_SecureMemcpy(appDataChunk, appDataChunkSize,1004 lastAddress,1005 appDataChunkSize);1006 1007 eStatus = (MOS_STATUS)PackApplicationData(pakInsertObjectParams.pBsBuffer, appDataChunk, appDataCmdSizeResidue);1008 if (eStatus != MOS_STATUS_SUCCESS)1009 {1010 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1011 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1012 MOS_SafeFreeMemory(tempJpegQuantMatrix);1013 MOS_SafeFreeMemory(appDataChunk);1014 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1015 }1016 pakInsertObjectParams.dwOffset = 0;1017 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1018 //if full header is included in application data, it will be the last insert headers1019 if(m_fullHeaderInAppData)1020 {1021 pakInsertObjectParams.bLastHeader = true;1022 pakInsertObjectParams.bEndOfSlice = true;1023 }1024 else1025 {1026 pakInsertObjectParams.bLastHeader = false;1027 pakInsertObjectParams.bEndOfSlice = false;1028 }1029 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1030 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1031 &pakInsertObjectParams);1032 if (eStatus != MOS_STATUS_SUCCESS)1033 {1034 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1035 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1036 MOS_SafeFreeMemory(tempJpegQuantMatrix);1037 MOS_SafeFreeMemory(appDataChunk);1038 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1039 }1040 }1041 1042 MOS_FreeMemory(appDataChunk);1043 }1044 if(!m_fullHeaderInAppData)1045 {1046 // Add Quant Table for Y1047 eStatus = (MOS_STATUS)PackQuantTable(pakInsertObjectParams.pBsBuffer, jpegComponentY);1048 if (eStatus != MOS_STATUS_SUCCESS)1049 {1050 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1051 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1052 MOS_SafeFreeMemory(tempJpegQuantMatrix);1053 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1054 }1055 pakInsertObjectParams.dwOffset = 0;1056 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1057 pakInsertObjectParams.bLastHeader = false;1058 pakInsertObjectParams.bEndOfSlice = false;1059 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1060 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1061 &pakInsertObjectParams);1062 if (eStatus != MOS_STATUS_SUCCESS)1063 {1064 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1065 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1066 MOS_SafeFreeMemory(tempJpegQuantMatrix);1067 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1068 }1069 MOS_FreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1070 1071 if (!useSingleDefaultQuantTable)1072 {1073 // Since there is no U and V in monochrome format, donot add Quantization table header for U and V components1074 if (m_jpegPicParams->m_inputSurfaceFormat != codechalJpegY8)1075 {1076 // Add quant table for U1077 eStatus = (MOS_STATUS)PackQuantTable(pakInsertObjectParams.pBsBuffer, jpegComponentU);1078 if (eStatus != MOS_STATUS_SUCCESS)1079 {1080 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1081 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1082 MOS_SafeFreeMemory(tempJpegQuantMatrix);1083 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1084 }1085 pakInsertObjectParams.dwOffset = 0;1086 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1087 pakInsertObjectParams.bLastHeader = false;1088 pakInsertObjectParams.bEndOfSlice = false;1089 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1090 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1091 &pakInsertObjectParams);1092 if (eStatus != MOS_STATUS_SUCCESS)1093 {1094 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1095 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1096 MOS_SafeFreeMemory(tempJpegQuantMatrix);1097 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1098 }1099 MOS_FreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1100 1101 // Add quant table for V1102 eStatus = (MOS_STATUS)PackQuantTable(pakInsertObjectParams.pBsBuffer, jpegComponentV);1103 if (eStatus != MOS_STATUS_SUCCESS)1104 {1105 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1106 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1107 MOS_SafeFreeMemory(tempJpegQuantMatrix);1108 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1109 }1110 pakInsertObjectParams.dwOffset = 0;1111 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1112 pakInsertObjectParams.bLastHeader = false;1113 pakInsertObjectParams.bEndOfSlice = false;1114 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1115 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1116 &pakInsertObjectParams);1117 if (eStatus != MOS_STATUS_SUCCESS)1118 {1119 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1120 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1121 MOS_SafeFreeMemory(tempJpegQuantMatrix);1122 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1123 }1124 MOS_FreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1125 }1126 }1127 1128 // Add Frame Header1129 eStatus = (MOS_STATUS)PackFrameHeader(pakInsertObjectParams.pBsBuffer, useSingleDefaultQuantTable);1130 if (eStatus != MOS_STATUS_SUCCESS)1131 {1132 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1133 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1134 MOS_SafeFreeMemory(tempJpegQuantMatrix);1135 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1136 }1137 pakInsertObjectParams.dwOffset = 0;1138 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1139 pakInsertObjectParams.bLastHeader = false;1140 pakInsertObjectParams.bEndOfSlice = false;1141 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1142 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1143 &pakInsertObjectParams);1144 if (eStatus != MOS_STATUS_SUCCESS)1145 {1146 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1147 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1148 MOS_SafeFreeMemory(tempJpegQuantMatrix);1149 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1150 }1151 MOS_FreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1152 1153 // Add Huffman Table for Y - DC table, Y- AC table, U/V - DC table, U/V - AC table1154 for (uint32_t i = 0; i < m_encodeParams.dwNumHuffBuffers; i++)1155 {1156 eStatus = (MOS_STATUS)PackHuffmanTable(pakInsertObjectParams.pBsBuffer, i);1157 if (eStatus != MOS_STATUS_SUCCESS)1158 {1159 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1160 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1161 MOS_SafeFreeMemory(tempJpegQuantMatrix);1162 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1163 }1164 pakInsertObjectParams.dwOffset = 0;1165 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1166 pakInsertObjectParams.bLastHeader = false;1167 pakInsertObjectParams.bEndOfSlice = false;1168 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1169 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1170 &pakInsertObjectParams);1171 if (eStatus != MOS_STATUS_SUCCESS)1172 {1173 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1174 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1175 MOS_SafeFreeMemory(tempJpegQuantMatrix);1176 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1177 }1178 MOS_FreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1179 }1180 1181 // Restart Interval - Add only if the restart interval is not zero1182 if (m_jpegScanParams->m_restartInterval != 0)1183 {1184 eStatus = (MOS_STATUS)PackRestartInterval(pakInsertObjectParams.pBsBuffer);1185 if (eStatus != MOS_STATUS_SUCCESS)1186 {1187 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer->pBase);1188 MOS_SafeFreeMemory(pakInsertObjectParams.pBsBuffer);1189 MOS_SafeFreeMemory(tempJpegQuantMatrix);1190 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);1191 }1192 pakInsertObjectParams.dwOffset = 0;1193 pakInsertObjectParams.dwBitSize = pakInsertObjectParams.pBsBuffer->BufferSize;1194 pakInsertObjectParams.bLastHeader = false;1195 pakInsertObjectParams.bEndOfSlice = false;1196 pakInsertObjectParams.bResetBitstreamStartingPos = 1; // from discussion with HW Architect1197 eStatus = (MOS_STATUS)m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr,1198 &pakInsertObjectParams);1199 if (eStatus != MOS_STATUS_SUCCESS)1200 {