Home | History | Annotate | Download | only in libGLESv2 
      1 //
      2 // Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 
      7 // validationES.h: Validation functions for generic OpenGL ES entry point parameters
      8 
      9 #include "libGLESv2/validationES.h"
     10 #include "libGLESv2/validationES2.h"
     11 #include "libGLESv2/validationES3.h"
     12 #include "libGLESv2/Context.h"
     13 #include "libGLESv2/Texture.h"
     14 #include "libGLESv2/Framebuffer.h"
     15 #include "libGLESv2/FramebufferAttachment.h"
     16 #include "libGLESv2/formatutils.h"
     17 #include "libGLESv2/main.h"
     18 #include "libGLESv2/Query.h"
     19 #include "libGLESv2/ProgramBinary.h"
     20 #include "libGLESv2/TransformFeedback.h"
     21 #include "libGLESv2/VertexArray.h"
     22 #include "libGLESv2/renderer/BufferImpl.h"
     23 
     24 #include "common/mathutil.h"
     25 #include "common/utilities.h"
     26 
     27 namespace gl
     28 {
     29 
     30 bool ValidCap(const Context *context, GLenum cap)
     31 {
     32     switch (cap)
     33     {
     34       case GL_CULL_FACE:
     35       case GL_POLYGON_OFFSET_FILL:
     36       case GL_SAMPLE_ALPHA_TO_COVERAGE:
     37       case GL_SAMPLE_COVERAGE:
     38       case GL_SCISSOR_TEST:
     39       case GL_STENCIL_TEST:
     40       case GL_DEPTH_TEST:
     41       case GL_BLEND:
     42       case GL_DITHER:
     43         return true;
     44       case GL_PRIMITIVE_RESTART_FIXED_INDEX:
     45       case GL_RASTERIZER_DISCARD:
     46         return (context->getClientVersion() >= 3);
     47       default:
     48         return false;
     49     }
     50 }
     51 
     52 bool ValidTextureTarget(const Context *context, GLenum target)
     53 {
     54     switch (target)
     55     {
     56       case GL_TEXTURE_2D:
     57       case GL_TEXTURE_CUBE_MAP:
     58         return true;
     59 
     60       case GL_TEXTURE_3D:
     61       case GL_TEXTURE_2D_ARRAY:
     62         return (context->getClientVersion() >= 3);
     63 
     64       default:
     65         return false;
     66     }
     67 }
     68 
     69 // This function differs from ValidTextureTarget in that the target must be
     70 // usable as the destination of a 2D operation-- so a cube face is valid, but
     71 // GL_TEXTURE_CUBE_MAP is not.
     72 // Note: duplicate of IsInternalTextureTarget
     73 bool ValidTexture2DDestinationTarget(const Context *context, GLenum target)
     74 {
     75     switch (target)
     76     {
     77       case GL_TEXTURE_2D:
     78       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
     79       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
     80       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
     81       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
     82       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
     83       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
     84         return true;
     85       case GL_TEXTURE_2D_ARRAY:
     86       case GL_TEXTURE_3D:
     87         return (context->getClientVersion() >= 3);
     88       default:
     89         return false;
     90     }
     91 }
     92 
     93 bool ValidFramebufferTarget(GLenum target)
     94 {
     95     META_ASSERT(GL_DRAW_FRAMEBUFFER_ANGLE == GL_DRAW_FRAMEBUFFER && GL_READ_FRAMEBUFFER_ANGLE == GL_READ_FRAMEBUFFER);
     96 
     97     switch (target)
     98     {
     99       case GL_FRAMEBUFFER:      return true;
    100       case GL_READ_FRAMEBUFFER: return true;
    101       case GL_DRAW_FRAMEBUFFER: return true;
    102       default:                  return false;
    103     }
    104 }
    105 
    106 bool ValidBufferTarget(const Context *context, GLenum target)
    107 {
    108     switch (target)
    109     {
    110       case GL_ARRAY_BUFFER:
    111       case GL_ELEMENT_ARRAY_BUFFER:
    112         return true;
    113 
    114       case GL_PIXEL_PACK_BUFFER:
    115       case GL_PIXEL_UNPACK_BUFFER:
    116         return context->getExtensions().pixelBufferObject;
    117 
    118       case GL_COPY_READ_BUFFER:
    119       case GL_COPY_WRITE_BUFFER:
    120       case GL_TRANSFORM_FEEDBACK_BUFFER:
    121       case GL_UNIFORM_BUFFER:
    122         return (context->getClientVersion() >= 3);
    123 
    124       default:
    125         return false;
    126     }
    127 }
    128 
    129 bool ValidBufferParameter(const Context *context, GLenum pname)
    130 {
    131     switch (pname)
    132     {
    133       case GL_BUFFER_USAGE:
    134       case GL_BUFFER_SIZE:
    135         return true;
    136 
    137       // GL_BUFFER_MAP_POINTER is a special case, and may only be
    138       // queried with GetBufferPointerv
    139       case GL_BUFFER_ACCESS_FLAGS:
    140       case GL_BUFFER_MAPPED:
    141       case GL_BUFFER_MAP_OFFSET:
    142       case GL_BUFFER_MAP_LENGTH:
    143         return (context->getClientVersion() >= 3);
    144 
    145       default:
    146         return false;
    147     }
    148 }
    149 
    150 bool ValidMipLevel(const Context *context, GLenum target, GLint level)
    151 {
    152     size_t maxDimension = 0;
    153     switch (target)
    154     {
    155       case GL_TEXTURE_2D:                  maxDimension = context->getCaps().max2DTextureSize;       break;
    156       case GL_TEXTURE_CUBE_MAP:
    157       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
    158       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
    159       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
    160       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
    161       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
    162       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: maxDimension = context->getCaps().maxCubeMapTextureSize;  break;
    163       case GL_TEXTURE_3D:                  maxDimension = context->getCaps().max3DTextureSize;       break;
    164       case GL_TEXTURE_2D_ARRAY:            maxDimension = context->getCaps().max2DTextureSize;       break;
    165       default: UNREACHABLE();
    166     }
    167 
    168     return level <= gl::log2(maxDimension);
    169 }
    170 
    171 bool ValidImageSize(const Context *context, GLenum target, GLint level,
    172                     GLsizei width, GLsizei height, GLsizei depth)
    173 {
    174     if (level < 0 || width < 0 || height < 0 || depth < 0)
    175     {
    176         return false;
    177     }
    178 
    179     if (!context->getExtensions().textureNPOT &&
    180         (level != 0 && (!gl::isPow2(width) || !gl::isPow2(height) || !gl::isPow2(depth))))
    181     {
    182         return false;
    183     }
    184 
    185     if (!ValidMipLevel(context, target, level))
    186     {
    187         return false;
    188     }
    189 
    190     return true;
    191 }
    192 
    193 bool ValidCompressedImageSize(const Context *context, GLenum internalFormat, GLsizei width, GLsizei height)
    194 {
    195     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat);
    196     if (!formatInfo.compressed)
    197     {
    198         return false;
    199     }
    200 
    201     if (width  < 0 || (static_cast<GLuint>(width)  > formatInfo.compressedBlockWidth  && width  % formatInfo.compressedBlockWidth != 0) ||
    202         height < 0 || (static_cast<GLuint>(height) > formatInfo.compressedBlockHeight && height % formatInfo.compressedBlockHeight != 0))
    203     {
    204         return false;
    205     }
    206 
    207     return true;
    208 }
    209 
    210 bool ValidQueryType(const Context *context, GLenum queryType)
    211 {
    212     META_ASSERT(GL_ANY_SAMPLES_PASSED == GL_ANY_SAMPLES_PASSED_EXT);
    213     META_ASSERT(GL_ANY_SAMPLES_PASSED_CONSERVATIVE == GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT);
    214 
    215     switch (queryType)
    216     {
    217       case GL_ANY_SAMPLES_PASSED:
    218       case GL_ANY_SAMPLES_PASSED_CONSERVATIVE:
    219         return true;
    220       case GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN:
    221         return (context->getClientVersion() >= 3);
    222       default:
    223         return false;
    224     }
    225 }
    226 
    227 bool ValidProgram(Context *context, GLuint id)
    228 {
    229     // ES3 spec (section 2.11.1) -- "Commands that accept shader or program object names will generate the
    230     // error INVALID_VALUE if the provided name is not the name of either a shader or program object and
    231     // INVALID_OPERATION if the provided name identifies an object that is not the expected type."
    232 
    233     if (context->getProgram(id) != NULL)
    234     {
    235         return true;
    236     }
    237     else if (context->getShader(id) != NULL)
    238     {
    239         // ID is the wrong type
    240         context->recordError(Error(GL_INVALID_OPERATION));
    241         return false;
    242     }
    243     else
    244     {
    245         // No shader/program object has this ID
    246         context->recordError(Error(GL_INVALID_VALUE));
    247         return false;
    248     }
    249 }
    250 
    251 bool ValidateAttachmentTarget(gl::Context *context, GLenum attachment)
    252 {
    253     if (attachment >= GL_COLOR_ATTACHMENT0_EXT && attachment <= GL_COLOR_ATTACHMENT15_EXT)
    254     {
    255         const unsigned int colorAttachment = (attachment - GL_COLOR_ATTACHMENT0_EXT);
    256 
    257         if (colorAttachment >= context->getCaps().maxColorAttachments)
    258         {
    259             context->recordError(Error(GL_INVALID_VALUE));
    260             return false;
    261         }
    262     }
    263     else
    264     {
    265         switch (attachment)
    266         {
    267           case GL_DEPTH_ATTACHMENT:
    268           case GL_STENCIL_ATTACHMENT:
    269             break;
    270 
    271           case GL_DEPTH_STENCIL_ATTACHMENT:
    272             if (context->getClientVersion() < 3)
    273             {
    274                 context->recordError(Error(GL_INVALID_ENUM));
    275                 return false;
    276             }
    277             break;
    278 
    279           default:
    280             context->recordError(Error(GL_INVALID_ENUM));
    281             return false;
    282         }
    283     }
    284 
    285     return true;
    286 }
    287 
    288 bool ValidateRenderbufferStorageParameters(gl::Context *context, GLenum target, GLsizei samples,
    289                                            GLenum internalformat, GLsizei width, GLsizei height,
    290                                            bool angleExtension)
    291 {
    292     switch (target)
    293     {
    294       case GL_RENDERBUFFER:
    295         break;
    296       default:
    297         context->recordError(Error(GL_INVALID_ENUM));
    298         return false;
    299     }
    300 
    301     if (width < 0 || height < 0 || samples < 0)
    302     {
    303         context->recordError(Error(GL_INVALID_VALUE));
    304         return false;
    305     }
    306 
    307     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
    308     if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
    309     {
    310         context->recordError(Error(GL_INVALID_ENUM));
    311         return false;
    312     }
    313 
    314     // ANGLE_framebuffer_multisample does not explicitly state that the internal format must be
    315     // sized but it does state that the format must be in the ES2.0 spec table 4.5 which contains
    316     // only sized internal formats. The ES3 spec (section 4.4.2) does, however, state that the
    317     // internal format must be sized and not an integer format if samples is greater than zero.
    318     if (formatInfo.pixelBytes == 0)
    319     {
    320         context->recordError(Error(GL_INVALID_ENUM));
    321         return false;
    322     }
    323 
    324     if ((formatInfo.componentType == GL_UNSIGNED_INT || formatInfo.componentType == GL_INT) && samples > 0)
    325     {
    326         context->recordError(Error(GL_INVALID_OPERATION));
    327         return false;
    328     }
    329 
    330     const TextureCaps &formatCaps = context->getTextureCaps().get(internalformat);
    331     if (!formatCaps.renderable)
    332     {
    333         context->recordError(Error(GL_INVALID_ENUM));
    334         return false;
    335     }
    336 
    337     if (static_cast<GLuint>(std::max(width, height)) > context->getCaps().maxRenderbufferSize)
    338     {
    339         context->recordError(Error(GL_INVALID_VALUE));
    340         return false;
    341     }
    342 
    343     // ANGLE_framebuffer_multisample states that the value of samples must be less than or equal
    344     // to MAX_SAMPLES_ANGLE (Context::getMaxSupportedSamples) while the ES3.0 spec (section 4.4.2)
    345     // states that samples must be less than or equal to the maximum samples for the specified
    346     // internal format.
    347     if (angleExtension)
    348     {
    349         ASSERT(context->getExtensions().framebufferMultisample);
    350         if (static_cast<GLuint>(samples) > context->getExtensions().maxSamples)
    351         {
    352             context->recordError(Error(GL_INVALID_VALUE));
    353             return false;
    354         }
    355 
    356         // Check if this specific format supports enough samples
    357         if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
    358         {
    359             context->recordError(Error(GL_OUT_OF_MEMORY));
    360             return false;
    361         }
    362     }
    363     else
    364     {
    365         if (static_cast<GLuint>(samples) > formatCaps.getMaxSamples())
    366         {
    367             context->recordError(Error(GL_INVALID_VALUE));
    368             return false;
    369         }
    370     }
    371 
    372     GLuint handle = context->getState().getRenderbufferId();
    373     if (handle == 0)
    374     {
    375         context->recordError(Error(GL_INVALID_OPERATION));
    376         return false;
    377     }
    378 
    379     return true;
    380 }
    381 
    382 bool ValidateFramebufferRenderbufferParameters(gl::Context *context, GLenum target, GLenum attachment,
    383                                                GLenum renderbuffertarget, GLuint renderbuffer)
    384 {
    385     if (!ValidFramebufferTarget(target))
    386     {
    387         context->recordError(Error(GL_INVALID_ENUM));
    388         return false;
    389     }
    390 
    391     gl::Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target);
    392     GLuint framebufferHandle = context->getState().getTargetFramebuffer(target)->id();
    393 
    394     if (!framebuffer || (framebufferHandle == 0 && renderbuffer != 0))
    395     {
    396         context->recordError(Error(GL_INVALID_OPERATION));
    397         return false;
    398     }
    399 
    400     if (!ValidateAttachmentTarget(context, attachment))
    401     {
    402         return false;
    403     }
    404 
    405     // [OpenGL ES 2.0.25] Section 4.4.3 page 112
    406     // [OpenGL ES 3.0.2] Section 4.4.2 page 201
    407     // 'renderbuffer' must be either zero or the name of an existing renderbuffer object of
    408     // type 'renderbuffertarget', otherwise an INVALID_OPERATION error is generated.
    409     if (renderbuffer != 0)
    410     {
    411         if (!context->getRenderbuffer(renderbuffer))
    412         {
    413             context->recordError(Error(GL_INVALID_OPERATION));
    414             return false;
    415         }
    416     }
    417 
    418     return true;
    419 }
    420 
    421 static bool IsPartialBlit(gl::Context *context, gl::FramebufferAttachment *readBuffer, gl::FramebufferAttachment *writeBuffer,
    422                           GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
    423                           GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1)
    424 {
    425     if (srcX0 != 0 || srcY0 != 0 || dstX0 != 0 || dstY0 != 0 ||
    426         dstX1 != writeBuffer->getWidth() || dstY1 != writeBuffer->getHeight() ||
    427         srcX1 != readBuffer->getWidth() || srcY1 != readBuffer->getHeight())
    428     {
    429         return true;
    430     }
    431     else if (context->getState().isScissorTestEnabled())
    432     {
    433         const Rectangle &scissor = context->getState().getScissor();
    434 
    435         return scissor.x > 0 || scissor.y > 0 ||
    436                scissor.width < writeBuffer->getWidth() ||
    437                scissor.height < writeBuffer->getHeight();
    438     }
    439     else
    440     {
    441         return false;
    442     }
    443 }
    444 
    445 bool ValidateBlitFramebufferParameters(gl::Context *context, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
    446                                        GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
    447                                        GLenum filter, bool fromAngleExtension)
    448 {
    449     switch (filter)
    450     {
    451       case GL_NEAREST:
    452         break;
    453       case GL_LINEAR:
    454         if (fromAngleExtension)
    455         {
    456             context->recordError(Error(GL_INVALID_ENUM));
    457             return false;
    458         }
    459         break;
    460       default:
    461         context->recordError(Error(GL_INVALID_ENUM));
    462         return false;
    463     }
    464 
    465     if ((mask & ~(GL_COLOR_BUFFER_BIT | GL_STENCIL_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)) != 0)
    466     {
    467         context->recordError(Error(GL_INVALID_VALUE));
    468         return false;
    469     }
    470 
    471     if (mask == 0)
    472     {
    473         // ES3.0 spec, section 4.3.2 specifies that a mask of zero is valid and no
    474         // buffers are copied.
    475         return false;
    476     }
    477 
    478     if (fromAngleExtension && (srcX1 - srcX0 != dstX1 - dstX0 || srcY1 - srcY0 != dstY1 - dstY0))
    479     {
    480         ERR("Scaling and flipping in BlitFramebufferANGLE not supported by this implementation.");
    481         context->recordError(Error(GL_INVALID_OPERATION));
    482         return false;
    483     }
    484 
    485     // ES3.0 spec, section 4.3.2 states that linear filtering is only available for the
    486     // color buffer, leaving only nearest being unfiltered from above
    487     if ((mask & ~GL_COLOR_BUFFER_BIT) != 0 && filter != GL_NEAREST)
    488     {
    489         context->recordError(Error(GL_INVALID_OPERATION));
    490         return false;
    491     }
    492 
    493     if (context->getState().getReadFramebuffer()->id() == context->getState().getDrawFramebuffer()->id())
    494     {
    495         if (fromAngleExtension)
    496         {
    497             ERR("Blits with the same source and destination framebuffer are not supported by this "
    498                 "implementation.");
    499         }
    500         context->recordError(Error(GL_INVALID_OPERATION));
    501         return false;
    502     }
    503 
    504     gl::Framebuffer *readFramebuffer = context->getState().getReadFramebuffer();
    505     gl::Framebuffer *drawFramebuffer = context->getState().getDrawFramebuffer();
    506     if (!readFramebuffer || readFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE ||
    507         !drawFramebuffer || drawFramebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
    508     {
    509         context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
    510         return false;
    511     }
    512 
    513     if (drawFramebuffer->getSamples() != 0)
    514     {
    515         context->recordError(Error(GL_INVALID_OPERATION));
    516         return false;
    517     }
    518 
    519     bool sameBounds = srcX0 == dstX0 && srcY0 == dstY0 && srcX1 == dstX1 && srcY1 == dstY1;
    520 
    521     if (mask & GL_COLOR_BUFFER_BIT)
    522     {
    523         gl::FramebufferAttachment *readColorBuffer = readFramebuffer->getReadColorbuffer();
    524         gl::FramebufferAttachment *drawColorBuffer = drawFramebuffer->getFirstColorbuffer();
    525 
    526         if (readColorBuffer && drawColorBuffer)
    527         {
    528             GLenum readInternalFormat = readColorBuffer->getActualFormat();
    529             const InternalFormat &readFormatInfo = GetInternalFormatInfo(readInternalFormat);
    530 
    531             for (unsigned int i = 0; i < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; i++)
    532             {
    533                 if (drawFramebuffer->isEnabledColorAttachment(i))
    534                 {
    535                     GLenum drawInternalFormat = drawFramebuffer->getColorbuffer(i)->getActualFormat();
    536                     const InternalFormat &drawFormatInfo = GetInternalFormatInfo(drawInternalFormat);
    537 
    538                     // The GL ES 3.0.2 spec (pg 193) states that:
    539                     // 1) If the read buffer is fixed point format, the draw buffer must be as well
    540                     // 2) If the read buffer is an unsigned integer format, the draw buffer must be as well
    541                     // 3) If the read buffer is a signed integer format, the draw buffer must be as well
    542                     if ( (readFormatInfo.componentType == GL_UNSIGNED_NORMALIZED || readFormatInfo.componentType == GL_SIGNED_NORMALIZED) &&
    543                         !(drawFormatInfo.componentType == GL_UNSIGNED_NORMALIZED || drawFormatInfo.componentType == GL_SIGNED_NORMALIZED))
    544                     {
    545                         context->recordError(Error(GL_INVALID_OPERATION));
    546                         return false;
    547                     }
    548 
    549                     if (readFormatInfo.componentType == GL_UNSIGNED_INT && drawFormatInfo.componentType != GL_UNSIGNED_INT)
    550                     {
    551                         context->recordError(Error(GL_INVALID_OPERATION));
    552                         return false;
    553                     }
    554 
    555                     if (readFormatInfo.componentType == GL_INT && drawFormatInfo.componentType != GL_INT)
    556                     {
    557                         context->recordError(Error(GL_INVALID_OPERATION));
    558                         return false;
    559                     }
    560 
    561                     if (readColorBuffer->getSamples() > 0 && (readInternalFormat != drawInternalFormat || !sameBounds))
    562                     {
    563                         context->recordError(Error(GL_INVALID_OPERATION));
    564                         return false;
    565                     }
    566                 }
    567             }
    568 
    569             if ((readFormatInfo.componentType == GL_INT || readFormatInfo.componentType == GL_UNSIGNED_INT) && filter == GL_LINEAR)
    570             {
    571                 context->recordError(Error(GL_INVALID_OPERATION));
    572                 return false;
    573             }
    574 
    575             if (fromAngleExtension)
    576             {
    577                 const GLenum readColorbufferType = readFramebuffer->getReadColorbufferType();
    578                 if (readColorbufferType != GL_TEXTURE_2D && readColorbufferType != GL_RENDERBUFFER)
    579                 {
    580                     context->recordError(Error(GL_INVALID_OPERATION));
    581                     return false;
    582                 }
    583 
    584                 for (unsigned int colorAttachment = 0; colorAttachment < gl::IMPLEMENTATION_MAX_DRAW_BUFFERS; colorAttachment++)
    585                 {
    586                     if (drawFramebuffer->isEnabledColorAttachment(colorAttachment))
    587                     {
    588                         FramebufferAttachment *attachment = drawFramebuffer->getColorbuffer(colorAttachment);
    589                         ASSERT(attachment);
    590 
    591                         if (attachment->type() != GL_TEXTURE_2D && attachment->type() != GL_RENDERBUFFER)
    592                         {
    593                             context->recordError(Error(GL_INVALID_OPERATION));
    594                             return false;
    595                         }
    596 
    597                         if (attachment->getActualFormat() != readColorBuffer->getActualFormat())
    598                         {
    599                             context->recordError(Error(GL_INVALID_OPERATION));
    600                             return false;
    601                         }
    602                     }
    603                 }
    604                 if (readFramebuffer->getSamples() != 0 && IsPartialBlit(context, readColorBuffer, drawColorBuffer,
    605                                                                         srcX0, srcY0, srcX1, srcY1,
    606                                                                         dstX0, dstY0, dstX1, dstY1))
    607                 {
    608                     context->recordError(Error(GL_INVALID_OPERATION));
    609                     return false;
    610                 }
    611             }
    612         }
    613     }
    614 
    615     if (mask & GL_DEPTH_BUFFER_BIT)
    616     {
    617         gl::FramebufferAttachment *readDepthBuffer = readFramebuffer->getDepthbuffer();
    618         gl::FramebufferAttachment *drawDepthBuffer = drawFramebuffer->getDepthbuffer();
    619 
    620         if (readDepthBuffer && drawDepthBuffer)
    621         {
    622             if (readDepthBuffer->getActualFormat() != drawDepthBuffer->getActualFormat())
    623             {
    624                 context->recordError(Error(GL_INVALID_OPERATION));
    625                 return false;
    626             }
    627 
    628             if (readDepthBuffer->getSamples() > 0 && !sameBounds)
    629             {
    630                 context->recordError(Error(GL_INVALID_OPERATION));
    631                 return false;
    632             }
    633 
    634             if (fromAngleExtension)
    635             {
    636                 if (IsPartialBlit(context, readDepthBuffer, drawDepthBuffer,
    637                                   srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1))
    638                 {
    639                     ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
    640                     context->recordError(Error(GL_INVALID_OPERATION)); // only whole-buffer copies are permitted
    641                     return false;
    642                 }
    643 
    644                 if (readDepthBuffer->getSamples() != 0 || drawDepthBuffer->getSamples() != 0)
    645                 {
    646                     context->recordError(Error(GL_INVALID_OPERATION));
    647                     return false;
    648                 }
    649             }
    650         }
    651     }
    652 
    653     if (mask & GL_STENCIL_BUFFER_BIT)
    654     {
    655         gl::FramebufferAttachment *readStencilBuffer = readFramebuffer->getStencilbuffer();
    656         gl::FramebufferAttachment *drawStencilBuffer = drawFramebuffer->getStencilbuffer();
    657 
    658         if (readStencilBuffer && drawStencilBuffer)
    659         {
    660             if (readStencilBuffer->getActualFormat() != drawStencilBuffer->getActualFormat())
    661             {
    662                 context->recordError(Error(GL_INVALID_OPERATION));
    663                 return false;
    664             }
    665 
    666             if (readStencilBuffer->getSamples() > 0 && !sameBounds)
    667             {
    668                 context->recordError(Error(GL_INVALID_OPERATION));
    669                 return false;
    670             }
    671 
    672             if (fromAngleExtension)
    673             {
    674                 if (IsPartialBlit(context, readStencilBuffer, drawStencilBuffer,
    675                                   srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1))
    676                 {
    677                     ERR("Only whole-buffer depth and stencil blits are supported by this implementation.");
    678                     context->recordError(Error(GL_INVALID_OPERATION)); // only whole-buffer copies are permitted
    679                     return false;
    680                 }
    681 
    682                 if (readStencilBuffer->getSamples() != 0 || drawStencilBuffer->getSamples() != 0)
    683                 {
    684                     context->recordError(Error(GL_INVALID_OPERATION));
    685                     return false;
    686                 }
    687             }
    688         }
    689     }
    690 
    691     return true;
    692 }
    693 
    694 bool ValidateGetVertexAttribParameters(Context *context, GLenum pname)
    695 {
    696     switch (pname)
    697     {
    698       case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
    699       case GL_VERTEX_ATTRIB_ARRAY_SIZE:
    700       case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
    701       case GL_VERTEX_ATTRIB_ARRAY_TYPE:
    702       case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
    703       case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
    704       case GL_CURRENT_VERTEX_ATTRIB:
    705         return true;
    706 
    707       case GL_VERTEX_ATTRIB_ARRAY_DIVISOR:
    708         // Don't verify ES3 context because GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE uses
    709         // the same constant.
    710         META_ASSERT(GL_VERTEX_ATTRIB_ARRAY_DIVISOR == GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE);
    711         return true;
    712 
    713       case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
    714         if (context->getClientVersion() < 3)
    715         {
    716             context->recordError(Error(GL_INVALID_ENUM));
    717             return false;
    718         }
    719         return true;
    720 
    721       default:
    722         context->recordError(Error(GL_INVALID_ENUM));
    723         return false;
    724     }
    725 }
    726 
    727 bool ValidateTexParamParameters(gl::Context *context, GLenum pname, GLint param)
    728 {
    729     switch (pname)
    730     {
    731       case GL_TEXTURE_WRAP_R:
    732       case GL_TEXTURE_SWIZZLE_R:
    733       case GL_TEXTURE_SWIZZLE_G:
    734       case GL_TEXTURE_SWIZZLE_B:
    735       case GL_TEXTURE_SWIZZLE_A:
    736       case GL_TEXTURE_BASE_LEVEL:
    737       case GL_TEXTURE_MAX_LEVEL:
    738       case GL_TEXTURE_COMPARE_MODE:
    739       case GL_TEXTURE_COMPARE_FUNC:
    740       case GL_TEXTURE_MIN_LOD:
    741       case GL_TEXTURE_MAX_LOD:
    742         if (context->getClientVersion() < 3)
    743         {
    744             context->recordError(Error(GL_INVALID_ENUM));
    745             return false;
    746         }
    747         break;
    748 
    749       default: break;
    750     }
    751 
    752     switch (pname)
    753     {
    754       case GL_TEXTURE_WRAP_S:
    755       case GL_TEXTURE_WRAP_T:
    756       case GL_TEXTURE_WRAP_R:
    757         switch (param)
    758         {
    759           case GL_REPEAT:
    760           case GL_CLAMP_TO_EDGE:
    761           case GL_MIRRORED_REPEAT:
    762             return true;
    763           default:
    764             context->recordError(Error(GL_INVALID_ENUM));
    765             return false;
    766         }
    767 
    768       case GL_TEXTURE_MIN_FILTER:
    769         switch (param)
    770         {
    771           case GL_NEAREST:
    772           case GL_LINEAR:
    773           case GL_NEAREST_MIPMAP_NEAREST:
    774           case GL_LINEAR_MIPMAP_NEAREST:
    775           case GL_NEAREST_MIPMAP_LINEAR:
    776           case GL_LINEAR_MIPMAP_LINEAR:
    777             return true;
    778           default:
    779             context->recordError(Error(GL_INVALID_ENUM));
    780             return false;
    781         }
    782         break;
    783 
    784       case GL_TEXTURE_MAG_FILTER:
    785         switch (param)
    786         {
    787           case GL_NEAREST:
    788           case GL_LINEAR:
    789             return true;
    790           default:
    791             context->recordError(Error(GL_INVALID_ENUM));
    792             return false;
    793         }
    794         break;
    795 
    796       case GL_TEXTURE_USAGE_ANGLE:
    797         switch (param)
    798         {
    799           case GL_NONE:
    800           case GL_FRAMEBUFFER_ATTACHMENT_ANGLE:
    801             return true;
    802           default:
    803             context->recordError(Error(GL_INVALID_ENUM));
    804             return false;
    805         }
    806         break;
    807 
    808       case GL_TEXTURE_MAX_ANISOTROPY_EXT:
    809         if (!context->getExtensions().textureFilterAnisotropic)
    810         {
    811             context->recordError(Error(GL_INVALID_ENUM));
    812             return false;
    813         }
    814 
    815         // we assume the parameter passed to this validation method is truncated, not rounded
    816         if (param < 1)
    817         {
    818             context->recordError(Error(GL_INVALID_VALUE));
    819             return false;
    820         }
    821         return true;
    822 
    823       case GL_TEXTURE_MIN_LOD:
    824       case GL_TEXTURE_MAX_LOD:
    825         // any value is permissible
    826         return true;
    827 
    828       case GL_TEXTURE_COMPARE_MODE:
    829         // Acceptable mode parameters from GLES 3.0.2 spec, table 3.17
    830         switch (param)
    831         {
    832           case GL_NONE:
    833           case GL_COMPARE_REF_TO_TEXTURE:
    834             return true;
    835           default:
    836             context->recordError(Error(GL_INVALID_ENUM));
    837             return false;
    838         }
    839         break;
    840 
    841       case GL_TEXTURE_COMPARE_FUNC:
    842         // Acceptable function parameters from GLES 3.0.2 spec, table 3.17
    843         switch (param)
    844         {
    845           case GL_LEQUAL:
    846           case GL_GEQUAL:
    847           case GL_LESS:
    848           case GL_GREATER:
    849           case GL_EQUAL:
    850           case GL_NOTEQUAL:
    851           case GL_ALWAYS:
    852           case GL_NEVER:
    853             return true;
    854           default:
    855             context->recordError(Error(GL_INVALID_ENUM));
    856             return false;
    857         }
    858         break;
    859 
    860       case GL_TEXTURE_SWIZZLE_R:
    861       case GL_TEXTURE_SWIZZLE_G:
    862       case GL_TEXTURE_SWIZZLE_B:
    863       case GL_TEXTURE_SWIZZLE_A:
    864         switch (param)
    865         {
    866           case GL_RED:
    867           case GL_GREEN:
    868           case GL_BLUE:
    869           case GL_ALPHA:
    870           case GL_ZERO:
    871           case GL_ONE:
    872             return true;
    873           default:
    874             context->recordError(Error(GL_INVALID_ENUM));
    875             return false;
    876         }
    877         break;
    878 
    879       case GL_TEXTURE_BASE_LEVEL:
    880       case GL_TEXTURE_MAX_LEVEL:
    881         if (param < 0)
    882         {
    883             context->recordError(Error(GL_INVALID_VALUE));
    884             return false;
    885         }
    886         return true;
    887 
    888       default:
    889         context->recordError(Error(GL_INVALID_ENUM));
    890         return false;
    891     }
    892 }
    893 
    894 bool ValidateSamplerObjectParameter(gl::Context *context, GLenum pname)
    895 {
    896     switch (pname)
    897     {
    898       case GL_TEXTURE_MIN_FILTER:
    899       case GL_TEXTURE_MAG_FILTER:
    900       case GL_TEXTURE_WRAP_S:
    901       case GL_TEXTURE_WRAP_T:
    902       case GL_TEXTURE_WRAP_R:
    903       case GL_TEXTURE_MIN_LOD:
    904       case GL_TEXTURE_MAX_LOD:
    905       case GL_TEXTURE_COMPARE_MODE:
    906       case GL_TEXTURE_COMPARE_FUNC:
    907         return true;
    908 
    909       default:
    910         context->recordError(Error(GL_INVALID_ENUM));
    911         return false;
    912     }
    913 }
    914 
    915 bool ValidateReadPixelsParameters(gl::Context *context, GLint x, GLint y, GLsizei width, GLsizei height,
    916                                   GLenum format, GLenum type, GLsizei *bufSize, GLvoid *pixels)
    917 {
    918     gl::Framebuffer *framebuffer = context->getState().getReadFramebuffer();
    919     ASSERT(framebuffer);
    920 
    921     if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
    922     {
    923         context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
    924         return false;
    925     }
    926 
    927     if (context->getState().getReadFramebuffer()->id() != 0 && framebuffer->getSamples() != 0)
    928     {
    929         context->recordError(Error(GL_INVALID_OPERATION));
    930         return false;
    931     }
    932 
    933     if (!framebuffer->getReadColorbuffer())
    934     {
    935         context->recordError(Error(GL_INVALID_OPERATION));
    936         return false;
    937     }
    938 
    939     GLenum currentInternalFormat, currentFormat, currentType;
    940     GLuint clientVersion = context->getClientVersion();
    941 
    942     context->getCurrentReadFormatType(&currentInternalFormat, &currentFormat, &currentType);
    943 
    944     bool validReadFormat = (clientVersion < 3) ? ValidES2ReadFormatType(context, format, type) :
    945                                                  ValidES3ReadFormatType(context, currentInternalFormat, format, type);
    946 
    947     if (!(currentFormat == format && currentType == type) && !validReadFormat)
    948     {
    949         context->recordError(Error(GL_INVALID_OPERATION));
    950         return false;
    951     }
    952 
    953     GLenum sizedInternalFormat = GetSizedInternalFormat(format, type);
    954     const InternalFormat &sizedFormatInfo = GetInternalFormatInfo(sizedInternalFormat);
    955 
    956     GLsizei outputPitch = sizedFormatInfo.computeRowPitch(type, width, context->getState().getPackAlignment());
    957     // sized query sanity check
    958     if (bufSize)
    959     {
    960         int requiredSize = outputPitch * height;
    961         if (requiredSize > *bufSize)
    962         {
    963             context->recordError(Error(GL_INVALID_OPERATION));
    964             return false;
    965         }
    966     }
    967 
    968     return true;
    969 }
    970 
    971 bool ValidateBeginQuery(gl::Context *context, GLenum target, GLuint id)
    972 {
    973     if (!ValidQueryType(context, target))
    974     {
    975         context->recordError(Error(GL_INVALID_ENUM));
    976         return false;
    977     }
    978 
    979     if (id == 0)
    980     {
    981         context->recordError(Error(GL_INVALID_OPERATION));
    982         return false;
    983     }
    984 
    985     // From EXT_occlusion_query_boolean: If BeginQueryEXT is called with an <id>
    986     // of zero, if the active query object name for <target> is non-zero (for the
    987     // targets ANY_SAMPLES_PASSED_EXT and ANY_SAMPLES_PASSED_CONSERVATIVE_EXT, if
    988     // the active query for either target is non-zero), if <id> is the name of an
    989     // existing query object whose type does not match <target>, or if <id> is the
    990     // active query object name for any query type, the error INVALID_OPERATION is
    991     // generated.
    992 
    993     // Ensure no other queries are active
    994     // NOTE: If other queries than occlusion are supported, we will need to check
    995     // separately that:
    996     //    a) The query ID passed is not the current active query for any target/type
    997     //    b) There are no active queries for the requested target (and in the case
    998     //       of GL_ANY_SAMPLES_PASSED_EXT and GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT,
    999     //       no query may be active for either if glBeginQuery targets either.
   1000     if (context->getState().isQueryActive())
   1001     {
   1002         context->recordError(Error(GL_INVALID_OPERATION));
   1003         return false;
   1004     }
   1005 
   1006     Query *queryObject = context->getQuery(id, true, target);
   1007 
   1008     // check that name was obtained with glGenQueries
   1009     if (!queryObject)
   1010     {
   1011         context->recordError(Error(GL_INVALID_OPERATION));
   1012         return false;
   1013     }
   1014 
   1015     // check for type mismatch
   1016     if (queryObject->getType() != target)
   1017     {
   1018         context->recordError(Error(GL_INVALID_OPERATION));
   1019         return false;
   1020     }
   1021 
   1022     return true;
   1023 }
   1024 
   1025 bool ValidateEndQuery(gl::Context *context, GLenum target)
   1026 {
   1027     if (!ValidQueryType(context, target))
   1028     {
   1029         context->recordError(Error(GL_INVALID_ENUM));
   1030         return false;
   1031     }
   1032 
   1033     const Query *queryObject = context->getState().getActiveQuery(target);
   1034 
   1035     if (queryObject == NULL)
   1036     {
   1037         context->recordError(Error(GL_INVALID_OPERATION));
   1038         return false;
   1039     }
   1040 
   1041     return true;
   1042 }
   1043 
   1044 static bool ValidateUniformCommonBase(gl::Context *context, GLenum targetUniformType,
   1045                                       GLint location, GLsizei count, LinkedUniform **uniformOut)
   1046 {
   1047     if (count < 0)
   1048     {
   1049         context->recordError(Error(GL_INVALID_VALUE));
   1050         return false;
   1051     }
   1052 
   1053     gl::ProgramBinary *programBinary = context->getState().getCurrentProgramBinary();
   1054     if (!programBinary)
   1055     {
   1056         context->recordError(Error(GL_INVALID_OPERATION));
   1057         return false;
   1058     }
   1059 
   1060     if (location == -1)
   1061     {
   1062         // Silently ignore the uniform command
   1063         return false;
   1064     }
   1065 
   1066     if (!programBinary->isValidUniformLocation(location))
   1067     {
   1068         context->recordError(Error(GL_INVALID_OPERATION));
   1069         return false;
   1070     }
   1071 
   1072     LinkedUniform *uniform = programBinary->getUniformByLocation(location);
   1073 
   1074     // attempting to write an array to a non-array uniform is an INVALID_OPERATION
   1075     if (uniform->elementCount() == 1 && count > 1)
   1076     {
   1077         context->recordError(Error(GL_INVALID_OPERATION));
   1078         return false;
   1079     }
   1080 
   1081     *uniformOut = uniform;
   1082     return true;
   1083 }
   1084 
   1085 bool ValidateUniform(gl::Context *context, GLenum uniformType, GLint location, GLsizei count)
   1086 {
   1087     // Check for ES3 uniform entry points
   1088     if (VariableComponentType(uniformType) == GL_UNSIGNED_INT && context->getClientVersion() < 3)
   1089     {
   1090         context->recordError(Error(GL_INVALID_OPERATION));
   1091         return false;
   1092     }
   1093 
   1094     LinkedUniform *uniform = NULL;
   1095     if (!ValidateUniformCommonBase(context, uniformType, location, count, &uniform))
   1096     {
   1097         return false;
   1098     }
   1099 
   1100     GLenum targetBoolType = VariableBoolVectorType(uniformType);
   1101     bool samplerUniformCheck = (IsSampler(uniform->type) && uniformType == GL_INT);
   1102     if (!samplerUniformCheck && uniformType != uniform->type && targetBoolType != uniform->type)
   1103     {
   1104         context->recordError(Error(GL_INVALID_OPERATION));
   1105         return false;
   1106     }
   1107 
   1108     return true;
   1109 }
   1110 
   1111 bool ValidateUniformMatrix(gl::Context *context, GLenum matrixType, GLint location, GLsizei count,
   1112                            GLboolean transpose)
   1113 {
   1114     // Check for ES3 uniform entry points
   1115     int rows = VariableRowCount(matrixType);
   1116     int cols = VariableColumnCount(matrixType);
   1117     if (rows != cols && context->getClientVersion() < 3)
   1118     {
   1119         context->recordError(Error(GL_INVALID_OPERATION));
   1120         return false;
   1121     }
   1122 
   1123     if (transpose != GL_FALSE && context->getClientVersion() < 3)
   1124     {
   1125         context->recordError(Error(GL_INVALID_VALUE));
   1126         return false;
   1127     }
   1128 
   1129     LinkedUniform *uniform = NULL;
   1130     if (!ValidateUniformCommonBase(context, matrixType, location, count, &uniform))
   1131     {
   1132         return false;
   1133     }
   1134 
   1135     if (uniform->type != matrixType)
   1136     {
   1137         context->recordError(Error(GL_INVALID_OPERATION));
   1138         return false;
   1139     }
   1140 
   1141     return true;
   1142 }
   1143 
   1144 bool ValidateStateQuery(gl::Context *context, GLenum pname, GLenum *nativeType, unsigned int *numParams)
   1145 {
   1146     if (!context->getQueryParameterInfo(pname, nativeType, numParams))
   1147     {
   1148         context->recordError(Error(GL_INVALID_ENUM));
   1149         return false;
   1150     }
   1151 
   1152     if (pname >= GL_DRAW_BUFFER0 && pname <= GL_DRAW_BUFFER15)
   1153     {
   1154         unsigned int colorAttachment = (pname - GL_DRAW_BUFFER0);
   1155 
   1156         if (colorAttachment >= context->getCaps().maxDrawBuffers)
   1157         {
   1158             context->recordError(Error(GL_INVALID_OPERATION));
   1159             return false;
   1160         }
   1161     }
   1162 
   1163     switch (pname)
   1164     {
   1165       case GL_TEXTURE_BINDING_2D:
   1166       case GL_TEXTURE_BINDING_CUBE_MAP:
   1167       case GL_TEXTURE_BINDING_3D:
   1168       case GL_TEXTURE_BINDING_2D_ARRAY:
   1169         if (context->getState().getActiveSampler() >= context->getCaps().maxCombinedTextureImageUnits)
   1170         {
   1171             context->recordError(Error(GL_INVALID_OPERATION));
   1172             return false;
   1173         }
   1174         break;
   1175 
   1176       case GL_IMPLEMENTATION_COLOR_READ_TYPE:
   1177       case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
   1178         {
   1179             Framebuffer *framebuffer = context->getState().getReadFramebuffer();
   1180             ASSERT(framebuffer);
   1181             if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
   1182             {
   1183                 context->recordError(Error(GL_INVALID_OPERATION));
   1184                 return false;
   1185             }
   1186 
   1187             FramebufferAttachment *attachment = framebuffer->getReadColorbuffer();
   1188             if (!attachment)
   1189             {
   1190                 context->recordError(Error(GL_INVALID_OPERATION));
   1191                 return false;
   1192             }
   1193         }
   1194         break;
   1195 
   1196       default:
   1197         break;
   1198     }
   1199 
   1200     // pname is valid, but there are no parameters to return
   1201     if (numParams == 0)
   1202     {
   1203         return false;
   1204     }
   1205 
   1206     return true;
   1207 }
   1208 
   1209 bool ValidateCopyTexImageParametersBase(gl::Context* context, GLenum target, GLint level, GLenum internalformat, bool isSubImage,
   1210                                         GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height,
   1211                                         GLint border, GLenum *textureFormatOut)
   1212 {
   1213 
   1214     if (!ValidTexture2DDestinationTarget(context, target))
   1215     {
   1216         context->recordError(Error(GL_INVALID_ENUM));
   1217         return false;
   1218     }
   1219 
   1220     if (level < 0 || xoffset < 0 || yoffset < 0 || zoffset < 0 || width < 0 || height < 0)
   1221     {
   1222         context->recordError(Error(GL_INVALID_VALUE));
   1223         return false;
   1224     }
   1225 
   1226     if (std::numeric_limits<GLsizei>::max() - xoffset < width || std::numeric_limits<GLsizei>::max() - yoffset < height)
   1227     {
   1228         context->recordError(Error(GL_INVALID_VALUE));
   1229         return false;
   1230     }
   1231 
   1232     if (border != 0)
   1233     {
   1234         context->recordError(Error(GL_INVALID_VALUE));
   1235         return false;
   1236     }
   1237 
   1238     if (!ValidMipLevel(context, target, level))
   1239     {
   1240         context->recordError(Error(GL_INVALID_VALUE));
   1241         return false;
   1242     }
   1243 
   1244     gl::Framebuffer *framebuffer = context->getState().getReadFramebuffer();
   1245     if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE)
   1246     {
   1247         context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
   1248         return false;
   1249     }
   1250 
   1251     if (context->getState().getReadFramebuffer()->id() != 0 && framebuffer->getSamples() != 0)
   1252     {
   1253         context->recordError(Error(GL_INVALID_OPERATION));
   1254         return false;
   1255     }
   1256 
   1257     const gl::Caps &caps = context->getCaps();
   1258 
   1259     gl::Texture *texture = NULL;
   1260     GLenum textureInternalFormat = GL_NONE;
   1261     GLint textureLevelWidth = 0;
   1262     GLint textureLevelHeight = 0;
   1263     GLint textureLevelDepth = 0;
   1264     GLuint maxDimension = 0;
   1265 
   1266     switch (target)
   1267     {
   1268       case GL_TEXTURE_2D:
   1269         {
   1270             gl::Texture2D *texture2d = context->getTexture2D();
   1271             if (texture2d)
   1272             {
   1273                 textureInternalFormat = texture2d->getInternalFormat(level);
   1274                 textureLevelWidth = texture2d->getWidth(level);
   1275                 textureLevelHeight = texture2d->getHeight(level);
   1276                 textureLevelDepth = 1;
   1277                 texture = texture2d;
   1278                 maxDimension = caps.max2DTextureSize;
   1279             }
   1280         }
   1281         break;
   1282 
   1283       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
   1284       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
   1285       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
   1286       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
   1287       case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
   1288       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
   1289         {
   1290             gl::TextureCubeMap *textureCube = context->getTextureCubeMap();
   1291             if (textureCube)
   1292             {
   1293                 textureInternalFormat = textureCube->getInternalFormat(target, level);
   1294                 textureLevelWidth = textureCube->getWidth(target, level);
   1295                 textureLevelHeight = textureCube->getHeight(target, level);
   1296                 textureLevelDepth = 1;
   1297                 texture = textureCube;
   1298                 maxDimension = caps.maxCubeMapTextureSize;
   1299             }
   1300         }
   1301         break;
   1302 
   1303       case GL_TEXTURE_2D_ARRAY:
   1304         {
   1305             gl::Texture2DArray *texture2dArray = context->getTexture2DArray();
   1306             if (texture2dArray)
   1307             {
   1308                 textureInternalFormat = texture2dArray->getInternalFormat(level);
   1309                 textureLevelWidth = texture2dArray->getWidth(level);
   1310                 textureLevelHeight = texture2dArray->getHeight(level);
   1311                 textureLevelDepth = texture2dArray->getLayers(level);
   1312                 texture = texture2dArray;
   1313                 maxDimension = caps.max2DTextureSize;
   1314             }
   1315         }
   1316         break;
   1317 
   1318       case GL_TEXTURE_3D:
   1319         {
   1320             gl::Texture3D *texture3d = context->getTexture3D();
   1321             if (texture3d)
   1322             {
   1323                 textureInternalFormat = texture3d->getInternalFormat(level);
   1324                 textureLevelWidth = texture3d->getWidth(level);
   1325                 textureLevelHeight = texture3d->getHeight(level);
   1326                 textureLevelDepth = texture3d->getDepth(level);
   1327                 texture = texture3d;
   1328                 maxDimension = caps.max3DTextureSize;
   1329             }
   1330         }
   1331         break;
   1332 
   1333       default:
   1334         context->recordError(Error(GL_INVALID_ENUM));
   1335         return false;
   1336     }
   1337 
   1338     if (!texture)
   1339     {
   1340         context->recordError(Error(GL_INVALID_OPERATION));
   1341         return false;
   1342     }
   1343 
   1344     if (texture->isImmutable() && !isSubImage)
   1345     {
   1346         context->recordError(Error(GL_INVALID_OPERATION));
   1347         return false;
   1348     }
   1349 
   1350     const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat);
   1351 
   1352     if (formatInfo.depthBits > 0)
   1353     {
   1354         context->recordError(Error(GL_INVALID_OPERATION));
   1355         return false;
   1356     }
   1357 
   1358     if (formatInfo.compressed)
   1359     {
   1360         if (((width % formatInfo.compressedBlockWidth) != 0 && width != textureLevelWidth) ||
   1361             ((height % formatInfo.compressedBlockHeight) != 0 && height != textureLevelHeight))
   1362         {
   1363             context->recordError(Error(GL_INVALID_OPERATION));
   1364             return false;
   1365         }
   1366     }
   1367 
   1368     if (isSubImage)
   1369     {
   1370         if (xoffset + width > textureLevelWidth ||
   1371             yoffset + height > textureLevelHeight ||
   1372             zoffset >= textureLevelDepth)
   1373         {
   1374             context->recordError(Error(GL_INVALID_VALUE));
   1375             return false;
   1376         }
   1377     }
   1378     else
   1379     {
   1380         if (IsCubemapTextureTarget(target) && width != height)
   1381         {
   1382             context->recordError(Error(GL_INVALID_VALUE));
   1383             return false;
   1384         }
   1385 
   1386         if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions()))
   1387         {
   1388             context->recordError(Error(GL_INVALID_ENUM));
   1389             return false;
   1390         }
   1391 
   1392         int maxLevelDimension = (maxDimension >> level);
   1393         if (static_cast<int>(width) > maxLevelDimension || static_cast<int>(height) > maxLevelDimension)
   1394         {
   1395             context->recordError(Error(GL_INVALID_VALUE));
   1396             return false;
   1397         }
   1398     }
   1399 
   1400     *textureFormatOut = textureInternalFormat;
   1401     return true;
   1402 }
   1403 
   1404 static bool ValidateDrawBase(Context *context, GLenum mode, GLsizei count, GLsizei maxVertex, GLsizei primcount)
   1405 {
   1406     switch (mode)
   1407     {
   1408       case GL_POINTS:
   1409       case GL_LINES:
   1410       case GL_LINE_LOOP:
   1411       case GL_LINE_STRIP:
   1412       case GL_TRIANGLES:
   1413       case GL_TRIANGLE_STRIP:
   1414       case GL_TRIANGLE_FAN:
   1415         break;
   1416       default:
   1417         context->recordError(Error(GL_INVALID_ENUM));
   1418         return false;
   1419     }
   1420 
   1421     if (count < 0)
   1422     {
   1423         context->recordError(Error(GL_INVALID_VALUE));
   1424         return false;
   1425     }
   1426 
   1427     const State &state = context->getState();
   1428 
   1429     // Check for mapped buffers
   1430     if (state.hasMappedBuffer(GL_ARRAY_BUFFER))
   1431     {
   1432         context->recordError(Error(GL_INVALID_OPERATION));
   1433         return false;
   1434     }
   1435 
   1436     const gl::DepthStencilState &depthStencilState = state.getDepthStencilState();
   1437     if (depthStencilState.stencilWritemask != depthStencilState.stencilBackWritemask ||
   1438         state.getStencilRef() != state.getStencilBackRef() ||
   1439         depthStencilState.stencilMask != depthStencilState.stencilBackMask)
   1440     {
   1441         // Note: these separate values are not supported in WebGL, due to D3D's limitations.
   1442         // See Section 6.10 of the WebGL 1.0 spec
   1443         ERR("This ANGLE implementation does not support separate front/back stencil "
   1444             "writemasks, reference values, or stencil mask values.");
   1445         context->recordError(Error(GL_INVALID_OPERATION));
   1446         return false;
   1447     }
   1448 
   1449     const gl::Framebuffer *fbo = state.getDrawFramebuffer();
   1450     if (!fbo || fbo->completeness() != GL_FRAMEBUFFER_COMPLETE)
   1451     {
   1452         context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION));
   1453         return false;
   1454     }
   1455 
   1456     if (state.getCurrentProgramId() == 0)
   1457     {
   1458         context->recordError(Error(GL_INVALID_OPERATION));
   1459         return false;
   1460     }
   1461 
   1462     gl::ProgramBinary *programBinary = state.getCurrentProgramBinary();
   1463     if (!programBinary->validateSamplers(NULL, context->getCaps()))
   1464     {
   1465         context->recordError(Error(GL_INVALID_OPERATION));
   1466         return false;
   1467     }
   1468 
   1469     // Buffer validations
   1470     const VertexArray *vao = state.getVertexArray();
   1471     for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
   1472     {
   1473         const VertexAttribute &attrib = vao->getVertexAttribute(attributeIndex);
   1474         bool attribActive = (programBinary->getSemanticIndex(attributeIndex) != -1);
   1475         if (attribActive && attrib.enabled)
   1476         {
   1477             gl::Buffer *buffer = attrib.buffer.get();
   1478 
   1479             if (buffer)
   1480             {
   1481                 GLint64 attribStride = static_cast<GLint64>(ComputeVertexAttributeStride(attrib));
   1482                 GLint64 maxVertexElement = 0;
   1483 
   1484                 if (attrib.divisor > 0)
   1485                 {
   1486                     maxVertexElement = static_cast<GLint64>(primcount) / static_cast<GLint64>(attrib.divisor);
   1487                 }
   1488                 else
   1489                 {
   1490                     maxVertexElement = static_cast<GLint64>(maxVertex);
   1491                 }
   1492 
   1493                 GLint64 attribDataSize = maxVertexElement * attribStride;
   1494 
   1495                 // [OpenGL ES 3.0.2] section 2.9.4 page 40:
   1496                 // We can return INVALID_OPERATION if our vertex attribute does not have
   1497                 // enough backing data.
   1498                 if (attribDataSize > buffer->getSize())
   1499                 {
   1500                     context->recordError(Error(GL_INVALID_OPERATION));
   1501                     return false;
   1502                 }
   1503             }
   1504             else if (attrib.pointer == NULL)
   1505             {
   1506                 // This is an application error that would normally result in a crash,
   1507                 // but we catch it and return an error
   1508                 context->recordError(Error(GL_INVALID_OPERATION, "An enabled vertex array has no buffer and no pointer."));
   1509                 return false;
   1510             }
   1511         }
   1512     }
   1513 
   1514     // No-op if zero count
   1515     return (count > 0);
   1516 }
   1517 
   1518 bool ValidateDrawArrays(Context *context, GLenum mode, GLint first, GLsizei count, GLsizei primcount)
   1519 {
   1520     if (first < 0)
   1521     {
   1522         context->recordError(Error(GL_INVALID_VALUE));
   1523         return false;
   1524     }
   1525 
   1526     const State &state = context->getState();
   1527     gl::TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
   1528     if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused() &&
   1529         curTransformFeedback->getDrawMode() != mode)
   1530     {
   1531         // It is an invalid operation to call DrawArrays or DrawArraysInstanced with a draw mode
   1532         // that does not match the current transform feedback object's draw mode (if transform feedback
   1533         // is active), (3.0.2, section 2.14, pg 86)
   1534         context->recordError(Error(GL_INVALID_OPERATION));
   1535         return false;
   1536     }
   1537 
   1538     if (!ValidateDrawBase(context, mode, count, count, primcount))
   1539     {
   1540         return false;
   1541     }
   1542 
   1543     return true;
   1544 }
   1545 
   1546 bool ValidateDrawArraysInstanced(Context *context, GLenum mode, GLint first, GLsizei count, GLsizei primcount)
   1547 {
   1548     if (primcount < 0)
   1549     {
   1550         context->recordError(Error(GL_INVALID_VALUE));
   1551         return false;
   1552     }
   1553 
   1554     if (!ValidateDrawArrays(context, mode, first, count, primcount))
   1555     {
   1556         return false;
   1557     }
   1558 
   1559     // No-op if zero primitive count
   1560     return (primcount > 0);
   1561 }
   1562 
   1563 static bool ValidateDrawInstancedANGLE(Context *context)
   1564 {
   1565     // Verify there is at least one active attribute with a divisor of zero
   1566     const gl::State& state = context->getState();
   1567 
   1568     gl::ProgramBinary *programBinary = state.getCurrentProgramBinary();
   1569 
   1570     const VertexArray *vao = state.getVertexArray();
   1571     for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
   1572     {
   1573         const VertexAttribute &attrib = vao->getVertexAttribute(attributeIndex);
   1574         bool active = (programBinary->getSemanticIndex(attributeIndex) != -1);
   1575         if (active && attrib.divisor == 0)
   1576         {
   1577             return true;
   1578         }
   1579     }
   1580 
   1581     context->recordError(Error(GL_INVALID_OPERATION, "ANGLE_instanced_arrays requires that at least one active attribute"
   1582                                                      "has a divisor of zero."));
   1583     return false;
   1584 }
   1585 
   1586 bool ValidateDrawArraysInstancedANGLE(Context *context, GLenum mode, GLint first, GLsizei count, GLsizei primcount)
   1587 {
   1588     if (!ValidateDrawInstancedANGLE(context))
   1589     {
   1590         return false;
   1591     }
   1592 
   1593     return ValidateDrawArraysInstanced(context, mode, first, count, primcount);
   1594 }
   1595 
   1596 bool ValidateDrawElements(Context *context, GLenum mode, GLsizei count, GLenum type,
   1597                           const GLvoid* indices, GLsizei primcount, rx::RangeUI *indexRangeOut)
   1598 {
   1599     switch (type)
   1600     {
   1601       case GL_UNSIGNED_BYTE:
   1602       case GL_UNSIGNED_SHORT:
   1603         break;
   1604       case GL_UNSIGNED_INT:
   1605         if (!context->getExtensions().elementIndexUint)
   1606         {
   1607             context->recordError(Error(GL_INVALID_ENUM));
   1608             return false;
   1609         }
   1610         break;
   1611       default:
   1612         context->recordError(Error(GL_INVALID_ENUM));
   1613         return false;
   1614     }
   1615 
   1616     const State &state = context->getState();
   1617 
   1618     gl::TransformFeedback *curTransformFeedback = state.getCurrentTransformFeedback();
   1619     if (curTransformFeedback && curTransformFeedback->isStarted() && !curTransformFeedback->isPaused())
   1620     {
   1621         // It is an invalid operation to call DrawElements, DrawRangeElements or DrawElementsInstanced
   1622         // while transform feedback is active, (3.0.2, section 2.14, pg 86)
   1623         context->recordError(Error(GL_INVALID_OPERATION));
   1624         return false;
   1625     }
   1626 
   1627     // Check for mapped buffers
   1628     if (state.hasMappedBuffer(GL_ELEMENT_ARRAY_BUFFER))
   1629     {
   1630         context->recordError(Error(GL_INVALID_OPERATION));
   1631         return false;
   1632     }
   1633 
   1634     const gl::VertexArray *vao = state.getVertexArray();
   1635     const gl::Buffer *elementArrayBuffer = vao->getElementArrayBuffer();
   1636     if (!indices && !elementArrayBuffer)
   1637     {
   1638         context->recordError(Error(GL_INVALID_OPERATION));
   1639         return false;
   1640     }
   1641 
   1642     if (elementArrayBuffer)
   1643     {
   1644         const gl::Type &typeInfo = gl::GetTypeInfo(type);
   1645 
   1646         GLint64 offset = reinterpret_cast<GLint64>(indices);
   1647         GLint64 byteCount = static_cast<GLint64>(typeInfo.bytes) * static_cast<GLint64>(count)+offset;
   1648 
   1649         // check for integer overflows
   1650         if (static_cast<GLuint>(count) > (std::numeric_limits<GLuint>::max() / typeInfo.bytes) ||
   1651             byteCount > static_cast<GLint64>(std::numeric_limits<GLuint>::max()))
   1652         {
   1653             context->recordError(Error(GL_OUT_OF_MEMORY));
   1654             return false;
   1655         }
   1656 
   1657         // Check for reading past the end of the bound buffer object
   1658         if (byteCount > elementArrayBuffer->getSize())
   1659         {
   1660             context->recordError(Error(GL_INVALID_OPERATION));
   1661             return false;
   1662         }
   1663     }
   1664     else if (!indices)
   1665     {
   1666         // Catch this programming error here
   1667         context->recordError(Error(GL_INVALID_OPERATION));
   1668         return false;
   1669     }
   1670 
   1671     // Use max index to validate if our vertex buffers are large enough for the pull.
   1672     // TODO: offer fast path, with disabled index validation.
   1673     // TODO: also disable index checking on back-ends that are robust to out-of-range accesses.
   1674     if (elementArrayBuffer)
   1675     {
   1676         unsigned int offset = reinterpret_cast<unsigned int>(indices);
   1677         if (!elementArrayBuffer->getIndexRangeCache()->findRange(type, offset, count, indexRangeOut, NULL))
   1678         {
   1679             const void *dataPointer = elementArrayBuffer->getImplementation()->getData();
   1680             const uint8_t *offsetPointer = static_cast<const uint8_t *>(dataPointer) + offset;
   1681             *indexRangeOut = rx::IndexRangeCache::ComputeRange(type, offsetPointer, count);
   1682         }
   1683     }
   1684     else
   1685     {
   1686         *indexRangeOut = rx::IndexRangeCache::ComputeRange(type, indices, count);
   1687     }
   1688 
   1689     if (!ValidateDrawBase(context, mode, count, static_cast<GLsizei>(indexRangeOut->end), primcount))
   1690     {
   1691         return false;
   1692     }
   1693 
   1694     return true;
   1695 }
   1696 
   1697 bool ValidateDrawElementsInstanced(Context *context,
   1698                                    GLenum mode, GLsizei count, GLenum type,
   1699                                    const GLvoid *indices, GLsizei primcount,
   1700                                    rx::RangeUI *indexRangeOut)
   1701 {
   1702     if (primcount < 0)
   1703     {
   1704         context->recordError(Error(GL_INVALID_VALUE));
   1705         return false;
   1706     }
   1707 
   1708     if (!ValidateDrawElements(context, mode, count, type, indices, primcount, indexRangeOut))
   1709     {
   1710         return false;
   1711     }
   1712 
   1713     // No-op zero primitive count
   1714     return (primcount > 0);
   1715 }
   1716 
   1717 bool ValidateDrawElementsInstancedANGLE(Context *context, GLenum mode, GLsizei count, GLenum type,
   1718                                         const GLvoid *indices, GLsizei primcount, rx::RangeUI *indexRangeOut)
   1719 {
   1720     if (!ValidateDrawInstancedANGLE(context))
   1721     {
   1722         return false;
   1723     }
   1724 
   1725     return ValidateDrawElementsInstanced(context, mode, count, type, indices, primcount, indexRangeOut);
   1726 }
   1727 
   1728 bool ValidateFramebufferTextureBase(Context *context, GLenum target, GLenum attachment,
   1729                                     GLuint texture, GLint level)
   1730 {
   1731     if (!ValidFramebufferTarget(target))
   1732     {
   1733         context->recordError(Error(GL_INVALID_ENUM));
   1734         return false;
   1735     }
   1736 
   1737     if (!ValidateAttachmentTarget(context, attachment))
   1738     {
   1739         return false;
   1740     }
   1741 
   1742     if (texture != 0)
   1743     {
   1744         gl::Texture *tex = context->getTexture(texture);
   1745 
   1746         if (tex == NULL)
   1747         {
   1748             context->recordError(Error(GL_INVALID_OPERATION));
   1749             return false;
   1750         }
   1751 
   1752         if (level < 0)
   1753         {
   1754             context->recordError(Error(GL_INVALID_VALUE));
   1755             return false;
   1756         }
   1757     }
   1758 
   1759     const gl::Framebuffer *framebuffer = context->getState().getTargetFramebuffer(target);
   1760     GLuint framebufferHandle = context->getState().getTargetFramebuffer(target)->id();
   1761 
   1762     if (framebufferHandle == 0 || !framebuffer)
   1763     {
   1764         context->recordError(Error(GL_INVALID_OPERATION));
   1765         return false;
   1766     }
   1767 
   1768     return true;
   1769 }
   1770 
   1771 bool ValidateFramebufferTexture2D(Context *context, GLenum target, GLenum attachment,
   1772                                   GLenum textarget, GLuint texture, GLint level)
   1773 {
   1774     // Attachments are required to be bound to level 0 in ES2
   1775     if (context->getClientVersion() < 3 && level != 0)
   1776     {
   1777         context->recordError(Error(GL_INVALID_VALUE));
   1778         return false;
   1779     }
   1780 
   1781     if (!ValidateFramebufferTextureBase(context, target, attachment, texture, level))
   1782     {
   1783         return false;
   1784     }
   1785 
   1786     if (texture != 0)
   1787     {
   1788         gl::Texture *tex = context->getTexture(texture);
   1789         ASSERT(tex);
   1790 
   1791         const gl::Caps &caps = context->getCaps();
   1792 
   1793         switch (textarget)
   1794         {
   1795           case GL_TEXTURE_2D:
   1796             {
   1797                 if (level > gl::log2(caps.max2DTextureSize))
   1798                 {
   1799                     context->recordError(Error(GL_INVALID_VALUE));
   1800                     return false;
   1801                 }
   1802                 if (tex->getTarget() != GL_TEXTURE_2D)
   1803                 {
   1804                     context->recordError(Error(GL_INVALID_OPERATION));
   1805                     return false;
   1806                 }
   1807                 gl::Texture2D *tex2d = static_cast<gl::Texture2D *>(tex);
   1808                 if (tex2d->isCompressed(level))
   1809                 {
   1810                     context->recordError(Error(GL_INVALID_OPERATION));
   1811                     return false;
   1812                 }
   1813             }
   1814             break;
   1815 
   1816           case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
   1817           case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
   1818           case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
   1819           case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
   1820           case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
   1821           case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
   1822             {
   1823                 if (level > gl::log2(caps.maxCubeMapTextureSize))
   1824                 {
   1825                     context->recordError(Error(GL_INVALID_VALUE));
   1826                     return false;
   1827                 }
   1828                 if (tex->getTarget() != GL_TEXTURE_CUBE_MAP)
   1829                 {
   1830                     context->recordError(Error(GL_INVALID_OPERATION));
   1831                     return false;
   1832                 }
   1833                 gl::TextureCubeMap *texcube = static_cast<gl::TextureCubeMap *>(tex);
   1834                 if (texcube->isCompressed(textarget, level))
   1835                 {
   1836                     context->recordError(Error(GL_INVALID_OPERATION));
   1837                     return false;
   1838                 }
   1839             }
   1840             break;
   1841 
   1842           default:
   1843             context->recordError(Error(GL_INVALID_ENUM));
   1844             return false;
   1845         }
   1846     }
   1847 
   1848     return true;
   1849 }
   1850 
   1851 bool ValidateGetUniformBase(Context *context, GLuint program, GLint location)
   1852 {
   1853     if (program == 0)
   1854     {
   1855         context->recordError(Error(GL_INVALID_VALUE));
   1856         return false;
   1857     }
   1858 
   1859     gl::Program *programObject = context->getProgram(program);
   1860 
   1861     if (!programObject || !programObject->isLinked())
   1862     {
   1863         context->recordError(Error(GL_INVALID_OPERATION));
   1864         return false;
   1865     }
   1866 
   1867     gl::ProgramBinary *programBinary = programObject->getProgramBinary();
   1868     if (!programBinary)
   1869     {
   1870         context->recordError(Error(GL_INVALID_OPERATION));
   1871         return false;
   1872     }
   1873 
   1874     if (!programBinary->isValidUniformLocation(location))
   1875     {
   1876         context->recordError(Error(GL_INVALID_OPERATION));
   1877         return false;
   1878     }
   1879 
   1880     return true;
   1881 }
   1882 
   1883 bool ValidateGetUniformfv(Context *context, GLuint program, GLint location, GLfloat* params)
   1884 {
   1885     return ValidateGetUniformBase(context, program, location);
   1886 }
   1887 
   1888 bool ValidateGetUniformiv(Context *context, GLuint program, GLint location, GLint* params)
   1889 {
   1890     return ValidateGetUniformBase(context, program, location);
   1891 }
   1892 
   1893 static bool ValidateSizedGetUniform(Context *context, GLuint program, GLint location, GLsizei bufSize)
   1894 {
   1895     if (!ValidateGetUniformBase(context, program, location))
   1896     {
   1897         return false;
   1898     }
   1899 
   1900     gl::Program *programObject = context->getProgram(program);
   1901     ASSERT(programObject);
   1902     gl::ProgramBinary *programBinary = programObject->getProgramBinary();
   1903 
   1904     // sized queries -- ensure the provided buffer is large enough
   1905     LinkedUniform *uniform = programBinary->getUniformByLocation(location);
   1906     size_t requiredBytes = VariableExternalSize(uniform->type);
   1907     if (static_cast<size_t>(bufSize) < requiredBytes)
   1908     {
   1909         context->recordError(Error(GL_INVALID_OPERATION));
   1910         return false;
   1911     }
   1912 
   1913     return true;
   1914 }
   1915 
   1916 bool ValidateGetnUniformfvEXT(Context *context, GLuint program, GLint location, GLsizei bufSize, GLfloat* params)
   1917 {
   1918     return ValidateSizedGetUniform(context, program, location, bufSize);
   1919 }
   1920 
   1921 bool ValidateGetnUniformivEXT(Context *context, GLuint program, GLint location, GLsizei bufSize, GLint* params)
   1922 {
   1923     return ValidateSizedGetUniform(context, program, location, bufSize);
   1924 }
   1925 
   1926 }
   1927