class Texture2D : private TextureLevelPyramid
{
public:
- Texture2D (const TextureFormat& format, int width, int height, bool es2 = false);
- Texture2D (const TextureFormat& format, int width, int height, int mipmaps);
- Texture2D (const Texture2D& other);
- ~Texture2D (void);
+ Texture2D (const TextureFormat& format, int width, int height, bool es2 = false);
+ Texture2D (const TextureFormat& format, int width, int height, int mipmaps);
+ Texture2D (const Texture2D& other);
+ ~Texture2D (void);
- int getWidth (void) const { return m_width; }
- int getHeight (void) const { return m_height; }
- const Texture2DView& getView (void) const { return m_view; }
-
- void allocLevel (int levelNdx);
+ int getWidth (void) const { return m_width; }
+ int getHeight (void) const { return m_height; }
+ const Texture2DView& getView (void) const { return m_view; }
+ bool isYUVTextureUsed (void) const { return m_yuvTextureUsed;}
+ void allocLevel (int levelNdx);
// Sampling
- Vec4 sample (const Sampler& sampler, float s, float t, float lod) const;
- Vec4 sampleOffset (const Sampler& sampler, float s, float t, float lod, const IVec2& offset) const;
- float sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const;
- float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, const IVec2& offset) const;
+ Vec4 sample (const Sampler& sampler, float s, float t, float lod) const;
+ Vec4 sampleOffset (const Sampler& sampler, float s, float t, float lod, const IVec2& offset) const;
+ float sampleCompare (const Sampler& sampler, float ref, float s, float t, float lod) const;
+ float sampleCompareOffset (const Sampler& sampler, float ref, float s, float t, float lod, const IVec2& offset) const;
- Vec4 gatherOffsets (const Sampler& sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const;
- Vec4 gatherOffsetsCompare(const Sampler& sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const;
+ Vec4 gatherOffsets (const Sampler& sampler, float s, float t, int componentNdx, const IVec2 (&offsets)[4]) const;
+ Vec4 gatherOffsetsCompare (const Sampler& sampler, float ref, float s, float t, const IVec2 (&offsets)[4]) const;
using TextureLevelPyramid::getFormat;
using TextureLevelPyramid::getNumLevels;
using TextureLevelPyramid::isLevelEmpty;
Texture2D& operator= (const Texture2D& other);
-
+ //whether this is a yuv format texture tests
+ bool m_yuvTextureUsed;
operator Texture2DView (void) const { return m_view; }
private:
- int m_width;
- int m_height;
- Texture2DView m_view;
+ int m_width;
+ int m_height;
+ Texture2DView m_view;
} DE_WARN_UNUSED_TYPE;
inline Vec4 Texture2D::sample (const Sampler& sampler, float s, float t, float lod) const
#if (DE_OS != DE_OS_ANDROID)
-MovePtr<ImageSource> createAndroidNativeImageSource (GLenum format, deUint32 numLayers)
+MovePtr<ImageSource> createAndroidNativeImageSource (GLenum format, deUint32 numLayers, bool isYUV)
{
DE_UNREF(numLayers);
- return createUnsupportedImageSource("Not Android platform", format);
+ return createUnsupportedImageSource("Not Android platform", format, isYUV);
}
#else // DE_OS == DE_OS_ANDROID
#if !defined(BUILT_WITH_ANDROID_HARDWARE_BUFFER)
-MovePtr<ImageSource> createAndroidNativeImageSource (GLenum format, deUint32 numLayers)
+MovePtr<ImageSource> createAndroidNativeImageSource (GLenum format, deUint32 numLayers, bool isYUV)
{
DE_UNREF(numLayers);
- return createUnsupportedImageSource("AHB API not supported", format);
+ return createUnsupportedImageSource("AHB API not supported", format, isYUV);
}
#else // defined(BUILT_WITH_ANDROID_HARDWARE_BUFFER)
class AndroidNativeClientBuffer : public ClientBuffer
{
public:
- AndroidNativeClientBuffer (const Library& egl, GLenum format, deUint32 numLayers);
- ~AndroidNativeClientBuffer (void);
- EGLClientBuffer get (void) const;
- void lock (void** data);
- void unlock (void);
+ AndroidNativeClientBuffer (const Library& egl, GLenum format, deUint32 numLayers, bool isYUV);
+ ~AndroidNativeClientBuffer (void);
+ EGLClientBuffer get (void) const;
+ void lock (void** data);
+ void unlock (void);
AHardwareBuffer_Desc describe (void);
private:
AHardwareBuffer* m_hardwareBuffer;
};
-AndroidNativeClientBuffer::AndroidNativeClientBuffer (const Library& egl, GLenum format, deUint32 numLayers)
+AndroidNativeClientBuffer::AndroidNativeClientBuffer (const Library& egl, GLenum format, deUint32 numLayers, bool isYUV)
: m_egl(egl)
{
deInt32 sdkVersion = androidGetSdkVersion();
64u,
64u,
numLayers,
- getPixelFormat(format),
+ isYUV ? AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 : getPixelFormat(format),
AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY |
AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE |
class AndroidNativeImageSource : public ImageSource
{
public:
- AndroidNativeImageSource (GLenum format, deUint32 numLayers) : m_format(format), m_numLayers(numLayers) {}
+ AndroidNativeImageSource (GLenum format, deUint32 numLayers, bool isYUV) : m_format(format), m_numLayers(numLayers), m_isY8Cb8Cr8_420(isYUV) {}
~AndroidNativeImageSource (void);
MovePtr<ClientBuffer> createBuffer (const Library& egl, const glw::Functions&, Texture2D*) const;
string getRequiredExtension (void) const { return "EGL_ANDROID_get_native_client_buffer"; }
EGLImageKHR createImage (const Library& egl, EGLDisplay dpy, EGLContext ctx, EGLClientBuffer clientBuffer) const;
GLenum getEffectiveFormat (void) const { return m_format; }
-
+ bool isYUVFormatImage (void) const { return m_isY8Cb8Cr8_420; }
protected:
GLenum m_format;
deUint32 m_numLayers;
+ bool m_isY8Cb8Cr8_420;
};
AndroidNativeImageSource::~AndroidNativeImageSource (void)
MovePtr<ClientBuffer> AndroidNativeImageSource::createBuffer (const Library& egl, const glw::Functions&, Texture2D* ref) const
{
- MovePtr<AndroidNativeClientBuffer> buffer (new AndroidNativeClientBuffer(egl, m_format, m_numLayers));
+ MovePtr<AndroidNativeClientBuffer> buffer (new AndroidNativeClientBuffer(egl, m_format, m_numLayers, m_isY8Cb8Cr8_420));
if (ref != DE_NULL)
{
void* bufferData = DE_NULL;
*ref = Texture2D(texFormat, 64, 64);
+ ref->m_yuvTextureUsed = m_isY8Cb8Cr8_420;
ref->allocLevel(0);
tcu::fillWithComponentGradients(ref->getLevel(0),
tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f),
// AHB doesn't allow locking a layered image. In that case the data
// will be initialized later using OpenGL API.
- if (m_numLayers == 1u)
+ // YUV format texture will be initialized by glClear.
+
+ if (m_numLayers == 1u && !m_isY8Cb8Cr8_420)
{
buffer->lock(&bufferData);
{
} // anonymous
-MovePtr<ImageSource> createAndroidNativeImageSource (GLenum format, deUint32 numLayers)
+MovePtr<ImageSource> createAndroidNativeImageSource (GLenum format, deUint32 numLayers, bool isYUV)
{
try
{
- return MovePtr<ImageSource>(new AndroidNativeImageSource(format, numLayers));
+ return MovePtr<ImageSource>(new AndroidNativeImageSource(format, numLayers, isYUV));
}
catch (const std::runtime_error& exc)
{
- return createUnsupportedImageSource(string("Android native buffers unsupported: ") + exc.what(), format);
+ return createUnsupportedImageSource(string("Android native buffers unsupported: ") + exc.what(), format, isYUV);
}
}
bool invokeGLES (GLESImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const;
deUint32 getNumLayers (void) const { return m_numLayers; }
glw::GLenum getEffectiveFormat (void) const { return m_imgSource->getEffectiveFormat(); }
-
+ bool isYUVFormatImage (void) const { return m_imgSource->isYUVFormatImage(); }
private:
UniquePtr<ImageSource> m_imgSource;
deUint32 m_numLayers;
bool invokeGLES (GLESImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const override;
string getRequiredExtension (void) const override { return "GL_OES_EGL_image_external"; }
};
-
+ class RenderYUVTexture : public Render
+ {
+ public:
+ bool invokeGLES (GLESImageApi& api, MovePtr<UniqueImage>& image, tcu::Texture2D& ref) const override;
+ string getRequiredExtension (void) const override { return "GL_EXT_YUV_target"; }
+ };
class Modify : public GLESAction
{
public:
return match;
}
+bool GLESImageApi::RenderYUVTexture::invokeGLES (GLESImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
+{
+ const glw::Functions& gl = api.m_gl;
+ tcu::TestLog& log = api.getLog();
+ Texture srcTex (gl);
+
+ DE_ASSERT(reference.isYUVTextureUsed());
+
+ gl.clearColor(0.0, 0.0, 0.0, 0.0);
+ gl.viewport(0, 0, reference.getWidth(), reference.getHeight());
+ gl.clear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+ gl.disable(GL_DEPTH_TEST);
+
+ log << tcu::TestLog::Message << "Rendering EGLImage as GL_TEXTURE_EXTERNAL_OES in context: " << api.m_contextId << tcu::TestLog::EndMessage;
+ TCU_CHECK(**img != EGL_NO_IMAGE_KHR);
+ GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_EXTERNAL_OES, *srcTex));
+ imageTargetExternalTexture(api.m_egl, gl, **img);
+ {
+ /* init YUV texture with glClear, clear color value in YUV color space */
+ glu::Framebuffer fbo(gl);
+ GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, *fbo));
+ GLU_CHECK_GLW_CALL(gl, framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_EXTERNAL_OES,*srcTex, 0));
+ const tcu::Vec4 colorValues[] =
+ {
+ tcu::Vec4(0.9f, 0.5f, 0.65f, 1.0f),
+ tcu::Vec4(0.5f, 0.7f, 0.65f, 1.0f),
+ tcu::Vec4(0.2f, 0.5f, 0.65f, 1.0f),
+ tcu::Vec4(0.3f, 0.1f, 0.5f, 1.0f),
+ tcu::Vec4(0.8f, 0.2f, 0.3f, 1.0f),
+ tcu::Vec4(0.9f, 0.4f, 0.8f, 1.0f),
+ };
+ tcu::clear(reference.getLevel(0), tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f));
+ GLU_CHECK_GLW_CALL(gl, enable(GL_SCISSOR_TEST));
+ for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorValues); ++ndx)
+ {
+ const tcu::IVec2 size = tcu::IVec2((int)((float)(DE_LENGTH_OF_ARRAY(colorValues) - ndx) * ((float)reference.getWidth() / float(DE_LENGTH_OF_ARRAY(colorValues)))),
+ (int)((float)(DE_LENGTH_OF_ARRAY(colorValues) - ndx) * ((float)reference.getHeight() / float(DE_LENGTH_OF_ARRAY(colorValues)))));
+
+ if (size.x() == 0 || size.y() == 0)
+ break;
+ GLU_CHECK_GLW_CALL(gl, scissor(0, 0, size.x(), size.y()));
+
+ GLU_CHECK_GLW_CALL(gl, clearColor(colorValues[ndx].x(), colorValues[ndx].y(), colorValues[ndx].z(), colorValues[ndx].w()));
+ GLU_CHECK_GLW_CALL(gl, clear(GL_COLOR_BUFFER_BIT));
+ GLU_CHECK_GLW_CALL(gl, finish());
+ char tmp[4]={"0"};
+ GLU_CHECK_GLW_CALL(gl, readPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, (void*)tmp));
+ tcu::clear(tcu::getSubregion(reference.getLevel(0), 0, 0, size.x(), size.y()), tcu::Vec4(tmp[0]/(255.0f), tmp[1]/(255.0f), tmp[2]/(255.0f), tmp[3]/(255.0f)));
+ }
+ GLU_CHECK_GLW_CALL(gl, disable(GL_SCISSOR_TEST));
+ GLU_CHECK_GLW_CALL(gl, framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_EXTERNAL_OES, 0, 0));
+ GLU_CHECK_GLW_CALL(gl, bindFramebuffer(GL_FRAMEBUFFER, 0));
+ GLU_CHECK_GLW_CALL(gl, finish());
+ }
+
+ GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
+ GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
+ GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+ GLU_CHECK_GLW_CALL(gl, texParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
+
+ const char* const vertexShader =
+ "attribute highp vec2 a_coord;\n"
+ "varying mediump vec2 v_texCoord;\n"
+ "void main(void) {\n"
+ "\tv_texCoord = vec2((a_coord.x + 1.0) * 0.5, (a_coord.y + 1.0) * 0.5);\n"
+ "\tgl_Position = vec4(a_coord, -0.1, 1.0);\n"
+ "}\n";
+
+ const char* const fragmentShader =
+ "#extension GL_OES_EGL_image_external : require\n"
+ "varying mediump vec2 v_texCoord;\n"
+ "uniform samplerExternalOES u_sampler;\n"
+ "void main(void) {\n"
+ "\tmediump vec4 texColor = texture2D(u_sampler, v_texCoord);\n"
+ "\tgl_FragColor = vec4(texColor);\n"
+ "}";
+
+ Program program(gl, vertexShader, fragmentShader);
+ TCU_CHECK(program.isOk());
+
+ GLuint glProgram = program.getProgram();
+ GLU_CHECK_GLW_CALL(gl, useProgram(glProgram));
+
+ GLuint coordLoc = gl.getAttribLocation(glProgram, "a_coord");
+ TCU_CHECK_MSG((int)coordLoc != -1, "Couldn't find attribute a_coord");
+
+ GLuint samplerLoc = gl.getUniformLocation(glProgram, "u_sampler");
+ TCU_CHECK_MSG((int)samplerLoc != (int)-1, "Couldn't find uniform u_sampler");
+
+ GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_EXTERNAL_OES, *srcTex));
+ GLU_CHECK_GLW_CALL(gl, uniform1i(samplerLoc, 0));
+ GLU_CHECK_GLW_CALL(gl, enableVertexAttribArray(coordLoc));
+ GLU_CHECK_GLW_CALL(gl, vertexAttribPointer(coordLoc, 2, GL_FLOAT, GL_FALSE, 0, squareTriangleCoords));
+
+ GLU_CHECK_GLW_CALL(gl, drawArrays(GL_TRIANGLES, 0, 6));
+ GLU_CHECK_GLW_CALL(gl, disableVertexAttribArray(coordLoc));
+ GLU_CHECK_GLW_CALL(gl, bindTexture(GL_TEXTURE_EXTERNAL_OES, 0));
+
+ tcu::Surface refSurface (reference.getWidth(), reference.getHeight());
+ tcu::Surface screen (reference.getWidth(), reference.getHeight());
+ GLU_CHECK_GLW_CALL(gl, readPixels(0, 0, screen.getWidth(), screen.getHeight(), GL_RGBA, GL_UNSIGNED_BYTE, screen.getAccess().getDataPtr()));
+
+ tcu::copy(refSurface.getAccess(), reference.getLevel(0));
+
+ float threshold = 0.05f;
+ bool match = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refSurface, screen, threshold, tcu::COMPARE_LOG_RESULT);
+
+ return match;
+}
+
bool GLESImageApi::RenderExternalTextureSamplerArray::invokeGLES (GLESImageApi& api, MovePtr<UniqueImage>& img, tcu::Texture2D& reference) const
{
const glw::Functions& gl = api.m_gl;
void addCreateTexture (const string& name, EGLenum source, GLenum internalFormat, GLenum format, GLenum type);
void addCreateRenderbuffer (const string& name, GLenum format);
- void addCreateAndroidNative (const string& name, GLenum format);
+ void addCreateAndroidNative (const string& name, GLenum format, bool isYUV);
void addCreateAndroidNativeArray (const string& name, GLenum format, deUint32 numLayers);
void addCreateTexture2DActions (const string& prefix);
void addCreateTextureCubemapActions (const string& suffix, GLenum internalFormat, GLenum format, GLenum type);
m_createActions.add(name, MovePtr<Action>(new GLESImageApi::Create(createRenderbufferImageSource(format))));
}
-void ImageTests::addCreateAndroidNative (const string& name, GLenum format)
+void ImageTests::addCreateAndroidNative (const string& name, GLenum format, bool isYUV = false)
{
- m_createActions.add(name, MovePtr<Action>(new GLESImageApi::Create(createAndroidNativeImageSource(format, 1u))));
+ m_createActions.add(name, MovePtr<Action>(new GLESImageApi::Create(createAndroidNativeImageSource(format, 1u, isYUV))));
}
void ImageTests::addCreateAndroidNativeArray (const string& name, GLenum format, deUint32 numLayers)
{
- m_createActions.add(name, MovePtr<Action>(new GLESImageApi::Create(createAndroidNativeImageSource(format, numLayers), numLayers)));
+ m_createActions.add(name, MovePtr<Action>(new GLESImageApi::Create(createAndroidNativeImageSource(format, numLayers, false), numLayers)));
}
void ImageTests::addCreateTexture2DActions (const string& prefix)
addCreateAndroidNative("android_native_rgb10a2", GL_RGB10_A2);
addCreateAndroidNative("android_native_rgba16f", GL_RGBA16F);
addCreateAndroidNative("android_native_s8", GL_STENCIL_INDEX8);
+ addCreateAndroidNative("android_native_yuv420", GL_RGBA8, true);
addCreateAndroidNativeArray("android_native_array_rgba4", GL_RGBA4, 4u);
addCreateAndroidNativeArray("android_native_array_rgb5_a1", GL_RGB5_A1, 4u);
m_renderActions.add("read_pixels", MovePtr<Action>(new GLESImageApi::RenderReadPixelsRenderbuffer()));
m_renderActions.add("depth_buffer", MovePtr<Action>(new GLESImageApi::RenderDepthbuffer()));
m_renderActions.add("stencil_buffer", MovePtr<Action>(new GLESImageApi::RenderStencilbuffer()));
+ m_renderActions.add("yuv_texture", MovePtr<Action>(new GLESImageApi::RenderYUVTexture()));
}
class SimpleCreationTests : public RenderTests
{
if (const GLESImageApi::Create* glesCreate = dynamic_cast<const GLESImageApi::Create*>(&create))
{
- const GLenum createFormat = glesCreate->getEffectiveFormat();
-
- if (dynamic_cast<const GLESImageApi::RenderTexture2DArray*>(&render))
- {
- // Makes sense only for texture arrays.
- if (glesCreate->getNumLayers() <= 1u)
- return false;
- }
- else if (glesCreate->getNumLayers() != 1u)
+ bool yuvFormatTest = glesCreate->isYUVFormatImage();
+ // this path only for none-yuv format tests
+ if(!yuvFormatTest)
{
- // Skip other render actions for texture arrays.
- return false;
- }
+ const GLenum createFormat = glesCreate->getEffectiveFormat();
- if (dynamic_cast<const GLESImageApi::RenderTexture2D*>(&render))
- {
- // GLES does not have depth or stencil textures
- if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
+ if (dynamic_cast<const GLESImageApi::RenderTexture2DArray*>(&render))
+ {
+ // Makes sense only for texture arrays.
+ if (glesCreate->getNumLayers() <= 1u)
+ return false;
+ }
+ else if (glesCreate->getNumLayers() != 1u)
+ {
+ // Skip other render actions for texture arrays.
return false;
- }
+ }
- if (dynamic_cast<const GLESImageApi::RenderReadPixelsRenderbuffer*>(&render))
- {
- // GLES does not support readPixels for depth or stencil.
- if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
- return false;
- }
+ if (dynamic_cast<const GLESImageApi::RenderTexture2D*>(&render))
+ {
+ // GLES does not have depth or stencil textures
+ if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
+ return false;
+ }
- if (dynamic_cast<const GLESImageApi::RenderDepthbuffer*>(&render))
- {
- // Copying non-depth data to depth renderbuffer and expecting meaningful
- // results just doesn't make any sense.
- if (!isDepthFormat(createFormat))
+ if (dynamic_cast<const GLESImageApi::RenderReadPixelsRenderbuffer*>(&render))
+ {
+ // GLES does not support readPixels for depth or stencil.
+ if (isDepthFormat(createFormat) || isStencilFormat(createFormat))
+ return false;
+ }
+
+ if (dynamic_cast<const GLESImageApi::RenderDepthbuffer*>(&render))
+ {
+ // Copying non-depth data to depth renderbuffer and expecting meaningful
+ // results just doesn't make any sense.
+ if (!isDepthFormat(createFormat))
+ return false;
+ }
+
+ if (dynamic_cast<const GLESImageApi::RenderStencilbuffer*>(&render))
+ {
+ // Copying non-stencil data to stencil renderbuffer and expecting meaningful
+ // results just doesn't make any sense.
+ if (!isStencilFormat(createFormat))
+ return false;
+ }
+
+ if (dynamic_cast<const GLESImageApi::RenderYUVTexture*>(&render))
+ {
+ // In yuv path rendering with non-yuv format native buffer and expecting meaningful
+ // results just doesn't make any sense
return false;
- }
+ }
- if (dynamic_cast<const GLESImageApi::RenderStencilbuffer*>(&render))
+ return true;
+ }
+ else if (dynamic_cast<const GLESImageApi::RenderYUVTexture*>(&render))
{
- // Copying non-stencil data to stencil renderbuffer and expecting meaningful
- // results just doesn't make any sense.
- if (!isStencilFormat(createFormat))
- return false;
+ return true;
}
-
- return true;
}
else
DE_ASSERT(false);
if (!isCompatibleCreateAndRenderActions(*createAction.action, *renderAction.action))
continue;
- if (dynamic_cast<const GLESImageApi::RenderTexture2DArray*>(renderAction.action.get()))
+ if (dynamic_cast<const GLESImageApi::RenderTexture2DArray*>(renderAction.action.get()) ||
+ dynamic_cast<const GLESImageApi::RenderYUVTexture*>(renderAction.action.get()))
{
// Texture array tests require GLES3.
spec.name = std::string("gles3_") + createAction.label + "_" + renderAction.label;
// No modify tests for texture arrays.
if (glesCreate->getNumLayers() > 1u)
return false;
+ // No modify tests for yuv format image.
+ if (glesCreate->isYUVFormatImage())
+ return false;
const GLenum createFormat = glesCreate->getEffectiveFormat();
projects / platform / upstream / VK-GL-CTS.git / commitdiff