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