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