/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2021 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 Decoding Base Classe Functionality
 *//*--------------------------------------------------------------------*/
 /*
 * 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 "vktVideoBaseDecodeUtils.hpp"

#include "tcuPlatform.hpp"
#include "vkDefs.hpp"
#include "vkQueryUtil.hpp"
#include "vkMemUtil.hpp"
#include "vkStrUtil.hpp"
#include "deRandom.hpp"

#include <iostream>
#include <algorithm>
#include <numeric>
#include <random>

namespace vkt
{
namespace video
{
using namespace vk;
using namespace std;
using de::MovePtr;
using de::SharedPtr;

static const deUint32 topFieldShift		   = 0;
static const deUint32 topFieldMask		   = (1 << topFieldShift);
static const deUint32 bottomFieldShift	   = 1;
static const deUint32 bottomFieldMask	   = (1 << bottomFieldShift);
static const deUint32 fieldIsReferenceMask = (topFieldMask | bottomFieldMask);

#define HEVC_MAX_DPB_SLOTS 16
#define AVC_MAX_DPB_SLOTS 17

inline vkPicBuffBase *GetPic(VkPicIf *pPicBuf)
{
	return (vkPicBuffBase *) pPicBuf;
}

inline VkVideoChromaSubsamplingFlagBitsKHR ConvertStdH264ChromaFormatToVulkan(StdVideoH264ChromaFormatIdc stdFormat)
{
	switch (stdFormat)
	{
		case STD_VIDEO_H264_CHROMA_FORMAT_IDC_420:
			return VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR;
		case STD_VIDEO_H264_CHROMA_FORMAT_IDC_422:
			return VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR;
		case STD_VIDEO_H264_CHROMA_FORMAT_IDC_444:
			return VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR;
		default:
			TCU_THROW(InternalError, "Invalid chroma sub-sampling format");
	}
}

VkFormat codecGetVkFormat(VkVideoChromaSubsamplingFlagBitsKHR chromaFormatIdc,
						  int bitDepthLuma,
						  bool isSemiPlanar)
{
	switch (chromaFormatIdc)
	{
		case VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR:
		{
			switch (bitDepthLuma)
			{
				case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR:
					return VK_FORMAT_R8_UNORM;
				case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR:
					return VK_FORMAT_R10X6_UNORM_PACK16;
				case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR:
					return VK_FORMAT_R12X4_UNORM_PACK16;
				default:
					TCU_THROW(InternalError, "Cannot map monochrome format to VkFormat");
			}
		}
		case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR:
		{
			switch (bitDepthLuma)
			{
				case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G8_B8R8_2PLANE_420_UNORM : VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM);
				case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 : VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16);
				case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 : VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16);
				default:
					TCU_THROW(InternalError, "Cannot map 420 format to VkFormat");
			}
		}
		case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR:
		{
			switch (bitDepthLuma)
			{
				case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G8_B8R8_2PLANE_422_UNORM : VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM);
				case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 : VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16);
				case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 : VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16);
				default:
					TCU_THROW(InternalError, "Cannot map 422 format to VkFormat");
			}
		}
		case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR:
		{
			switch (bitDepthLuma)
			{
				case VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT : VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM);
				case VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT : VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16);
				case VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR:
					return (isSemiPlanar ? VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT : VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16);
				default:
					TCU_THROW(InternalError, "Cannot map 444 format to VkFormat");
			}
		}
		default:
			TCU_THROW(InternalError, "Unknown input idc format");
	}
}

VkVideoComponentBitDepthFlagsKHR getLumaBitDepth(deUint8 lumaBitDepthMinus8)
{
	switch (lumaBitDepthMinus8)
	{
		case 0:
			return VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
		case 2:
			return VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR;
		case 4:
			return VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR;
		default:
			TCU_THROW(InternalError, "Unhandler lumaBitDepthMinus8");
	}
}

VkVideoComponentBitDepthFlagsKHR getChromaBitDepth(deUint8 chromaBitDepthMinus8)
{
	switch (chromaBitDepthMinus8)
	{
		case 0:
			return VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
		case 2:
			return VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR;
		case 4:
			return VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR;
		default:
			TCU_THROW(InternalError, "Unhandler chromaBitDepthMinus8");
	}
}

void setImageLayout(const DeviceInterface &vkd,
					VkCommandBuffer cmdBuffer,
					VkImage image,
					VkImageLayout oldImageLayout,
					VkImageLayout newImageLayout,
					VkPipelineStageFlags2KHR srcStages,
					VkPipelineStageFlags2KHR dstStages,
					VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT)
{
	VkAccessFlags2KHR srcAccessMask = 0;
	VkAccessFlags2KHR dstAccessMask = 0;

	switch (static_cast<VkImageLayout>(oldImageLayout))
	{
		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
			srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
			break;
		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
			srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
			break;
		case VK_IMAGE_LAYOUT_PREINITIALIZED:
			srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
			break;
		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
			srcAccessMask = VK_ACCESS_SHADER_READ_BIT;
			break;
		case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
			srcAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR;
			break;
		default:
			srcAccessMask = 0;
			break;
	}

	switch (static_cast<VkImageLayout>(newImageLayout))
	{
		case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
			dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
			break;
		case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
			dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
			break;
		case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
			dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
			break;
		case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:
			dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
			break;
		case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:
			dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
			break;
		case VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR:
			dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR;
			break;
		case VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR:
			dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR;
			break;
		case VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR:
			dstAccessMask = VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR;
			break;
		case VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR:
			dstAccessMask = VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR | VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR;
			break;
		case VK_IMAGE_LAYOUT_GENERAL:
			dstAccessMask = VK_ACCESS_HOST_WRITE_BIT;
			break;
		default:
			dstAccessMask = 0;
			break;
	}

	const VkImageMemoryBarrier2KHR imageMemoryBarrier =
			{
					VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR,    //  VkStructureType				sType;
					DE_NULL,                                        //  const void*					pNext;
					srcStages,                                        //  VkPipelineStageFlags2KHR	srcStageMask;
					srcAccessMask,                                    //  VkAccessFlags2KHR			srcAccessMask;
					dstStages,                                        //  VkPipelineStageFlags2KHR	dstStageMask;
					dstAccessMask,                                    //  VkAccessFlags2KHR			dstAccessMask;
					oldImageLayout,                                    //  VkImageLayout				oldLayout;
					newImageLayout,                                    //  VkImageLayout				newLayout;
					VK_QUEUE_FAMILY_IGNORED,                        //  deUint32					srcQueueFamilyIndex;
					VK_QUEUE_FAMILY_IGNORED,                        //  deUint32					dstQueueFamilyIndex;
					image,                                            //  VkImage						image;
					{aspectMask, 0, 1, 0, 1},                        //  VkImageSubresourceRange		subresourceRange;
			};

	const VkDependencyInfoKHR dependencyInfo =
			{
					VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR,    //  VkStructureType						sType;
					DE_NULL,                                //  const void*							pNext;
					VK_DEPENDENCY_BY_REGION_BIT,            //  VkDependencyFlags					dependencyFlags;
					0,                                        //  deUint32							memoryBarrierCount;
					DE_NULL,                                //  const VkMemoryBarrier2KHR*			pMemoryBarriers;
					0,                                        //  deUint32							bufferMemoryBarrierCount;
					DE_NULL,                                //  const VkBufferMemoryBarrier2KHR*	pBufferMemoryBarriers;
					1,                                        //  deUint32							imageMemoryBarrierCount;
					&imageMemoryBarrier,                    //  const VkImageMemoryBarrier2KHR*		pImageMemoryBarriers;
			};

	vkd.cmdPipelineBarrier2(cmdBuffer, &dependencyInfo);
}

typedef struct dpbH264Entry {
	int8_t dpbSlot;
	// bit0(used_for_reference)=1: top field used for reference,
	// bit1(used_for_reference)=1: bottom field used for reference
	deUint32 used_for_reference : 2;
	deUint32 is_long_term : 1; // 0 = short-term, 1 = long-term
	deUint32 is_non_existing : 1; // 1 = marked as non-existing
	deUint32 is_field_ref : 1; // set if unpaired field or complementary field pair
	union {
		int16_t FieldOrderCnt[2]; // h.264 : 2*32 [top/bottom].
		int32_t PicOrderCnt; // HEVC PicOrderCnt
	};
	union {
		int16_t FrameIdx; // : 16   short-term: FrameNum (16 bits), long-term:
		// LongTermFrameIdx (4 bits)
		int8_t originalDpbIndex; // Original Dpb source Index.
	};
	vkPicBuffBase* m_picBuff; // internal picture reference

	void setReferenceAndTopBottomField(
			bool isReference, bool nonExisting, bool isLongTerm, bool isFieldRef,
			bool topFieldIsReference, bool bottomFieldIsReference, int16_t frameIdx,
			const int16_t fieldOrderCntList[2], vkPicBuffBase* picBuff)
	{
		is_non_existing = nonExisting;
		is_long_term = isLongTerm;
		is_field_ref = isFieldRef;
		if (isReference && isFieldRef) {
			used_for_reference = (bottomFieldIsReference << bottomFieldShift) | (topFieldIsReference << topFieldShift);
		} else {
			used_for_reference = isReference ? 3 : 0;
		}

		FrameIdx = frameIdx;

		FieldOrderCnt[0] = fieldOrderCntList[used_for_reference == 2]; // 0: for progressive and top reference; 1: for
		// bottom reference only.
		FieldOrderCnt[1] = fieldOrderCntList[used_for_reference != 1]; // 0: for top reference only;  1: for bottom
		// reference and progressive.

		dpbSlot = -1;
		m_picBuff = picBuff;
	}

	void setReference(bool isLongTerm, int32_t picOrderCnt,
					  vkPicBuffBase* picBuff)
	{
		is_non_existing = (picBuff == NULL);
		is_long_term = isLongTerm;
		is_field_ref = false;
		used_for_reference = (picBuff != NULL) ? 3 : 0;

		PicOrderCnt = picOrderCnt;

		dpbSlot = -1;
		m_picBuff = picBuff;
		originalDpbIndex = -1;
	}

	bool isRef() { return (used_for_reference != 0); }

	StdVideoDecodeH264ReferenceInfoFlags getPictureFlag(bool currentPictureIsProgressive)
	{
		StdVideoDecodeH264ReferenceInfoFlags picFlags = StdVideoDecodeH264ReferenceInfoFlags();
		if (videoLoggingEnabled())
			std::cout << "\t\t Flags: ";

		if (used_for_reference) {
			if (videoLoggingEnabled())
				std::cout << "FRAME_IS_REFERENCE ";
			// picFlags.is_reference = true;
		}

		if (is_long_term) {
			if (videoLoggingEnabled())
				std::cout << "IS_LONG_TERM ";
			picFlags.used_for_long_term_reference = true;
		}
		if (is_non_existing) {
			if (videoLoggingEnabled())
				std::cout << "IS_NON_EXISTING ";
			picFlags.is_non_existing = true;
		}

		if (is_field_ref) {
			if (videoLoggingEnabled())
				std::cout << "IS_FIELD ";
			// picFlags.field_pic_flag = true;
		}

		if (!currentPictureIsProgressive && (used_for_reference & topFieldMask)) {
			if (videoLoggingEnabled())
				std::cout << "TOP_FIELD_IS_REF ";
			picFlags.top_field_flag = true;
		}
		if (!currentPictureIsProgressive && (used_for_reference & bottomFieldMask)) {
			if (videoLoggingEnabled())
				std::cout << "BOTTOM_FIELD_IS_REF ";
			picFlags.bottom_field_flag = true;
		}

		return picFlags;
	}

	void setH264PictureData(nvVideoDecodeH264DpbSlotInfo* pDpbRefList,
							VkVideoReferenceSlotInfoKHR* pReferenceSlots,
							deUint32 dpbEntryIdx, deUint32 dpbSlotIndex,
							bool currentPictureIsProgressive)
	{
		DE_ASSERT(dpbEntryIdx < AVC_MAX_DPB_SLOTS);
		DE_ASSERT(dpbSlotIndex < AVC_MAX_DPB_SLOTS);

		DE_ASSERT((dpbSlotIndex == (deUint32)dpbSlot) || is_non_existing);
		pReferenceSlots[dpbEntryIdx].sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR;
		pReferenceSlots[dpbEntryIdx].slotIndex = dpbSlotIndex;
		pReferenceSlots[dpbEntryIdx].pNext = pDpbRefList[dpbEntryIdx].Init(dpbSlotIndex);

		StdVideoDecodeH264ReferenceInfo* pRefPicInfo = &pDpbRefList[dpbEntryIdx].stdReferenceInfo;
		pRefPicInfo->FrameNum = FrameIdx;
		if (videoLoggingEnabled()) {
			std::cout << "\tdpbEntryIdx: " << dpbEntryIdx
					  << "dpbSlotIndex: " << dpbSlotIndex
					  << " FrameIdx: " << (int32_t)FrameIdx;
		}
		pRefPicInfo->flags = getPictureFlag(currentPictureIsProgressive);
		pRefPicInfo->PicOrderCnt[0] = FieldOrderCnt[0];
		pRefPicInfo->PicOrderCnt[1] = FieldOrderCnt[1];
		if (videoLoggingEnabled())
			std::cout << " fieldOrderCnt[0]: " << pRefPicInfo->PicOrderCnt[0]
					  << " fieldOrderCnt[1]: " << pRefPicInfo->PicOrderCnt[1]
					  << std::endl;
	}

	void setH265PictureData(nvVideoDecodeH265DpbSlotInfo* pDpbSlotInfo,
							VkVideoReferenceSlotInfoKHR* pReferenceSlots,
							deUint32 dpbEntryIdx, deUint32 dpbSlotIndex)
	{
		DE_ASSERT(dpbEntryIdx < HEVC_MAX_DPB_SLOTS);
		DE_ASSERT(dpbSlotIndex < HEVC_MAX_DPB_SLOTS);
		DE_ASSERT(isRef());

		DE_ASSERT((dpbSlotIndex == (deUint32)dpbSlot) || is_non_existing);
		pReferenceSlots[dpbEntryIdx].sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR;
		pReferenceSlots[dpbEntryIdx].slotIndex = dpbSlotIndex;
		pReferenceSlots[dpbEntryIdx].pNext = pDpbSlotInfo[dpbEntryIdx].Init(dpbSlotIndex);

		StdVideoDecodeH265ReferenceInfo* pRefPicInfo = &pDpbSlotInfo[dpbEntryIdx].stdReferenceInfo;
		pRefPicInfo->PicOrderCntVal = PicOrderCnt;
		pRefPicInfo->flags.used_for_long_term_reference = is_long_term;

		if (videoLoggingEnabled()) {
			std::cout << "\tdpbIndex: " << dpbSlotIndex
					  << " picOrderCntValList: " << PicOrderCnt;

			std::cout << "\t\t Flags: ";
			std::cout << "FRAME IS REFERENCE ";
			if (pRefPicInfo->flags.used_for_long_term_reference) {
				std::cout << "IS LONG TERM ";
			}
			std::cout << std::endl;
		}
	}

} dpbH264Entry;

int8_t VideoBaseDecoder::GetPicIdx(vkPicBuffBase *pPicBuf)
{
	if (pPicBuf)
	{
		int32_t picIndex = pPicBuf->m_picIdx;

		if ((picIndex >= 0) && ((deUint32) picIndex < m_maxNumDecodeSurfaces))
		{
			return (int8_t) picIndex;
		}
	}

	return -1;
}

int8_t VideoBaseDecoder::GetPicIdx(VkPicIf *pPicBuf)
{
	return GetPicIdx(GetPic(pPicBuf));
}

int8_t VideoBaseDecoder::GetPicDpbSlot(int8_t picIndex)
{
	return m_pictureToDpbSlotMap[picIndex];
}

bool VideoBaseDecoder::GetFieldPicFlag(int8_t picIndex)
{
	DE_ASSERT((picIndex >= 0) && ((deUint32) picIndex < m_maxNumDecodeSurfaces));

	return !!(m_fieldPicFlagMask & (1 << (deUint32) picIndex));
}

bool VideoBaseDecoder::SetFieldPicFlag(int8_t picIndex, bool fieldPicFlag)
{
	DE_ASSERT((picIndex >= 0) && ((deUint32) picIndex < m_maxNumDecodeSurfaces));

	bool oldFieldPicFlag = GetFieldPicFlag(picIndex);

	if (fieldPicFlag)
	{
		m_fieldPicFlagMask |= (1 << (deUint32) picIndex);
	}
	else
	{
		m_fieldPicFlagMask &= ~(1 << (deUint32) picIndex);
	}

	return oldFieldPicFlag;
}

int8_t VideoBaseDecoder::SetPicDpbSlot(int8_t picIndex, int8_t dpbSlot)
{
	int8_t oldDpbSlot = m_pictureToDpbSlotMap[picIndex];

	m_pictureToDpbSlotMap[picIndex] = dpbSlot;

	if (dpbSlot >= 0)
	{
		m_dpbSlotsMask |= (1 << picIndex);
	}
	else
	{
		m_dpbSlotsMask &= ~(1 << picIndex);

		if (oldDpbSlot >= 0)
		{
			m_dpb.FreeSlot(oldDpbSlot);
		}
	}

	return oldDpbSlot;
}

deUint32 VideoBaseDecoder::ResetPicDpbSlots(deUint32 picIndexSlotValidMask)
{
	deUint32 resetSlotsMask = ~(picIndexSlotValidMask | ~m_dpbSlotsMask);

	for (deUint32 picIdx = 0; (picIdx < m_maxNumDecodeSurfaces) && resetSlotsMask; picIdx++)
	{
		if (resetSlotsMask & (1 << picIdx))
		{
			resetSlotsMask &= ~(1 << picIdx);

			SetPicDpbSlot((int8_t) picIdx, -1);
		}
	}

	return m_dpbSlotsMask;
}

VideoBaseDecoder::VideoBaseDecoder(Parameters&& params)
	: m_deviceContext(params.context)
	, m_profile(*params.profile)
	, m_framesToCheck(params.framesToCheck)
	, m_dpb(3)
	, m_videoFrameBuffer(params.framebuffer)
	// TODO: interface cleanup
	, m_decodeFramesData(params.context->getDeviceDriver(), params.context->device, params.context->decodeQueueFamilyIdx())
	, m_resetPictureParametersFrameTriggerHack(params.pictureParameterUpdateTriggerHack)
	, m_queryResultWithStatus(params.queryDecodeStatus)
	, m_outOfOrderDecoding(params.outOfOrderDecoding)
	, m_alwaysRecreateDPB(params.alwaysRecreateDPB)
{
	std::fill(m_pictureToDpbSlotMap.begin(), m_pictureToDpbSlotMap.end(), -1);

	VK_CHECK(util::getVideoDecodeCapabilities(*m_deviceContext, *params.profile, m_videoCaps, m_decodeCaps));

	VK_CHECK(util::getSupportedVideoFormats(*m_deviceContext, m_profile, m_decodeCaps.flags,
											 m_outImageFormat,
											 m_dpbImageFormat));

	m_supportedVideoCodecs = util::getSupportedCodecs(*m_deviceContext,
													  m_deviceContext->decodeQueueFamilyIdx(),
													 VK_QUEUE_VIDEO_DECODE_BIT_KHR,
													  VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR | VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR);
	DE_ASSERT(m_supportedVideoCodecs != VK_VIDEO_CODEC_OPERATION_NONE_KHR);
}

void VideoBaseDecoder::Deinitialize()
{
	const DeviceInterface& vkd			 = m_deviceContext->getDeviceDriver();
	VkDevice			   device		 = m_deviceContext->device;
	VkQueue				   queueDecode	 = m_deviceContext->decodeQueue;
	VkQueue				   queueTransfer = m_deviceContext->transferQueue;

	if (queueDecode)
		vkd.queueWaitIdle(queueDecode);

	if (queueTransfer)
		vkd.queueWaitIdle(queueTransfer);

	vkd.deviceWaitIdle(device);

	m_dpb.Deinit();
	m_videoFrameBuffer = nullptr;
	m_decodeFramesData.deinit();
	m_videoSession = nullptr;
}

int32_t VideoBaseDecoder::StartVideoSequence (const VkParserDetectedVideoFormat* pVideoFormat)
{
	VkExtent2D codedExtent = { pVideoFormat->coded_width, pVideoFormat->coded_height };

	// Width and height of the image surface
	VkExtent2D imageExtent = VkExtent2D { std::max((deUint32)(pVideoFormat->display_area.right  - pVideoFormat->display_area.left), pVideoFormat->coded_width),
										  std::max((deUint32)(pVideoFormat->display_area.bottom - pVideoFormat->display_area.top),  pVideoFormat->coded_height) };

	// REVIEW: There is some inflexibility in the parser regarding this parameter. For the Jellyfish content, it continues wanting to allocate buffers
	// well past what is advertises here. The tangential problem with that content is that the second GOP doesn't start with an IDR frame like all the
	// other test content. Should look more ino this problem, but for now cheese it by always allocating the total number of frames we might need
	// to allocate, even if many of them could be recycled if the parser output pictures earlier (which would be legal but isn't happening for some
	// reason)
	m_numDecodeSurfaces = std::max(4u, m_framesToCheck); // N.B. pVideoFormat->minNumDecodeSurfaces is NOT advertised correctly!
	VkResult result = VK_SUCCESS;

	if (videoLoggingEnabled()) {
		std::cout << "\t" << std::hex << m_supportedVideoCodecs << " HW codec types are available: " << std::dec << std::endl;
	}

	VkVideoCodecOperationFlagBitsKHR detectedVideoCodec = pVideoFormat->codec;

	VkVideoCoreProfile videoProfile(detectedVideoCodec, pVideoFormat->chromaSubsampling, pVideoFormat->lumaBitDepth, pVideoFormat->chromaBitDepth,
									pVideoFormat->codecProfile);
	DE_ASSERT(videoProfile == m_profile);

	// Check the detected profile is the same as the specified test profile.
	DE_ASSERT(m_profile == videoProfile);

	DE_ASSERT(((detectedVideoCodec & m_supportedVideoCodecs) != 0) && (detectedVideoCodec == m_profile.GetCodecType()));

	if (m_videoFormat.coded_width && m_videoFormat.coded_height) {
		// CreateDecoder() has been called before, and now there's possible config change
		m_deviceContext->waitDecodeQueue();
		m_deviceContext->deviceWaitIdle();
	}

	deUint32 maxDpbSlotCount = pVideoFormat->maxNumDpbSlots;

	if (videoLoggingEnabled())
	{
		// TODO: Tidy up all the logging stuff copied from NVIDIA...
		std::cout << std::dec << "Video Input Information" << std::endl
				  << "\tCodec        : " << util::getVideoCodecString(pVideoFormat->codec) << std::endl
				  << "\tFrame rate   : " << pVideoFormat->frame_rate.numerator << "/" << pVideoFormat->frame_rate.denominator << " = " << ((pVideoFormat->frame_rate.denominator != 0) ? (1.0 * pVideoFormat->frame_rate.numerator / pVideoFormat->frame_rate.denominator) : 0.0) << " fps" << std::endl
				  << "\tSequence     : " << (pVideoFormat->progressive_sequence ? "Progressive" : "Interlaced") << std::endl
				  << "\tCoded size   : [" << codedExtent.width << ", " << codedExtent.height << "]" << std::endl
				  << "\tDisplay area : [" << pVideoFormat->display_area.left << ", " << pVideoFormat->display_area.top << ", " << pVideoFormat->display_area.right << ", " << pVideoFormat->display_area.bottom << "]" << std::endl
				  << "\tChroma       : " << util::getVideoChromaFormatString(pVideoFormat->chromaSubsampling) << std::endl
				  << "\tBit depth    : " << pVideoFormat->bit_depth_luma_minus8 + 8 << std::endl
				  << "\tCodec        : " << VkVideoCoreProfile::CodecToName(detectedVideoCodec) << std::endl
				  << "\t#Decode surf : " << m_numDecodeSurfaces << std::endl
				  << "\tCoded extent : " << codedExtent.width << " x " << codedExtent.height << std::endl
				  << "\tMax DPB slots : " << maxDpbSlotCount << std::endl;
	}

	DE_ASSERT(VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR == pVideoFormat->chromaSubsampling ||
		   VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR == pVideoFormat->chromaSubsampling ||
		   VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR == pVideoFormat->chromaSubsampling ||
		   VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR == pVideoFormat->chromaSubsampling);
	DE_ASSERT(pVideoFormat->chromaSubsampling == m_profile.GetColorSubsampling());

	imageExtent.width  = std::max(imageExtent.width, m_videoCaps.minCodedExtent.width);
	imageExtent.height = std::max(imageExtent.height, m_videoCaps.minCodedExtent.height);

	imageExtent.width = deAlign32(imageExtent.width,  m_videoCaps.pictureAccessGranularity.width);
	imageExtent.height = deAlign32(imageExtent.height,  m_videoCaps.pictureAccessGranularity.height);

	if (!m_videoSession ||
		!m_videoSession->IsCompatible(m_deviceContext->device,
									  m_deviceContext->decodeQueueFamilyIdx(),
									  &videoProfile,
									  m_outImageFormat,
									  imageExtent,
									  m_dpbImageFormat,
									  maxDpbSlotCount,
									  maxDpbSlotCount) ||
		m_alwaysRecreateDPB)
	{

		VK_CHECK(VulkanVideoSession::Create(*m_deviceContext,
											m_deviceContext->decodeQueueFamilyIdx(),
											&videoProfile,
											m_outImageFormat,
											imageExtent,
											m_dpbImageFormat,
											maxDpbSlotCount,
											std::min<deUint32>(maxDpbSlotCount, m_videoCaps.maxActiveReferencePictures),
											m_videoSession));

		// after creating a new video session, we need codec reset.
		m_resetDecoder = true;
		DE_ASSERT(result == VK_SUCCESS);
	}

	if (m_currentPictureParameters)
	{
		m_currentPictureParameters->FlushPictureParametersQueue(m_videoSession);
	}

	VkImageUsageFlags outImageUsage = (VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR |
									   VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
									   VK_IMAGE_USAGE_TRANSFER_DST_BIT);
	VkImageUsageFlags dpbImageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;

	if (dpbAndOutputCoincide()) {
		dpbImageUsage = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
	} else {
		// The implementation does not support dpbAndOutputCoincide
		m_useSeparateOutputImages = true;
	}

	if(!(m_videoCaps.flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR)) {
		// The implementation does not support individual images for DPB and so must use arrays
		m_useImageArray = true;
		m_useImageViewArray = true;
	}

	bool useLinearOutput = false;
	int32_t ret = m_videoFrameBuffer->InitImagePool(videoProfile.GetProfile(),
													m_numDecodeSurfaces,
													m_dpbImageFormat,
													m_outImageFormat,
													codedExtent,
													imageExtent,
													dpbImageUsage,
													outImageUsage,
													m_deviceContext->decodeQueueFamilyIdx(),
													m_useImageArray, m_useImageViewArray,
													m_useSeparateOutputImages, useLinearOutput);

	DE_ASSERT((deUint32)ret >= m_numDecodeSurfaces);
	if ((deUint32)ret != m_numDecodeSurfaces) {
		fprintf(stderr, "\nERROR: InitImagePool() ret(%d) != m_numDecodeSurfaces(%d)\n", ret, m_numDecodeSurfaces);
	}

	if (videoLoggingEnabled()) {
		std::cout << "Allocating Video Device Memory" << std::endl
				  << "Allocating " << m_numDecodeSurfaces << " Num Decode Surfaces and "
				  << maxDpbSlotCount << " Video Device Memory Images for DPB " << std::endl
				  << imageExtent.width << " x " << imageExtent.height << std::endl;
	}

	// There will be no more than 32 frames in the queue.
	m_decodeFramesData.resize(m_numDecodeSurfaces);

	int32_t availableBuffers = (int32_t)m_decodeFramesData.GetBitstreamBuffersQueue().GetAvailableNodesNumber();
	if (availableBuffers < m_numBitstreamBuffersToPreallocate) {
		deUint32 allocateNumBuffers = std::min<deUint32>(
				m_decodeFramesData.GetBitstreamBuffersQueue().GetMaxNodes(),
				(m_numBitstreamBuffersToPreallocate - availableBuffers));

		allocateNumBuffers = std::min<deUint32>(allocateNumBuffers,
												m_decodeFramesData.GetBitstreamBuffersQueue().GetFreeNodesNumber());

		for (deUint32 i = 0; i < 1; i++) {

			VkSharedBaseObj<BitstreamBufferImpl> bitstreamBuffer;
			VkDeviceSize allocSize = 2 * 1024 * 1024;

			result = BitstreamBufferImpl::Create(m_deviceContext,
													   m_deviceContext->decodeQueueFamilyIdx(),
													   allocSize,
													   m_videoCaps.minBitstreamBufferOffsetAlignment,
													   m_videoCaps.minBitstreamBufferSizeAlignment,
													   bitstreamBuffer,
													   m_profile.GetProfileListInfo());
			DE_ASSERT(result == VK_SUCCESS);
			if (result != VK_SUCCESS) {
				fprintf(stderr, "\nERROR: CreateVideoBitstreamBuffer() result: 0x%x\n", result);
				break;
			}

			int32_t nodeAddedWithIndex = m_decodeFramesData.GetBitstreamBuffersQueue().
					AddNodeToPool(bitstreamBuffer, false);
			if (nodeAddedWithIndex < 0) {
				DE_ASSERT("Could not add the new node to the pool");
				break;
			}
		}
	}

	// Save the original config
	m_videoFormat = *pVideoFormat;
	return m_numDecodeSurfaces;
}

int32_t VideoBaseDecoder::BeginSequence (const VkParserSequenceInfo* pnvsi)
{
	bool sequenceUpdate = m_nvsi.nMaxWidth != 0 && m_nvsi.nMaxHeight != 0;

	const deUint32 maxDpbSlots =  (pnvsi->eCodec == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) ? VkParserPerFrameDecodeParameters::MAX_DPB_REF_AND_SETUP_SLOTS : VkParserPerFrameDecodeParameters::MAX_DPB_REF_SLOTS;
	deUint32 configDpbSlots = (pnvsi->nMinNumDpbSlots > 0) ? pnvsi->nMinNumDpbSlots : maxDpbSlots;
	configDpbSlots = std::min<deUint32>(configDpbSlots, maxDpbSlots);

	bool sequenceReconfigureFormat = false;
	bool sequenceReconfigureCodedExtent = false;
	if (sequenceUpdate) {
		if ((pnvsi->eCodec != m_nvsi.eCodec) ||
			(pnvsi->nChromaFormat != m_nvsi.nChromaFormat) || (pnvsi->uBitDepthLumaMinus8 != m_nvsi.uBitDepthLumaMinus8) ||
			(pnvsi->uBitDepthChromaMinus8 != m_nvsi.uBitDepthChromaMinus8) ||
			(pnvsi->bProgSeq != m_nvsi.bProgSeq)) {
			sequenceReconfigureFormat = true;
		}

		if ((pnvsi->nCodedWidth != m_nvsi.nCodedWidth) || (pnvsi->nCodedHeight != m_nvsi.nCodedHeight)) {
			sequenceReconfigureCodedExtent = true;
		}

	}

	m_nvsi = *pnvsi;
	m_nvsi.nMaxWidth = pnvsi->nCodedWidth;
	m_nvsi.nMaxHeight = pnvsi->nCodedHeight;

	m_maxNumDecodeSurfaces = pnvsi->nMinNumDecodeSurfaces;

		VkParserDetectedVideoFormat detectedFormat;
		deUint8 raw_seqhdr_data[1024]; /* Output the sequence header data, currently
                                      not used */

		memset(&detectedFormat, 0, sizeof(detectedFormat));

		detectedFormat.sequenceUpdate = sequenceUpdate;
		detectedFormat.sequenceReconfigureFormat = sequenceReconfigureFormat;
		detectedFormat.sequenceReconfigureCodedExtent = sequenceReconfigureCodedExtent;

		detectedFormat.codec = pnvsi->eCodec;
		detectedFormat.frame_rate.numerator = NV_FRAME_RATE_NUM(pnvsi->frameRate);
		detectedFormat.frame_rate.denominator = NV_FRAME_RATE_DEN(pnvsi->frameRate);
		detectedFormat.progressive_sequence = pnvsi->bProgSeq;
		detectedFormat.coded_width = pnvsi->nCodedWidth;
		detectedFormat.coded_height = pnvsi->nCodedHeight;
		detectedFormat.display_area.right = pnvsi->nDisplayWidth;
		detectedFormat.display_area.bottom = pnvsi->nDisplayHeight;

		if ((StdChromaFormatIdc)pnvsi->nChromaFormat == chroma_format_idc_420) {
			detectedFormat.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR;
		} else if ((StdChromaFormatIdc)pnvsi->nChromaFormat == chroma_format_idc_422) {
			detectedFormat.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR;
		} else if ((StdChromaFormatIdc)pnvsi->nChromaFormat == chroma_format_idc_444) {
			detectedFormat.chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR;
		} else {
			DE_ASSERT(!"Invalid chroma sub-sampling format");
		}

		switch (pnvsi->uBitDepthLumaMinus8) {
			case 0:
				detectedFormat.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
				break;
			case 2:
				detectedFormat.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR;
				break;
			case 4:
				detectedFormat.lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR;
				break;
			default:
				DE_ASSERT(false);
		}

		switch (pnvsi->uBitDepthChromaMinus8) {
			case 0:
				detectedFormat.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR;
				break;
			case 2:
				detectedFormat.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR;
				break;
			case 4:
				detectedFormat.chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR;
				break;
			default:
				DE_ASSERT(false);
		}

		detectedFormat.bit_depth_luma_minus8 = pnvsi->uBitDepthLumaMinus8;
		detectedFormat.bit_depth_chroma_minus8 = pnvsi->uBitDepthChromaMinus8;
		detectedFormat.bitrate = pnvsi->lBitrate;
		detectedFormat.display_aspect_ratio.x = pnvsi->lDARWidth;
		detectedFormat.display_aspect_ratio.y = pnvsi->lDARHeight;
		detectedFormat.video_signal_description.video_format = pnvsi->lVideoFormat;
		detectedFormat.video_signal_description.video_full_range_flag = pnvsi->uVideoFullRange;
		detectedFormat.video_signal_description.color_primaries = pnvsi->lColorPrimaries;
		detectedFormat.video_signal_description.transfer_characteristics = pnvsi->lTransferCharacteristics;
		detectedFormat.video_signal_description.matrix_coefficients = pnvsi->lMatrixCoefficients;
		detectedFormat.seqhdr_data_length = (deUint32)std::min((size_t)pnvsi->cbSequenceHeader, sizeof(raw_seqhdr_data));
		detectedFormat.minNumDecodeSurfaces = pnvsi->nMinNumDecodeSurfaces;
		detectedFormat.maxNumDpbSlots = configDpbSlots;
		detectedFormat.codecProfile = pnvsi->codecProfile;

		if (detectedFormat.seqhdr_data_length > 0) {
			memcpy(raw_seqhdr_data, pnvsi->SequenceHeaderData,
				   detectedFormat.seqhdr_data_length);
		}
		int32_t maxDecodeRTs = StartVideoSequence(&detectedFormat);
		// nDecodeRTs <= 0 means SequenceCallback failed
		// nDecodeRTs  = 1 means SequenceCallback succeeded
		// nDecodeRTs  > 1 means we need to overwrite the MaxNumDecodeSurfaces
		if (maxDecodeRTs <= 0) {
			return 0;
		}
		// MaxNumDecodeSurface may not be correctly calculated by the client while
		// parser creation so overwrite it with NumDecodeSurface. (only if nDecodeRT
		// > 1)
		if (maxDecodeRTs > 1) {
			m_maxNumDecodeSurfaces = maxDecodeRTs;
		}

	// Always deinit the DPB between sequences. The optimization path does not work for resolution change cases.
	m_maxNumDpbSlots = m_dpb.Init(configDpbSlots, false /* reconfigure the DPB size if true */);
	// Ensure the picture map is empited, so that DPB slot management doesn't get confused in-between sequences.
	m_pictureToDpbSlotMap.fill(-1);

	return m_maxNumDecodeSurfaces;
}

bool VideoBaseDecoder::AllocPictureBuffer (VkPicIf** ppNvidiaVulkanPicture)
{
	DEBUGLOG(std::cout << "VideoBaseDecoder::AllocPictureBuffer" << std::endl);
	bool result = false;

	*ppNvidiaVulkanPicture = m_videoFrameBuffer->ReservePictureBuffer();

	if (*ppNvidiaVulkanPicture)
	{
		result = true;

		DEBUGLOG(std::cout << "\tVideoBaseDecoder::AllocPictureBuffer " << (void*)*ppNvidiaVulkanPicture << std::endl);
	}

	if (!result)
	{
		*ppNvidiaVulkanPicture = (VkPicIf*)nullptr;
	}

	return result;
}

bool VideoBaseDecoder::DecodePicture (VkParserPictureData* pd)
{
	DEBUGLOG(std::cout << "VideoBaseDecoder::DecodePicture" << std::endl);
	bool							result				= false;

	if (!pd->pCurrPic)
	{
		return result;
	}

	vkPicBuffBase*	pVkPicBuff	= GetPic(pd->pCurrPic);
	const int32_t				picIdx		= pVkPicBuff ? pVkPicBuff->m_picIdx : -1;
	if (videoLoggingEnabled())
		std::cout
            << "\t ==> VulkanVideoParser::DecodePicture " << picIdx << std::endl
            << "\t\t progressive: " << (bool)pd->progressive_frame
            << // Frame is progressive
            "\t\t field: " << (bool)pd->field_pic_flag << std::endl
            << // 0 = frame picture, 1 = field picture
            "\t\t\t bottom_field: " << (bool)pd->bottom_field_flag
            << // 0 = top field, 1 = bottom field (ignored if field_pic_flag=0)
            "\t\t\t second_field: " << (bool)pd->second_field
            << // Second field of a complementary field pair
            "\t\t\t top_field: " << (bool)pd->top_field_first << std::endl
            << // Frame pictures only
            "\t\t repeat_first: " << pd->repeat_first_field
            << // For 3:2 pulldown (number of additional fields, 2 = frame
            // doubling, 4 = frame tripling)
            "\t\t ref_pic: " << (bool)pd->ref_pic_flag
            << std::endl; // Frame is a reference frame

	DE_ASSERT(picIdx < MAX_FRM_CNT);

	VkParserDecodePictureInfo	decodePictureInfo	= VkParserDecodePictureInfo();
	decodePictureInfo.pictureIndex				= picIdx;
	decodePictureInfo.flags.progressiveFrame	= pd->progressive_frame;
	decodePictureInfo.flags.fieldPic			= pd->field_pic_flag;			// 0 = frame picture, 1 = field picture
	decodePictureInfo.flags.repeatFirstField	= pd->repeat_first_field;	// For 3:2 pulldown (number of additional fields, 2 = frame doubling, 4 = frame tripling)
	decodePictureInfo.flags.refPic				= pd->ref_pic_flag;				// Frame is a reference frame

	// Mark the first field as unpaired Detect unpaired fields
	if (pd->field_pic_flag)
	{
		decodePictureInfo.flags.bottomField		= pd->bottom_field_flag;	// 0 = top field, 1 = bottom field (ignored if field_pic_flag=0)
		decodePictureInfo.flags.secondField		= pd->second_field;			// Second field of a complementary field pair
		decodePictureInfo.flags.topFieldFirst	= pd->top_field_first;		// Frame pictures only

		if (!pd->second_field)
		{
			decodePictureInfo.flags.unpairedField = true; // Incomplete (half) frame.
		}
		else
		{
			if (decodePictureInfo.flags.unpairedField)
			{
				decodePictureInfo.flags.syncToFirstField = true;
				decodePictureInfo.flags.unpairedField = false;
			}
		}
	}

	decodePictureInfo.frameSyncinfo.unpairedField		= decodePictureInfo.flags.unpairedField;
	decodePictureInfo.frameSyncinfo.syncToFirstField	= decodePictureInfo.flags.syncToFirstField;

	return DecodePicture(pd, pVkPicBuff, &decodePictureInfo);
}


bool VideoBaseDecoder::DecodePicture (VkParserPictureData* pd,
									  vkPicBuffBase* /*pVkPicBuff*/,
									  VkParserDecodePictureInfo* pDecodePictureInfo)
{
	DEBUGLOG(std::cout << "\tDecodePicture sps_sid:" << (deUint32)pNvidiaVulkanParserPictureData->CodecSpecific.h264.pStdSps->seq_parameter_set_id << " pps_sid:" << (deUint32)pNvidiaVulkanParserPictureData->CodecSpecific.h264.pStdPps->seq_parameter_set_id << " pps_pid:" << (deUint32)pNvidiaVulkanParserPictureData->CodecSpecific.h264.pStdPps->pic_parameter_set_id << std::endl);

	if (!pd->pCurrPic)
	{
		return false;
	}
	const deUint32 PicIdx = GetPicIdx(pd->pCurrPic);
	TCU_CHECK (PicIdx < MAX_FRM_CNT);

	m_cachedDecodeParams.emplace_back(new CachedDecodeParameters);
	auto& cachedParameters = m_cachedDecodeParams.back();
	bool bRet = false;

	if (m_resetDecoder)
	{
		cachedParameters->performCodecReset = true;
		m_resetDecoder = false;
	}
	else
	{
		cachedParameters->performCodecReset = false;
	}

	// Copy the picture data over, taking care to memcpy the heap resources that might get freed on the parser side (we have no guarantees about those pointers)
	cachedParameters->pd = *pd;
	if (pd->sideDataLen > 0)
	{
		cachedParameters->pd.pSideData = new deUint8[pd->sideDataLen];
		deMemcpy(cachedParameters->pd.pSideData, pd->pSideData, pd->sideDataLen);
	}
	// And again for the decoded picture information, these are all POD types for now.
	cachedParameters->decodedPictureInfo = *pDecodePictureInfo;
	pDecodePictureInfo = &cachedParameters->decodedPictureInfo;

	// Now build up the frame's decode parameters and store it in the cache
	cachedParameters->pictureParams = VkParserPerFrameDecodeParameters();
	VkParserPerFrameDecodeParameters* pCurrFrameDecParams = &cachedParameters->pictureParams;
	pCurrFrameDecParams->currPicIdx = PicIdx;
	pCurrFrameDecParams->numSlices = pd->numSlices;
	pCurrFrameDecParams->firstSliceIndex = pd->firstSliceIndex;
	pCurrFrameDecParams->bitstreamDataOffset = pd->bitstreamDataOffset;
	pCurrFrameDecParams->bitstreamDataLen = pd->bitstreamDataLen;
	pCurrFrameDecParams->bitstreamData = pd->bitstreamData;

	auto& referenceSlots = cachedParameters->referenceSlots;
	auto& setupReferenceSlot = cachedParameters->setupReferenceSlot;
	setupReferenceSlot.sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR;
	setupReferenceSlot.pPictureResource = nullptr;
	setupReferenceSlot.slotIndex = -1;

	pCurrFrameDecParams->decodeFrameInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR;
	pCurrFrameDecParams->decodeFrameInfo.dstPictureResource.sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR;
	pCurrFrameDecParams->dpbSetupPictureResource.sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR;

	if (m_profile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR)
	{
		const VkParserH264PictureData* const pin = &pd->CodecSpecific.h264;
		cachedParameters->h264PicParams = nvVideoH264PicParameters();
		VkVideoDecodeH264PictureInfoKHR* h264PictureInfo = &cachedParameters->h264PicParams.pictureInfo;
		nvVideoDecodeH264DpbSlotInfo* h264DpbReferenceList = cachedParameters->h264PicParams.dpbRefList;
		StdVideoDecodeH264PictureInfo* h264StandardPictureInfo = &cachedParameters->h264PicParams.stdPictureInfo;

		pCurrFrameDecParams->pStdPps = pin->pStdPps;
		pCurrFrameDecParams->pStdSps = pin->pStdSps;
		pCurrFrameDecParams->pStdVps = nullptr;

		cachedParameters->decodedPictureInfo.videoFrameType = 0; // pd->CodecSpecific.h264.slice_type;
		// FIXME: If mvcext is enabled.
		cachedParameters->decodedPictureInfo.viewId = pd->CodecSpecific.h264.mvcext.view_id;

		h264PictureInfo->pStdPictureInfo = &cachedParameters->h264PicParams.stdPictureInfo;
		h264PictureInfo->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR;
		h264PictureInfo->pNext = nullptr;
		pCurrFrameDecParams->decodeFrameInfo.pNext = h264PictureInfo;

		h264StandardPictureInfo->pic_parameter_set_id = pin->pic_parameter_set_id; // PPS ID
		h264StandardPictureInfo->seq_parameter_set_id = pin->seq_parameter_set_id; // SPS ID;
		h264StandardPictureInfo->frame_num = (deUint16)pin->frame_num;
		h264PictureInfo->sliceCount = pd->numSlices;

		deUint32 maxSliceCount = 0;
		DE_ASSERT(pd->firstSliceIndex == 0); // No slice and MV modes are supported yet
		h264PictureInfo->pSliceOffsets = pd->bitstreamData->GetStreamMarkersPtr(pd->firstSliceIndex, maxSliceCount);
		DE_ASSERT(maxSliceCount == pd->numSlices);

		StdVideoDecodeH264PictureInfoFlags currPicFlags = StdVideoDecodeH264PictureInfoFlags();
		currPicFlags.is_intra = (pd->intra_pic_flag != 0);
		// 0 = frame picture, 1 = field picture
		if (pd->field_pic_flag) {
			// 0 = top field, 1 = bottom field (ignored if field_pic_flag = 0)
			currPicFlags.field_pic_flag = true;
			if (pd->bottom_field_flag) {
				currPicFlags.bottom_field_flag = true;
			}
		}
		// Second field of a complementary field pair
		if (pd->second_field) {
			currPicFlags.complementary_field_pair = true;
		}
		// Frame is a reference frame
		if (pd->ref_pic_flag) {
			currPicFlags.is_reference = true;
		}
		h264StandardPictureInfo->flags = currPicFlags;
		if (!pd->field_pic_flag) {
			h264StandardPictureInfo->PicOrderCnt[0] = pin->CurrFieldOrderCnt[0];
			h264StandardPictureInfo->PicOrderCnt[1] = pin->CurrFieldOrderCnt[1];
		} else {
			h264StandardPictureInfo->PicOrderCnt[pd->bottom_field_flag] = pin->CurrFieldOrderCnt[pd->bottom_field_flag];
		}

		const deUint32 maxDpbInputSlots = sizeof(pin->dpb) / sizeof(pin->dpb[0]);
		pCurrFrameDecParams->numGopReferenceSlots = FillDpbH264State(
				pd, pin->dpb, maxDpbInputSlots, h264DpbReferenceList,
				VkParserPerFrameDecodeParameters::MAX_DPB_REF_SLOTS, // 16 reference pictures
				referenceSlots, pCurrFrameDecParams->pGopReferenceImagesIndexes,
				h264StandardPictureInfo->flags, &setupReferenceSlot.slotIndex);

		DE_ASSERT(!pd->ref_pic_flag || (setupReferenceSlot.slotIndex >= 0));

		// TODO: Dummy struct to silence validation. The root problem is that the dpb map doesn't take account of the setup slot,
		// for some reason... So we can't use the existing logic to setup the picture flags and frame number from the dpbEntry
		// class.
		cachedParameters->h264SlotInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR;
		cachedParameters->h264SlotInfo.pNext = nullptr;
		cachedParameters->h264SlotInfo.pStdReferenceInfo = &cachedParameters->h264RefInfo;

		if (setupReferenceSlot.slotIndex >= 0) {
			setupReferenceSlot.pPictureResource = &pCurrFrameDecParams->dpbSetupPictureResource;
			setupReferenceSlot.pNext = &cachedParameters->h264SlotInfo;
			pCurrFrameDecParams->decodeFrameInfo.pSetupReferenceSlot = &setupReferenceSlot;
		}
		if (pCurrFrameDecParams->numGopReferenceSlots) {
			DE_ASSERT(pCurrFrameDecParams->numGopReferenceSlots <= (int32_t)VkParserPerFrameDecodeParameters::MAX_DPB_REF_SLOTS);
			for (deUint32 dpbEntryIdx = 0; dpbEntryIdx < (deUint32)pCurrFrameDecParams->numGopReferenceSlots;
				 dpbEntryIdx++) {
				pCurrFrameDecParams->pictureResources[dpbEntryIdx].sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR;
				referenceSlots[dpbEntryIdx].pPictureResource = &pCurrFrameDecParams->pictureResources[dpbEntryIdx];
				DE_ASSERT(h264DpbReferenceList[dpbEntryIdx].IsReference());
			}

			pCurrFrameDecParams->decodeFrameInfo.pReferenceSlots = referenceSlots;
			pCurrFrameDecParams->decodeFrameInfo.referenceSlotCount = pCurrFrameDecParams->numGopReferenceSlots;
		} else {
			pCurrFrameDecParams->decodeFrameInfo.pReferenceSlots = NULL;
			pCurrFrameDecParams->decodeFrameInfo.referenceSlotCount = 0;
		}
	}
	else if (m_profile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR)
	{
		const VkParserHevcPictureData* const pin = &pd->CodecSpecific.hevc;
		cachedParameters->h265PicParams = nvVideoH265PicParameters();
		VkVideoDecodeH265PictureInfoKHR* pPictureInfo = &cachedParameters->h265PicParams.pictureInfo;
		StdVideoDecodeH265PictureInfo* pStdPictureInfo = &cachedParameters->h265PicParams.stdPictureInfo;
		nvVideoDecodeH265DpbSlotInfo* pDpbRefList = cachedParameters->h265PicParams.dpbRefList;

		pCurrFrameDecParams->pStdPps = pin->pStdPps;
		pCurrFrameDecParams->pStdSps = pin->pStdSps;
		pCurrFrameDecParams->pStdVps = pin->pStdVps;
		if (videoLoggingEnabled()) {
			std::cout << "\n\tCurrent h.265 Picture VPS update : "
					  << pin->pStdVps->GetUpdateSequenceCount() << std::endl;
			std::cout << "\n\tCurrent h.265 Picture SPS update : "
					  << pin->pStdSps->GetUpdateSequenceCount() << std::endl;
			std::cout << "\tCurrent h.265 Picture PPS update : "
					  << pin->pStdPps->GetUpdateSequenceCount() << std::endl;
		}

		pPictureInfo->sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR;
		pPictureInfo->pNext = nullptr;

		pPictureInfo->pStdPictureInfo = &cachedParameters->h265PicParams.stdPictureInfo;
		pCurrFrameDecParams->decodeFrameInfo.pNext = &cachedParameters->h265PicParams.pictureInfo;

		pDecodePictureInfo->videoFrameType = 0; // pd->CodecSpecific.hevc.SliceType;
		if (pd->CodecSpecific.hevc.mv_hevc_enable) {
			pDecodePictureInfo->viewId = pd->CodecSpecific.hevc.nuh_layer_id;
		} else {
			pDecodePictureInfo->viewId = 0;
		}

		pPictureInfo->sliceSegmentCount = pd->numSlices;
		deUint32 maxSliceCount = 0;
		DE_ASSERT(pd->firstSliceIndex == 0); // No slice and MV modes are supported yet
		pPictureInfo->pSliceSegmentOffsets = pd->bitstreamData->GetStreamMarkersPtr(pd->firstSliceIndex, maxSliceCount);
		DE_ASSERT(maxSliceCount == pd->numSlices);

		pStdPictureInfo->pps_pic_parameter_set_id   = pin->pic_parameter_set_id;       // PPS ID
		pStdPictureInfo->pps_seq_parameter_set_id   = pin->seq_parameter_set_id;       // SPS ID
		pStdPictureInfo->sps_video_parameter_set_id = pin->vps_video_parameter_set_id; // VPS ID

		// hevc->irapPicFlag = m_slh.nal_unit_type >= NUT_BLA_W_LP &&
		// m_slh.nal_unit_type <= NUT_CRA_NUT;
		pStdPictureInfo->flags.IrapPicFlag = pin->IrapPicFlag; // Intra Random Access Point for current picture.
		// hevc->idrPicFlag = m_slh.nal_unit_type == NUT_IDR_W_RADL ||
		// m_slh.nal_unit_type == NUT_IDR_N_LP;
		pStdPictureInfo->flags.IdrPicFlag = pin->IdrPicFlag; // Instantaneous Decoding Refresh for current picture.

		// NumBitsForShortTermRPSInSlice = s->sh.short_term_rps ?
		// s->sh.short_term_ref_pic_set_size : 0
		pStdPictureInfo->NumBitsForSTRefPicSetInSlice = pin->NumBitsForShortTermRPSInSlice;

		// NumDeltaPocsOfRefRpsIdx = s->sh.short_term_rps ?
		// s->sh.short_term_rps->rps_idx_num_delta_pocs : 0
		pStdPictureInfo->NumDeltaPocsOfRefRpsIdx = pin->NumDeltaPocsOfRefRpsIdx;
		pStdPictureInfo->PicOrderCntVal = pin->CurrPicOrderCntVal;

		if (videoLoggingEnabled())
			std::cout << "\tnumPocStCurrBefore: " << (int32_t)pin->NumPocStCurrBefore
					  << " numPocStCurrAfter: " << (int32_t)pin->NumPocStCurrAfter
					  << " numPocLtCurr: " << (int32_t)pin->NumPocLtCurr << std::endl;

		pCurrFrameDecParams->numGopReferenceSlots = FillDpbH265State(pd, pin, pDpbRefList, pStdPictureInfo,
																	 VkParserPerFrameDecodeParameters::MAX_DPB_REF_SLOTS, // max 16 reference pictures
																	 referenceSlots, pCurrFrameDecParams->pGopReferenceImagesIndexes,
																	 &setupReferenceSlot.slotIndex);

		DE_ASSERT(!pd->ref_pic_flag || (setupReferenceSlot.slotIndex >= 0));
		// TODO: Dummy struct to silence validation. The root problem is that the dpb map doesn't take account of the setup slot,
		// for some reason... So we can't use the existing logic to setup the picture flags and frame number from the dpbEntry
		// class.
		cachedParameters->h265SlotInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR;
		cachedParameters->h265SlotInfo.pNext = nullptr;
		cachedParameters->h265SlotInfo.pStdReferenceInfo = &cachedParameters->h265RefInfo;

		if (setupReferenceSlot.slotIndex >= 0) {
			setupReferenceSlot.pPictureResource = &pCurrFrameDecParams->dpbSetupPictureResource;
			setupReferenceSlot.pNext = &cachedParameters->h265SlotInfo;
			pCurrFrameDecParams->decodeFrameInfo.pSetupReferenceSlot = &setupReferenceSlot;
		}
		if (pCurrFrameDecParams->numGopReferenceSlots) {
			DE_ASSERT(pCurrFrameDecParams->numGopReferenceSlots <= (int32_t)VkParserPerFrameDecodeParameters::MAX_DPB_REF_SLOTS);
			for (deUint32 dpbEntryIdx = 0; dpbEntryIdx < (deUint32)pCurrFrameDecParams->numGopReferenceSlots;
				 dpbEntryIdx++) {
				pCurrFrameDecParams->pictureResources[dpbEntryIdx].sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR;
				referenceSlots[dpbEntryIdx].pPictureResource = &pCurrFrameDecParams->pictureResources[dpbEntryIdx];
				DE_ASSERT(pDpbRefList[dpbEntryIdx].IsReference());
			}

			pCurrFrameDecParams->decodeFrameInfo.pReferenceSlots = referenceSlots;
			pCurrFrameDecParams->decodeFrameInfo.referenceSlotCount = pCurrFrameDecParams->numGopReferenceSlots;
		} else {
			pCurrFrameDecParams->decodeFrameInfo.pReferenceSlots = nullptr;
			pCurrFrameDecParams->decodeFrameInfo.referenceSlotCount = 0;
		}

		if (videoLoggingEnabled()) {
			for (int32_t i = 0; i < HEVC_MAX_DPB_SLOTS; i++) {
				std::cout << "\tdpbIndex: " << i;
				if (pDpbRefList[i]) {
					std::cout << " REFERENCE FRAME";

					std::cout << " picOrderCntValList: "
							  << (int32_t)pDpbRefList[i]
									  .dpbSlotInfo.pStdReferenceInfo->PicOrderCntVal;

					std::cout << "\t\t Flags: ";
					if (pDpbRefList[i]
							.dpbSlotInfo.pStdReferenceInfo->flags.used_for_long_term_reference) {
						std::cout << "IS LONG TERM ";
					}

				} else {
					std::cout << " NOT A REFERENCE ";
				}
				std::cout << std::endl;
			}
		}
	}

	pDecodePictureInfo->displayWidth	= m_nvsi.nDisplayWidth;
	pDecodePictureInfo->displayHeight	= m_nvsi.nDisplayHeight;

	bRet = DecodePictureWithParameters(cachedParameters) >= 0;

	DE_ASSERT(bRet);

	m_nCurrentPictureID++;

	return bRet;
}

int32_t VideoBaseDecoder::DecodePictureWithParameters(MovePtr<CachedDecodeParameters>& cachedParameters)
{
	TCU_CHECK_MSG(m_videoSession, "Video session has not been initialized!");

	auto *pPicParams = &cachedParameters->pictureParams;

	int32_t currPicIdx = pPicParams->currPicIdx;
	DE_ASSERT((deUint32) currPicIdx < m_numDecodeSurfaces);

	cachedParameters->picNumInDecodeOrder = m_decodePicCount++;
	m_videoFrameBuffer->SetPicNumInDecodeOrder(currPicIdx, cachedParameters->picNumInDecodeOrder);

	DE_ASSERT(pPicParams->bitstreamData->GetMaxSize() >= pPicParams->bitstreamDataLen);
	pPicParams->decodeFrameInfo.srcBuffer = pPicParams->bitstreamData->GetBuffer();
	DE_ASSERT(pPicParams->bitstreamDataOffset == 0);
	DE_ASSERT(pPicParams->firstSliceIndex == 0);
	pPicParams->decodeFrameInfo.srcBufferOffset = pPicParams->bitstreamDataOffset;
	pPicParams->decodeFrameInfo.srcBufferRange = deAlign64(pPicParams->bitstreamDataLen, m_videoCaps.minBitstreamBufferSizeAlignment);

	int32_t retPicIdx = GetCurrentFrameData((deUint32) currPicIdx, cachedParameters->frameDataSlot);
	DE_ASSERT(retPicIdx == currPicIdx);

	if (retPicIdx != currPicIdx)
	{
		fprintf(stderr, "\nERROR: DecodePictureWithParameters() retPicIdx(%d) != currPicIdx(%d)\n", retPicIdx, currPicIdx);
	}

	auto &decodeBeginInfo = cachedParameters->decodeBeginInfo;
	decodeBeginInfo.sType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR;
	// CmdResetQueryPool are NOT Supported yet.
	decodeBeginInfo.pNext = pPicParams->beginCodingInfoPictureParametersExt;
	decodeBeginInfo.videoSession = m_videoSession->GetVideoSession();

	cachedParameters->currentPictureParameterObject = m_currentPictureParameters;

	DE_ASSERT(!!pPicParams->decodeFrameInfo.srcBuffer);
	cachedParameters->bitstreamBufferMemoryBarrier = {
			VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR,
			nullptr,
			VK_PIPELINE_STAGE_2_NONE_KHR,
			0, // VK_ACCESS_2_HOST_WRITE_BIT_KHR,
			VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR,
			VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR,
			(deUint32) m_deviceContext->decodeQueueFamilyIdx(),
			(deUint32) m_deviceContext->decodeQueueFamilyIdx(),
			pPicParams->decodeFrameInfo.srcBuffer,
			pPicParams->decodeFrameInfo.srcBufferOffset,
			pPicParams->decodeFrameInfo.srcBufferRange
	};

	deUint32 baseArrayLayer = (m_useImageArray || m_useImageViewArray) ? pPicParams->currPicIdx : 0;
	const VkImageMemoryBarrier2KHR dpbBarrierTemplate = {
			VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR, // VkStructureType sType
			nullptr, // const void*     pNext
			VK_PIPELINE_STAGE_2_NONE_KHR, // VkPipelineStageFlags2KHR srcStageMask
			0, // VkAccessFlags2KHR        srcAccessMask
			VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR, // VkPipelineStageFlags2KHR dstStageMask;
			VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR, // VkAccessFlags   dstAccessMask
			VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout   oldLayout
			VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR, // VkImageLayout   newLayout
			(deUint32) m_deviceContext->decodeQueueFamilyIdx(), // deUint32        srcQueueFamilyIndex
			(deUint32) m_deviceContext->decodeQueueFamilyIdx(), // deUint32   dstQueueFamilyIndex
			VK_NULL_HANDLE, // VkImage         image;
			{
					// VkImageSubresourceRange   subresourceRange
					VK_IMAGE_ASPECT_COLOR_BIT, // VkImageAspectFlags aspectMask
					0, // deUint32           baseMipLevel
					1, // deUint32           levelCount
					baseArrayLayer, // deUint32           baseArrayLayer
					1, // deUint32           layerCount;
			},
	};

	cachedParameters->currentDpbPictureResourceInfo = VulkanVideoFrameBuffer::PictureResourceInfo();
	cachedParameters->currentOutputPictureResourceInfo = VulkanVideoFrameBuffer::PictureResourceInfo();
	deMemset(&cachedParameters->currentOutputPictureResource, 0, sizeof(VkVideoPictureResourceInfoKHR));
	cachedParameters->currentOutputPictureResource.sType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR;

	auto *pOutputPictureResource = cachedParameters->pOutputPictureResource;
	auto *pOutputPictureResourceInfo = cachedParameters->pOutputPictureResourceInfo;
	if (!dpbAndOutputCoincide())
	{
		// Output Distinct will use the decodeFrameInfo.dstPictureResource directly.
		pOutputPictureResource = &pPicParams->decodeFrameInfo.dstPictureResource;
	}
	else if (true) // TODO: Tidying
	{
		// Output Coincide needs the output only if we are processing linear images that we need to copy to below.
		pOutputPictureResource = &cachedParameters->currentOutputPictureResource;
	}

	if (pOutputPictureResource)
	{
		// if the pOutputPictureResource is set then we also need the pOutputPictureResourceInfo.
		pOutputPictureResourceInfo = &cachedParameters->currentOutputPictureResourceInfo;
	}

	if (pPicParams->currPicIdx !=
		m_videoFrameBuffer->GetCurrentImageResourceByIndex(pPicParams->currPicIdx,
														   &pPicParams->dpbSetupPictureResource,
														   &cachedParameters->currentDpbPictureResourceInfo,
														   VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR,
														   pOutputPictureResource,
														   pOutputPictureResourceInfo,
														   VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR))
	{
		DE_ASSERT(!"GetImageResourcesByIndex has failed");
	}

	if (dpbAndOutputCoincide())
	{
		// For the Output Coincide, the DPB and destination output resources are the same.
		pPicParams->decodeFrameInfo.dstPictureResource = pPicParams->dpbSetupPictureResource;

		// Also, when we are copying the output we need to know which layer is used for the current frame.
		// This is if a multi-layered image is used for the DPB and the output (since they coincide).
		cachedParameters->decodedPictureInfo.imageLayerIndex = pPicParams->dpbSetupPictureResource.baseArrayLayer;
	}
	else if (pOutputPictureResourceInfo)
	{
		// For Output Distinct transition the image to DECODE_DST
		if (pOutputPictureResourceInfo->currentImageLayout == VK_IMAGE_LAYOUT_UNDEFINED)
		{
			VkImageMemoryBarrier2KHR barrier = dpbBarrierTemplate;
			barrier.oldLayout = pOutputPictureResourceInfo->currentImageLayout;
			barrier.newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR;
			barrier.image = pOutputPictureResourceInfo->image;
			barrier.dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR;
			cachedParameters->imageBarriers.push_back(barrier);
			DE_ASSERT(!!cachedParameters->imageBarriers.back().image);
		}
	}

	if (cachedParameters->currentDpbPictureResourceInfo.currentImageLayout == VK_IMAGE_LAYOUT_UNDEFINED)
	{
		VkImageMemoryBarrier2KHR barrier = dpbBarrierTemplate;
		barrier.oldLayout = cachedParameters->currentDpbPictureResourceInfo.currentImageLayout;
		barrier.newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR;
		barrier.image = cachedParameters->currentDpbPictureResourceInfo.image;
		barrier.dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR;
		cachedParameters->imageBarriers.push_back(barrier);
		DE_ASSERT(!!cachedParameters->imageBarriers.back().image);
	}

	// Transition all the DPB images to DECODE_DPB layout, if necessary.
	deMemset(cachedParameters->pictureResourcesInfo, 0, DE_LENGTH_OF_ARRAY(cachedParameters->pictureResourcesInfo) * sizeof(cachedParameters->pictureResourcesInfo[0]));
	const int8_t *pGopReferenceImagesIndexes = pPicParams->pGopReferenceImagesIndexes;
	if (pPicParams->numGopReferenceSlots)
	{
		if (pPicParams->numGopReferenceSlots != m_videoFrameBuffer->GetDpbImageResourcesByIndex(
				pPicParams->numGopReferenceSlots,
				pGopReferenceImagesIndexes,
				pPicParams->pictureResources,
				cachedParameters->pictureResourcesInfo,
				VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR))
		{
			DE_ASSERT(!"GetImageResourcesByIndex has failed");
		}
		for (int32_t resId = 0; resId < pPicParams->numGopReferenceSlots; resId++)
		{
			// slotLayer requires NVIDIA specific extension VK_KHR_video_layers, not enabled, just yet.
			// pGopReferenceSlots[resId].slotLayerIndex = 0;
			// pictureResourcesInfo[resId].image can be a nullptr handle if the picture is not-existent.
			if (!!cachedParameters->pictureResourcesInfo[resId].image &&
				(cachedParameters->pictureResourcesInfo[resId].currentImageLayout != VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR) &&
				(cachedParameters->pictureResourcesInfo[resId].currentImageLayout != VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR))
			{
				VkImageMemoryBarrier2KHR barrier = dpbBarrierTemplate;
				barrier.oldLayout = cachedParameters->currentDpbPictureResourceInfo.currentImageLayout;
				barrier.newLayout = VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR;
				barrier.image = cachedParameters->pictureResourcesInfo[resId].image;
				barrier.dstAccessMask = VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR;
				cachedParameters->imageBarriers.push_back(barrier);
				DE_ASSERT(!!cachedParameters->imageBarriers.back().image);
			}
		}
	}

	decodeBeginInfo.referenceSlotCount = pPicParams->decodeFrameInfo.referenceSlotCount;
	decodeBeginInfo.pReferenceSlots = pPicParams->decodeFrameInfo.pReferenceSlots;

	// Ensure the resource for the resources associated with the
	// reference slot (if it exists) are in the bound picture
	// resources set.  See VUID-vkCmdDecodeVideoKHR-pDecodeInfo-07149.
	if (pPicParams->decodeFrameInfo.pSetupReferenceSlot != nullptr)
	{
		cachedParameters->fullReferenceSlots.clear();
		for (deUint32 i = 0; i < decodeBeginInfo.referenceSlotCount; i++)
			cachedParameters->fullReferenceSlots.push_back(decodeBeginInfo.pReferenceSlots[i]);
		VkVideoReferenceSlotInfoKHR setupActivationSlot = {};
		setupActivationSlot.sType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR;
		setupActivationSlot.slotIndex = -1;
		setupActivationSlot.pPictureResource = &pPicParams->dpbSetupPictureResource; //dpbAndOutputCoincide() ? &pPicParams->decodeFrameInfo.dstPictureResource : &pPicParams->pictureResources[pPicParams->numGopReferenceSlots];
		cachedParameters->fullReferenceSlots.push_back(setupActivationSlot);
		decodeBeginInfo.referenceSlotCount++;
		decodeBeginInfo.pReferenceSlots = cachedParameters->fullReferenceSlots.data();
	}

	if (cachedParameters->decodedPictureInfo.flags.unpairedField)
	{
		// DE_ASSERT(pFrameSyncinfo->frameCompleteSemaphore == VK_NULL_HANDLE);
		cachedParameters->decodedPictureInfo.flags.syncFirstReady = true;
	}
	// FIXME: the below sequence for interlaced synchronization.
	cachedParameters->decodedPictureInfo.flags.syncToFirstField = false;

	cachedParameters->frameSynchronizationInfo = VulkanVideoFrameBuffer::FrameSynchronizationInfo();
	cachedParameters->frameSynchronizationInfo.hasFrameCompleteSignalFence = true;
	cachedParameters->frameSynchronizationInfo.hasFrameCompleteSignalSemaphore = true;


	VulkanVideoFrameBuffer::ReferencedObjectsInfo referencedObjectsInfo(pPicParams->bitstreamData,
																		pPicParams->pStdPps,
																		pPicParams->pStdSps,
																		pPicParams->pStdVps);
	int picIdx = m_videoFrameBuffer->QueuePictureForDecode(currPicIdx, &cachedParameters->decodedPictureInfo, &referencedObjectsInfo,
														   &cachedParameters->frameSynchronizationInfo);
	DE_ASSERT(picIdx == currPicIdx);
	DE_UNREF(picIdx);

	if (m_outOfOrderDecoding)
		return currPicIdx;

	WaitForFrameFences(cachedParameters);
	ApplyPictureParameters(cachedParameters);
	RecordCommandBuffer(cachedParameters);
	SubmitQueue(cachedParameters);
	if (m_queryResultWithStatus)
	{
		QueryDecodeResults(cachedParameters);
	}

	return currPicIdx;
}

void VideoBaseDecoder::ApplyPictureParameters(de::MovePtr<CachedDecodeParameters> &cachedParameters)
{
	auto* pPicParams = &cachedParameters->pictureParams;
	VkSharedBaseObj<VkVideoRefCountBase> currentVkPictureParameters;
	bool valid = pPicParams->pStdPps->GetClientObject(currentVkPictureParameters);
	DE_ASSERT(currentVkPictureParameters && valid);
	VkParserVideoPictureParameters *pOwnerPictureParameters =
			VkParserVideoPictureParameters::VideoPictureParametersFromBase(currentVkPictureParameters);
	DE_ASSERT(pOwnerPictureParameters);
	int32_t ret = pOwnerPictureParameters->FlushPictureParametersQueue(m_videoSession);
	DE_ASSERT(ret >= 0);
	DE_UNREF(ret);
	bool isSps = false;
	int32_t spsId = pPicParams->pStdPps->GetSpsId(isSps);
	DE_ASSERT(!isSps);
	DE_ASSERT(spsId >= 0);
	DE_ASSERT(pOwnerPictureParameters->HasSpsId(spsId));
	bool isPps = false;
	int32_t ppsId = pPicParams->pStdPps->GetPpsId(isPps);
	DE_ASSERT(isPps);
	DE_ASSERT(ppsId >= 0);
	DE_ASSERT(pOwnerPictureParameters->HasPpsId(ppsId));
	DE_UNREF(valid);

	cachedParameters->decodeBeginInfo.videoSessionParameters = *pOwnerPictureParameters;

	if (videoLoggingEnabled())
	{
		std::cout << "ApplyPictureParameters object " << cachedParameters->decodeBeginInfo.videoSessionParameters << " with ID: (" << pOwnerPictureParameters->GetId() << ")"
				  << " for SPS: " << spsId << ", PPS: " << ppsId << std::endl;
	}
}

void VideoBaseDecoder::WaitForFrameFences(de::MovePtr<CachedDecodeParameters> &cachedParameters)
{
	// Check here that the frame for this entry (for this command buffer) has already completed decoding.
	// Otherwise we may step over a hot command buffer by starting a new recording.
	// This fence wait should be NOP in 99.9% of the cases, because the decode queue is deep enough to
	// ensure the frame has already been completed.
	VK_CHECK(m_deviceContext->getDeviceDriver().waitForFences(m_deviceContext->device, 1, &cachedParameters->frameSynchronizationInfo.frameCompleteFence, true, TIMEOUT_100ms));
	VkResult result = m_deviceContext->getDeviceDriver().getFenceStatus(m_deviceContext->device, cachedParameters->frameSynchronizationInfo.frameCompleteFence);
	TCU_CHECK_MSG(result == VK_SUCCESS || result == VK_NOT_READY, "Bad fence status");
}

void VideoBaseDecoder::RecordCommandBuffer(de::MovePtr<CachedDecodeParameters> &cachedParameters)
{
	auto &vk = m_deviceContext->getDeviceDriver();

	VkCommandBuffer commandBuffer = cachedParameters->frameDataSlot.commandBuffer;

	VkCommandBufferBeginInfo beginInfo{};
	beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
	beginInfo.pInheritanceInfo = nullptr;

	vk.beginCommandBuffer(commandBuffer, &beginInfo);

	if (m_queryResultWithStatus)
	{
		vk.cmdResetQueryPool(commandBuffer, cachedParameters->frameSynchronizationInfo.queryPool, cachedParameters->frameSynchronizationInfo.startQueryId,
							 cachedParameters->frameSynchronizationInfo.numQueries);
	}

	vk.cmdBeginVideoCodingKHR(commandBuffer, &cachedParameters->decodeBeginInfo);

	if (cachedParameters->performCodecReset)
	{
		VkVideoCodingControlInfoKHR codingControlInfo = {VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
														 nullptr,
														 VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR};
		vk.cmdControlVideoCodingKHR(commandBuffer, &codingControlInfo);
	}

	const VkDependencyInfoKHR dependencyInfo = {
			VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR,
			nullptr,
			VK_DEPENDENCY_BY_REGION_BIT,
			0,
			nullptr,
			1,
			&cachedParameters->bitstreamBufferMemoryBarrier,
			static_cast<deUint32>(cachedParameters->imageBarriers.size()),
			cachedParameters->imageBarriers.data(),
	};
	vk.cmdPipelineBarrier2(commandBuffer, &dependencyInfo);

	if (m_queryResultWithStatus)
	{
		vk.cmdBeginQuery(commandBuffer, cachedParameters->frameSynchronizationInfo.queryPool, cachedParameters->frameSynchronizationInfo.startQueryId, VkQueryControlFlags());
	}

	vk.cmdDecodeVideoKHR(commandBuffer, &cachedParameters->pictureParams.decodeFrameInfo);

	if (m_queryResultWithStatus)
	{
		vk.cmdEndQuery(commandBuffer, cachedParameters->frameSynchronizationInfo.queryPool, cachedParameters->frameSynchronizationInfo.startQueryId);
	}

	VkVideoEndCodingInfoKHR decodeEndInfo{};
	decodeEndInfo.sType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR;
	vk.cmdEndVideoCodingKHR(commandBuffer, &decodeEndInfo);

	m_deviceContext->getDeviceDriver().endCommandBuffer(commandBuffer);
}

void VideoBaseDecoder::SubmitQueue(de::MovePtr<CachedDecodeParameters> &cachedParameters)
{
	auto&			vk								 = m_deviceContext->getDeviceDriver();
	auto			device							 = m_deviceContext->device;
	VkCommandBuffer commandBuffer					 = cachedParameters->frameDataSlot.commandBuffer;
	VkSubmitInfo	submitInfo{};
	submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	submitInfo.waitSemaphoreCount					 = (cachedParameters->frameSynchronizationInfo.frameConsumerDoneSemaphore == VK_NULL_HANDLE) ? 0 : 1;
	submitInfo.pWaitSemaphores						 = &cachedParameters->frameSynchronizationInfo.frameConsumerDoneSemaphore;
	VkPipelineStageFlags videoDecodeSubmitWaitStages = VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR;
	submitInfo.pWaitDstStageMask					 = &videoDecodeSubmitWaitStages;
	submitInfo.commandBufferCount					 = 1;
	submitInfo.pCommandBuffers						 = &commandBuffer;
	submitInfo.signalSemaphoreCount					 = 1;
	submitInfo.pSignalSemaphores					 = &cachedParameters->frameSynchronizationInfo.frameCompleteSemaphore;

	if ((cachedParameters->frameSynchronizationInfo.frameConsumerDoneSemaphore == VK_NULL_HANDLE) &&
		(cachedParameters->frameSynchronizationInfo.frameConsumerDoneFence != VK_NULL_HANDLE))
	{
		VK_CHECK(vk.waitForFences(device, 1, &cachedParameters->frameSynchronizationInfo.frameConsumerDoneFence, true, TIMEOUT_100ms));
		VkResult result = vk.getFenceStatus(device, cachedParameters->frameSynchronizationInfo.frameCompleteFence);
		TCU_CHECK_MSG(result == VK_SUCCESS || result == VK_NOT_READY, "Bad fence status");
	}

	VK_CHECK(vk.resetFences(device, 1, &cachedParameters->frameSynchronizationInfo.frameCompleteFence));
	VkResult result = vk.getFenceStatus(device, cachedParameters->frameSynchronizationInfo.frameCompleteFence);
	TCU_CHECK_MSG(result == VK_SUCCESS || result == VK_NOT_READY, "Bad fence status");

	VK_CHECK(vk.queueSubmit(m_deviceContext->decodeQueue, 1, &submitInfo, cachedParameters->frameSynchronizationInfo.frameCompleteFence));

	if (videoLoggingEnabled())
	{
		std::cout << "\t +++++++++++++++++++++++++++< " << cachedParameters->pictureParams.currPicIdx << " >++++++++++++++++++++++++++++++" << std::endl;
		std::cout << std::dec << "\t => Decode Submitted for CurrPicIdx: " << cachedParameters->pictureParams.currPicIdx << std::endl
				  << "\t\tm_nPicNumInDecodeOrder: " << cachedParameters->picNumInDecodeOrder << "\t\tframeCompleteFence " << cachedParameters->frameSynchronizationInfo.frameCompleteFence
				  << "\t\tframeCompleteSemaphore " << cachedParameters->frameSynchronizationInfo.frameCompleteSemaphore << "\t\tdstImageView "
				  << cachedParameters->pictureParams.decodeFrameInfo.dstPictureResource.imageViewBinding << std::endl;
	}

	const bool checkDecodeIdleSync = false; // For fence/sync/idle debugging
	if (checkDecodeIdleSync)
	{ // For fence/sync debugging
		if (cachedParameters->frameSynchronizationInfo.frameCompleteFence == VK_NULL_HANDLE)
		{
			VK_CHECK(vk.queueWaitIdle(m_deviceContext->decodeQueue));
		}
		else
		{
			if (cachedParameters->frameSynchronizationInfo.frameCompleteSemaphore == VK_NULL_HANDLE)
			{
				VK_CHECK(vk.waitForFences(device, 1, &cachedParameters->frameSynchronizationInfo.frameCompleteFence, true, TIMEOUT_100ms));
				result = vk.getFenceStatus(device, cachedParameters->frameSynchronizationInfo.frameCompleteFence);
				TCU_CHECK_MSG(result == VK_SUCCESS || result == VK_NOT_READY, "Bad fence status");
			}
		}
	}
}

void VideoBaseDecoder::QueryDecodeResults(de::MovePtr<CachedDecodeParameters> &cachedParameters)
{
	auto& vk						   = m_deviceContext->getDeviceDriver();
	auto  device					   = m_deviceContext->device;

	VkQueryResultStatusKHR decodeStatus;
	VkResult result = vk.getQueryPoolResults(device,
											 cachedParameters->frameSynchronizationInfo.queryPool,
											 cachedParameters->frameSynchronizationInfo.startQueryId,
											 1,
											 sizeof(decodeStatus),
											 &decodeStatus,
											 sizeof(decodeStatus),
											 VK_QUERY_RESULT_WITH_STATUS_BIT_KHR | VK_QUERY_RESULT_WAIT_BIT);
	if (videoLoggingEnabled())
	{
		std::cout << "\t +++++++++++++++++++++++++++< " << cachedParameters->pictureParams.currPicIdx << " >++++++++++++++++++++++++++++++" << std::endl;
		std::cout << "\t => Decode Status for CurrPicIdx: " << cachedParameters->pictureParams.currPicIdx << std::endl
				  << "\t\tdecodeStatus: " << decodeStatus << std::endl;
	}

	TCU_CHECK_AND_THROW(TestError, result == VK_SUCCESS || result == VK_ERROR_DEVICE_LOST, "Driver has returned an invalid query result");
	TCU_CHECK_AND_THROW(TestError, decodeStatus != VK_QUERY_RESULT_STATUS_ERROR_KHR, "Decode query returned an unexpected error");
}

void VideoBaseDecoder::decodeFramesOutOfOrder()
{
	std::vector<int> ordering(m_cachedDecodeParams.size());
	std::iota(ordering.begin(), ordering.end(), 0);
	if (ordering.size() == 2)
		std::swap(ordering[0], ordering[1]);
	else // TODO: test seeding
		std::shuffle(ordering.begin(), ordering.end(), std::mt19937{std::random_device{}()});

	DE_ASSERT(m_cachedDecodeParams.size() > 1);

	// Record out of order
	for (int recordOrderIdx : ordering)
	{
		auto &cachedParams = m_cachedDecodeParams[recordOrderIdx];
		WaitForFrameFences(cachedParams);
		ApplyPictureParameters(cachedParams);
		RecordCommandBuffer(cachedParams);
	}

	// Submit in order
	for (int i = 0; i < m_cachedDecodeParams.size(); i++)
	{
		auto& cachedParams = m_cachedDecodeParams[i];
		SubmitQueue(cachedParams);
		if (m_queryResultWithStatus)
		{
			QueryDecodeResults(cachedParams);
		}
	}
}

bool VideoBaseDecoder::UpdatePictureParameters(VkSharedBaseObj<StdVideoPictureParametersSet>& pictureParametersObject, /* in */
											   VkSharedBaseObj<VkVideoRefCountBase>&		  client)
{
	triggerPictureParameterSequenceCount();

	VkResult result = VkParserVideoPictureParameters::AddPictureParameters(*m_deviceContext,
																		   m_videoSession,
																		   pictureParametersObject,
																		   m_currentPictureParameters);
	client			= m_currentPictureParameters;
	return (result == VK_SUCCESS);
}

bool VideoBaseDecoder::DisplayPicture (VkPicIf*	pNvidiaVulkanPicture,
									   int64_t					/*llPTS*/)
{
	vkPicBuffBase* pVkPicBuff = GetPic(pNvidiaVulkanPicture);

	DE_ASSERT(pVkPicBuff != DE_NULL);
	int32_t picIdx = pVkPicBuff ? pVkPicBuff->m_picIdx : -1;
	DE_ASSERT(picIdx != -1);
	DE_ASSERT(m_videoFrameBuffer != nullptr);

	if (videoLoggingEnabled())
	{
		std::cout << "\t ======================< " << picIdx << " >============================" << std::endl;
		std::cout << "\t ==> VulkanVideoParser::DisplayPicture " << picIdx << std::endl;
	}

	VulkanVideoDisplayPictureInfo dispInfo = VulkanVideoDisplayPictureInfo();

	dispInfo.timestamp					   = 0; // NOTE: we ignore PTS in the CTS

	const int32_t retVal				   = m_videoFrameBuffer->QueueDecodedPictureForDisplay((int8_t)picIdx, &dispInfo);
	DE_ASSERT(picIdx == retVal);
	DE_UNREF(retVal);

	return true;
}

int32_t VideoBaseDecoder::ReleaseDisplayedFrame(DecodedFrame* pDisplayedFrame)
{
	if (pDisplayedFrame->pictureIndex == -1)
		return -1;

	DecodedFrameRelease	 decodedFramesRelease		 = {pDisplayedFrame->pictureIndex, 0, 0, 0, 0, 0};
	DecodedFrameRelease* decodedFramesReleasePtr	 = &decodedFramesRelease;
	pDisplayedFrame->pictureIndex					 = -1;
	decodedFramesRelease.decodeOrder				 = pDisplayedFrame->decodeOrder;
	decodedFramesRelease.displayOrder				 = pDisplayedFrame->displayOrder;
	decodedFramesRelease.hasConsummerSignalFence	 = pDisplayedFrame->hasConsummerSignalFence;
	decodedFramesRelease.hasConsummerSignalSemaphore = pDisplayedFrame->hasConsummerSignalSemaphore;
	decodedFramesRelease.timestamp					 = 0;

	return m_videoFrameBuffer->ReleaseDisplayedPicture(&decodedFramesReleasePtr, 1);
}

VkDeviceSize VideoBaseDecoder::GetBitstreamBuffer(VkDeviceSize size, VkDeviceSize minBitstreamBufferOffsetAlignment, VkDeviceSize minBitstreamBufferSizeAlignment, const deUint8* pInitializeBufferMemory, VkDeviceSize initializeBufferMemorySize, VkSharedBaseObj<VulkanBitstreamBuffer>& bitstreamBuffer)
{
	DE_ASSERT(initializeBufferMemorySize <= size);
	VkDeviceSize							newSize = size;
	VkSharedBaseObj<BitstreamBufferImpl>	newBitstreamBuffer;

	VK_CHECK(BitstreamBufferImpl::Create(m_deviceContext,
										 m_deviceContext->decodeQueueFamilyIdx(),
										 newSize,
										 minBitstreamBufferOffsetAlignment,
										 minBitstreamBufferSizeAlignment,
										 newBitstreamBuffer,
										 m_profile.GetProfileListInfo()));
	if (videoLoggingEnabled())
	{
		std::cout << "\tAllocated bitstream buffer with size " << newSize << " B, " << newSize / 1024 << " KB, " << newSize / 1024 / 1024 << " MB" << std::endl;
	}

	DE_ASSERT(newBitstreamBuffer);
	newSize = newBitstreamBuffer->GetMaxSize();
	DE_ASSERT(initializeBufferMemorySize <= newSize);

	size_t bytesToCopy = std::min(initializeBufferMemorySize, newSize);
	size_t bytesCopied = newBitstreamBuffer->CopyDataFromBuffer((const deUint8*)pInitializeBufferMemory, 0, 0, bytesToCopy);
	DE_ASSERT(bytesToCopy == bytesCopied);
	DE_UNREF(bytesCopied);

	newBitstreamBuffer->MemsetData(0x0, bytesToCopy, newSize - bytesToCopy);

	if (videoLoggingEnabled())
	{
		std::cout << "\t\tFrom bitstream buffer pool with size " << newSize << " B, " << newSize / 1024 << " KB, " << newSize / 1024 / 1024 << " MB" << std::endl;

		std::cout << "\t\t\t FreeNodes " << m_decodeFramesData.GetBitstreamBuffersQueue().GetFreeNodesNumber();
		std::cout << " of MaxNodes " << m_decodeFramesData.GetBitstreamBuffersQueue().GetMaxNodes();
		std::cout << ", AvailableNodes " << m_decodeFramesData.GetBitstreamBuffersQueue().GetAvailableNodesNumber();
		std::cout << std::endl;
	}

	bitstreamBuffer = newBitstreamBuffer;
	if (videoLoggingEnabled() && newSize > m_maxStreamBufferSize)
	{
		std::cout << "\tAllocated bitstream buffer with size " << newSize << " B, " << newSize / 1024 << " KB, " << newSize / 1024 / 1024 << " MB" << std::endl;
		m_maxStreamBufferSize = newSize;
	}
	return bitstreamBuffer->GetMaxSize();
}

void VideoBaseDecoder::UnhandledNALU (const deUint8*	pbData,
									  size_t			cbData)
{
	const vector<deUint8> data (pbData, pbData + cbData);
	ostringstream css;

	css << "UnhandledNALU=";

	for (const auto& i: data)
		css << std::hex << std::setw(2) << std::setfill('0') << (deUint32)i << ' ';

	TCU_THROW(InternalError, css.str());
}

deUint32 VideoBaseDecoder::FillDpbH264State (const VkParserPictureData *	pd,
											 const VkParserH264DpbEntry*	dpbIn,
											 deUint32								maxDpbInSlotsInUse,
											 nvVideoDecodeH264DpbSlotInfo*		pDpbRefList,
											 deUint32			/*maxRefPictures*/,
											 VkVideoReferenceSlotInfoKHR*			pReferenceSlots,
											 int8_t*								pGopReferenceImagesIndexes,
											 StdVideoDecodeH264PictureInfoFlags		currPicFlags,
											 int32_t*								pCurrAllocatedSlotIndex)
{
	// #### Update m_dpb based on dpb parameters ####
	// Create unordered DPB and generate a bitmask of all render targets present
	// in DPB
	deUint32 num_ref_frames = pd->CodecSpecific.h264.pStdSps->GetStdH264Sps()->max_num_ref_frames;
	DE_ASSERT(num_ref_frames <= HEVC_MAX_DPB_SLOTS);
	DE_ASSERT(num_ref_frames <= m_maxNumDpbSlots);
	dpbH264Entry refOnlyDpbIn[AVC_MAX_DPB_SLOTS]; // max number of Dpb
	// surfaces
	memset(&refOnlyDpbIn, 0, m_maxNumDpbSlots * sizeof(refOnlyDpbIn[0]));
	deUint32 refDpbUsedAndValidMask = 0;
	deUint32 numUsedRef = 0;
	for (int32_t inIdx = 0; (deUint32)inIdx < maxDpbInSlotsInUse; inIdx++) {
		// used_for_reference: 0 = unused, 1 = top_field, 2 = bottom_field, 3 =
		// both_fields
		const deUint32 used_for_reference = dpbIn[inIdx].used_for_reference & fieldIsReferenceMask;
		if (used_for_reference) {
			int8_t picIdx = (!dpbIn[inIdx].not_existing && dpbIn[inIdx].pPicBuf)
							? GetPicIdx(dpbIn[inIdx].pPicBuf)
							: -1;
			const bool isFieldRef = (picIdx >= 0) ? GetFieldPicFlag(picIdx)
												  : (used_for_reference && (used_for_reference != fieldIsReferenceMask));
			const int16_t fieldOrderCntList[2] = {
					(int16_t)dpbIn[inIdx].FieldOrderCnt[0],
					(int16_t)dpbIn[inIdx].FieldOrderCnt[1]
			};
			refOnlyDpbIn[numUsedRef].setReferenceAndTopBottomField(
					!!used_for_reference,
					(picIdx < 0), /* not_existing is frame inferred by the decoding
                           process for gaps in frame_num */
					!!dpbIn[inIdx].is_long_term, isFieldRef,
					!!(used_for_reference & topFieldMask),
					!!(used_for_reference & bottomFieldMask), dpbIn[inIdx].FrameIdx,
					fieldOrderCntList, GetPic(dpbIn[inIdx].pPicBuf));
			if (picIdx >= 0) {
				refDpbUsedAndValidMask |= (1 << picIdx);
			}
			numUsedRef++;
		}
		// Invalidate all slots.
		pReferenceSlots[inIdx].slotIndex = -1;
		pGopReferenceImagesIndexes[inIdx] = -1;
	}

	DE_ASSERT(numUsedRef <= HEVC_MAX_DPB_SLOTS);
	DE_ASSERT(numUsedRef <= m_maxNumDpbSlots);
	DE_ASSERT(numUsedRef <= num_ref_frames);

	if (videoLoggingEnabled()) {
		std::cout << " =>>> ********************* picIdx: "
				  << (int32_t)GetPicIdx(pd->pCurrPic)
				  << " *************************" << std::endl;
		std::cout << "\tRef frames data in for picIdx: "
				  << (int32_t)GetPicIdx(pd->pCurrPic) << std::endl
				  << "\tSlot Index:\t\t";
		if (numUsedRef == 0)
			std::cout << "(none)" << std::endl;
		else
		{
			for (deUint32 slot = 0; slot < numUsedRef; slot++)
			{
				if (!refOnlyDpbIn[slot].is_non_existing)
				{
					std::cout << slot << ",\t";
				}
				else
				{
					std::cout << 'X' << ",\t";
				}
			}
			std::cout << std::endl;
		}
		std::cout << "\tPict Index:\t\t";
		if (numUsedRef == 0)
			std::cout << "(none)" << std::endl;
		else
		{
			for (deUint32 slot = 0; slot < numUsedRef; slot++)
			{
				if (!refOnlyDpbIn[slot].is_non_existing)
				{
					std::cout << refOnlyDpbIn[slot].m_picBuff->m_picIdx << ",\t";
				}
				else
				{
					std::cout << 'X' << ",\t";
				}
			}
		}
		std::cout << "\n\tTotal Ref frames for picIdx: "
				  << (int32_t)GetPicIdx(pd->pCurrPic) << " : " << numUsedRef
				  << " out of " << num_ref_frames << " MAX(" << m_maxNumDpbSlots
				  << ")" << std::endl
				  << std::endl;

		std::cout << std::flush;
	}

	// Map all frames not present in DPB as non-reference, and generate a mask of
	// all used DPB entries
	/* deUint32 destUsedDpbMask = */ ResetPicDpbSlots(refDpbUsedAndValidMask);

	// Now, map DPB render target indices to internal frame buffer index,
	// assign each reference a unique DPB entry, and create the ordered DPB
	// This is an undocumented MV restriction: the position in the DPB is stored
	// along with the co-located data, so once a reference frame is assigned a DPB
	// entry, it can no longer change.

	// Find or allocate slots for existing dpb items.
	// Take into account the reference picture now.
	int8_t currPicIdx = GetPicIdx(pd->pCurrPic);
	DE_ASSERT(currPicIdx >= 0);
	int8_t bestNonExistingPicIdx = currPicIdx;
	if (refDpbUsedAndValidMask) {
		int32_t minFrameNumDiff = 0x10000;
		for (int32_t dpbIdx = 0; (deUint32)dpbIdx < numUsedRef; dpbIdx++) {
			if (!refOnlyDpbIn[dpbIdx].is_non_existing) {
				vkPicBuffBase* picBuff = refOnlyDpbIn[dpbIdx].m_picBuff;
				int8_t picIdx = GetPicIdx(picBuff); // should always be valid at this point
				DE_ASSERT(picIdx >= 0);
				// We have up to 17 internal frame buffers, but only MAX_DPB_SIZE dpb
				// entries, so we need to re-map the index from the [0..MAX_DPB_SIZE]
				// range to [0..15]
				int8_t dpbSlot = GetPicDpbSlot(picIdx);
				if (dpbSlot < 0) {
					dpbSlot = m_dpb.AllocateSlot();
					DE_ASSERT((dpbSlot >= 0) && ((deUint32)dpbSlot < m_maxNumDpbSlots));
					SetPicDpbSlot(picIdx, dpbSlot);
					m_dpb[dpbSlot].setPictureResource(picBuff, m_nCurrentPictureID);
				}
				m_dpb[dpbSlot].MarkInUse(m_nCurrentPictureID);
				DE_ASSERT(dpbSlot >= 0);

				if (dpbSlot >= 0) {
					refOnlyDpbIn[dpbIdx].dpbSlot = dpbSlot;
				} else {
					// This should never happen
					printf("DPB mapping logic broken!\n");
					DE_ASSERT(0);
				}

				int32_t frameNumDiff = ((int32_t)pd->CodecSpecific.h264.frame_num - refOnlyDpbIn[dpbIdx].FrameIdx);
				if (frameNumDiff <= 0) {
					frameNumDiff = 0xffff;
				}
				if (frameNumDiff < minFrameNumDiff) {
					bestNonExistingPicIdx = picIdx;
					minFrameNumDiff = frameNumDiff;
				} else if (bestNonExistingPicIdx == currPicIdx) {
					bestNonExistingPicIdx = picIdx;
				}
			}
		}
	}
	// In Vulkan, we always allocate a Dbp slot for the current picture,
	// regardless if it is going to become a reference or not. Non-reference slots
	// get freed right after usage. if (pd->ref_pic_flag) {
	int8_t currPicDpbSlot = AllocateDpbSlotForCurrentH264(GetPic(pd->pCurrPic),
														  currPicFlags, pd->current_dpb_id);
	DE_ASSERT(currPicDpbSlot >= 0);
	*pCurrAllocatedSlotIndex = currPicDpbSlot;

	if (refDpbUsedAndValidMask) {
		// Find or allocate slots for non existing dpb items and populate the slots.
		deUint32 dpbInUseMask = m_dpb.getSlotInUseMask();
		int8_t firstNonExistingDpbSlot = 0;
		for (deUint32 dpbIdx = 0; dpbIdx < numUsedRef; dpbIdx++) {
			int8_t dpbSlot = -1;
			int8_t picIdx = -1;
			if (refOnlyDpbIn[dpbIdx].is_non_existing) {
				DE_ASSERT(refOnlyDpbIn[dpbIdx].m_picBuff == NULL);
				while (((deUint32)firstNonExistingDpbSlot < m_maxNumDpbSlots) && (dpbSlot == -1)) {
					if (!(dpbInUseMask & (1 << firstNonExistingDpbSlot))) {
						dpbSlot = firstNonExistingDpbSlot;
					}
					firstNonExistingDpbSlot++;
				}
				DE_ASSERT((dpbSlot >= 0) && ((deUint32)dpbSlot < m_maxNumDpbSlots));
				picIdx = bestNonExistingPicIdx;
				// Find the closest valid refpic already in the DPB
				deUint32 minDiffPOC = 0x7fff;
				for (deUint32 j = 0; j < numUsedRef; j++) {
					if (!refOnlyDpbIn[j].is_non_existing && (refOnlyDpbIn[j].used_for_reference & refOnlyDpbIn[dpbIdx].used_for_reference) == refOnlyDpbIn[dpbIdx].used_for_reference) {
						deUint32 diffPOC = abs((int32_t)(refOnlyDpbIn[j].FieldOrderCnt[0] - refOnlyDpbIn[dpbIdx].FieldOrderCnt[0]));
						if (diffPOC <= minDiffPOC) {
							minDiffPOC = diffPOC;
							picIdx = GetPicIdx(refOnlyDpbIn[j].m_picBuff);
						}
					}
				}
			} else {
				DE_ASSERT(refOnlyDpbIn[dpbIdx].m_picBuff != NULL);
				dpbSlot = refOnlyDpbIn[dpbIdx].dpbSlot;
				picIdx = GetPicIdx(refOnlyDpbIn[dpbIdx].m_picBuff);
			}
			DE_ASSERT((dpbSlot >= 0) && ((deUint32)dpbSlot < m_maxNumDpbSlots));
			refOnlyDpbIn[dpbIdx].setH264PictureData(pDpbRefList, pReferenceSlots,
													dpbIdx, dpbSlot, pd->progressive_frame);
			pGopReferenceImagesIndexes[dpbIdx] = picIdx;
		}
	}

	if (videoLoggingEnabled()) {
		deUint32 slotInUseMask = m_dpb.getSlotInUseMask();
		deUint32 slotsInUseCount = 0;
		std::cout << "\tAllocated DPB slot " << (int32_t)currPicDpbSlot << " for "
				  << (pd->ref_pic_flag ? "REFERENCE" : "NON-REFERENCE")
				  << " picIdx: " << (int32_t)currPicIdx << std::endl;
		std::cout << "\tDPB frames map for picIdx: " << (int32_t)currPicIdx
				  << std::endl
				  << "\tSlot Index:\t\t";
		for (deUint32 slot = 0; slot < m_dpb.getMaxSize(); slot++) {
			if (slotInUseMask & (1 << slot)) {
				std::cout << slot << ",\t";
				slotsInUseCount++;
			} else {
				std::cout << 'X' << ",\t";
			}
		}
		std::cout << std::endl
				  << "\tPict Index:\t\t";
		for (deUint32 slot = 0; slot < m_dpb.getMaxSize(); slot++) {
			if (slotInUseMask & (1 << slot)) {
				if (m_dpb[slot].getPictureResource()) {
					std::cout << m_dpb[slot].getPictureResource()->m_picIdx << ",\t";
				} else {
					std::cout << "non existent"
							  << ",\t";
				}
			} else {
				std::cout << 'X' << ",\t";
			}
		}
		std::cout << "\n\tTotal slots in use for picIdx: " << (int32_t)currPicIdx
				  << " : " << slotsInUseCount << " out of " << m_dpb.getMaxSize()
				  << std::endl;
		std::cout << " <<<= ********************* picIdx: "
				  << (int32_t)GetPicIdx(pd->pCurrPic)
				  << " *************************" << std::endl
				  << std::endl;
		std::cout << std::flush;
	}
	return refDpbUsedAndValidMask ? numUsedRef : 0;}

deUint32 VideoBaseDecoder::FillDpbH265State (const VkParserPictureData* pd,
											 const VkParserHevcPictureData* pin,
											 nvVideoDecodeH265DpbSlotInfo* pDpbSlotInfo,
											 StdVideoDecodeH265PictureInfo* pStdPictureInfo,
											 deUint32 /*maxRefPictures*/,
											 VkVideoReferenceSlotInfoKHR* pReferenceSlots,
											 int8_t* pGopReferenceImagesIndexes,
											 int32_t* pCurrAllocatedSlotIndex)
{
	// #### Update m_dpb based on dpb parameters ####
	// Create unordered DPB and generate a bitmask of all render targets present
	// in DPB
	dpbH264Entry refOnlyDpbIn[HEVC_MAX_DPB_SLOTS];
	DE_ASSERT(m_maxNumDpbSlots <= HEVC_MAX_DPB_SLOTS);
	memset(&refOnlyDpbIn, 0, m_maxNumDpbSlots * sizeof(refOnlyDpbIn[0]));
	deUint32 refDpbUsedAndValidMask = 0;
	deUint32 numUsedRef = 0;
	if (videoLoggingEnabled())
		std::cout << "Ref frames data: " << std::endl;
	for (int32_t inIdx = 0; inIdx < HEVC_MAX_DPB_SLOTS; inIdx++) {
		// used_for_reference: 0 = unused, 1 = top_field, 2 = bottom_field, 3 =
		// both_fields
		int8_t picIdx = GetPicIdx(pin->RefPics[inIdx]);
		if (picIdx >= 0) {
			DE_ASSERT(numUsedRef < HEVC_MAX_DPB_SLOTS);
			refOnlyDpbIn[numUsedRef].setReference((pin->IsLongTerm[inIdx] == 1),
												  pin->PicOrderCntVal[inIdx],
												  GetPic(pin->RefPics[inIdx]));
			if (picIdx >= 0) {
				refDpbUsedAndValidMask |= (1 << picIdx);
			}
			refOnlyDpbIn[numUsedRef].originalDpbIndex = inIdx;
			numUsedRef++;
		}
		// Invalidate all slots.
		pReferenceSlots[inIdx].slotIndex = -1;
		pGopReferenceImagesIndexes[inIdx] = -1;
	}

	if (videoLoggingEnabled())
		std::cout << "Total Ref frames: " << numUsedRef << std::endl;

	DE_ASSERT(numUsedRef <= m_maxNumDpbSlots);
	DE_ASSERT(numUsedRef <= HEVC_MAX_DPB_SLOTS);

	// Take into account the reference picture now.
	int8_t currPicIdx = GetPicIdx(pd->pCurrPic);
	DE_ASSERT(currPicIdx >= 0);
	if (currPicIdx >= 0) {
		refDpbUsedAndValidMask |= (1 << currPicIdx);
	}

	// Map all frames not present in DPB as non-reference, and generate a mask of
	// all used DPB entries
	/* deUint32 destUsedDpbMask = */ ResetPicDpbSlots(refDpbUsedAndValidMask);

	// Now, map DPB render target indices to internal frame buffer index,
	// assign each reference a unique DPB entry, and create the ordered DPB
	// This is an undocumented MV restriction: the position in the DPB is stored
	// along with the co-located data, so once a reference frame is assigned a DPB
	// entry, it can no longer change.

	int8_t frmListToDpb[HEVC_MAX_DPB_SLOTS];
	// TODO change to -1 for invalid indexes.
	memset(&frmListToDpb, 0, sizeof(frmListToDpb));
	// Find or allocate slots for existing dpb items.
	for (int32_t dpbIdx = 0; (deUint32)dpbIdx < numUsedRef; dpbIdx++) {
		if (!refOnlyDpbIn[dpbIdx].is_non_existing) {
			vkPicBuffBase* picBuff = refOnlyDpbIn[dpbIdx].m_picBuff;
			int32_t picIdx = GetPicIdx(picBuff); // should always be valid at this point
			DE_ASSERT(picIdx >= 0);
			// We have up to 17 internal frame buffers, but only HEVC_MAX_DPB_SLOTS
			// dpb entries, so we need to re-map the index from the
			// [0..HEVC_MAX_DPB_SLOTS] range to [0..15]
			int8_t dpbSlot = GetPicDpbSlot(picIdx);
			if (dpbSlot < 0) {
				dpbSlot = m_dpb.AllocateSlot();
				DE_ASSERT(dpbSlot >= 0);
				SetPicDpbSlot(picIdx, dpbSlot);
				m_dpb[dpbSlot].setPictureResource(picBuff, m_nCurrentPictureID);
			}
			m_dpb[dpbSlot].MarkInUse(m_nCurrentPictureID);
			DE_ASSERT(dpbSlot >= 0);

			if (dpbSlot >= 0) {
				refOnlyDpbIn[dpbIdx].dpbSlot = dpbSlot;
				deUint32 originalDpbIndex = refOnlyDpbIn[dpbIdx].originalDpbIndex;
				DE_ASSERT(originalDpbIndex < HEVC_MAX_DPB_SLOTS);
				frmListToDpb[originalDpbIndex] = dpbSlot;
			} else {
				// This should never happen
				printf("DPB mapping logic broken!\n");
				DE_ASSERT(0);
			}
		}
	}

	// Find or allocate slots for non existing dpb items and populate the slots.
	deUint32 dpbInUseMask = m_dpb.getSlotInUseMask();
	int8_t firstNonExistingDpbSlot = 0;
	for (deUint32 dpbIdx = 0; dpbIdx < numUsedRef; dpbIdx++) {
		int8_t dpbSlot = -1;
		if (refOnlyDpbIn[dpbIdx].is_non_existing) {
			// There shouldn't be  not_existing in h.265
			DE_ASSERT(0);
			DE_ASSERT(refOnlyDpbIn[dpbIdx].m_picBuff == NULL);
			while (((deUint32)firstNonExistingDpbSlot < m_maxNumDpbSlots) && (dpbSlot == -1)) {
				if (!(dpbInUseMask & (1 << firstNonExistingDpbSlot))) {
					dpbSlot = firstNonExistingDpbSlot;
				}
				firstNonExistingDpbSlot++;
			}
			DE_ASSERT((dpbSlot >= 0) && ((deUint32)dpbSlot < m_maxNumDpbSlots));
		} else {
			DE_ASSERT(refOnlyDpbIn[dpbIdx].m_picBuff != NULL);
			dpbSlot = refOnlyDpbIn[dpbIdx].dpbSlot;
		}
		DE_ASSERT((dpbSlot >= 0) && (dpbSlot < HEVC_MAX_DPB_SLOTS));
		refOnlyDpbIn[dpbIdx].setH265PictureData(pDpbSlotInfo, pReferenceSlots,
												dpbIdx, dpbSlot);
		pGopReferenceImagesIndexes[dpbIdx] = GetPicIdx(refOnlyDpbIn[dpbIdx].m_picBuff);
	}

	if (videoLoggingEnabled()) {
		std::cout << "frmListToDpb:" << std::endl;
		for (int8_t dpbResIdx = 0; dpbResIdx < HEVC_MAX_DPB_SLOTS; dpbResIdx++) {
			std::cout << "\tfrmListToDpb[" << (int32_t)dpbResIdx << "] is "
					  << (int32_t)frmListToDpb[dpbResIdx] << std::endl;
		}
	}

	int32_t numPocStCurrBefore = 0;
	const size_t maxNumPocStCurrBefore = sizeof(pStdPictureInfo->RefPicSetStCurrBefore) / sizeof(pStdPictureInfo->RefPicSetStCurrBefore[0]);
	DE_ASSERT((size_t)pin->NumPocStCurrBefore <= maxNumPocStCurrBefore);
	if ((size_t)pin->NumPocStCurrBefore > maxNumPocStCurrBefore) {
		tcu::print("\nERROR: FillDpbH265State() pin->NumPocStCurrBefore(%d) must be smaller than maxNumPocStCurrBefore(%zd)\n", pin->NumPocStCurrBefore, maxNumPocStCurrBefore);
	}
	for (int32_t i = 0; i < pin->NumPocStCurrBefore; i++) {
		deUint8 idx = (deUint8)pin->RefPicSetStCurrBefore[i];
		if (idx < HEVC_MAX_DPB_SLOTS) {
			if (videoLoggingEnabled())
				std::cout << "\trefPicSetStCurrBefore[" << i << "] is " << (int32_t)idx
						  << " -> " << (int32_t)frmListToDpb[idx] << std::endl;
			pStdPictureInfo->RefPicSetStCurrBefore[numPocStCurrBefore++] = frmListToDpb[idx] & 0xf;
		}
	}
	while (numPocStCurrBefore < 8) {
		pStdPictureInfo->RefPicSetStCurrBefore[numPocStCurrBefore++] = 0xff;
	}

	int32_t numPocStCurrAfter = 0;
	const size_t maxNumPocStCurrAfter = sizeof(pStdPictureInfo->RefPicSetStCurrAfter) / sizeof(pStdPictureInfo->RefPicSetStCurrAfter[0]);
	DE_ASSERT((size_t)pin->NumPocStCurrAfter <= maxNumPocStCurrAfter);
	if ((size_t)pin->NumPocStCurrAfter > maxNumPocStCurrAfter) {
		fprintf(stderr, "\nERROR: FillDpbH265State() pin->NumPocStCurrAfter(%d) must be smaller than maxNumPocStCurrAfter(%zd)\n", pin->NumPocStCurrAfter, maxNumPocStCurrAfter);
	}
	for (int32_t i = 0; i < pin->NumPocStCurrAfter; i++) {
		deUint8 idx = (deUint8)pin->RefPicSetStCurrAfter[i];
		if (idx < HEVC_MAX_DPB_SLOTS) {
			if (videoLoggingEnabled())
				std::cout << "\trefPicSetStCurrAfter[" << i << "] is " << (int32_t)idx
						  << " -> " << (int32_t)frmListToDpb[idx] << std::endl;
			pStdPictureInfo->RefPicSetStCurrAfter[numPocStCurrAfter++] = frmListToDpb[idx] & 0xf;
		}
	}
	while (numPocStCurrAfter < 8) {
		pStdPictureInfo->RefPicSetStCurrAfter[numPocStCurrAfter++] = 0xff;
	}

	int32_t numPocLtCurr = 0;
	const size_t maxNumPocLtCurr = sizeof(pStdPictureInfo->RefPicSetLtCurr) / sizeof(pStdPictureInfo->RefPicSetLtCurr[0]);
	DE_ASSERT((size_t)pin->NumPocLtCurr <= maxNumPocLtCurr);
	if ((size_t)pin->NumPocLtCurr > maxNumPocLtCurr) {
		fprintf(stderr, "\nERROR: FillDpbH265State() pin->NumPocLtCurr(%d) must be smaller than maxNumPocLtCurr(%zd)\n", pin->NumPocLtCurr, maxNumPocLtCurr);
	}
	for (int32_t i = 0; i < pin->NumPocLtCurr; i++) {
		deUint8 idx = (deUint8)pin->RefPicSetLtCurr[i];
		if (idx < HEVC_MAX_DPB_SLOTS) {
			if (videoLoggingEnabled())
				std::cout << "\trefPicSetLtCurr[" << i << "] is " << (int32_t)idx
						  << " -> " << (int32_t)frmListToDpb[idx] << std::endl;
			pStdPictureInfo->RefPicSetLtCurr[numPocLtCurr++] = frmListToDpb[idx] & 0xf;
		}
	}
	while (numPocLtCurr < 8) {
		pStdPictureInfo->RefPicSetLtCurr[numPocLtCurr++] = 0xff;
	}

	for (int32_t i = 0; i < 8; i++) {
		if (videoLoggingEnabled())
			std::cout << "\tlist indx " << i << ": "
					  << " refPicSetStCurrBefore: "
					  << (int32_t)pStdPictureInfo->RefPicSetStCurrBefore[i]
					  << " refPicSetStCurrAfter: "
					  << (int32_t)pStdPictureInfo->RefPicSetStCurrAfter[i]
					  << " refPicSetLtCurr: "
					  << (int32_t)pStdPictureInfo->RefPicSetLtCurr[i] << std::endl;
	}

	int8_t dpbSlot = AllocateDpbSlotForCurrentH265(GetPic(pd->pCurrPic),
												   true /* isReference */, pd->current_dpb_id);
	*pCurrAllocatedSlotIndex = dpbSlot;
	DE_ASSERT(!(dpbSlot < 0));
	if (dpbSlot >= 0) {
		DE_ASSERT(pd->ref_pic_flag);
	}

	return numUsedRef;
}

int8_t VideoBaseDecoder::AllocateDpbSlotForCurrentH264 (vkPicBuffBase* pPic, StdVideoDecodeH264PictureInfoFlags currPicFlags,
														int8_t /*presetDpbSlot*/)
{
	// Now, map the current render target
	int8_t dpbSlot = -1;
	int8_t currPicIdx = GetPicIdx(pPic);
	DE_ASSERT(currPicIdx >= 0);
	SetFieldPicFlag(currPicIdx, currPicFlags.field_pic_flag);
	// In Vulkan we always allocate reference slot for the current picture.
	if (true /* currPicFlags.is_reference */) {
		dpbSlot = GetPicDpbSlot(currPicIdx);
		if (dpbSlot < 0) {
			dpbSlot = m_dpb.AllocateSlot();
			DE_ASSERT(dpbSlot >= 0);
			SetPicDpbSlot(currPicIdx, dpbSlot);
			m_dpb[dpbSlot].setPictureResource(pPic, m_nCurrentPictureID);
		}
		DE_ASSERT(dpbSlot >= 0);
	}
	return dpbSlot;
}

int8_t VideoBaseDecoder::AllocateDpbSlotForCurrentH265 (vkPicBuffBase* pPic,
														bool isReference, int8_t /*presetDpbSlot*/)
{
	// Now, map the current render target
	int8_t dpbSlot = -1;
	int8_t currPicIdx = GetPicIdx(pPic);
	DE_ASSERT(currPicIdx >= 0);
	DE_ASSERT(isReference);
	if (isReference) {
		dpbSlot = GetPicDpbSlot(currPicIdx);
		if (dpbSlot < 0) {
			dpbSlot = m_dpb.AllocateSlot();
			DE_ASSERT(dpbSlot >= 0);
			SetPicDpbSlot(currPicIdx, dpbSlot);
			m_dpb[dpbSlot].setPictureResource(pPic, m_nCurrentPictureID);
		}
		DE_ASSERT(dpbSlot >= 0);
	}
	return dpbSlot;
}

VkFormat getRecommendedFormat (const vector<VkFormat>& formats, VkFormat recommendedFormat)
{
	if (formats.empty())
		return VK_FORMAT_UNDEFINED;
	else if (recommendedFormat != VK_FORMAT_UNDEFINED && std::find(formats.begin(), formats.end(), recommendedFormat) != formats.end())
		return recommendedFormat;
	else
		return formats[0];
}

VkResult VulkanVideoSession::Create(DeviceContext& vkDevCtx,
								   deUint32            videoQueueFamily,
								   VkVideoCoreProfile* pVideoProfile,
								   VkFormat            pictureFormat,
								   const VkExtent2D&   maxCodedExtent,
								   VkFormat            referencePicturesFormat,
								   deUint32            maxDpbSlots,
								   deUint32            maxActiveReferencePictures,
								   VkSharedBaseObj<VulkanVideoSession>& videoSession)
{
	auto& vk = vkDevCtx.getDeviceDriver();
	auto device = vkDevCtx.device;

	VulkanVideoSession* pNewVideoSession = new VulkanVideoSession(vkDevCtx, pVideoProfile);

	static const VkExtensionProperties h264DecodeStdExtensionVersion = { VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION };
	static const VkExtensionProperties h265DecodeStdExtensionVersion = { VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION };
	static const VkExtensionProperties h264EncodeStdExtensionVersion = { VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION };
	static const VkExtensionProperties h265EncodeStdExtensionVersion = { VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION };

	VkVideoSessionCreateInfoKHR& createInfo = pNewVideoSession->m_createInfo;
	createInfo.flags = 0;
	createInfo.pVideoProfile = pVideoProfile->GetProfile();
	createInfo.queueFamilyIndex = videoQueueFamily;
	createInfo.pictureFormat = pictureFormat;
	createInfo.maxCodedExtent = maxCodedExtent;
	createInfo.maxDpbSlots = maxDpbSlots;
	createInfo.maxActiveReferencePictures = maxActiveReferencePictures;
	createInfo.referencePictureFormat = referencePicturesFormat;

	switch ((int32_t)pVideoProfile->GetCodecType()) {
		case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
			createInfo.pStdHeaderVersion = &h264DecodeStdExtensionVersion;
			break;
		case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
			createInfo.pStdHeaderVersion = &h265DecodeStdExtensionVersion;
			break;
		case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_EXT:
			createInfo.pStdHeaderVersion = &h264EncodeStdExtensionVersion;
			break;
		case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_EXT:
			createInfo.pStdHeaderVersion = &h265EncodeStdExtensionVersion;
			break;
		default:
			DE_ASSERT(0);
	}
	VkResult result = vk.createVideoSessionKHR(device, &createInfo, NULL, &pNewVideoSession->m_videoSession);
	if (result != VK_SUCCESS) {
		return result;
	}

	deUint32 videoSessionMemoryRequirementsCount = 0;
	VkVideoSessionMemoryRequirementsKHR decodeSessionMemoryRequirements[MAX_BOUND_MEMORY];
	// Get the count first
	result = vk.getVideoSessionMemoryRequirementsKHR(device, pNewVideoSession->m_videoSession,
															&videoSessionMemoryRequirementsCount, NULL);
	DE_ASSERT(result == VK_SUCCESS);
	DE_ASSERT(videoSessionMemoryRequirementsCount <= MAX_BOUND_MEMORY);

	memset(decodeSessionMemoryRequirements, 0x00, sizeof(decodeSessionMemoryRequirements));
	for (deUint32 i = 0; i < videoSessionMemoryRequirementsCount; i++) {
		decodeSessionMemoryRequirements[i].sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR;
	}

	result = vk.getVideoSessionMemoryRequirementsKHR(device, pNewVideoSession->m_videoSession,
															&videoSessionMemoryRequirementsCount,
															decodeSessionMemoryRequirements);
	if (result != VK_SUCCESS) {
		return result;
	}

	deUint32 decodeSessionBindMemoryCount = videoSessionMemoryRequirementsCount;
	VkBindVideoSessionMemoryInfoKHR decodeSessionBindMemory[MAX_BOUND_MEMORY];

	for (deUint32 memIdx = 0; memIdx < decodeSessionBindMemoryCount; memIdx++) {

		deUint32 memoryTypeIndex = 0;
		deUint32 memoryTypeBits = decodeSessionMemoryRequirements[memIdx].memoryRequirements.memoryTypeBits;
		if (memoryTypeBits == 0) {
			return VK_ERROR_INITIALIZATION_FAILED;
		}

		// Find an available memory type that satisfies the requested properties.
		for (; !(memoryTypeBits & 1); memoryTypeIndex++  ) {
			memoryTypeBits >>= 1;
		}

		VkMemoryAllocateInfo memInfo = {
				VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,                          // sType
				NULL,                                                            // pNext
				decodeSessionMemoryRequirements[memIdx].memoryRequirements.size, // allocationSize
				memoryTypeIndex,                                                 // memoryTypeIndex
		};

		result = vk.allocateMemory(device, &memInfo, 0,
										  &pNewVideoSession->m_memoryBound[memIdx]);
		if (result != VK_SUCCESS) {
			return result;
		}

		DE_ASSERT(result == VK_SUCCESS);
		decodeSessionBindMemory[memIdx].pNext = NULL;
		decodeSessionBindMemory[memIdx].sType = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR;
		decodeSessionBindMemory[memIdx].memory = pNewVideoSession->m_memoryBound[memIdx];

		decodeSessionBindMemory[memIdx].memoryBindIndex = decodeSessionMemoryRequirements[memIdx].memoryBindIndex;
		decodeSessionBindMemory[memIdx].memoryOffset = 0;
		decodeSessionBindMemory[memIdx].memorySize = decodeSessionMemoryRequirements[memIdx].memoryRequirements.size;
	}

	result = vk.bindVideoSessionMemoryKHR(device, pNewVideoSession->m_videoSession, decodeSessionBindMemoryCount,
												 decodeSessionBindMemory);
	DE_ASSERT(result == VK_SUCCESS);

	videoSession = pNewVideoSession;

	// Make sure we do not use dangling (on the stack) pointers
	createInfo.pNext = nullptr;

	return result;
}






VkResult VkImageResource::Create(DeviceContext&					   vkDevCtx,
								 const VkImageCreateInfo*		   pImageCreateInfo,
								 VkSharedBaseObj<VkImageResource>& imageResource)
{
	imageResource = new VkImageResource(vkDevCtx,
										pImageCreateInfo);

	return VK_SUCCESS;
}

VkResult VkImageResourceView::Create(DeviceContext& vkDevCtx,
									 VkSharedBaseObj<VkImageResource>& imageResource,
									 VkImageSubresourceRange &imageSubresourceRange,
									 VkSharedBaseObj<VkImageResourceView>& imageResourceView)
{
	auto& vk = vkDevCtx.getDeviceDriver();
	VkDevice device = vkDevCtx.device;
	VkImageView  imageView;
	VkImageViewCreateInfo viewInfo = VkImageViewCreateInfo();
	viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
	viewInfo.pNext = nullptr;
	viewInfo.image = imageResource->GetImage();
	viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
	viewInfo.format = imageResource->GetImageCreateInfo().format;
	viewInfo.components = { VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY,
							VK_COMPONENT_SWIZZLE_IDENTITY, VK_COMPONENT_SWIZZLE_IDENTITY};
	viewInfo.subresourceRange = imageSubresourceRange;
	viewInfo.flags = 0;
	VkResult result = vk.createImageView(device, &viewInfo, nullptr, &imageView);
	if (result != VK_SUCCESS) {
		return result;
	}

	imageResourceView = new VkImageResourceView(vkDevCtx, imageResource,
												imageView, imageSubresourceRange);

	return result;
}

VkImageResourceView::~VkImageResourceView()
{
	auto& vk = m_vkDevCtx.getDeviceDriver();
	auto device = m_vkDevCtx.device;

	if (m_imageView != VK_NULL_HANDLE) {
		vk.destroyImageView(device, m_imageView, nullptr);
		m_imageView = VK_NULL_HANDLE;
	}

	m_imageResource = nullptr;
}


const char* VkParserVideoPictureParameters::m_refClassId = "VkParserVideoPictureParameters";
int32_t VkParserVideoPictureParameters::m_currentId = 0;

int32_t VkParserVideoPictureParameters::PopulateH264UpdateFields(const StdVideoPictureParametersSet* pStdPictureParametersSet,
																 VkVideoDecodeH264SessionParametersAddInfoKHR& h264SessionParametersAddInfo)
{
	int32_t currentId = -1;
	if (pStdPictureParametersSet == nullptr) {
		return currentId;
	}

	DE_ASSERT( (pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H264_SPS) ||
			(pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H264_PPS));

	DE_ASSERT(h264SessionParametersAddInfo.sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR);

	if (pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H264_SPS) {
		h264SessionParametersAddInfo.stdSPSCount = 1;
		h264SessionParametersAddInfo.pStdSPSs = pStdPictureParametersSet->GetStdH264Sps();
		bool isSps = false;
		currentId = pStdPictureParametersSet->GetSpsId(isSps);
		DE_ASSERT(isSps);
	} else if (pStdPictureParametersSet->GetStdType() ==  StdVideoPictureParametersSet::TYPE_H264_PPS ) {
		h264SessionParametersAddInfo.stdPPSCount = 1;
		h264SessionParametersAddInfo.pStdPPSs = pStdPictureParametersSet->GetStdH264Pps();
		bool isPps = false;
		currentId = pStdPictureParametersSet->GetPpsId(isPps);
		DE_ASSERT(isPps);
	} else {
		DE_ASSERT(!"Incorrect h.264 type");
	}

	return currentId;
}

int32_t VkParserVideoPictureParameters::PopulateH265UpdateFields(const StdVideoPictureParametersSet* pStdPictureParametersSet,
																 VkVideoDecodeH265SessionParametersAddInfoKHR& h265SessionParametersAddInfo)
{
	int32_t currentId = -1;
	if (pStdPictureParametersSet == nullptr) {
		return currentId;
	}

	DE_ASSERT( (pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H265_VPS) ||
			(pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H265_SPS) ||
			(pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H265_PPS));

	DE_ASSERT(h265SessionParametersAddInfo.sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR);

	if (pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H265_VPS) {
		h265SessionParametersAddInfo.stdVPSCount = 1;
		h265SessionParametersAddInfo.pStdVPSs = pStdPictureParametersSet->GetStdH265Vps();
		bool isVps = false;
		currentId = pStdPictureParametersSet->GetVpsId(isVps);
		DE_ASSERT(isVps);
	} else if (pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H265_SPS) {
		h265SessionParametersAddInfo.stdSPSCount = 1;
		h265SessionParametersAddInfo.pStdSPSs = pStdPictureParametersSet->GetStdH265Sps();
		bool isSps = false;
		currentId = pStdPictureParametersSet->GetSpsId(isSps);
		DE_ASSERT(isSps);
	} else if (pStdPictureParametersSet->GetStdType() == StdVideoPictureParametersSet::TYPE_H265_PPS) {
		h265SessionParametersAddInfo.stdPPSCount = 1;
		h265SessionParametersAddInfo.pStdPPSs = pStdPictureParametersSet->GetStdH265Pps();
		bool isPps = false;
		currentId = pStdPictureParametersSet->GetPpsId(isPps);
		DE_ASSERT(isPps);
	} else {
		DE_ASSERT(!"Incorrect h.265 type");
	}

	return currentId;
}

VkResult
VkParserVideoPictureParameters::Create(DeviceContext& deviceContext,
									   VkSharedBaseObj<VkParserVideoPictureParameters>& templatePictureParameters,
									   VkSharedBaseObj<VkParserVideoPictureParameters>& videoPictureParameters)
{
	VkSharedBaseObj<VkParserVideoPictureParameters> newVideoPictureParameters(
			new VkParserVideoPictureParameters(deviceContext, templatePictureParameters));
	if (!newVideoPictureParameters) {
		return VK_ERROR_OUT_OF_HOST_MEMORY;
	}

	videoPictureParameters = newVideoPictureParameters;
	return VK_SUCCESS;
}

VkResult VkParserVideoPictureParameters::CreateParametersObject(VkSharedBaseObj<VulkanVideoSession>& videoSession,
																const StdVideoPictureParametersSet* pStdVideoPictureParametersSet,
																VkParserVideoPictureParameters* pTemplatePictureParameters)
{
	int32_t currentId = -1;

	VkVideoSessionParametersCreateInfoKHR createInfo{};
	createInfo.sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR;

	VkVideoDecodeH264SessionParametersCreateInfoKHR h264SessionParametersCreateInfo{};
	h264SessionParametersCreateInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR;
	VkVideoDecodeH264SessionParametersAddInfoKHR h264SessionParametersAddInfo{};
	h264SessionParametersAddInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR;

	VkVideoDecodeH265SessionParametersCreateInfoKHR h265SessionParametersCreateInfo{};
	h265SessionParametersCreateInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR;
	VkVideoDecodeH265SessionParametersAddInfoKHR h265SessionParametersAddInfo{};
	h265SessionParametersAddInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;

	StdVideoPictureParametersSet::StdType updateType = pStdVideoPictureParametersSet->GetStdType();
	switch (updateType)
	{
		case StdVideoPictureParametersSet::TYPE_H264_SPS:
		case StdVideoPictureParametersSet::TYPE_H264_PPS:
		{
			createInfo.pNext =  &h264SessionParametersCreateInfo;
			h264SessionParametersCreateInfo.maxStdSPSCount = MAX_SPS_IDS;
			h264SessionParametersCreateInfo.maxStdPPSCount = MAX_PPS_IDS;
			h264SessionParametersCreateInfo.pParametersAddInfo = &h264SessionParametersAddInfo;

			currentId = PopulateH264UpdateFields(pStdVideoPictureParametersSet, h264SessionParametersAddInfo);

		}
			break;
		case StdVideoPictureParametersSet::TYPE_H265_VPS:
		case StdVideoPictureParametersSet::TYPE_H265_SPS:
		case StdVideoPictureParametersSet::TYPE_H265_PPS:
		{
			createInfo.pNext =  &h265SessionParametersCreateInfo;
			h265SessionParametersCreateInfo.maxStdVPSCount = MAX_VPS_IDS;
			h265SessionParametersCreateInfo.maxStdSPSCount = MAX_SPS_IDS;
			h265SessionParametersCreateInfo.maxStdPPSCount = MAX_PPS_IDS;
			h265SessionParametersCreateInfo.pParametersAddInfo = &h265SessionParametersAddInfo;

			currentId = PopulateH265UpdateFields(pStdVideoPictureParametersSet, h265SessionParametersAddInfo);
		}
			break;
		default:
			DE_ASSERT(!"Invalid Parser format");
			return VK_ERROR_INITIALIZATION_FAILED;
	}

	createInfo.videoSessionParametersTemplate = pTemplatePictureParameters ? VkVideoSessionParametersKHR(*pTemplatePictureParameters) : VK_NULL_HANDLE;
	createInfo.videoSession = videoSession->GetVideoSession();
	VkResult result = m_deviceContext.getDeviceDriver().createVideoSessionParametersKHR(m_deviceContext.device,
																&createInfo,
																nullptr,
																&m_sessionParameters);

	if (result != VK_SUCCESS) {

		DE_ASSERT(!"Could not create Session Parameters Object");
		return result;

	} else {

		m_videoSession = videoSession;

		if (pTemplatePictureParameters) {
			m_vpsIdsUsed = pTemplatePictureParameters->m_vpsIdsUsed;
			m_spsIdsUsed = pTemplatePictureParameters->m_spsIdsUsed;
			m_ppsIdsUsed = pTemplatePictureParameters->m_ppsIdsUsed;
		}

		assert (currentId >= 0);
		switch (pStdVideoPictureParametersSet->GetParameterType()) {
			case StdVideoPictureParametersSet::PPS_TYPE:
				m_ppsIdsUsed.set(currentId, true);
				break;

			case StdVideoPictureParametersSet::SPS_TYPE:
				m_spsIdsUsed.set(currentId, true);
				break;

			case StdVideoPictureParametersSet::VPS_TYPE:
				m_vpsIdsUsed.set(currentId, true);
				break;
			default:
				DE_ASSERT(!"Invalid StdVideoPictureParametersSet Parameter Type!");
		}
		m_Id = ++m_currentId;
	}

	return result;
}

VkResult VkParserVideoPictureParameters::UpdateParametersObject(StdVideoPictureParametersSet* pStdVideoPictureParametersSet)
{
	if (pStdVideoPictureParametersSet == nullptr) {
		return VK_SUCCESS;
	}

	int32_t currentId = -1;
	VkVideoSessionParametersUpdateInfoKHR updateInfo{};
	updateInfo.sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR;
	VkVideoDecodeH264SessionParametersAddInfoKHR h264SessionParametersAddInfo{};
	h264SessionParametersAddInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR;
	VkVideoDecodeH265SessionParametersAddInfoKHR h265SessionParametersAddInfo{};
	h265SessionParametersAddInfo.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR;

	StdVideoPictureParametersSet::StdType updateType = pStdVideoPictureParametersSet->GetStdType();
	switch (updateType)
	{
		case StdVideoPictureParametersSet::TYPE_H264_SPS:
		case StdVideoPictureParametersSet::TYPE_H264_PPS:
		{
			updateInfo.pNext = &h264SessionParametersAddInfo;
			currentId = PopulateH264UpdateFields(pStdVideoPictureParametersSet, h264SessionParametersAddInfo);
		}
			break;
		case StdVideoPictureParametersSet::TYPE_H265_VPS:
		case StdVideoPictureParametersSet::TYPE_H265_SPS:
		case StdVideoPictureParametersSet::TYPE_H265_PPS:
		{
			updateInfo.pNext = &h265SessionParametersAddInfo;
			currentId = PopulateH265UpdateFields(pStdVideoPictureParametersSet, h265SessionParametersAddInfo);
		}
			break;
		default:
			DE_ASSERT(!"Invalid Parser format");
			return VK_ERROR_INITIALIZATION_FAILED;
	}

	updateInfo.updateSequenceCount = ++m_updateCount;
	VK_CHECK(m_deviceContext.getDeviceDriver().updateVideoSessionParametersKHR(m_deviceContext.device,
																			   m_sessionParameters,
																			   &updateInfo));


	DE_ASSERT(currentId >= 0);
	switch (pStdVideoPictureParametersSet->GetParameterType()) {
		case StdVideoPictureParametersSet::PPS_TYPE:
			m_ppsIdsUsed.set(currentId, true);
			break;

		case StdVideoPictureParametersSet::SPS_TYPE:
			m_spsIdsUsed.set(currentId, true);
			break;

		case StdVideoPictureParametersSet::VPS_TYPE:
			m_vpsIdsUsed.set(currentId, true);
			break;
		default:
			DE_ASSERT(!"Invalid StdVideoPictureParametersSet Parameter Type!");
	}

	return VK_SUCCESS;
}

VkParserVideoPictureParameters::~VkParserVideoPictureParameters()
{
	if (!!m_sessionParameters) {
		m_deviceContext.getDeviceDriver().destroyVideoSessionParametersKHR(m_deviceContext.device, m_sessionParameters, nullptr);
		m_sessionParameters = VK_NULL_HANDLE;
	}
	m_videoSession = nullptr;
}

bool VkParserVideoPictureParameters::UpdatePictureParametersHierarchy(
		VkSharedBaseObj<StdVideoPictureParametersSet>& pictureParametersObject)
{
	int32_t nodeId = -1;
	bool isNodeId = false;
	StdVideoPictureParametersSet::ParameterType nodeParent = StdVideoPictureParametersSet::INVALID_TYPE;
	StdVideoPictureParametersSet::ParameterType nodeChild = StdVideoPictureParametersSet::INVALID_TYPE;
	switch (pictureParametersObject->GetParameterType()) {
		case StdVideoPictureParametersSet::PPS_TYPE:
			nodeParent = StdVideoPictureParametersSet::SPS_TYPE;
			nodeId = pictureParametersObject->GetPpsId(isNodeId);
			if (!((deUint32)nodeId < VkParserVideoPictureParameters::MAX_PPS_IDS)) {
				DE_ASSERT(!"PPS ID is out of bounds");
				return false;
			}
			DE_ASSERT(isNodeId);
			if (m_lastPictParamsQueue[nodeParent]) {
				bool isParentId = false;
				const int32_t spsParentId = pictureParametersObject->GetSpsId(isParentId);
				DE_ASSERT(!isParentId);
				if (spsParentId == m_lastPictParamsQueue[nodeParent]->GetSpsId(isParentId)) {
					DE_ASSERT(isParentId);
					pictureParametersObject->m_parent = m_lastPictParamsQueue[nodeParent];
				}
			}
			break;
		case StdVideoPictureParametersSet::SPS_TYPE:
			nodeParent = StdVideoPictureParametersSet::VPS_TYPE;
			nodeChild = StdVideoPictureParametersSet::PPS_TYPE;
			nodeId = pictureParametersObject->GetSpsId(isNodeId);
			if (!((deUint32)nodeId < VkParserVideoPictureParameters::MAX_SPS_IDS)) {
				DE_ASSERT(!"SPS ID is out of bounds");
				return false;
			}
			DE_ASSERT(isNodeId);
			if (m_lastPictParamsQueue[nodeChild]) {
				const int32_t spsChildId = m_lastPictParamsQueue[nodeChild]->GetSpsId(isNodeId);
				DE_ASSERT(!isNodeId);
				if (spsChildId == nodeId) {
					m_lastPictParamsQueue[nodeChild]->m_parent = pictureParametersObject;
				}
			}
			if (m_lastPictParamsQueue[nodeParent]) {
				const int32_t vpsParentId = pictureParametersObject->GetVpsId(isNodeId);
				DE_ASSERT(!isNodeId);
				if (vpsParentId == m_lastPictParamsQueue[nodeParent]->GetVpsId(isNodeId)) {
					pictureParametersObject->m_parent = m_lastPictParamsQueue[nodeParent];
					DE_ASSERT(isNodeId);
				}
			}
			break;
		case StdVideoPictureParametersSet::VPS_TYPE:
			nodeChild = StdVideoPictureParametersSet::SPS_TYPE;
			nodeId = pictureParametersObject->GetVpsId(isNodeId);
			if (!((deUint32)nodeId < VkParserVideoPictureParameters::MAX_VPS_IDS)) {
				DE_ASSERT(!"VPS ID is out of bounds");
				return false;
			}
			DE_ASSERT(isNodeId);
			if (m_lastPictParamsQueue[nodeChild]) {
				const int32_t vpsParentId = m_lastPictParamsQueue[nodeChild]->GetVpsId(isNodeId);
				DE_ASSERT(!isNodeId);
				if (vpsParentId == nodeId) {
					m_lastPictParamsQueue[nodeChild]->m_parent = pictureParametersObject;
				}
			}
			break;
		default:
			DE_ASSERT("!Invalid STD type");
			return false;
	}
	m_lastPictParamsQueue[pictureParametersObject->GetParameterType()] = pictureParametersObject;

	return true;
}

VkResult VkParserVideoPictureParameters::AddPictureParametersToQueue(VkSharedBaseObj<StdVideoPictureParametersSet>& pictureParametersSet)
{
	m_pictureParametersQueue.push(pictureParametersSet);
	return VK_SUCCESS;
}

VkResult VkParserVideoPictureParameters::HandleNewPictureParametersSet(VkSharedBaseObj<VulkanVideoSession>& videoSession,
																	   StdVideoPictureParametersSet* pStdVideoPictureParametersSet)
{
	VkResult result;
	if (m_sessionParameters == VK_NULL_HANDLE) {
		DE_ASSERT(videoSession != VK_NULL_HANDLE);
		DE_ASSERT(m_videoSession == VK_NULL_HANDLE);
		if (m_templatePictureParameters) {
			m_templatePictureParameters->FlushPictureParametersQueue(videoSession);
		}
		result = CreateParametersObject(videoSession, pStdVideoPictureParametersSet,
										m_templatePictureParameters);
		DE_ASSERT(result == VK_SUCCESS);
		m_templatePictureParameters = nullptr; // the template object is not needed anymore
		m_videoSession = videoSession;

	} else {
		DE_ASSERT(m_videoSession != VK_NULL_HANDLE);
		DE_ASSERT(m_sessionParameters != VK_NULL_HANDLE);
		result = UpdateParametersObject(pStdVideoPictureParametersSet);
		DE_ASSERT(result == VK_SUCCESS);
	}

	return result;
}


int32_t VkParserVideoPictureParameters::FlushPictureParametersQueue(VkSharedBaseObj<VulkanVideoSession>& videoSession)
{
	if (!videoSession) {
		return -1;
	}
	deUint32 numQueueItems = 0;
	while (!m_pictureParametersQueue.empty()) {
		VkSharedBaseObj<StdVideoPictureParametersSet>& stdVideoPictureParametersSet = m_pictureParametersQueue.front();

		VkResult result =  HandleNewPictureParametersSet(videoSession, stdVideoPictureParametersSet);
		if (result != VK_SUCCESS) {
			return -1;
		}

		m_pictureParametersQueue.pop();
		numQueueItems++;
	}

	return numQueueItems;
}

bool VkParserVideoPictureParameters::CheckStdObjectBeforeUpdate(VkSharedBaseObj<StdVideoPictureParametersSet>& stdPictureParametersSet,
																VkSharedBaseObj<VkParserVideoPictureParameters>& currentVideoPictureParameters)
{
	if (!stdPictureParametersSet) {
		return false;
	}

	bool stdObjectUpdate = (stdPictureParametersSet->GetUpdateSequenceCount() > 0);

	if (!currentVideoPictureParameters || stdObjectUpdate) {

		// Create new Vulkan Picture Parameters object
		return true;

	} else { // existing VkParserVideoPictureParameters object
		DE_ASSERT(currentVideoPictureParameters);
		// Update with the existing Vulkan Picture Parameters object
	}

	VkSharedBaseObj<VkVideoRefCountBase> clientObject;
	stdPictureParametersSet->GetClientObject(clientObject);
	DE_ASSERT(!clientObject);

	return false;
}

VkResult
VkParserVideoPictureParameters::AddPictureParameters(DeviceContext& deviceContext,
													 VkSharedBaseObj<VulkanVideoSession>& /*videoSession*/,
													 VkSharedBaseObj<StdVideoPictureParametersSet>& stdPictureParametersSet,
													 VkSharedBaseObj<VkParserVideoPictureParameters>& currentVideoPictureParameters)
{
	if (!stdPictureParametersSet) {
		return VK_ERROR_INITIALIZATION_FAILED;
	}

	VkResult result;
	if (CheckStdObjectBeforeUpdate(stdPictureParametersSet, currentVideoPictureParameters)) {
		result = VkParserVideoPictureParameters::Create(deviceContext,
														currentVideoPictureParameters,
														currentVideoPictureParameters);
	}

	result = currentVideoPictureParameters->AddPictureParametersToQueue(stdPictureParametersSet);

	return result;
}


int32_t VkParserVideoPictureParameters::AddRef()
{
	return ++m_refCount;
}

int32_t VkParserVideoPictureParameters::Release()
{
	deUint32 ret;
	ret = --m_refCount;
	// Destroy the device if refcount reaches zero
	if (ret == 0) {
		delete this;
	}
	return ret;
}

}	// video
}	// vkt