#ifndef _VKTVIDEOFRAMEBUFFER_HPP
#define _VKTVIDEOFRAMEBUFFER_HPP
/*------------------------------------------------------------------------
* Vulkan Conformance Tests
* ------------------------
*
* Copyright (c) 2023 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*	  http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Video framebuffer
*//*--------------------------------------------------------------------*/
/*
* Copyright 2020 NVIDIA Corporation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*    http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "deDefs.hpp"
#include "vktVideoTestUtils.hpp"
#include "extNvidiaVideoParserIf.hpp"

namespace vkt
{
namespace video
{

using ImagePtr =de::MovePtr<ImageWithMemory>;

class VkImageResource : public VkVideoRefCountBase
{
public:
	static VkResult Create(DeviceContext&					 vkDevCtx,
						   const VkImageCreateInfo*			 pImageCreateInfo,
						   VkSharedBaseObj<VkImageResource>& imageResource);

	int32_t AddRef() override
	{
		return ++m_refCount;
	}

	int32_t Release() override
	{
		deUint32 ret = --m_refCount;
		// Destroy the device if ref-count reaches zero
		if (ret == 0)
		{
			delete this;
		}
		return ret;
	}

	VkImage GetImage() const
	{
		return m_imageWithMemory->get();
	}

	const VkImageCreateInfo& GetImageCreateInfo() const
	{
		return m_imageCreateInfo;
	}

private:
	std::atomic<int32_t>	m_refCount;
	const VkImageCreateInfo m_imageCreateInfo;
	ImagePtr				m_imageWithMemory;

	VkImageResource(DeviceContext&							 vkDevCtx,
					const VkImageCreateInfo*				 pImageCreateInfo)
		: m_refCount(0), m_imageCreateInfo(*pImageCreateInfo)
	{
		m_imageWithMemory = ImagePtr(new ImageWithMemory(vkDevCtx.getDeviceDriver(), vkDevCtx.device, vkDevCtx.allocator(), *pImageCreateInfo, MemoryRequirement::Local));
	}
};

class VkImageResourceView : public VkVideoRefCountBase
{
public:
	static VkResult Create(DeviceContext&						 vkDevCtx,
						   VkSharedBaseObj<VkImageResource>&	 imageResource,
						   VkImageSubresourceRange&				 imageSubresourceRange,
						   VkSharedBaseObj<VkImageResourceView>& imageResourceView);

	virtual int32_t AddRef()
	{
		return ++m_refCount;
	}

	virtual int32_t Release()
	{
		deUint32 ret = --m_refCount;
		// Destroy the device if ref-count reaches zero
		if (ret == 0)
		{
			delete this;
		}
		return ret;
	}

	operator VkImageView() const
	{
		return m_imageView;
	}
	VkImageView GetImageView() const
	{
		return m_imageView;
	}

	const VkSharedBaseObj<VkImageResource>& GetImageResource()
	{
		return m_imageResource;
	}

private:
	std::atomic<int32_t>			 m_refCount;
	DeviceContext&					 m_vkDevCtx;
	VkSharedBaseObj<VkImageResource> m_imageResource;
	VkImageView						 m_imageView;

	VkImageResourceView(DeviceContext&					  vkDevCtx,
						VkSharedBaseObj<VkImageResource>& imageResource,
						VkImageView						  imageView,
						VkImageSubresourceRange&		  /*imageSubresourceRange*/)
		: m_refCount(0), m_vkDevCtx(vkDevCtx), m_imageResource(imageResource), m_imageView(imageView)
	{
	}

	virtual ~VkImageResourceView();
};

struct DecodedFrame
{
	int32_t								 pictureIndex;
	uint32_t							 imageLayerIndex; // The layer of a multi-layered images. Always "0" for single layered images
	int32_t								 displayWidth;
	int32_t								 displayHeight;
	VkSharedBaseObj<VkImageResourceView> decodedImageView;
	VkSharedBaseObj<VkImageResourceView> outputImageView;
	VkFence								 frameCompleteFence; // If valid, the fence is signaled when the decoder is done decoding the frame.
	VkFence								 frameConsumerDoneFence; // If valid, the fence is signaled when the consumer (graphics, compute or display) is done using the frame.
	VkSemaphore							 frameCompleteSemaphore; // If valid, the semaphore is signaled when the decoder is done decoding the frame.
	VkSemaphore							 frameConsumerDoneSemaphore; // If valid, the semaphore is signaled when the consumer (graphics, compute or display) is done using the frame.
	VkQueryPool							 queryPool; // queryPool handle used for the video queries.
	int32_t								 startQueryId; // query Id used for the this frame.
	deUint32							 numQueries; // usually one query per frame
	// If multiple queues are available, submittedVideoQueueIndex is the queue index that the video frame was submitted to.
	// if only one queue is available, submittedVideoQueueIndex will always have a value of "0".
	int32_t								 submittedVideoQueueIndex;
	uint64_t							 timestamp;
	deUint32							 hasConsummerSignalFence : 1;
	deUint32							 hasConsummerSignalSemaphore : 1;
	// For debugging
	int32_t								 decodeOrder;
	int32_t								 displayOrder;

	void								 Reset()
	{
		pictureIndex				= -1;
		imageLayerIndex				= 0;
		displayWidth				= 0;
		displayHeight				= 0;
		decodedImageView			= nullptr;
		outputImageView				= nullptr;
		frameCompleteFence			= VK_NULL_HANDLE;
		frameConsumerDoneFence		= VK_NULL_HANDLE;
		frameCompleteSemaphore		= VK_NULL_HANDLE;
		frameConsumerDoneSemaphore	= VK_NULL_HANDLE;
		queryPool					= VK_NULL_HANDLE;
		startQueryId				= 0;
		numQueries					= 0;
		submittedVideoQueueIndex	= 0;
		timestamp					= 0;
		hasConsummerSignalFence		= false;
		hasConsummerSignalSemaphore = false;
		// For debugging
		decodeOrder					= 0;
		displayOrder				= 0;
	}
};

struct DecodedFrameRelease
{
	int32_t			 pictureIndex;
	VkVideotimestamp timestamp;
	deUint32		 hasConsummerSignalFence : 1;
	deUint32		 hasConsummerSignalSemaphore : 1;
	// For debugging
	int32_t			 decodeOrder;
	int32_t			 displayOrder;
};

class VulkanVideoFrameBuffer : public IVulkanVideoFrameBufferParserCb
{
public:
	// Synchronization
	struct FrameSynchronizationInfo
	{
		VkFence		frameCompleteFence{VK_NULL_HANDLE};
		VkSemaphore frameCompleteSemaphore{VK_NULL_HANDLE};
		VkFence		frameConsumerDoneFence{VK_NULL_HANDLE};
		VkSemaphore frameConsumerDoneSemaphore{VK_NULL_HANDLE};
		VkQueryPool queryPool{VK_NULL_HANDLE};
		int32_t		startQueryId;
		deUint32	numQueries;
		deUint32	hasFrameCompleteSignalFence : 1;
		deUint32	hasFrameCompleteSignalSemaphore : 1;
	};

	struct ReferencedObjectsInfo
	{

		// The bitstream Buffer
		const VkVideoRefCountBase* pBitstreamData;
		// PPS
		const VkVideoRefCountBase* pStdPps;
		// SPS
		const VkVideoRefCountBase* pStdSps;
		// VPS
		const VkVideoRefCountBase* pStdVps;

		ReferencedObjectsInfo(const VkVideoRefCountBase* pBitstreamDataRef,
							  const VkVideoRefCountBase* pStdPpsRef,
							  const VkVideoRefCountBase* pStdSpsRef,
							  const VkVideoRefCountBase* pStdVpsRef = nullptr)
			: pBitstreamData(pBitstreamDataRef)
			, pStdPps(pStdPpsRef)
			, pStdSps(pStdSpsRef)
			, pStdVps(pStdVpsRef)
		{
		}
	};

	struct PictureResourceInfo
	{
		VkImage		  image;
		VkFormat	  imageFormat;
		VkImageLayout currentImageLayout;
	};

	virtual int32_t InitImagePool(const VkVideoProfileInfoKHR* pDecodeProfile,
								  deUint32					   numImages,
								  VkFormat					   dpbImageFormat,
								  VkFormat					   outImageFormat,
								  const VkExtent2D&			   codedExtent,
								  const VkExtent2D&			   maxImageExtent,
								  VkImageUsageFlags			   dpbImageUsage,
								  VkImageUsageFlags			   outImageUsage,
								  deUint32					   queueFamilyIndex,
								  bool						   useImageArray		  = false,
								  bool						   useImageViewArray	  = false,
								  bool						   useSeparateOutputImage = false,
								  bool						   useLinearOutput		  = false)																																																						= 0;

	virtual int32_t QueuePictureForDecode(int8_t picId, VkParserDecodePictureInfo* pDecodePictureInfo, ReferencedObjectsInfo* pReferencedObjectsInfo, FrameSynchronizationInfo* pFrameSynchronizationInfo)																			= 0;
	virtual int32_t DequeueDecodedPicture(DecodedFrame* pDecodedFrame)																																																				= 0;
	virtual int32_t ReleaseDisplayedPicture(DecodedFrameRelease** pDecodedFramesRelease, deUint32 numFramesToRelease)																																								= 0;
	virtual int32_t GetDpbImageResourcesByIndex(deUint32 numResources, const int8_t* referenceSlotIndexes, VkVideoPictureResourceInfoKHR* pictureResources, PictureResourceInfo* pictureResourcesInfo, VkImageLayout newDpbImageLayerLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR) = 0;
	virtual int32_t GetCurrentImageResourceByIndex(int8_t						  referenceSlotIndex,
												   VkVideoPictureResourceInfoKHR* dpbPictureResource,
												   PictureResourceInfo*			  dpbPictureResourceInfo,
												   VkImageLayout				  newDpbImageLayerLayout	= VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
												   VkVideoPictureResourceInfoKHR* outputPictureResource		= nullptr,
												   PictureResourceInfo*			  outputPictureResourceInfo = nullptr,
												   VkImageLayout				  newOutputImageLayerLayout = VK_IMAGE_LAYOUT_MAX_ENUM)																																								= 0;
	virtual int32_t ReleaseImageResources(deUint32 numResources, const deUint32* indexes)																																															= 0;
	virtual int32_t SetPicNumInDecodeOrder(int32_t picId, int32_t picNumInDecodeOrder)																																																= 0;
	virtual int32_t SetPicNumInDisplayOrder(int32_t picId, int32_t picNumInDisplayOrder)																																															= 0;
	virtual size_t	GetSize()																																																														= 0;
	virtual size_t	GetDisplayedFrameCount() const																																																									= 0;

	virtual ~VulkanVideoFrameBuffer()
	{
	}

	static VkResult Create(DeviceContext*							devCtx,
						   bool										supportsQueries,
						   VkSharedBaseObj<VulkanVideoFrameBuffer>& vkVideoFrameBuffer);
};

} // namespace video
} // namespace vkt

#endif // _VKTVIDEOFRAMEBUFFER_HPP