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 Capabilities tests
22 *//*--------------------------------------------------------------------*/
23
24 #include "vktVideoCapabilitiesTests.hpp"
25 #include "vktVideoTestUtils.hpp"
26
27 #include "vkDefs.hpp"
28 #include "vkTypeUtil.hpp"
29
30 #include "vktTestCase.hpp"
31 #include "vktCustomInstancesDevices.hpp"
32
33 namespace vkt
34 {
35 namespace video
36 {
37 namespace
38 {
39 using namespace vk;
40 using namespace std;
41
42 enum TestType
43 {
44 TEST_TYPE_QUEUE_SUPPORT_QUERY, // Test case 1
45 TEST_TYPE_H264_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 2 iteration 1 ?
46 TEST_TYPE_H264_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 2 iteration 2 ?
47 TEST_TYPE_H264_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 3 iteration 1
48 TEST_TYPE_H264_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 3 iteration 2
49 TEST_TYPE_H265_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 4a iteration 1 ?
50 TEST_TYPE_H265_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 4a iteration 2 ?
51 TEST_TYPE_H265_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 4b iteration 1
52 TEST_TYPE_H265_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY, // Test case 4b iteration 2
53 TEST_TYPE_AV1_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY,
54 TEST_TYPE_AV1_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY,
55 TEST_TYPE_H264_DECODE_CAPABILITIES_QUERY, // Test case 5a
56 TEST_TYPE_H264_ENCODE_CAPABILITIES_QUERY, // Test case 5b
57 TEST_TYPE_H265_DECODE_CAPABILITIES_QUERY, // Test case 5c
58 TEST_TYPE_H265_ENCODE_CAPABILITIES_QUERY, // Test case 5d
59 TEST_TYPE_AV1_DECODE_CAPABILITIES_QUERY,
60 TEST_TYPE_LAST
61 };
62
63 struct CaseDef
64 {
65 TestType testType;
66 };
67
68 #define VALIDATE_FIELD_EQUAL(A, B, X) \
69 if (deMemCmp(&A.X, &B.X, sizeof(A.X)) != 0) \
70 TCU_FAIL("Unequal " #A "." #X)
71
72 class VideoQueueQueryTestInstance : public VideoBaseTestInstance
73 {
74 public:
75 VideoQueueQueryTestInstance(Context &context, const CaseDef &data);
76 ~VideoQueueQueryTestInstance(void);
77
78 tcu::TestStatus iterate(void);
79
80 private:
81 CaseDef m_caseDef;
82 };
83
VideoQueueQueryTestInstance(Context & context,const CaseDef & data)84 VideoQueueQueryTestInstance::VideoQueueQueryTestInstance(Context &context, const CaseDef &data)
85 : VideoBaseTestInstance(context)
86 , m_caseDef(data)
87 {
88 DE_UNREF(m_caseDef);
89 }
90
~VideoQueueQueryTestInstance(void)91 VideoQueueQueryTestInstance::~VideoQueueQueryTestInstance(void)
92 {
93 }
94
iterate(void)95 tcu::TestStatus VideoQueueQueryTestInstance::iterate(void)
96 {
97 const InstanceInterface &vk = m_context.getInstanceInterface();
98 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
99 uint32_t queueFamilyPropertiesCount = 0u;
100 vector<VkQueueFamilyProperties2> queueFamilyProperties2;
101 vector<VkQueueFamilyVideoPropertiesKHR> videoQueueFamilyProperties2;
102 bool encodePass = false;
103 bool decodePass = false;
104
105 vk.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyPropertiesCount, DE_NULL);
106
107 if (queueFamilyPropertiesCount == 0u)
108 TCU_FAIL("Device reports an empty set of queue family properties");
109
110 queueFamilyProperties2.resize(queueFamilyPropertiesCount);
111 videoQueueFamilyProperties2.resize(queueFamilyPropertiesCount);
112
113 for (size_t ndx = 0; ndx < queueFamilyPropertiesCount; ++ndx)
114 {
115 queueFamilyProperties2[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
116 queueFamilyProperties2[ndx].pNext = &videoQueueFamilyProperties2[ndx];
117 videoQueueFamilyProperties2[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR;
118 videoQueueFamilyProperties2[ndx].pNext = DE_NULL;
119 videoQueueFamilyProperties2[ndx].videoCodecOperations = 0;
120 }
121
122 vk.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &queueFamilyPropertiesCount,
123 queueFamilyProperties2.data());
124
125 if (queueFamilyPropertiesCount != queueFamilyProperties2.size())
126 TCU_FAIL("Device returns less queue families than initially reported");
127
128 for (uint32_t ndx = 0; ndx < queueFamilyPropertiesCount; ++ndx)
129 {
130 const uint32_t queueCount = queueFamilyProperties2[ndx].queueFamilyProperties.queueCount;
131 const VkQueueFlags queueFlags = queueFamilyProperties2[ndx].queueFamilyProperties.queueFlags;
132 const VkVideoCodecOperationFlagsKHR queueVideoCodecOperations =
133 videoQueueFamilyProperties2[ndx].videoCodecOperations;
134
135 if ((queueFlags & VK_QUEUE_VIDEO_ENCODE_BIT_KHR) != 0)
136 {
137 if (!VideoDevice::isVideoEncodeOperation(queueVideoCodecOperations))
138 TCU_FAIL("Invalid codec operations for encode queue");
139
140 if (queueCount == 0)
141 TCU_FAIL("Video encode queue returned queueCount is zero");
142
143 encodePass = true;
144 }
145
146 if ((queueFlags & VK_QUEUE_VIDEO_DECODE_BIT_KHR) != 0)
147 {
148 if (!VideoDevice::isVideoDecodeOperation(queueVideoCodecOperations))
149 TCU_FAIL("Invalid codec operations for decode queue");
150
151 if (queueCount == 0)
152 TCU_FAIL("Video decode queue returned queueCount is zero");
153
154 decodePass = true;
155 }
156 }
157
158 if (!m_context.isDeviceFunctionalitySupported("VK_KHR_video_encode_queue"))
159 encodePass = false;
160
161 if (!m_context.isDeviceFunctionalitySupported("VK_KHR_video_decode_queue"))
162 decodePass = false;
163
164 if (encodePass || decodePass)
165 return tcu::TestStatus::pass("Pass");
166 else
167 return tcu::TestStatus::fail("Neither encode, nor decode is available");
168 }
169
170 template <typename ProfileOperation>
171 class VideoFormatPropertiesQueryTestInstance : public VideoBaseTestInstance
172 {
173 public:
174 VideoFormatPropertiesQueryTestInstance(Context &context, const CaseDef &data);
175 ~VideoFormatPropertiesQueryTestInstance(void);
176 tcu::TestStatus iterate(void);
177
178 private:
179 ProfileOperation getProfileOperation(void);
180
181 CaseDef m_caseDef;
182 VkVideoCodecOperationFlagsKHR m_videoCodecOperation;
183 VkImageUsageFlags m_imageUsageFlags;
184 };
185
186 template <typename ProfileOperation>
VideoFormatPropertiesQueryTestInstance(Context & context,const CaseDef & data)187 VideoFormatPropertiesQueryTestInstance<ProfileOperation>::VideoFormatPropertiesQueryTestInstance(Context &context,
188 const CaseDef &data)
189 : VideoBaseTestInstance(context)
190 , m_caseDef(data)
191 {
192 switch (m_caseDef.testType)
193 {
194 case TEST_TYPE_H264_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
195 case TEST_TYPE_H264_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
196 m_videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR;
197 break;
198 case TEST_TYPE_H264_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
199 case TEST_TYPE_H264_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
200 m_videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR;
201 break;
202 case TEST_TYPE_H265_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
203 case TEST_TYPE_H265_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
204 m_videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR;
205 break;
206 case TEST_TYPE_H265_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
207 case TEST_TYPE_H265_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
208 m_videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR;
209 break;
210 case TEST_TYPE_AV1_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
211 case TEST_TYPE_AV1_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
212 m_videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
213 break;
214
215 default:
216 TCU_THROW(InternalError, "Unknown testType");
217 }
218
219 switch (m_caseDef.testType)
220 {
221 case TEST_TYPE_H264_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
222 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR;
223 break;
224 case TEST_TYPE_H264_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
225 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
226 break;
227 case TEST_TYPE_H264_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
228 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR;
229 break;
230 case TEST_TYPE_H264_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
231 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR;
232 break;
233 case TEST_TYPE_H265_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
234 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR;
235 break;
236 case TEST_TYPE_H265_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
237 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
238 break;
239 case TEST_TYPE_H265_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
240 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR;
241 break;
242 case TEST_TYPE_H265_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
243 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR;
244 break;
245 case TEST_TYPE_AV1_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
246 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR;
247 break;
248 case TEST_TYPE_AV1_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
249 m_imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR;
250 break;
251
252 default:
253 TCU_THROW(InternalError, "Unknown testType");
254 }
255 }
256
257 template <typename ProfileOperation>
~VideoFormatPropertiesQueryTestInstance(void)258 VideoFormatPropertiesQueryTestInstance<ProfileOperation>::~VideoFormatPropertiesQueryTestInstance(void)
259 {
260 }
261
262 template <>
263 VkVideoDecodeH264ProfileInfoKHR VideoFormatPropertiesQueryTestInstance<
getProfileOperation(void)264 VkVideoDecodeH264ProfileInfoKHR>::getProfileOperation(void)
265 {
266 return getProfileOperationH264Decode();
267 }
268
269 template <>
270 VkVideoEncodeH264ProfileInfoKHR VideoFormatPropertiesQueryTestInstance<
getProfileOperation()271 VkVideoEncodeH264ProfileInfoKHR>::getProfileOperation()
272 {
273 return getProfileOperationH264Encode();
274 }
275
276 template <>
277 VkVideoDecodeH265ProfileInfoKHR VideoFormatPropertiesQueryTestInstance<
getProfileOperation()278 VkVideoDecodeH265ProfileInfoKHR>::getProfileOperation()
279 {
280 return getProfileOperationH265Decode();
281 }
282
283 template <>
284 VkVideoEncodeH265ProfileInfoKHR VideoFormatPropertiesQueryTestInstance<
getProfileOperation()285 VkVideoEncodeH265ProfileInfoKHR>::getProfileOperation()
286 {
287 return getProfileOperationH265Encode();
288 }
289
290 template <>
291 VkVideoDecodeAV1ProfileInfoKHR VideoFormatPropertiesQueryTestInstance<
getProfileOperation()292 VkVideoDecodeAV1ProfileInfoKHR>::getProfileOperation()
293 {
294 return getProfileOperationAV1Decode();
295 }
296
297 template <typename ProfileOperation>
iterate(void)298 tcu::TestStatus VideoFormatPropertiesQueryTestInstance<ProfileOperation>::iterate(void)
299 {
300 const InstanceInterface &vk = m_context.getInstanceInterface();
301 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
302 uint32_t videoFormatPropertiesCount = 0u;
303 bool testResult = false;
304
305 const ProfileOperation videoProfileOperation = getProfileOperation();
306 const VkVideoCodecOperationFlagBitsKHR videoCodecOperation =
307 static_cast<VkVideoCodecOperationFlagBitsKHR>(m_videoCodecOperation);
308 const VkVideoProfileInfoKHR videoProfile = {
309 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
310 (void *)&videoProfileOperation, // void* pNext;
311 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
312 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
313 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
314 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
315 };
316 const VkVideoProfileListInfoKHR videoProfiles = {
317 VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR, // VkStructureType sType;
318 DE_NULL, // void* pNext;
319 1u, // uint32_t profilesCount;
320 &videoProfile, // const VkVideoProfileInfoKHR* pProfiles;
321 };
322
323 const VkPhysicalDeviceVideoFormatInfoKHR videoFormatInfo = {
324 VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR, // VkStructureType sType;
325 const_cast<VkVideoProfileListInfoKHR *>(&videoProfiles), // const void* pNext;
326 m_imageUsageFlags, // VkImageUsageFlags imageUsage;
327 };
328 const VkImageUsageFlags imageUsageFlagsDPB =
329 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR | VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR;
330 const bool imageUsageDPB = (videoFormatInfo.imageUsage & imageUsageFlagsDPB) != 0;
331
332 {
333 const VkResult result = vk.getPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, &videoFormatInfo,
334 &videoFormatPropertiesCount, DE_NULL);
335
336 if (result != VK_SUCCESS)
337 {
338 ostringstream failMsg;
339
340 failMsg << "Failed query call to vkGetPhysicalDeviceVideoFormatPropertiesKHR with " << result;
341
342 return tcu::TestStatus::fail(failMsg.str());
343 }
344
345 if (videoFormatPropertiesCount == 0)
346 return tcu::TestStatus::fail("vkGetPhysicalDeviceVideoFormatPropertiesKHR reports 0 formats");
347 }
348
349 {
350 const VkVideoFormatPropertiesKHR videoFormatPropertiesKHR = {
351 VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR, // VkStructureType sType;
352 DE_NULL, // void* pNext;
353 VK_FORMAT_MAX_ENUM, // VkFormat format;
354 vk::makeComponentMappingIdentity(), // VkComponentMapping componentMapping;
355 (VkImageCreateFlags)0u, // VkImageCreateFlags imageCreateFlags;
356 VK_IMAGE_TYPE_2D, // VkImageType imageType;
357 VK_IMAGE_TILING_OPTIMAL, // VkImageTiling imageTiling;
358 VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR |
359 VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR, // VkImageUsageFlags imageUsageFlags;
360 };
361 std::vector<VkVideoFormatPropertiesKHR> videoFormatProperties(videoFormatPropertiesCount,
362 videoFormatPropertiesKHR);
363
364 const VkResult result = vk.getPhysicalDeviceVideoFormatPropertiesKHR(
365 physicalDevice, &videoFormatInfo, &videoFormatPropertiesCount, videoFormatProperties.data());
366
367 if (result != VK_SUCCESS)
368 {
369 ostringstream failMsg;
370
371 failMsg << "Failed query data call to vkGetPhysicalDeviceVideoFormatPropertiesKHR with " << result;
372
373 return tcu::TestStatus::fail(failMsg.str());
374 }
375
376 if (videoFormatPropertiesCount == 0)
377 return tcu::TestStatus::fail(
378 "vkGetPhysicalDeviceVideoFormatPropertiesKHR reports 0 formats supported for chosen encding/decoding");
379
380 if (videoFormatPropertiesCount != videoFormatProperties.size())
381 return tcu::TestStatus::fail("Number of formats returned is less than reported.");
382
383 for (const auto &videoFormatProperty : videoFormatProperties)
384 {
385 if (videoFormatProperty.format == VK_FORMAT_MAX_ENUM)
386 return tcu::TestStatus::fail("Format is not written");
387
388 if (videoFormatProperty.format == VK_FORMAT_UNDEFINED)
389 {
390 if (!imageUsageDPB)
391 TCU_FAIL("VK_FORMAT_UNDEFINED is allowed only for DPB image usage");
392
393 if (videoFormatProperties.size() != 1)
394 TCU_FAIL("VK_FORMAT_UNDEFINED must be the only format returned for opaque DPB");
395
396 testResult = true;
397
398 break;
399 }
400
401 if (videoFormatProperty.format == VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM ||
402 videoFormatProperty.format == VK_FORMAT_G8_B8R8_2PLANE_420_UNORM)
403 {
404 testResult = true;
405
406 break;
407 }
408 }
409 }
410
411 if (testResult)
412 return tcu::TestStatus::pass("Pass");
413 else
414 return tcu::TestStatus::fail("Fail");
415 }
416
417 typedef VideoFormatPropertiesQueryTestInstance<VkVideoDecodeH264ProfileInfoKHR>
418 VideoFormatPropertiesQueryH264DecodeTestInstance;
419 typedef VideoFormatPropertiesQueryTestInstance<VkVideoEncodeH264ProfileInfoKHR>
420 VideoFormatPropertiesQueryH264EncodeTestInstance;
421 typedef VideoFormatPropertiesQueryTestInstance<VkVideoDecodeH265ProfileInfoKHR>
422 VideoFormatPropertiesQueryH265DecodeTestInstance;
423 typedef VideoFormatPropertiesQueryTestInstance<VkVideoEncodeH265ProfileInfoKHR>
424 VideoFormatPropertiesQueryH265EncodeTestInstance;
425 typedef VideoFormatPropertiesQueryTestInstance<VkVideoDecodeAV1ProfileInfoKHR>
426 VideoFormatPropertiesQueryAV1DecodeTestInstance;
427
428 class VideoCapabilitiesQueryTestInstance : public VideoBaseTestInstance
429 {
430 public:
431 VideoCapabilitiesQueryTestInstance(Context &context, const CaseDef &data);
432 ~VideoCapabilitiesQueryTestInstance(void);
433
434 protected:
435 void validateVideoCapabilities(const VkVideoCapabilitiesKHR &videoCapabilitiesKHR,
436 const VkVideoCapabilitiesKHR &videoCapabilitiesKHRSecond);
437 void validateVideoDecodeCapabilities(const VkVideoDecodeCapabilitiesKHR &videoDecodeCapabilitiesKHR,
438 const VkVideoDecodeCapabilitiesKHR &videoDecodeCapabilitiesKHRSecond);
439 void validateVideoEncodeCapabilities(const VkVideoEncodeCapabilitiesKHR &videoEncodeCapabilitiesKHR,
440 const VkVideoEncodeCapabilitiesKHR &videoEncodeCapabilitiesKHRSecond);
441 void validateExtensionProperties(const VkExtensionProperties &extensionProperties,
442 const VkExtensionProperties &extensionPropertiesSecond);
443 CaseDef m_caseDef;
444 };
445
VideoCapabilitiesQueryTestInstance(Context & context,const CaseDef & data)446 VideoCapabilitiesQueryTestInstance::VideoCapabilitiesQueryTestInstance(Context &context, const CaseDef &data)
447 : VideoBaseTestInstance(context)
448 , m_caseDef(data)
449 {
450 DE_UNREF(m_caseDef);
451 }
452
~VideoCapabilitiesQueryTestInstance(void)453 VideoCapabilitiesQueryTestInstance::~VideoCapabilitiesQueryTestInstance(void)
454 {
455 }
456
validateVideoCapabilities(const VkVideoCapabilitiesKHR & videoCapabilitiesKHR,const VkVideoCapabilitiesKHR & videoCapabilitiesKHRSecond)457 void VideoCapabilitiesQueryTestInstance::validateVideoCapabilities(
458 const VkVideoCapabilitiesKHR &videoCapabilitiesKHR, const VkVideoCapabilitiesKHR &videoCapabilitiesKHRSecond)
459 {
460 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, sType);
461 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, flags);
462 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, minBitstreamBufferOffsetAlignment);
463 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, minBitstreamBufferSizeAlignment);
464 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, pictureAccessGranularity);
465 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, minCodedExtent);
466 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxCodedExtent);
467 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxDpbSlots);
468 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxActiveReferencePictures);
469 validateExtensionProperties(videoCapabilitiesKHR.stdHeaderVersion, videoCapabilitiesKHRSecond.stdHeaderVersion);
470
471 const VkVideoCapabilityFlagsKHR videoCapabilityFlagsKHR =
472 VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR | VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR;
473
474 if ((videoCapabilitiesKHR.flags & ~videoCapabilityFlagsKHR) != 0)
475 TCU_FAIL("Undeclared videoCapabilitiesKHR.flags returned");
476
477 if (!deIsPowerOfTwo64(videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment))
478 TCU_FAIL("Expected to be Power-Of-Two: videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment");
479
480 if (!deIsPowerOfTwo64(videoCapabilitiesKHR.minBitstreamBufferSizeAlignment))
481 TCU_FAIL("Expected to be Power-Of-Two: videoCapabilitiesKHR.minBitstreamBufferSizeAlignment");
482
483 if (videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment == 0)
484 TCU_FAIL("Expected to be non zero: videoCapabilitiesKHR.minBitstreamBufferOffsetAlignment");
485
486 if (videoCapabilitiesKHR.minBitstreamBufferSizeAlignment == 0)
487 TCU_FAIL("Expected to be non zero: videoCapabilitiesKHR.minBitstreamBufferSizeAlignment");
488
489 if (videoCapabilitiesKHR.pictureAccessGranularity.width == 0)
490 TCU_FAIL("Expected to be non-zero: videoCapabilitiesKHR.pictureAccessGranularity.width");
491
492 if (videoCapabilitiesKHR.pictureAccessGranularity.height == 0)
493 TCU_FAIL("Expected to be non-zero: videoCapabilitiesKHR.pictureAccessGranularity.height");
494
495 if (videoCapabilitiesKHR.minCodedExtent.width == 0 || videoCapabilitiesKHR.minCodedExtent.height == 0)
496 TCU_FAIL("Invalid videoCapabilitiesKHR.minCodedExtent");
497
498 if (videoCapabilitiesKHR.maxCodedExtent.width < videoCapabilitiesKHR.minCodedExtent.width)
499 TCU_FAIL("Invalid videoCapabilitiesKHR.maxCodedExtent.width");
500
501 if (videoCapabilitiesKHR.maxCodedExtent.height < videoCapabilitiesKHR.minCodedExtent.height)
502 TCU_FAIL("Invalid videoCapabilitiesKHR.maxCodedExtent.height");
503
504 if (videoCapabilitiesKHR.maxDpbSlots == 0)
505 TCU_FAIL("Invalid videoCapabilitiesKHR.maxDpbSlots");
506
507 if (videoCapabilitiesKHR.maxActiveReferencePictures == 0)
508 TCU_FAIL("Invalid videoCapabilitiesKHR.maxActiveReferencePictures");
509 }
510
validateVideoDecodeCapabilities(const VkVideoDecodeCapabilitiesKHR & videoDecodeCapabilitiesKHR,const VkVideoDecodeCapabilitiesKHR & videoDecodeCapabilitiesKHRSecond)511 void VideoCapabilitiesQueryTestInstance::validateVideoDecodeCapabilities(
512 const VkVideoDecodeCapabilitiesKHR &videoDecodeCapabilitiesKHR,
513 const VkVideoDecodeCapabilitiesKHR &videoDecodeCapabilitiesKHRSecond)
514 {
515 const VkVideoDecodeCapabilityFlagsKHR videoDecodeCapabilitiesFlags =
516 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR |
517 VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR;
518
519 VALIDATE_FIELD_EQUAL(videoDecodeCapabilitiesKHR, videoDecodeCapabilitiesKHRSecond, sType);
520 VALIDATE_FIELD_EQUAL(videoDecodeCapabilitiesKHR, videoDecodeCapabilitiesKHRSecond, flags);
521
522 if ((videoDecodeCapabilitiesKHR.flags & ~videoDecodeCapabilitiesFlags) != 0)
523 TCU_FAIL("Undefined videoDecodeCapabilitiesKHR.flags");
524 }
525
validateVideoEncodeCapabilities(const VkVideoEncodeCapabilitiesKHR & videoEncodeCapabilitiesKHR,const VkVideoEncodeCapabilitiesKHR & videoEncodeCapabilitiesKHRSecond)526 void VideoCapabilitiesQueryTestInstance::validateVideoEncodeCapabilities(
527 const VkVideoEncodeCapabilitiesKHR &videoEncodeCapabilitiesKHR,
528 const VkVideoEncodeCapabilitiesKHR &videoEncodeCapabilitiesKHRSecond)
529 {
530 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, sType);
531 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, flags);
532 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, rateControlModes);
533 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, maxRateControlLayers);
534 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, maxQualityLevels);
535 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, encodeInputPictureGranularity);
536 VALIDATE_FIELD_EQUAL(videoEncodeCapabilitiesKHR, videoEncodeCapabilitiesKHRSecond, supportedEncodeFeedbackFlags);
537
538 const VkVideoEncodeCapabilityFlagsKHR videoEncodeCapabilityFlags =
539 VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR;
540
541 if ((videoEncodeCapabilitiesKHR.flags & ~videoEncodeCapabilityFlags) != 0)
542 TCU_FAIL("Undeclared VkVideoEncodeCapabilitiesKHR.flags returned");
543
544 if (videoEncodeCapabilitiesKHR.maxRateControlLayers == 0)
545 TCU_FAIL("videoEncodeCapabilitiesKHR.maxRateControlLayers is zero. Implementations must report at least 1.");
546
547 if (videoEncodeCapabilitiesKHR.maxQualityLevels == 0)
548 TCU_FAIL("videoEncodeCapabilitiesKHR.maxQualityLevels is zero. Implementations must report at least 1.");
549 }
550
validateExtensionProperties(const VkExtensionProperties & extensionProperties,const VkExtensionProperties & extensionPropertiesSecond)551 void VideoCapabilitiesQueryTestInstance::validateExtensionProperties(
552 const VkExtensionProperties &extensionProperties, const VkExtensionProperties &extensionPropertiesSecond)
553 {
554 VALIDATE_FIELD_EQUAL(extensionProperties, extensionPropertiesSecond, specVersion);
555
556 for (size_t ndx = 0; ndx < VK_MAX_EXTENSION_NAME_SIZE; ++ndx)
557 {
558 if (extensionProperties.extensionName[ndx] != extensionPropertiesSecond.extensionName[ndx])
559 TCU_FAIL("Unequal extensionProperties.extensionName");
560
561 if (extensionProperties.extensionName[ndx] == 0)
562 return;
563 }
564
565 TCU_FAIL("Non-zero terminated string extensionProperties.extensionName");
566 }
567
568 class VideoCapabilitiesQueryH264DecodeTestInstance : public VideoCapabilitiesQueryTestInstance
569 {
570 public:
571 VideoCapabilitiesQueryH264DecodeTestInstance(Context &context, const CaseDef &data);
572 virtual ~VideoCapabilitiesQueryH264DecodeTestInstance(void);
573 tcu::TestStatus iterate(void);
574
575 protected:
576 void validateVideoCapabilitiesExt(const VkVideoDecodeH264CapabilitiesKHR &videoCapabilitiesKHR,
577 const VkVideoDecodeH264CapabilitiesKHR &videoCapabilitiesKHRSecond);
578 };
579
VideoCapabilitiesQueryH264DecodeTestInstance(Context & context,const CaseDef & data)580 VideoCapabilitiesQueryH264DecodeTestInstance::VideoCapabilitiesQueryH264DecodeTestInstance(Context &context,
581 const CaseDef &data)
582 : VideoCapabilitiesQueryTestInstance(context, data)
583 {
584 }
585
~VideoCapabilitiesQueryH264DecodeTestInstance(void)586 VideoCapabilitiesQueryH264DecodeTestInstance::~VideoCapabilitiesQueryH264DecodeTestInstance(void)
587 {
588 }
589
iterate(void)590 tcu::TestStatus VideoCapabilitiesQueryH264DecodeTestInstance::iterate(void)
591 {
592 const InstanceInterface &vk = m_context.getInstanceInterface();
593 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
594 const VkVideoCodecOperationFlagBitsKHR videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR;
595 const VkVideoDecodeH264ProfileInfoKHR videoProfileOperation = {
596 VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR, // VkStructureType sType;
597 DE_NULL, // const void* pNext;
598 STD_VIDEO_H264_PROFILE_IDC_BASELINE, // StdVideoH264ProfileIdc stdProfileIdc;
599 VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR, // VkVideoDecodeH264PictureLayoutFlagsKHR pictureLayout;
600 };
601 const VkVideoProfileInfoKHR videoProfile = {
602 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
603 (void *)&videoProfileOperation, // void* pNext;
604 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
605 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
606 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
607 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
608 };
609
610 VkVideoDecodeH264CapabilitiesKHR videoDecodeH264Capabilities[2];
611 VkVideoDecodeCapabilitiesKHR videoDecodeCapabilities[2];
612 VkVideoCapabilitiesKHR videoCapabilites[2];
613
614 for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(videoCapabilites); ++ndx)
615 {
616 const uint8_t filling = (ndx == 0) ? 0x00 : 0xFF;
617
618 deMemset(&videoCapabilites[ndx], filling, sizeof(videoCapabilites[ndx]));
619 deMemset(&videoDecodeCapabilities[ndx], filling, sizeof(videoDecodeCapabilities[ndx]));
620 deMemset(&videoDecodeH264Capabilities[ndx], filling, sizeof(videoDecodeH264Capabilities[ndx]));
621
622 videoCapabilites[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
623 videoCapabilites[ndx].pNext = &videoDecodeCapabilities[ndx];
624 videoDecodeCapabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
625 videoDecodeCapabilities[ndx].pNext = &videoDecodeH264Capabilities[ndx];
626 videoDecodeH264Capabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR;
627 videoDecodeH264Capabilities[ndx].pNext = DE_NULL;
628
629 VkResult result =
630 vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, &videoProfile, &videoCapabilites[ndx]);
631
632 if (result != VK_SUCCESS)
633 {
634 ostringstream failMsg;
635
636 failMsg << "Failed query call to vkGetPhysicalDeviceVideoCapabilitiesKHR with " << result
637 << " at iteration " << ndx;
638
639 return tcu::TestStatus::fail(failMsg.str());
640 }
641 }
642
643 validateVideoCapabilities(videoCapabilites[0], videoCapabilites[1]);
644 validateExtensionProperties(videoCapabilites[0].stdHeaderVersion,
645 *getVideoExtensionProperties(videoCodecOperation));
646 validateVideoDecodeCapabilities(videoDecodeCapabilities[0], videoDecodeCapabilities[1]);
647 validateVideoCapabilitiesExt(videoDecodeH264Capabilities[0], videoDecodeH264Capabilities[1]);
648
649 return tcu::TestStatus::pass("Pass");
650 }
651
validateVideoCapabilitiesExt(const VkVideoDecodeH264CapabilitiesKHR & videoCapabilitiesKHR,const VkVideoDecodeH264CapabilitiesKHR & videoCapabilitiesKHRSecond)652 void VideoCapabilitiesQueryH264DecodeTestInstance::validateVideoCapabilitiesExt(
653 const VkVideoDecodeH264CapabilitiesKHR &videoCapabilitiesKHR,
654 const VkVideoDecodeH264CapabilitiesKHR &videoCapabilitiesKHRSecond)
655 {
656 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, sType);
657 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxLevelIdc);
658 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, fieldOffsetGranularity);
659 }
660
661 class VideoCapabilitiesQueryH264EncodeTestInstance : public VideoCapabilitiesQueryTestInstance
662 {
663 public:
664 VideoCapabilitiesQueryH264EncodeTestInstance(Context &context, const CaseDef &data);
665 virtual ~VideoCapabilitiesQueryH264EncodeTestInstance(void);
666 tcu::TestStatus iterate(void);
667
668 private:
669 void validateVideoCapabilitiesExt(const VkVideoEncodeH264CapabilitiesKHR &videoCapabilitiesKHR,
670 const VkVideoEncodeH264CapabilitiesKHR &videoCapabilitiesKHRSecond);
671 };
672
VideoCapabilitiesQueryH264EncodeTestInstance(Context & context,const CaseDef & data)673 VideoCapabilitiesQueryH264EncodeTestInstance::VideoCapabilitiesQueryH264EncodeTestInstance(Context &context,
674 const CaseDef &data)
675 : VideoCapabilitiesQueryTestInstance(context, data)
676 {
677 }
678
~VideoCapabilitiesQueryH264EncodeTestInstance(void)679 VideoCapabilitiesQueryH264EncodeTestInstance::~VideoCapabilitiesQueryH264EncodeTestInstance(void)
680 {
681 }
682
iterate(void)683 tcu::TestStatus VideoCapabilitiesQueryH264EncodeTestInstance::iterate(void)
684 {
685 const InstanceInterface &vk = m_context.getInstanceInterface();
686 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
687 const VkVideoCodecOperationFlagBitsKHR videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR;
688 const VkVideoEncodeH264ProfileInfoKHR videoProfileOperation = {
689 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, // VkStructureType sType;
690 DE_NULL, // const void* pNext;
691 STD_VIDEO_H264_PROFILE_IDC_BASELINE, // StdVideoH264ProfileIdc stdProfileIdc;
692 };
693 const VkVideoProfileInfoKHR videoProfile = {
694 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
695 (void *)&videoProfileOperation, // void* pNext;
696 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
697 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
698 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
699 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
700 };
701 VkVideoEncodeH264CapabilitiesKHR videoEncodeH264Capabilities[2];
702 VkVideoEncodeCapabilitiesKHR videoEncodeCapabilities[2];
703 VkVideoCapabilitiesKHR videoCapabilites[2];
704
705 for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(videoCapabilites); ++ndx)
706 {
707 const uint8_t filling = (ndx == 0) ? 0x00 : 0xFF;
708
709 deMemset(&videoCapabilites[ndx], filling, sizeof(videoCapabilites[ndx]));
710 deMemset(&videoEncodeCapabilities[ndx], filling, sizeof(videoEncodeCapabilities[ndx]));
711 deMemset(&videoEncodeH264Capabilities[ndx], filling, sizeof(videoEncodeH264Capabilities[ndx]));
712
713 videoCapabilites[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
714 videoCapabilites[ndx].pNext = &videoEncodeCapabilities[ndx];
715 videoEncodeCapabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
716 videoEncodeCapabilities[ndx].pNext = &videoEncodeH264Capabilities[ndx];
717 videoEncodeH264Capabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR;
718 videoEncodeH264Capabilities[ndx].pNext = DE_NULL;
719
720 VkResult result =
721 vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, &videoProfile, &videoCapabilites[ndx]);
722
723 if (result != VK_SUCCESS)
724 {
725 ostringstream failMsg;
726
727 failMsg << "Failed query call to vkGetPhysicalDeviceVideoCapabilitiesKHR with " << result
728 << " at iteration " << ndx;
729
730 return tcu::TestStatus::fail(failMsg.str());
731 }
732 }
733
734 validateVideoCapabilities(videoCapabilites[0], videoCapabilites[1]);
735 validateVideoEncodeCapabilities(videoEncodeCapabilities[0], videoEncodeCapabilities[1]);
736 validateExtensionProperties(videoCapabilites[0].stdHeaderVersion,
737 *getVideoExtensionProperties(videoCodecOperation));
738 validateVideoCapabilitiesExt(videoEncodeH264Capabilities[0], videoEncodeH264Capabilities[1]);
739
740 return tcu::TestStatus::pass("Pass");
741 }
742
validateVideoCapabilitiesExt(const VkVideoEncodeH264CapabilitiesKHR & videoCapabilitiesKHR,const VkVideoEncodeH264CapabilitiesKHR & videoCapabilitiesKHRSecond)743 void VideoCapabilitiesQueryH264EncodeTestInstance::validateVideoCapabilitiesExt(
744 const VkVideoEncodeH264CapabilitiesKHR &videoCapabilitiesKHR,
745 const VkVideoEncodeH264CapabilitiesKHR &videoCapabilitiesKHRSecond)
746 {
747 const VkVideoEncodeH264CapabilityFlagsKHR videoCapabilityFlags =
748 VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR |
749 VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR |
750 VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR |
751 VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR |
752 VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR |
753 VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR |
754 VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR |
755 VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR |
756 VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR;
757
758 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, sType);
759 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, flags);
760 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxLevelIdc);
761 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxSliceCount);
762 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxPPictureL0ReferenceCount);
763 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxBPictureL0ReferenceCount);
764 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxL1ReferenceCount);
765 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxTemporalLayerCount);
766 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, expectDyadicTemporalLayerPattern);
767 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, minQp);
768 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxQp);
769 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, prefersGopRemainingFrames);
770 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, requiresGopRemainingFrames);
771
772 if (videoCapabilitiesKHR.flags == 0)
773 TCU_FAIL("videoCapabilitiesKHR.flags must not be 0");
774
775 if ((videoCapabilitiesKHR.flags & ~videoCapabilityFlags) != 0)
776 TCU_FAIL("Undefined videoCapabilitiesKHR.flags");
777 }
778
779 class VideoCapabilitiesQueryH265DecodeTestInstance : public VideoCapabilitiesQueryTestInstance
780 {
781 public:
782 VideoCapabilitiesQueryH265DecodeTestInstance(Context &context, const CaseDef &data);
783 virtual ~VideoCapabilitiesQueryH265DecodeTestInstance(void);
784 tcu::TestStatus iterate(void);
785
786 protected:
787 void validateVideoCapabilitiesExt(const VkVideoDecodeH265CapabilitiesKHR &videoCapabilitiesKHR,
788 const VkVideoDecodeH265CapabilitiesKHR &videoCapabilitiesKHRSecond);
789 };
790
VideoCapabilitiesQueryH265DecodeTestInstance(Context & context,const CaseDef & data)791 VideoCapabilitiesQueryH265DecodeTestInstance::VideoCapabilitiesQueryH265DecodeTestInstance(Context &context,
792 const CaseDef &data)
793 : VideoCapabilitiesQueryTestInstance(context, data)
794 {
795 }
796
~VideoCapabilitiesQueryH265DecodeTestInstance(void)797 VideoCapabilitiesQueryH265DecodeTestInstance::~VideoCapabilitiesQueryH265DecodeTestInstance(void)
798 {
799 }
800
iterate(void)801 tcu::TestStatus VideoCapabilitiesQueryH265DecodeTestInstance::iterate(void)
802 {
803 const InstanceInterface &vk = m_context.getInstanceInterface();
804 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
805 const VkVideoCodecOperationFlagBitsKHR videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR;
806 const VkVideoDecodeH265ProfileInfoKHR videoProfileOperation = {
807 VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR, // VkStructureType sType;
808 DE_NULL, // const void* pNext;
809 STD_VIDEO_H265_PROFILE_IDC_MAIN, // StdVideoH265ProfileIdc stdProfileIdc;
810 };
811 const VkVideoProfileInfoKHR videoProfile = {
812 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
813 (void *)&videoProfileOperation, // void* pNext;
814 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
815 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
816 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
817 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
818 };
819 VkVideoDecodeH265CapabilitiesKHR videoDecodeH265Capabilities[2];
820 VkVideoDecodeCapabilitiesKHR videoDecodeCapabilities[2];
821 VkVideoCapabilitiesKHR videoCapabilites[2];
822
823 for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(videoCapabilites); ++ndx)
824 {
825 const uint8_t filling = (ndx == 0) ? 0x00 : 0xFF;
826
827 deMemset(&videoCapabilites[ndx], filling, sizeof(videoCapabilites[ndx]));
828 deMemset(&videoDecodeCapabilities[ndx], filling, sizeof(videoDecodeCapabilities[ndx]));
829 deMemset(&videoDecodeH265Capabilities[ndx], filling, sizeof(videoDecodeH265Capabilities[ndx]));
830
831 videoCapabilites[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
832 videoCapabilites[ndx].pNext = &videoDecodeCapabilities[ndx];
833 videoDecodeCapabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
834 videoDecodeCapabilities[ndx].pNext = &videoDecodeH265Capabilities[ndx];
835 videoDecodeH265Capabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR;
836 videoDecodeH265Capabilities[ndx].pNext = DE_NULL;
837
838 VkResult result =
839 vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, &videoProfile, &videoCapabilites[ndx]);
840
841 if (result != VK_SUCCESS)
842 {
843 ostringstream failMsg;
844
845 failMsg << "Failed query call to vkGetPhysicalDeviceVideoCapabilitiesKHR with " << result
846 << " at iteration " << ndx;
847
848 return tcu::TestStatus::fail(failMsg.str());
849 }
850 }
851
852 validateVideoCapabilities(videoCapabilites[0], videoCapabilites[1]);
853 validateExtensionProperties(videoCapabilites[0].stdHeaderVersion,
854 *getVideoExtensionProperties(videoCodecOperation));
855 validateVideoDecodeCapabilities(videoDecodeCapabilities[0], videoDecodeCapabilities[1]);
856 validateVideoCapabilitiesExt(videoDecodeH265Capabilities[0], videoDecodeH265Capabilities[1]);
857
858 return tcu::TestStatus::pass("Pass");
859 }
860
validateVideoCapabilitiesExt(const VkVideoDecodeH265CapabilitiesKHR & videoCapabilitiesKHR,const VkVideoDecodeH265CapabilitiesKHR & videoCapabilitiesKHRSecond)861 void VideoCapabilitiesQueryH265DecodeTestInstance::validateVideoCapabilitiesExt(
862 const VkVideoDecodeH265CapabilitiesKHR &videoCapabilitiesKHR,
863 const VkVideoDecodeH265CapabilitiesKHR &videoCapabilitiesKHRSecond)
864 {
865 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, sType);
866 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxLevelIdc);
867 }
868
869 class VideoCapabilitiesQueryAV1DecodeTestInstance : public VideoCapabilitiesQueryTestInstance
870 {
871 public:
872 VideoCapabilitiesQueryAV1DecodeTestInstance(Context &context, const CaseDef &data);
873 virtual ~VideoCapabilitiesQueryAV1DecodeTestInstance(void);
874 tcu::TestStatus iterate(void);
875
876 protected:
877 void validateVideoCapabilitiesExt(const VkVideoDecodeAV1CapabilitiesKHR &videoCapabilitiesKHR,
878 const VkVideoDecodeAV1CapabilitiesKHR &videoCapabilitiesKHRSecond);
879 };
880
VideoCapabilitiesQueryAV1DecodeTestInstance(Context & context,const CaseDef & data)881 VideoCapabilitiesQueryAV1DecodeTestInstance::VideoCapabilitiesQueryAV1DecodeTestInstance(Context &context,
882 const CaseDef &data)
883 : VideoCapabilitiesQueryTestInstance(context, data)
884 {
885 }
886
~VideoCapabilitiesQueryAV1DecodeTestInstance(void)887 VideoCapabilitiesQueryAV1DecodeTestInstance::~VideoCapabilitiesQueryAV1DecodeTestInstance(void)
888 {
889 }
890
iterate(void)891 tcu::TestStatus VideoCapabilitiesQueryAV1DecodeTestInstance::iterate(void)
892 {
893 const InstanceInterface &vk = m_context.getInstanceInterface();
894 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
895 const VkVideoCodecOperationFlagBitsKHR videoCodecOperation = VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR;
896 VkVideoDecodeAV1ProfileInfoKHR videoProfileOperation = {
897 VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR, // VkStructureType sType;
898 DE_NULL, // const void* pNext;
899 STD_VIDEO_AV1_PROFILE_MAIN, // StdVideoAV1ProfileIdc stdProfileIdc;
900 false, // VkBool filmGrainSupport
901 };
902 VkVideoProfileInfoKHR videoProfile = {
903 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
904 (void *)&videoProfileOperation, // void* pNext;
905 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
906 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
907 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
908 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
909 };
910 VkVideoDecodeAV1CapabilitiesKHR videoDecodeAV1Capabilities[2];
911 VkVideoDecodeCapabilitiesKHR videoDecodeCapabilities[2];
912 VkVideoCapabilitiesKHR videoCapabilites[2];
913
914 for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(videoCapabilites); ++ndx)
915 {
916 const uint8_t filling = (ndx == 0) ? 0x00 : 0xFF;
917
918 deMemset(&videoCapabilites[ndx], filling, sizeof(videoCapabilites[ndx]));
919 deMemset(&videoDecodeCapabilities[ndx], filling, sizeof(videoDecodeCapabilities[ndx]));
920 deMemset(&videoDecodeAV1Capabilities[ndx], filling, sizeof(videoDecodeAV1Capabilities[ndx]));
921
922 videoCapabilites[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
923 videoCapabilites[ndx].pNext = &videoDecodeCapabilities[ndx];
924 videoDecodeCapabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR;
925 videoDecodeCapabilities[ndx].pNext = &videoDecodeAV1Capabilities[ndx];
926 videoDecodeAV1Capabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR;
927 videoDecodeAV1Capabilities[ndx].pNext = DE_NULL;
928
929 VkResult result =
930 vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, &videoProfile, &videoCapabilites[ndx]);
931
932 if (result != VK_SUCCESS)
933 {
934 ostringstream failMsg;
935
936 failMsg << "Failed query call to vkGetPhysicalDeviceVideoCapabilitiesKHR with " << result
937 << " at iteration " << ndx;
938
939 return tcu::TestStatus::fail(failMsg.str());
940 }
941 }
942
943 validateVideoCapabilities(videoCapabilites[0], videoCapabilites[1]);
944 validateExtensionProperties(videoCapabilites[0].stdHeaderVersion,
945 *getVideoExtensionProperties(videoCodecOperation));
946 validateVideoDecodeCapabilities(videoDecodeCapabilities[0], videoDecodeCapabilities[1]);
947 validateVideoCapabilitiesExt(videoDecodeAV1Capabilities[0], videoDecodeAV1Capabilities[1]);
948
949 return tcu::TestStatus::pass("Pass");
950 }
951
validateVideoCapabilitiesExt(const VkVideoDecodeAV1CapabilitiesKHR & videoCapabilitiesKHR,const VkVideoDecodeAV1CapabilitiesKHR & videoCapabilitiesKHRSecond)952 void VideoCapabilitiesQueryAV1DecodeTestInstance::validateVideoCapabilitiesExt(
953 const VkVideoDecodeAV1CapabilitiesKHR &videoCapabilitiesKHR,
954 const VkVideoDecodeAV1CapabilitiesKHR &videoCapabilitiesKHRSecond)
955 {
956 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, sType);
957 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxLevel);
958 }
959
960 class VideoCapabilitiesQueryH265EncodeTestInstance : public VideoCapabilitiesQueryTestInstance
961 {
962 public:
963 VideoCapabilitiesQueryH265EncodeTestInstance(Context &context, const CaseDef &data);
964 virtual ~VideoCapabilitiesQueryH265EncodeTestInstance(void);
965 tcu::TestStatus iterate(void);
966
967 protected:
968 void validateVideoCapabilitiesExt(const VkVideoEncodeH265CapabilitiesKHR &videoCapabilitiesKHR,
969 const VkVideoEncodeH265CapabilitiesKHR &videoCapabilitiesKHRSecond);
970 };
971
VideoCapabilitiesQueryH265EncodeTestInstance(Context & context,const CaseDef & data)972 VideoCapabilitiesQueryH265EncodeTestInstance::VideoCapabilitiesQueryH265EncodeTestInstance(Context &context,
973 const CaseDef &data)
974 : VideoCapabilitiesQueryTestInstance(context, data)
975 {
976 }
977
~VideoCapabilitiesQueryH265EncodeTestInstance(void)978 VideoCapabilitiesQueryH265EncodeTestInstance::~VideoCapabilitiesQueryH265EncodeTestInstance(void)
979 {
980 }
981
iterate(void)982 tcu::TestStatus VideoCapabilitiesQueryH265EncodeTestInstance::iterate(void)
983 {
984 const InstanceInterface &vk = m_context.getInstanceInterface();
985 const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
986 const VkVideoCodecOperationFlagBitsKHR videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR;
987 const VkVideoEncodeH265ProfileInfoKHR videoProfileOperation = {
988 VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, // VkStructureType sType;
989 DE_NULL, // const void* pNext;
990 STD_VIDEO_H265_PROFILE_IDC_MAIN, // StdVideoH265ProfileIdc stdProfileIdc;
991 };
992 const VkVideoProfileInfoKHR videoProfile = {
993 VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, // VkStructureType sType;
994 (void *)&videoProfileOperation, // void* pNext;
995 videoCodecOperation, // VkVideoCodecOperationFlagBitsKHR videoCodecOperation;
996 VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, // VkVideoChromaSubsamplingFlagsKHR chromaSubsampling;
997 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR lumaBitDepth;
998 VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, // VkVideoComponentBitDepthFlagsKHR chromaBitDepth;
999 };
1000 VkVideoEncodeH265CapabilitiesKHR videoEncodeH265Capabilities[2];
1001 VkVideoEncodeCapabilitiesKHR videoEncodeCapabilities[2];
1002 VkVideoCapabilitiesKHR videoCapabilites[2];
1003
1004 for (size_t ndx = 0; ndx < DE_LENGTH_OF_ARRAY(videoCapabilites); ++ndx)
1005 {
1006 const uint8_t filling = (ndx == 0) ? 0x00 : 0xFF;
1007
1008 deMemset(&videoCapabilites[ndx], filling, sizeof(videoCapabilites[ndx]));
1009 deMemset(&videoEncodeCapabilities[ndx], filling, sizeof(videoEncodeCapabilities[ndx]));
1010 deMemset(&videoEncodeH265Capabilities[ndx], filling, sizeof(videoEncodeH265Capabilities[ndx]));
1011
1012 videoCapabilites[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR;
1013 videoCapabilites[ndx].pNext = &videoEncodeCapabilities[ndx];
1014 videoEncodeCapabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR;
1015 videoEncodeCapabilities[ndx].pNext = &videoEncodeH265Capabilities[ndx];
1016 videoEncodeH265Capabilities[ndx].sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR;
1017 videoEncodeH265Capabilities[ndx].pNext = DE_NULL;
1018
1019 VkResult result =
1020 vk.getPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, &videoProfile, &videoCapabilites[ndx]);
1021
1022 if (result != VK_SUCCESS)
1023 {
1024 ostringstream failMsg;
1025
1026 failMsg << "Failed query call to vkGetPhysicalDeviceVideoCapabilitiesKHR with " << result
1027 << " at iteration " << ndx;
1028
1029 return tcu::TestStatus::fail(failMsg.str());
1030 }
1031 }
1032
1033 validateVideoCapabilities(videoCapabilites[0], videoCapabilites[1]);
1034 validateVideoEncodeCapabilities(videoEncodeCapabilities[0], videoEncodeCapabilities[1]);
1035 validateExtensionProperties(videoCapabilites[0].stdHeaderVersion,
1036 *getVideoExtensionProperties(videoCodecOperation));
1037 validateVideoCapabilitiesExt(videoEncodeH265Capabilities[0], videoEncodeH265Capabilities[1]);
1038
1039 return tcu::TestStatus::pass("Pass");
1040 }
1041
validateVideoCapabilitiesExt(const VkVideoEncodeH265CapabilitiesKHR & videoCapabilitiesKHR,const VkVideoEncodeH265CapabilitiesKHR & videoCapabilitiesKHRSecond)1042 void VideoCapabilitiesQueryH265EncodeTestInstance::validateVideoCapabilitiesExt(
1043 const VkVideoEncodeH265CapabilitiesKHR &videoCapabilitiesKHR,
1044 const VkVideoEncodeH265CapabilitiesKHR &videoCapabilitiesKHRSecond)
1045 {
1046 const VkVideoEncodeH265CtbSizeFlagsKHR ctbSizeFlags = VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR |
1047 VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR |
1048 VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR;
1049 const VkVideoEncodeH265TransformBlockSizeFlagsKHR transformBlockSizes =
1050 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR |
1051 VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR | VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR;
1052
1053 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, sType);
1054 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, flags);
1055 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxLevelIdc);
1056 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxSliceSegmentCount);
1057 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxTiles);
1058 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxPPictureL0ReferenceCount);
1059 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxBPictureL0ReferenceCount);
1060 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxL1ReferenceCount);
1061 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxSubLayerCount);
1062 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, expectDyadicTemporalSubLayerPattern);
1063 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, minQp);
1064 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, maxQp);
1065 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, prefersGopRemainingFrames);
1066 VALIDATE_FIELD_EQUAL(videoCapabilitiesKHR, videoCapabilitiesKHRSecond, requiresGopRemainingFrames);
1067
1068 if (videoCapabilitiesKHR.ctbSizes == 0)
1069 TCU_FAIL("Invalid videoCapabilitiesKHR.ctbSizes");
1070
1071 if ((videoCapabilitiesKHR.ctbSizes & ~ctbSizeFlags) != 0)
1072 TCU_FAIL("Undefined videoCapabilitiesKHR.ctbSizeFlags");
1073
1074 if (videoCapabilitiesKHR.transformBlockSizes == 0)
1075 TCU_FAIL("Invalid videoCapabilitiesKHR.transformBlockSizes");
1076
1077 if ((videoCapabilitiesKHR.transformBlockSizes & ~transformBlockSizes) != 0)
1078 TCU_FAIL("Undefined videoCapabilitiesKHR.transformBlockSizes");
1079 }
1080
1081 class VideoCapabilitiesQueryTestCase : public TestCase
1082 {
1083 public:
1084 VideoCapabilitiesQueryTestCase(tcu::TestContext &context, const char *name, const CaseDef caseDef);
1085 ~VideoCapabilitiesQueryTestCase(void);
1086
1087 virtual TestInstance *createInstance(Context &context) const;
1088 virtual void checkSupport(Context &context) const;
1089
1090 private:
1091 CaseDef m_caseDef;
1092 };
1093
VideoCapabilitiesQueryTestCase(tcu::TestContext & context,const char * name,const CaseDef caseDef)1094 VideoCapabilitiesQueryTestCase::VideoCapabilitiesQueryTestCase(tcu::TestContext &context, const char *name,
1095 const CaseDef caseDef)
1096 : vkt::TestCase(context, name)
1097 , m_caseDef(caseDef)
1098 {
1099 }
1100
~VideoCapabilitiesQueryTestCase(void)1101 VideoCapabilitiesQueryTestCase::~VideoCapabilitiesQueryTestCase(void)
1102 {
1103 }
1104
checkSupport(Context & context) const1105 void VideoCapabilitiesQueryTestCase::checkSupport(Context &context) const
1106 {
1107 context.requireDeviceFunctionality("VK_KHR_video_queue");
1108
1109 switch (m_caseDef.testType)
1110 {
1111 case TEST_TYPE_QUEUE_SUPPORT_QUERY:
1112 break;
1113 case TEST_TYPE_H264_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1114 case TEST_TYPE_H264_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1115 context.requireDeviceFunctionality("VK_KHR_video_decode_h264");
1116 break;
1117 case TEST_TYPE_H264_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
1118 case TEST_TYPE_H264_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1119 context.requireDeviceFunctionality("VK_KHR_video_encode_h264");
1120 break;
1121 case TEST_TYPE_H265_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1122 case TEST_TYPE_H265_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1123 context.requireDeviceFunctionality("VK_KHR_video_decode_h265");
1124 break;
1125 case TEST_TYPE_H265_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
1126 case TEST_TYPE_H265_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1127 context.requireDeviceFunctionality("VK_EXT_video_encode_h265");
1128 break;
1129 case TEST_TYPE_AV1_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1130 case TEST_TYPE_AV1_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1131 context.requireDeviceFunctionality("VK_KHR_video_decode_av1");
1132 break;
1133 case TEST_TYPE_H264_DECODE_CAPABILITIES_QUERY:
1134 context.requireDeviceFunctionality("VK_KHR_video_decode_h264");
1135 break;
1136 case TEST_TYPE_H264_ENCODE_CAPABILITIES_QUERY:
1137 context.requireDeviceFunctionality("VK_KHR_video_encode_h264");
1138 break;
1139 case TEST_TYPE_H265_DECODE_CAPABILITIES_QUERY:
1140 context.requireDeviceFunctionality("VK_KHR_video_decode_h265");
1141 break;
1142 case TEST_TYPE_H265_ENCODE_CAPABILITIES_QUERY:
1143 context.requireDeviceFunctionality("VK_EXT_video_encode_h265");
1144 break;
1145 case TEST_TYPE_AV1_DECODE_CAPABILITIES_QUERY:
1146 context.requireDeviceFunctionality("VK_KHR_video_decode_av1");
1147 break;
1148 default:
1149 TCU_THROW(NotSupportedError, "Unknown TestType");
1150 }
1151 }
1152
createInstance(Context & context) const1153 TestInstance *VideoCapabilitiesQueryTestCase::createInstance(Context &context) const
1154 {
1155 switch (m_caseDef.testType)
1156 {
1157 case TEST_TYPE_QUEUE_SUPPORT_QUERY:
1158 return new VideoQueueQueryTestInstance(context, m_caseDef);
1159 case TEST_TYPE_H264_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1160 return new VideoFormatPropertiesQueryH264DecodeTestInstance(context, m_caseDef);
1161 case TEST_TYPE_H264_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1162 return new VideoFormatPropertiesQueryH264DecodeTestInstance(context, m_caseDef);
1163 case TEST_TYPE_H264_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
1164 return new VideoFormatPropertiesQueryH264EncodeTestInstance(context, m_caseDef);
1165 case TEST_TYPE_H264_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1166 return new VideoFormatPropertiesQueryH264EncodeTestInstance(context, m_caseDef);
1167 case TEST_TYPE_H265_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1168 return new VideoFormatPropertiesQueryH265DecodeTestInstance(context, m_caseDef);
1169 case TEST_TYPE_H265_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1170 return new VideoFormatPropertiesQueryH265DecodeTestInstance(context, m_caseDef);
1171 case TEST_TYPE_H265_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
1172 return new VideoFormatPropertiesQueryH265EncodeTestInstance(context, m_caseDef);
1173 case TEST_TYPE_H265_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1174 return new VideoFormatPropertiesQueryH265EncodeTestInstance(context, m_caseDef);
1175 case TEST_TYPE_AV1_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1176 return new VideoFormatPropertiesQueryAV1DecodeTestInstance(context, m_caseDef);
1177 case TEST_TYPE_AV1_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1178 return new VideoFormatPropertiesQueryAV1DecodeTestInstance(context, m_caseDef);
1179 case TEST_TYPE_H264_DECODE_CAPABILITIES_QUERY:
1180 return new VideoCapabilitiesQueryH264DecodeTestInstance(context, m_caseDef);
1181 case TEST_TYPE_H264_ENCODE_CAPABILITIES_QUERY:
1182 return new VideoCapabilitiesQueryH264EncodeTestInstance(context, m_caseDef);
1183 case TEST_TYPE_H265_DECODE_CAPABILITIES_QUERY:
1184 return new VideoCapabilitiesQueryH265DecodeTestInstance(context, m_caseDef);
1185 case TEST_TYPE_H265_ENCODE_CAPABILITIES_QUERY:
1186 return new VideoCapabilitiesQueryH265EncodeTestInstance(context, m_caseDef);
1187 case TEST_TYPE_AV1_DECODE_CAPABILITIES_QUERY:
1188 return new VideoCapabilitiesQueryAV1DecodeTestInstance(context, m_caseDef);
1189 default:
1190 TCU_THROW(NotSupportedError, "Unknown TestType");
1191 }
1192 }
1193
getTestName(const TestType testType)1194 const char *getTestName(const TestType testType)
1195 {
1196 switch (testType)
1197 {
1198 case TEST_TYPE_QUEUE_SUPPORT_QUERY:
1199 return "queue_support_query";
1200 case TEST_TYPE_H264_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1201 return "h264_decode_dst_video_format_support_query";
1202 case TEST_TYPE_H264_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1203 return "h264_decode_dpb_video_format_support_query";
1204 case TEST_TYPE_H264_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
1205 return "h264_encode_src_video_format_support_query";
1206 case TEST_TYPE_H264_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1207 return "h264_encode_dpb_video_format_support_query";
1208 case TEST_TYPE_H265_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1209 return "h265_decode_dst_video_format_support_query";
1210 case TEST_TYPE_H265_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1211 return "h265_decode_dpb_video_format_support_query";
1212 case TEST_TYPE_H265_ENCODE_SRC_VIDEO_FORMAT_SUPPORT_QUERY:
1213 return "h265_encode_src_video_format_support_query";
1214 case TEST_TYPE_H265_ENCODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1215 return "h265_encode_dpb_video_format_support_query";
1216 case TEST_TYPE_AV1_DECODE_DST_VIDEO_FORMAT_SUPPORT_QUERY:
1217 return "av1_decode_dst_video_format_support_query";
1218 case TEST_TYPE_AV1_DECODE_DPB_VIDEO_FORMAT_SUPPORT_QUERY:
1219 return "av1_decode_dpb_video_format_support_query";
1220 case TEST_TYPE_H264_DECODE_CAPABILITIES_QUERY:
1221 return "h264_decode_capabilities_query";
1222 case TEST_TYPE_H264_ENCODE_CAPABILITIES_QUERY:
1223 return "h264_encode_capabilities_query";
1224 case TEST_TYPE_H265_DECODE_CAPABILITIES_QUERY:
1225 return "h265_decode_capabilities_query";
1226 case TEST_TYPE_H265_ENCODE_CAPABILITIES_QUERY:
1227 return "h265_encode_capabilities_query";
1228 case TEST_TYPE_AV1_DECODE_CAPABILITIES_QUERY:
1229 return "av1_decode_capabilities_query";
1230 default:
1231 TCU_THROW(NotSupportedError, "Unknown TestType");
1232 }
1233 }
1234 } // namespace
1235
createVideoCapabilitiesTests(tcu::TestContext & testCtx)1236 tcu::TestCaseGroup *createVideoCapabilitiesTests(tcu::TestContext &testCtx)
1237 {
1238 // Video encoding and decoding capability query tests
1239 de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, "capabilities"));
1240
1241 for (int testTypeNdx = 0; testTypeNdx < TEST_TYPE_LAST; ++testTypeNdx)
1242 {
1243 const TestType testType = static_cast<TestType>(testTypeNdx);
1244 const CaseDef caseDef = {
1245 testType, // TestType testType;
1246 };
1247
1248 group->addChild(new VideoCapabilitiesQueryTestCase(testCtx, getTestName(testType), caseDef));
1249 }
1250
1251 return group.release();
1252 }
1253 } // namespace video
1254 } // namespace vkt
1255