Fix descriptorCount for YCbCr-related tests

Certain YCbCr tests did not behave consistently with the Vulkan spec
when creating descriptor pools.
Tests now properly query combinedImageSamplerDescriptorCount to
correctly set pool size in the event of multiplane images.

Affects:

dEQP-VK.protected_memory.interaction.ycbcr.*
dEQP-VK.ycbcr.format.*
dEQP-VK.ycbcr.plane_view.*
dEQP-VK.ycbcr.query.*

Components: Vulkan

VK-GL-CTS Issue: 2386

Change-Id: I8bb261a29c7e4ce82deced447767de915cee451a

diff --git a/external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemYCbCrConversionTests.cpp b/external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemYCbCrConversionTests.cpp
index f5d4bbe..7544484 100644 (file)
--- a/external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemYCbCrConversionTests.cpp
+++ b/external/vulkancts/modules/vulkan/protected_memory/vktProtectedMemYCbCrConversionTests.cpp
@@ -495,7 +495,8 @@ void logBoundImages (tcu::TestLog& log, const tcu::UVec2 size, const std::vector
 bool validateImage (ProtectedContext&                                                  ctx,
                                         const std::vector<YCbCrValidationData>&        refData,
                                         const vk::VkSampler                                            sampler,
-                                        const vk::VkImageView                                          imageView)
+                                        const vk::VkImageView                                          imageView,
+                                        const deUint32                                                         combinedSamplerDescriptorCount)
 {
        {
                tcu::TestLog&   log     (ctx.getTestContext().getLog());
@@ -546,7 +547,7 @@ bool validateImage (ProtectedContext&                                                       ctx,
                .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, vk::VK_SHADER_STAGE_COMPUTE_BIT)
                .build(vk, device));
        const vk::Unique<vk::VkDescriptorPool>          descriptorPool(vk::DescriptorPoolBuilder()
-               .addType(vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u)
+               .addType(vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, combinedSamplerDescriptorCount)
                .addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u)
                .addType(vk::VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1u)
                .build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
@@ -821,7 +822,8 @@ void renderYCbCrToColor (ProtectedContext&                                                  ctx,
                                                 const vk::VkImage                                                      colorImage,
                                                 const vk::VkImageView                                          colorImageView,
                                                 const std::vector<YCbCrValidationData>&        referenceData,
-                                                const std::vector<tcu::Vec2>&                          posCoords)
+                                                const std::vector<tcu::Vec2>&                          posCoords,
+                                                const deUint32                                                         combinedSamplerDescriptorCount)
 {
        const vk::DeviceInterface&                                      vk                                      = ctx.getDeviceInterface();
        const vk::VkDevice                                                      device                          = ctx.getDevice();
@@ -839,7 +841,7 @@ void renderYCbCrToColor (ProtectedContext&                                                  ctx,
                                                                                                                                                .addSingleBinding(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, vk::VK_SHADER_STAGE_ALL)
                                                                                                                                                .build(vk, device));
        const vk::Unique<vk::VkDescriptorPool>          descriptorPool          (vk::DescriptorPoolBuilder()
-                                                                                                                                               .addType(vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1u)
+                                                                                                                                               .addType(vk::VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, combinedSamplerDescriptorCount)
                                                                                                                                                .addType(vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1u)
                                                                                                                                                .build(vk, device, vk::VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u));
        const vk::Unique<vk::VkDescriptorSet>           descriptorSet           (makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout));
@@ -1182,6 +1184,31 @@ tcu::TestStatus conversionTest (Context& context, TestConfig config)
                                                                                                                                                                                           *conversion));
        const vk::Unique<vk::VkImageView>                                       ycbcrImageView                  (createImageView(vk, device, **ycbcrImage, config.format, *conversion));
 
+       deUint32                                                                                        combinedSamplerDescriptorCount = 1;
+       {
+               const vk::VkPhysicalDeviceImageFormatInfo2                      imageFormatInfo                         =
+               {
+                       vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,      // sType
+                       DE_NULL,                                                                                                        // pNext
+                       config.format,                                                                                          // format
+                       vk::VK_IMAGE_TYPE_2D,                                                                           // type
+                       vk::VK_IMAGE_TILING_OPTIMAL,                                                            // tiling
+                       vk::VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                       vk::VK_IMAGE_USAGE_SAMPLED_BIT,                                                         // usage
+                       ycbcrImageFlags                                                                                         // flags
+               };
+
+               vk::VkSamplerYcbcrConversionImageFormatProperties       samplerYcbcrConversionImage = {};
+               samplerYcbcrConversionImage.sType = vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+               samplerYcbcrConversionImage.pNext = DE_NULL;
+
+               vk::VkImageFormatProperties2                                            imageFormatProperties           = {};
+               imageFormatProperties.sType = vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+               imageFormatProperties.pNext = &samplerYcbcrConversionImage;
+
+               VK_CHECK(context.getInstanceInterface().getPhysicalDeviceImageFormatProperties2(context.getPhysicalDevice(), &imageFormatInfo, &imageFormatProperties));
+               combinedSamplerDescriptorCount = samplerYcbcrConversionImage.combinedImageSamplerDescriptorCount;
+       }
 
        // Input attributes
        std::vector<tcu::Vec2>                                                          texCoords;
@@ -1244,14 +1271,14 @@ tcu::TestStatus conversionTest (Context& context, TestConfig config)
                const vk::Unique<vk::VkImageView>                       colorImageView          (createImageView(ctx, **colorImage, s_colorFormat));
                const vk::Unique<vk::VkSampler>                         colorSampler            (makeSampler(vk, device));
 
-               renderYCbCrToColor(ctx, size, *ycbcrSampler, *ycbcrImageView, **colorImage, *colorImageView, referenceData, posCoords);
+               renderYCbCrToColor(ctx, size, *ycbcrSampler, *ycbcrImageView, **colorImage, *colorImageView, referenceData, posCoords, combinedSamplerDescriptorCount);
 
-               if (!validateImage(ctx, colorReferenceData, *colorSampler, *colorImageView))
+               if (!validateImage(ctx, colorReferenceData, *colorSampler, *colorImageView, combinedSamplerDescriptorCount))
                        return tcu::TestStatus::fail("YCbCr image conversion via fragment shader failed");
        }
        else if (config.shaderType == glu::SHADERTYPE_COMPUTE)
        {
-               if (!validateImage(ctx, referenceData, *ycbcrSampler, *ycbcrImageView))
+               if (!validateImage(ctx, referenceData, *ycbcrSampler, *ycbcrImageView, combinedSamplerDescriptorCount))
                        return tcu::TestStatus::fail("YCbCr image conversion via compute shader failed");
        }
        else

diff --git a/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrFormatTests.cpp b/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrFormatTests.cpp
index 319c508..2e73821 100644 (file)
--- a/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrFormatTests.cpp
+++ b/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrFormatTests.cpp
@@ -152,11 +152,11 @@ Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk
        return createDescriptorSetLayout(vkd, device, &layoutInfo);
 }
 
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vkd, VkDevice device)
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vkd, VkDevice device, const deUint32 combinedSamplerDescriptorCount)
 {
        const VkDescriptorPoolSize                      poolSizes[]     =
        {
-               { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    1u      },
+               { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    combinedSamplerDescriptorCount  },
        };
        const VkDescriptorPoolCreateInfo        poolInfo        =
        {
@@ -380,14 +380,6 @@ tcu::TestStatus testFormat (Context& context, TestParameters params)
                VK_FALSE,                                                                       // unnormalizedCoords
        };
 
-       const Unique<VkSampler>                                 sampler                                 (createSampler(vkd, device, &samplerInfo));
-
-       const Unique<VkDescriptorSetLayout>             descLayout                              (createDescriptorSetLayout(vkd, device, *sampler));
-       const Unique<VkDescriptorPool>                  descPool                                (createDescriptorPool(vkd, device));
-       const Unique<VkDescriptorSet>                   descSet                                 (createDescriptorSet(vkd, device, *descPool, *descLayout, *imageView));
-
-       MultiPlaneImageData                                             imageData                               (format, size);
-
        const VkPhysicalDeviceImageFormatInfo2                  imageFormatInfo =
        {
                VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
@@ -395,16 +387,16 @@ tcu::TestStatus testFormat (Context& context, TestParameters params)
                params.format,
                VK_IMAGE_TYPE_2D,
                params.tiling,
-               VK_IMAGE_USAGE_TRANSFER_DST_BIT|VK_IMAGE_USAGE_SAMPLED_BIT,
+               VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
                params.flags,
        };
-       VkSamplerYcbcrConversionImageFormatProperties           ycbcrProperties =
+       VkSamplerYcbcrConversionImageFormatProperties   ycbcrProperties =
        {
                VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
                DE_NULL,
                0,
        };
-       VkImageFormatProperties2                                extProperties =
+       VkImageFormatProperties2                                                extProperties   =
        {
                VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
                &ycbcrProperties,
@@ -420,7 +412,7 @@ tcu::TestStatus testFormat (Context& context, TestParameters params)
                        0u,             // maxResourceSize
                },
        };
-       VkResult                                propsResult;
+       VkResult                                                propsResult;
        const CustomInstance                    instance        (createCustomInstanceWithExtension(context, "VK_KHR_get_physical_device_properties2"));
        const InstanceDriver&                   vki                     (instance.getDriver());
 
@@ -430,6 +422,14 @@ tcu::TestStatus testFormat (Context& context, TestParameters params)
        TCU_CHECK(propsResult == VK_SUCCESS);
        TCU_CHECK(ycbcrProperties.combinedImageSamplerDescriptorCount >= 1);
 
+       const Unique<VkSampler>                                 sampler                                 (createSampler(vkd, device, &samplerInfo));
+
+       const Unique<VkDescriptorSetLayout>             descLayout                              (createDescriptorSetLayout(vkd, device, *sampler));
+       const Unique<VkDescriptorPool>                  descPool                                (createDescriptorPool(vkd, device, ycbcrProperties.combinedImageSamplerDescriptorCount));
+       const Unique<VkDescriptorSet>                   descSet                                 (createDescriptorSet(vkd, device, *descPool, *descLayout, *imageView));
+
+       MultiPlaneImageData                                             imageData                               (format, size);
+
        // Zero fill unused layer
        if (params.useArrayLayers)
        {

diff --git a/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrImageQueryTests.cpp b/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrImageQueryTests.cpp
index 1f1c82a..09d91f8 100644 (file)
--- a/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrImageQueryTests.cpp
+++ b/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrImageQueryTests.cpp
@@ -280,11 +280,11 @@ Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk
        return createDescriptorSetLayout(vkd, device, &layoutInfo);
 }
 
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vkd, VkDevice device)
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vkd, VkDevice device, const deUint32 combinedSamplerDescriptorCount)
 {
        const VkDescriptorPoolSize                      poolSizes[]     =
        {
-               { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    1u      },
+               { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    combinedSamplerDescriptorCount  },
        };
        const VkDescriptorPoolCreateInfo        poolInfo        =
        {
@@ -361,6 +361,7 @@ UVec2 getMaxPlaneDivisor (const PlanarFormatDescription& formatDesc)
 tcu::TestStatus testImageQuery (Context& context, TestParameters params)
 {
        const bool                                                      isYCbCrImage    = isYCbCrFormat(params.format);
+       const InstanceInterface&                        vk                              = context.getInstanceInterface();
        const DeviceInterface&                          vkd                             = context.getDeviceInterface();
        const VkDevice                                          device                  = context.getDevice();
 
@@ -415,9 +416,35 @@ tcu::TestStatus testImageQuery (Context& context, TestParameters params)
                VK_FALSE,                                                                       // unnormalizedCoords
        };
 
+       deUint32                                                                                combinedSamplerDescriptorCount  = 1;
+       {
+               const VkPhysicalDeviceImageFormatInfo2                  imageFormatInfo                         =
+               {
+                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,  // sType
+                       DE_NULL,                                                                                                // pNext
+                       params.format,                                                                                  // format
+                       VK_IMAGE_TYPE_2D,                                                                               // type
+                       VK_IMAGE_TILING_OPTIMAL,                                                                // tiling
+                       VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                       VK_IMAGE_USAGE_SAMPLED_BIT,                                                             // usage
+                       params.flags                                                                                    // flags
+               };
+
+               VkSamplerYcbcrConversionImageFormatProperties   samplerYcbcrConversionImage     = {};
+               samplerYcbcrConversionImage.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+               samplerYcbcrConversionImage.pNext = DE_NULL;
+
+               VkImageFormatProperties2                                                imageFormatProperties           = {};
+               imageFormatProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+               imageFormatProperties.pNext = &samplerYcbcrConversionImage;
+
+               VK_CHECK(vk.getPhysicalDeviceImageFormatProperties2(context.getPhysicalDevice(), &imageFormatInfo, &imageFormatProperties));
+               combinedSamplerDescriptorCount = samplerYcbcrConversionImage.combinedImageSamplerDescriptorCount;
+       }
+
        const Unique<VkSampler>                         sampler         (createSampler(vkd, device, &samplerInfo));
        const Unique<VkDescriptorSetLayout>     descLayout      (createDescriptorSetLayout(vkd, device, *sampler));
-       const Unique<VkDescriptorPool>          descPool        (createDescriptorPool(vkd, device));
+       const Unique<VkDescriptorPool>          descPool        (createDescriptorPool(vkd, device, combinedSamplerDescriptorCount));
        const Unique<VkDescriptorSet>           descSet         (createDescriptorSet(vkd, device, *descPool, *descLayout));
 
        vector<TestImageSp>                                     testImages;
@@ -513,6 +540,7 @@ void checkSupport (Context& context, TestParameters params)
 tcu::TestStatus testImageQueryLod (Context& context, TestParameters params)
 {
        const bool                                                      isYCbCrImage    = isYCbCrFormat(params.format);
+       const InstanceInterface&                        vk                              = context.getInstanceInterface();
        const DeviceInterface&                          vkd                             = context.getDeviceInterface();
        const VkDevice                                          device                  = context.getDevice();
 
@@ -567,9 +595,35 @@ tcu::TestStatus testImageQueryLod (Context& context, TestParameters params)
                VK_FALSE,                                                                       // unnormalizedCoords
        };
 
+       deUint32                                                                                combinedSamplerDescriptorCount  = 1;
+       {
+               const VkPhysicalDeviceImageFormatInfo2          imageFormatInfo                                 =
+               {
+                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,  // sType;
+                       DE_NULL,                                                                                                // pNext;
+                       params.format,                                                                                  // format;
+                       VK_IMAGE_TYPE_2D,                                                                               // type;
+                       VK_IMAGE_TILING_OPTIMAL,                                                                // tiling;
+                       VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                       VK_IMAGE_USAGE_SAMPLED_BIT,                                                             // usage;
+                       params.flags                                                                                    // flags;
+               };
+
+               VkSamplerYcbcrConversionImageFormatProperties   samplerYcbcrConversionImage = {};
+               samplerYcbcrConversionImage.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+               samplerYcbcrConversionImage.pNext = DE_NULL;
+
+               VkImageFormatProperties2                                                imageFormatProperties           = {};
+               imageFormatProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+               imageFormatProperties.pNext = &samplerYcbcrConversionImage;
+
+               VK_CHECK(vk.getPhysicalDeviceImageFormatProperties2(context.getPhysicalDevice(), &imageFormatInfo, &imageFormatProperties));
+               combinedSamplerDescriptorCount = samplerYcbcrConversionImage.combinedImageSamplerDescriptorCount;
+       }
+
        const Unique<VkSampler>                         sampler         (createSampler(vkd, device, &samplerInfo));
        const Unique<VkDescriptorSetLayout>     descLayout      (createDescriptorSetLayout(vkd, device, *sampler));
-       const Unique<VkDescriptorPool>          descPool        (createDescriptorPool(vkd, device));
+       const Unique<VkDescriptorPool>          descPool        (createDescriptorPool(vkd, device, combinedSamplerDescriptorCount));
        const Unique<VkDescriptorSet>           descSet         (createDescriptorSet(vkd, device, *descPool, *descLayout));
 
        vector<TestImageSp>                                     testImages;

diff --git a/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrViewTests.cpp b/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrViewTests.cpp
index 6c3f4c5..0cba5fe 100644 (file)
--- a/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrViewTests.cpp
+++ b/external/vulkancts/modules/vulkan/ycbcr/vktYCbCrViewTests.cpp
@@ -155,11 +155,11 @@ Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk
        return createDescriptorSetLayout(vkd, device, &layoutInfo);
 }
 
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vkd, VkDevice device)
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vkd, VkDevice device, const deUint32 combinedSamplerDescriptorCount)
 {
        const VkDescriptorPoolSize                      poolSizes[]     =
        {
-               { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    2u      },
+               { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,    2u * combinedSamplerDescriptorCount     },
        };
        const VkDescriptorPoolCreateInfo        poolInfo        =
        {
@@ -383,6 +383,7 @@ tcu::TestStatus testPlaneView (Context& context, TestParameters params)
                                                                                                         deInt32Hash((deUint32)params.planeNdx) ^
                                                                                                         deInt32Hash((deUint32)params.shaderType));
 
+       const InstanceInterface&                vk                              = context.getInstanceInterface();
        const DeviceInterface&                  vkd                             = context.getDeviceInterface();
        const VkDevice                                  device                  = context.getDevice();
 
@@ -502,11 +503,37 @@ tcu::TestStatus testPlaneView (Context& context, TestParameters params)
                VK_FALSE,                                                                       // unnormalizedCoords
        };
 
+       deUint32                                                                        combinedSamplerDescriptorCount = 1;
+       {
+               const VkPhysicalDeviceImageFormatInfo2                  imageFormatInfo                         =
+               {
+                       VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,  // sType;
+                       DE_NULL,                                                                                                // pNext;
+                       format,                                                                                                 // format;
+                       VK_IMAGE_TYPE_2D,                                                                               // type;
+                       VK_IMAGE_TILING_OPTIMAL,                                                                // tiling;
+                       VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+                       VK_IMAGE_USAGE_SAMPLED_BIT,                                                             // usage;
+                       createFlags                                                                                             // flags;
+               };
+
+               VkSamplerYcbcrConversionImageFormatProperties   samplerYcbcrConversionImage = {};
+               samplerYcbcrConversionImage.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
+               samplerYcbcrConversionImage.pNext = DE_NULL;
+
+               VkImageFormatProperties2                                                imageFormatProperties           = {};
+               imageFormatProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
+               imageFormatProperties.pNext = &samplerYcbcrConversionImage;
+
+               VK_CHECK(vk.getPhysicalDeviceImageFormatProperties2(context.getPhysicalDevice(), &imageFormatInfo, &imageFormatProperties));
+               combinedSamplerDescriptorCount = samplerYcbcrConversionImage.combinedImageSamplerDescriptorCount;
+       }
+
        const Unique<VkSampler>                                 wholeSampler(createSampler(vkd, device, &wholeSamplerInfo));
        const Unique<VkSampler>                                 planeSampler(createSampler(vkd, device, &planeSamplerInfo));
 
        const Unique<VkDescriptorSetLayout>             descLayout      (createDescriptorSetLayout(vkd, device, *wholeSampler));
-       const Unique<VkDescriptorPool>                  descPool        (createDescriptorPool(vkd, device));
+       const Unique<VkDescriptorPool>                  descPool        (createDescriptorPool(vkd, device, combinedSamplerDescriptorCount));
        const Unique<VkDescriptorSet>                   descSet         (createDescriptorSet(vkd, device, *descPool, *descLayout, *planeView, *planeSampler, *wholeView, *wholeSampler));
 
        MultiPlaneImageData                                             imageData       (format, size);