1 /*------------------------------------------------------------------------
2 * Vulkan Conformance Tests
3 * ------------------------
4 *
5 * Copyright (c) 2021 The Khronos Group Inc.
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Video Encoding and Decoding Utility Functions
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktVideoTestUtils.hpp"
25
26 #ifdef DE_BUILD_VIDEO
27 #include "vktVideoBaseDecodeUtils.hpp"
28 #endif
29
30 #include "vkDefs.hpp"
31 #include "vkMemUtil.hpp"
32 #include "vkRefUtil.hpp"
33 #include "vkTypeUtil.hpp"
34 #include "vkQueryUtil.hpp"
35 #include "vkObjUtil.hpp"
36 #include "vkDeviceUtil.hpp"
37 #include "vkImageUtil.hpp"
38 #include "tcuCommandLine.hpp"
39 #include "tcuResource.hpp"
40
41 #include "vktCustomInstancesDevices.hpp"
42 #include "vktTestCase.hpp"
43
44 #include "vktVideoDecodeTests.hpp"
45
46 #include "vkMd5Sum.hpp"
47
48 #ifdef DE_BUILD_VIDEO
49 #include "video_generator.h"
50 #endif
51
52 #ifndef STREAM_DUMP_DEBUG
53 #define STREAM_DUMP_DEBUG 0
54 #endif
55
56 using namespace vk;
57 using namespace std;
58
59 namespace vkt
60 {
61 namespace video
62 {
63
64 using namespace vk;
65 using namespace std;
66
videoLoggingEnabled()67 bool videoLoggingEnabled()
68 {
69 static int debuggingEnabled = -1; // -1 means it hasn't been checked yet
70 if (debuggingEnabled == -1)
71 {
72 const char *s = getenv("CTS_DEBUG_VIDEO");
73 debuggingEnabled = s != nullptr;
74 }
75
76 return debuggingEnabled > 0;
77 }
78
cmdPipelineImageMemoryBarrier2(const DeviceInterface & vk,const VkCommandBuffer commandBuffer,const VkImageMemoryBarrier2KHR * pImageMemoryBarriers,const size_t imageMemoryBarrierCount,const VkDependencyFlags dependencyFlags)79 void cmdPipelineImageMemoryBarrier2(const DeviceInterface &vk, const VkCommandBuffer commandBuffer,
80 const VkImageMemoryBarrier2KHR *pImageMemoryBarriers,
81 const size_t imageMemoryBarrierCount, const VkDependencyFlags dependencyFlags)
82 {
83 const uint32_t imageMemoryBarrierCount32 = static_cast<uint32_t>(imageMemoryBarrierCount);
84 const VkDependencyInfo dependencyInfoKHR = {
85 vk::VK_STRUCTURE_TYPE_DEPENDENCY_INFO, // VkStructureType sType;
86 nullptr, // const void* pNext;
87 dependencyFlags, // VkDependencyFlags dependencyFlags;
88 0u, // uint32_t memoryBarrierCount;
89 nullptr, // const VkMemoryBarrier2KHR* pMemoryBarriers;
90 0u, // uint32_t bufferMemoryBarrierCount;
91 nullptr, // const VkBufferMemoryBarrier2KHR* pBufferMemoryBarriers;
92 imageMemoryBarrierCount32, // uint32_t imageMemoryBarrierCount;
93 pImageMemoryBarriers, // const VkImageMemoryBarrier2KHR* pImageMemoryBarriers;
94 };
95
96 DE_ASSERT(imageMemoryBarrierCount == imageMemoryBarrierCount32);
97
98 vk.cmdPipelineBarrier2(commandBuffer, &dependencyInfoKHR);
99 }
100
makeExtensionProperties(const char * extensionName,uint32_t specVersion)101 static VkExtensionProperties makeExtensionProperties(const char *extensionName, uint32_t specVersion)
102 {
103 const uint32_t extensionNameLen = static_cast<uint32_t>(strlen(extensionName));
104 VkExtensionProperties result;
105
106 deMemset(&result, 0, sizeof(result));
107
108 deMemcpy(&result.extensionName, extensionName, extensionNameLen);
109
110 result.specVersion = specVersion;
111
112 return result;
113 }
114
115 static const VkExtensionProperties EXTENSION_PROPERTIES_H264_DECODE = makeExtensionProperties(
116 VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION);
117 static const VkExtensionProperties EXTENSION_PROPERTIES_H264_ENCODE = makeExtensionProperties(
118 VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H264_ENCODE_SPEC_VERSION);
119 static const VkExtensionProperties EXTENSION_PROPERTIES_AV1_ENCODE = makeExtensionProperties(
120 VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_AV1_ENCODE_SPEC_VERSION);
121 static const VkExtensionProperties EXTENSION_PROPERTIES_H265_DECODE = makeExtensionProperties(
122 VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION);
123 static const VkExtensionProperties EXTENSION_PROPERTIES_H265_ENCODE = makeExtensionProperties(
124 VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_H265_ENCODE_SPEC_VERSION);
125 static const VkExtensionProperties EXTENSION_PROPERTIES_AV1_DECODE = makeExtensionProperties(
126 VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME, VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION);
127
getBufferSize(VkFormat format,uint32_t width,uint32_t height)128 VkDeviceSize getBufferSize(VkFormat format, uint32_t width, uint32_t height)
129 {
130 VkDeviceSize result = 0;
131
132 if (vk::isYCbCrFormat(format))
133 {
134 const PlanarFormatDescription formatDescription = getPlanarFormatDescription(format);
135 const tcu::UVec2 baseExtend(width, height);
136
137 for (uint32_t plane = 0; plane < formatDescription.numPlanes; ++plane)
138 result += getPlaneSizeInBytes(formatDescription, baseExtend, plane, 0u, 1u);
139 }
140 else
141 {
142 result = static_cast<VkDeviceSize>(mapVkFormat(format).getPixelSize()) * width * height;
143 }
144
145 return result;
146 }
147
transferImageOwnership(const DeviceInterface & vkd,VkDevice device,VkImage image,uint32_t transferQueueFamilyIndex,uint32_t encodeQueueFamilyIndex,VkImageLayout newLayout)148 void transferImageOwnership(const DeviceInterface &vkd, VkDevice device, VkImage image,
149 uint32_t transferQueueFamilyIndex, uint32_t encodeQueueFamilyIndex, VkImageLayout newLayout)
150 {
151 const VkImageSubresourceRange imageSubresourceRange =
152 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1);
153 const VkImageMemoryBarrier2KHR imageBarrierOwnershipTransfer = makeImageMemoryBarrier2(
154 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR, VK_ACCESS_NONE_KHR, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
155 VK_ACCESS_NONE_KHR, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, image, imageSubresourceRange,
156 transferQueueFamilyIndex, encodeQueueFamilyIndex);
157 const VkImageMemoryBarrier2KHR imageBarrierOwnershipEncode = makeImageMemoryBarrier2(
158 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, VK_ACCESS_NONE_KHR, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
159 VK_ACCESS_NONE_KHR, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL, image, imageSubresourceRange,
160 transferQueueFamilyIndex, encodeQueueFamilyIndex);
161 const VkImageMemoryBarrier2KHR imageBarrierChangeDstLayout = makeImageMemoryBarrier2(
162 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, VK_ACCESS_NONE_KHR, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
163 VK_ACCESS_NONE_KHR, VK_IMAGE_LAYOUT_GENERAL, newLayout, image, imageSubresourceRange, encodeQueueFamilyIndex,
164 encodeQueueFamilyIndex);
165 const Move<VkCommandPool> cmdEncodePool(makeCommandPool(vkd, device, encodeQueueFamilyIndex));
166 const Move<VkCommandBuffer> cmdEncodeBuffer(
167 allocateCommandBuffer(vkd, device, *cmdEncodePool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
168 const Move<VkCommandPool> cmdTransferPool(makeCommandPool(vkd, device, transferQueueFamilyIndex));
169 const Move<VkCommandBuffer> cmdTransferBuffer(
170 allocateCommandBuffer(vkd, device, *cmdTransferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
171 Move<VkSemaphore> semaphore = createSemaphore(vkd, device);
172 Move<VkFence> encodeFence = createFence(vkd, device);
173 Move<VkFence> transferFence = createFence(vkd, device);
174 VkFence fences[] = {*encodeFence, *transferFence};
175 const VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
176 const VkSubmitInfo transferSubmitInfo{
177 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
178 nullptr, // const void* pNext;
179 0u, // uint32_t waitSemaphoreCount;
180 nullptr, // const VkSemaphore* pWaitSemaphores;
181 nullptr, // const VkPipelineStageFlags* pWaitDstStageMask;
182 1u, // uint32_t commandBufferCount;
183 &*cmdTransferBuffer, // const VkCommandBuffer* pCommandBuffers;
184 1u, // uint32_t signalSemaphoreCount;
185 &*semaphore, // const VkSemaphore* pSignalSemaphores;
186 };
187 const VkSubmitInfo encodeSubmitInfo{
188 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
189 nullptr, // const void* pNext;
190 1u, // uint32_t waitSemaphoreCount;
191 &*semaphore, // const VkSemaphore* pWaitSemaphores;
192 &waitDstStageMask, // const VkPipelineStageFlags* pWaitDstStageMask;
193 1u, // uint32_t commandBufferCount;
194 &*cmdEncodeBuffer, // const VkCommandBuffer* pCommandBuffers;
195 0u, // uint32_t signalSemaphoreCount;
196 nullptr, // const VkSemaphore* pSignalSemaphores;
197 };
198 const VkQueue encodeQueue = getDeviceQueue(vkd, device, encodeQueueFamilyIndex, 0u);
199 const VkQueue transferQueue = getDeviceQueue(vkd, device, transferQueueFamilyIndex, 0u);
200
201 beginCommandBuffer(vkd, *cmdTransferBuffer, 0u);
202 cmdPipelineImageMemoryBarrier2(vkd, *cmdTransferBuffer, &imageBarrierOwnershipTransfer);
203 endCommandBuffer(vkd, *cmdTransferBuffer);
204
205 beginCommandBuffer(vkd, *cmdEncodeBuffer, 0u);
206 cmdPipelineImageMemoryBarrier2(vkd, *cmdEncodeBuffer, &imageBarrierOwnershipEncode);
207 cmdPipelineImageMemoryBarrier2(vkd, *cmdEncodeBuffer, &imageBarrierChangeDstLayout);
208 endCommandBuffer(vkd, *cmdEncodeBuffer);
209
210 VK_CHECK(vkd.queueSubmit(transferQueue, 1u, &transferSubmitInfo, *transferFence));
211 VK_CHECK(vkd.queueSubmit(encodeQueue, 1u, &encodeSubmitInfo, *encodeFence));
212
213 VK_CHECK(vkd.waitForFences(device, DE_LENGTH_OF_ARRAY(fences), fences, true, ~0ull));
214 }
215
getDecodedImage(const DeviceInterface & vkd,VkDevice device,Allocator & allocator,VkImage image,VkImageLayout layout,VkFormat format,VkExtent2D codedExtent,uint32_t queueFamilyIndexTransfer,uint32_t queueFamilyIndexDecode)216 de::MovePtr<vkt::ycbcr::MultiPlaneImageData> getDecodedImage(const DeviceInterface &vkd, VkDevice device,
217 Allocator &allocator, VkImage image, VkImageLayout layout,
218 VkFormat format, VkExtent2D codedExtent,
219 uint32_t queueFamilyIndexTransfer,
220 uint32_t queueFamilyIndexDecode)
221 {
222 de::MovePtr<vkt::ycbcr::MultiPlaneImageData> multiPlaneImageData(
223 new vkt::ycbcr::MultiPlaneImageData(format, tcu::UVec2(codedExtent.width, codedExtent.height)));
224 const VkQueue queueDecode = getDeviceQueue(vkd, device, queueFamilyIndexDecode, 0u);
225 const VkQueue queueTransfer = getDeviceQueue(vkd, device, queueFamilyIndexTransfer, 0u);
226 const VkImageSubresourceRange imageSubresourceRange =
227 makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1);
228 const VkImageMemoryBarrier2KHR imageBarrierDecode =
229 makeImageMemoryBarrier2(VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR, VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR,
230 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, VK_ACCESS_NONE_KHR, layout,
231 VK_IMAGE_LAYOUT_GENERAL, image, imageSubresourceRange);
232 const VkImageMemoryBarrier2KHR imageBarrierOwnershipDecode = makeImageMemoryBarrier2(
233 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR, VK_ACCESS_NONE_KHR, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
234 VK_ACCESS_NONE_KHR, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image, imageSubresourceRange,
235 queueFamilyIndexDecode, queueFamilyIndexTransfer);
236 const VkImageMemoryBarrier2KHR imageBarrierOwnershipTransfer = makeImageMemoryBarrier2(
237 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR, VK_ACCESS_NONE_KHR, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR,
238 VK_ACCESS_NONE_KHR, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_GENERAL,
239
240 image, imageSubresourceRange, queueFamilyIndexDecode, queueFamilyIndexTransfer);
241 const VkImageMemoryBarrier2KHR imageBarrierTransfer = makeImageMemoryBarrier2(
242 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_ACCESS_2_MEMORY_WRITE_BIT, VK_PIPELINE_STAGE_2_TRANSFER_BIT,
243 VK_ACCESS_2_TRANSFER_READ_BIT_KHR, VK_IMAGE_LAYOUT_GENERAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, image,
244 imageSubresourceRange);
245 const Move<VkCommandPool> cmdDecodePool(makeCommandPool(vkd, device, queueFamilyIndexDecode));
246 const Move<VkCommandBuffer> cmdDecodeBuffer(
247 allocateCommandBuffer(vkd, device, *cmdDecodePool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
248 const Move<VkCommandPool> cmdTransferPool(makeCommandPool(vkd, device, queueFamilyIndexTransfer));
249 const Move<VkCommandBuffer> cmdTransferBuffer(
250 allocateCommandBuffer(vkd, device, *cmdTransferPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY));
251 Move<VkSemaphore> semaphore = createSemaphore(vkd, device);
252 Move<VkFence> decodeFence = createFence(vkd, device);
253 Move<VkFence> transferFence = createFence(vkd, device);
254 VkFence fences[] = {*decodeFence, *transferFence};
255 const VkPipelineStageFlags waitDstStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
256 const VkSubmitInfo decodeSubmitInfo{
257 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
258 nullptr, // const void* pNext;
259 0u, // uint32_t waitSemaphoreCount;
260 nullptr, // const VkSemaphore* pWaitSemaphores;
261 nullptr, // const VkPipelineStageFlags* pWaitDstStageMask;
262 1u, // uint32_t commandBufferCount;
263 &*cmdDecodeBuffer, // const VkCommandBuffer* pCommandBuffers;
264 1u, // uint32_t signalSemaphoreCount;
265 &*semaphore, // const VkSemaphore* pSignalSemaphores;
266 };
267 const VkSubmitInfo transferSubmitInfo{
268 VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
269 nullptr, // const void* pNext;
270 1u, // uint32_t waitSemaphoreCount;
271 &*semaphore, // const VkSemaphore* pWaitSemaphores;
272 &waitDstStageMask, // const VkPipelineStageFlags* pWaitDstStageMask;
273 1u, // uint32_t commandBufferCount;
274 &*cmdTransferBuffer, // const VkCommandBuffer* pCommandBuffers;
275 0u, // uint32_t signalSemaphoreCount;
276 nullptr, // const VkSemaphore* pSignalSemaphores;
277 };
278
279 beginCommandBuffer(vkd, *cmdDecodeBuffer, 0u);
280 cmdPipelineImageMemoryBarrier2(vkd, *cmdDecodeBuffer, &imageBarrierDecode);
281 cmdPipelineImageMemoryBarrier2(vkd, *cmdDecodeBuffer, &imageBarrierOwnershipDecode);
282 endCommandBuffer(vkd, *cmdDecodeBuffer);
283
284 beginCommandBuffer(vkd, *cmdTransferBuffer, 0u);
285 cmdPipelineImageMemoryBarrier2(vkd, *cmdTransferBuffer, &imageBarrierOwnershipTransfer);
286 cmdPipelineImageMemoryBarrier2(vkd, *cmdTransferBuffer, &imageBarrierTransfer);
287 endCommandBuffer(vkd, *cmdTransferBuffer);
288
289 VK_CHECK(vkd.queueSubmit(queueDecode, 1u, &decodeSubmitInfo, *decodeFence));
290 VK_CHECK(vkd.queueSubmit(queueTransfer, 1u, &transferSubmitInfo, *transferFence));
291
292 VK_CHECK(vkd.waitForFences(device, DE_LENGTH_OF_ARRAY(fences), fences, true, ~0ull));
293
294 vkt::ycbcr::downloadImage(vkd, device, queueFamilyIndexTransfer, allocator, image, multiPlaneImageData.get(), 0,
295 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
296
297 return multiPlaneImageData;
298 }
299
createDeviceSupportingQueue(const VkQueueFlags queueFlagsRequired,const VkVideoCodecOperationFlagsKHR videoCodecOperationFlags,const VideoDevice::VideoDeviceFlags videoDeviceFlags)300 bool VideoBaseTestInstance::createDeviceSupportingQueue(const VkQueueFlags queueFlagsRequired,
301 const VkVideoCodecOperationFlagsKHR videoCodecOperationFlags,
302 const VideoDevice::VideoDeviceFlags videoDeviceFlags)
303 {
304 return m_videoDevice.createDeviceSupportingQueue(queueFlagsRequired, videoCodecOperationFlags, videoDeviceFlags);
305 }
306
getDeviceSupportingQueue(const VkQueueFlags queueFlagsRequired,const VkVideoCodecOperationFlagsKHR videoCodecOperationFlags,const VideoDevice::VideoDeviceFlags videoDeviceFlags)307 VkDevice VideoBaseTestInstance::getDeviceSupportingQueue(const VkQueueFlags queueFlagsRequired,
308 const VkVideoCodecOperationFlagsKHR videoCodecOperationFlags,
309 const VideoDevice::VideoDeviceFlags videoDeviceFlags)
310 {
311 return m_videoDevice.getDeviceSupportingQueue(queueFlagsRequired, videoCodecOperationFlags, videoDeviceFlags);
312 }
313
getDeviceDriver(void)314 const DeviceDriver &VideoBaseTestInstance::getDeviceDriver(void)
315 {
316 return m_videoDevice.getDeviceDriver();
317 }
318
getQueueFamilyIndexTransfer(void)319 uint32_t VideoBaseTestInstance::getQueueFamilyIndexTransfer(void)
320 {
321 return m_videoDevice.getQueueFamilyIndexTransfer();
322 }
323
getQueueFamilyIndexDecode(void)324 uint32_t VideoBaseTestInstance::getQueueFamilyIndexDecode(void)
325 {
326 return m_videoDevice.getQueueFamilyIndexDecode();
327 }
328
getQueueFamilyIndexEncode(void)329 uint32_t VideoBaseTestInstance::getQueueFamilyIndexEncode(void)
330 {
331 return m_videoDevice.getQueueFamilyIndexEncode();
332 }
333
getAllocator(void)334 Allocator &VideoBaseTestInstance::getAllocator(void)
335 {
336 return m_videoDevice.getAllocator();
337 }
338
loadVideoData(const string & filename)339 de::MovePtr<vector<uint8_t>> VideoBaseTestInstance::loadVideoData(const string &filename)
340 {
341 tcu::Archive &archive = m_context.getTestContext().getArchive();
342 de::UniquePtr<tcu::Resource> resource(archive.getResource(filename.c_str()));
343 const int resourceSize = resource->getSize();
344 de::MovePtr<vector<uint8_t>> result(new vector<uint8_t>(resourceSize));
345
346 resource->read(result->data(), resource->getSize());
347
348 return result;
349 }
350 #ifdef DE_BUILD_VIDEO
validateEncodedContent(VkVideoCodecOperationFlagBitsKHR videoCodecEncodeOperation,StdVideoAV1Profile profile,const char * encodedFileName,const char * yuvFileName,int32_t numberOfFrames,int32_t inputWidth,int32_t inputHeight,const VkExtent2D expectedOutputExtent,VkVideoChromaSubsamplingFlagsKHR chromaSubsampling,VkVideoComponentBitDepthFlagsKHR lumaBitDepth,VkVideoComponentBitDepthFlagsKHR chromaBitDepth,double psnrThresholdLowerLimit)351 tcu::TestStatus VideoBaseTestInstance::validateEncodedContent(
352 VkVideoCodecOperationFlagBitsKHR videoCodecEncodeOperation, StdVideoAV1Profile profile, const char *encodedFileName,
353 const char *yuvFileName, int32_t numberOfFrames, int32_t inputWidth, int32_t inputHeight,
354 const VkExtent2D expectedOutputExtent, VkVideoChromaSubsamplingFlagsKHR chromaSubsampling,
355 VkVideoComponentBitDepthFlagsKHR lumaBitDepth, VkVideoComponentBitDepthFlagsKHR chromaBitDepth,
356 double psnrThresholdLowerLimit)
357 {
358 double criticalPsnrThreshold = 10.0;
359 VkVideoCodecOperationFlagBitsKHR videoCodecDecodeOperation = VK_VIDEO_CODEC_OPERATION_NONE_KHR;
360 ElementaryStreamFraming framing = ElementaryStreamFraming::UNKNOWN;
361
362 switch (videoCodecEncodeOperation)
363 {
364 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
365 videoCodecDecodeOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR;
366 framing = ElementaryStreamFraming::H26X_BYTE_STREAM;
367 break;
368 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR:
369 videoCodecDecodeOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR;
370 framing = ElementaryStreamFraming::H26X_BYTE_STREAM;
371 break;
372 case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR:
373 videoCodecDecodeOperation = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
374 framing = ElementaryStreamFraming::IVF;
375 break;
376 default:
377 tcu::TestStatus::fail("Unable to validate the encoded content, the decode operation is not supported.");
378 };
379
380 VideoDevice::VideoDeviceFlags videoDeviceFlags = VideoDevice::VIDEO_DEVICE_FLAG_REQUIRE_SYNC2_OR_NOT_SUPPORTED;
381 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
382 const VkDevice videoDevice =
383 getDeviceSupportingQueue(VK_QUEUE_VIDEO_ENCODE_BIT_KHR | VK_QUEUE_VIDEO_DECODE_BIT_KHR | VK_QUEUE_TRANSFER_BIT,
384 videoCodecDecodeOperation | videoCodecEncodeOperation, videoDeviceFlags);
385 const DeviceInterface &videoDeviceDriver = getDeviceDriver();
386
387 const uint32_t encodeQueueFamilyIndex = getQueueFamilyIndexEncode();
388 const uint32_t decodeQueueFamilyIndex = getQueueFamilyIndexDecode();
389 const uint32_t transferQueueFamilyIndex = getQueueFamilyIndexTransfer();
390
391 const VkQueue encodeQueue = getDeviceQueue(videoDeviceDriver, videoDevice, encodeQueueFamilyIndex, 0u);
392 const VkQueue decodeQueue = getDeviceQueue(videoDeviceDriver, videoDevice, decodeQueueFamilyIndex, 0u);
393 const VkQueue transferQueue = getDeviceQueue(videoDeviceDriver, videoDevice, transferQueueFamilyIndex, 0u);
394
395 DeviceContext deviceContext(&m_context, &m_videoDevice, physicalDevice, videoDevice, decodeQueue, encodeQueue,
396 transferQueue);
397 auto decodeProfile =
398 VkVideoCoreProfile(videoCodecDecodeOperation, chromaSubsampling, lumaBitDepth, chromaBitDepth, profile);
399 auto basicDecoder = createBasicDecoder(&deviceContext, &decodeProfile, numberOfFrames, false);
400
401 Demuxer::Params demuxParams = {};
402 demuxParams.data = std::make_unique<BufferedReader>(static_cast<const char *>(encodedFileName));
403 demuxParams.codecOperation = videoCodecDecodeOperation;
404
405 demuxParams.framing = framing;
406 auto demuxer = Demuxer::create(std::move(demuxParams));
407
408 VkVideoParser parser;
409 // TODO: Check for decoder extension support before attempting validation!
410 createParser(demuxer->codecOperation(), basicDecoder, parser, demuxer->framing());
411
412 FrameProcessor processor(std::move(demuxer), basicDecoder);
413 std::vector<int> incorrectFrames;
414 std::vector<int> correctFrames;
415 for (int frameIdx = 0; frameIdx < numberOfFrames; frameIdx++)
416 {
417 DecodedFrame frame;
418 TCU_CHECK_AND_THROW(
419 InternalError, processor.getNextFrame(&frame) > 0,
420 "Expected more frames from the bitstream. Most likely an internal CTS bug, or maybe an invalid bitstream");
421
422 auto resultImage =
423 getDecodedImageFromContext(deviceContext,
424 basicDecoder->dpbAndOutputCoincide() ? VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR :
425 VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR,
426 &frame);
427
428 if (frame.displayWidth != expectedOutputExtent.width || frame.displayHeight != expectedOutputExtent.height)
429 {
430 return tcu::TestStatus::fail(
431 "Decoded frame resolution (" + std::to_string(frame.displayWidth) + "," +
432 std::to_string(frame.displayHeight) + ")" + " doesn't match expected resolution (" +
433 std::to_string(expectedOutputExtent.width) + "," + std::to_string(expectedOutputExtent.height) + ")");
434 }
435
436 double psnr;
437 if (lumaBitDepth == VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR)
438 {
439 de::MovePtr<std::vector<uint8_t>> out =
440 vkt::ycbcr::YCbCrConvUtil<uint8_t>::MultiPlanarNV12toI420(resultImage.get());
441 de::MovePtr<std::vector<uint8_t>> inputFrame =
442 vkt::ycbcr::YCbCrContent<uint8_t>::getFrame(yuvFileName, inputWidth, inputHeight, frameIdx);
443 psnr = util::PSNRImplicitCrop(*inputFrame, inputWidth, inputHeight, *out, expectedOutputExtent.width,
444 expectedOutputExtent.height);
445 #if STREAM_DUMP_DEBUG
446 const string outputFileName = "out_" + std::to_string(frameIdx) + ".yuv";
447 vkt::ycbcr::YCbCrContent<uint8_t>::save(*out, outputFileName);
448 const string refFileName = "ref_" + std::to_string(frameIdx) + ".yuv";
449 vkt::ycbcr::YCbCrContent<uint8_t>::save(*inputFrame, refFileName);
450 #endif
451 }
452 else
453 {
454 de::MovePtr<std::vector<uint16_t>> out =
455 vkt::ycbcr::YCbCrConvUtil<uint16_t>::MultiPlanarNV12toI420(resultImage.get());
456 de::MovePtr<std::vector<uint16_t>> inputFrame =
457 vkt::ycbcr::YCbCrContent<uint16_t>::getFrame(yuvFileName, inputWidth, inputHeight, frameIdx);
458 psnr = util::PSNRImplicitCrop(*inputFrame, inputWidth, inputHeight, *out, expectedOutputExtent.width,
459 expectedOutputExtent.height);
460 #if STREAM_DUMP_DEBUG
461 const string outputFileName = "out_" + std::to_string(frameIdx) + ".yuv";
462 vkt::ycbcr::YCbCrContent<uint16_t>::save(*out, outputFileName);
463 const string refFileName = "ref_" + std::to_string(frameIdx) + ".yuv";
464 vkt::ycbcr::YCbCrContent<uint16_t>::save(*inputFrame, refFileName);
465 #endif
466 }
467 #if STREAM_DUMP_DEBUG
468 cout << "Current PSNR: " << psnr << endl;
469 #endif
470
471 string failMessage;
472
473 if (psnr < psnrThresholdLowerLimit)
474 {
475 double difference = psnrThresholdLowerLimit - psnr;
476
477 if (psnr > criticalPsnrThreshold)
478 {
479 failMessage = "Frame " + std::to_string(frameIdx) + " with PSNR " + std::to_string(psnr) + " is " +
480 std::to_string(difference) + " points below the lower threshold";
481 return tcu::TestStatus(QP_TEST_RESULT_QUALITY_WARNING, failMessage);
482 }
483 else
484 {
485 failMessage = "Frame " + std::to_string(frameIdx) + " with PSNR " + std::to_string(psnr) + " is " +
486 std::to_string(difference) + " points below the critical threshold";
487 return tcu::TestStatus::fail(failMessage);
488 }
489 }
490 }
491
492 return tcu::TestStatus::pass("Video encoding completed successfully");
493 }
494 #endif
495
getVideoDecodeCapabilities(void * pNext)496 de::MovePtr<VkVideoDecodeCapabilitiesKHR> getVideoDecodeCapabilities(void *pNext)
497 {
498 const VkVideoDecodeCapabilitiesKHR videoDecodeCapabilities = {
499 vk::VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, // VkStructureType sType;
500 pNext, // void* pNext;
501 0, // VkVideoDecodeCapabilityFlagsKHR Flags;
502 };
503
504 return de::MovePtr<VkVideoDecodeCapabilitiesKHR>(new VkVideoDecodeCapabilitiesKHR(videoDecodeCapabilities));
505 }
506
getVideoCapabilitiesExtensionH264D(void)507 de::MovePtr<VkVideoDecodeH264CapabilitiesKHR> getVideoCapabilitiesExtensionH264D(void)
508 {
509 const VkVideoDecodeH264CapabilitiesKHR videoCapabilitiesExtension = {
510 vk::VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR, // VkStructureType sType;
511 nullptr, // void* pNext;
512 STD_VIDEO_H264_LEVEL_IDC_1_0, // StdVideoH264Level maxLevel;
513 {0, 0}, // VkOffset2D fieldOffsetGranularity;
514 };
515
516 return de::MovePtr<VkVideoDecodeH264CapabilitiesKHR>(
517 new VkVideoDecodeH264CapabilitiesKHR(videoCapabilitiesExtension));
518 }
519
getVideoCapabilitiesExtensionH264E(void * pNext)520 de::MovePtr<VkVideoEncodeH264CapabilitiesKHR> getVideoCapabilitiesExtensionH264E(void *pNext)
521 {
522 const VkVideoEncodeH264CapabilitiesKHR videoCapabilitiesExtension = {
523 vk::VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR, // VkStructureType sType;
524 pNext, // const void* pNext;
525 0u, // VkVideoEncodeH264CapabilityFlagsKHR flags;
526 static_cast<StdVideoH264LevelIdc>(0u), // StdVideoH264LevelIdc maxLevelIdc;
527 0u, // uint32_t maxSliceCount;
528 0u, // uint8_t maxPPictureL0ReferenceCount;
529 0u, // uint8_t maxBPictureL0ReferenceCount;
530 0u, // uint8_t maxL1ReferenceCount;
531 0u, // uint32_t maxTemporalLayerCount;
532 false, // VkBool32 expectDyadicTemporalLayerPattern;
533 0u, // uint32_t minQp;
534 0u, // uint32_t maxQp;
535 false, // VkBool32 prefersGopRemainingFrames;
536 false, // VkBool32 requiresGopRemainingFrames;
537 static_cast<VkVideoEncodeH264StdFlagsKHR>(0) // VkVideoEncodeH264StdFlagsKHR stdSyntaxFlags;
538 };
539
540 return de::MovePtr<VkVideoEncodeH264CapabilitiesKHR>(
541 new VkVideoEncodeH264CapabilitiesKHR(videoCapabilitiesExtension));
542 }
543
getVideoEncodeH264QuantizationMapCapabilities(void)544 de::MovePtr<VkVideoEncodeH264QuantizationMapCapabilitiesKHR> getVideoEncodeH264QuantizationMapCapabilities(void)
545 {
546 const VkVideoEncodeH264QuantizationMapCapabilitiesKHR quantizationMapCapabilities = {
547 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR, // VkStructureType sType
548 nullptr, // void* pNext
549 0, // int32_t minQpDelta
550 0 // int32_t maxQpDelta
551 };
552 return de::MovePtr<VkVideoEncodeH264QuantizationMapCapabilitiesKHR>(
553 new VkVideoEncodeH264QuantizationMapCapabilitiesKHR(quantizationMapCapabilities));
554 }
555
getVideoEncodeCapabilities(void * pNext)556 de::MovePtr<VkVideoEncodeCapabilitiesKHR> getVideoEncodeCapabilities(void *pNext)
557 {
558 const VkVideoEncodeCapabilitiesKHR videoEncodeCapabilities = {
559 VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR, // VkStructureType sType;
560 pNext, // void* pNext;
561 0, // VkVideoEncodeCapabilityFlagsKHR flags;
562 0, // VkVideoEncodeRateControlModeFlagsKHR rateControlModes;
563 0, // uint32_t maxRateControlLayers;
564 0, // uint64_t maxBitrate;
565 0, // uint32_t maxQualityLevels;
566 {0, 0}, // VkExtent2D encodeInputPictureGranularity;
567 static_cast<VkVideoEncodeFeedbackFlagsKHR>(0), // VkVideoEncodeFeedbackFlagsKHR supportedEncodeFeedbackFlags;
568 };
569
570 return de::MovePtr<VkVideoEncodeCapabilitiesKHR>(new VkVideoEncodeCapabilitiesKHR(videoEncodeCapabilities));
571 }
572
getVideoCapabilitiesExtensionH265D(void)573 de::MovePtr<VkVideoDecodeH265CapabilitiesKHR> getVideoCapabilitiesExtensionH265D(void)
574 {
575 const VkVideoDecodeH265CapabilitiesKHR videoCapabilitiesExtension = {
576 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR, // VkStructureType sType;
577 nullptr, // void* pNext;
578 STD_VIDEO_H265_LEVEL_IDC_1_0, // StdVideoH265Level maxLevel;
579 };
580
581 return de::MovePtr<VkVideoDecodeH265CapabilitiesKHR>(
582 new VkVideoDecodeH265CapabilitiesKHR(videoCapabilitiesExtension));
583 }
584
getVideoCapabilitiesExtensionH265E(void * pNext)585 de::MovePtr<VkVideoEncodeH265CapabilitiesKHR> getVideoCapabilitiesExtensionH265E(void *pNext)
586 {
587 const VkVideoEncodeH265CapabilitiesKHR videoCapabilitiesExtension = {
588 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR, // VkStructureType sType;
589 pNext, // const void* pNext;
590 0u, // VkVideoEncodeH265CapabilityFlagsKHR flags;
591 static_cast<StdVideoH265LevelIdc>(0), // StdVideoH265LevelIdc maxLevelIdc;
592 0u, // uint32_t maxSliceSegmentCount;
593 {0, 0}, // VkExtent2D maxTiles;
594 VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR, // VkVideoEncodeH265CtbSizeFlagsKHR ctbSizes;
595 0u, // VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes;
596 0u, // uint8_t maxPPictureL0ReferenceCount;
597 0u, // uint8_t maxBPictureL0ReferenceCount;
598 0u, // uint32_t maxL1ReferenceCount;
599 0u, // uint32_t maxSubLayerCount;
600 false, // VkBool32 expectDyadicTemporalSubLayerPattern;
601 0u, // int32_t minQp;
602 0u, // int32_t maxQp;
603 false, // VkBool32 prefersGopRemainingFrames;
604 false, // VkBool32 requiresGopRemainingFrames;
605 static_cast<VkVideoEncodeH265StdFlagsKHR>(0), // VkVideoEncodeH265StdFlagsKHR stdSyntaxFlags;
606 };
607
608 return de::MovePtr<VkVideoEncodeH265CapabilitiesKHR>(
609 new VkVideoEncodeH265CapabilitiesKHR(videoCapabilitiesExtension));
610 }
611
getVideoEncodeH265QuantizationMapCapabilities(void)612 de::MovePtr<VkVideoEncodeH265QuantizationMapCapabilitiesKHR> getVideoEncodeH265QuantizationMapCapabilities(void)
613 {
614 const VkVideoEncodeH265QuantizationMapCapabilitiesKHR quantizationMapCapabilities = {
615 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR, // VkStructureType sType
616 nullptr, // void* pNext
617 0, // int32_t minQpDelta
618 0 // int32_t maxQpDelta
619 };
620 return de::MovePtr<VkVideoEncodeH265QuantizationMapCapabilitiesKHR>(
621 new VkVideoEncodeH265QuantizationMapCapabilitiesKHR(quantizationMapCapabilities));
622 }
623
getVideoCapabilitiesExtensionAV1E(void)624 de::MovePtr<VkVideoEncodeAV1CapabilitiesKHR> getVideoCapabilitiesExtensionAV1E(void)
625 {
626 const VkVideoEncodeAV1CapabilitiesKHR videoCapabilitiesExtension = {
627 VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR, // VkStructureType sType
628 nullptr, // void* pNext
629 0u, // VkVideoEncodeAV1CapabilityFlagsKHR flags
630 static_cast<StdVideoAV1Level>(0), // StdVideoAV1Level maxLevel
631 {0, 0}, // codedPictureAlignment
632 {0, 0}, // VkExtent2D maxTiles
633 {0, 0}, // VkExtent2D minTileSize
634 {0, 0}, // VkExtent2D maxTileSize
635 static_cast<VkVideoEncodeAV1SuperblockSizeFlagsKHR>(
636 0), // VkVideoEncodeAV1SuperblockSizeFlagsKHR superblockSizes
637 0u, // uint32_t maxSingleReferenceCount
638 0u, // uint32_t singleReferenceNameMask
639 0u, // uint32_t maxUnidirectionalCompoundReferenceCount
640 0u, // uint32_t maxUnidirectionalCompoundGroup1ReferenceCount
641 0u, // uint32_t unidirectionalCompoundReferenceNameMask
642 0u, // uint32_t maxBidirectionalCompoundReferenceCount
643 0u, // uint32_t maxBidirectionalCompoundGroup1ReferenceCount
644 0u, // uint32_t maxBidirectionalCompoundGroup2ReferenceCount
645 0u, // uint32_t bidirectionalCompoundReferenceNameMask
646 0u, // uint32_t maxTemporalLayerCount
647 0u, // uint32_t maxSpatialLayerCount
648 0u, // uint32_t maxOperatingPoints
649 0u, // uint32_t minQIndex
650 0u, // uint32_t maxQIndex
651 VK_FALSE, // VkBool32 prefersGopRemainingFrames
652 VK_FALSE, // VkBool32 requiresGopRemainingFrames
653 static_cast<VkVideoEncodeAV1StdFlagsKHR>(0) // VkVideoEncodeAV1StdFlagsKHR stdSyntaxFlags
654 };
655
656 return de::MovePtr<VkVideoEncodeAV1CapabilitiesKHR>(
657 new VkVideoEncodeAV1CapabilitiesKHR(videoCapabilitiesExtension));
658 }
659
getVideoCapabilities(const InstanceInterface & vk,VkPhysicalDevice physicalDevice,const VkVideoProfileInfoKHR * videoProfile,void * pNext)660 de::MovePtr<VkVideoCapabilitiesKHR> getVideoCapabilities(const InstanceInterface &vk, VkPhysicalDevice physicalDevice,
661 const VkVideoProfileInfoKHR *videoProfile, void *pNext)
662 {
663 VkVideoCapabilitiesKHR *videoCapabilities = new VkVideoCapabilitiesKHR{
664 VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, // VkStructureType sType;
665 pNext, // void* pNext;
666 0, // VkVideoCapabilityFlagsKHR capabilityFlags;
667 0, // VkDeviceSize minBitstreamBufferOffsetAlignment;
668 0, // VkDeviceSize minBitstreamBufferSizeAlignment;
669 {0, 0}, // VkExtent2D videoPictureExtentGranularity;
670 {0, 0}, // VkExtent2D minExtent;
671 {0, 0}, // VkExtent2D maxExtent;
672 0, // uint32_t maxReferencePicturesSlotsCount;
673 0, // uint32_t maxReferencePicturesActiveCount;
674 {{0}, 0}, // VkExtensionProperties stdHeaderVersion;
675 };
676 de::MovePtr<VkVideoCapabilitiesKHR> result = de::MovePtr<VkVideoCapabilitiesKHR>(videoCapabilities);
677
678 VK_CHECK(vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, videoProfile, videoCapabilities));
679
680 return result;
681 }
682
getVideoProfileExtensionH264D(StdVideoH264ProfileIdc stdProfileIdc,VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout)683 de::MovePtr<VkVideoDecodeH264ProfileInfoKHR> getVideoProfileExtensionH264D(
684 StdVideoH264ProfileIdc stdProfileIdc, VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout)
685 {
686 VkVideoDecodeH264ProfileInfoKHR *videoCodecOperation =
687 new VkVideoDecodeH264ProfileInfoKHR(getProfileOperationH264Decode(stdProfileIdc, pictureLayout));
688 de::MovePtr<VkVideoDecodeH264ProfileInfoKHR> result =
689 de::MovePtr<VkVideoDecodeH264ProfileInfoKHR>(videoCodecOperation);
690
691 return result;
692 }
693
getVideoProfileExtensionH264E(StdVideoH264ProfileIdc stdProfileIdc)694 de::MovePtr<VkVideoEncodeH264ProfileInfoKHR> getVideoProfileExtensionH264E(StdVideoH264ProfileIdc stdProfileIdc)
695 {
696 VkVideoEncodeH264ProfileInfoKHR *videoCodecOperation =
697 new VkVideoEncodeH264ProfileInfoKHR(getProfileOperationH264Encode(stdProfileIdc));
698 de::MovePtr<VkVideoEncodeH264ProfileInfoKHR> result =
699 de::MovePtr<VkVideoEncodeH264ProfileInfoKHR>(videoCodecOperation);
700
701 return result;
702 }
703
getVideoProfileExtensionH265D(StdVideoH265ProfileIdc stdProfileIdc)704 de::MovePtr<VkVideoDecodeH265ProfileInfoKHR> getVideoProfileExtensionH265D(StdVideoH265ProfileIdc stdProfileIdc)
705 {
706 VkVideoDecodeH265ProfileInfoKHR *videoCodecOperation =
707 new VkVideoDecodeH265ProfileInfoKHR(getProfileOperationH265Decode(stdProfileIdc));
708 de::MovePtr<VkVideoDecodeH265ProfileInfoKHR> result =
709 de::MovePtr<VkVideoDecodeH265ProfileInfoKHR>(videoCodecOperation);
710
711 return result;
712 }
713
getVideoProfileExtensionH265E(StdVideoH265ProfileIdc stdProfileIdc)714 de::MovePtr<VkVideoEncodeH265ProfileInfoKHR> getVideoProfileExtensionH265E(StdVideoH265ProfileIdc stdProfileIdc)
715 {
716 VkVideoEncodeH265ProfileInfoKHR *videoCodecOperation =
717 new VkVideoEncodeH265ProfileInfoKHR(getProfileOperationH265Encode(stdProfileIdc));
718 de::MovePtr<VkVideoEncodeH265ProfileInfoKHR> result =
719 de::MovePtr<VkVideoEncodeH265ProfileInfoKHR>(videoCodecOperation);
720
721 return result;
722 }
723
getEncodeUsageInfo(void * pNext,VkVideoEncodeUsageFlagsKHR videoUsageHints,VkVideoEncodeContentFlagsKHR videoContentHints,VkVideoEncodeTuningModeKHR tuningMode)724 de::MovePtr<VkVideoEncodeUsageInfoKHR> getEncodeUsageInfo(void *pNext, VkVideoEncodeUsageFlagsKHR videoUsageHints,
725 VkVideoEncodeContentFlagsKHR videoContentHints,
726 VkVideoEncodeTuningModeKHR tuningMode)
727 {
728 VkVideoEncodeUsageInfoKHR *encodeUsageInfo = new VkVideoEncodeUsageInfoKHR{
729 VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR, // VkStructureType sType
730 pNext, // const void* pNext
731 videoUsageHints, // VkVideoEncodeUsageFlagsKHR videoUsageHints
732 videoContentHints, // VkVideoEncodeContentFlagsKHR videoContentHints
733 tuningMode // VkVideoEncodeTuningModeKHR tuningMode
734 };
735
736 de::MovePtr<VkVideoEncodeUsageInfoKHR> result = de::MovePtr<VkVideoEncodeUsageInfoKHR>(encodeUsageInfo);
737
738 return result;
739 }
740
getVideoProfile(VkVideoCodecOperationFlagBitsKHR videoCodecOperation,void * pNext,VkVideoChromaSubsamplingFlagsKHR chromaSubsampling,VkVideoComponentBitDepthFlagsKHR lumaBitDepth,VkVideoComponentBitDepthFlagsKHR chromaBitDepth)741 de::MovePtr<VkVideoProfileInfoKHR> getVideoProfile(VkVideoCodecOperationFlagBitsKHR videoCodecOperation, void *pNext,
742 VkVideoChromaSubsamplingFlagsKHR chromaSubsampling,
743 VkVideoComponentBitDepthFlagsKHR lumaBitDepth,
744 VkVideoComponentBitDepthFlagsKHR chromaBitDepth)
745 {
746 VkVideoProfileInfoKHR *videoProfile = new VkVideoProfileInfoKHR{
747 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
748 pNext, // void* pNext;
749 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
750 chromaSubsampling, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
751 lumaBitDepth, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
752 chromaBitDepth, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
753 };
754 de::MovePtr<VkVideoProfileInfoKHR> result = de::MovePtr<VkVideoProfileInfoKHR>(videoProfile);
755
756 return result;
757 }
758
getVideoProfileList(const VkVideoProfileInfoKHR * videoProfile,uint32_t profileCount)759 de::MovePtr<VkVideoProfileListInfoKHR> getVideoProfileList(const VkVideoProfileInfoKHR *videoProfile,
760 uint32_t profileCount)
761 {
762 VkVideoProfileListInfoKHR *videoProfileList = new VkVideoProfileListInfoKHR{
763 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, // VkStructureType sType;
764 nullptr, // const void* pNext;
765 profileCount, // uint32_t profileCount;
766 videoProfile, // const VkVideoProfileInfoKHR* pProfiles;
767 };
768
769 de::MovePtr<VkVideoProfileListInfoKHR> result = de::MovePtr<VkVideoProfileListInfoKHR>(videoProfileList);
770
771 return result;
772 }
773
getVideoExtensionProperties(const VkVideoCodecOperationFlagBitsKHR codecOperation)774 const VkExtensionProperties *getVideoExtensionProperties(const VkVideoCodecOperationFlagBitsKHR codecOperation)
775 {
776 switch (codecOperation)
777 {
778 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
779 return &EXTENSION_PROPERTIES_H264_ENCODE;
780 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR:
781 return &EXTENSION_PROPERTIES_H265_ENCODE;
782 case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR:
783 return &EXTENSION_PROPERTIES_AV1_ENCODE;
784 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
785 return &EXTENSION_PROPERTIES_H264_DECODE;
786 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
787 return &EXTENSION_PROPERTIES_H265_DECODE;
788 case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
789 return &EXTENSION_PROPERTIES_AV1_DECODE;
790 default:
791 TCU_THROW(InternalError, "Unkown codec operation");
792 }
793 }
794
getVideoSessionCreateInfo(uint32_t queueFamilyIndex,VkVideoSessionCreateFlagsKHR flags,const VkVideoProfileInfoKHR * videoProfile,const VkExtent2D & codedExtent,VkFormat pictureFormat,VkFormat referencePicturesFormat,uint32_t maxReferencePicturesSlotsCount,uint32_t maxReferencePicturesActiveCount)795 de::MovePtr<VkVideoSessionCreateInfoKHR> getVideoSessionCreateInfo(
796 uint32_t queueFamilyIndex, VkVideoSessionCreateFlagsKHR flags, const VkVideoProfileInfoKHR *videoProfile,
797 const VkExtent2D &codedExtent, VkFormat pictureFormat, VkFormat referencePicturesFormat,
798 uint32_t maxReferencePicturesSlotsCount, uint32_t maxReferencePicturesActiveCount)
799 {
800 const VkExtensionProperties *extensionProperties = getVideoExtensionProperties(videoProfile->videoCodecOperation);
801
802 VkVideoSessionCreateInfoKHR *videoSessionCreateInfo = new VkVideoSessionCreateInfoKHR{
803 VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR, // VkStructureType sType;
804 nullptr, // const void* pNext;
805 queueFamilyIndex, // uint32_t queueFamilyIndex;
806 flags, // VkVideoSessionCreateFlagsKHR flags;
807 videoProfile, // const VkVideoProfileInfoKHR* pVideoProfile;
808 pictureFormat, // VkFormat pictureFormat;
809 codedExtent, // VkExtent2D maxCodedExtent;
810 referencePicturesFormat, // VkFormat referencePicturesFormat;
811 maxReferencePicturesSlotsCount, // uint32_t maxReferencePicturesSlotsCount;
812 maxReferencePicturesActiveCount, // uint32_t maxReferencePicturesActiveCount;
813 extensionProperties, // const VkExtensionProperties* pStdHeaderVersion;
814 };
815
816 de::MovePtr<VkVideoSessionCreateInfoKHR> result = de::MovePtr<VkVideoSessionCreateInfoKHR>(videoSessionCreateInfo);
817
818 return result;
819 }
820
getAndBindVideoSessionMemory(const DeviceInterface & vkd,const VkDevice device,VkVideoSessionKHR videoSession,Allocator & allocator)821 vector<AllocationPtr> getAndBindVideoSessionMemory(const DeviceInterface &vkd, const VkDevice device,
822 VkVideoSessionKHR videoSession, Allocator &allocator)
823 {
824 uint32_t videoSessionMemoryRequirementsCount = 0;
825
826 DE_ASSERT(videoSession != VK_NULL_HANDLE);
827
828 VK_CHECK(
829 vkd.getVideoSessionMemoryRequirementsKHR(device, videoSession, &videoSessionMemoryRequirementsCount, nullptr));
830
831 const VkVideoSessionMemoryRequirementsKHR videoGetMemoryPropertiesKHR = {
832 VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR, // VkStructureType sType;
833 nullptr, // const void* pNext;
834 0u, // uint32_t memoryBindIndex;
835 {0ull, 0ull, 0u}, // VkMemoryRequirements memoryRequirements;
836 };
837
838 vector<VkVideoSessionMemoryRequirementsKHR> videoSessionMemoryRequirements(videoSessionMemoryRequirementsCount,
839 videoGetMemoryPropertiesKHR);
840
841 for (size_t ndx = 0; ndx < videoSessionMemoryRequirements.size(); ++ndx)
842 videoSessionMemoryRequirements[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR;
843
844 VK_CHECK(vkd.getVideoSessionMemoryRequirementsKHR(device, videoSession, &videoSessionMemoryRequirementsCount,
845 videoSessionMemoryRequirements.data()));
846
847 vector<AllocationPtr> allocations(videoSessionMemoryRequirements.size());
848 vector<VkBindVideoSessionMemoryInfoKHR> videoBindsMemoryKHR(videoSessionMemoryRequirements.size());
849
850 for (size_t ndx = 0; ndx < allocations.size(); ++ndx)
851 {
852 const VkMemoryRequirements &requirements = videoSessionMemoryRequirements[ndx].memoryRequirements;
853 const uint32_t memoryBindIndex = videoSessionMemoryRequirements[ndx].memoryBindIndex;
854 de::MovePtr<Allocation> alloc = allocator.allocate(requirements, MemoryRequirement::Any);
855
856 const VkBindVideoSessionMemoryInfoKHR videoBindMemoryKHR = {
857 VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR, // VkStructureType sType;
858 nullptr, // const void* pNext;
859 memoryBindIndex, // uint32_t memoryBindIndex;
860 alloc->getMemory(), // VkDeviceMemory memory;
861 alloc->getOffset(), // VkDeviceSize memoryOffset;
862 requirements.size, // VkDeviceSize memorySize;
863 };
864
865 allocations[ndx] = alloc;
866
867 videoBindsMemoryKHR[ndx] = videoBindMemoryKHR;
868 }
869
870 VK_CHECK(vkd.bindVideoSessionMemoryKHR(device, videoSession, static_cast<uint32_t>(videoBindsMemoryKHR.size()),
871 videoBindsMemoryKHR.data()));
872
873 return allocations;
874 }
875
getSupportedFormats(const InstanceInterface & vk,const VkPhysicalDevice physicalDevice,const VkImageUsageFlags imageUsageFlags,const VkVideoProfileListInfoKHR * videoProfileList)876 de::MovePtr<vector<VkFormat>> getSupportedFormats(const InstanceInterface &vk, const VkPhysicalDevice physicalDevice,
877 const VkImageUsageFlags imageUsageFlags,
878 const VkVideoProfileListInfoKHR *videoProfileList)
879
880 {
881 uint32_t videoFormatPropertiesCount = 0u;
882
883 const VkPhysicalDeviceVideoFormatInfoKHR videoFormatInfo = {
884 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, // VkStructureType sType;
885 videoProfileList, // const void* pNext;
886 imageUsageFlags, // VkImageUsageFlags imageUsage;
887 };
888
889 VkVideoFormatPropertiesKHR videoFormatPropertiesKHR = {};
890 videoFormatPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
891 videoFormatPropertiesKHR.pNext = nullptr;
892
893 vector<VkVideoFormatPropertiesKHR> videoFormatProperties;
894 de::MovePtr<vector<VkFormat>> result;
895
896 const VkResult res = vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, &videoFormatInfo,
897 &videoFormatPropertiesCount, nullptr);
898
899 if (res != VK_SUCCESS)
900 return de::MovePtr<vector<VkFormat>>(nullptr);
901
902 videoFormatProperties.resize(videoFormatPropertiesCount, videoFormatPropertiesKHR);
903
904 VK_CHECK(vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, &videoFormatInfo, &videoFormatPropertiesCount,
905 videoFormatProperties.data()));
906
907 DE_ASSERT(videoFormatPropertiesCount == videoFormatProperties.size());
908
909 result = de::MovePtr<vector<VkFormat>>(new vector<VkFormat>);
910
911 result->reserve(videoFormatProperties.size());
912
913 for (const auto &videoFormatProperty : videoFormatProperties)
914 result->push_back(videoFormatProperty.format);
915
916 return result;
917 }
918
getSupportedFormatProperties(const InstanceInterface & vk,const VkPhysicalDevice physicalDevice,const VkImageUsageFlags imageUsageFlags,void * pNext,const VkFormat format)919 VkVideoFormatPropertiesKHR getSupportedFormatProperties(const InstanceInterface &vk,
920 const VkPhysicalDevice physicalDevice,
921 const VkImageUsageFlags imageUsageFlags, void *pNext,
922 const VkFormat format)
923
924 {
925 if (format == VK_FORMAT_UNDEFINED)
926 return VkVideoFormatPropertiesKHR();
927
928 uint32_t videoFormatPropertiesCount = 0u;
929
930 const VkPhysicalDeviceVideoFormatInfoKHR videoFormatInfo = {
931 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, // VkStructureType sType;
932 pNext, // const void* pNext;
933 imageUsageFlags, // VkImageUsageFlags imageUsage;
934 };
935
936 VkVideoFormatPropertiesKHR videoFormatPropertiesKHR = {};
937 videoFormatPropertiesKHR.sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
938 videoFormatPropertiesKHR.pNext = nullptr;
939
940 vector<VkVideoFormatPropertiesKHR> videoFormatProperties;
941
942 const VkResult res = vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, &videoFormatInfo,
943 &videoFormatPropertiesCount, nullptr);
944
945 if (res != VK_SUCCESS)
946 return VkVideoFormatPropertiesKHR();
947
948 videoFormatProperties.resize(videoFormatPropertiesCount, videoFormatPropertiesKHR);
949
950 VK_CHECK(vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, &videoFormatInfo, &videoFormatPropertiesCount,
951 videoFormatProperties.data()));
952
953 DE_ASSERT(videoFormatPropertiesCount == videoFormatProperties.size());
954
955 for (const auto &videoFormatProperty : videoFormatProperties)
956 {
957 if (videoFormatProperty.format == format)
958 return videoFormatProperty;
959 };
960
961 TCU_THROW(NotSupportedError, "Video format not found in properties list");
962 }
963
validateVideoExtent(const VkExtent2D & codedExtent,const VkVideoCapabilitiesKHR & videoCapabilities)964 bool validateVideoExtent(const VkExtent2D &codedExtent, const VkVideoCapabilitiesKHR &videoCapabilities)
965 {
966 if (!de::inRange(codedExtent.width, videoCapabilities.minCodedExtent.width, videoCapabilities.maxCodedExtent.width))
967 TCU_THROW(NotSupportedError, "Video width does not fit capabilities");
968
969 if (!de::inRange(codedExtent.height, videoCapabilities.minCodedExtent.height,
970 videoCapabilities.maxCodedExtent.height))
971 TCU_THROW(NotSupportedError, "Video height does not fit capabilities");
972
973 return true;
974 }
975
validateFormatSupport(const InstanceInterface & vk,VkPhysicalDevice physicalDevice,const VkImageUsageFlags imageUsageFlags,const VkVideoProfileListInfoKHR * videoProfileList,const VkFormat format,bool throwException)976 bool validateFormatSupport(const InstanceInterface &vk, VkPhysicalDevice physicalDevice,
977 const VkImageUsageFlags imageUsageFlags, const VkVideoProfileListInfoKHR *videoProfileList,
978 const VkFormat format, bool throwException)
979 {
980 de::MovePtr<vector<VkFormat>> supportedVideoFormats =
981 getSupportedFormats(vk, physicalDevice, imageUsageFlags, videoProfileList);
982
983 if (supportedVideoFormats)
984 {
985 if (supportedVideoFormats->size() == 0)
986 if (throwException)
987 TCU_THROW(NotSupportedError, "Supported video formats count is 0");
988
989 for (const auto &supportedVideoFormat : *supportedVideoFormats)
990 {
991 if (supportedVideoFormat == format)
992 return true;
993 }
994
995 if (throwException)
996 TCU_THROW(NotSupportedError, "Required format is not supported for video");
997 }
998 else
999 {
1000 if (throwException)
1001 TCU_THROW(NotSupportedError, "Separate DPB and DST buffers expected");
1002 }
1003
1004 return false;
1005 }
1006
getImageFormatProperties(const InstanceInterface & vk,VkPhysicalDevice physicalDevice,const VkVideoProfileListInfoKHR * videoProfileList,const VkFormat format,const VkImageUsageFlags usage)1007 const VkImageFormatProperties getImageFormatProperties(const InstanceInterface &vk, VkPhysicalDevice physicalDevice,
1008 const VkVideoProfileListInfoKHR *videoProfileList,
1009 const VkFormat format, const VkImageUsageFlags usage)
1010 {
1011 /*
1012 VkImageFormatProperties imageFormatProperties =
1013 {
1014 {0,0}, // VkExtent3D maxExtent;
1015 0, // uint32_t maxMipLevels;
1016 0, // uint32_t maxArrayLayers;
1017 0, // VkSampleCountFlags sampleCounts;
1018 0, // VkDeviceSize maxResourceSize;
1019 };
1020
1021 VK_CHECK(vk.getPhysicalDeviceImageFormatProperties(physicalDevice, format, VK_IMAGE_TYPE_2D, VK_IMAGE_TILING_OPTIMAL, usage, static_cast<VkImageCreateFlags>(0), &imageFormatProperties));
1022
1023 return imageFormatProperties;
1024 */
1025
1026 VkPhysicalDeviceImageFormatInfo2 imageFormatInfo = {};
1027 imageFormatInfo.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
1028 imageFormatInfo.pNext = videoProfileList;
1029 imageFormatInfo.format = format;
1030 imageFormatInfo.usage = usage;
1031
1032 VkSamplerYcbcrConversionImageFormatProperties samplerYcbcrConversionImage = {};
1033 samplerYcbcrConversionImage.sType = vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
1034 samplerYcbcrConversionImage.pNext = nullptr;
1035
1036 VkImageFormatProperties2 imageFormatProperties2 = {};
1037 imageFormatProperties2.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
1038 imageFormatProperties2.pNext = &samplerYcbcrConversionImage;
1039
1040 VK_CHECK(vk.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &imageFormatProperties2));
1041
1042 return imageFormatProperties2.imageFormatProperties;
1043 }
1044
getProfileOperationH264Decode(StdVideoH264ProfileIdc stdProfileIdc,VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout)1045 VkVideoDecodeH264ProfileInfoKHR getProfileOperationH264Decode(StdVideoH264ProfileIdc stdProfileIdc,
1046 VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout)
1047 {
1048 const VkVideoDecodeH264ProfileInfoKHR videoProfileOperation = {
1049 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, // VkStructureType sType;
1050 nullptr, // const void* pNext;
1051 stdProfileIdc, // StdVideoH264ProfileIdc stdProfileIdc;
1052 pictureLayout, // VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout;
1053 };
1054
1055 return videoProfileOperation;
1056 }
1057
getProfileOperationH264Encode(StdVideoH264ProfileIdc stdProfileIdc)1058 VkVideoEncodeH264ProfileInfoKHR getProfileOperationH264Encode(StdVideoH264ProfileIdc stdProfileIdc)
1059 {
1060 const VkVideoEncodeH264ProfileInfoKHR videoProfileOperation = {
1061 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, // VkStructureType sType;
1062 nullptr, // const void* pNext;
1063 stdProfileIdc, // StdVideoH264ProfileIdc stdProfileIdc;
1064 };
1065
1066 return videoProfileOperation;
1067 }
1068
getProfileOperationH265Decode(StdVideoH265ProfileIdc stdProfileIdc)1069 VkVideoDecodeH265ProfileInfoKHR getProfileOperationH265Decode(StdVideoH265ProfileIdc stdProfileIdc)
1070 {
1071 const VkVideoDecodeH265ProfileInfoKHR videoProfileOperation = {
1072 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, // VkStructureType sType;
1073 nullptr, // const void* pNext;
1074 stdProfileIdc, // StdVideoH265ProfileIdc stdProfileIdc;
1075 };
1076
1077 return videoProfileOperation;
1078 }
1079
getProfileOperationH265Encode(StdVideoH265ProfileIdc stdProfileIdc)1080 VkVideoEncodeH265ProfileInfoKHR getProfileOperationH265Encode(StdVideoH265ProfileIdc stdProfileIdc)
1081 {
1082 const VkVideoEncodeH265ProfileInfoKHR videoProfileOperation = {
1083 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, // VkStructureType sType;
1084 nullptr, // const void* pNext;
1085 stdProfileIdc, // StdVideoH265ProfileIdc stdProfileIdc;
1086 };
1087
1088 return videoProfileOperation;
1089 }
1090
getProfileOperationAV1Decode(StdVideoAV1Profile stdProfile,bool filmgrainSupport)1091 VkVideoDecodeAV1ProfileInfoKHR getProfileOperationAV1Decode(StdVideoAV1Profile stdProfile, bool filmgrainSupport)
1092 {
1093 const VkVideoDecodeAV1ProfileInfoKHR videoProfileOperation = {
1094 VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR,
1095 nullptr,
1096 stdProfile,
1097 filmgrainSupport,
1098 };
1099
1100 return videoProfileOperation;
1101 }
1102
getProfileOperationAV1Encode(StdVideoAV1Profile stdProfile)1103 VkVideoEncodeAV1ProfileInfoKHR getProfileOperationAV1Encode(StdVideoAV1Profile stdProfile)
1104 {
1105 const VkVideoEncodeAV1ProfileInfoKHR videoProfileOperation = {
1106 VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR,
1107 nullptr,
1108 stdProfile,
1109 };
1110
1111 return videoProfileOperation;
1112 }
1113
makeImageCreateInfo(VkFormat format,const VkExtent2D & extent,const VkImageCreateFlags flags,const uint32_t * queueFamilyIndex,const VkImageUsageFlags usage,void * pNext,const uint32_t arrayLayers,const VkImageLayout initialLayout,const VkImageTiling tiling)1114 VkImageCreateInfo makeImageCreateInfo(VkFormat format, const VkExtent2D &extent, const VkImageCreateFlags flags,
1115 const uint32_t *queueFamilyIndex, const VkImageUsageFlags usage, void *pNext,
1116 const uint32_t arrayLayers, const VkImageLayout initialLayout,
1117 const VkImageTiling tiling)
1118 {
1119
1120 const VkExtent3D extent3D = makeExtent3D(extent.width, extent.height, 1u);
1121
1122 const VkImageCreateInfo imageCreateInfo = {
1123 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
1124 pNext, // const void* pNext;
1125 flags, // VkImageCreateFlags flags;
1126 VK_IMAGE_TYPE_2D, // VkImageType imageType;
1127 format, // VkFormat format;
1128 extent3D, // VkExtent3D extent;
1129 1, // uint32_t mipLevels;
1130 arrayLayers, // uint32_t arrayLayers;
1131 VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
1132 tiling, // VkImageTiling tiling;
1133 usage, // VkImageUsageFlags usage;
1134 VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
1135 1u, // uint32_t queueFamilyIndexCount;
1136 queueFamilyIndex, // const uint32_t* pQueueFamilyIndices;
1137 initialLayout, // VkImageLayout initialLayout;
1138 };
1139
1140 return imageCreateInfo;
1141 }
1142
getStdVideoH264DecodeSequenceParameterSet(uint32_t width,uint32_t height,StdVideoH264SequenceParameterSetVui * stdVideoH264SequenceParameterSetVui)1143 de::MovePtr<StdVideoH264SequenceParameterSet> getStdVideoH264DecodeSequenceParameterSet(
1144 uint32_t width, uint32_t height, StdVideoH264SequenceParameterSetVui *stdVideoH264SequenceParameterSetVui)
1145 {
1146 const StdVideoH264SpsFlags stdVideoH264SpsFlags = {
1147 0u, // uint32_t constraint_set0_flag:1;
1148 0u, // uint32_t constraint_set1_flag:1;
1149 0u, // uint32_t constraint_set2_flag:1;
1150 0u, // uint32_t constraint_set3_flag:1;
1151 0u, // uint32_t constraint_set4_flag:1;
1152 0u, // uint32_t constraint_set5_flag:1;
1153 1u, // uint32_t direct_8x8_inference_flag:1;
1154 0u, // uint32_t mb_adaptive_frame_field_flag:1;
1155 1u, // uint32_t frame_mbs_only_flag:1;
1156 0u, // uint32_t delta_pic_order_always_zero_flag:1;
1157 0u, // uint32_t separate_colour_plane_flag:1;
1158 0u, // uint32_t gaps_in_frame_num_value_allowed_flag:1;
1159 0u, // uint32_t qpprime_y_zero_transform_bypass_flag:1;
1160 0u, // uint32_t frame_cropping_flag:1;
1161 0u, // uint32_t seq_scaling_matrix_present_flag:1;
1162 0u, // uint32_t vui_parameters_present_flag:1;
1163 };
1164
1165 const StdVideoH264SequenceParameterSet stdVideoH264SequenceParameterSet = {
1166 stdVideoH264SpsFlags, // StdVideoH264SpsFlags flags;
1167 STD_VIDEO_H264_PROFILE_IDC_BASELINE, // StdVideoH264ProfileIdc profile_idc;
1168 STD_VIDEO_H264_LEVEL_IDC_4_1, // StdVideoH264Level level_idc;
1169 STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, // StdVideoH264ChromaFormatIdc chroma_format_idc;
1170 0u, // uint8_t seq_parameter_set_id;
1171 0u, // uint8_t bit_depth_luma_minus8;
1172 0u, // uint8_t bit_depth_chroma_minus8;
1173 0u, // uint8_t log2_max_frame_num_minus4;
1174 STD_VIDEO_H264_POC_TYPE_2, // StdVideoH264PocType pic_order_cnt_type;
1175 0, // int32_t offset_for_non_ref_pic;
1176 0, // int32_t offset_for_top_to_bottom_field;
1177 0u, // uint8_t log2_max_pic_order_cnt_lsb_minus4;
1178 0u, // uint8_t num_ref_frames_in_pic_order_cnt_cycle;
1179 3u, // uint8_t max_num_ref_frames;
1180 0u, // uint8_t reserved1;
1181 (width + 15) / 16 - 1, // uint32_t pic_width_in_mbs_minus1;
1182 (height + 15) / 16 - 1, // uint32_t pic_height_in_map_units_minus1;
1183 0u, // uint32_t frame_crop_left_offset;
1184 0u, // uint32_t frame_crop_right_offset;
1185 0u, // uint32_t frame_crop_top_offset;
1186 0u, // uint32_t frame_crop_bottom_offset;
1187 0u, // uint32_t reserved2;
1188 nullptr, // const int32_t* pOffsetForRefFrame;
1189 nullptr, // const StdVideoH264ScalingLists* pScalingLists;
1190 stdVideoH264SequenceParameterSetVui, // const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui;
1191 };
1192
1193 return de::MovePtr<StdVideoH264SequenceParameterSet>(
1194 new StdVideoH264SequenceParameterSet(stdVideoH264SequenceParameterSet));
1195 }
1196
getStdVideoH264EncodeSequenceParameterSet(uint32_t width,uint32_t height,uint8_t maxNumRefs,StdVideoH264SequenceParameterSetVui * stdVideoH264SequenceParameterSetVui)1197 de::MovePtr<StdVideoH264SequenceParameterSet> getStdVideoH264EncodeSequenceParameterSet(
1198 uint32_t width, uint32_t height, uint8_t maxNumRefs,
1199 StdVideoH264SequenceParameterSetVui *stdVideoH264SequenceParameterSetVui)
1200 {
1201 const StdVideoH264SpsFlags stdVideoH264SpsFlags = {
1202 0u, // uint32_t constraint_set0_flag:1;
1203 0u, // uint32_t constraint_set1_flag:1;
1204 0u, // uint32_t constraint_set2_flag:1;
1205 0u, // uint32_t constraint_set3_flag:1;
1206 0u, // uint32_t constraint_set4_flag:1;
1207 0u, // uint32_t constraint_set5_flag:1;
1208 1u, // uint32_t direct_8x8_inference_flag:1;
1209 0u, // uint32_t mb_adaptive_frame_field_flag:1;
1210 1u, // uint32_t frame_mbs_only_flag:1;
1211 0u, // uint32_t delta_pic_order_always_zero_flag:1;
1212 0u, // uint32_t separate_colour_plane_flag:1;
1213 0u, // uint32_t gaps_in_frame_num_value_allowed_flag:1;
1214 0u, // uint32_t qpprime_y_zero_transform_bypass_flag:1;
1215 0u, // uint32_t frame_cropping_flag:1;
1216 0u, // uint32_t seq_scaling_matrix_present_flag:1;
1217 0u, // uint32_t vui_parameters_present_flag:1;
1218 };
1219
1220 const StdVideoH264SequenceParameterSet stdVideoH264SequenceParameterSet = {
1221 stdVideoH264SpsFlags, // StdVideoH264SpsFlags flags;
1222 STD_VIDEO_H264_PROFILE_IDC_MAIN, // StdVideoH264ProfileIdc profile_idc;
1223 // ResourceError (videoDeviceDriver.getEncodedVideoSessionParametersKHR(videoDevice, &videoEncodeSessionParametersGetInfo, &videoEncodeSessionParametersFeedbackInfo, &bitstreamBufferOffset, nullptr): VK_ERROR_OUT_OF_HOST_MEMORY at vktVideoEncodeTests.cpp:1386)
1224 //STD_VIDEO_H264_PROFILE_IDC_MAIN, // StdVideoH264ProfileIdc profile_idc;
1225 STD_VIDEO_H264_LEVEL_IDC_4_1, // StdVideoH264Level level_idc;
1226 //STD_VIDEO_H264_LEVEL_IDC_1_1, // StdVideoH264Level level_idc;
1227 STD_VIDEO_H264_CHROMA_FORMAT_IDC_420, // StdVideoH264ChromaFormatIdc chroma_format_idc;
1228 0u, // uint8_t seq_parameter_set_id;
1229 0u, // uint8_t bit_depth_luma_minus8;
1230 0u, // uint8_t bit_depth_chroma_minus8;
1231 0u, // uint8_t log2_max_frame_num_minus4;
1232 STD_VIDEO_H264_POC_TYPE_0, // StdVideoH264PocType pic_order_cnt_type;
1233 0, // int32_t offset_for_non_ref_pic;
1234 0, // int32_t offset_for_top_to_bottom_field;
1235 4u, // uint8_t log2_max_pic_order_cnt_lsb_minus4;
1236 0u, // uint8_t num_ref_frames_in_pic_order_cnt_cycle;
1237 maxNumRefs, // uint8_t max_num_ref_frames;
1238 0u, // uint8_t reserved1;
1239 static_cast<uint32_t>(std::ceil(width / 16.0) - 1), // uint32_t pic_width_in_mbs_minus1;
1240 static_cast<uint32_t>(std::ceil(height / 16.0) - 1), // uint32_t pic_height_in_map_units_minus1;
1241 0u, // uint32_t frame_crop_left_offset;
1242 0u, // uint32_t frame_crop_right_offset;
1243 0u, // uint32_t frame_crop_top_offset;
1244 0u, // uint32_t frame_crop_bottom_offset;
1245 0u, // uint32_t reserved2;
1246 nullptr, // const int32_t* pOffsetForRefFrame;
1247 nullptr, // const StdVideoH264ScalingLists* pScalingLists;
1248 stdVideoH264SequenceParameterSetVui, // const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui;
1249 };
1250
1251 return de::MovePtr<StdVideoH264SequenceParameterSet>(
1252 new StdVideoH264SequenceParameterSet(stdVideoH264SequenceParameterSet));
1253 }
1254
getStdVideoH264EncodePictureParameterSet(uint8_t numL0,uint8_t numL1)1255 de::MovePtr<StdVideoH264PictureParameterSet> getStdVideoH264EncodePictureParameterSet(uint8_t numL0, uint8_t numL1)
1256 {
1257 const StdVideoH264PpsFlags stdVideoH264PpsFlags = {
1258 0u, // uint32_t transform_8x8_mode_flag:1;
1259 0u, // uint32_t redundant_pic_cnt_present_flag:1;
1260 0u, // uint32_t constrained_intra_pred_flag:1;
1261 1u, // uint32_t deblocking_filter_control_present_flag:1;
1262 0u, // uint32_t weighted_pred_flag:1;
1263 0u, // uint32_4 bottom_field_pic_order_in_frame_present_flag:1;
1264 1u, // uint32_t entropy_coding_mode_flag:1;
1265 0u, // uint32_t pic_scaling_matrix_present_flag;
1266 };
1267
1268 const StdVideoH264PictureParameterSet stdVideoH264PictureParameterSet = {
1269 stdVideoH264PpsFlags, // StdVideoH264PpsFlags flags;
1270 0u, // uint8_t seq_parameter_set_id;
1271 0u, // uint8_t pic_parameter_set_id;
1272 static_cast<uint8_t>(numL0 ? numL0 - 1 : 0), // uint8_t num_ref_idx_l0_default_active_minus1;
1273 static_cast<uint8_t>(numL1 ? numL1 - 1 : 0), // uint8_t num_ref_idx_l1_default_active_minus1;
1274 STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, // StdVideoH264WeightedBipredIdc weighted_bipred_idc;
1275 0, // int8_t pic_init_qp_minus26;
1276 0, // int8_t pic_init_qs_minus26;
1277 0, // int8_t chroma_qp_index_offset;
1278 0, // int8_t second_chroma_qp_index_offset;
1279 nullptr, // const StdVideoH264ScalingLists* pScalingLists;
1280 };
1281
1282 return de::MovePtr<StdVideoH264PictureParameterSet>(
1283 new StdVideoH264PictureParameterSet(stdVideoH264PictureParameterSet));
1284 }
1285
createVideoEncodeH264SessionParametersAddInfoKHR(uint32_t stdSPSCount,const StdVideoH264SequenceParameterSet * pStdSPSs,uint32_t stdPPSCount,const StdVideoH264PictureParameterSet * pStdPPSs)1286 de::MovePtr<VkVideoEncodeH264SessionParametersAddInfoKHR> createVideoEncodeH264SessionParametersAddInfoKHR(
1287 uint32_t stdSPSCount, const StdVideoH264SequenceParameterSet *pStdSPSs, uint32_t stdPPSCount,
1288 const StdVideoH264PictureParameterSet *pStdPPSs)
1289 {
1290 VkVideoEncodeH264SessionParametersAddInfoKHR videoEncodeH264SessionParametersAddInfoKHR = {
1291 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR, // VkStructureType sType
1292 nullptr, // const void* pNext
1293 stdSPSCount, // uint32_t stdSPSCount
1294 pStdSPSs, // const StdVideoH264SequenceParameterSet* pStdSPSs
1295 stdPPSCount, // uint32_t stdPPSCount
1296 pStdPPSs // const StdVideoH264PictureParameterSet* pStdPPSs
1297 };
1298
1299 return de::MovePtr<VkVideoEncodeH264SessionParametersAddInfoKHR>(
1300 new VkVideoEncodeH264SessionParametersAddInfoKHR(videoEncodeH264SessionParametersAddInfoKHR));
1301 }
1302
createVideoEncodeH264SessionParametersCreateInfoKHR(const void * pNext,uint32_t maxStdSPSCount,uint32_t maxStdPPSCount,const VkVideoEncodeH264SessionParametersAddInfoKHR * pParametersAddInfo)1303 de::MovePtr<VkVideoEncodeH264SessionParametersCreateInfoKHR> createVideoEncodeH264SessionParametersCreateInfoKHR(
1304 const void *pNext, uint32_t maxStdSPSCount, uint32_t maxStdPPSCount,
1305 const VkVideoEncodeH264SessionParametersAddInfoKHR *pParametersAddInfo)
1306 {
1307 VkVideoEncodeH264SessionParametersCreateInfoKHR videoEncodeH264SessionParametersCreateInfoKHR = {
1308 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR, // VkStructureType sType
1309 pNext, // const void* pNext
1310 maxStdSPSCount, // uint32_t maxStdSPSCount
1311 maxStdPPSCount, // uint32_t maxStdPPSCount
1312 pParametersAddInfo // const VkVideoEncodeH264SessionParametersAddInfoKHR* pParametersAddInfo
1313 };
1314
1315 return de::MovePtr<VkVideoEncodeH264SessionParametersCreateInfoKHR>(
1316 new VkVideoEncodeH264SessionParametersCreateInfoKHR(videoEncodeH264SessionParametersCreateInfoKHR));
1317 }
1318
getStdVideoH265ProfileTierLevel(StdVideoH265ProfileIdc general_profile_idc,StdVideoH265LevelIdc general_level_idc)1319 de::MovePtr<StdVideoH265ProfileTierLevel> getStdVideoH265ProfileTierLevel(StdVideoH265ProfileIdc general_profile_idc,
1320 StdVideoH265LevelIdc general_level_idc)
1321 {
1322 const StdVideoH265ProfileTierLevelFlags stdVideoH265ProfileTierLevelFlags = {
1323 0, // general_tier_flag : 1;
1324 1, // general_progressive_source_flag : 1;
1325 0, // general_interlaced_source_flag : 1;
1326 0, // general_non_packed_constraint_flag : 1;
1327 1, // general_frame_only_constraint_flag : 1;
1328 };
1329
1330 const StdVideoH265ProfileTierLevel stdVideoH265ProfileTierLevelInstance = {
1331 stdVideoH265ProfileTierLevelFlags, // StdVideoH265ProfileTierLevelFlags flags;
1332 general_profile_idc, // StdVideoH265ProfileIdc general_profile_idc;
1333 general_level_idc, // StdVideoH265LevelIdc general_level_idc;
1334 };
1335
1336 return de::MovePtr<StdVideoH265ProfileTierLevel>(
1337 new StdVideoH265ProfileTierLevel(stdVideoH265ProfileTierLevelInstance));
1338 }
1339
getStdVideoH265DecPicBufMgr()1340 de::MovePtr<StdVideoH265DecPicBufMgr> getStdVideoH265DecPicBufMgr()
1341 {
1342 const StdVideoH265DecPicBufMgr stdVideoH265DecPicBufMgrInstance = {
1343 {5}, // max_latency_increase_plus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE];
1344 {4}, // max_dec_pic_buffering_minus1[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE];
1345 {2}, // max_num_reorder_pics[STD_VIDEO_H265_SUBLAYERS_LIST_SIZE];
1346 };
1347
1348 return de::MovePtr<StdVideoH265DecPicBufMgr>(new StdVideoH265DecPicBufMgr(stdVideoH265DecPicBufMgrInstance));
1349 }
1350
getStdVideoH265VideoParameterSet(const StdVideoH265DecPicBufMgr * pDecPicBufMgr,const StdVideoH265ProfileTierLevel * pProfileTierLevel)1351 de::MovePtr<StdVideoH265VideoParameterSet> getStdVideoH265VideoParameterSet(
1352 const StdVideoH265DecPicBufMgr *pDecPicBufMgr, const StdVideoH265ProfileTierLevel *pProfileTierLevel)
1353 {
1354 const StdVideoH265VpsFlags stdVideoH265VpsFlags = {
1355 1, // vps_temporal_id_nesting_flag : 1;
1356 1, // vps_sub_layer_ordering_info_present_flag : 1;
1357 0, // vps_timing_info_present_flag : 1;
1358 0 // vps_poc_proportional_to_timing_flag : 1;
1359 };
1360
1361 const StdVideoH265VideoParameterSet stdVideoH265VideoParameterSet = {
1362 stdVideoH265VpsFlags, // StdVideoH265VpsFlags flags;
1363 0u, // uint8_t vps_video_parameter_set_id;
1364 0u, // uint8_t vps_max_sub_layers_minus1;
1365 0u, // uint8_t reserved1;
1366 0u, // uint8_t reserved2;
1367 0u, // uint32_t vps_num_units_in_tick;
1368 0u, // uint32_t vps_time_scale;
1369 0u, // uint32_t vps_num_ticks_poc_diff_one_minus1;
1370 0u, // uint32_t reserved3;
1371 pDecPicBufMgr, // const StdVideoH265DecPicBufMgr* pDecPicBufMgr;
1372 nullptr, // const StdVideoH265HrdParameters* pHrdParameters;
1373 pProfileTierLevel, // const StdVideoH265ProfileTierLevel* pProfileTierLevel;
1374 };
1375
1376 return de::MovePtr<StdVideoH265VideoParameterSet>(new StdVideoH265VideoParameterSet(stdVideoH265VideoParameterSet));
1377 }
1378
getStdVideoH265ShortTermRefPicSet(StdVideoH265PictureType pictureType,uint32_t frameIdx,uint32_t consecutiveBFrameCount)1379 de::MovePtr<StdVideoH265ShortTermRefPicSet> getStdVideoH265ShortTermRefPicSet(StdVideoH265PictureType pictureType,
1380 uint32_t frameIdx,
1381 uint32_t consecutiveBFrameCount)
1382 {
1383 struct StdVideoH265ShortTermRefPicSet strps = {
1384 StdVideoH265ShortTermRefPicSetFlags(), // StdVideoH265ShortTermRefPicSetFlags flags;
1385 0, // uint32_t delta_idx_minus1;
1386 0, // uint16_t use_delta_flag;
1387 0, // uint16_t abs_delta_rps_minus1;
1388 0, // uint16_t used_by_curr_pic_flag;
1389 1, // uint16_t used_by_curr_pic_s0_flag;
1390 0, // uint16_t used_by_curr_pic_s1_flag;
1391 0, // uint16_t reserved1;
1392 0, // uint8_t reserved2;
1393 0, // uint8_t reserved3;
1394 0, // uint8_t num_negative_pics;
1395 0, // uint8_t num_positive_pics;
1396 {0}, // uint16_t delta_poc_s0_minus1[STD_VIDEO_H265_MAX_DPB_SIZE];
1397 {0}, // uint16_t delta_poc_s1_minus1[STD_VIDEO_H265_MAX_DPB_SIZE];
1398 };
1399
1400 uint32_t frameIdxMod = frameIdx % (consecutiveBFrameCount + 1);
1401
1402 switch (pictureType)
1403 {
1404 case STD_VIDEO_H265_PICTURE_TYPE_P:
1405 strps.num_negative_pics = 1;
1406 break;
1407
1408 case STD_VIDEO_H265_PICTURE_TYPE_B:
1409 strps.used_by_curr_pic_s1_flag = 1;
1410 strps.num_negative_pics = 1;
1411 strps.num_positive_pics = 1;
1412 strps.delta_poc_s1_minus1[0] = (frameIdxMod == 1) ? 1 : 0;
1413 strps.delta_poc_s0_minus1[0] = (frameIdxMod == 2) ? 1 : 0;
1414 break;
1415
1416 default:
1417 // explicitly ignore other variants
1418 break;
1419 }
1420
1421 DE_UNREF(pictureType);
1422
1423 return de::MovePtr<StdVideoH265ShortTermRefPicSet>(new StdVideoH265ShortTermRefPicSet(strps));
1424 }
1425
getStdVideoH265SequenceParameterSetVui(uint32_t vui_time_scale)1426 de::MovePtr<StdVideoH265SequenceParameterSetVui> getStdVideoH265SequenceParameterSetVui(uint32_t vui_time_scale)
1427 {
1428 const StdVideoH265SpsVuiFlags stdVideoH265SpsVuiFlags = {
1429 0, // aspect_ratio_info_present_flag : 1;
1430 0, // overscan_info_present_flag : 1;
1431 0, // overscan_appropriate_flag : 1;
1432 1, // video_signal_type_present_flag : 1;
1433 0, // video_full_range_flag : 1;
1434 0, // colour_description_present_flag : 1;
1435 0, // chroma_loc_info_present_flag : 1;
1436 0, // neutral_chroma_indication_flag : 1;
1437 0, // field_seq_flag : 1;
1438 0, // frame_field_info_present_flag : 1;
1439 0, // default_display_window_flag : 1;
1440 1, // vui_timing_info_present_flag : 1;
1441 0, // vui_poc_proportional_to_timing_flag : 1;
1442 0, // vui_hrd_parameters_present_flag : 1;
1443 0, // bitstream_restriction_flag : 1;
1444 0, // tiles_fixed_structure_flag : 1;
1445 0, // motion_vectors_over_pic_boundaries_flag : 1;
1446 0 // restricted_ref_pic_lists_flag : 1;
1447 };
1448
1449 const StdVideoH265SequenceParameterSetVui stdVideoH265SequenceParameterSetVui = {
1450 stdVideoH265SpsVuiFlags, // flags;
1451 STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED, // aspect_ratio_idc;
1452 0, // sar_width;
1453 0, // sar_height;
1454 1, // video_format;
1455 0, // colour_primaries;
1456 0, // transfer_characteristics;
1457 0, // matrix_coeffs;
1458 0, // chroma_sample_loc_type_top_field;
1459 0, // chroma_sample_loc_type_bottom_field;
1460 0, // reserved1;
1461 0, // reserved2;
1462 0, // def_disp_win_left_offset;
1463 0, // def_disp_win_right_offset;
1464 0, // def_disp_win_top_offset;
1465 0, // def_disp_win_bottom_offset;
1466 1, // vui_num_units_in_tick;
1467 vui_time_scale, // vui_time_scale;
1468 0, // vui_num_ticks_poc_diff_one_minus1;
1469 0, // min_spatial_segmentation_idc;
1470 0, // reserved3;
1471 0, // max_bytes_per_pic_denom;
1472 0, // max_bits_per_min_cu_denom;
1473 0, // log2_max_mv_length_horizontal;
1474 0, // log2_max_mv_length_vertical;
1475 0, // pHrdParameters;
1476 };
1477
1478 return de::MovePtr<StdVideoH265SequenceParameterSetVui>(
1479 new StdVideoH265SequenceParameterSetVui(stdVideoH265SequenceParameterSetVui));
1480 }
1481
getStdVideoH265SequenceParameterSet(uint32_t width,uint32_t height,VkVideoEncodeH265CtbSizeFlagsKHR ctbSizesFlag,VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizesFlag,const StdVideoH265DecPicBufMgr * pDecPicBufMgr,const StdVideoH265ProfileTierLevel * pProfileTierLevel,const StdVideoH265SequenceParameterSetVui * pSequenceParameterSetVui)1482 de::MovePtr<StdVideoH265SequenceParameterSet> getStdVideoH265SequenceParameterSet(
1483 uint32_t width, uint32_t height, VkVideoEncodeH265CtbSizeFlagsKHR ctbSizesFlag,
1484 VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizesFlag, const StdVideoH265DecPicBufMgr *pDecPicBufMgr,
1485 const StdVideoH265ProfileTierLevel *pProfileTierLevel,
1486 const StdVideoH265SequenceParameterSetVui *pSequenceParameterSetVui)
1487 {
1488 const StdVideoH265SpsFlags stdVideoH265SpsFlags = {
1489 1, // sps_temporal_id_nesting_flag : 1;
1490 0, // separate_colour_plane_flag : 1;
1491 1, // conformance_window_flag : 1;
1492 1, // sps_sub_layer_ordering_info_present_flag : 1;
1493 0, // scaling_list_enabled_flag : 1;
1494 0, // sps_scaling_list_data_present_flag : 1;
1495 0, // amp_enabled_flag : 1;
1496 1, // sample_adaptive_offset_enabled_flag : 1;
1497 0, // pcm_enabled_flag : 1;
1498 0, // pcm_loop_filter_disabled_flag : 1;
1499 0, // long_term_ref_pics_present_flag : 1;
1500 1, // sps_temporal_mvp_enabled_flag : 1;
1501 1, // strong_intra_smoothing_enabled_flag : 1;
1502 1, // vui_parameters_present_flag : 1;
1503 0, // sps_extension_present_flag : 1;
1504 0, // sps_range_extension_flag : 1;
1505 0, // transform_skip_rotation_enabled_flag : 1;
1506 0, // transform_skip_context_enabled_flag : 1;
1507 0, // implicit_rdpcm_enabled_flag : 1;
1508 0, // explicit_rdpcm_enabled_flag : 1;
1509 0, // extended_precision_processing_flag : 1;
1510 0, // intra_smoothing_disabled_flag : 1;
1511 0, // high_precision_offsets_enabled_flag : 1;
1512 0, // persistent_rice_adaptation_enabled_flag : 1;
1513 0, // cabac_bypass_alignment_enabled_flag : 1;
1514 0, // sps_scc_extension_flag : 1;
1515 0, // sps_curr_pic_ref_enabled_flag : 1;
1516 0, // palette_mode_enabled_flag : 1;
1517 0, // sps_palette_predictor_initializers_present_flag : 1;
1518 0 // intra_boundary_filtering_disabled_flag : 1;
1519 };
1520
1521 int max_ctb_size = 16;
1522 int min_ctb_size = 64;
1523
1524 if (ctbSizesFlag & VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR)
1525 {
1526 max_ctb_size = 64;
1527 }
1528 else if (ctbSizesFlag & VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR)
1529 {
1530 max_ctb_size = 32;
1531 }
1532
1533 if (ctbSizesFlag & VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR)
1534 {
1535 min_ctb_size = 16;
1536 }
1537 else if (ctbSizesFlag & VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR)
1538 {
1539 min_ctb_size = 32;
1540 }
1541
1542 //DE_UNREF(min_ctb_size);
1543
1544 int min_tb_size = 0;
1545 int max_tb_size = 0;
1546
1547 if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR)
1548 min_tb_size = 4;
1549 else if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR)
1550 min_tb_size = 8;
1551 else if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR)
1552 min_tb_size = 16;
1553 else if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR)
1554 min_tb_size = 32;
1555
1556 if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR)
1557 max_tb_size = 32;
1558 else if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR)
1559 max_tb_size = 16;
1560 else if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR)
1561 max_tb_size = 8;
1562 else if (transformBlockSizesFlag & VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR)
1563 max_tb_size = 4;
1564
1565 uint8_t log2_min_luma_coding_block_size_minus3 = 0; // 8x8 cb is smallest
1566 uint8_t log2_diff_max_min_luma_coding_block_size = static_cast<uint8_t>(std::log2(max_ctb_size) - 3);
1567
1568 uint8_t log2_min_luma_transform_block_size_minus2 = static_cast<uint8_t>(std::log2(min_tb_size) - 2);
1569 uint8_t log2_diff_max_min_luma_transform_block_size =
1570 static_cast<uint8_t>(std::log2(max_tb_size) - std::log2(min_tb_size));
1571
1572 uint8_t max_transform_hierarchy = static_cast<uint8_t>(std::log2(max_ctb_size) - std::log2(min_tb_size));
1573
1574 uint32_t pic_width_in_luma_samples =
1575 static_cast<uint32_t>((std::ceil(static_cast<double>(width) / min_ctb_size)) * min_ctb_size);
1576 uint32_t pic_height_in_luma_samples =
1577 static_cast<uint32_t>((std::ceil(static_cast<double>(height) / min_ctb_size)) * min_ctb_size);
1578
1579 uint32_t conf_win_left_offset = 0;
1580 uint32_t conf_win_right_offset = (pic_width_in_luma_samples - width) / 2;
1581 uint32_t conf_win_top_offset = 0;
1582 uint32_t conf_win_bottom_offset = (pic_height_in_luma_samples - height) / 2;
1583
1584 const StdVideoH265SequenceParameterSet stdVideoH265SequenceParameterSet = {
1585 stdVideoH265SpsFlags, // StdVideoH265SpsFlags flags;
1586 STD_VIDEO_H265_CHROMA_FORMAT_IDC_420, // StdVideoH265ChromaFormatIdc chroma_format_idc;
1587 pic_width_in_luma_samples, // uint32_t pic_width_in_luma_samples;
1588 pic_height_in_luma_samples, // uint32_t pic_height_in_luma_samples;
1589 0u, // uint8_t sps_video_parameter_set_id;
1590 0u, // uint8_t sps_max_sub_layers_minus1;
1591 0u, // uint8_t sps_seq_parameter_set_id;
1592 0u, // uint8_t bit_depth_luma_minus8;
1593 0u, // uint8_t bit_depth_chroma_minus8;
1594 4u, // uint8_t log2_max_pic_order_cnt_lsb_minus;4
1595 log2_min_luma_coding_block_size_minus3, // uint8_t log2_min_luma_coding_block_size_minus3;
1596 log2_diff_max_min_luma_coding_block_size, // uint8_t log2_diff_max_min_luma_coding_block_size;
1597 log2_min_luma_transform_block_size_minus2, // uint8_t log2_min_luma_transform_block_size_minus2;
1598 log2_diff_max_min_luma_transform_block_size, // uint8_t log2_diff_max_min_luma_transform_block_size;
1599 max_transform_hierarchy, // uint8_t max_transform_hierarchy_depth_inter;
1600 max_transform_hierarchy, // uint8_t max_transform_hierarchy_depth_intra;
1601 0u, // uint8_t num_short_term_ref_pic_sets;
1602 0u, // uint8_t num_long_term_ref_pics_sps;
1603 0u, // uint8_t pcm_sample_bit_depth_luma_minus1;
1604 0u, // uint8_t pcm_sample_bit_depth_chroma_minus1;
1605 0u, // uint8_t log2_min_pcm_luma_coding_block_size_minus3;
1606 0u, // uint8_t log2_diff_max_min_pcm_luma_coding_block_size;
1607 0u, // uint8_t reserved1;
1608 0u, // uint8_t reserved2;
1609 0u, // uint8_t palette_max_size;
1610 0u, // uint8_t delta_palette_max_predictor_size;
1611 0u, // uint8_t motion_vector_resolution_control_idc;
1612 0u, // uint8_t sps_num_palette_predictor_initializers_minus1;
1613 conf_win_left_offset, // uint32_t conf_win_left_offset;
1614 conf_win_right_offset, // uint32_t conf_win_right_offset;
1615 conf_win_top_offset, // uint32_t conf_win_top_offset;
1616 conf_win_bottom_offset, // uint32_t conf_win_bottom_offset;
1617 pProfileTierLevel, // const StdVideoH265ProfileTierLevel* pProfileTierLevel;
1618 pDecPicBufMgr, // const StdVideoH265DecPicBufMgr* pDecPicBufMgr;
1619 nullptr, // const StdVideoH265ScalingLists* pScalingLists;
1620 nullptr, // const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet;
1621 nullptr, // const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps;
1622 pSequenceParameterSetVui, // const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui;
1623 nullptr, // const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries;
1624 };
1625
1626 return de::MovePtr<StdVideoH265SequenceParameterSet>(
1627 new StdVideoH265SequenceParameterSet(stdVideoH265SequenceParameterSet));
1628 }
1629
getStdVideoH265PictureParameterSet(const VkVideoEncodeH265CapabilitiesKHR * videoH265CapabilitiesExtension)1630 de::MovePtr<StdVideoH265PictureParameterSet> getStdVideoH265PictureParameterSet(
1631 const VkVideoEncodeH265CapabilitiesKHR *videoH265CapabilitiesExtension)
1632 {
1633 uint32_t weighted_pred_flag =
1634 (videoH265CapabilitiesExtension->stdSyntaxFlags & VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR) ? 1 :
1635 0;
1636 uint32_t transform_skip_enabled_flag = (videoH265CapabilitiesExtension->stdSyntaxFlags &
1637 VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR) ?
1638 1 :
1639 0;
1640 uint32_t entropy_coding_sync_enabled_flag =
1641 (videoH265CapabilitiesExtension->maxTiles.width > 1 || videoH265CapabilitiesExtension->maxTiles.height > 1) ?
1642 1 :
1643 0;
1644
1645 const StdVideoH265PpsFlags stdVideoH265PpsFlags = {
1646 0, // dependent_slice_segments_enabled_flag : 1;
1647 0, // output_flag_present_flag : 1;
1648 0, // sign_data_hiding_enabled_flag : 1;
1649 0, // cabac_init_present_flag : 1;
1650 0, // constrained_intra_pred_flag : 1;
1651 transform_skip_enabled_flag, // transform_skip_enabled_flag : 1;
1652 1, // cu_qp_delta_enabled_flag : 1;
1653 0, // pps_slice_chroma_qp_offsets_present_flag : 1;
1654 weighted_pred_flag, // weighted_pred_flag : 1;
1655 0, // weighted_bipred_flag : 1;
1656 0, // transquant_bypass_enabled_flag : 1;
1657 0, // tiles_enabled_flag : 1;
1658 entropy_coding_sync_enabled_flag, // entropy_coding_sync_enabled_flag : 1;
1659 0, // uniform_spacing_flag : 1;
1660 0, // loop_filter_across_tiles_enabled_flag : 1;
1661 1, // pps_loop_filter_across_slices_enabled_flag : 1;
1662 0, // deblocking_filter_control_present_flag : 1;
1663 0, // deblocking_filter_override_enabled_flag : 1;
1664 0, // pps_deblocking_filter_disabled_flag : 1;
1665 0, // pps_scaling_list_data_present_flag : 1;
1666 0, // lists_modification_present_flag : 1;
1667 0, // slice_segment_header_extension_present_flag : 1;
1668 0, // pps_extension_present_flag : 1;
1669 0, // cross_component_prediction_enabled_flag : 1;
1670 0, // chroma_qp_offset_list_enabled_flag : 1;
1671 0, // pps_curr_pic_ref_enabled_flag : 1;
1672 0, // residual_adaptive_colour_transform_enabled_flag : 1;
1673 0, // pps_slice_act_qp_offsets_present_flag : 1;
1674 0, // pps_palette_predictor_initializers_present_flag : 1;
1675 0, // monochrome_palette_flag : 1;
1676 0, // pps_range_extension_flag : 1;
1677 };
1678
1679 const StdVideoH265PictureParameterSet stdVideoH265PictureParameterSet = {
1680 stdVideoH265PpsFlags, // StdVideoH265PpsFlags flags;
1681 0u, // uint8_t pps_pic_parameter_set_id;
1682 0u, // uint8_t pps_seq_parameter_set_id;
1683 0u, // uint8_t sps_video_parameter_set_id;
1684 0u, // uint8_t num_extra_slice_header_bits;
1685 0u, // uint8_t num_ref_idx_l0_default_active_minus1;
1686 0u, // uint8_t num_ref_idx_l1_default_active_minus1;
1687 0, // int8_t init_qp_minus26;
1688 1u, // uint8_t diff_cu_qp_delta_depth;
1689 0, // int8_t pps_cb_qp_offset;
1690 0, // int8_t pps_cr_qp_offset;
1691 0, // int8_t pps_beta_offset_div2;
1692 0, // int8_t pps_tc_offset_div2;
1693 0u, // uint8_t log2_parallel_merge_level_minus2;
1694 0u, // uint8_t log2_max_transform_skip_block_size_minus2;
1695 0u, // uint8_t diff_cu_chroma_qp_offset_depth;
1696 0u, // uint8_t chroma_qp_offset_list_len_minus1;
1697 {}, // int8_t cb_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
1698 {}, // int8_t cr_qp_offset_list[STD_VIDEO_H265_CHROMA_QP_OFFSET_LIST_SIZE];
1699 0u, // uint8_t log2_sao_offset_scale_luma;
1700 0u, // uint8_t log2_sao_offset_scale_chroma;
1701 0, // int8_t pps_act_y_qp_offset_plus5;
1702 0, // int8_t pps_act_cb_qp_offset_plus5;
1703 0, // int8_t pps_act_cr_qp_offset_plus3;
1704 0u, // uint8_t pps_num_palette_predictor_initializers;
1705 0u, // uint8_t luma_bit_depth_entry_minus8;
1706 0u, // uint8_t chroma_bit_depth_entry_minus8;
1707 0u, // uint8_t num_tile_columns_minus1;
1708 0u, // uint8_t num_tile_rows_minus1;
1709 0u, // uint8_t reserved1;
1710 0u, // uint8_t reserved2;
1711 {}, // uint16_t column_width_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_COLS_LIST_SIZE];
1712 {}, // uint16_t row_height_minus1[STD_VIDEO_H265_CHROMA_QP_OFFSET_TILE_ROWS_LIST_SIZE];
1713 0u, // uint32_t reserved3;
1714 nullptr, // const StdVideoH265ScalingLists* pScalingLists;
1715 nullptr, // const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries;
1716 };
1717
1718 return de::MovePtr<StdVideoH265PictureParameterSet>(
1719 new StdVideoH265PictureParameterSet(stdVideoH265PictureParameterSet));
1720 }
1721
getVideoEncodeH265SessionParametersAddInfoKHR(uint32_t stdVPSCount,const StdVideoH265VideoParameterSet * pStdVPSs,uint32_t stdSPSCount,const StdVideoH265SequenceParameterSet * pStdSPSs,uint32_t stdPPSCount,const StdVideoH265PictureParameterSet * pStdPPSs)1722 de::MovePtr<VkVideoEncodeH265SessionParametersAddInfoKHR> getVideoEncodeH265SessionParametersAddInfoKHR(
1723 uint32_t stdVPSCount, const StdVideoH265VideoParameterSet *pStdVPSs, uint32_t stdSPSCount,
1724 const StdVideoH265SequenceParameterSet *pStdSPSs, uint32_t stdPPSCount,
1725 const StdVideoH265PictureParameterSet *pStdPPSs)
1726 {
1727 VkVideoEncodeH265SessionParametersAddInfoKHR encodeH265SessionParametersAddInfoKHR = {
1728 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR, // VkStructureType sType;
1729 nullptr, // const void* pNext;
1730 stdVPSCount, // uint32_t stdVPSCount;
1731 pStdVPSs, // const StdVideoH265VideoParameterSet* pStdVPSs;
1732 stdSPSCount, // uint32_t stdSPSCount;
1733 pStdSPSs, // const StdVideoH265SequenceParameterSet* pStdSPSs;
1734 stdPPSCount, // uint32_t stdPPSCount;
1735 pStdPPSs // const StdVideoH265PictureParameterSet* pStdPPSs;
1736 };
1737
1738 return de::MovePtr<VkVideoEncodeH265SessionParametersAddInfoKHR>(
1739 new VkVideoEncodeH265SessionParametersAddInfoKHR(encodeH265SessionParametersAddInfoKHR));
1740 }
1741
getVideoEncodeH265SessionParametersCreateInfoKHR(const void * pNext,uint32_t maxStdVPSCount,uint32_t maxStdSPSCount,uint32_t maxStdPPSCount,const VkVideoEncodeH265SessionParametersAddInfoKHR * pParametersAddInfo)1742 de::MovePtr<VkVideoEncodeH265SessionParametersCreateInfoKHR> getVideoEncodeH265SessionParametersCreateInfoKHR(
1743 const void *pNext, uint32_t maxStdVPSCount, uint32_t maxStdSPSCount, uint32_t maxStdPPSCount,
1744 const VkVideoEncodeH265SessionParametersAddInfoKHR *pParametersAddInfo)
1745 {
1746 VkVideoEncodeH265SessionParametersCreateInfoKHR sessionParametersCreateInfoKHR = {
1747 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR, // VkStructureType sType;
1748 pNext, // const void* pNext;
1749 maxStdVPSCount, // uint32_t maxStdVPSCount;
1750 maxStdSPSCount, // uint32_t maxStdSPSCount;
1751 maxStdPPSCount, // uint32_t maxStdPPSCount;
1752 pParametersAddInfo // const VkVideoEncodeH265SessionParametersAddInfoKHR* pParametersAddInfo;
1753 };
1754
1755 return de::MovePtr<VkVideoEncodeH265SessionParametersCreateInfoKHR>(
1756 new VkVideoEncodeH265SessionParametersCreateInfoKHR(sessionParametersCreateInfoKHR));
1757 }
1758
getVideoSessionParametersCreateInfoKHR(const void * pNext,const VkVideoSessionParametersCreateFlagsKHR flags,VkVideoSessionKHR videoSession)1759 de::MovePtr<VkVideoSessionParametersCreateInfoKHR> getVideoSessionParametersCreateInfoKHR(
1760 const void *pNext, const VkVideoSessionParametersCreateFlagsKHR flags, VkVideoSessionKHR videoSession)
1761 {
1762 VkVideoSessionParametersCreateInfoKHR sessionParametersCreateInfo = {
1763 VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR, // VkStructureType sType;
1764 pNext, // const void* pNext;
1765 flags, // VkVideoSessionParametersCreateFlagsKHR flags;
1766 VK_NULL_HANDLE, // VkVideoSessionParametersKHR videoEncodeSessionParametersTemplate;
1767 videoSession, // VkVideoSessionKHR videoEncodeSession;
1768 };
1769
1770 return de::MovePtr<VkVideoSessionParametersCreateInfoKHR>(
1771 new VkVideoSessionParametersCreateInfoKHR(sessionParametersCreateInfo));
1772 }
1773
getStdVideoEncodeH264ReferenceInfo(StdVideoH264PictureType primary_pic_type,uint32_t FrameNum,int32_t PicOrderCnt)1774 de::MovePtr<StdVideoEncodeH264ReferenceInfo> getStdVideoEncodeH264ReferenceInfo(
1775 StdVideoH264PictureType primary_pic_type, uint32_t FrameNum, int32_t PicOrderCnt)
1776 {
1777 const StdVideoEncodeH264ReferenceInfoFlags H264referenceInfoFlags = {
1778 0, // uint32_t used_for_long_term_reference : 1;
1779 0, // uint32_t reserved : 31;
1780 };
1781
1782 const StdVideoEncodeH264ReferenceInfo H264referenceInfo = {
1783 H264referenceInfoFlags, // StdVideoEncodeH264ReferenceInfoFlags flags;
1784 primary_pic_type, // StdVideoH264PictureType primary_pic_type;
1785 FrameNum, // uint32_t FrameNum;
1786 PicOrderCnt, // int32_t PicOrderCnt;
1787 0, // uint16_t long_term_pic_num;
1788 0, // uint16_t long_term_frame_idx;
1789 0, // uint8_t temporal_id;
1790 };
1791
1792 return de::MovePtr<StdVideoEncodeH264ReferenceInfo>(new StdVideoEncodeH264ReferenceInfo(H264referenceInfo));
1793 }
1794
getVideoEncodeH264DpbSlotInfo(const StdVideoEncodeH264ReferenceInfo * pStdReferenceInfo)1795 de::MovePtr<VkVideoEncodeH264DpbSlotInfoKHR> getVideoEncodeH264DpbSlotInfo(
1796 const StdVideoEncodeH264ReferenceInfo *pStdReferenceInfo)
1797 {
1798 const VkVideoEncodeH264DpbSlotInfoKHR h264DpbSlotInfo = {
1799 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR, // VkStructureType sType;
1800 nullptr, // const void* pNext;
1801 pStdReferenceInfo, // const StdVideoEncodeH264ReferenceInfo* pStdReferenceInfo;
1802 };
1803
1804 return de::MovePtr<VkVideoEncodeH264DpbSlotInfoKHR>(new VkVideoEncodeH264DpbSlotInfoKHR(h264DpbSlotInfo));
1805 }
1806
getStdVideoEncodeH265ReferenceInfo(StdVideoH265PictureType pic_type,int32_t PicOrderCntVal)1807 de::MovePtr<StdVideoEncodeH265ReferenceInfo> getStdVideoEncodeH265ReferenceInfo(StdVideoH265PictureType pic_type,
1808 int32_t PicOrderCntVal)
1809 {
1810 const StdVideoEncodeH265ReferenceInfoFlags H265referenceInfoFlags = {
1811 0, // uint32_t used_for_long_term_reference:1;
1812 0, // uint32_t unused_for_reference:1;
1813 0, // uint32_t reserved:30;
1814 };
1815
1816 const StdVideoEncodeH265ReferenceInfo H265referenceInfo = {
1817 H265referenceInfoFlags, // StdVideoEncodeH265ReferenceInfoFlags flags;
1818 pic_type, // StdVideoH265PictureType pic_type;
1819 PicOrderCntVal, // int32_t PicOrderCntVal;
1820 0, // uint8_t TemporalId;
1821 };
1822
1823 return de::MovePtr<StdVideoEncodeH265ReferenceInfo>(new StdVideoEncodeH265ReferenceInfo(H265referenceInfo));
1824 }
1825
getVideoEncodeH265DpbSlotInfo(const StdVideoEncodeH265ReferenceInfo * pStdReferenceInfo)1826 de::MovePtr<VkVideoEncodeH265DpbSlotInfoKHR> getVideoEncodeH265DpbSlotInfo(
1827 const StdVideoEncodeH265ReferenceInfo *pStdReferenceInfo)
1828 {
1829 const VkVideoEncodeH265DpbSlotInfoKHR h265DpbSlotInfo = {
1830 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR, // VkStructureType sType;
1831 nullptr, // const void* pNext;
1832 pStdReferenceInfo, // const StdVideoEncodeH265ReferenceInfo* pStdReferenceInfo;
1833 };
1834
1835 return de::MovePtr<VkVideoEncodeH265DpbSlotInfoKHR>(new VkVideoEncodeH265DpbSlotInfoKHR(h265DpbSlotInfo));
1836 }
1837
getStdVideoEncodeH264SliceHeader(StdVideoH264SliceType sliceType,bool activeOverrideFlag)1838 de::MovePtr<StdVideoEncodeH264SliceHeader> getStdVideoEncodeH264SliceHeader(StdVideoH264SliceType sliceType,
1839 bool activeOverrideFlag)
1840 {
1841 StdVideoEncodeH264SliceHeaderFlags stdVideoEncodeH264SliceHeaderFlag = {
1842 0, // uint32_t direct_spatial_mv_pred_flag : 1;
1843 activeOverrideFlag, // uint32_t num_ref_idx_active_override_flag : 1;
1844 0, // uint32_t reserved : 30;
1845 };
1846
1847 const StdVideoEncodeH264SliceHeader stdVideoEncodeH264SliceHeader = {
1848 stdVideoEncodeH264SliceHeaderFlag, // StdVideoEncodeH264SliceHeaderFlags flags;
1849 0u, // uint32_t first_mb_in_slice;
1850 sliceType, // StdVideoH264SliceType slice_type;
1851 0, // int8_t slice_alpha_c0_offset_div2;
1852 0, // int8_t slice_beta_offset_div2;
1853 0, // int8_t slice_qp_delta;
1854 0u, // uint16_t reserved1;
1855 STD_VIDEO_H264_CABAC_INIT_IDC_0, // StdVideoH264CabacInitIdc cabac_init_idc;
1856 STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED, // StdVideoH264DisableDeblockingFilterIdc disable_deblocking_filter_idc;
1857 nullptr, // const StdVideoEncodeH264WeightTable* pWeightTable;
1858 };
1859
1860 return de::MovePtr<StdVideoEncodeH264SliceHeader>(new StdVideoEncodeH264SliceHeader(stdVideoEncodeH264SliceHeader));
1861 }
1862
getStdVideoEncodeH265SliceSegmentHeader(StdVideoH265SliceType sliceType)1863 de::MovePtr<StdVideoEncodeH265SliceSegmentHeader> getStdVideoEncodeH265SliceSegmentHeader(
1864 StdVideoH265SliceType sliceType)
1865 {
1866 StdVideoEncodeH265SliceSegmentHeaderFlags stdVideoEncodeH265SliceSegmentHeaderFlags = {
1867 1, // first_slice_segment_in_pic_flag;
1868 0, // dependent_slice_segment_flag;
1869 1, // slice_sao_luma_flag;
1870 1, // slice_sao_chroma_flag;
1871 0, // num_ref_idx_active_override_flag;
1872 0, // mvd_l1_zero_flag;
1873 0, // cabac_init_flag;
1874 1, // cu_chroma_qp_offset_enabled_flag;
1875 1, // deblocking_filter_override_flag;
1876 0, // slice_deblocking_filter_disabled_flag;
1877 0, // collocated_from_l0_flag;
1878 0, // slice_loop_filter_across_slices_enabled_flag;
1879 0, // reserved
1880 };
1881
1882 const StdVideoEncodeH265SliceSegmentHeader stdVideoEncodeH265SliceSegmentHeader = {
1883 stdVideoEncodeH265SliceSegmentHeaderFlags, // StdVideoEncodeH265SliceSegmentHeaderFlags flags;
1884 sliceType, // StdVideoH265SliceType slice_type;
1885 0u, // uint32_t slice_segment_address;
1886 0u, // uint8_t collocated_ref_idx;
1887 5u, // uint8_t MaxNumMergeCand;
1888 0, // int8_t slice_cb_qp_offset;
1889 0, // int8_t slice_cr_qp_offset;
1890 0, // int8_t slice_beta_offset_div2;
1891 0, // int8_t slice_tc_offset_div2;
1892 0, // int8_t slice_act_y_qp_offset;
1893 0, // int8_t slice_act_cb_qp_offset;
1894 0, // int8_t slice_act_cr_qp_offset;
1895 0, // int8_t slice_qp_delta;
1896 0, // uint16_t reserved1;
1897 nullptr // const StdVideoEncodeH265WeightTable* pWeightTable;
1898 };
1899
1900 return de::MovePtr<StdVideoEncodeH265SliceSegmentHeader>(
1901 new StdVideoEncodeH265SliceSegmentHeader(stdVideoEncodeH265SliceSegmentHeader));
1902 }
1903
getVideoEncodeH264NaluSlice(StdVideoEncodeH264SliceHeader * stdVideoEncodeH264SliceHeader,const int32_t qpValue)1904 de::MovePtr<VkVideoEncodeH264NaluSliceInfoKHR> getVideoEncodeH264NaluSlice(
1905 StdVideoEncodeH264SliceHeader *stdVideoEncodeH264SliceHeader, const int32_t qpValue)
1906 {
1907 const VkVideoEncodeH264NaluSliceInfoKHR videoEncodeH264NaluSlice = {
1908 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR, // VkStructureType sType;
1909 nullptr, // const void* pNext;
1910 qpValue, // uint32_t constantQp;
1911 stdVideoEncodeH264SliceHeader, // const StdVideoEncodeH264SliceHeader* pStdSliceHeader
1912 };
1913
1914 return de::MovePtr<VkVideoEncodeH264NaluSliceInfoKHR>(
1915 new VkVideoEncodeH264NaluSliceInfoKHR(videoEncodeH264NaluSlice));
1916 }
1917
getVideoEncodeH265NaluSliceSegment(StdVideoEncodeH265SliceSegmentHeader * stdVideoEncodeH265SliceSegmentHeader,const int32_t qpValue)1918 de::MovePtr<VkVideoEncodeH265NaluSliceSegmentInfoKHR> getVideoEncodeH265NaluSliceSegment(
1919 StdVideoEncodeH265SliceSegmentHeader *stdVideoEncodeH265SliceSegmentHeader, const int32_t qpValue)
1920 {
1921 const VkVideoEncodeH265NaluSliceSegmentInfoKHR videoEncodeH265NaluSliceSegmentInfoKHR = {
1922 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR, // VkStructureType sType;
1923 nullptr, // const void* pNext;
1924 qpValue, // int32_t constantQp;
1925 stdVideoEncodeH265SliceSegmentHeader // const StdVideoEncodeH265SliceSegmentHeader* pStdSliceSegmentHeader;
1926 };
1927
1928 return de::MovePtr<VkVideoEncodeH265NaluSliceSegmentInfoKHR>(
1929 new VkVideoEncodeH265NaluSliceSegmentInfoKHR(videoEncodeH265NaluSliceSegmentInfoKHR));
1930 }
1931
getVideoEncodeH264ReferenceListsInfo(uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF],uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF],uint8_t numL0,uint8_t numL1)1932 de::MovePtr<StdVideoEncodeH264ReferenceListsInfo> getVideoEncodeH264ReferenceListsInfo(
1933 uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF], uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF],
1934 uint8_t numL0, uint8_t numL1)
1935 {
1936 const StdVideoEncodeH264ReferenceListsInfoFlags videoEncodeH264ReferenceListsInfoFlags{
1937 0, // uint32_t ref_pic_list_modification_flag_l0:1;
1938 0, // uint32_t ref_pic_list_modification_flag_l1:1;
1939 0, // uint32_t reserved:30;
1940 };
1941
1942 StdVideoEncodeH264ReferenceListsInfo videoEncodeH264ReferenceListsInfo = {
1943 videoEncodeH264ReferenceListsInfoFlags, // StdVideoEncodeH264ReferenceListsInfoFlags flags;
1944 static_cast<uint8_t>(numL0 ? numL0 - 1 : 0), // uint8_t num_ref_idx_l0_active_minus1;
1945 static_cast<uint8_t>(numL1 ? numL1 - 1 : 0), // uint8_t num_ref_idx_l1_active_minus1;
1946 {}, // uint8_t RefPicList0[STD_VIDEO_H264_MAX_NUM_LIST_REF];
1947 {}, // uint8_t RefPicList1[STD_VIDEO_H264_MAX_NUM_LIST_REF];
1948 0, // uint8_t refList0ModOpCount;
1949 0, // uint8_t refList1ModOpCount;
1950 0, // uint8_t refPicMarkingOpCount;
1951 {0, 0, 0, 0, 0, 0, 0}, // uint8_t reserved1[7];
1952 nullptr, // const StdVideoEncodeH264RefListModEntry* pRefList0ModOperations;
1953 nullptr, // const StdVideoEncodeH264RefListModEntry* pRefList1ModOperations;
1954 nullptr, // const StdVideoEncodeH264RefPicMarkingEntry* pRefPicMarkingOperations;
1955 };
1956
1957 for (int i = 0; i < STD_VIDEO_H264_MAX_NUM_LIST_REF; ++i)
1958 {
1959 videoEncodeH264ReferenceListsInfo.RefPicList0[i] = RefPicList0[i];
1960 videoEncodeH264ReferenceListsInfo.RefPicList1[i] = RefPicList1[i];
1961 }
1962
1963 return de::MovePtr<StdVideoEncodeH264ReferenceListsInfo>(
1964 new StdVideoEncodeH264ReferenceListsInfo(videoEncodeH264ReferenceListsInfo));
1965 }
1966
getVideoEncodeH265ReferenceListsInfo(uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF],uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF])1967 de::MovePtr<StdVideoEncodeH265ReferenceListsInfo> getVideoEncodeH265ReferenceListsInfo(
1968 uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF], uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF])
1969 {
1970 const StdVideoEncodeH265ReferenceListsInfoFlags videoEncodeH265ReferenceListsInfoFlags{
1971 0, // uint32_t ref_pic_list_modification_flag_l0:1;
1972 0, // uint32_t ref_pic_list_modification_flag_l1:1;
1973 0, // uint32_t reserved:30;
1974 };
1975
1976 StdVideoEncodeH265ReferenceListsInfo videoEncodeH265ReferenceListsInfo = {
1977 videoEncodeH265ReferenceListsInfoFlags, // StdVideoEncodeH264ReferenceListsInfoFlags flags;
1978 0, // uint8_t num_ref_idx_l0_active_minus1;
1979 0, // uint8_t num_ref_idx_l1_active_minus1;
1980 {}, // uint8_t RefPicList0[STD_VIDEO_H265_MAX_NUM_LIST_REF];
1981 {}, // uint8_t RefPicList1[STD_VIDEO_H265_MAX_NUM_LIST_REF];
1982 {}, // uint8_t list_entry_l0[STD_VIDEO_H265_MAX_NUM_LIST_REF];
1983 {}, // uint8_t list_entry_l1[STD_VIDEO_H265_MAX_NUM_LIST_REF];
1984 };
1985
1986 for (int i = 0; i < STD_VIDEO_H265_MAX_NUM_LIST_REF; ++i)
1987 {
1988 videoEncodeH265ReferenceListsInfo.RefPicList0[i] = RefPicList0[i];
1989 videoEncodeH265ReferenceListsInfo.RefPicList1[i] = RefPicList1[i];
1990 }
1991
1992 return de::MovePtr<StdVideoEncodeH265ReferenceListsInfo>(
1993 new StdVideoEncodeH265ReferenceListsInfo(videoEncodeH265ReferenceListsInfo));
1994 }
1995
getStdVideoEncodeH264PictureInfo(StdVideoH264PictureType pictureType,uint32_t frameNum,int32_t PicOrderCnt,uint16_t idr_pic_id,const StdVideoEncodeH264ReferenceListsInfo * pRefLists)1996 de::MovePtr<StdVideoEncodeH264PictureInfo> getStdVideoEncodeH264PictureInfo(
1997 StdVideoH264PictureType pictureType, uint32_t frameNum, int32_t PicOrderCnt, uint16_t idr_pic_id,
1998 const StdVideoEncodeH264ReferenceListsInfo *pRefLists)
1999 {
2000 const StdVideoEncodeH264PictureInfoFlags pictureInfoFlags = {
2001 (pictureType == STD_VIDEO_H264_PICTURE_TYPE_IDR), // uint32_t idr_flag : 1;
2002 (pictureType != STD_VIDEO_H264_PICTURE_TYPE_B), // uint32_t is_reference_flag : 1;
2003 0, // uint32_t no_output_of_prior_pics_flag : 1;
2004 0, // uint32_t long_term_reference_flag : 1;
2005 0, // uint32_t adaptive_ref_pic_marking_mode_flag : 1;
2006 0, // uint32_t reserved : 27;
2007 };
2008
2009 const StdVideoEncodeH264PictureInfo pictureInfo = {
2010 pictureInfoFlags, // StdVideoEncodeH264PictureInfoFlags flags;
2011 0u, // uint8_t seq_parameter_set_id;
2012 0u, // uint8_t pic_parameter_set_id;
2013 idr_pic_id, // uint16_t idr_pic_id;
2014 pictureType, // StdVideoH264PictureType pictureType;
2015 frameNum, // uint32_t frame_num;
2016 PicOrderCnt, // int32_t PicOrderCnt;
2017 0, // uint8_t temporal_id;
2018 {0, 0, 0}, // uint8_t reserved1[3];
2019 pRefLists // const StdVideoEncodeH264ReferenceListsInfo* pRefLists;
2020 };
2021
2022 return de::MovePtr<StdVideoEncodeH264PictureInfo>(new StdVideoEncodeH264PictureInfo(pictureInfo));
2023 }
2024
getStdVideoEncodeH265PictureInfo(StdVideoH265PictureType pictureType,int32_t PicOrderCntVal,const StdVideoEncodeH265ReferenceListsInfo * pRefLists,StdVideoH265ShortTermRefPicSet * pShortTermRefPicSet)2025 de::MovePtr<StdVideoEncodeH265PictureInfo> getStdVideoEncodeH265PictureInfo(
2026 StdVideoH265PictureType pictureType, int32_t PicOrderCntVal, const StdVideoEncodeH265ReferenceListsInfo *pRefLists,
2027 StdVideoH265ShortTermRefPicSet *pShortTermRefPicSet)
2028 {
2029 const StdVideoEncodeH265PictureInfoFlags IRDpictureInfoFlags = {
2030 1, // is_reference : 1;
2031 1, // IrapPicFlag : 1;
2032 0, // used_for_long_term_reference : 1;
2033 0, // discardable_flag : 1;
2034 0, // cross_layer_bla_flag : 1;
2035 1, // pic_output_flag : 1;
2036 0, // no_output_of_prior_pics_flag : 1;
2037 0, // short_term_ref_pic_set_sps_flag : 1;
2038 0, // slice_temporal_mvp_enabled_flag : 1;
2039 0 // reserved : 23;
2040 };
2041
2042 const StdVideoEncodeH265PictureInfoFlags PpictureInfoFlags = {
2043 1, // is_reference : 1;
2044 0, // IrapPicFlag : 1;
2045 0, // used_for_long_term_reference : 1;
2046 0, // discardable_flag : 1;
2047 0, // cross_layer_bla_flag : 1;
2048 0, // pic_output_flag : 1;
2049 0, // no_output_of_prior_pics_flag : 1;
2050 0, // short_term_ref_pic_set_sps_flag : 1;
2051 0, // slice_temporal_mvp_enabled_flag : 1;
2052 0 // reserved : 23;
2053 };
2054
2055 const StdVideoEncodeH265PictureInfoFlags BpictureInfoFlags = {
2056 0, // is_reference : 1;
2057 0, // IrapPicFlag : 1;
2058 0, // used_for_long_term_reference : 1;
2059 0, // discardable_flag : 1;
2060 0, // cross_layer_bla_flag : 1;
2061 0, // pic_output_flag : 1;
2062 0, // no_output_of_prior_pics_flag : 1;
2063 0, // short_term_ref_pic_set_sps_flag : 1;
2064 0, // slice_temporal_mvp_enabled_flag : 1;
2065 0 // reserved : 23;
2066 };
2067
2068 StdVideoEncodeH265PictureInfoFlags flags = IRDpictureInfoFlags;
2069
2070 switch (pictureType)
2071 {
2072 case STD_VIDEO_H265_PICTURE_TYPE_IDR:
2073 case STD_VIDEO_H265_PICTURE_TYPE_I:
2074 flags = IRDpictureInfoFlags;
2075 break;
2076 case STD_VIDEO_H265_PICTURE_TYPE_P:
2077 flags = PpictureInfoFlags;
2078 break;
2079 case STD_VIDEO_H265_PICTURE_TYPE_B:
2080 flags = BpictureInfoFlags;
2081 break;
2082 default:
2083 TCU_THROW(InternalError, "Unknown frame type");
2084 }
2085
2086 const StdVideoEncodeH265PictureInfo pictureInfo = {
2087 flags, // StdVideoEncodeH265PictureInfoFlags flags;
2088 pictureType, // StdVideoH265PictureType pictureType;
2089 0u, // uint8_t sps_video_parameter_set_id;
2090 0u, // uint8_t pps_seq_parameter_set_id;
2091 0u, // uint8_t pps_pic_parameter_set_id;
2092 0u, // uint8_t short_term_ref_pic_set_idx;
2093 PicOrderCntVal, // int32_t PicOrderCntVal;
2094 0u, // uint8_t TemporalId;
2095 {0, 0, 0, 0, 0, 0, 0}, // uint8_t reserved1[7];
2096 pRefLists, // const StdVideoEncodeH265ReferenceListsInfo* pRefLists;
2097 pShortTermRefPicSet, // const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet;
2098 nullptr, // const StdVideoEncodeH265SliceSegmentLongTermRefPics* pLongTermRefPics;
2099 };
2100
2101 return de::MovePtr<StdVideoEncodeH265PictureInfo>(new StdVideoEncodeH265PictureInfo(pictureInfo));
2102 }
2103
getVideoEncodeH264PictureInfo(const StdVideoEncodeH264PictureInfo * pictureInfo,const VkVideoEncodeH264NaluSliceInfoKHR * pNaluSliceEntries)2104 de::MovePtr<VkVideoEncodeH264PictureInfoKHR> getVideoEncodeH264PictureInfo(
2105 const StdVideoEncodeH264PictureInfo *pictureInfo, const VkVideoEncodeH264NaluSliceInfoKHR *pNaluSliceEntries)
2106 {
2107 const VkVideoEncodeH264PictureInfoKHR videoEncodeH264PictureInfo = {
2108 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR, // VkStructureType sType;
2109 nullptr, // const void* pNext;
2110 1u, // uint32_t naluSliceEntryCount;
2111 pNaluSliceEntries, // const VkVideoEncodeH264NaluSliceInfoKHR* pNaluSliceEntries;
2112 pictureInfo, // const StdVideoEncodeH264PictureInfo* pStdPictureInfo;
2113 false, // VkBool32 generatePrefixNalu;
2114
2115 };
2116
2117 return de::MovePtr<VkVideoEncodeH264PictureInfoKHR>(
2118 new VkVideoEncodeH264PictureInfoKHR(videoEncodeH264PictureInfo));
2119 }
2120
getVideoEncodeH265PictureInfo(const StdVideoEncodeH265PictureInfo * pictureInfo,const VkVideoEncodeH265NaluSliceSegmentInfoKHR * pNaluSliceSegmentInfo)2121 de::MovePtr<VkVideoEncodeH265PictureInfoKHR> getVideoEncodeH265PictureInfo(
2122 const StdVideoEncodeH265PictureInfo *pictureInfo,
2123 const VkVideoEncodeH265NaluSliceSegmentInfoKHR *pNaluSliceSegmentInfo)
2124 {
2125 const VkVideoEncodeH265PictureInfoKHR videoEncodeH265PictureInfo = {
2126 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR, // VkStructureType sType;
2127 nullptr, // const void* pNext;
2128 1u, // uint32_t naluSliceSegmentEntryCount;
2129 pNaluSliceSegmentInfo, // const VkVideoEncodeH265NaluSliceSegmentInfoKHR* pNaluSliceSegmentEntries;
2130 pictureInfo, // const StdVideoEncodeH265PictureInfo* pStdPictureInfo;
2131 };
2132
2133 return de::MovePtr<VkVideoEncodeH265PictureInfoKHR>(
2134 new VkVideoEncodeH265PictureInfoKHR(videoEncodeH265PictureInfo));
2135 }
2136
getVideoBeginCodingInfo(VkVideoSessionKHR videoEncodeSession,VkVideoSessionParametersKHR videoEncodeSessionParameters,uint32_t referenceSlotCount,const VkVideoReferenceSlotInfoKHR * pReferenceSlots,const void * pNext)2137 de::MovePtr<VkVideoBeginCodingInfoKHR> getVideoBeginCodingInfo(VkVideoSessionKHR videoEncodeSession,
2138 VkVideoSessionParametersKHR videoEncodeSessionParameters,
2139 uint32_t referenceSlotCount,
2140 const VkVideoReferenceSlotInfoKHR *pReferenceSlots,
2141 const void *pNext)
2142 {
2143 const VkVideoBeginCodingInfoKHR videoBeginCodingInfo = {
2144 VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR, // VkStructureType sType;
2145 pNext, // const void* pNext;
2146 0u, // VkVideoBeginCodingFlagsKHR flags;
2147 videoEncodeSession, // VkVideoSessionKHR videoSession;
2148 videoEncodeSessionParameters, // VkVideoSessionParametersKHR videoSessionParameters;
2149 referenceSlotCount, // uint32_t referenceSlotCount;
2150 pReferenceSlots, // const VkVideoReferenceSlotInfoKHR* pReferenceSlots;
2151 };
2152
2153 return de::MovePtr<VkVideoBeginCodingInfoKHR>(new VkVideoBeginCodingInfoKHR(videoBeginCodingInfo));
2154 }
2155
getVideoInlineQueryInfo(VkQueryPool queryPool,uint32_t firstQuery,uint32_t queryCount,const void * pNext)2156 de::MovePtr<VkVideoInlineQueryInfoKHR> getVideoInlineQueryInfo(VkQueryPool queryPool, uint32_t firstQuery,
2157 uint32_t queryCount, const void *pNext)
2158 {
2159 const VkVideoInlineQueryInfoKHR videoInlineQueryInfo = {
2160 VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR, // VkStructureType sType;
2161 pNext, // const void* pNext;
2162 queryPool, // VkQueryPool queryPool;
2163 firstQuery, // uint32_t firstQuery;
2164 queryCount, // uint32_t queryCount;
2165 };
2166
2167 return de::MovePtr<VkVideoInlineQueryInfoKHR>(new VkVideoInlineQueryInfoKHR(videoInlineQueryInfo));
2168 }
2169
getVideoEncodeH264QuantizationMapParameters(VkExtent2D quantizationMapTexelSize)2170 de::MovePtr<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR> getVideoEncodeH264QuantizationMapParameters(
2171 VkExtent2D quantizationMapTexelSize)
2172 {
2173
2174 const VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR quantizationMapParameters = {
2175 VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR, // VkStructureType sType;
2176 nullptr, // void* pNext;
2177 quantizationMapTexelSize, // VkExtent2D quantizationMapTexelSize;
2178 };
2179
2180 return de::MovePtr<VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR>(
2181 new VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR(quantizationMapParameters));
2182 }
2183
getQuantizationMapInfo(VkImageView quantizationMap,VkExtent2D quantizationMapExtent,const void * pNext)2184 de::MovePtr<VkVideoEncodeQuantizationMapInfoKHR> getQuantizationMapInfo(VkImageView quantizationMap,
2185 VkExtent2D quantizationMapExtent,
2186 const void *pNext)
2187 {
2188 const VkVideoEncodeQuantizationMapInfoKHR quantizationMapInfo = {
2189 VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR, // VkStructureType sType;
2190 pNext, // const void* pNext;
2191 quantizationMap, // VkImageView quantizationMap;
2192 quantizationMapExtent, // VkExtent2D quantizationMapTexelSize;
2193 };
2194
2195 return de::MovePtr<VkVideoEncodeQuantizationMapInfoKHR>(
2196 new VkVideoEncodeQuantizationMapInfoKHR(quantizationMapInfo));
2197 }
2198
getStdVideoH264DecodePictureParameterSet(void)2199 de::MovePtr<StdVideoH264PictureParameterSet> getStdVideoH264DecodePictureParameterSet(void)
2200 {
2201 const StdVideoH264PpsFlags stdVideoH264PpsFlags = {
2202 1u, // uint32_t transform_8x8_mode_flag:1;
2203 0u, // uint32_t redundant_pic_cnt_present_flag:1;
2204 0u, // uint32_t constrained_intra_pred_flag:1;
2205 1u, // uint32_t deblocking_filter_control_present_flag:1;
2206 0u, // uint32_t weighted_pred_flag:1;
2207 0u, // uint32_4 bottom_field_pic_order_in_frame_present_flag:1;
2208 1u, // uint32_t entropy_coding_mode_flag:1;
2209 0u, // uint32_t pic_scaling_matrix_present_flag;
2210 };
2211
2212 const StdVideoH264PictureParameterSet stdVideoH264PictureParameterSet = {
2213 stdVideoH264PpsFlags, // StdVideoH264PpsFlags flags;
2214 0u, // uint8_t seq_parameter_set_id;
2215 0u, // uint8_t pic_parameter_set_id;
2216 1u, // uint8_t num_ref_idx_l0_default_active_minus1;
2217 0u, // uint8_t num_ref_idx_l1_default_active_minus1;
2218 STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT, // StdVideoH264WeightedBipredIdc weighted_bipred_idc;
2219 -16, // int8_t pic_init_qp_minus26;
2220 0, // int8_t pic_init_qs_minus26;
2221 -2, // int8_t chroma_qp_index_offset;
2222 -2, // int8_t second_chroma_qp_index_offset;
2223 nullptr, // const StdVideoH264ScalingLists* pScalingLists;
2224 };
2225
2226 return de::MovePtr<StdVideoH264PictureParameterSet>(
2227 new StdVideoH264PictureParameterSet(stdVideoH264PictureParameterSet));
2228 }
2229
getVideoEncodeInfo(const void * pNext,const VkVideoEncodeFlagsKHR encodeFlags,const VkBuffer & dstBuffer,const VkDeviceSize & dstBufferOffset,const VkVideoPictureResourceInfoKHR & srcPictureResource,const VkVideoReferenceSlotInfoKHR * pSetupReferenceSlot,const uint32_t & referenceSlotCount,const VkVideoReferenceSlotInfoKHR * pReferenceSlots)2230 de::MovePtr<VkVideoEncodeInfoKHR> getVideoEncodeInfo(const void *pNext, const VkVideoEncodeFlagsKHR encodeFlags,
2231 const VkBuffer &dstBuffer, const VkDeviceSize &dstBufferOffset,
2232 const VkVideoPictureResourceInfoKHR &srcPictureResource,
2233 const VkVideoReferenceSlotInfoKHR *pSetupReferenceSlot,
2234 const uint32_t &referenceSlotCount,
2235 const VkVideoReferenceSlotInfoKHR *pReferenceSlots)
2236 {
2237 const VkVideoEncodeInfoKHR videoEncodeFrameInfo = {
2238 VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR, // VkStructureType sType;
2239 pNext, // const void* pNext;
2240 encodeFlags, // VkVideoEncodeFlagsKHR flags;
2241 dstBuffer, // VkBuffer dstBuffer;
2242 dstBufferOffset, // VkDeviceSize dstBufferOffset;
2243 0u, // VkDeviceSize dstBufferRange;
2244 srcPictureResource, // VkVideoPictureResourceInfoKHR srcPictureResource;
2245 pSetupReferenceSlot, // const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot;
2246 referenceSlotCount, // uint32_t referenceSlotCount;
2247 pReferenceSlots, // const VkVideoReferenceSlotInfoKHR* pReferenceSlots;
2248 0 // uint32_t precedingExternallyEncodedBytes;
2249 };
2250
2251 return de::MovePtr<VkVideoEncodeInfoKHR>(new VkVideoEncodeInfoKHR(videoEncodeFrameInfo));
2252 }
2253
semiplanarToYV12(const ycbcr::MultiPlaneImageData & multiPlaneImageData)2254 std::vector<uint8_t> semiplanarToYV12(const ycbcr::MultiPlaneImageData &multiPlaneImageData)
2255 {
2256 DE_ASSERT(multiPlaneImageData.getFormat() == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM);
2257
2258 std::vector<uint8_t> YV12Buffer;
2259 size_t plane0Size = multiPlaneImageData.getPlaneSize(0);
2260 size_t plane1Size = multiPlaneImageData.getPlaneSize(1);
2261
2262 YV12Buffer.resize(plane0Size + plane1Size);
2263
2264 // Copy the luma plane.
2265 deMemcpy(YV12Buffer.data(), multiPlaneImageData.getPlanePtr(0), plane0Size);
2266
2267 // Deinterleave the Cr and Cb plane.
2268 uint16_t *plane2 = (uint16_t *)multiPlaneImageData.getPlanePtr(1);
2269 std::vector<uint8_t>::size_type idx = plane0Size;
2270 for (unsigned i = 0; i < plane1Size / 2; i++)
2271 YV12Buffer[idx++] = static_cast<uint8_t>(plane2[i] & 0xFF);
2272 for (unsigned i = 0; i < plane1Size / 2; i++)
2273 YV12Buffer[idx++] = static_cast<uint8_t>((plane2[i] >> 8) & 0xFF);
2274
2275 return YV12Buffer;
2276 }
2277
imageMatchesReferenceChecksum(const ycbcr::MultiPlaneImageData & multiPlaneImageData,const std::string & referenceChecksum)2278 bool imageMatchesReferenceChecksum(const ycbcr::MultiPlaneImageData &multiPlaneImageData,
2279 const std::string &referenceChecksum)
2280 {
2281 std::vector<uint8_t> yv12 = semiplanarToYV12(multiPlaneImageData);
2282 std::string checksum = MD5SumBase16(yv12.data(), yv12.size());
2283 return checksum == referenceChecksum;
2284 }
2285
2286 namespace util
2287 {
2288 #ifdef DE_BUILD_VIDEO
generateYCbCrFile(std::string fileName,uint32_t n_frames,uint32_t width,uint32_t height,uint32_t format,uint8_t bitdepth)2289 void generateYCbCrFile(std::string fileName, uint32_t n_frames, uint32_t width, uint32_t height, uint32_t format,
2290 uint8_t bitdepth)
2291 {
2292 video_generator gen;
2293 video_generator_settings cfg;
2294 uint32_t max_frames;
2295 std::ofstream outFile(fileName, std::ios::binary | std::ios::out);
2296
2297 if (!outFile.is_open())
2298 {
2299 TCU_THROW(NotSupportedError, "Unable to create the file to generate the YUV content");
2300 }
2301
2302 max_frames = n_frames;
2303 memset(&cfg, 0, sizeof(cfg));
2304 cfg.width = width;
2305 cfg.height = height;
2306 cfg.format = format;
2307 cfg.bitdepth = bitdepth;
2308
2309 if (video_generator_init(&cfg, &gen))
2310 {
2311 TCU_THROW(NotSupportedError, "Unable to create the video generator");
2312 }
2313
2314 while (gen.frame < max_frames)
2315 {
2316 video_generator_update(&gen);
2317 // write video planes to a file
2318 outFile.write((char *)gen.y, gen.ybytes);
2319 outFile.write((char *)gen.u, gen.ubytes);
2320 outFile.write((char *)gen.v, gen.vbytes);
2321 }
2322
2323 outFile.close();
2324 video_generator_clear(&gen);
2325 }
2326 #endif
2327
getVideoCodecString(VkVideoCodecOperationFlagBitsKHR codec)2328 const char *getVideoCodecString(VkVideoCodecOperationFlagBitsKHR codec)
2329 {
2330 static struct
2331 {
2332 VkVideoCodecOperationFlagBitsKHR eCodec;
2333 const char *name;
2334 } aCodecName[] = {
2335 {VK_VIDEO_CODEC_OPERATION_NONE_KHR, "None"},
2336 {VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR, "AVC/H.264"},
2337 {VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR, "H.265/HEVC"},
2338 };
2339
2340 for (auto &i : aCodecName)
2341 {
2342 if (codec == i.eCodec)
2343 return aCodecName[codec].name;
2344 }
2345
2346 return "Unknown";
2347 }
2348
getVideoChromaFormatString(VkVideoChromaSubsamplingFlagBitsKHR chromaFormat)2349 const char *getVideoChromaFormatString(VkVideoChromaSubsamplingFlagBitsKHR chromaFormat)
2350 {
2351 switch (chromaFormat)
2352 {
2353 case VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR:
2354 return "YCbCr 400 (Monochrome)";
2355 case VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR:
2356 return "YCbCr 420";
2357 case VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR:
2358 return "YCbCr 422";
2359 case VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR:
2360 return "YCbCr 444";
2361 default:
2362 DE_ASSERT(false && "Unknown Chroma sub-sampled format");
2363 };
2364
2365 return "Unknown";
2366 }
2367
getSupportedCodecs(DeviceContext & devCtx,uint32_t selectedVideoQueueFamily,VkQueueFlags queueFlagsRequired,VkVideoCodecOperationFlagsKHR videoCodeOperations)2368 VkVideoCodecOperationFlagsKHR getSupportedCodecs(DeviceContext &devCtx, uint32_t selectedVideoQueueFamily,
2369 VkQueueFlags queueFlagsRequired,
2370 VkVideoCodecOperationFlagsKHR videoCodeOperations)
2371 {
2372 uint32_t count = 0;
2373 auto &vkif = devCtx.context->getInstanceInterface();
2374 vkif.getPhysicalDeviceQueueFamilyProperties2(devCtx.phys, &count, nullptr);
2375 std::vector<VkQueueFamilyProperties2> queues(count);
2376 std::vector<VkQueueFamilyVideoPropertiesKHR> videoQueues(count);
2377 std::vector<VkQueueFamilyQueryResultStatusPropertiesKHR> queryResultStatus(count);
2378 for (std::vector<VkQueueFamilyProperties2>::size_type i = 0; i < queues.size(); i++)
2379 {
2380 queues[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
2381 videoQueues[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
2382 queues[i].pNext = &videoQueues[i];
2383 queryResultStatus[i].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR;
2384 videoQueues[i].pNext = &queryResultStatus[i];
2385 }
2386 vkif.getPhysicalDeviceQueueFamilyProperties2(devCtx.phys, &count, queues.data());
2387
2388 TCU_CHECK(selectedVideoQueueFamily < queues.size());
2389
2390 const VkQueueFamilyProperties2 &q = queues[selectedVideoQueueFamily];
2391 const VkQueueFamilyVideoPropertiesKHR &videoQueue = videoQueues[selectedVideoQueueFamily];
2392
2393 if (q.queueFamilyProperties.queueFlags & queueFlagsRequired &&
2394 videoQueue.videoCodecOperations & videoCodeOperations)
2395 {
2396 // The video queues may or may not support queryResultStatus
2397 // DE_ASSERT(queryResultStatus[queueIndx].queryResultStatusSupport);
2398 return videoQueue.videoCodecOperations;
2399 }
2400
2401 return VK_VIDEO_CODEC_OPERATION_NONE_KHR;
2402 }
2403
getVideoFormats(DeviceContext & devCtx,const VkVideoCoreProfile & videoProfile,VkImageUsageFlags imageUsage,uint32_t & formatCount,VkFormat * formats,bool dumpData)2404 VkResult getVideoFormats(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile, VkImageUsageFlags imageUsage,
2405 uint32_t &formatCount, VkFormat *formats, bool dumpData)
2406 {
2407 auto &vkif = devCtx.context->getInstanceInterface();
2408
2409 for (uint32_t i = 0; i < formatCount; i++)
2410 {
2411 formats[i] = VK_FORMAT_UNDEFINED;
2412 }
2413
2414 const VkVideoProfileListInfoKHR videoProfiles = {VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, nullptr, 1,
2415 videoProfile.GetProfile()};
2416 const VkPhysicalDeviceVideoFormatInfoKHR videoFormatInfo = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
2417 const_cast<VkVideoProfileListInfoKHR *>(&videoProfiles),
2418 imageUsage};
2419
2420 uint32_t supportedFormatCount = 0;
2421 VkResult result =
2422 vkif.getPhysicalDeviceVideoFormatPropertiesKHR(devCtx.phys, &videoFormatInfo, &supportedFormatCount, nullptr);
2423 DE_ASSERT(result == VK_SUCCESS);
2424 DE_ASSERT(supportedFormatCount);
2425
2426 VkVideoFormatPropertiesKHR *pSupportedFormats = new VkVideoFormatPropertiesKHR[supportedFormatCount];
2427 memset(pSupportedFormats, 0x00, supportedFormatCount * sizeof(VkVideoFormatPropertiesKHR));
2428 for (uint32_t i = 0; i < supportedFormatCount; i++)
2429 {
2430 pSupportedFormats[i].sType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR;
2431 }
2432
2433 result = vkif.getPhysicalDeviceVideoFormatPropertiesKHR(devCtx.phys, &videoFormatInfo, &supportedFormatCount,
2434 pSupportedFormats);
2435 DE_ASSERT(result == VK_SUCCESS);
2436 if (dumpData)
2437 {
2438 std::cout << "\t"
2439 << ((videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR) ? "h264" : "h265")
2440 << "decode formats: " << std::endl;
2441 for (uint32_t fmt = 0; fmt < supportedFormatCount; fmt++)
2442 {
2443 std::cout << "\t " << fmt << ": " << std::hex << pSupportedFormats[fmt].format << std::dec << std::endl;
2444 }
2445 }
2446
2447 formatCount = std::min(supportedFormatCount, formatCount);
2448
2449 for (uint32_t i = 0; i < formatCount; i++)
2450 {
2451 formats[i] = pSupportedFormats[i].format;
2452 }
2453
2454 delete[] pSupportedFormats;
2455
2456 return result;
2457 }
2458
getSupportedVideoFormats(DeviceContext & devCtx,const VkVideoCoreProfile & videoProfile,VkVideoDecodeCapabilityFlagsKHR capabilityFlags,VkFormat & pictureFormat,VkFormat & referencePicturesFormat)2459 VkResult getSupportedVideoFormats(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile,
2460 VkVideoDecodeCapabilityFlagsKHR capabilityFlags, VkFormat &pictureFormat,
2461 VkFormat &referencePicturesFormat)
2462 {
2463 VkResult result = VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR;
2464 if ((capabilityFlags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR) != 0)
2465 {
2466 // NV, Intel
2467 VkFormat supportedDpbFormats[8];
2468 uint32_t formatCount = sizeof(supportedDpbFormats) / sizeof(supportedDpbFormats[0]);
2469 result = util::getVideoFormats(devCtx, videoProfile,
2470 (VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR |
2471 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | VK_IMAGE_USAGE_TRANSFER_SRC_BIT),
2472 formatCount, supportedDpbFormats);
2473
2474 referencePicturesFormat = supportedDpbFormats[0];
2475 pictureFormat = supportedDpbFormats[0];
2476 }
2477 else if ((capabilityFlags & VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR) != 0)
2478 {
2479 // AMD
2480 VkFormat supportedDpbFormats[8];
2481 VkFormat supportedOutFormats[8];
2482 uint32_t formatCount = sizeof(supportedDpbFormats) / sizeof(supportedDpbFormats[0]);
2483 result = util::getVideoFormats(devCtx, videoProfile, VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR, formatCount,
2484 supportedDpbFormats);
2485
2486 DE_ASSERT(result == VK_SUCCESS);
2487
2488 result = util::getVideoFormats(devCtx, videoProfile,
2489 VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
2490 formatCount, supportedOutFormats);
2491
2492 referencePicturesFormat = supportedDpbFormats[0];
2493 pictureFormat = supportedOutFormats[0];
2494 }
2495 else
2496 {
2497 fprintf(stderr, "\nERROR: Unsupported decode capability flags.");
2498 return VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR;
2499 }
2500
2501 DE_ASSERT(result == VK_SUCCESS);
2502 if (result != VK_SUCCESS)
2503 {
2504 fprintf(stderr, "\nERROR: GetVideoFormats() result: 0x%x\n", result);
2505 }
2506
2507 DE_ASSERT((referencePicturesFormat != VK_FORMAT_UNDEFINED) && (pictureFormat != VK_FORMAT_UNDEFINED));
2508 DE_ASSERT(referencePicturesFormat == pictureFormat);
2509
2510 return result;
2511 }
2512
codecToName(VkVideoCodecOperationFlagBitsKHR codec)2513 const char *codecToName(VkVideoCodecOperationFlagBitsKHR codec)
2514 {
2515 switch ((int32_t)codec)
2516 {
2517 case VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR:
2518 return "decode h.264";
2519 case VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR:
2520 return "decode h.265";
2521 case VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR:
2522 return "decode av1";
2523 case VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR:
2524 return "encode h.264";
2525 case VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR:
2526 return "encode h.265";
2527 case VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR:
2528 return "encode av1";
2529 default:
2530 tcu::die("Unknown video codec");
2531 }
2532
2533 return "";
2534 }
2535
getVideoCapabilities(DeviceContext & devCtx,const VkVideoCoreProfile & videoProfile,VkVideoCapabilitiesKHR * pVideoCapabilities)2536 VkResult getVideoCapabilities(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile,
2537 VkVideoCapabilitiesKHR *pVideoCapabilities)
2538 {
2539 auto &vkif = devCtx.context->getInstanceInterface();
2540 DE_ASSERT(pVideoCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR);
2541
2542 VkVideoDecodeCapabilitiesKHR *pVideoDecodeCapabilities{};
2543 VkVideoDecodeH264CapabilitiesKHR *pH264DecodeCapabilities{};
2544 VkVideoDecodeH265CapabilitiesKHR *pH265DecodeCapabilities{};
2545 VkVideoDecodeAV1CapabilitiesKHR *pAV1DecodeCapabilities{};
2546
2547 VkVideoEncodeCapabilitiesKHR *pVideoEncodeCapabilities{};
2548 VkVideoEncodeH264CapabilitiesKHR *pH264EncodeCapabilities{};
2549 VkVideoEncodeH265CapabilitiesKHR *pH265EncodeCapabilities{};
2550
2551 pVideoDecodeCapabilities = (VkVideoDecodeCapabilitiesKHR *)pVideoCapabilities->pNext;
2552 pVideoEncodeCapabilities = (VkVideoEncodeCapabilitiesKHR *)pVideoCapabilities->pNext;
2553
2554 if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR)
2555 {
2556 DE_ASSERT(pVideoDecodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR);
2557 pH264DecodeCapabilities = (VkVideoDecodeH264CapabilitiesKHR *)pVideoDecodeCapabilities->pNext;
2558 DE_ASSERT(pH264DecodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR);
2559 }
2560 else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR)
2561 {
2562 DE_ASSERT(pVideoDecodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR);
2563 pH265DecodeCapabilities = (VkVideoDecodeH265CapabilitiesKHR *)pVideoDecodeCapabilities->pNext;
2564 DE_ASSERT(pH265DecodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR);
2565 }
2566 else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR)
2567 {
2568 DE_ASSERT(pVideoDecodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR);
2569 pAV1DecodeCapabilities = (VkVideoDecodeAV1CapabilitiesKHR *)pVideoDecodeCapabilities->pNext;
2570 DE_ASSERT(pAV1DecodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR);
2571 }
2572 else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR)
2573 {
2574 DE_ASSERT(pVideoEncodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR);
2575 pH264EncodeCapabilities = (VkVideoEncodeH264CapabilitiesKHR *)pVideoEncodeCapabilities->pNext;
2576 DE_ASSERT(pH264EncodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR);
2577 }
2578 else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR)
2579 {
2580 DE_ASSERT(pVideoEncodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR);
2581 pH265EncodeCapabilities = (VkVideoEncodeH265CapabilitiesKHR *)pVideoEncodeCapabilities->pNext;
2582 DE_ASSERT(pH265EncodeCapabilities->sType == VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR);
2583 }
2584 else
2585 {
2586 DE_ASSERT(false && "Unsupported codec");
2587 return VK_ERROR_FORMAT_NOT_SUPPORTED;
2588 }
2589
2590 // For silencing unused variables static analysis error
2591 DE_UNREF(pVideoDecodeCapabilities);
2592 DE_UNREF(pH264DecodeCapabilities);
2593 DE_UNREF(pH265DecodeCapabilities);
2594 DE_UNREF(pVideoEncodeCapabilities);
2595 DE_UNREF(pH264EncodeCapabilities);
2596 DE_UNREF(pH265EncodeCapabilities);
2597
2598 VkResult result =
2599 vkif.getPhysicalDeviceVideoCapabilitiesKHR(devCtx.phys, videoProfile.GetProfile(), pVideoCapabilities);
2600 if (result != VK_SUCCESS)
2601 {
2602 return result;
2603 }
2604
2605 if (videoLoggingEnabled())
2606 {
2607 if (pVideoCapabilities->flags & VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR)
2608 tcu::print("\tseparate reference images\n");
2609
2610 std::cout << "\t"
2611 << "minBitstreamBufferOffsetAlignment: " << pVideoCapabilities->minBitstreamBufferOffsetAlignment
2612 << std::endl;
2613 std::cout << "\t"
2614 << "minBitstreamBufferSizeAlignment: " << pVideoCapabilities->minBitstreamBufferSizeAlignment
2615 << std::endl;
2616 std::cout << "\t"
2617 << "pictureAccessGranularity: " << pVideoCapabilities->pictureAccessGranularity.width << " x "
2618 << pVideoCapabilities->pictureAccessGranularity.height << std::endl;
2619 std::cout << "\t"
2620 << "minCodedExtent: " << pVideoCapabilities->minCodedExtent.width << " x "
2621 << pVideoCapabilities->minCodedExtent.height << std::endl;
2622 std::cout << "\t"
2623 << "maxCodedExtent: " << pVideoCapabilities->maxCodedExtent.width << " x "
2624 << pVideoCapabilities->maxCodedExtent.height << std::endl;
2625 std::cout << "\t"
2626 << "maxDpbSlots: " << pVideoCapabilities->maxDpbSlots << std::endl;
2627 std::cout << "\t"
2628 << "maxActiveReferencePictures: " << pVideoCapabilities->maxActiveReferencePictures << std::endl;
2629 }
2630
2631 if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR)
2632 {
2633 if (videoLoggingEnabled())
2634 {
2635 std::cout << "\t"
2636 << "maxLevelIdc: " << pH264DecodeCapabilities->maxLevelIdc << std::endl;
2637 std::cout << "\t"
2638 << "fieldOffsetGranularity: " << pH264DecodeCapabilities->fieldOffsetGranularity.x << " x "
2639 << pH264DecodeCapabilities->fieldOffsetGranularity.y << std::endl;
2640 ;
2641 }
2642
2643 if (strncmp(pVideoCapabilities->stdHeaderVersion.extensionName,
2644 VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_EXTENSION_NAME,
2645 sizeof(pVideoCapabilities->stdHeaderVersion.extensionName) - 1U) ||
2646 (pVideoCapabilities->stdHeaderVersion.specVersion != VK_STD_VULKAN_VIDEO_CODEC_H264_DECODE_SPEC_VERSION))
2647 {
2648 DE_ASSERT(false && "Unsupported AVC extension specification");
2649 return VK_ERROR_INCOMPATIBLE_DRIVER;
2650 }
2651 }
2652 else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR)
2653 {
2654 if (videoLoggingEnabled())
2655 {
2656 std::cout << "\t"
2657 << "maxLevelIdc: " << pH265DecodeCapabilities->maxLevelIdc << std::endl;
2658 }
2659 if (strncmp(pVideoCapabilities->stdHeaderVersion.extensionName,
2660 VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_EXTENSION_NAME,
2661 sizeof(pVideoCapabilities->stdHeaderVersion.extensionName) - 1U) ||
2662 (pVideoCapabilities->stdHeaderVersion.specVersion != VK_STD_VULKAN_VIDEO_CODEC_H265_DECODE_SPEC_VERSION))
2663 {
2664 DE_ASSERT(false && "Unsupported HEVC extension specification");
2665 return VK_ERROR_INCOMPATIBLE_DRIVER;
2666 }
2667 }
2668 else if (videoProfile.GetCodecType() == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR)
2669 {
2670 if (videoLoggingEnabled())
2671 {
2672 std::cout << "\t"
2673 << "maxLevel: " << pAV1DecodeCapabilities->maxLevel << std::endl;
2674 }
2675 if ((strncmp(pVideoCapabilities->stdHeaderVersion.extensionName,
2676 VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_EXTENSION_NAME,
2677 sizeof(pVideoCapabilities->stdHeaderVersion.extensionName) - 1U) ||
2678 (pVideoCapabilities->stdHeaderVersion.specVersion != VK_STD_VULKAN_VIDEO_CODEC_AV1_DECODE_SPEC_VERSION)))
2679 {
2680 DE_ASSERT(false && "Unsupported AV1 extension specification");
2681 return VK_ERROR_INCOMPATIBLE_DRIVER;
2682 }
2683 }
2684 else
2685 {
2686 DE_ASSERT(false && "Unsupported codec extension");
2687 }
2688
2689 return result;
2690 }
2691
getVideoDecodeCapabilities(DeviceContext & devCtx,const VkVideoCoreProfile & videoProfile,VkVideoCapabilitiesKHR & videoCapabilities,VkVideoDecodeCapabilitiesKHR & videoDecodeCapabilities)2692 VkResult getVideoDecodeCapabilities(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile,
2693 VkVideoCapabilitiesKHR &videoCapabilities,
2694 VkVideoDecodeCapabilitiesKHR &videoDecodeCapabilities)
2695 {
2696
2697 VkVideoCodecOperationFlagsKHR videoCodec = videoProfile.GetProfile()->videoCodecOperation;
2698
2699 videoDecodeCapabilities = VkVideoDecodeCapabilitiesKHR{VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR, nullptr, 0};
2700
2701 deMemset(&videoCapabilities, 0, sizeof(VkVideoCapabilitiesKHR));
2702 videoCapabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
2703 videoCapabilities.pNext = &videoDecodeCapabilities;
2704
2705 VkVideoDecodeH264CapabilitiesKHR h264Capabilities{};
2706 h264Capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
2707
2708 VkVideoDecodeH265CapabilitiesKHR h265Capabilities{};
2709 h265Capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
2710
2711 VkVideoDecodeAV1CapabilitiesKHR av1Capabilities{};
2712 av1Capabilities.sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
2713
2714 if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR)
2715 {
2716 videoDecodeCapabilities.pNext = &h264Capabilities;
2717 }
2718 else if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR)
2719 {
2720 videoDecodeCapabilities.pNext = &h265Capabilities;
2721 }
2722 else if (videoCodec == VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR)
2723 {
2724 videoDecodeCapabilities.pNext = &av1Capabilities;
2725 }
2726 else
2727 {
2728 DE_ASSERT(false && "Unsupported codec");
2729 return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
2730 }
2731 VkResult result = util::getVideoCapabilities(devCtx, videoProfile, &videoCapabilities);
2732
2733 return result;
2734 }
2735
getVideoEncodeCapabilities(DeviceContext & devCtx,const VkVideoCoreProfile & videoProfile,VkVideoCapabilitiesKHR & videoCapabilities,VkVideoEncodeCapabilitiesKHR & videoEncodeCapabilities)2736 VkResult getVideoEncodeCapabilities(DeviceContext &devCtx, const VkVideoCoreProfile &videoProfile,
2737 VkVideoCapabilitiesKHR &videoCapabilities,
2738 VkVideoEncodeCapabilitiesKHR &videoEncodeCapabilities)
2739 {
2740 VkVideoCodecOperationFlagsKHR videoCodec = videoProfile.GetProfile()->videoCodecOperation;
2741
2742 // Encode Capabilities
2743
2744 videoEncodeCapabilities = VkVideoEncodeCapabilitiesKHR();
2745
2746 VkVideoEncodeH264CapabilitiesKHR h264EncodeCapabilities{};
2747 h264EncodeCapabilities.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
2748
2749 VkVideoEncodeH265CapabilitiesKHR h265EncodeCapabilities{};
2750 h265EncodeCapabilities.sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
2751
2752 deMemset(&videoCapabilities, 0, sizeof(VkVideoCapabilitiesKHR));
2753 videoCapabilities.sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
2754 videoCapabilities.pNext = &videoEncodeCapabilities;
2755
2756 if (videoCodec == VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR)
2757 {
2758 videoEncodeCapabilities.pNext = &h264EncodeCapabilities;
2759 }
2760 else if (videoCodec == VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR)
2761 {
2762 videoEncodeCapabilities.pNext = &h265EncodeCapabilities;
2763 }
2764 else
2765 {
2766 DE_ASSERT(false && "Unsupported codec");
2767 return VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR;
2768 }
2769
2770 VkResult result = util::getVideoCapabilities(devCtx, videoProfile, &videoCapabilities);
2771 DE_ASSERT(result == VK_SUCCESS);
2772 if (result != VK_SUCCESS)
2773 {
2774 fprintf(stderr, "\nERROR: Input is not supported. GetVideoCapabilities() result: 0x%x\n", result);
2775 }
2776 return result;
2777 }
2778
PSNR(const std::vector<uint8_t> & img1,const std::vector<uint8_t> & img2)2779 double PSNR(const std::vector<uint8_t> &img1, const std::vector<uint8_t> &img2)
2780 {
2781 TCU_CHECK_AND_THROW(InternalError, (img1.size() > 0) && (img1.size() == img2.size()),
2782 "Input and output YUVs have different sizes " + de::toString(img1.size()) + " vs " +
2783 de::toString(img2.size()));
2784
2785 using sizet = std::vector<uint8_t>::size_type;
2786 sizet sz = img1.size();
2787 double squaredError = 0.0;
2788
2789 for (sizet i = 0; i < sz; i++)
2790 {
2791 int diff = static_cast<int>(img1[i]) - static_cast<int>(img2[i]);
2792 squaredError += std::abs(diff);
2793 }
2794
2795 double mse = squaredError / static_cast<double>(sz);
2796 if (mse == 0)
2797 {
2798 return std::numeric_limits<double>::infinity();
2799 }
2800
2801 return 10 * std::log10((255.0 * 255.0) / mse);
2802 }
2803
calculatePSNRdifference(const std::vector<uint8_t> & inVector,const std::vector<uint8_t> & out,const VkExtent2D & codedExtent,const VkExtent2D & quantizationMapExtent,const VkExtent2D & quantizationMapTexelSize)2804 double calculatePSNRdifference(const std::vector<uint8_t> &inVector, const std::vector<uint8_t> &out,
2805 const VkExtent2D &codedExtent, const VkExtent2D &quantizationMapExtent,
2806 const VkExtent2D &quantizationMapTexelSize)
2807 {
2808 uint32_t halfWidthInPixels = (quantizationMapExtent.width / 2) * quantizationMapTexelSize.width;
2809 halfWidthInPixels = std::min(halfWidthInPixels, codedExtent.width);
2810
2811 std::vector<uint8_t> inLeftHalfRef =
2812 util::cropImage(inVector, codedExtent.width, codedExtent.height, 0, 0, halfWidthInPixels, codedExtent.height);
2813 std::vector<uint8_t> inRightHalfRef =
2814 util::cropImage(inVector, codedExtent.width, codedExtent.height, halfWidthInPixels, 0,
2815 codedExtent.width - halfWidthInPixels, codedExtent.height);
2816 std::vector<uint8_t> outLeftHalf =
2817 util::cropImage(out, codedExtent.width, codedExtent.height, 0, 0, halfWidthInPixels, codedExtent.height);
2818 std::vector<uint8_t> outRightHalf = util::cropImage(out, codedExtent.width, codedExtent.height, halfWidthInPixels,
2819 0, codedExtent.width - halfWidthInPixels, codedExtent.height);
2820
2821 double leftPSNR = PSNR(inLeftHalfRef, outLeftHalf);
2822 double rightPSNR = PSNR(inRightHalfRef, outRightHalf);
2823
2824 return rightPSNR - leftPSNR;
2825 }
2826
cropImage(const std::vector<uint8_t> & imageData,int imageWidth,int imageHeight,int roiX,int roiY,int roiWidth,int roiHeight)2827 std::vector<uint8_t> cropImage(const std::vector<uint8_t> &imageData, int imageWidth, int imageHeight, int roiX,
2828 int roiY, int roiWidth, int roiHeight)
2829 {
2830 DE_ASSERT(roiX >= 0 && roiY >= 0 && roiWidth > 0 && roiHeight > 0);
2831 DE_ASSERT(roiX + roiWidth <= imageWidth && roiY + roiHeight <= imageHeight);
2832 DE_UNREF(imageHeight);
2833
2834 std::vector<uint8_t> croppedImage;
2835 croppedImage.reserve(roiWidth * roiHeight);
2836
2837 for (int y = roiY; y < roiY + roiHeight; ++y)
2838 {
2839 for (int x = roiX; x < roiX + roiWidth; ++x)
2840 {
2841 croppedImage.push_back((imageData)[y * imageWidth + x]);
2842 }
2843 }
2844
2845 return croppedImage;
2846 }
2847
2848 } // namespace util
2849
getStdVideoDecodeH264PictureInfo(void)2850 de::MovePtr<StdVideoDecodeH264PictureInfo> getStdVideoDecodeH264PictureInfo(void)
2851 {
2852 const StdVideoDecodeH264PictureInfoFlags stdPictureInfoFlags = {
2853 0u, // uint32_t field_pic_flag;
2854 0u, // uint32_t is_intra;
2855 0u, // uint32_t IdrPicFlag;
2856 0u, // uint32_t bottom_field_flag;
2857 0u, // uint32_t is_reference;
2858 0u, // uint32_t complementary_field_pair;
2859 };
2860
2861 const StdVideoDecodeH264PictureInfo stdPictureInfo = {
2862 stdPictureInfoFlags, // StdVideoDecodeH264PictureInfoFlags flags;
2863 0u, // uint8_t seq_parameter_set_id;
2864 0u, // uint8_t pic_parameter_set_id;
2865 0u, // uint8_t reserved1;
2866 0u, // uint8_t reserved2;
2867 0u, // uint16_t frame_num;
2868 0u, // uint16_t idr_pic_id;
2869 {0}, // int32_t PicOrderCnt[STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_LIST_SIZE];
2870 };
2871
2872 return de::MovePtr<StdVideoDecodeH264PictureInfo>(new StdVideoDecodeH264PictureInfo(stdPictureInfo));
2873 }
2874
getVideoDecodeH264PictureInfo(StdVideoDecodeH264PictureInfo * stdPictureInfo,uint32_t * sliceOffset)2875 de::SharedPtr<VkVideoDecodeH264PictureInfoKHR> getVideoDecodeH264PictureInfo(
2876 StdVideoDecodeH264PictureInfo *stdPictureInfo, uint32_t *sliceOffset)
2877 {
2878 const VkVideoDecodeH264PictureInfoKHR pictureInfoHeap = {
2879 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR, // VkStructureType sType;
2880 nullptr, // const void* pNext;
2881 stdPictureInfo, // const StdVideoDecodeH264PictureInfo* pStdPictureInfo;
2882 1u, // uint32_t sliceCount;
2883 sliceOffset, // const uint32_t* pSliceOffsets;
2884 };
2885
2886 return de::SharedPtr<VkVideoDecodeH264PictureInfoKHR>(new VkVideoDecodeH264PictureInfoKHR(pictureInfoHeap));
2887 }
2888
getVideoEncodeH264RateControlLayerInfo(VkBool32 useMinQp,int32_t minQpI,int32_t minQpP,int32_t minQpB,VkBool32 useMaxQp,int32_t maxQpI,int32_t maxQpP,int32_t maxQpB)2889 de::MovePtr<VkVideoEncodeH264RateControlLayerInfoKHR> getVideoEncodeH264RateControlLayerInfo(
2890 VkBool32 useMinQp, int32_t minQpI, int32_t minQpP, int32_t minQpB, VkBool32 useMaxQp, int32_t maxQpI,
2891 int32_t maxQpP, int32_t maxQpB)
2892 {
2893 const VkVideoEncodeH264FrameSizeKHR videoEncodeH264FrameSize = {
2894 0, // uint32_t frameISize;
2895 0, // uint32_t framePSize;
2896 0, // uint32_t frameBSize;
2897 };
2898
2899 const VkVideoEncodeH264QpKHR videoEncodeH264MinQp = {
2900 minQpI, // int32_t qpI;
2901 minQpP, // int32_t qpP;
2902 minQpB, // int32_t qpB;
2903 };
2904
2905 const VkVideoEncodeH264QpKHR videoEncodeH264MaxQp = {
2906 maxQpI, // int32_t qpI;
2907 maxQpP, // int32_t qpI;
2908 maxQpB, // int32_t qpI;
2909 };
2910
2911 const VkVideoEncodeH264RateControlLayerInfoKHR videoEncodeH264RateControlLayerInfo = {
2912 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR, // VkStructureType sType;
2913 nullptr, // const void* pNext;
2914 useMinQp, // VkBool32 useMinQp;
2915 videoEncodeH264MinQp, // VkVideoEncodeH264QpKHR minQp;
2916 useMaxQp, // VkBool32 useMaxQp;
2917 videoEncodeH264MaxQp, // VkVideoEncodeH264QpKHR maxQp;
2918 true, // VkBool32 useMaxFrameSize;
2919 videoEncodeH264FrameSize, // VkVideoEncodeH264FrameSizeKHR maxFrameSize;
2920 };
2921
2922 return de::MovePtr<VkVideoEncodeH264RateControlLayerInfoKHR>(
2923 new VkVideoEncodeH264RateControlLayerInfoKHR(videoEncodeH264RateControlLayerInfo));
2924 }
2925
getVideoEncodeH265RateControlLayerInfo(VkBool32 useMinQp,int32_t minQpI,int32_t minQpP,int32_t minQpB,VkBool32 useMaxQp,int32_t maxQpI,int32_t maxQpP,int32_t maxQpB)2926 de::MovePtr<VkVideoEncodeH265RateControlLayerInfoKHR> getVideoEncodeH265RateControlLayerInfo(
2927 VkBool32 useMinQp, int32_t minQpI, int32_t minQpP, int32_t minQpB, VkBool32 useMaxQp, int32_t maxQpI,
2928 int32_t maxQpP, int32_t maxQpB)
2929 {
2930 const VkVideoEncodeH265FrameSizeKHR videoEncodeH265FrameSize = {
2931 0, // uint32_t frameISize;
2932 0, // uint32_t framePSize;
2933 0, // uint32_t frameBSize;
2934 };
2935
2936 const VkVideoEncodeH265QpKHR videoEncodeH265MinQp = {
2937 minQpI, // int32_t qpI;
2938 minQpP, // int32_t qpP;
2939 minQpB, // int32_t qpB;
2940 };
2941
2942 const VkVideoEncodeH265QpKHR videoEncodeH265MaxQp = {
2943 maxQpI, // int32_t qpI;
2944 maxQpP, // int32_t qpP;
2945 maxQpB, // int32_t qpB;
2946 };
2947
2948 const VkVideoEncodeH265RateControlLayerInfoKHR videoEncodeH265RateControlLayerInfo = {
2949 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR, // VkStructureType sType;
2950 DE_NULL, // const void* pNext;
2951 useMinQp, // VkBool32 useMinQp;
2952 videoEncodeH265MinQp, // VkVideoEncodeH265QpKHR minQp;
2953 useMaxQp, // VkBool32 useMaxQp;
2954 videoEncodeH265MaxQp, // VkVideoEncodeH265QpKHR maxQp;
2955 true, // VkBool32 useMaxFrameSize;
2956 videoEncodeH265FrameSize, // VkVideoEncodeH265FrameSizeKHR maxFrameSize;
2957 };
2958
2959 return de::MovePtr<VkVideoEncodeH265RateControlLayerInfoKHR>(
2960 new VkVideoEncodeH265RateControlLayerInfoKHR(videoEncodeH265RateControlLayerInfo));
2961 }
2962
getVideoEncodeRateControlLayerInfo(const void * pNext,VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode,const uint32_t frameRateNumerator)2963 de::MovePtr<VkVideoEncodeRateControlLayerInfoKHR> getVideoEncodeRateControlLayerInfo(
2964 const void *pNext, VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode, const uint32_t frameRateNumerator)
2965 {
2966 const VkVideoEncodeRateControlLayerInfoKHR videoEncodeRateControlLayerInfo = {
2967 VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR, // VkStructureType sType;
2968 pNext, // const void* pNext;
2969 50000, // uint64_t averageBitrate;
2970 static_cast<uint64_t>(
2971 rateControlMode == VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR ? 50000 : 75000), // uint64_t maxBitrate;
2972 frameRateNumerator, // uint32_t frameRateNumerator;
2973 1, // uint32_t frameRateDenominator;
2974 };
2975
2976 return de::MovePtr<VkVideoEncodeRateControlLayerInfoKHR>(
2977 new VkVideoEncodeRateControlLayerInfoKHR(videoEncodeRateControlLayerInfo));
2978 }
2979
getVideoEncodeRateControlInfo(const void * pNext,VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode,VkVideoEncodeRateControlLayerInfoKHR * videoEncodeRateControlLayerInfo)2980 de::MovePtr<VkVideoEncodeRateControlInfoKHR> getVideoEncodeRateControlInfo(
2981 const void *pNext, VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode,
2982 VkVideoEncodeRateControlLayerInfoKHR *videoEncodeRateControlLayerInfo)
2983 {
2984 const VkVideoEncodeRateControlInfoKHR videoEncodeRateControlInfo = {
2985 VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR, // VkStructureType sType;
2986 pNext, // const void* pNext;
2987 static_cast<VkVideoEncodeRateControlFlagsKHR>(0u), // VkVideoEncodeRateControlFlagsKHR flags;
2988 rateControlMode, // VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
2989 videoEncodeRateControlLayerInfo == nullptr ? 0 : 1U, // uint8_t layerCount;
2990 videoEncodeRateControlLayerInfo, // const VkVideoEncodeRateControlLayerInfoKHR* pLayers;
2991 videoEncodeRateControlLayerInfo == nullptr ? 0 : 1000U, // uint32_t virtualBufferSizeInMs;
2992 videoEncodeRateControlLayerInfo == nullptr ? 0 : 500U, // uint32_t initialVirtualBufferSizeInMs;
2993 };
2994
2995 return de::MovePtr<VkVideoEncodeRateControlInfoKHR>(
2996 new VkVideoEncodeRateControlInfoKHR(videoEncodeRateControlInfo));
2997 }
2998
getvideoEncodeH264QualityLevelProperties(int32_t qpI,int32_t qpP,int32_t qpB)2999 de::MovePtr<VkVideoEncodeH264QualityLevelPropertiesKHR> getvideoEncodeH264QualityLevelProperties(int32_t qpI,
3000 int32_t qpP,
3001 int32_t qpB)
3002 {
3003 const VkVideoEncodeH264QpKHR preferredConstantQp = {
3004 qpI, // int32_t qpI;
3005 qpP, // int32_t qpP;
3006 qpB, // int32_t qpB;
3007 };
3008
3009 const VkVideoEncodeH264QualityLevelPropertiesKHR videoEncodeH264QualityLevelProperties = {
3010 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR, // VkStructureType sType;
3011 nullptr, // void* pNext;
3012 VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR, // VkVideoEncodeH264RateControlFlagsKHR preferredRateControlFlags;
3013 0, // uint32_t preferredGopFrameCount;
3014 0, // uint32_t preferredIdrPeriod;
3015 0, // uint32_t preferredConsecutiveBFrameCount;
3016 0, // uint32_t preferredTemporalLayerCount;
3017 preferredConstantQp, // VkVideoEncodeH264QpKHR preferredConstantQp;
3018 0, // uint32_t preferredMaxL0ReferenceCount;
3019 0, // uint32_t preferredMaxL1ReferenceCount;
3020 0, // VkBool32 preferredStdEntropyCodingModeFlag;
3021 };
3022
3023 return de::MovePtr<VkVideoEncodeH264QualityLevelPropertiesKHR>(
3024 new VkVideoEncodeH264QualityLevelPropertiesKHR(videoEncodeH264QualityLevelProperties));
3025 }
3026
getvideoEncodeH265QualityLevelProperties(int32_t qpI,int32_t qpP,int32_t qpB)3027 de::MovePtr<VkVideoEncodeH265QualityLevelPropertiesKHR> getvideoEncodeH265QualityLevelProperties(int32_t qpI,
3028 int32_t qpP,
3029 int32_t qpB)
3030 {
3031 const VkVideoEncodeH265QpKHR preferredConstantQp = {
3032 qpI, // int32_t qpI;
3033 qpP, // int32_t qpP;
3034 qpB, // int32_t qpB;
3035 };
3036
3037 const VkVideoEncodeH265QualityLevelPropertiesKHR videoEncodeH265QualityLevelProperties = {
3038 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR, // VkStructureType sType;
3039 nullptr, // void* pNext;
3040 VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR, // VkVideoEncodeH265RateControlFlagsKHR preferredRateControlFlags;
3041 0, // uint32_t preferredGopFrameCount;
3042 0, // uint32_t preferredIdrPeriod;
3043 0, // uint32_t preferredConsecutiveBFrameCount;
3044 0, // uint32_t preferredSubLayerCount;
3045 preferredConstantQp, // VkVideoEncodeH265QpKHR preferredConstantQp;
3046 0, // uint32_t preferredMaxL0ReferenceCount;
3047 0, // uint32_t preferredMaxL1ReferenceCount;
3048 };
3049
3050 return de::MovePtr<VkVideoEncodeH265QualityLevelPropertiesKHR>(
3051 new VkVideoEncodeH265QualityLevelPropertiesKHR(videoEncodeH265QualityLevelProperties));
3052 }
3053
getVideoEncodeQualityLevelProperties(void * pNext,VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode)3054 de::MovePtr<VkVideoEncodeQualityLevelPropertiesKHR> getVideoEncodeQualityLevelProperties(
3055 void *pNext, VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode)
3056 {
3057 const VkVideoEncodeQualityLevelPropertiesKHR videoEncodeQualityLevelProperties = {
3058 VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR, // VkStructureType sType;
3059 pNext, // void* pNext;
3060 preferredRateControlMode, // VkVideoEncodeRateControlModeFlagBitsKHR preferredRateControlMode;
3061 1U, // uint32_t preferredRateControlLayerCount;
3062 };
3063
3064 return de::MovePtr<VkVideoEncodeQualityLevelPropertiesKHR>(
3065 new VkVideoEncodeQualityLevelPropertiesKHR(videoEncodeQualityLevelProperties));
3066 }
3067
getPhysicalDeviceVideoEncodeQualityLevelInfo(const VkVideoProfileInfoKHR * pVideoProfile,uint32_t qualityLevel)3068 de::MovePtr<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR> getPhysicalDeviceVideoEncodeQualityLevelInfo(
3069 const VkVideoProfileInfoKHR *pVideoProfile, uint32_t qualityLevel)
3070 {
3071 VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR physicalDeviceVideoEncodeQualityLevelInfo = {
3072 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, // VkStructureType sType;
3073 nullptr, // const void* pNext;
3074 pVideoProfile, // const VkVideoProfileInfoKHR* pVideoProfile;
3075 qualityLevel, // uint32_t qualityLevel;
3076 };
3077
3078 return de::MovePtr<VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR>(
3079 new VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR(physicalDeviceVideoEncodeQualityLevelInfo));
3080 }
3081
getVideoEncodeQualityLevelInfo(uint32_t qualityLevel,VkVideoEncodeQualityLevelPropertiesKHR * videoEncodeQualityLevelProperties)3082 de::MovePtr<VkVideoEncodeQualityLevelInfoKHR> getVideoEncodeQualityLevelInfo(
3083 uint32_t qualityLevel, VkVideoEncodeQualityLevelPropertiesKHR *videoEncodeQualityLevelProperties)
3084 {
3085 const VkVideoEncodeQualityLevelInfoKHR videoEncodeQualityLevelInfo = {
3086 VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR, // VkStructureType sType;
3087 videoEncodeQualityLevelProperties, // const void* pNext;
3088 qualityLevel, // uint32_t qualityLevel;
3089 };
3090
3091 return de::MovePtr<VkVideoEncodeQualityLevelInfoKHR>(
3092 new VkVideoEncodeQualityLevelInfoKHR(videoEncodeQualityLevelInfo));
3093 }
3094
getVideoCodingControlInfo(VkVideoCodingControlFlagsKHR flags,const void * pNext)3095 de::MovePtr<VkVideoCodingControlInfoKHR> getVideoCodingControlInfo(VkVideoCodingControlFlagsKHR flags,
3096 const void *pNext)
3097 {
3098 const VkVideoCodingControlInfoKHR videoEncodingControlInfo = {
3099 VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR, // VkStructureType sType;
3100 pNext, // const void* pNext;
3101 flags, // VkVideoCodingControlFlagsKHR flags;
3102 };
3103
3104 return de::MovePtr<VkVideoCodingControlInfoKHR>(new VkVideoCodingControlInfoKHR(videoEncodingControlInfo));
3105 }
3106
3107 } // namespace video
3108 } // namespace vkt
3109