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