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 // validationES3.cpp: Validation functions for OpenGL ES 3.0 entry point parameters 8 9 #include "libGLESv2/validationES3.h" 10 #include "libGLESv2/validationES.h" 11 #include "libGLESv2/Context.h" 12 #include "libGLESv2/Texture.h" 13 #include "libGLESv2/Framebuffer.h" 14 #include "libGLESv2/Renderbuffer.h" 15 #include "libGLESv2/formatutils.h" 16 #include "libGLESv2/main.h" 17 #include "libGLESv2/FramebufferAttachment.h" 18 19 #include "common/mathutil.h" 20 21 namespace gl 22 { 23 24 struct ES3FormatCombination 25 { 26 GLenum internalFormat; 27 GLenum format; 28 GLenum type; 29 }; 30 31 bool operator<(const ES3FormatCombination& a, const ES3FormatCombination& b) 32 { 33 return memcmp(&a, &b, sizeof(ES3FormatCombination)) < 0; 34 } 35 36 typedef std::set<ES3FormatCombination> ES3FormatCombinationSet; 37 38 static inline void InsertES3FormatCombo(ES3FormatCombinationSet *set, GLenum internalFormat, GLenum format, GLenum type) 39 { 40 ES3FormatCombination info; 41 info.internalFormat = internalFormat; 42 info.format = format; 43 info.type = type; 44 set->insert(info); 45 } 46 47 ES3FormatCombinationSet BuildES3FormatSet() 48 { 49 ES3FormatCombinationSet set; 50 51 // Format combinations from ES 3.0.1 spec, table 3.2 52 53 // | Internal format | Format | Type | 54 // | | | | 55 InsertES3FormatCombo(&set, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE ); 56 InsertES3FormatCombo(&set, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_BYTE ); 57 InsertES3FormatCombo(&set, GL_RGBA4, GL_RGBA, GL_UNSIGNED_BYTE ); 58 InsertES3FormatCombo(&set, GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE ); 59 InsertES3FormatCombo(&set, GL_RGBA8_SNORM, GL_RGBA, GL_BYTE ); 60 InsertES3FormatCombo(&set, GL_RGBA4, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 ); 61 InsertES3FormatCombo(&set, GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV ); 62 InsertES3FormatCombo(&set, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV ); 63 InsertES3FormatCombo(&set, GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 ); 64 InsertES3FormatCombo(&set, GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT ); 65 InsertES3FormatCombo(&set, GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT_OES ); 66 InsertES3FormatCombo(&set, GL_RGBA32F, GL_RGBA, GL_FLOAT ); 67 InsertES3FormatCombo(&set, GL_RGBA16F, GL_RGBA, GL_FLOAT ); 68 InsertES3FormatCombo(&set, GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE ); 69 InsertES3FormatCombo(&set, GL_RGBA8I, GL_RGBA_INTEGER, GL_BYTE ); 70 InsertES3FormatCombo(&set, GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT ); 71 InsertES3FormatCombo(&set, GL_RGBA16I, GL_RGBA_INTEGER, GL_SHORT ); 72 InsertES3FormatCombo(&set, GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT ); 73 InsertES3FormatCombo(&set, GL_RGBA32I, GL_RGBA_INTEGER, GL_INT ); 74 InsertES3FormatCombo(&set, GL_RGB10_A2UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT_2_10_10_10_REV ); 75 InsertES3FormatCombo(&set, GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE ); 76 InsertES3FormatCombo(&set, GL_RGB565, GL_RGB, GL_UNSIGNED_BYTE ); 77 InsertES3FormatCombo(&set, GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE ); 78 InsertES3FormatCombo(&set, GL_RGB8_SNORM, GL_RGB, GL_BYTE ); 79 InsertES3FormatCombo(&set, GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5 ); 80 InsertES3FormatCombo(&set, GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV ); 81 InsertES3FormatCombo(&set, GL_RGB9_E5, GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV ); 82 InsertES3FormatCombo(&set, GL_RGB16F, GL_RGB, GL_HALF_FLOAT ); 83 InsertES3FormatCombo(&set, GL_RGB16F, GL_RGB, GL_HALF_FLOAT_OES ); 84 InsertES3FormatCombo(&set, GL_R11F_G11F_B10F, GL_RGB, GL_HALF_FLOAT ); 85 InsertES3FormatCombo(&set, GL_R11F_G11F_B10F, GL_RGB, GL_HALF_FLOAT_OES ); 86 InsertES3FormatCombo(&set, GL_RGB9_E5, GL_RGB, GL_HALF_FLOAT ); 87 InsertES3FormatCombo(&set, GL_RGB9_E5, GL_RGB, GL_HALF_FLOAT_OES ); 88 InsertES3FormatCombo(&set, GL_RGB32F, GL_RGB, GL_FLOAT ); 89 InsertES3FormatCombo(&set, GL_RGB16F, GL_RGB, GL_FLOAT ); 90 InsertES3FormatCombo(&set, GL_R11F_G11F_B10F, GL_RGB, GL_FLOAT ); 91 InsertES3FormatCombo(&set, GL_RGB9_E5, GL_RGB, GL_FLOAT ); 92 InsertES3FormatCombo(&set, GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE ); 93 InsertES3FormatCombo(&set, GL_RGB8I, GL_RGB_INTEGER, GL_BYTE ); 94 InsertES3FormatCombo(&set, GL_RGB16UI, GL_RGB_INTEGER, GL_UNSIGNED_SHORT ); 95 InsertES3FormatCombo(&set, GL_RGB16I, GL_RGB_INTEGER, GL_SHORT ); 96 InsertES3FormatCombo(&set, GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT ); 97 InsertES3FormatCombo(&set, GL_RGB32I, GL_RGB_INTEGER, GL_INT ); 98 InsertES3FormatCombo(&set, GL_RG8, GL_RG, GL_UNSIGNED_BYTE ); 99 InsertES3FormatCombo(&set, GL_RG8_SNORM, GL_RG, GL_BYTE ); 100 InsertES3FormatCombo(&set, GL_RG16F, GL_RG, GL_HALF_FLOAT ); 101 InsertES3FormatCombo(&set, GL_RG16F, GL_RG, GL_HALF_FLOAT_OES ); 102 InsertES3FormatCombo(&set, GL_RG32F, GL_RG, GL_FLOAT ); 103 InsertES3FormatCombo(&set, GL_RG16F, GL_RG, GL_FLOAT ); 104 InsertES3FormatCombo(&set, GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE ); 105 InsertES3FormatCombo(&set, GL_RG8I, GL_RG_INTEGER, GL_BYTE ); 106 InsertES3FormatCombo(&set, GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT ); 107 InsertES3FormatCombo(&set, GL_RG16I, GL_RG_INTEGER, GL_SHORT ); 108 InsertES3FormatCombo(&set, GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT ); 109 InsertES3FormatCombo(&set, GL_RG32I, GL_RG_INTEGER, GL_INT ); 110 InsertES3FormatCombo(&set, GL_R8, GL_RED, GL_UNSIGNED_BYTE ); 111 InsertES3FormatCombo(&set, GL_R8_SNORM, GL_RED, GL_BYTE ); 112 InsertES3FormatCombo(&set, GL_R16F, GL_RED, GL_HALF_FLOAT ); 113 InsertES3FormatCombo(&set, GL_R16F, GL_RED, GL_HALF_FLOAT_OES ); 114 InsertES3FormatCombo(&set, GL_R32F, GL_RED, GL_FLOAT ); 115 InsertES3FormatCombo(&set, GL_R16F, GL_RED, GL_FLOAT ); 116 InsertES3FormatCombo(&set, GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE ); 117 InsertES3FormatCombo(&set, GL_R8I, GL_RED_INTEGER, GL_BYTE ); 118 InsertES3FormatCombo(&set, GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT ); 119 InsertES3FormatCombo(&set, GL_R16I, GL_RED_INTEGER, GL_SHORT ); 120 InsertES3FormatCombo(&set, GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT ); 121 InsertES3FormatCombo(&set, GL_R32I, GL_RED_INTEGER, GL_INT ); 122 123 // Unsized formats 124 InsertES3FormatCombo(&set, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE ); 125 InsertES3FormatCombo(&set, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4 ); 126 InsertES3FormatCombo(&set, GL_RGBA, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1 ); 127 InsertES3FormatCombo(&set, GL_RGB, GL_RGB, GL_UNSIGNED_BYTE ); 128 InsertES3FormatCombo(&set, GL_RGB, GL_RGB, GL_UNSIGNED_SHORT_5_6_5 ); 129 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE ); 130 InsertES3FormatCombo(&set, GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE ); 131 InsertES3FormatCombo(&set, GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE ); 132 InsertES3FormatCombo(&set, GL_SRGB_ALPHA_EXT, GL_SRGB_ALPHA_EXT, GL_UNSIGNED_BYTE ); 133 InsertES3FormatCombo(&set, GL_SRGB_EXT, GL_SRGB_EXT, GL_UNSIGNED_BYTE ); 134 135 // Depth stencil formats 136 InsertES3FormatCombo(&set, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT ); 137 InsertES3FormatCombo(&set, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT ); 138 InsertES3FormatCombo(&set, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT ); 139 InsertES3FormatCombo(&set, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT ); 140 InsertES3FormatCombo(&set, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8 ); 141 InsertES3FormatCombo(&set, GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV); 142 143 // From GL_EXT_sRGB 144 InsertES3FormatCombo(&set, GL_SRGB8_ALPHA8_EXT, GL_SRGB_ALPHA_EXT, GL_UNSIGNED_BYTE ); 145 InsertES3FormatCombo(&set, GL_SRGB8, GL_SRGB_EXT, GL_UNSIGNED_BYTE ); 146 147 // From GL_OES_texture_float 148 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_FLOAT ); 149 InsertES3FormatCombo(&set, GL_LUMINANCE, GL_LUMINANCE, GL_FLOAT ); 150 InsertES3FormatCombo(&set, GL_ALPHA, GL_ALPHA, GL_FLOAT ); 151 152 // From GL_OES_texture_half_float 153 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT ); 154 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES ); 155 InsertES3FormatCombo(&set, GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT ); 156 InsertES3FormatCombo(&set, GL_LUMINANCE, GL_LUMINANCE, GL_HALF_FLOAT_OES ); 157 InsertES3FormatCombo(&set, GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT ); 158 InsertES3FormatCombo(&set, GL_ALPHA, GL_ALPHA, GL_HALF_FLOAT_OES ); 159 160 // From GL_EXT_texture_format_BGRA8888 161 InsertES3FormatCombo(&set, GL_BGRA_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE ); 162 163 // From GL_EXT_texture_storage 164 // | Internal format | Format | Type | 165 // | | | | 166 InsertES3FormatCombo(&set, GL_ALPHA8_EXT, GL_ALPHA, GL_UNSIGNED_BYTE ); 167 InsertES3FormatCombo(&set, GL_LUMINANCE8_EXT, GL_LUMINANCE, GL_UNSIGNED_BYTE ); 168 InsertES3FormatCombo(&set, GL_LUMINANCE8_ALPHA8_EXT, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE ); 169 InsertES3FormatCombo(&set, GL_ALPHA32F_EXT, GL_ALPHA, GL_FLOAT ); 170 InsertES3FormatCombo(&set, GL_LUMINANCE32F_EXT, GL_LUMINANCE, GL_FLOAT ); 171 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA32F_EXT, GL_LUMINANCE_ALPHA, GL_FLOAT ); 172 InsertES3FormatCombo(&set, GL_ALPHA16F_EXT, GL_ALPHA, GL_HALF_FLOAT ); 173 InsertES3FormatCombo(&set, GL_ALPHA16F_EXT, GL_ALPHA, GL_HALF_FLOAT_OES ); 174 InsertES3FormatCombo(&set, GL_LUMINANCE16F_EXT, GL_LUMINANCE, GL_HALF_FLOAT ); 175 InsertES3FormatCombo(&set, GL_LUMINANCE16F_EXT, GL_LUMINANCE, GL_HALF_FLOAT_OES ); 176 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA16F_EXT, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT ); 177 InsertES3FormatCombo(&set, GL_LUMINANCE_ALPHA16F_EXT, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_OES ); 178 179 // From GL_EXT_texture_storage and GL_EXT_texture_format_BGRA8888 180 InsertES3FormatCombo(&set, GL_BGRA8_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE ); 181 InsertES3FormatCombo(&set, GL_BGRA4_ANGLEX, GL_BGRA_EXT, GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT); 182 InsertES3FormatCombo(&set, GL_BGRA4_ANGLEX, GL_BGRA_EXT, GL_UNSIGNED_BYTE ); 183 InsertES3FormatCombo(&set, GL_BGR5_A1_ANGLEX, GL_BGRA_EXT, GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT); 184 InsertES3FormatCombo(&set, GL_BGR5_A1_ANGLEX, GL_BGRA_EXT, GL_UNSIGNED_BYTE ); 185 186 // From GL_ANGLE_depth_texture 187 InsertES3FormatCombo(&set, GL_DEPTH_COMPONENT32_OES, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT_24_8_OES ); 188 189 // Compressed formats 190 // From ES 3.0.1 spec, table 3.16 191 // | Internal format | Format | Type | 192 // | | | | 193 InsertES3FormatCombo(&set, GL_COMPRESSED_R11_EAC, GL_COMPRESSED_R11_EAC, GL_UNSIGNED_BYTE); 194 InsertES3FormatCombo(&set, GL_COMPRESSED_R11_EAC, GL_COMPRESSED_R11_EAC, GL_UNSIGNED_BYTE); 195 InsertES3FormatCombo(&set, GL_COMPRESSED_SIGNED_R11_EAC, GL_COMPRESSED_SIGNED_R11_EAC, GL_UNSIGNED_BYTE); 196 InsertES3FormatCombo(&set, GL_COMPRESSED_RG11_EAC, GL_COMPRESSED_RG11_EAC, GL_UNSIGNED_BYTE); 197 InsertES3FormatCombo(&set, GL_COMPRESSED_SIGNED_RG11_EAC, GL_COMPRESSED_SIGNED_RG11_EAC, GL_UNSIGNED_BYTE); 198 InsertES3FormatCombo(&set, GL_COMPRESSED_RGB8_ETC2, GL_COMPRESSED_RGB8_ETC2, GL_UNSIGNED_BYTE); 199 InsertES3FormatCombo(&set, GL_COMPRESSED_SRGB8_ETC2, GL_COMPRESSED_SRGB8_ETC2, GL_UNSIGNED_BYTE); 200 InsertES3FormatCombo(&set, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_UNSIGNED_BYTE); 201 InsertES3FormatCombo(&set, GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, GL_UNSIGNED_BYTE); 202 InsertES3FormatCombo(&set, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_COMPRESSED_RGBA8_ETC2_EAC, GL_UNSIGNED_BYTE); 203 InsertES3FormatCombo(&set, GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, GL_UNSIGNED_BYTE); 204 205 206 // From GL_EXT_texture_compression_dxt1 207 InsertES3FormatCombo(&set, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_UNSIGNED_BYTE); 208 InsertES3FormatCombo(&set, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_UNSIGNED_BYTE); 209 210 // From GL_ANGLE_texture_compression_dxt3 211 InsertES3FormatCombo(&set, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, GL_UNSIGNED_BYTE); 212 213 // From GL_ANGLE_texture_compression_dxt5 214 InsertES3FormatCombo(&set, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, GL_UNSIGNED_BYTE); 215 216 return set; 217 } 218 219 static bool ValidateTexImageFormatCombination(gl::Context *context, GLenum internalFormat, GLenum format, GLenum type) 220 { 221 // Note: dEQP 2013.4 expects an INVALID_VALUE error for TexImage3D with an invalid 222 // internal format. (dEQP-GLES3.functional.negative_api.texture.teximage3d) 223 const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalFormat); 224 if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions())) 225 { 226 context->recordError(Error(GL_INVALID_ENUM)); 227 return false; 228 } 229 230 // The type and format are valid if any supported internal format has that type and format 231 bool formatSupported = false; 232 bool typeSupported = false; 233 234 static const ES3FormatCombinationSet es3FormatSet = BuildES3FormatSet(); 235 for (ES3FormatCombinationSet::const_iterator i = es3FormatSet.begin(); i != es3FormatSet.end(); i++) 236 { 237 if (i->format == format || i->type == type) 238 { 239 const gl::InternalFormat &info = gl::GetInternalFormatInfo(i->internalFormat); 240 bool supported = info.textureSupport(context->getClientVersion(), context->getExtensions()); 241 if (supported && i->type == type) 242 { 243 typeSupported = true; 244 } 245 if (supported && i->format == format) 246 { 247 formatSupported = true; 248 } 249 250 // Early-out if both type and format are supported now 251 if (typeSupported && formatSupported) 252 { 253 break; 254 } 255 } 256 } 257 258 if (!typeSupported || !formatSupported) 259 { 260 context->recordError(Error(GL_INVALID_ENUM)); 261 return false; 262 } 263 264 // Check if this is a valid format combination to load texture data 265 ES3FormatCombination searchFormat; 266 searchFormat.internalFormat = internalFormat; 267 searchFormat.format = format; 268 searchFormat.type = type; 269 270 if (es3FormatSet.find(searchFormat) == es3FormatSet.end()) 271 { 272 context->recordError(Error(GL_INVALID_OPERATION)); 273 return false; 274 } 275 276 return true; 277 } 278 279 bool ValidateES3TexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat, bool isCompressed, bool isSubImage, 280 GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, 281 GLint border, GLenum format, GLenum type, const GLvoid *pixels) 282 { 283 if (!ValidTexture2DDestinationTarget(context, target)) 284 { 285 context->recordError(Error(GL_INVALID_ENUM)); 286 return false; 287 } 288 289 // Validate image size 290 if (!ValidImageSize(context, target, level, width, height, depth)) 291 { 292 context->recordError(Error(GL_INVALID_VALUE)); 293 return false; 294 } 295 296 // Verify zero border 297 if (border != 0) 298 { 299 context->recordError(Error(GL_INVALID_VALUE)); 300 return false; 301 } 302 303 if (xoffset < 0 || yoffset < 0 || zoffset < 0 || 304 std::numeric_limits<GLsizei>::max() - xoffset < width || 305 std::numeric_limits<GLsizei>::max() - yoffset < height || 306 std::numeric_limits<GLsizei>::max() - zoffset < depth) 307 { 308 context->recordError(Error(GL_INVALID_VALUE)); 309 return false; 310 } 311 312 const gl::Caps &caps = context->getCaps(); 313 314 gl::Texture *texture = NULL; 315 bool textureCompressed = false; 316 GLenum textureInternalFormat = GL_NONE; 317 GLint textureLevelWidth = 0; 318 GLint textureLevelHeight = 0; 319 GLint textureLevelDepth = 0; 320 switch (target) 321 { 322 case GL_TEXTURE_2D: 323 { 324 if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) || 325 static_cast<GLuint>(height) > (caps.max2DTextureSize >> level)) 326 { 327 context->recordError(Error(GL_INVALID_VALUE)); 328 return false; 329 } 330 331 gl::Texture2D *texture2d = context->getTexture2D(); 332 if (texture2d) 333 { 334 textureCompressed = texture2d->isCompressed(level); 335 textureInternalFormat = texture2d->getInternalFormat(level); 336 textureLevelWidth = texture2d->getWidth(level); 337 textureLevelHeight = texture2d->getHeight(level); 338 textureLevelDepth = 1; 339 texture = texture2d; 340 } 341 } 342 break; 343 344 case GL_TEXTURE_CUBE_MAP_POSITIVE_X: 345 case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: 346 case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: 347 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: 348 case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: 349 case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: 350 { 351 if (!isSubImage && width != height) 352 { 353 context->recordError(Error(GL_INVALID_VALUE)); 354 return false; 355 } 356 357 if (static_cast<GLuint>(width) > (caps.maxCubeMapTextureSize >> level)) 358 { 359 context->recordError(Error(GL_INVALID_VALUE)); 360 return false; 361 } 362 363 gl::TextureCubeMap *textureCube = context->getTextureCubeMap(); 364 if (textureCube) 365 { 366 textureCompressed = textureCube->isCompressed(target, level); 367 textureInternalFormat = textureCube->getInternalFormat(target, level); 368 textureLevelWidth = textureCube->getWidth(target, level); 369 textureLevelHeight = textureCube->getHeight(target, level); 370 textureLevelDepth = 1; 371 texture = textureCube; 372 } 373 } 374 break; 375 376 case GL_TEXTURE_3D: 377 { 378 if (static_cast<GLuint>(width) > (caps.max3DTextureSize >> level) || 379 static_cast<GLuint>(height) > (caps.max3DTextureSize >> level) || 380 static_cast<GLuint>(depth) > (caps.max3DTextureSize >> level)) 381 { 382 context->recordError(Error(GL_INVALID_VALUE)); 383 return false; 384 } 385 386 gl::Texture3D *texture3d = context->getTexture3D(); 387 if (texture3d) 388 { 389 textureCompressed = texture3d->isCompressed(level); 390 textureInternalFormat = texture3d->getInternalFormat(level); 391 textureLevelWidth = texture3d->getWidth(level); 392 textureLevelHeight = texture3d->getHeight(level); 393 textureLevelDepth = texture3d->getDepth(level); 394 texture = texture3d; 395 } 396 } 397 break; 398 399 case GL_TEXTURE_2D_ARRAY: 400 { 401 if (static_cast<GLuint>(width) > (caps.max2DTextureSize >> level) || 402 static_cast<GLuint>(height) > (caps.max2DTextureSize >> level) || 403 static_cast<GLuint>(depth) > (caps.maxArrayTextureLayers >> level)) 404 { 405 context->recordError(Error(GL_INVALID_VALUE)); 406 return false; 407 } 408 409 gl::Texture2DArray *texture2darray = context->getTexture2DArray(); 410 if (texture2darray) 411 { 412 textureCompressed = texture2darray->isCompressed(level); 413 textureInternalFormat = texture2darray->getInternalFormat(level); 414 textureLevelWidth = texture2darray->getWidth(level); 415 textureLevelHeight = texture2darray->getHeight(level); 416 textureLevelDepth = texture2darray->getLayers(level); 417 texture = texture2darray; 418 } 419 } 420 break; 421 422 default: 423 context->recordError(Error(GL_INVALID_ENUM)); 424 return false; 425 } 426 427 if (!texture) 428 { 429 context->recordError(Error(GL_INVALID_OPERATION)); 430 return false; 431 } 432 433 if (texture->isImmutable() && !isSubImage) 434 { 435 context->recordError(Error(GL_INVALID_OPERATION)); 436 return false; 437 } 438 439 // Validate texture formats 440 GLenum actualInternalFormat = isSubImage ? textureInternalFormat : internalformat; 441 const gl::InternalFormat &actualFormatInfo = gl::GetInternalFormatInfo(actualInternalFormat); 442 if (isCompressed) 443 { 444 if (!ValidCompressedImageSize(context, actualInternalFormat, width, height)) 445 { 446 context->recordError(Error(GL_INVALID_OPERATION)); 447 return false; 448 } 449 450 if (!actualFormatInfo.compressed) 451 { 452 context->recordError(Error(GL_INVALID_ENUM)); 453 return false; 454 } 455 456 if (target == GL_TEXTURE_3D) 457 { 458 context->recordError(Error(GL_INVALID_OPERATION)); 459 return false; 460 } 461 } 462 else 463 { 464 if (!ValidateTexImageFormatCombination(context, actualInternalFormat, format, type)) 465 { 466 return false; 467 } 468 469 if (target == GL_TEXTURE_3D && (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL)) 470 { 471 context->recordError(Error(GL_INVALID_OPERATION)); 472 return false; 473 } 474 } 475 476 // Validate sub image parameters 477 if (isSubImage) 478 { 479 if (isCompressed != textureCompressed) 480 { 481 context->recordError(Error(GL_INVALID_OPERATION)); 482 return false; 483 } 484 485 if (isCompressed) 486 { 487 if ((width % 4 != 0 && width != textureLevelWidth) || 488 (height % 4 != 0 && height != textureLevelHeight)) 489 { 490 context->recordError(Error(GL_INVALID_OPERATION)); 491 return false; 492 } 493 } 494 495 if (width == 0 || height == 0 || depth == 0) 496 { 497 return false; 498 } 499 500 if (xoffset < 0 || yoffset < 0 || zoffset < 0) 501 { 502 context->recordError(Error(GL_INVALID_VALUE)); 503 return false; 504 } 505 506 if (std::numeric_limits<GLsizei>::max() - xoffset < width || 507 std::numeric_limits<GLsizei>::max() - yoffset < height || 508 std::numeric_limits<GLsizei>::max() - zoffset < depth) 509 { 510 context->recordError(Error(GL_INVALID_VALUE)); 511 return false; 512 } 513 514 if (xoffset + width > textureLevelWidth || 515 yoffset + height > textureLevelHeight || 516 zoffset + depth > textureLevelDepth) 517 { 518 context->recordError(Error(GL_INVALID_VALUE)); 519 return false; 520 } 521 } 522 523 // Check for pixel unpack buffer related API errors 524 gl::Buffer *pixelUnpackBuffer = context->getState().getTargetBuffer(GL_PIXEL_UNPACK_BUFFER); 525 if (pixelUnpackBuffer != NULL) 526 { 527 // ...the data would be unpacked from the buffer object such that the memory reads required 528 // would exceed the data store size. 529 size_t widthSize = static_cast<size_t>(width); 530 size_t heightSize = static_cast<size_t>(height); 531 size_t depthSize = static_cast<size_t>(depth); 532 GLenum sizedFormat = GetSizedInternalFormat(actualInternalFormat, type); 533 534 size_t pixelBytes = static_cast<size_t>(gl::GetInternalFormatInfo(sizedFormat).pixelBytes); 535 536 if (!rx::IsUnsignedMultiplicationSafe(widthSize, heightSize) || 537 !rx::IsUnsignedMultiplicationSafe(widthSize * heightSize, depthSize) || 538 !rx::IsUnsignedMultiplicationSafe(widthSize * heightSize * depthSize, pixelBytes)) 539 { 540 // Overflow past the end of the buffer 541 context->recordError(Error(GL_INVALID_OPERATION)); 542 return false; 543 } 544 545 size_t copyBytes = widthSize * heightSize * depthSize * pixelBytes; 546 size_t offset = reinterpret_cast<size_t>(pixels); 547 548 if (!rx::IsUnsignedAdditionSafe(offset, copyBytes) || 549 ((offset + copyBytes) > static_cast<size_t>(pixelUnpackBuffer->getSize()))) 550 { 551 // Overflow past the end of the buffer 552 context->recordError(Error(GL_INVALID_OPERATION)); 553 return false; 554 } 555 556 // ...data is not evenly divisible into the number of bytes needed to store in memory a datum 557 // indicated by type. 558 size_t dataBytesPerPixel = static_cast<size_t>(gl::GetTypeInfo(type).bytes); 559 560 if ((offset % dataBytesPerPixel) != 0) 561 { 562 context->recordError(Error(GL_INVALID_OPERATION)); 563 return false; 564 } 565 566 // ...the buffer object's data store is currently mapped. 567 if (pixelUnpackBuffer->isMapped()) 568 { 569 context->recordError(Error(GL_INVALID_OPERATION)); 570 return false; 571 } 572 } 573 574 return true; 575 } 576 577 struct EffectiveInternalFormatInfo 578 { 579 GLenum mEffectiveFormat; 580 GLenum mDestFormat; 581 GLuint mMinRedBits; 582 GLuint mMaxRedBits; 583 GLuint mMinGreenBits; 584 GLuint mMaxGreenBits; 585 GLuint mMinBlueBits; 586 GLuint mMaxBlueBits; 587 GLuint mMinAlphaBits; 588 GLuint mMaxAlphaBits; 589 590 EffectiveInternalFormatInfo(GLenum effectiveFormat, GLenum destFormat, GLuint minRedBits, GLuint maxRedBits, 591 GLuint minGreenBits, GLuint maxGreenBits, GLuint minBlueBits, GLuint maxBlueBits, 592 GLuint minAlphaBits, GLuint maxAlphaBits) 593 : mEffectiveFormat(effectiveFormat), mDestFormat(destFormat), mMinRedBits(minRedBits), 594 mMaxRedBits(maxRedBits), mMinGreenBits(minGreenBits), mMaxGreenBits(maxGreenBits), 595 mMinBlueBits(minBlueBits), mMaxBlueBits(maxBlueBits), mMinAlphaBits(minAlphaBits), 596 mMaxAlphaBits(maxAlphaBits) {}; 597 }; 598 599 typedef std::vector<EffectiveInternalFormatInfo> EffectiveInternalFormatList; 600 601 static EffectiveInternalFormatList BuildSizedEffectiveInternalFormatList() 602 { 603 EffectiveInternalFormatList list; 604 605 // OpenGL ES 3.0.3 Specification, Table 3.17, pg 141: Effective internal format coresponding to destination internal format and 606 // linear source buffer component sizes. 607 // | Source channel min/max sizes | 608 // Effective Internal Format | N/A | R | G | B | A | 609 list.push_back(EffectiveInternalFormatInfo(GL_ALPHA8_EXT, GL_NONE, 0, 0, 0, 0, 0, 0, 1, 8)); 610 list.push_back(EffectiveInternalFormatInfo(GL_R8, GL_NONE, 1, 8, 0, 0, 0, 0, 0, 0)); 611 list.push_back(EffectiveInternalFormatInfo(GL_RG8, GL_NONE, 1, 8, 1, 8, 0, 0, 0, 0)); 612 list.push_back(EffectiveInternalFormatInfo(GL_RGB565, GL_NONE, 1, 5, 1, 6, 1, 5, 0, 0)); 613 list.push_back(EffectiveInternalFormatInfo(GL_RGB8, GL_NONE, 6, 8, 7, 8, 6, 8, 0, 0)); 614 list.push_back(EffectiveInternalFormatInfo(GL_RGBA4, GL_NONE, 1, 4, 1, 4, 1, 4, 1, 4)); 615 list.push_back(EffectiveInternalFormatInfo(GL_RGB5_A1, GL_NONE, 5, 5, 5, 5, 5, 5, 1, 1)); 616 list.push_back(EffectiveInternalFormatInfo(GL_RGBA8, GL_NONE, 5, 8, 5, 8, 5, 8, 2, 8)); 617 list.push_back(EffectiveInternalFormatInfo(GL_RGB10_A2, GL_NONE, 9, 10, 9, 10, 9, 10, 2, 2)); 618 619 return list; 620 } 621 622 static EffectiveInternalFormatList BuildUnsizedEffectiveInternalFormatList() 623 { 624 EffectiveInternalFormatList list; 625 626 // OpenGL ES 3.0.3 Specification, Table 3.17, pg 141: Effective internal format coresponding to destination internal format and 627 // linear source buffer component sizes. 628 // | Source channel min/max sizes | 629 // Effective Internal Format | Dest Format | R | G | B | A | 630 list.push_back(EffectiveInternalFormatInfo(GL_ALPHA8_EXT, GL_ALPHA, 0, UINT_MAX, 0, UINT_MAX, 0, UINT_MAX, 1, 8)); 631 list.push_back(EffectiveInternalFormatInfo(GL_LUMINANCE8_EXT, GL_LUMINANCE, 1, 8, 0, UINT_MAX, 0, UINT_MAX, 0, UINT_MAX)); 632 list.push_back(EffectiveInternalFormatInfo(GL_LUMINANCE8_ALPHA8_EXT, GL_LUMINANCE_ALPHA, 1, 8, 0, UINT_MAX, 0, UINT_MAX, 1, 8)); 633 list.push_back(EffectiveInternalFormatInfo(GL_RGB565, GL_RGB, 1, 5, 1, 6, 1, 5, 0, UINT_MAX)); 634 list.push_back(EffectiveInternalFormatInfo(GL_RGB8, GL_RGB, 6, 8, 7, 8, 6, 8, 0, UINT_MAX)); 635 list.push_back(EffectiveInternalFormatInfo(GL_RGBA4, GL_RGBA, 1, 4, 1, 4, 1, 4, 1, 4)); 636 list.push_back(EffectiveInternalFormatInfo(GL_RGB5_A1, GL_RGBA, 5, 5, 5, 5, 5, 5, 1, 1)); 637 list.push_back(EffectiveInternalFormatInfo(GL_RGBA8, GL_RGBA, 5, 8, 5, 8, 5, 8, 5, 8)); 638 639 return list; 640 } 641 642 static bool GetEffectiveInternalFormat(const InternalFormat &srcFormat, const InternalFormat &destFormat, 643 GLenum *outEffectiveFormat) 644 { 645 const EffectiveInternalFormatList *list = NULL; 646 GLenum targetFormat = GL_NONE; 647 648 if (destFormat.pixelBytes > 0) 649 { 650 static const EffectiveInternalFormatList sizedList = BuildSizedEffectiveInternalFormatList(); 651 list = &sizedList; 652 } 653 else 654 { 655 static const EffectiveInternalFormatList unsizedList = BuildUnsizedEffectiveInternalFormatList(); 656 list = &unsizedList; 657 targetFormat = destFormat.format; 658 } 659 660 for (size_t curFormat = 0; curFormat < list->size(); ++curFormat) 661 { 662 const EffectiveInternalFormatInfo& formatInfo = list->at(curFormat); 663 if ((formatInfo.mDestFormat == targetFormat) && 664 (formatInfo.mMinRedBits <= srcFormat.redBits && formatInfo.mMaxRedBits >= srcFormat.redBits) && 665 (formatInfo.mMinGreenBits <= srcFormat.greenBits && formatInfo.mMaxGreenBits >= srcFormat.greenBits) && 666 (formatInfo.mMinBlueBits <= srcFormat.blueBits && formatInfo.mMaxBlueBits >= srcFormat.blueBits) && 667 (formatInfo.mMinAlphaBits <= srcFormat.alphaBits && formatInfo.mMaxAlphaBits >= srcFormat.alphaBits)) 668 { 669 *outEffectiveFormat = formatInfo.mEffectiveFormat; 670 return true; 671 } 672 } 673 674 return false; 675 } 676 677 struct CopyConversion 678 { 679 GLenum mTextureFormat; 680 GLenum mFramebufferFormat; 681 682 CopyConversion(GLenum textureFormat, GLenum framebufferFormat) 683 : mTextureFormat(textureFormat), mFramebufferFormat(framebufferFormat) { } 684 685 bool operator<(const CopyConversion& other) const 686 { 687 return memcmp(this, &other, sizeof(CopyConversion)) < 0; 688 } 689 }; 690 691 typedef std::set<CopyConversion> CopyConversionSet; 692 693 static CopyConversionSet BuildValidES3CopyTexImageCombinations() 694 { 695 CopyConversionSet set; 696 697 // From ES 3.0.1 spec, table 3.15 698 set.insert(CopyConversion(GL_ALPHA, GL_RGBA)); 699 set.insert(CopyConversion(GL_LUMINANCE, GL_RED)); 700 set.insert(CopyConversion(GL_LUMINANCE, GL_RG)); 701 set.insert(CopyConversion(GL_LUMINANCE, GL_RGB)); 702 set.insert(CopyConversion(GL_LUMINANCE, GL_RGBA)); 703 set.insert(CopyConversion(GL_LUMINANCE_ALPHA, GL_RGBA)); 704 set.insert(CopyConversion(GL_RED, GL_RED)); 705 set.insert(CopyConversion(GL_RED, GL_RG)); 706 set.insert(CopyConversion(GL_RED, GL_RGB)); 707 set.insert(CopyConversion(GL_RED, GL_RGBA)); 708 set.insert(CopyConversion(GL_RG, GL_RG)); 709 set.insert(CopyConversion(GL_RG, GL_RGB)); 710 set.insert(CopyConversion(GL_RG, GL_RGBA)); 711 set.insert(CopyConversion(GL_RGB, GL_RGB)); 712 set.insert(CopyConversion(GL_RGB, GL_RGBA)); 713 set.insert(CopyConversion(GL_RGBA, GL_RGBA)); 714 715 // Necessary for ANGLE back-buffers 716 set.insert(CopyConversion(GL_ALPHA, GL_BGRA_EXT)); 717 set.insert(CopyConversion(GL_LUMINANCE, GL_BGRA_EXT)); 718 set.insert(CopyConversion(GL_LUMINANCE_ALPHA, GL_BGRA_EXT)); 719 set.insert(CopyConversion(GL_RED, GL_BGRA_EXT)); 720 set.insert(CopyConversion(GL_RG, GL_BGRA_EXT)); 721 set.insert(CopyConversion(GL_RGB, GL_BGRA_EXT)); 722 set.insert(CopyConversion(GL_RGBA, GL_BGRA_EXT)); 723 724 set.insert(CopyConversion(GL_RED_INTEGER, GL_RED_INTEGER)); 725 set.insert(CopyConversion(GL_RED_INTEGER, GL_RG_INTEGER)); 726 set.insert(CopyConversion(GL_RED_INTEGER, GL_RGB_INTEGER)); 727 set.insert(CopyConversion(GL_RED_INTEGER, GL_RGBA_INTEGER)); 728 set.insert(CopyConversion(GL_RG_INTEGER, GL_RG_INTEGER)); 729 set.insert(CopyConversion(GL_RG_INTEGER, GL_RGB_INTEGER)); 730 set.insert(CopyConversion(GL_RG_INTEGER, GL_RGBA_INTEGER)); 731 set.insert(CopyConversion(GL_RGB_INTEGER, GL_RGB_INTEGER)); 732 set.insert(CopyConversion(GL_RGB_INTEGER, GL_RGBA_INTEGER)); 733 set.insert(CopyConversion(GL_RGBA_INTEGER, GL_RGBA_INTEGER)); 734 735 return set; 736 } 737 738 static bool IsValidES3CopyTexImageCombination(GLenum textureInternalFormat, GLenum frameBufferInternalFormat, GLuint readBufferHandle) 739 { 740 const InternalFormat &textureInternalFormatInfo = GetInternalFormatInfo(textureInternalFormat); 741 const InternalFormat &framebufferInternalFormatInfo = GetInternalFormatInfo(frameBufferInternalFormat); 742 743 static const CopyConversionSet conversionSet = BuildValidES3CopyTexImageCombinations(); 744 if (conversionSet.find(CopyConversion(textureInternalFormatInfo.format, framebufferInternalFormatInfo.format)) != conversionSet.end()) 745 { 746 // Section 3.8.5 of the GLES 3.0.3 spec states that source and destination formats 747 // must both be signed, unsigned, or fixed point and both source and destinations 748 // must be either both SRGB or both not SRGB. EXT_color_buffer_float adds allowed 749 // conversion between fixed and floating point. 750 751 if ((textureInternalFormatInfo.colorEncoding == GL_SRGB) != (framebufferInternalFormatInfo.colorEncoding == GL_SRGB)) 752 { 753 return false; 754 } 755 756 if (((textureInternalFormatInfo.componentType == GL_INT) != (framebufferInternalFormatInfo.componentType == GL_INT )) || 757 ((textureInternalFormatInfo.componentType == GL_UNSIGNED_INT) != (framebufferInternalFormatInfo.componentType == GL_UNSIGNED_INT))) 758 { 759 return false; 760 } 761 762 if ((textureInternalFormatInfo.componentType == GL_UNSIGNED_NORMALIZED || 763 textureInternalFormatInfo.componentType == GL_SIGNED_NORMALIZED || 764 textureInternalFormatInfo.componentType == GL_FLOAT) && 765 !(framebufferInternalFormatInfo.componentType == GL_UNSIGNED_NORMALIZED || 766 framebufferInternalFormatInfo.componentType == GL_SIGNED_NORMALIZED || 767 framebufferInternalFormatInfo.componentType == GL_FLOAT)) 768 { 769 return false; 770 } 771 772 // GLES specification 3.0.3, sec 3.8.5, pg 139-140: 773 // The effective internal format of the source buffer is determined with the following rules applied in order: 774 // * If the source buffer is a texture or renderbuffer that was created with a sized internal format then the 775 // effective internal format is the source buffer's sized internal format. 776 // * If the source buffer is a texture that was created with an unsized base internal format, then the 777 // effective internal format is the source image array's effective internal format, as specified by table 778 // 3.12, which is determined from the <format> and <type> that were used when the source image array was 779 // specified by TexImage*. 780 // * Otherwise the effective internal format is determined by the row in table 3.17 or 3.18 where 781 // Destination Internal Format matches internalformat and where the [source channel sizes] are consistent 782 // with the values of the source buffer's [channel sizes]. Table 3.17 is used if the 783 // FRAMEBUFFER_ATTACHMENT_ENCODING is LINEAR and table 3.18 is used if the FRAMEBUFFER_ATTACHMENT_ENCODING 784 // is SRGB. 785 const InternalFormat *sourceEffectiveFormat = NULL; 786 if (readBufferHandle != 0) 787 { 788 // Not the default framebuffer, therefore the read buffer must be a user-created texture or renderbuffer 789 if (framebufferInternalFormatInfo.pixelBytes > 0) 790 { 791 sourceEffectiveFormat = &framebufferInternalFormatInfo; 792 } 793 else 794 { 795 // Renderbuffers cannot be created with an unsized internal format, so this must be an unsized-format 796 // texture. We can use the same table we use when creating textures to get its effective sized format. 797 const FormatType &typeInfo = GetFormatTypeInfo(framebufferInternalFormatInfo.format, framebufferInternalFormatInfo.type); 798 sourceEffectiveFormat = &GetInternalFormatInfo(typeInfo.internalFormat); 799 } 800 } 801 else 802 { 803 // The effective internal format must be derived from the source framebuffer's channel sizes. 804 // This is done in GetEffectiveInternalFormat for linear buffers (table 3.17) 805 if (framebufferInternalFormatInfo.colorEncoding == GL_LINEAR) 806 { 807 GLenum effectiveFormat; 808 if (GetEffectiveInternalFormat(framebufferInternalFormatInfo, textureInternalFormatInfo, &effectiveFormat)) 809 { 810 sourceEffectiveFormat = &GetInternalFormatInfo(effectiveFormat); 811 } 812 else 813 { 814 return false; 815 } 816 } 817 else if (framebufferInternalFormatInfo.colorEncoding == GL_SRGB) 818 { 819 // SRGB buffers can only be copied to sized format destinations according to table 3.18 820 if ((textureInternalFormatInfo.pixelBytes > 0) && 821 (framebufferInternalFormatInfo.redBits >= 1 && framebufferInternalFormatInfo.redBits <= 8) && 822 (framebufferInternalFormatInfo.greenBits >= 1 && framebufferInternalFormatInfo.greenBits <= 8) && 823 (framebufferInternalFormatInfo.blueBits >= 1 && framebufferInternalFormatInfo.blueBits <= 8) && 824 (framebufferInternalFormatInfo.alphaBits >= 1 && framebufferInternalFormatInfo.alphaBits <= 8)) 825 { 826 sourceEffectiveFormat = &GetInternalFormatInfo(GL_SRGB8_ALPHA8); 827 } 828 else 829 { 830 return false; 831 } 832 } 833 else 834 { 835 UNREACHABLE(); 836 return false; 837 } 838 } 839 840 if (textureInternalFormatInfo.pixelBytes > 0) 841 { 842 // Section 3.8.5 of the GLES 3.0.3 spec, pg 139, requires that, if the destination format is sized, 843 // component sizes of the source and destination formats must exactly match 844 if (textureInternalFormatInfo.redBits != sourceEffectiveFormat->redBits || 845 textureInternalFormatInfo.greenBits != sourceEffectiveFormat->greenBits || 846 textureInternalFormatInfo.blueBits != sourceEffectiveFormat->blueBits || 847 textureInternalFormatInfo.alphaBits != sourceEffectiveFormat->alphaBits) 848 { 849 return false; 850 } 851 } 852 853 854 return true; // A conversion function exists, and no rule in the specification has precluded conversion 855 // between these formats. 856 } 857 858 return false; 859 } 860 861 bool ValidateES3CopyTexImageParameters(Context *context, GLenum target, GLint level, GLenum internalformat, 862 bool isSubImage, GLint xoffset, GLint yoffset, GLint zoffset, 863 GLint x, GLint y, GLsizei width, GLsizei height, GLint border) 864 { 865 GLenum textureInternalFormat; 866 if (!ValidateCopyTexImageParametersBase(context, target, level, internalformat, isSubImage, 867 xoffset, yoffset, zoffset, x, y, width, height, 868 border, &textureInternalFormat)) 869 { 870 return false; 871 } 872 873 gl::Framebuffer *framebuffer = context->getState().getReadFramebuffer(); 874 875 if (framebuffer->completeness() != GL_FRAMEBUFFER_COMPLETE) 876 { 877 context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION)); 878 return false; 879 } 880 881 if (context->getState().getReadFramebuffer()->id() != 0 && framebuffer->getSamples() != 0) 882 { 883 context->recordError(Error(GL_INVALID_OPERATION)); 884 return false; 885 } 886 887 gl::FramebufferAttachment *source = framebuffer->getReadColorbuffer(); 888 GLenum colorbufferInternalFormat = source->getInternalFormat(); 889 890 if (isSubImage) 891 { 892 if (!IsValidES3CopyTexImageCombination(textureInternalFormat, colorbufferInternalFormat, 893 context->getState().getReadFramebuffer()->id())) 894 { 895 context->recordError(Error(GL_INVALID_OPERATION)); 896 return false; 897 } 898 } 899 else 900 { 901 if (!gl::IsValidES3CopyTexImageCombination(internalformat, colorbufferInternalFormat, 902 context->getState().getReadFramebuffer()->id())) 903 { 904 context->recordError(Error(GL_INVALID_OPERATION)); 905 return false; 906 } 907 } 908 909 // If width or height is zero, it is a no-op. Return false without setting an error. 910 return (width > 0 && height > 0); 911 } 912 913 bool ValidateES3TexStorageParameters(Context *context, GLenum target, GLsizei levels, GLenum internalformat, 914 GLsizei width, GLsizei height, GLsizei depth) 915 { 916 if (width < 1 || height < 1 || depth < 1 || levels < 1) 917 { 918 context->recordError(Error(GL_INVALID_VALUE)); 919 return false; 920 } 921 922 if (levels > gl::log2(std::max(std::max(width, height), depth)) + 1) 923 { 924 context->recordError(Error(GL_INVALID_OPERATION)); 925 return false; 926 } 927 928 const gl::Caps &caps = context->getCaps(); 929 930 gl::Texture *texture = NULL; 931 switch (target) 932 { 933 case GL_TEXTURE_2D: 934 { 935 texture = context->getTexture2D(); 936 937 if (static_cast<GLuint>(width) > caps.max2DTextureSize || 938 static_cast<GLuint>(height) > caps.max2DTextureSize) 939 { 940 context->recordError(Error(GL_INVALID_VALUE)); 941 return false; 942 } 943 } 944 break; 945 946 case GL_TEXTURE_CUBE_MAP: 947 { 948 texture = context->getTextureCubeMap(); 949 950 if (width != height) 951 { 952 context->recordError(Error(GL_INVALID_VALUE)); 953 return false; 954 } 955 956 if (static_cast<GLuint>(width) > caps.maxCubeMapTextureSize) 957 { 958 context->recordError(Error(GL_INVALID_VALUE)); 959 return false; 960 } 961 } 962 break; 963 964 case GL_TEXTURE_3D: 965 { 966 texture = context->getTexture3D(); 967 968 if (static_cast<GLuint>(width) > caps.max3DTextureSize || 969 static_cast<GLuint>(height) > caps.max3DTextureSize || 970 static_cast<GLuint>(depth) > caps.max3DTextureSize) 971 { 972 context->recordError(Error(GL_INVALID_VALUE)); 973 return false; 974 } 975 } 976 break; 977 978 case GL_TEXTURE_2D_ARRAY: 979 { 980 texture = context->getTexture2DArray(); 981 982 if (static_cast<GLuint>(width) > caps.max2DTextureSize || 983 static_cast<GLuint>(height) > caps.max2DTextureSize || 984 static_cast<GLuint>(depth) > caps.maxArrayTextureLayers) 985 { 986 context->recordError(Error(GL_INVALID_VALUE)); 987 return false; 988 } 989 } 990 break; 991 992 default: 993 context->recordError(Error(GL_INVALID_ENUM)); 994 return false; 995 } 996 997 if (!texture || texture->id() == 0) 998 { 999 context->recordError(Error(GL_INVALID_OPERATION)); 1000 return false; 1001 } 1002 1003 if (texture->isImmutable()) 1004 { 1005 context->recordError(Error(GL_INVALID_OPERATION)); 1006 return false; 1007 } 1008 1009 const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(internalformat); 1010 if (!formatInfo.textureSupport(context->getClientVersion(), context->getExtensions())) 1011 { 1012 context->recordError(Error(GL_INVALID_ENUM)); 1013 return false; 1014 } 1015 1016 if (formatInfo.pixelBytes == 0) 1017 { 1018 context->recordError(Error(GL_INVALID_ENUM)); 1019 return false; 1020 } 1021 1022 return true; 1023 } 1024 1025 bool ValidateFramebufferTextureLayer(Context *context, GLenum target, GLenum attachment, 1026 GLuint texture, GLint level, GLint layer) 1027 { 1028 if (context->getClientVersion() < 3) 1029 { 1030 context->recordError(Error(GL_INVALID_OPERATION)); 1031 return false; 1032 } 1033 1034 if (layer < 0) 1035 { 1036 context->recordError(Error(GL_INVALID_VALUE)); 1037 return false; 1038 } 1039 1040 if (!ValidateFramebufferTextureBase(context, target, attachment, texture, level)) 1041 { 1042 return false; 1043 } 1044 1045 const gl::Caps &caps = context->getCaps(); 1046 if (texture != 0) 1047 { 1048 gl::Texture *tex = context->getTexture(texture); 1049 ASSERT(tex); 1050 1051 switch (tex->getTarget()) 1052 { 1053 case GL_TEXTURE_2D_ARRAY: 1054 { 1055 if (level > gl::log2(caps.max2DTextureSize)) 1056 { 1057 context->recordError(Error(GL_INVALID_VALUE)); 1058 return false; 1059 } 1060 1061 if (static_cast<GLuint>(layer) >= caps.maxArrayTextureLayers) 1062 { 1063 context->recordError(Error(GL_INVALID_VALUE)); 1064 return false; 1065 } 1066 1067 gl::Texture2DArray *texArray = static_cast<gl::Texture2DArray *>(tex); 1068 if (texArray->isCompressed(level)) 1069 { 1070 context->recordError(Error(GL_INVALID_OPERATION)); 1071 return false; 1072 } 1073 } 1074 break; 1075 1076 case GL_TEXTURE_3D: 1077 { 1078 if (level > gl::log2(caps.max3DTextureSize)) 1079 { 1080 context->recordError(Error(GL_INVALID_VALUE)); 1081 return false; 1082 } 1083 1084 if (static_cast<GLuint>(layer) >= caps.max3DTextureSize) 1085 { 1086 context->recordError(Error(GL_INVALID_VALUE)); 1087 return false; 1088 } 1089 1090 gl::Texture3D *tex3d = static_cast<gl::Texture3D *>(tex); 1091 if (tex3d->isCompressed(level)) 1092 { 1093 context->recordError(Error(GL_INVALID_OPERATION)); 1094 return false; 1095 } 1096 } 1097 break; 1098 1099 default: 1100 context->recordError(Error(GL_INVALID_OPERATION)); 1101 return false; 1102 } 1103 } 1104 1105 return true; 1106 } 1107 1108 bool ValidES3ReadFormatType(Context *context, GLenum internalFormat, GLenum format, GLenum type) 1109 { 1110 const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat); 1111 1112 switch (format) 1113 { 1114 case GL_RGBA: 1115 switch (type) 1116 { 1117 case GL_UNSIGNED_BYTE: 1118 break; 1119 case GL_UNSIGNED_INT_2_10_10_10_REV: 1120 if (internalFormat != GL_RGB10_A2) 1121 { 1122 return false; 1123 } 1124 break; 1125 case GL_FLOAT: 1126 if (internalFormatInfo.componentType != GL_FLOAT) 1127 { 1128 return false; 1129 } 1130 break; 1131 default: 1132 return false; 1133 } 1134 break; 1135 case GL_RGBA_INTEGER: 1136 switch (type) 1137 { 1138 case GL_INT: 1139 if (internalFormatInfo.componentType != GL_INT) 1140 { 1141 return false; 1142 } 1143 break; 1144 case GL_UNSIGNED_INT: 1145 if (internalFormatInfo.componentType != GL_UNSIGNED_INT) 1146 { 1147 return false; 1148 } 1149 break; 1150 default: 1151 return false; 1152 } 1153 break; 1154 case GL_BGRA_EXT: 1155 switch (type) 1156 { 1157 case GL_UNSIGNED_BYTE: 1158 case GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT: 1159 case GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT: 1160 break; 1161 default: 1162 return false; 1163 } 1164 break; 1165 case GL_RG_EXT: 1166 case GL_RED_EXT: 1167 if (!context->getExtensions().textureRG) 1168 { 1169 return false; 1170 } 1171 switch (type) 1172 { 1173 case GL_UNSIGNED_BYTE: 1174 break; 1175 default: 1176 return false; 1177 } 1178 break; 1179 default: 1180 return false; 1181 } 1182 return true; 1183 } 1184 1185 bool ValidateInvalidateFramebufferParameters(Context *context, GLenum target, GLsizei numAttachments, 1186 const GLenum* attachments) 1187 { 1188 bool defaultFramebuffer = false; 1189 1190 switch (target) 1191 { 1192 case GL_DRAW_FRAMEBUFFER: 1193 case GL_FRAMEBUFFER: 1194 defaultFramebuffer = context->getState().getDrawFramebuffer()->id() == 0; 1195 break; 1196 case GL_READ_FRAMEBUFFER: 1197 defaultFramebuffer = context->getState().getReadFramebuffer()->id() == 0; 1198 break; 1199 default: 1200 context->recordError(Error(GL_INVALID_ENUM)); 1201 return false; 1202 } 1203 1204 for (int i = 0; i < numAttachments; ++i) 1205 { 1206 if (attachments[i] >= GL_COLOR_ATTACHMENT0 && attachments[i] <= GL_COLOR_ATTACHMENT15) 1207 { 1208 if (defaultFramebuffer) 1209 { 1210 context->recordError(Error(GL_INVALID_ENUM)); 1211 return false; 1212 } 1213 1214 if (attachments[i] >= GL_COLOR_ATTACHMENT0 + context->getCaps().maxColorAttachments) 1215 { 1216 context->recordError(Error(GL_INVALID_OPERATION)); 1217 return false; 1218 } 1219 } 1220 else 1221 { 1222 switch (attachments[i]) 1223 { 1224 case GL_DEPTH_ATTACHMENT: 1225 case GL_STENCIL_ATTACHMENT: 1226 case GL_DEPTH_STENCIL_ATTACHMENT: 1227 if (defaultFramebuffer) 1228 { 1229 context->recordError(Error(GL_INVALID_ENUM)); 1230 return false; 1231 } 1232 break; 1233 case GL_COLOR: 1234 case GL_DEPTH: 1235 case GL_STENCIL: 1236 if (!defaultFramebuffer) 1237 { 1238 context->recordError(Error(GL_INVALID_ENUM)); 1239 return false; 1240 } 1241 break; 1242 default: 1243 context->recordError(Error(GL_INVALID_ENUM)); 1244 return false; 1245 } 1246 } 1247 } 1248 1249 return true; 1250 } 1251 1252 bool ValidateClearBuffer(Context *context) 1253 { 1254 if (context->getClientVersion() < 3) 1255 { 1256 context->recordError(Error(GL_INVALID_OPERATION)); 1257 return false; 1258 } 1259 1260 const gl::Framebuffer *fbo = context->getState().getDrawFramebuffer(); 1261 if (!fbo || fbo->completeness() != GL_FRAMEBUFFER_COMPLETE) 1262 { 1263 context->recordError(Error(GL_INVALID_FRAMEBUFFER_OPERATION)); 1264 return false; 1265 } 1266 1267 return true; 1268 } 1269 1270 bool ValidateGetUniformuiv(Context *context, GLuint program, GLint location, GLuint* params) 1271 { 1272 if (context->getClientVersion() < 3) 1273 { 1274 context->recordError(Error(GL_INVALID_OPERATION)); 1275 return false; 1276 } 1277 1278 return ValidateGetUniformBase(context, program, location); 1279 } 1280 1281 } 1282
