gpu/command_buffer/common/gles2_cmd_utils.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is here so other GLES2 related files can have a common set of
   6 // includes where appropriate.
   7
   8 #include <sstream>
   9 #include <GLES2/gl2.h>
  10 #include <GLES2/gl2ext.h>
  11 #include <GLES2/gl2extchromium.h>
  12
  13 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  14 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  15
  16 namespace gpu {
  17 namespace gles2 {
  18
  19 namespace gl_error_bit {
  20 enum GLErrorBit {
  21   kNoError = 0,
  22   kInvalidEnum = (1 << 0),
  23   kInvalidValue = (1 << 1),
  24   kInvalidOperation = (1 << 2),
  25   kOutOfMemory = (1 << 3),
  26   kInvalidFrameBufferOperation = (1 << 4)
  27 };
  28 }
  29
  30 int GLES2Util::GLGetNumValuesReturned(int id) const {
  31   switch (id) {
  32     // -- glGetBooleanv, glGetFloatv, glGetIntergerv
  33     case GL_ACTIVE_TEXTURE:
  34       return 1;
  35     case GL_ALIASED_LINE_WIDTH_RANGE:
  36       return 2;
  37     case GL_ALIASED_POINT_SIZE_RANGE:
  38       return 2;
  39     case GL_ALPHA_BITS:
  40       return 1;
  41     case GL_ARRAY_BUFFER_BINDING:
  42       return 1;
  43     case GL_BLEND:
  44       return 1;
  45     case GL_BLEND_COLOR:
  46       return 4;
  47     case GL_BLEND_DST_ALPHA:
  48       return 1;
  49     case GL_BLEND_DST_RGB:
  50       return 1;
  51     case GL_BLEND_EQUATION_ALPHA:
  52       return 1;
  53     case GL_BLEND_EQUATION_RGB:
  54       return 1;
  55     case GL_BLEND_SRC_ALPHA:
  56       return 1;
  57     case GL_BLEND_SRC_RGB:
  58       return 1;
  59     case GL_BLUE_BITS:
  60       return 1;
  61     case GL_COLOR_CLEAR_VALUE:
  62       return 4;
  63     case GL_COLOR_WRITEMASK:
  64       return 4;
  65     case GL_COMPRESSED_TEXTURE_FORMATS:
  66       return num_compressed_texture_formats_;
  67     case GL_CULL_FACE:
  68       return 1;
  69     case GL_CULL_FACE_MODE:
  70       return 1;
  71     case GL_CURRENT_PROGRAM:
  72       return 1;
  73     case GL_DEPTH_BITS:
  74       return 1;
  75     case GL_DEPTH_CLEAR_VALUE:
  76       return 1;
  77     case GL_DEPTH_FUNC:
  78       return 1;
  79     case GL_DEPTH_RANGE:
  80       return 2;
  81     case GL_DEPTH_TEST:
  82       return 1;
  83     case GL_DEPTH_WRITEMASK:
  84       return 1;
  85     case GL_DITHER:
  86       return 1;
  87     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
  88       return 1;
  89     case GL_FRAMEBUFFER_BINDING:
  90       return 1;
  91     case GL_FRONT_FACE:
  92       return 1;
  93     case GL_GENERATE_MIPMAP_HINT:
  94       return 1;
  95     case GL_GREEN_BITS:
  96       return 1;
  97     case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
  98       return 1;
  99     case GL_IMPLEMENTATION_COLOR_READ_TYPE:
 100       return 1;
 101     case GL_LINE_WIDTH:
 102       return 1;
 103     case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
 104       return 1;
 105     case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
 106       return 1;
 107     case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
 108       return 1;
 109     case GL_MAX_RENDERBUFFER_SIZE:
 110       return 1;
 111     case GL_MAX_TEXTURE_IMAGE_UNITS:
 112       return 1;
 113     case GL_MAX_TEXTURE_SIZE:
 114       return 1;
 115     case GL_MAX_VARYING_VECTORS:
 116       return 1;
 117     case GL_MAX_VERTEX_ATTRIBS:
 118       return 1;
 119     case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
 120       return 1;
 121     case GL_MAX_VERTEX_UNIFORM_VECTORS:
 122       return 1;
 123     case GL_MAX_VIEWPORT_DIMS:
 124       return 2;
 125     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
 126       return 1;
 127     case GL_NUM_SHADER_BINARY_FORMATS:
 128       return 1;
 129     case GL_PACK_ALIGNMENT:
 130       return 1;
 131     case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
 132       return 1;
 133     case GL_POLYGON_OFFSET_FACTOR:
 134       return 1;
 135     case GL_POLYGON_OFFSET_FILL:
 136       return 1;
 137     case GL_POLYGON_OFFSET_UNITS:
 138       return 1;
 139     case GL_RED_BITS:
 140       return 1;
 141     case GL_RENDERBUFFER_BINDING:
 142       return 1;
 143     case GL_SAMPLE_BUFFERS:
 144       return 1;
 145     case GL_SAMPLE_COVERAGE_INVERT:
 146       return 1;
 147     case GL_SAMPLE_COVERAGE_VALUE:
 148       return 1;
 149     case GL_SAMPLES:
 150       return 1;
 151     case GL_SCISSOR_BOX:
 152       return 4;
 153     case GL_SCISSOR_TEST:
 154       return 1;
 155     case GL_SHADER_BINARY_FORMATS:
 156       return num_shader_binary_formats_;
 157     case GL_SHADER_COMPILER:
 158       return 1;
 159     case GL_STENCIL_BACK_FAIL:
 160       return 1;
 161     case GL_STENCIL_BACK_FUNC:
 162       return 1;
 163     case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
 164       return 1;
 165     case GL_STENCIL_BACK_PASS_DEPTH_PASS:
 166       return 1;
 167     case GL_STENCIL_BACK_REF:
 168       return 1;
 169     case GL_STENCIL_BACK_VALUE_MASK:
 170       return 1;
 171     case GL_STENCIL_BACK_WRITEMASK:
 172       return 1;
 173     case GL_STENCIL_BITS:
 174       return 1;
 175     case GL_STENCIL_CLEAR_VALUE:
 176       return 1;
 177     case GL_STENCIL_FAIL:
 178       return 1;
 179     case GL_STENCIL_FUNC:
 180       return 1;
 181     case GL_STENCIL_PASS_DEPTH_FAIL:
 182       return 1;
 183     case GL_STENCIL_PASS_DEPTH_PASS:
 184       return 1;
 185     case GL_STENCIL_REF:
 186       return 1;
 187     case GL_STENCIL_TEST:
 188       return 1;
 189     case GL_STENCIL_VALUE_MASK:
 190       return 1;
 191     case GL_STENCIL_WRITEMASK:
 192       return 1;
 193     case GL_SUBPIXEL_BITS:
 194       return 1;
 195     case GL_TEXTURE_BINDING_2D:
 196       return 1;
 197     case GL_TEXTURE_BINDING_CUBE_MAP:
 198       return 1;
 199     case GL_TEXTURE_BINDING_EXTERNAL_OES:
 200       return 1;
 201     case GL_TEXTURE_BINDING_RECTANGLE_ARB:
 202       return 1;
 203     case GL_TEXTURE_IMMUTABLE_FORMAT_EXT:
 204       return 1;
 205     case GL_UNPACK_ALIGNMENT:
 206       return 1;
 207     case GL_VIEWPORT:
 208       return 4;
 209     // -- glGetBooleanv, glGetFloatv, glGetIntergerv with
 210     //    GL_CHROMIUM_framebuffer_multisample
 211     case GL_MAX_SAMPLES_EXT:
 212       return 1;
 213     case GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT:
 214       return 1;
 215
 216     // -- glGetBufferParameteriv
 217     case GL_BUFFER_SIZE:
 218       return 1;
 219     case GL_BUFFER_USAGE:
 220       return 1;
 221
 222     // -- glGetFramebufferAttachmentParameteriv
 223     case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
 224       return 1;
 225     case GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
 226       return 1;
 227     case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
 228       return 1;
 229     case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
 230       return 1;
 231     // -- glGetFramebufferAttachmentParameteriv with
 232     //    GL_EXT_multisampled_render_to_texture
 233     case GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT:
 234       return 1;
 235
 236     // -- glGetProgramiv
 237     case GL_DELETE_STATUS:
 238       return 1;
 239     case GL_LINK_STATUS:
 240       return 1;
 241     case GL_VALIDATE_STATUS:
 242       return 1;
 243     case GL_INFO_LOG_LENGTH:
 244       return 1;
 245     case GL_ATTACHED_SHADERS:
 246       return 1;
 247     case GL_ACTIVE_ATTRIBUTES:
 248       return 1;
 249     case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
 250       return 1;
 251     case GL_ACTIVE_UNIFORMS:
 252       return 1;
 253     case GL_ACTIVE_UNIFORM_MAX_LENGTH:
 254       return 1;
 255
 256
 257     // -- glGetRenderbufferAttachmentParameteriv
 258     case GL_RENDERBUFFER_WIDTH:
 259       return 1;
 260     case GL_RENDERBUFFER_HEIGHT:
 261       return 1;
 262     case GL_RENDERBUFFER_INTERNAL_FORMAT:
 263       return 1;
 264     case GL_RENDERBUFFER_RED_SIZE:
 265       return 1;
 266     case GL_RENDERBUFFER_GREEN_SIZE:
 267       return 1;
 268     case GL_RENDERBUFFER_BLUE_SIZE:
 269       return 1;
 270     case GL_RENDERBUFFER_ALPHA_SIZE:
 271       return 1;
 272     case GL_RENDERBUFFER_DEPTH_SIZE:
 273       return 1;
 274     case GL_RENDERBUFFER_STENCIL_SIZE:
 275       return 1;
 276     // -- glGetRenderbufferAttachmentParameteriv with
 277     //    GL_EXT_multisampled_render_to_texture
 278     case GL_RENDERBUFFER_SAMPLES_EXT:
 279       return 1;
 280
 281     // -- glGetShaderiv
 282     case GL_SHADER_TYPE:
 283       return 1;
 284     // Already defined under glGetFramebufferAttachemntParameteriv.
 285     // case GL_DELETE_STATUS:
 286     //   return 1;
 287     case GL_COMPILE_STATUS:
 288       return 1;
 289     // Already defined under glGetFramebufferAttachemntParameteriv.
 290     // case GL_INFO_LOG_LENGTH:
 291     //   return 1;
 292     case GL_SHADER_SOURCE_LENGTH:
 293       return 1;
 294     case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
 295       return 1;
 296
 297     // -- glGetTexParameterfv, glGetTexParameteriv
 298     case GL_TEXTURE_MAG_FILTER:
 299       return 1;
 300     case GL_TEXTURE_MIN_FILTER:
 301       return 1;
 302     case GL_TEXTURE_WRAP_S:
 303       return 1;
 304     case GL_TEXTURE_WRAP_T:
 305       return 1;
 306     case GL_TEXTURE_MAX_ANISOTROPY_EXT:
 307       return 1;
 308
 309     // -- glGetVertexAttribfv, glGetVertexAttribiv
 310     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING:
 311       return 1;
 312     case GL_VERTEX_ATTRIB_ARRAY_ENABLED:
 313       return 1;
 314     case GL_VERTEX_ATTRIB_ARRAY_SIZE:
 315       return 1;
 316     case GL_VERTEX_ATTRIB_ARRAY_STRIDE:
 317       return 1;
 318     case GL_VERTEX_ATTRIB_ARRAY_TYPE:
 319       return 1;
 320     case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
 321       return 1;
 322     case GL_CURRENT_VERTEX_ATTRIB:
 323       return 4;
 324
 325     // -- glHint with GL_OES_standard_derivatives
 326     case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
 327       return 1;
 328
 329     // Chromium internal bind_generates_resource query
 330     case GL_BIND_GENERATES_RESOURCE_CHROMIUM:
 331       return 1;
 332
 333     // bad enum
 334     default:
 335       return 0;
 336   }
 337 }
 338
 339 namespace {
 340
 341 // Return the number of elements per group of a specified format.
 342 int ElementsPerGroup(int format, int type) {
 343   switch (type) {
 344     case GL_UNSIGNED_SHORT_5_6_5:
 345     case GL_UNSIGNED_SHORT_4_4_4_4:
 346     case GL_UNSIGNED_SHORT_5_5_5_1:
 347     case GL_UNSIGNED_INT_24_8_OES:
 348        return 1;
 349     default:
 350        break;
 351     }
 352
 353     switch (format) {
 354     case GL_RGB:
 355        return 3;
 356     case GL_LUMINANCE_ALPHA:
 357        return 2;
 358     case GL_RGBA:
 359     case GL_BGRA_EXT:
 360        return 4;
 361     case GL_ALPHA:
 362     case GL_LUMINANCE:
 363     case GL_DEPTH_COMPONENT:
 364     case GL_DEPTH_COMPONENT24_OES:
 365     case GL_DEPTH_COMPONENT32_OES:
 366     case GL_DEPTH_COMPONENT16:
 367     case GL_DEPTH24_STENCIL8_OES:
 368     case GL_DEPTH_STENCIL_OES:
 369        return 1;
 370     default:
 371        return 0;
 372   }
 373 }
 374
 375 // Return the number of bytes per element, based on the element type.
 376 int BytesPerElement(int type) {
 377   switch (type) {
 378     case GL_FLOAT:
 379     case GL_UNSIGNED_INT_24_8_OES:
 380     case GL_UNSIGNED_INT:
 381       return 4;
 382     case GL_HALF_FLOAT_OES:
 383     case GL_UNSIGNED_SHORT:
 384     case GL_SHORT:
 385     case GL_UNSIGNED_SHORT_5_6_5:
 386     case GL_UNSIGNED_SHORT_4_4_4_4:
 387     case GL_UNSIGNED_SHORT_5_5_5_1:
 388        return 2;
 389     case GL_UNSIGNED_BYTE:
 390     case GL_BYTE:
 391        return 1;
 392     default:
 393        return 0;
 394   }
 395 }
 396
 397 }  // anonymous namespace
 398
 399 uint32 GLES2Util::ComputeImageGroupSize(int format, int type) {
 400   return BytesPerElement(type) * ElementsPerGroup(format, type);
 401 }
 402
 403 bool GLES2Util::ComputeImagePaddedRowSize(
 404         int width, int format, int type, int unpack_alignment,
 405         uint32* padded_row_size) {
 406   uint32 bytes_per_group = ComputeImageGroupSize(format, type);
 407   uint32 unpadded_row_size;
 408   if (!SafeMultiplyUint32(width, bytes_per_group, &unpadded_row_size)) {
 409     return false;
 410   }
 411   uint32 temp;
 412   if (!SafeAddUint32(unpadded_row_size, unpack_alignment - 1, &temp)) {
 413       return false;
 414   }
 415   *padded_row_size = (temp / unpack_alignment) * unpack_alignment;
 416   return true;
 417 }
 418
 419 // Returns the amount of data glTexImage2D or glTexSubImage2D will access.
 420 bool GLES2Util::ComputeImageDataSizes(
 421     int width, int height, int format, int type, int unpack_alignment,
 422     uint32* size, uint32* ret_unpadded_row_size, uint32* ret_padded_row_size) {
 423   uint32 bytes_per_group = ComputeImageGroupSize(format, type);
 424   uint32 row_size;
 425   if (!SafeMultiplyUint32(width, bytes_per_group, &row_size)) {
 426     return false;
 427   }
 428   if (height > 1) {
 429     uint32 temp;
 430     if (!SafeAddUint32(row_size, unpack_alignment - 1, &temp)) {
 431       return false;
 432     }
 433     uint32 padded_row_size = (temp / unpack_alignment) * unpack_alignment;
 434     uint32 size_of_all_but_last_row;
 435     if (!SafeMultiplyUint32((height - 1), padded_row_size,
 436                             &size_of_all_but_last_row)) {
 437       return false;
 438     }
 439     if (!SafeAddUint32(size_of_all_but_last_row, row_size, size)) {
 440       return false;
 441     }
 442     if (ret_padded_row_size) {
 443       *ret_padded_row_size = padded_row_size;
 444     }
 445   } else {
 446     if (!SafeMultiplyUint32(height, row_size, size)) {
 447       return false;
 448     }
 449     if (ret_padded_row_size) {
 450       *ret_padded_row_size = row_size;
 451     }
 452   }
 453   if (ret_unpadded_row_size) {
 454     *ret_unpadded_row_size = row_size;
 455   }
 456
 457   return true;
 458 }
 459
 460 size_t GLES2Util::RenderbufferBytesPerPixel(int format) {
 461   switch (format) {
 462     case GL_STENCIL_INDEX8:
 463       return 1;
 464     case GL_RGBA4:
 465     case GL_RGB565:
 466     case GL_RGB5_A1:
 467     case GL_DEPTH_COMPONENT16:
 468       return 2;
 469     case GL_RGB:
 470     case GL_RGBA:
 471     case GL_DEPTH24_STENCIL8_OES:
 472     case GL_RGB8_OES:
 473     case GL_RGBA8_OES:
 474     case GL_DEPTH_COMPONENT24_OES:
 475       return 4;
 476     default:
 477       return 0;
 478   }
 479 }
 480
 481 uint32 GLES2Util::GetGLDataTypeSizeForUniforms(int type) {
 482   switch (type) {
 483     case GL_FLOAT:
 484       return sizeof(GLfloat);              // NOLINT
 485     case GL_FLOAT_VEC2:
 486       return sizeof(GLfloat) * 2;          // NOLINT
 487     case GL_FLOAT_VEC3:
 488       return sizeof(GLfloat) * 3;          // NOLINT
 489     case GL_FLOAT_VEC4:
 490       return sizeof(GLfloat) * 4;          // NOLINT
 491     case GL_INT:
 492       return sizeof(GLint);                // NOLINT
 493     case GL_INT_VEC2:
 494       return sizeof(GLint) * 2;            // NOLINT
 495     case GL_INT_VEC3:
 496       return sizeof(GLint) * 3;            // NOLINT
 497     case GL_INT_VEC4:
 498       return sizeof(GLint) * 4;            // NOLINT
 499     case GL_BOOL:
 500       return sizeof(GLint);                // NOLINT
 501     case GL_BOOL_VEC2:
 502       return sizeof(GLint) * 2;            // NOLINT
 503     case GL_BOOL_VEC3:
 504       return sizeof(GLint) * 3;            // NOLINT
 505     case GL_BOOL_VEC4:
 506       return sizeof(GLint) * 4;            // NOLINT
 507     case GL_FLOAT_MAT2:
 508       return sizeof(GLfloat) * 2 * 2;      // NOLINT
 509     case GL_FLOAT_MAT3:
 510       return sizeof(GLfloat) * 3 * 3;      // NOLINT
 511     case GL_FLOAT_MAT4:
 512       return sizeof(GLfloat) * 4 * 4;      // NOLINT
 513     case GL_SAMPLER_2D:
 514       return sizeof(GLint);                // NOLINT
 515     case GL_SAMPLER_2D_RECT_ARB:
 516       return sizeof(GLint);                // NOLINT
 517     case GL_SAMPLER_CUBE:
 518       return sizeof(GLint);                // NOLINT
 519     case GL_SAMPLER_EXTERNAL_OES:
 520       return sizeof(GLint);                // NOLINT
 521     default:
 522       return 0;
 523   }
 524 }
 525
 526 size_t GLES2Util::GetGLTypeSizeForTexturesAndBuffers(uint32 type) {
 527   switch (type) {
 528     case GL_BYTE:
 529       return sizeof(GLbyte);  // NOLINT
 530     case GL_UNSIGNED_BYTE:
 531       return sizeof(GLubyte);  // NOLINT
 532     case GL_SHORT:
 533       return sizeof(GLshort);  // NOLINT
 534     case GL_UNSIGNED_SHORT:
 535       return sizeof(GLushort);  // NOLINT
 536     case GL_INT:
 537       return sizeof(GLint);  // NOLINT
 538     case GL_UNSIGNED_INT:
 539       return sizeof(GLuint);  // NOLINT
 540     case GL_FLOAT:
 541       return sizeof(GLfloat);  // NOLINT
 542     case GL_FIXED:
 543       return sizeof(GLfixed);  // NOLINT
 544     default:
 545       return 0;
 546   }
 547 }
 548
 549 uint32 GLES2Util::GLErrorToErrorBit(uint32 error) {
 550   switch (error) {
 551     case GL_INVALID_ENUM:
 552       return gl_error_bit::kInvalidEnum;
 553     case GL_INVALID_VALUE:
 554       return gl_error_bit::kInvalidValue;
 555     case GL_INVALID_OPERATION:
 556       return gl_error_bit::kInvalidOperation;
 557     case GL_OUT_OF_MEMORY:
 558       return gl_error_bit::kOutOfMemory;
 559     case GL_INVALID_FRAMEBUFFER_OPERATION:
 560       return gl_error_bit::kInvalidFrameBufferOperation;
 561     default:
 562       NOTREACHED();
 563       return gl_error_bit::kNoError;
 564   }
 565 }
 566
 567 uint32 GLES2Util::GLErrorBitToGLError(uint32 error_bit) {
 568   switch (error_bit) {
 569     case gl_error_bit::kInvalidEnum:
 570       return GL_INVALID_ENUM;
 571     case gl_error_bit::kInvalidValue:
 572       return GL_INVALID_VALUE;
 573     case gl_error_bit::kInvalidOperation:
 574       return GL_INVALID_OPERATION;
 575     case gl_error_bit::kOutOfMemory:
 576       return GL_OUT_OF_MEMORY;
 577     case gl_error_bit::kInvalidFrameBufferOperation:
 578       return GL_INVALID_FRAMEBUFFER_OPERATION;
 579     default:
 580       NOTREACHED();
 581       return GL_NO_ERROR;
 582   }
 583 }
 584
 585 uint32 GLES2Util::IndexToGLFaceTarget(int index) {
 586   static uint32 faces[] = {
 587     GL_TEXTURE_CUBE_MAP_POSITIVE_X,
 588     GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
 589     GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
 590     GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
 591     GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
 592     GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
 593   };
 594   return faces[index];
 595 }
 596
 597 uint32 GLES2Util::GetPreferredGLReadPixelsFormat(uint32 internal_format) {
 598   switch (internal_format) {
 599     case GL_RGB16F_EXT:
 600     case GL_RGB32F_EXT:
 601       return GL_RGB;
 602     case GL_RGBA16F_EXT:
 603     case GL_RGBA32F_EXT:
 604       return GL_RGBA;
 605     default:
 606       return GL_RGBA;
 607   }
 608 }
 609
 610 uint32 GLES2Util::GetPreferredGLReadPixelsType(
 611     uint32 internal_format, uint32 texture_type) {
 612   switch (internal_format) {
 613     case GL_RGBA32F_EXT:
 614     case GL_RGB32F_EXT:
 615       return GL_FLOAT;
 616     case GL_RGBA16F_EXT:
 617     case GL_RGB16F_EXT:
 618       return GL_HALF_FLOAT_OES;
 619     case GL_RGBA:
 620     case GL_RGB:
 621       // Unsized internal format, check the type
 622       switch (texture_type) {
 623         case GL_FLOAT:
 624         case GL_HALF_FLOAT_OES:
 625           return GL_FLOAT;
 626         default:
 627           return GL_UNSIGNED_BYTE;
 628       }
 629     default:
 630       return GL_UNSIGNED_BYTE;
 631   }
 632 }
 633
 634 uint32 GLES2Util::GetChannelsForFormat(int format) {
 635   switch (format) {
 636     case GL_ALPHA:
 637     case GL_ALPHA16F_EXT:
 638     case GL_ALPHA32F_EXT:
 639       return kAlpha;
 640     case GL_LUMINANCE:
 641       return kRGB;
 642     case GL_LUMINANCE_ALPHA:
 643       return kRGBA;
 644     case GL_RGB:
 645     case GL_RGB8_OES:
 646     case GL_RGB565:
 647     case GL_RGB16F_EXT:
 648     case GL_RGB32F_EXT:
 649       return kRGB;
 650     case GL_BGRA_EXT:
 651     case GL_BGRA8_EXT:
 652     case GL_RGBA16F_EXT:
 653     case GL_RGBA32F_EXT:
 654     case GL_RGBA:
 655     case GL_RGBA8_OES:
 656     case GL_RGBA4:
 657     case GL_RGB5_A1:
 658       return kRGBA;
 659     case GL_DEPTH_COMPONENT32_OES:
 660     case GL_DEPTH_COMPONENT24_OES:
 661     case GL_DEPTH_COMPONENT16:
 662     case GL_DEPTH_COMPONENT:
 663       return kDepth;
 664     case GL_STENCIL_INDEX8:
 665       return kStencil;
 666     case GL_DEPTH_STENCIL_OES:
 667     case GL_DEPTH24_STENCIL8_OES:
 668       return kDepth | kStencil;
 669     default:
 670       return 0x0000;
 671   }
 672 }
 673
 674 uint32 GLES2Util::GetChannelsNeededForAttachmentType(
 675     int type, uint32 max_color_attachments) {
 676   switch (type) {
 677     case GL_DEPTH_ATTACHMENT:
 678       return kDepth;
 679     case GL_STENCIL_ATTACHMENT:
 680       return kStencil;
 681     default:
 682       if (type >= GL_COLOR_ATTACHMENT0 &&
 683           type < static_cast<int>(
 684               GL_COLOR_ATTACHMENT0 + max_color_attachments)) {
 685         return kRGBA;
 686       }
 687       return 0x0000;
 688   }
 689 }
 690
 691 std::string GLES2Util::GetStringEnum(uint32 value) {
 692   const EnumToString* entry = enum_to_string_table_;
 693   const EnumToString* end = entry + enum_to_string_table_len_;
 694   for (;entry < end; ++entry) {
 695     if (value == entry->value) {
 696       return entry->name;
 697     }
 698   }
 699   std::stringstream ss;
 700   ss.fill('0');
 701   ss.width(value < 0x10000 ? 4 : 8);
 702   ss << std::hex << value;
 703   return "0x" + ss.str();
 704 }
 705
 706 std::string GLES2Util::GetStringError(uint32 value) {
 707   static EnumToString string_table[] = {
 708     { GL_NONE, "GL_NONE" },
 709   };
 710   return GLES2Util::GetQualifiedEnumString(
 711       string_table, arraysize(string_table), value);
 712 }
 713
 714 std::string GLES2Util::GetStringBool(uint32 value) {
 715   return value ? "GL_TRUE" : "GL_FALSE";
 716 }
 717
 718 std::string GLES2Util::GetQualifiedEnumString(
 719     const EnumToString* table, size_t count, uint32 value) {
 720   for (const EnumToString* end = table + count; table < end; ++table) {
 721     if (table->value == value) {
 722       return table->name;
 723     }
 724   }
 725   return GetStringEnum(value);
 726 }
 727
 728 bool GLES2Util::ParseUniformName(
 729     const std::string& name,
 730     size_t* array_pos,
 731     int* element_index,
 732     bool* getting_array) {
 733   bool getting_array_location = false;
 734   size_t open_pos = std::string::npos;
 735   int index = 0;
 736   if (name[name.size() - 1] == ']') {
 737     if (name.size() < 3) {
 738       return false;
 739     }
 740     open_pos = name.find_last_of('[');
 741     if (open_pos == std::string::npos ||
 742         open_pos >= name.size() - 2) {
 743       return false;
 744     }
 745     size_t last = name.size() - 1;
 746     for (size_t pos = open_pos + 1; pos < last; ++pos) {
 747       int8 digit = name[pos] - '0';
 748       if (digit < 0 || digit > 9) {
 749         return false;
 750       }
 751       index = index * 10 + digit;
 752     }
 753     getting_array_location = true;
 754   }
 755   *getting_array = getting_array_location;
 756   *element_index = index;
 757   *array_pos = open_pos;
 758   return true;
 759 }
 760
 761 namespace {
 762
 763 // From <EGL/egl.h>.
 764 const int32 kAlphaSize       = 0x3021;  // EGL_ALPHA_SIZE
 765 const int32 kBlueSize        = 0x3022;  // EGL_BLUE_SIZE
 766 const int32 kGreenSize       = 0x3023;  // EGL_GREEN_SIZE
 767 const int32 kRedSize         = 0x3024;  // EGL_RED_SIZE
 768 const int32 kDepthSize       = 0x3025;  // EGL_DEPTH_SIZE
 769 const int32 kStencilSize     = 0x3026;  // EGL_STENCIL_SIZE
 770 const int32 kSamples         = 0x3031;  // EGL_SAMPLES
 771 const int32 kSampleBuffers   = 0x3032;  // EGL_SAMPLE_BUFFERS
 772 const int32 kNone            = 0x3038;  // EGL_NONE
 773 const int32 kSwapBehavior    = 0x3093;  // EGL_SWAP_BEHAVIOR
 774 const int32 kBufferPreserved = 0x3094;  // EGL_BUFFER_PRESERVED
 775 const int32 kBufferDestroyed = 0x3095;  // EGL_BUFFER_DESTROYED
 776
 777 // Chromium only.
 778 const int32 kShareResources        = 0x10000;
 779 const int32 kBindGeneratesResource = 0x10001;
 780 const int32 kFailIfMajorPerfCaveat = 0x10002;
 781 const int32 kLoseContextWhenOutOfMemory = 0x10003;
 782
 783 }  // namespace
 784
 785 ContextCreationAttribHelper::ContextCreationAttribHelper()
 786     : alpha_size_(-1),
 787       blue_size_(-1),
 788       green_size_(-1),
 789       red_size_(-1),
 790       depth_size_(-1),
 791       stencil_size_(-1),
 792       samples_(-1),
 793       sample_buffers_(-1),
 794       buffer_preserved_(true),
 795       share_resources_(false),
 796       bind_generates_resource_(true),
 797       fail_if_major_perf_caveat_(false),
 798       lose_context_when_out_of_memory_(false) {}
 799
 800 void ContextCreationAttribHelper::Serialize(std::vector<int32>* attribs) {
 801   if (alpha_size_ != -1) {
 802     attribs->push_back(kAlphaSize);
 803     attribs->push_back(alpha_size_);
 804   }
 805   if (blue_size_ != -1) {
 806     attribs->push_back(kBlueSize);
 807     attribs->push_back(blue_size_);
 808   }
 809   if (green_size_ != -1) {
 810     attribs->push_back(kGreenSize);
 811     attribs->push_back(green_size_);
 812   }
 813   if (red_size_ != -1) {
 814     attribs->push_back(kRedSize);
 815     attribs->push_back(red_size_);
 816   }
 817   if (depth_size_ != -1) {
 818     attribs->push_back(kDepthSize);
 819     attribs->push_back(depth_size_);
 820   }
 821   if (stencil_size_ != -1) {
 822     attribs->push_back(kStencilSize);
 823     attribs->push_back(stencil_size_);
 824   }
 825   if (samples_ != -1) {
 826     attribs->push_back(kSamples);
 827     attribs->push_back(samples_);
 828   }
 829   if (sample_buffers_ != -1) {
 830     attribs->push_back(kSampleBuffers);
 831     attribs->push_back(sample_buffers_);
 832   }
 833   attribs->push_back(kSwapBehavior);
 834   attribs->push_back(buffer_preserved_ ? kBufferPreserved : kBufferDestroyed);
 835   attribs->push_back(kShareResources);
 836   attribs->push_back(share_resources_ ? 1 : 0);
 837   attribs->push_back(kBindGeneratesResource);
 838   attribs->push_back(bind_generates_resource_ ? 1 : 0);
 839   attribs->push_back(kFailIfMajorPerfCaveat);
 840   attribs->push_back(fail_if_major_perf_caveat_ ? 1 : 0);
 841   attribs->push_back(kLoseContextWhenOutOfMemory);
 842   attribs->push_back(lose_context_when_out_of_memory_ ? 1 : 0);
 843   attribs->push_back(kNone);
 844 }
 845
 846 bool ContextCreationAttribHelper::Parse(const std::vector<int32>& attribs) {
 847   for (size_t i = 0; i < attribs.size(); i += 2) {
 848     const int32 attrib = attribs[i];
 849     if (i + 1 >= attribs.size()) {
 850       if (attrib == kNone) {
 851         return true;
 852       }
 853
 854       DLOG(ERROR) << "Missing value after context creation attribute: "
 855                   << attrib;
 856       return false;
 857     }
 858
 859     const int32 value = attribs[i+1];
 860     switch (attrib) {
 861       case kAlphaSize:
 862         alpha_size_ = value;
 863         break;
 864       case kBlueSize:
 865         blue_size_ = value;
 866         break;
 867       case kGreenSize:
 868         green_size_ = value;
 869         break;
 870       case kRedSize:
 871         red_size_ = value;
 872         break;
 873       case kDepthSize:
 874         depth_size_ = value;
 875         break;
 876       case kStencilSize:
 877         stencil_size_ = value;
 878         break;
 879       case kSamples:
 880         samples_ = value;
 881         break;
 882       case kSampleBuffers:
 883         sample_buffers_ = value;
 884         break;
 885       case kSwapBehavior:
 886         buffer_preserved_ = value == kBufferPreserved;
 887         break;
 888       case kShareResources:
 889         share_resources_ = value != 0;
 890         break;
 891       case kBindGeneratesResource:
 892         bind_generates_resource_ = value != 0;
 893         break;
 894       case kFailIfMajorPerfCaveat:
 895         fail_if_major_perf_caveat_ = value != 0;
 896         break;
 897       case kLoseContextWhenOutOfMemory:
 898         lose_context_when_out_of_memory_ = value != 0;
 899         break;
 900       case kNone:
 901         // Terminate list, even if more attributes.
 902         return true;
 903       default:
 904         DLOG(ERROR) << "Invalid context creation attribute: " << attrib;
 905         return false;
 906     }
 907   }
 908
 909   return true;
 910 }
 911
 912 #include "gpu/command_buffer/common/gles2_cmd_utils_implementation_autogen.h"
 913
 914 }  // namespace gles2
 915 }  // namespace gpu
 916