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_hevc_vdenc_packet.h 24 //! \brief Defines the interface to adapt to hevc vdenc encode pipeline 25 //! 26 27 #ifndef __CODECHAL_HEVC_VDENC_PACKET_H__ 28 #define __CODECHAL_HEVC_VDENC_PACKET_H__ 29 30 #include "media_cmd_packet.h" 31 #include "encode_utils.h" 32 #include "encode_hevc_vdenc_pipeline.h" 33 #include "encode_hevc_basic_feature.h" 34 #include "encode_status_report.h" 35 #include "mhw_vdbox_vdenc_itf.h" 36 #include "mhw_vdbox_hcp_itf.h" 37 #if _ENCODE_RESERVED 38 #include "encode_hevc_vdenc_par_dump.h" 39 #endif // _ENCODE_RESERVED 40 41 namespace encode 42 { 43 class HevcVdencPkt : public CmdPacket, public MediaStatusReportObserver, public mhw::vdbox::vdenc::Itf::ParSetting, public mhw::vdbox::hcp::Itf::ParSetting 44 { 45 //! 46 //! \struct AtomicScratchBuffer 47 //! \brief The sturct of Atomic Scratch Buffer 48 //! 49 struct AtomicScratchBuffer 50 { 51 PMOS_RESOURCE resAtomicScratchBuffer; //!> Handle of eStatus buffer 52 uint32_t * pData; //!> Pointer of the buffer of actual data 53 uint16_t encodeUpdateIndex; //!> used for VDBOX update encode status 54 uint16_t tearDownIndex; //!> Reserved for future extension 55 uint32_t zeroValueOffset; //!> Store the result of the ATOMIC_CMP 56 uint32_t operand1Offset; //!> Operand 1 of the ATOMIC_CMP 57 uint32_t operand2Offset; //!> Operand 2 of the ATOMIC_CMP 58 uint32_t operand3Offset; //!> Copy of the operand 1 59 uint32_t size; //!> Size of the buffer 60 uint32_t operandSetSize; //!> Size of Operand set 61 }; 62 63 #define CODECHAL_ENCODE_RECYCLED_BUFFER_NUM 6 64 #define CODECHAL_PAGE_SIZE 0x1000 65 66 //! 67 //! \struct CodechalEncodeHevcPakStatesBuffer 68 //! \brief Codechal encode HEVC PAK States buffer 69 //! 70 struct CodechalEncodeHevcPakStatesBuffer 71 { 72 uint32_t hcpBitstreamByteCountFrame; 73 uint32_t hcpBitstreamByteCountFrameNoheader; 74 uint32_t hcpImageStatusControl; 75 uint32_t reserved0; 76 uint32_t hcpImageStatusControlForLastPass; 77 uint32_t reserved1[3]; 78 }; 79 80 public: 81 enum SubmitState 82 { 83 submitFrameByDefault = 0, 84 submitPic, 85 submitTile, 86 submitInvalid 87 }; 88 enum FlushCmd 89 { 90 waitHevc = 0, 91 waitVdenc, 92 waitHevcVdenc 93 }; HevcVdencPkt(MediaPipeline * pipeline,MediaTask * task,CodechalHwInterfaceNext * hwInterface)94 HevcVdencPkt(MediaPipeline *pipeline, MediaTask *task, CodechalHwInterfaceNext *hwInterface) : CmdPacket(task), 95 m_pipeline(dynamic_cast<HevcVdencPipeline *>(pipeline)), 96 m_hwInterface(dynamic_cast<CodechalHwInterfaceNext *>(hwInterface)) 97 { 98 ENCODE_CHK_NULL_NO_STATUS_RETURN(hwInterface); 99 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_pipeline); 100 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hwInterface); 101 102 m_osInterface = hwInterface->GetOsInterface(); 103 m_statusReport = m_pipeline->GetStatusReportInstance(); 104 m_featureManager = m_pipeline->GetPacketLevelFeatureManager(HevcPipeline::hevcVdencPacket); 105 m_encodecp = m_pipeline->GetEncodeCp(); 106 m_vdencItf = std::static_pointer_cast<mhw::vdbox::vdenc::Itf>(m_hwInterface->GetVdencInterfaceNext()); 107 m_hcpItf = hwInterface->GetHcpInterfaceNext(); 108 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_hcpItf); 109 m_miItf = m_hwInterface->GetMiInterfaceNext(); 110 ENCODE_CHK_NULL_NO_STATUS_RETURN(m_miItf); 111 } 112 ~HevcVdencPkt()113 virtual ~HevcVdencPkt() 114 { 115 FreeResources(); 116 } 117 118 //! 119 //! \brief Initialize the media packet, allocate required resources 120 //! \return MOS_STATUS 121 //! MOS_STATUS_SUCCESS if success, else fail reason 122 //! 123 virtual MOS_STATUS Init() override; 124 125 //! 126 //! \brief Prepare interal parameters, should be invoked for each frame 127 //! \param [in] params 128 //! Pointer to the input parameters 129 //! \return MOS_STATUS 130 //! MOS_STATUS_SUCCESS if success, else fail reason 131 //! 132 virtual MOS_STATUS Prepare() override; 133 134 //! 135 //! \brief Destroy the media packet and release the resources 136 //! \return MOS_STATUS 137 //! MOS_STATUS_SUCCESS if success, else fail reason 138 //! 139 virtual MOS_STATUS Destroy() override; 140 141 //! 142 //! \brief Add the command sequence into the commandBuffer and 143 //! and return to the caller task 144 //! \param [in] commandBuffer 145 //! Pointer to the command buffer which is allocated by caller 146 //! \return MOS_STATUS 147 //! MOS_STATUS_SUCCESS if success, else fail reason 148 //! 149 virtual MOS_STATUS Submit( 150 MOS_COMMAND_BUFFER* commandBuffer, 151 uint8_t packetPhase = otherPacket) override; 152 153 //! 154 //! \brief One frame is completed 155 //! \param [in] mfxStatus 156 //! pointer to status buffer which for MFX 157 //! \param [in] rcsStatus 158 //! pointer to status buffer which for RCS 159 //! \param [in, out] statusReport 160 //! pointer of EncoderStatusReport 161 //! \return MOS_STATUS 162 //! MOS_STATUS_SUCCESS if success, else fail reason 163 //! 164 virtual MOS_STATUS Completed(void *mfxStatus, void *rcsStatus, void *statusReport) override; 165 166 //! 167 //! \brief Calculate picture state command size 168 //! 169 //! \return MOS_STATUS 170 //! MOS_STATUS_SUCCESS if success, else fail reason 171 //! 172 MOS_STATUS CalculatePictureStateCommandSize(); 173 174 virtual MOS_STATUS SendHwSliceEncodeCommand(const PCODEC_ENCODER_SLCDATA slcData, const uint32_t currSlcIdx, MOS_COMMAND_BUFFER &cmdBuffer); 175 176 //! 177 //! \brief get vdenc state command size and patch size 178 //! 179 //! \return MOS_STATUS 180 //! MOS_STATUS_SUCCESS if success, else fail reason 181 //! 182 virtual MOS_STATUS GetVdencStateCommandsDataSize(uint32_t &vdencPictureStatesSize, uint32_t &vdencPicturePatchListSize); 183 184 //! 185 //! \brief Calculate Command Size 186 //! 187 //! \param [in, out] commandBufferSize 188 //! requested size 189 //! \param [in, out] requestedPatchListSize 190 //! requested size 191 //! \return MOS_STATUS 192 //! status 193 //! 194 MOS_STATUS CalculateCommandSize( 195 uint32_t &commandBufferSize, 196 uint32_t &requestedPatchListSize) override; 197 198 //! 199 //! \brief Get Packet Name 200 //! \return std::string 201 //! GetPacketName()202 virtual std::string GetPacketName() override 203 { 204 return "VDENC_PASS" + std::to_string((uint32_t)m_pipeline->GetCurrentPass()); 205 } 206 SetSubmitState(SubmitState state)207 MOS_STATUS SetSubmitState(SubmitState state) 208 { 209 if (state >= submitFrameByDefault && state < submitInvalid) 210 { 211 m_submitState = state; 212 return MOS_STATUS_SUCCESS; 213 } 214 else 215 { 216 return MOS_STATUS_UNINITIALIZED; 217 } 218 } 219 220 MOS_STATUS PrepareHWMetaData(MOS_COMMAND_BUFFER *cmdBuffer); 221 222 protected: 223 #if USE_CODECHAL_DEBUG_TOOL 224 //! 225 //! \brief Dump input resources or infomation before submit 226 //! \return MOS_STATUS 227 //! MOS_STATUS_SUCCESS if success, else fail reason 228 //! 229 virtual MOS_STATUS DumpInput(); 230 #endif 231 //! 232 //! \brief get SliceStatesSize and SlicePatchListSize, 233 //! 234 //! \return MOS_STATUS 235 //! MOS_STATUS_SUCCESS if success, else fail reason 236 //! 237 virtual MOS_STATUS GetHxxPrimitiveCommandSize(); 238 239 //! 240 //! \brief Calculate Command Buffer Size 241 //! 242 //! \return uint32_t 243 //! Command buffer size calculated 244 //! 245 virtual uint32_t CalculateCommandBufferSize(); 246 247 //! 248 //! \brief Calculate Patch List Size 249 //! 250 //! \return uint32_t 251 //! Patchlist size calculated 252 //! 253 virtual uint32_t CalculatePatchListSize(); 254 255 //! 256 //! \brief Submit slice level commands 257 //! \param [in] cmdBuffer 258 //! Pointer to the command buffer which is allocated by caller 259 //! \param [in] packetPhase 260 //! Packet phase 261 //! \return MOS_STATUS 262 //! MOS_STATUS_SUCCESS if success, else fail reason 263 //! 264 MOS_STATUS SubmitPictureLevel(MOS_COMMAND_BUFFER* commandBuffer, uint8_t packetPhase); 265 266 //! 267 //! \brief Submit tile level commands 268 //! \param [in] cmdBuffer 269 //! Pointer to the command buffer which is allocated by caller 270 //! \param [in] packetPhase 271 //! Packet phase 272 //! \return MOS_STATUS 273 //! MOS_STATUS_SUCCESS if success, else fail reason 274 //! 275 MOS_STATUS SubmitTileLevel(MOS_COMMAND_BUFFER* commandBuffer, uint8_t packetPhase); 276 277 //! 278 //! \brief Patch slice level commands 279 //! \param [in] cmdBuffer 280 //! Pointer to the command buffer which is allocated by caller 281 //! \param [in] packetPhase 282 //! Packet phase 283 //! \return MOS_STATUS 284 //! MOS_STATUS_SUCCESS if success, else fail reason 285 //! 286 virtual MOS_STATUS PatchSliceLevelCommands(MOS_COMMAND_BUFFER &cmdBuffer, uint8_t packetPhase); 287 288 //! 289 //! \brief Patch tile level commands 290 //! \param [in] cmdBuffer 291 //! Pointer to the command buffer which is allocated by caller 292 //! \param [in] packetPhase 293 //! Packet phase 294 //! \return MOS_STATUS 295 //! MOS_STATUS_SUCCESS if success, else fail reason 296 //! 297 MOS_STATUS PatchTileLevelCommands(MOS_COMMAND_BUFFER &cmdBuffer, uint8_t packetPhase) ; 298 299 //! 300 //! \brief Add one tile commands 301 //! \param [in] cmdBuffer 302 //! Pointer to the command buffer which is allocated by caller 303 //! \param [in] tileRow 304 //! tile row 305 //! \param [in] tileCol 306 //! tile column 307 //! \param [in] tileRowPass 308 //! tile row pass 309 //! \return MOS_STATUS 310 //! MOS_STATUS_SUCCESS if success, else fail reason 311 //! 312 virtual MOS_STATUS AddOneTileCommands( 313 MOS_COMMAND_BUFFER &cmdBuffer, 314 uint32_t tileRow, 315 uint32_t tileCol, 316 uint32_t tileRowPass); 317 318 //! 319 //! \brief Add slice commands in tile 320 //! \param [in] cmdBuffer 321 //! Pointer to the command buffer which is allocated by caller 322 //! \return MOS_STATUS 323 //! MOS_STATUS_SUCCESS if success, else fail reason 324 //! 325 MOS_STATUS AddSlicesCommandsInTile( 326 MOS_COMMAND_BUFFER &cmdBuffer); 327 328 //! 329 //! \brief Update params 330 //! \return void 331 //! No return value 332 //! 333 void UpdateParameters(); 334 335 virtual MOS_STATUS AddPicStateWithNoTile( 336 MOS_COMMAND_BUFFER &cmdBuffer); 337 338 //! 339 //! \brief Add picture state with tile 340 //! \param [in] cmdBuffer 341 //! Pointer to the command buffer which is allocated by caller 342 //! \return MOS_STATUS 343 //! MOS_STATUS_SUCCESS if success, else fail reason 344 //! 345 MOS_STATUS AddPicStateWithTile( 346 MOS_COMMAND_BUFFER &cmdBuffer); 347 348 //! 349 //! \brief Add HCP picture level commands 350 //! \param [in] cmdBuffer 351 //! Pointer to the command buffer which is allocated by caller 352 //! \return MOS_STATUS 353 //! MOS_STATUS_SUCCESS if success, else fail reason 354 //! 355 MOS_STATUS AddPictureHcpCommands(MOS_COMMAND_BUFFER &cmdBuffer); 356 357 //! 358 //! \brief Add VDENC picture level commands 359 //! \param [in] cmdBuffer 360 //! Pointer to the command buffer which is allocated by caller 361 //! \return MOS_STATUS 362 //! MOS_STATUS_SUCCESS if success, else fail reason 363 //! 364 MOS_STATUS AddPictureVdencCommands(MOS_COMMAND_BUFFER &cmdBuffer); 365 366 //! 367 //! \brief Ensure all commands have been executed 368 //! \param [in] packetPhase 369 //! Packet phase 370 //! \param [in] cmdBuffer 371 //! Pointer to the command buffer which is allocated by caller 372 //! \return MOS_STATUS 373 //! MOS_STATUS_SUCCESS if success, else fail reason 374 //! 375 virtual MOS_STATUS PatchPictureLevelCommands(const uint8_t &packetPhase, MOS_COMMAND_BUFFER &cmdBuffer); 376 377 //! 378 //! \brief Ensure all commands have been executed 379 //! \param [in] cmdBuffer 380 //! Pointer to the command buffer which is allocated by caller 381 //! \return MOS_STATUS 382 //! MOS_STATUS_SUCCESS if success, else fail reason 383 //! 384 MOS_STATUS InsertSeqStreamEnd(MOS_COMMAND_BUFFER &cmdBuffer); 385 386 //! 387 //! \brief Ensure all commands have been executed 388 //! \param [in] cmdBuffer 389 //! Pointer to the command buffer which is allocated by caller 390 //! \return MOS_STATUS 391 //! MOS_STATUS_SUCCESS if success, else fail reason 392 //! 393 virtual MOS_STATUS EnsureAllCommandsExecuted(MOS_COMMAND_BUFFER &cmdBuffer); 394 395 virtual MOS_STATUS AddHcpPipeModeSelect( 396 MOS_COMMAND_BUFFER &cmdBuffer); 397 398 virtual MOS_STATUS UpdateStatusReport(uint32_t srType, MOS_COMMAND_BUFFER *cmdBuffer) override; 399 400 //! 401 //! \brief Construct 3rd level batch buffer 402 //! \return MOS_STATUS 403 //! MOS_STATUS_SUCCESS if success, else fail reason 404 //! 405 MOS_STATUS Construct3rdLevelBatch(); 406 407 virtual MOS_STATUS AllocateResources(); 408 409 //! 410 //! \brief Add conditional batch buffer end command 411 //! \param [in] cmdBuffer 412 //! Pointer to the command buffer which is allocated by caller 413 //! \return MOS_STATUS 414 //! MOS_STATUS_SUCCESS if success, else fail reason 415 //! 416 MOS_STATUS AddCondBBEndForLastPass(MOS_COMMAND_BUFFER &cmdBuffer); 417 418 virtual MOS_STATUS StartStatusReport( 419 uint32_t srType, 420 MOS_COMMAND_BUFFER *cmdBuffer) override; 421 422 virtual MOS_STATUS EndStatusReport( 423 uint32_t srType, 424 MOS_COMMAND_BUFFER *cmdBuffer) override; 425 426 //! 427 //! \brief Add command to read the HCP status 428 //! 429 //! \param [in] vdboxIndex 430 //! Index of vdbox 431 //! \param [in] statusReport 432 //! Encode status report 433 //! \param [in, out] cmdBuffer 434 //! Command buffer 435 //! 436 //! \return MOS_STATUS 437 //! MOS_STATUS_SUCCESS if success, else fail reason 438 //! 439 MOS_STATUS ReadHcpStatus( 440 MHW_VDBOX_NODE_IND vdboxIndex, 441 MediaStatusReport * statusReport, 442 MOS_COMMAND_BUFFER &cmdBuffer); 443 444 void SetPakPassType(); 445 446 MOS_STATUS ReadSliceSizeForSinglePipe(MOS_COMMAND_BUFFER &cmdBuffer); 447 448 MOS_STATUS ReadSliceSize(MOS_COMMAND_BUFFER &cmdBuffer); 449 450 // Inline functions 451 MOS_STATUS ValidateVdboxIdx(const MHW_VDBOX_NODE_IND &vdboxIndex); 452 453 void SetPerfTag(); 454 455 MOS_STATUS SetSemaphoreMem( 456 MOS_RESOURCE & semaphoreMem, 457 uint32_t value, 458 MOS_COMMAND_BUFFER &cmdBuffer); 459 460 MOS_STATUS SendPrologCmds( 461 MOS_COMMAND_BUFFER &cmdBuffer); 462 463 MOS_STATUS AllocateBatchBufferForPakSlices( 464 uint32_t numSlices, 465 uint16_t numPakPasses); 466 467 MOS_STATUS SetBatchBufferForPakSlices(); 468 469 virtual MOS_STATUS ReadExtStatistics(MOS_COMMAND_BUFFER &cmdBuffer); 470 471 //! 472 //! \brief Retreive BRC Pak statistics 473 //! 474 //! \param [in] cmdBuffer 475 //! Pointer to command buffer 476 //! \param [in] params 477 //! BRC pak statistics parameters 478 //! 479 //! \return MOS_STATUS 480 //! MOS_STATUS_SUCCESS if success, else fail reason 481 //! 482 virtual MOS_STATUS ReadBrcPakStatistics( 483 PMOS_COMMAND_BUFFER cmdBuffer, 484 EncodeReadBrcPakStatsParams *params); 485 486 virtual MOS_STATUS AddForceWakeup(MOS_COMMAND_BUFFER &cmdBuffer); 487 488 //! \brief Report extended statistics 489 //! 490 //! \param [in] encodeStatusMfx 491 //! Reference to encoder status for vdbox 492 //! \param [in, out] statusReportData 493 //! Reference to encoder status report data 494 //! 495 //! \return MOS_STATUS 496 //! MOS_STATUS_SUCCESS if success, else fail reason 497 //! 498 virtual MOS_STATUS ReportExtStatistics( 499 EncodeStatusMfx &encodeStatusMfx, 500 EncodeStatusReportData &statusReportData); 501 502 //! \brief Set Rowstore Cache offset 503 //! 504 //! \return MOS_STATUS 505 //! MOS_STATUS_SUCCESS if success, else fail reason 506 //! 507 MOS_STATUS SetRowstoreCachingOffsets(); 508 509 //! 510 //! \brief Free resources 511 //! \return MOS_STATUS 512 //! MOS_STATUS_SUCCESS if success, else fail reason 513 //! 514 virtual MOS_STATUS FreeResources(); 515 516 MHW_SETPAR_DECL_HDR(VDENC_CONTROL_STATE); 517 518 MHW_SETPAR_DECL_HDR(VDENC_PIPE_MODE_SELECT); 519 520 MHW_SETPAR_DECL_HDR(VDENC_PIPE_BUF_ADDR_STATE); 521 522 MHW_SETPAR_DECL_HDR(VD_PIPELINE_FLUSH); 523 524 MHW_SETPAR_DECL_HDR(HCP_PIPE_MODE_SELECT); 525 526 MHW_SETPAR_DECL_HDR(HCP_TILE_CODING); 527 528 MHW_SETPAR_DECL_HDR(HCP_PIPE_BUF_ADDR_STATE); 529 530 MHW_SETPAR_DECL_HDR(HCP_IND_OBJ_BASE_ADDR_STATE); 531 532 MHW_SETPAR_DECL_HDR(HCP_SLICE_STATE); 533 534 MHW_SETPAR_DECL_HDR(HCP_SURFACE_STATE); 535 536 MOS_STATUS AddAllCmds_HCP_PAK_INSERT_OBJECT(PMOS_COMMAND_BUFFER cmdBuffer) const; 537 538 MOS_STATUS AddAllCmds_HCP_PAK_INSERT_OBJECT_BRC(PMOS_COMMAND_BUFFER cmdBuffer) const; 539 540 MOS_STATUS AddAllCmds_HCP_SURFACE_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const; 541 542 MOS_STATUS AddAllCmds_HCP_REF_IDX_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const; 543 544 MOS_STATUS AddAllCmds_HCP_FQM_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const; 545 546 MOS_STATUS AddAllCmds_HCP_QM_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const; 547 548 MOS_STATUS AddAllCmds_HCP_WEIGHTOFFSET_STATE(PMOS_COMMAND_BUFFER cmdBuffer) const; 549 550 // 3rd Level Batch buffer 551 AtomicScratchBuffer m_atomicScratchBuf = {}; //!< Stores atomic operands and result 552 553 MHW_SETPAR_DECL_HDR(VDENC_HEVC_VP9_TILE_SLICE_STATE); 554 555 #if USE_CODECHAL_DEBUG_TOOL 556 //! \brief Dump the output resources in status report callback function 557 //! 558 //! \param [in] encodeStatusMfx 559 //! Pointer to encoder status for vdbox 560 //! \param [in] statusReportData 561 //! Pointer to encoder status report datas 562 //! 563 //! \return MOS_STATUS 564 //! MOS_STATUS_SUCCESS if success, else fail reason 565 //! 566 MOS_STATUS DumpResources( 567 EncodeStatusMfx * encodeStatusMfx, 568 EncodeStatusReportData *statusReportData); 569 #endif 570 HevcVdencPipeline *m_pipeline = nullptr; 571 572 // Interfaces 573 EncodeAllocator * m_allocator = nullptr; 574 CodechalHwInterfaceNext * m_hwInterface = nullptr; 575 HevcBasicFeature * m_basicFeature = nullptr; //!< Encode parameters used in each frame 576 EncodeMemComp * m_mmcState = nullptr; 577 EncodeCp * m_encodecp = nullptr; 578 PacketUtilities * m_packetUtilities = nullptr; 579 580 SubmitState m_submitState = submitFrameByDefault; 581 582 std::shared_ptr<mhw::vdbox::vdenc::Itf> m_vdencItf = nullptr; 583 std::shared_ptr<mhw::vdbox::hcp::Itf> m_hcpItf = nullptr; 584 std::shared_ptr<MediaFeatureManager::ManagerLite> m_featureManager = nullptr; 585 586 mutable uint8_t m_curHcpSurfStateId = 0; 587 588 // Parameters passed from application 589 const CODEC_HEVC_ENCODE_PICTURE_PARAMS * m_hevcPicParams = nullptr; //!< Pointer to picture parameter 590 const CODEC_HEVC_ENCODE_SEQUENCE_PARAMS *m_hevcSeqParams = nullptr; //!< Pointer to sequence parameter 591 const CODEC_HEVC_ENCODE_SLICE_PARAMS * m_hevcSliceParams = nullptr; //!< Pointer to slice parameter 592 const CODECHAL_HEVC_IQ_MATRIX_PARAMS * m_hevcIqMatrixParams = nullptr; //!< Pointer to IQ matrix parameter 593 const PCODECHAL_NAL_UNIT_PARAMS * m_nalUnitParams = nullptr; //!< Pointer to NAL unit parameters 594 595 bool m_pakOnlyPass = false; 596 bool m_streamInEnabled = false; //!< Vdenc stream in enabled flag 597 598 uint8_t m_currRecycledBufIdx = 0; //!< Current recycled buffer index 599 600 uint32_t m_mvOffset = 0; //!< MV data offset, in 64 byte 601 uint32_t m_mbCodeSize = 0; //!< MB code buffer size 602 PMOS_RESOURCE m_resMetadataLineBuffer = nullptr; //!< Metadata line data buffer 603 PMOS_RESOURCE m_resMetadataTileLineBuffer = nullptr; //!< Metadata tile line data buffer 604 PMOS_RESOURCE m_resMetadataTileColumnBuffer = nullptr; //!< Metadata tile column data buffer 605 PMOS_RESOURCE m_resLCUIldbStreamOutBuffer = nullptr; //!< LCU ILDB stream-out buffer 606 PMOS_RESOURCE m_resSSESrcPixelRowStoreBuffer = nullptr; //!< SSE Src pixel row store buffer 607 PMOS_RESOURCE m_resCumulativeCuCountStreamoutBuffer = nullptr; //!< Cumulative CU count stream out buffer 608 PMOS_RESOURCE m_vdencTileRowStoreBuffer = nullptr; //!< Tile row store buffer 609 PMOS_RESOURCE m_resPakcuLevelStreamOutData = nullptr; //!< PAK LCU level stream out data buffer 610 611 MHW_VDBOX_NODE_IND m_vdboxIndex = MHW_VDBOX_NODE_1; //!< Index of VDBOX 612 613 uint32_t m_sliceStatesSize = 0; //!< Slice states size 614 615 bool m_lastTaskInPhase = false; //!< last task in phase flag 616 617 bool m_useBatchBufferForPakSlices = false; 618 619 int32_t m_batchBufferForPakSlicesStartOffset = 0; 620 uint32_t m_sizeOfSseSrcPixelRowStoreBufferPerLcu = 0; //!< Size of SSE row store buffer per LCU 621 622 MHW_BATCH_BUFFER m_batchBufferForPakSlices[HevcBasicFeature::m_codecHalHevcNumPakSliceBatchBuffers] = {}; //!< Batch buffer for pak slice commands 623 624 PMOS_RESOURCE m_vdencIntraRowStoreScratch = nullptr; 625 626 bool m_usePatchList = 0; //!< Use Ptach List or not 627 uint32_t m_defaultPictureStatesSize = 0; //!< Picture state command size 628 uint32_t m_pictureStatesSize = 0; //!< Picture states size 629 uint32_t m_defaultSliceStatesSize = 0; //!< Slice state command size 630 uint32_t m_defaultPicturePatchListSize = 0; //!< Picture state patch list size 631 uint32_t m_picturePatchListSize = 0; //!< Picture patch list size 632 uint32_t m_defaultSlicePatchListSize = 0; //!< Slice state patch list size 633 uint32_t m_slicePatchListSize = 0; //!< Slice patch list size 634 635 bool m_vdencPakObjCmdStreamOutForceEnabled = false; 636 637 bool m_lastSliceInTile = false; 638 639 FlushCmd m_flushCmd = waitHevc; 640 641 #if USE_CODECHAL_DEBUG_TOOL && _ENCODE_RESERVED 642 std::shared_ptr<HevcVdencParDump> m_hevcParDump = nullptr; 643 #endif // _ENCODE_RESERVED 644 645 bool m_enableVdencStatusReport = false; 646 647 MEDIA_CLASS_DEFINE_END(encode__HevcVdencPkt) 648 }; 649 650 } 651 652 #endif 653