1 #ifndef _VKTVIDEOBASEDECODEUTILS_HPP 2 #define _VKTVIDEOBASEDECODEUTILS_HPP 3 /*------------------------------------------------------------------------ 4 * Vulkan Conformance Tests 5 * ------------------------ 6 * 7 * Copyright (c) 2021 The Khronos Group Inc. 8 * 9 * Licensed under the Apache License, Version 2.0 (the "License"); 10 * you may not use this file except in compliance with the License. 11 * You may obtain a copy of the License at 12 * 13 * http://www.apache.org/licenses/LICENSE-2.0 14 * 15 * Unless required by applicable law or agreed to in writing, software 16 * distributed under the License is distributed on an "AS IS" BASIS, 17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18 * See the License for the specific language governing permissions and 19 * limitations under the License. 20 * 21 *//*! 22 * \file 23 * \brief Video Decoding Base Classe Functionality 24 *//*--------------------------------------------------------------------*/ 25 /* 26 * Copyright 2020 NVIDIA Corporation. 27 * 28 * Licensed under the Apache License, Version 2.0 (the "License"); 29 * you may not use this file except in compliance with the License. 30 * You may obtain a copy of the License at 31 * 32 * http://www.apache.org/licenses/LICENSE-2.0 33 * 34 * Unless required by applicable law or agreed to in writing, software 35 * distributed under the License is distributed on an "AS IS" BASIS, 36 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 37 * See the License for the specific language governing permissions and 38 * limitations under the License. 39 */ 40 41 #include "vktVideoTestUtils.hpp" 42 #include "vktVideoSessionNvUtils.hpp" 43 #include "vktVideoSessionFfmpegUtils.hpp" 44 #include "extNvidiaVideoParserIf.hpp" 45 #include "vkImageWithMemory.hpp" 46 #include "vkBufferWithMemory.hpp" 47 48 #include <vector> 49 #include <list> 50 #include <bitset> 51 #include <queue> 52 53 namespace vkt 54 { 55 namespace video 56 { 57 58 using namespace vk; 59 using namespace std; 60 61 62 63 class ImageObject 64 { 65 public: 66 ImageObject (); 67 ~ImageObject (); 68 void DestroyImage (void); 69 70 VkResult CreateImage (const DeviceInterface& vkd, 71 VkDevice device, 72 int32_t queueFamilyIndex, 73 Allocator& allocator, 74 const VkImageCreateInfo* pImageCreateInfo, 75 const MemoryRequirement memoryRequirement); 76 VkResult StageImage (const DeviceInterface& vkd, 77 VkDevice device, 78 VkImageUsageFlags usage, 79 const MemoryRequirement memoryRequirement, 80 uint32_t queueFamilyIndex); 81 VkFormat getFormat (void) const; 82 VkExtent2D getExtent (void) const; 83 VkImage getImage (void) const; 84 VkImageView getView (void) const; 85 bool isArray (void) const; 86 bool isImageExist (void) const; 87 88 protected: 89 VkFormat m_imageFormat; 90 VkExtent2D m_imageExtent; 91 de::MovePtr<ImageWithMemory> m_image; 92 Move<VkImageView> m_imageView; 93 uint32_t m_imageArrayLayers; 94 }; 95 96 struct DecodedFrame 97 { 98 int32_t pictureIndex; 99 const ImageObject* pDecodedImage; 100 VkImageLayout decodedImageLayout; 101 VkFence frameCompleteFence; 102 VkFence frameConsumerDoneFence; 103 VkSemaphore frameCompleteSemaphore; 104 VkSemaphore frameConsumerDoneSemaphore; 105 VkQueryPool queryPool; 106 int32_t startQueryId; 107 uint32_t numQueries; 108 uint64_t timestamp; 109 uint32_t hasConsummerSignalFence : 1; 110 uint32_t hasConsummerSignalSemaphore : 1; 111 // For debugging 112 int32_t decodeOrder; 113 int32_t displayOrder; 114 }; 115 116 struct DecodedFrameRelease 117 { 118 int32_t pictureIndex; 119 int64_t timestamp; 120 uint32_t hasConsummerSignalFence : 1; 121 uint32_t hasConsummerSignalSemaphore : 1; 122 // For debugging 123 int32_t decodeOrder; 124 int32_t displayOrder; 125 }; 126 127 struct DisplayPictureInfo 128 { 129 int64_t timestamp; // Presentation time stamp 130 }; 131 132 133 class NvidiaPerFrameDecodeImage : public NvidiaVulkanPictureBase 134 { 135 public: 136 NvidiaPerFrameDecodeImage (); 137 NvidiaPerFrameDecodeImage (const NvidiaPerFrameDecodeImage& srcObj) = delete; 138 NvidiaPerFrameDecodeImage (NvidiaPerFrameDecodeImage&& srcObj) = delete; 139 ~NvidiaPerFrameDecodeImage (); 140 141 void deinit (void); 142 void init (const DeviceInterface& vkd, 143 VkDevice device); 144 145 VkResult CreateImage (const DeviceInterface& vkd, 146 VkDevice device, 147 int32_t queueFamilyIndex, 148 Allocator& allocator, 149 const VkImageCreateInfo* pImageCreateInfo, 150 const MemoryRequirement memoryRequirement); 151 152 const ImageObject* GetImageObject (void); 153 bool isImageExist (void); 154 const ImageObject* GetDPBImageObject (void); 155 156 VulkanParserDecodePictureInfo m_picDispInfo; 157 ImageObject m_frameImage; 158 VkImageLayout m_frameImageCurrentLayout; 159 Move<VkFence> m_frameCompleteFence; 160 Move<VkSemaphore> m_frameCompleteSemaphore; 161 Move<VkFence> m_frameConsumerDoneFence; 162 Move<VkSemaphore> m_frameConsumerDoneSemaphore; 163 uint32_t m_hasFrameCompleteSignalFence : 1; 164 uint32_t m_hasFrameCompleteSignalSemaphore : 1; 165 uint32_t m_hasConsummerSignalFence : 1; 166 uint32_t m_hasConsummerSignalSemaphore : 1; 167 uint32_t m_inDecodeQueue : 1; 168 uint32_t m_inDisplayQueue : 1; 169 uint32_t m_ownedByDisplay : 1; 170 NvidiaSharedBaseObj<NvidiaParserVideoRefCountBase> currentVkPictureParameters; 171 de::SharedPtr<ImageObject> m_dpbImage; 172 VkImageLayout m_dpbImageCurrentLayout; 173 }; 174 175 class NvidiaPerFrameDecodeImageSet 176 { 177 public: 178 enum 179 { 180 MAX_FRAMEBUFFER_IMAGES = 32 181 }; 182 NvidiaPerFrameDecodeImageSet (); 183 ~NvidiaPerFrameDecodeImageSet (); 184 185 int32_t init (const DeviceInterface& vkd, 186 VkDevice device, 187 int32_t queueFamilyIndex, 188 Allocator& allocator, 189 uint32_t numImages, 190 const VkImageCreateInfo* pOutImageCreateInfo, 191 const VkImageCreateInfo* pDpbImageCreateInfo, 192 MemoryRequirement memoryRequirement = MemoryRequirement::Any); 193 194 void deinit (void); 195 196 NvidiaPerFrameDecodeImage& operator[] (size_t index); 197 size_t size (void); 198 199 private: 200 size_t m_size; 201 NvidiaPerFrameDecodeImage m_frameDecodeImages[MAX_FRAMEBUFFER_IMAGES]; 202 }; 203 204 class VideoFrameBuffer 205 { 206 public: 207 // Synchronization 208 struct FrameSynchronizationInfo 209 { 210 VkFence frameCompleteFence; 211 VkSemaphore frameCompleteSemaphore; 212 VkFence frameConsumerDoneFence; 213 VkSemaphore frameConsumerDoneSemaphore; 214 VkQueryPool queryPool; 215 int32_t startQueryId; 216 uint32_t numQueries; 217 uint32_t hasFrameCompleteSignalFence : 1; 218 uint32_t hasFrameCompleteSignalSemaphore : 1; 219 }; 220 221 struct PictureResourceInfo 222 { 223 VkImage image; 224 VkImageLayout currentImageLayout; 225 }; 226 227 VideoFrameBuffer (); 228 virtual ~VideoFrameBuffer (); 229 230 virtual int32_t InitImagePool (const DeviceInterface& vkd, 231 VkDevice device, 232 int32_t queueFamilyIndex, 233 Allocator& allocator, 234 uint32_t numImages, 235 uint32_t maxNumImages, 236 const VkImageCreateInfo* pOutImageCreateInfo, 237 const VkImageCreateInfo* pDpbImageCreateInfo, 238 const VkVideoProfileInfoKHR* pDecodeProfile = DE_NULL); 239 virtual int32_t QueuePictureForDecode (int8_t picId, 240 VulkanParserDecodePictureInfo* pDecodePictureInfo, 241 NvidiaParserVideoRefCountBase* pCurrentVkPictureParameters, 242 FrameSynchronizationInfo* pFrameSynchronizationInfo); 243 virtual int32_t DequeueDecodedPicture (DecodedFrame* pDecodedFrame); 244 virtual int32_t GetDisplayFramesCount (void); 245 virtual int32_t ReleaseDisplayedPicture (DecodedFrameRelease** pDecodedFramesRelease, 246 uint32_t numFramesToRelease); 247 virtual void GetImageResourcesByIndex (int32_t numResources, 248 const int8_t* referenceSlotIndexes, 249 VkVideoPictureResourceInfoKHR* videoPictureResources, 250 PictureResourceInfo* pictureResourcesInfo, 251 VkImageLayout newImageLayout); 252 virtual void GetImageResourcesByIndex (const int8_t referenceSlotIndex, 253 VkVideoPictureResourceInfoKHR* videoPictureResources, 254 PictureResourceInfo* pictureResourcesInfo, 255 VkImageLayout newImageLayout); 256 virtual int32_t SetPicNumInDecodeOrder (int32_t picId, 257 int32_t picNumInDecodeOrder); 258 virtual int32_t SetPicNumInDisplayOrder (int32_t picId, 259 int32_t picNumInDisplayOrder); 260 virtual size_t GetSize (void); 261 Move<VkQueryPool> CreateVideoQueries (const DeviceInterface& vkd, 262 VkDevice device, 263 uint32_t numSlots, 264 const VkVideoProfileInfoKHR* pDecodeProfile); 265 int32_t QueueDecodedPictureForDisplay (int8_t picId, 266 DisplayPictureInfo* pDispInfo); 267 NvidiaVulkanPictureBase* ReservePictureBuffer (void); 268 269 protected: 270 NvidiaPerFrameDecodeImageSet m_perFrameDecodeImageSet; 271 queue<uint8_t> m_displayFrames; 272 Move<VkQueryPool> m_queryPool; 273 uint32_t m_ownedByDisplayMask; 274 int32_t m_frameNumInDecodeOrder; 275 int32_t m_frameNumInDisplayOrder; 276 VkExtent2D m_extent; 277 }; 278 279 struct NvidiaVideoDecodeH264DpbSlotInfo 280 { 281 NvidiaVideoDecodeH264DpbSlotInfo (); 282 const VkVideoDecodeH264DpbSlotInfoKHR* Init (int32_t slotIndex); 283 bool IsReference () const; 284 operator bool () const; 285 void Invalidate (); 286 287 VkVideoDecodeH264DpbSlotInfoKHR dpbSlotInfo; 288 StdVideoDecodeH264ReferenceInfo stdReferenceInfo; 289 }; 290 291 struct NvidiaVideoDecodeH265DpbSlotInfo 292 { 293 NvidiaVideoDecodeH265DpbSlotInfo (); 294 const VkVideoDecodeH265DpbSlotInfoKHR* Init (int32_t slotIndex); 295 bool IsReference () const; 296 operator bool () const; 297 void Invalidate (); 298 299 VkVideoDecodeH265DpbSlotInfoKHR dpbSlotInfo; 300 StdVideoDecodeH265ReferenceInfo stdReferenceInfo; 301 }; 302 303 class DpbSlot 304 { 305 public: 306 bool isInUse (); 307 bool isAvailable (); 308 bool Invalidate (); 309 NvidiaVulkanPictureBase* getPictureResource (); 310 NvidiaVulkanPictureBase* setPictureResource (NvidiaVulkanPictureBase* picBuf); 311 void Reserve (); 312 void MarkInUse (); 313 314 private: 315 NvidiaVulkanPictureBase* m_picBuf; // Associated resource 316 bool m_reserved; 317 bool m_inUse; 318 }; 319 320 class DpbSlots 321 { 322 public: 323 DpbSlots (uint32_t dpbMaxSize); 324 ~DpbSlots (); 325 326 int32_t Init (uint32_t newDpbMaxSize, 327 bool reconfigure); 328 void Deinit (void); 329 int8_t AllocateSlot (void); 330 void FreeSlot (int8_t slot); 331 DpbSlot& operator[] (uint32_t slot); 332 void MapPictureResource (NvidiaVulkanPictureBase* pPic, 333 int32_t dpbSlot); 334 uint32_t getMaxSize (void); 335 uint32_t getSlotInUseMask (void); 336 337 private: 338 uint32_t m_dpbMaxSize; 339 uint32_t m_slotInUseMask; 340 vector<DpbSlot> m_dpb; 341 queue<uint8_t> m_dpbSlotsAvailable; 342 }; 343 344 class NvidiaParserVideoPictureParameters : public NvidiaParserVideoRefCountBase 345 { 346 public: 347 static const uint32_t MAX_SPS_IDS = 32; 348 static const uint32_t MAX_PPS_IDS = 256; 349 350 virtual int32_t AddRef(); 351 virtual int32_t Release(); 352 static NvidiaParserVideoPictureParameters* VideoPictureParametersFromBase (NvidiaParserVideoRefCountBase* pBase); 353 static NvidiaParserVideoPictureParameters* Create (const DeviceInterface& vkd, 354 VkDevice device, 355 VkVideoSessionKHR videoSession, 356 const StdVideoPictureParametersSet* pSpsStdPictureParametersSet, 357 const StdVideoPictureParametersSet* pPpsStdPictureParametersSet, 358 NvidiaParserVideoPictureParameters* pTemplate); 359 static int32_t PopulateH264UpdateFields (const StdVideoPictureParametersSet* pStdPictureParametersSet, 360 VkVideoDecodeH264SessionParametersAddInfoKHR& h264SessionParametersAddInfo); 361 static int32_t PopulateH265UpdateFields (const StdVideoPictureParametersSet* pStdPictureParametersSet, 362 VkVideoDecodeH265SessionParametersAddInfoKHR& h265SessionParametersAddInfo); 363 VkResult Update (const DeviceInterface& vkd, 364 const StdVideoPictureParametersSet* pSpsStdPictureParametersSet, 365 const StdVideoPictureParametersSet* pPpsStdPictureParametersSet); 366 VkVideoSessionParametersKHR GetVideoSessionParametersKHR () const; 367 int32_t GetId () const; 368 bool HasSpsId (uint32_t spsId) const; 369 bool HasPpsId (uint32_t ppsId) const; 370 371 protected: 372 NvidiaParserVideoPictureParameters (VkDevice device); 373 virtual ~NvidiaParserVideoPictureParameters (); 374 375 private: 376 static int32_t m_currentId; 377 int32_t m_Id; 378 atomic<int32_t> m_refCount; 379 VkDevice m_device; 380 Move<VkVideoSessionParametersKHR> m_sessionParameters; 381 bitset<MAX_SPS_IDS> m_spsIdsUsed; 382 bitset<MAX_PPS_IDS> m_ppsIdsUsed; 383 }; 384 385 class VulkanVideoBitstreamBuffer 386 { 387 public: 388 VulkanVideoBitstreamBuffer (); 389 ~VulkanVideoBitstreamBuffer (); 390 VkResult CreateVideoBitstreamBuffer (const DeviceInterface& vkd, 391 VkDevice device, 392 Allocator& allocator, 393 VkDeviceSize bufferSize, 394 VkDeviceSize bufferOffsetAlignment, 395 VkDeviceSize bufferSizeAlignment, 396 void* pNext, 397 const unsigned char* pBitstreamData = DE_NULL, 398 VkDeviceSize bitstreamDataSize = 0); 399 VkResult CopyVideoBitstreamToBuffer (const DeviceInterface& vkd, 400 VkDevice device, 401 const unsigned char* pBitstreamData, 402 VkDeviceSize bitstreamDataSize); 403 void DestroyVideoBitstreamBuffer (); 404 VkDeviceSize GetBufferSize (); 405 VkDeviceSize GetBufferOffsetAlignment (); 406 const VkBuffer& get (); 407 408 protected: 409 VkDeviceSize m_bufferSize; 410 VkDeviceSize m_bufferOffsetAlignment; 411 VkDeviceSize m_bufferSizeAlignment; 412 de::MovePtr<BufferWithMemory> m_buffer; 413 }; 414 415 class NvVkDecodeFrameData 416 { 417 public: 418 VulkanVideoBitstreamBuffer bitstreamBuffer; 419 Move<VkCommandBuffer> commandBuffer; 420 }; 421 422 typedef queue<NvidiaSharedBaseObj<StdVideoPictureParametersSet>> PictureParametersQueue; 423 typedef NvidiaSharedBaseObj<StdVideoPictureParametersSet> LastSpsPictureParametersQueue; 424 typedef NvidiaSharedBaseObj<StdVideoPictureParametersSet> LastPpsPictureParametersQueue; 425 typedef NvidiaSharedBaseObj<NvidiaParserVideoPictureParameters> CurrentPictureParameters; 426 427 typedef vector<de::MovePtr<vector<deUint8>>> HeapType; 428 429 #define ALLOC_HEAP_OBJECT_ARRAY(H,T,N) ((T*)heap.emplace(H.end(), de::MovePtr<vector<deUint8>>(new vector<deUint8>(sizeof(T)*N)))->get()->data()) 430 #define ALLOC_HEAP_OBJECT(H,T) ALLOC_HEAP_OBJECT_ARRAY(H,T,1) 431 432 class VideoBaseDecoder : public NvidiaVulkanParserVideoDecodeClient 433 { 434 public: 435 enum 436 { 437 MAX_FRM_CNT = 32, 438 }; 439 440 VideoBaseDecoder (Context& context); 441 ~VideoBaseDecoder (void); 442 443 void initialize (const VkVideoCodecOperationFlagBitsKHR videoCodecOperation, 444 const DeviceInterface& vkd, 445 const VkDevice device, 446 const deUint32 queueFamilyIndexTransfer, 447 const deUint32 queueFamilyIndexDecode, 448 Allocator& allocator); 449 450 VkDevice getDevice (void); 451 const DeviceInterface& getDeviceDriver (void); 452 deUint32 getQueueFamilyIndexTransfer (void); 453 deUint32 getQueueFamilyIndexDecode (void); 454 VkQueue getQueueTransfer (void); 455 VkQueue getQueueDecode (void); 456 Allocator& getAllocator (void); 457 458 void setDecodeParameters (bool randomOrSwapped, 459 bool queryResultWithStatus, 460 uint32_t frameCountTrigger, 461 bool submitAfter = true, 462 uint32_t gopSize = 0, 463 uint32_t dpbCount = 1); 464 int32_t DecodeCachedPictures (VideoBaseDecoder* friendDecoder = DE_NULL, 465 bool waitSubmitted = true); 466 467 protected: 468 // NvidiaVulkanParserVideoDecodeClient callbacks 469 virtual int32_t BeginSequence (const NvidiaVulkanParserSequenceInfo* pnvsi) override; // Returns max number of reference frames (always at least 2 for MPEG-2) 470 virtual bool AllocPictureBuffer (INvidiaVulkanPicture** ppNvidiaVulkanPicture) override; // Returns a new INvidiaVulkanPicture interface 471 virtual bool DecodePicture (NvidiaVulkanParserPictureData* pNvidiaVulkanParserPictureData) override; // Called when a picture is ready to be decoded 472 virtual bool UpdatePictureParameters (NvidiaVulkanPictureParameters* pNvidiaVulkanPictureParameters, 473 NvidiaSharedBaseObj<NvidiaParserVideoRefCountBase>& pictureParametersObject, 474 uint64_t updateSequenceCount) override; // Called when a picture is ready to be decoded 475 virtual bool DisplayPicture (INvidiaVulkanPicture* pNvidiaVulkanPicture, 476 int64_t llPTS) override; // Called when a picture is ready to be displayed 477 virtual void UnhandledNALU (const uint8_t* pbData, 478 int32_t cbData) override; // Called for custom NAL parsing (not required) 479 480 // Parser methods 481 bool DecodePicture (NvidiaVulkanParserPictureData* pNvidiaVulkanParserPictureData, 482 VulkanParserDecodePictureInfo* pDecodePictureInfo); 483 uint32_t FillDpbH264State (const NvidiaVulkanParserPictureData* pNvidiaVulkanParserPictureData, 484 const NvidiaVulkanParserH264DpbEntry* dpbIn, 485 uint32_t maxDpbInSlotsInUse, 486 NvidiaVideoDecodeH264DpbSlotInfo* pDpbRefList, 487 VkVideoReferenceSlotInfoKHR* pReferenceSlots, 488 int8_t* pGopReferenceImagesIndexes, 489 StdVideoDecodeH264PictureInfoFlags currPicFlags, 490 int32_t* pCurrAllocatedSlotIndex); 491 uint32_t FillDpbH265State (const NvidiaVulkanParserPictureData* pNvidiaVulkanParserPictureData, 492 const NvidiaVulkanParserH265PictureData* pin, 493 NvidiaVideoDecodeH265DpbSlotInfo* pDpbSlotInfo, 494 StdVideoDecodeH265PictureInfo* pStdPictureInfo, 495 VkVideoReferenceSlotInfoKHR* pReferenceSlots, 496 int8_t* pGopReferenceImagesIndexes); 497 int8_t AllocateDpbSlotForCurrentH264 (NvidiaVulkanPictureBase* pNvidiaVulkanPictureBase, 498 StdVideoDecodeH264PictureInfoFlags currPicFlags); 499 int8_t AllocateDpbSlotForCurrentH265 (NvidiaVulkanPictureBase* pNvidiaVulkanPictureBase, 500 bool isReference); 501 int8_t GetPicIdx (NvidiaVulkanPictureBase* pNvidiaVulkanPictureBase); 502 int8_t GetPicIdx (INvidiaVulkanPicture* pNvidiaVulkanPicture); 503 int8_t GetPicDpbSlot (NvidiaVulkanPictureBase* pNvidiaVulkanPictureBase); 504 int8_t GetPicDpbSlot (int8_t picIndex); 505 int8_t SetPicDpbSlot (NvidiaVulkanPictureBase* pNvidiaVulkanPictureBase, 506 int8_t dpbSlot); 507 int8_t SetPicDpbSlot (int8_t picIndex, 508 int8_t dpbSlot); 509 uint32_t ResetPicDpbSlots (uint32_t picIndexSlotValidMask); 510 bool GetFieldPicFlag (int8_t picIndex); 511 bool SetFieldPicFlag (int8_t picIndex, 512 bool fieldPicFlag); 513 514 void ReinitCaches (void); 515 void SubmitQueue (VkCommandBufferSubmitInfoKHR* commandBufferSubmitInfo, 516 VkSubmitInfo2KHR* submitInfo, 517 VideoFrameBuffer::FrameSynchronizationInfo* frameSynchronizationInfo, 518 VkSemaphoreSubmitInfoKHR* frameConsumerDoneSemaphore, 519 VkSemaphoreSubmitInfoKHR* frameCompleteSemaphore); 520 521 void SubmitQueue (vector<VkCommandBufferSubmitInfoKHR>& commandBufferSubmitInfos, 522 VkSubmitInfo2KHR* submitInfo, 523 const VkFence frameCompleteFence, 524 const vector<VkFence>& frameConsumerDoneFence, 525 const vector<VkSemaphoreSubmitInfoKHR>& frameCompleteSemaphores, 526 const vector<VkSemaphoreSubmitInfoKHR>& frameConsumerDoneSemaphores); 527 528 // Client callbacks 529 virtual int32_t StartVideoSequence (const VulkanParserDetectedVideoFormat* pVideoFormat); 530 virtual bool UpdatePictureParametersHandler (NvidiaVulkanPictureParameters* pNvidiaVulkanPictureParameters, 531 NvidiaSharedBaseObj<NvidiaParserVideoRefCountBase>& pictureParametersObject, 532 uint64_t updateSequenceCount); 533 virtual int32_t DecodePictureWithParameters (PerFrameDecodeParameters* pPicParams, 534 VulkanParserDecodePictureInfo* pDecodePictureInfo, 535 HeapType& heap); 536 537 // Client methods 538 virtual void Deinitialize (void); 539 uint32_t GetNumDecodeSurfaces (VkVideoCodecOperationFlagBitsKHR codec, 540 uint32_t minNumDecodeSurfaces, 541 uint32_t width, 542 uint32_t height); 543 bool AddPictureParametersToQueue (NvidiaSharedBaseObj<StdVideoPictureParametersSet>& pictureParametersSet); 544 uint32_t FlushPictureParametersQueue (); 545 bool CheckStdObjectBeforeUpdate (NvidiaSharedBaseObj<StdVideoPictureParametersSet>& stdPictureParametersSet); 546 NvidiaParserVideoPictureParameters* CheckStdObjectAfterUpdate (NvidiaSharedBaseObj<StdVideoPictureParametersSet>& stdPictureParametersSet, 547 NvidiaParserVideoPictureParameters* pNewPictureParametersObject); 548 NvidiaParserVideoPictureParameters* AddPictureParameters (NvidiaSharedBaseObj<StdVideoPictureParametersSet>& spsStdPictureParametersSet, 549 NvidiaSharedBaseObj<StdVideoPictureParametersSet>& ppsStdPictureParametersSet); 550 NvVkDecodeFrameData* GetCurrentFrameData (uint32_t currentSlotId); 551 552 public: 553 NvVkDecodeFrameData* TriggerQueue (uint32_t currentSlotId); 554 int32_t ReleaseDisplayedFrame (DecodedFrame* pDisplayedFrame); 555 VideoFrameBuffer* GetVideoFrameBuffer (void); 556 IfcNvFunctions* GetNvFuncs (void); 557 IfcFfmpegFunctions* GetIfcFfmpegFuncs (void); 558 559 protected: 560 Context& m_context; 561 de::MovePtr<IfcNvFunctions> m_nvFuncs; 562 de::MovePtr<IfcFfmpegFunctions> m_ffmpegFuncs; 563 VkVideoCodecOperationFlagBitsKHR m_videoCodecOperation; 564 const DeviceInterface* m_vkd; 565 VkDevice m_device; 566 deUint32 m_queueFamilyIndexTransfer; 567 deUint32 m_queueFamilyIndexDecode; 568 VkQueue m_queueTransfer; 569 VkQueue m_queueDecode; 570 Allocator* m_allocator; 571 572 // Parser fields 573 int32_t m_nCurrentPictureID; 574 uint32_t m_dpbSlotsMask; 575 uint32_t m_fieldPicFlagMask; 576 DpbSlots m_dpb; 577 int8_t m_pictureToDpbSlotMap[MAX_FRM_CNT]; 578 uint32_t m_maxNumDecodeSurfaces; 579 uint32_t m_maxNumDpbSurfaces; 580 uint64_t m_clockRate; 581 VkDeviceSize m_minBitstreamBufferSizeAlignment; 582 VkDeviceSize m_minBitstreamBufferOffsetAlignment; 583 584 // Client fields 585 Move<VkVideoSessionKHR> m_videoDecodeSession; 586 vector<AllocationPtr> m_videoDecodeSessionAllocs; 587 uint32_t m_numDecodeSurfaces; 588 Move<VkCommandPool> m_videoCommandPool; 589 de::MovePtr<VideoFrameBuffer> m_videoFrameBuffer; 590 NvVkDecodeFrameData* m_decodeFramesData; 591 uint32_t m_maxDecodeFramesCount; 592 uint32_t m_maxDecodeFramesAllocated; 593 // dimension of the output 594 uint32_t m_width; 595 uint32_t m_height; 596 uint32_t m_codedWidth; 597 uint32_t m_codedHeight; 598 // height of the mapped surface 599 VkVideoChromaSubsamplingFlagBitsKHR m_chromaFormat; 600 uint8_t m_bitLumaDepthMinus8; 601 uint8_t m_bitChromaDepthMinus8; 602 int32_t m_decodePicCount; 603 VulkanParserDetectedVideoFormat m_videoFormat; 604 int32_t m_lastSpsIdInQueue; 605 PictureParametersQueue m_pictureParametersQueue; 606 LastSpsPictureParametersQueue m_lastSpsPictureParametersQueue; 607 LastPpsPictureParametersQueue m_lastPpsPictureParametersQueue; 608 CurrentPictureParameters m_currentPictureParameters; 609 610 bool m_randomOrSwapped; 611 bool m_queryResultWithStatus; 612 int32_t m_frameCountTrigger; 613 bool m_submitAfter; 614 uint32_t m_gopSize; 615 uint32_t m_dpbCount; 616 617 vector<HeapType> m_heaps; 618 619 vector<PerFrameDecodeParameters*> m_pPerFrameDecodeParameters; 620 vector<VulkanParserDecodePictureInfo*> m_pVulkanParserDecodePictureInfo; 621 vector<NvVkDecodeFrameData*> m_pFrameDatas; 622 vector<VkBufferMemoryBarrier2KHR> m_bitstreamBufferMemoryBarriers; 623 vector<vector<VkImageMemoryBarrier2KHR>> m_imageBarriersVec; 624 vector<VideoFrameBuffer::FrameSynchronizationInfo> m_frameSynchronizationInfos; 625 vector<VkCommandBufferSubmitInfoKHR> m_commandBufferSubmitInfos; 626 vector<VkVideoBeginCodingInfoKHR> m_decodeBeginInfos; 627 vector<vector<VideoFrameBuffer::PictureResourceInfo>> m_pictureResourcesInfos; 628 vector<VkDependencyInfoKHR> m_dependencyInfos; 629 vector<VkVideoEndCodingInfoKHR> m_decodeEndInfos; 630 vector<VkSubmitInfo2KHR> m_submitInfos; 631 vector<VkFence> m_frameCompleteFences; 632 vector<VkFence> m_frameConsumerDoneFences; 633 vector<VkSemaphoreSubmitInfoKHR> m_frameCompleteSemaphoreSubmitInfos; 634 vector<VkSemaphoreSubmitInfoKHR> m_frameConsumerDoneSemaphoreSubmitInfos; 635 636 NvidiaVulkanParserSequenceInfo m_nvidiaVulkanParserSequenceInfo; 637 bool m_distinctDstDpbImages; 638 }; 639 640 } // video 641 } // vkt 642 643 #endif // _VKTVIDEOBASEDECODEUTILS_HPP 644