src/gpu/gl/GrGLCaps.cpp

   1 /*
   2  * Copyright 2012 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "GrGLCaps.h"
   9 #include "GrContextOptions.h"
  10 #include "GrGLContext.h"
  11 #include "GrGLRenderTarget.h"
  12 #include "GrGLTexture.h"
  13 #include "GrShaderCaps.h"
  14 #include "GrSurfaceProxyPriv.h"
  15 #include "SkTSearch.h"
  16 #include "SkTSort.h"
  17 #include "instanced/GLInstancedRendering.h"
  18
  19 GrGLCaps::GrGLCaps(const GrContextOptions& contextOptions,
  20                    const GrGLContextInfo& ctxInfo,
  21                    const GrGLInterface* glInterface) : INHERITED(contextOptions) {
  22     fStandard = ctxInfo.standard();
  23
  24     fStencilFormats.reset();
  25     fMSFBOType = kNone_MSFBOType;
  26     fInvalidateFBType = kNone_InvalidateFBType;
  27     fMapBufferType = kNone_MapBufferType;
  28     fTransferBufferType = kNone_TransferBufferType;
  29     fMaxFragmentUniformVectors = 0;
  30     fUnpackRowLengthSupport = false;
  31     fUnpackFlipYSupport = false;
  32     fPackRowLengthSupport = false;
  33     fPackFlipYSupport = false;
  34     fTextureUsageSupport = false;
  35     fTextureRedSupport = false;
  36     fImagingSupport = false;
  37     fVertexArrayObjectSupport = false;
  38     fDirectStateAccessSupport = false;
  39     fDebugSupport = false;
  40     fES2CompatibilitySupport = false;
  41     fDrawInstancedSupport = false;
  42     fDrawIndirectSupport = false;
  43     fMultiDrawIndirectSupport = false;
  44     fBaseInstanceSupport = false;
  45     fIsCoreProfile = false;
  46     fBindFragDataLocationSupport = false;
  47     fRectangleTextureSupport = false;
  48     fTextureSwizzleSupport = false;
  49     fRGBA8888PixelsOpsAreSlow = false;
  50     fPartialFBOReadIsSlow = false;
  51     fMipMapLevelAndLodControlSupport = false;
  52     fRGBAToBGRAReadbackConversionsAreSlow = false;
  53     fDoManualMipmapping = false;
  54     fSRGBDecodeDisableSupport = false;
  55     fSRGBDecodeDisableAffectsMipmaps = false;
  56     fClearToBoundaryValuesIsBroken = false;
  57     fDrawArraysBaseVertexIsBroken = false;
  58
  59     fBlitFramebufferFlags = kNoSupport_BlitFramebufferFlag;
  60
  61     fShaderCaps.reset(new GrShaderCaps(contextOptions));
  62
  63     this->init(contextOptions, ctxInfo, glInterface);
  64 }
  65
  66 void GrGLCaps::init(const GrContextOptions& contextOptions,
  67                     const GrGLContextInfo& ctxInfo,
  68                     const GrGLInterface* gli) {
  69     GrGLStandard standard = ctxInfo.standard();
  70     GrGLVersion version = ctxInfo.version();
  71
  72     /**************************************************************************
  73      * Caps specific to GrGLCaps
  74      **************************************************************************/
  75
  76     if (kGLES_GrGLStandard == standard) {
  77         GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
  78                           &fMaxFragmentUniformVectors);
  79     } else {
  80         SkASSERT(kGL_GrGLStandard == standard);
  81         GrGLint max;
  82         GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
  83         fMaxFragmentUniformVectors = max / 4;
  84         if (version >= GR_GL_VER(3, 2)) {
  85             GrGLint profileMask;
  86             GR_GL_GetIntegerv(gli, GR_GL_CONTEXT_PROFILE_MASK, &profileMask);
  87             fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT);
  88         }
  89     }
  90     GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes);
  91
  92     if (kGL_GrGLStandard == standard) {
  93         fUnpackRowLengthSupport = true;
  94         fUnpackFlipYSupport = false;
  95         fPackRowLengthSupport = true;
  96         fPackFlipYSupport = false;
  97     } else {
  98         fUnpackRowLengthSupport = version >= GR_GL_VER(3,0) ||
  99                                   ctxInfo.hasExtension("GL_EXT_unpack_subimage");
 100         fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy");
 101         fPackRowLengthSupport = version >= GR_GL_VER(3,0) ||
 102                                 ctxInfo.hasExtension("GL_NV_pack_subimage");
 103         fPackFlipYSupport =
 104             ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order");
 105     }
 106
 107     fTextureUsageSupport = (kGLES_GrGLStandard == standard) &&
 108                             ctxInfo.hasExtension("GL_ANGLE_texture_usage");
 109
 110     if (kGL_GrGLStandard == standard) {
 111         fTextureBarrierSupport = version >= GR_GL_VER(4,5) ||
 112                                  ctxInfo.hasExtension("GL_ARB_texture_barrier") ||
 113                                  ctxInfo.hasExtension("GL_NV_texture_barrier");
 114     } else {
 115         fTextureBarrierSupport = ctxInfo.hasExtension("GL_NV_texture_barrier");
 116     }
 117
 118     if (kGL_GrGLStandard == standard) {
 119         fSampleLocationsSupport = version >= GR_GL_VER(3,2) ||
 120                                   ctxInfo.hasExtension("GL_ARB_texture_multisample");
 121     } else {
 122         fSampleLocationsSupport = version >= GR_GL_VER(3,1);
 123     }
 124
 125     // ARB_texture_rg is part of OpenGL 3.0, but osmesa doesn't support GL_RED
 126     // and GL_RG on FBO textures.
 127     if (kOSMesa_GrGLRenderer != ctxInfo.renderer()) {
 128         if (kGL_GrGLStandard == standard) {
 129             fTextureRedSupport = version >= GR_GL_VER(3,0) ||
 130                                  ctxInfo.hasExtension("GL_ARB_texture_rg");
 131         } else {
 132             fTextureRedSupport =  version >= GR_GL_VER(3,0) ||
 133                                   ctxInfo.hasExtension("GL_EXT_texture_rg");
 134         }
 135     }
 136     fImagingSupport = kGL_GrGLStandard == standard &&
 137                       ctxInfo.hasExtension("GL_ARB_imaging");
 138
 139     // A driver but on the nexus 6 causes incorrect dst copies when invalidate is called beforehand.
 140     // Thus we are blacklisting this extension for now on Adreno4xx devices.
 141     if (kAdreno4xx_GrGLRenderer != ctxInfo.renderer() &&
 142         ((kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) ||
 143          (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0)) ||
 144          ctxInfo.hasExtension("GL_ARB_invalidate_subdata"))) {
 145         fDiscardRenderTargetSupport = true;
 146         fInvalidateFBType = kInvalidate_InvalidateFBType;
 147     } else if (ctxInfo.hasExtension("GL_EXT_discard_framebuffer")) {
 148         fDiscardRenderTargetSupport = true;
 149         fInvalidateFBType = kDiscard_InvalidateFBType;
 150     }
 151
 152     if (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor()) {
 153         fFullClearIsFree = true;
 154     }
 155
 156     if (kGL_GrGLStandard == standard) {
 157         fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
 158                                     ctxInfo.hasExtension("GL_ARB_vertex_array_object") ||
 159                                     ctxInfo.hasExtension("GL_APPLE_vertex_array_object");
 160     } else {
 161         fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
 162                                     ctxInfo.hasExtension("GL_OES_vertex_array_object");
 163     }
 164
 165     if (kGL_GrGLStandard == standard) {
 166         fDirectStateAccessSupport = ctxInfo.hasExtension("GL_EXT_direct_state_access");
 167     } else {
 168         fDirectStateAccessSupport = false;
 169     }
 170
 171     if (kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) {
 172         fDebugSupport = true;
 173     } else {
 174         fDebugSupport = ctxInfo.hasExtension("GL_KHR_debug");
 175     }
 176
 177     if (kGL_GrGLStandard == standard) {
 178         fES2CompatibilitySupport = ctxInfo.hasExtension("GL_ARB_ES2_compatibility");
 179     }
 180     else {
 181         fES2CompatibilitySupport = true;
 182     }
 183
 184     if (kGL_GrGLStandard == standard) {
 185         fMultisampleDisableSupport = true;
 186     } else {
 187         fMultisampleDisableSupport = ctxInfo.hasExtension("GL_EXT_multisample_compatibility");
 188     }
 189
 190     if (kGL_GrGLStandard == standard) {
 191         if (version >= GR_GL_VER(3, 0)) {
 192             fBindFragDataLocationSupport = true;
 193         }
 194     } else {
 195         if (version >= GR_GL_VER(3, 0) && ctxInfo.hasExtension("GL_EXT_blend_func_extended")) {
 196             fBindFragDataLocationSupport = true;
 197         }
 198     }
 199
 200     fBindUniformLocationSupport = ctxInfo.hasExtension("GL_CHROMIUM_bind_uniform_location");
 201
 202     if (kGL_GrGLStandard == standard) {
 203         if (version >= GR_GL_VER(3, 1) || ctxInfo.hasExtension("GL_ARB_texture_rectangle")) {
 204             // We also require textureSize() support for rectangle 2D samplers which was added in
 205             // GLSL 1.40.
 206             if (ctxInfo.glslGeneration() >= k140_GrGLSLGeneration) {
 207                 fRectangleTextureSupport = true;
 208             }
 209         }
 210     } else {
 211         // Command buffer exposes this in GL ES context for Chromium reasons,
 212         // but it should not be used. Also, at the time of writing command buffer
 213         // lacks TexImage2D support and ANGLE lacks GL ES 3.0 support.
 214     }
 215
 216     if (kGL_GrGLStandard == standard) {
 217         if (version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle")) {
 218             fTextureSwizzleSupport = true;
 219         }
 220     } else {
 221         if (version >= GR_GL_VER(3,0)) {
 222             fTextureSwizzleSupport = true;
 223         }
 224     }
 225
 226     if (kGL_GrGLStandard == standard) {
 227         fMipMapLevelAndLodControlSupport = true;
 228     } else if (kGLES_GrGLStandard == standard) {
 229         if (version >= GR_GL_VER(3,0)) {
 230             fMipMapLevelAndLodControlSupport = true;
 231         }
 232     }
 233
 234 #ifdef SK_BUILD_FOR_WIN
 235     // We're assuming that on Windows Chromium we're using ANGLE.
 236     bool isANGLE = kANGLE_GrGLDriver == ctxInfo.driver() ||
 237                    kChromium_GrGLDriver == ctxInfo.driver();
 238     // Angle has slow read/write pixel paths for 32bit RGBA (but fast for BGRA).
 239     fRGBA8888PixelsOpsAreSlow = isANGLE;
 240     // On DX9 ANGLE reading a partial FBO is slow. TODO: Check whether this is still true and
 241     // check DX11 ANGLE.
 242     fPartialFBOReadIsSlow = isANGLE;
 243 #endif
 244
 245     bool isMESA = kMesa_GrGLDriver == ctxInfo.driver();
 246     bool isMAC = false;
 247 #ifdef SK_BUILD_FOR_MAC
 248     isMAC = true;
 249 #endif
 250
 251     // Both mesa and mac have reduced performance if reading back an RGBA framebuffer as BGRA or
 252     // vis-versa.
 253     fRGBAToBGRAReadbackConversionsAreSlow = isMESA || isMAC;
 254
 255     /**************************************************************************
 256     * GrShaderCaps fields
 257     **************************************************************************/
 258
 259     // This must be called after fCoreProfile is set on the GrGLCaps
 260     this->initGLSL(ctxInfo);
 261     GrShaderCaps* shaderCaps = fShaderCaps.get();
 262
 263     if (!contextOptions.fSuppressPathRendering) {
 264         shaderCaps->fPathRenderingSupport = this->hasPathRenderingSupport(ctxInfo, gli);
 265     }
 266
 267     // For now these two are equivalent but we could have dst read in shader via some other method.
 268     // Before setting this, initGLSL() must have been called.
 269     shaderCaps->fDstReadInShaderSupport = shaderCaps->fFBFetchSupport;
 270
 271     // Enable supported shader-related caps
 272     if (kGL_GrGLStandard == standard) {
 273         shaderCaps->fDualSourceBlendingSupport = (ctxInfo.version() >= GR_GL_VER(3, 3) ||
 274             ctxInfo.hasExtension("GL_ARB_blend_func_extended")) &&
 275             GrGLSLSupportsNamedFragmentShaderOutputs(ctxInfo.glslGeneration());
 276         shaderCaps->fShaderDerivativeSupport = true;
 277         // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
 278         shaderCaps->fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3, 2) &&
 279             ctxInfo.glslGeneration() >= k150_GrGLSLGeneration;
 280         shaderCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) &&
 281             ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
 282     }
 283     else {
 284         shaderCaps->fDualSourceBlendingSupport = ctxInfo.hasExtension("GL_EXT_blend_func_extended");
 285
 286         shaderCaps->fShaderDerivativeSupport = ctxInfo.version() >= GR_GL_VER(3, 0) ||
 287             ctxInfo.hasExtension("GL_OES_standard_derivatives");
 288
 289         shaderCaps->fGeometryShaderSupport = ctxInfo.hasExtension("GL_EXT_geometry_shader");
 290
 291         shaderCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) &&
 292             ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0.
 293     }
 294
 295     // Protect ourselves against tracking huge amounts of texture state.
 296     static const uint8_t kMaxSaneSamplers = 32;
 297     GrGLint maxSamplers;
 298     GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxSamplers);
 299     shaderCaps->fMaxVertexSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
 300     if (shaderCaps->fGeometryShaderSupport) {
 301         GR_GL_GetIntegerv(gli, GR_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &maxSamplers);
 302         shaderCaps->fMaxGeometrySamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
 303     }
 304     GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxSamplers);
 305     shaderCaps->fMaxFragmentSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
 306     GR_GL_GetIntegerv(gli, GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxSamplers);
 307     shaderCaps->fMaxCombinedSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
 308
 309     if (kGL_GrGLStandard == standard) {
 310         shaderCaps->fImageLoadStoreSupport = ctxInfo.version() >= GR_GL_VER(4, 2);
 311         if (!shaderCaps->fImageLoadStoreSupport &&
 312             ctxInfo.hasExtension("GL_ARB_shader_image_load_store")) {
 313             shaderCaps->fImageLoadStoreSupport = true;
 314             shaderCaps->fImageLoadStoreExtensionString = "GL_ARB_shader_image_load_store";
 315         }
 316     } else {
 317         shaderCaps->fImageLoadStoreSupport = ctxInfo.version() >= GR_GL_VER(3, 1);
 318     }
 319     if (shaderCaps->fImageLoadStoreSupport) {
 320         // Protect ourselves against tracking huge amounts of image state.
 321         static constexpr int kMaxSaneImages = 4;
 322         GrGLint maxUnits;
 323         GR_GL_GetIntegerv(gli, GR_GL_MAX_IMAGE_UNITS, &maxUnits);
 324         GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_IMAGE_UNIFORMS,
 325                           &shaderCaps->fMaxVertexImageStorages);
 326         if (shaderCaps->fGeometryShaderSupport) {
 327             GR_GL_GetIntegerv(gli, GR_GL_MAX_GEOMETRY_IMAGE_UNIFORMS,
 328                               &shaderCaps->fMaxGeometryImageStorages);
 329         }
 330         GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_IMAGE_UNIFORMS,
 331                           &shaderCaps->fMaxFragmentImageStorages);
 332         GR_GL_GetIntegerv(gli, GR_GL_MAX_COMBINED_IMAGE_UNIFORMS,
 333                           &shaderCaps->fMaxCombinedImageStorages);
 334         // We use one unit for every image uniform
 335         shaderCaps->fMaxCombinedImageStorages = SkTMin(SkTMin(shaderCaps->fMaxCombinedImageStorages,
 336                                                               maxUnits), kMaxSaneImages);
 337         shaderCaps->fMaxVertexImageStorages = SkTMin(maxUnits,
 338                                                      shaderCaps->fMaxVertexImageStorages);
 339         shaderCaps->fMaxGeometryImageStorages = SkTMin(maxUnits,
 340                                                        shaderCaps->fMaxGeometryImageStorages);
 341         shaderCaps->fMaxFragmentImageStorages =  SkTMin(maxUnits,
 342                                                         shaderCaps->fMaxFragmentImageStorages);
 343     }
 344
 345     /**************************************************************************
 346      * GrCaps fields
 347      **************************************************************************/
 348
 349     // SGX and Mali GPUs that are based on a tiled-deferred architecture that have trouble with
 350     // frequently changing VBOs. We've measured a performance increase using non-VBO vertex
 351     // data for dynamic content on these GPUs. Perhaps we should read the renderer string and
 352     // limit this decision to specific GPU families rather than basing it on the vendor alone.
 353     if (!GR_GL_MUST_USE_VBO &&
 354         !fIsCoreProfile &&
 355         (kARM_GrGLVendor == ctxInfo.vendor() ||
 356          kImagination_GrGLVendor == ctxInfo.vendor() ||
 357          kQualcomm_GrGLVendor == ctxInfo.vendor())) {
 358         fPreferClientSideDynamicBuffers = true;
 359     }
 360
 361     if (!contextOptions.fAvoidStencilBuffers) {
 362         // To reduce surface area, if we avoid stencil buffers, we also disable MSAA.
 363         this->initFSAASupport(contextOptions, ctxInfo, gli);
 364         this->initStencilSupport(ctxInfo);
 365     }
 366     this->initBlendEqationSupport(ctxInfo);
 367
 368     if (kGL_GrGLStandard == standard) {
 369         fMapBufferFlags = kCanMap_MapFlag; // we require VBO support and the desktop VBO
 370                                             // extension includes glMapBuffer.
 371         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_map_buffer_range")) {
 372             fMapBufferFlags |= kSubset_MapFlag;
 373             fMapBufferType = kMapBufferRange_MapBufferType;
 374         } else {
 375             fMapBufferType = kMapBuffer_MapBufferType;
 376         }
 377     } else {
 378         // Unextended GLES2 doesn't have any buffer mapping.
 379         fMapBufferFlags = kNone_MapBufferType;
 380         if (ctxInfo.hasExtension("GL_CHROMIUM_map_sub")) {
 381             fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag;
 382             fMapBufferType = kChromium_MapBufferType;
 383         } else if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_EXT_map_buffer_range")) {
 384             fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag;
 385             fMapBufferType = kMapBufferRange_MapBufferType;
 386         } else if (ctxInfo.hasExtension("GL_OES_mapbuffer")) {
 387             fMapBufferFlags = kCanMap_MapFlag;
 388             fMapBufferType = kMapBuffer_MapBufferType;
 389         }
 390     }
 391
 392     if (kGL_GrGLStandard == standard) {
 393         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_pixel_buffer_object")) {
 394             fTransferBufferType = kPBO_TransferBufferType;
 395         }
 396     } else {
 397         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_NV_pixel_buffer_object")) {
 398             fTransferBufferType = kPBO_TransferBufferType;
 399         } else if (ctxInfo.hasExtension("GL_CHROMIUM_pixel_transfer_buffer_object")) {
 400             fTransferBufferType = kChromium_TransferBufferType;
 401         }
 402     }
 403
 404     // On many GPUs, map memory is very expensive, so we effectively disable it here by setting the
 405     // threshold to the maximum unless the client gives us a hint that map memory is cheap.
 406     if (fBufferMapThreshold < 0) {
 407 #if 0
 408         // We think mapping on Chromium will be cheaper once we know ahead of time how much space
 409         // we will use for all GrMeshDrawOps. Right now we might wind up mapping a large buffer and
 410         // using a small subset.
 411         fBufferMapThreshold = kChromium_GrGLDriver == ctxInfo.driver() ? 0 : SK_MaxS32;
 412 #else
 413         fBufferMapThreshold = SK_MaxS32;
 414 #endif
 415     }
 416
 417     if (kGL_GrGLStandard == standard) {
 418         fNPOTTextureTileSupport = true;
 419         fMipMapSupport = true;
 420     } else {
 421         // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only
 422         // ES3 has no limitations.
 423         fNPOTTextureTileSupport = ctxInfo.version() >= GR_GL_VER(3,0) ||
 424                                   ctxInfo.hasExtension("GL_OES_texture_npot");
 425         // ES2 supports MIP mapping for POT textures but our caps don't allow for limited MIP
 426         // support. The OES extension or ES 3.0 allow for MIPS on NPOT textures. So, apparently,
 427         // does the undocumented GL_IMG_texture_npot extension. This extension does not seem to
 428         // to alllow arbitrary wrap modes, however.
 429         fMipMapSupport = fNPOTTextureTileSupport || ctxInfo.hasExtension("GL_IMG_texture_npot");
 430     }
 431
 432     // Using MIPs on this GPU seems to be a source of trouble.
 433     if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer()) {
 434         fMipMapSupport = false;
 435     }
 436
 437     GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize);
 438     GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize);
 439     // Our render targets are always created with textures as the color
 440     // attachment, hence this min:
 441     fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize);
 442
 443     fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker");
 444
 445     // Disable scratch texture reuse on Mali and Adreno devices
 446     fReuseScratchTextures = kARM_GrGLVendor != ctxInfo.vendor();
 447
 448 #if 0
 449     fReuseScratchBuffers = kARM_GrGLVendor != ctxInfo.vendor() &&
 450                            kQualcomm_GrGLVendor != ctxInfo.vendor();
 451 #endif
 452
 453     if (ctxInfo.hasExtension("GL_EXT_window_rectangles")) {
 454         GR_GL_GetIntegerv(gli, GR_GL_MAX_WINDOW_RECTANGLES, &fMaxWindowRectangles);
 455     }
 456
 457     if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer() ||
 458         kPowerVRRogue_GrGLRenderer == ctxInfo.renderer() ||
 459         (kAdreno3xx_GrGLRenderer == ctxInfo.renderer() &&
 460          ctxInfo.driver() != kChromium_GrGLDriver)) {
 461         fUseDrawInsteadOfClear = true;
 462     }
 463
 464     if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer()) {
 465         fUseDrawInsteadOfPartialRenderTargetWrite = true;
 466     }
 467
 468     // Texture uploads sometimes seem to be ignored to textures bound to FBOS on Tegra3.
 469     if (kTegra3_GrGLRenderer == ctxInfo.renderer()) {
 470         fUseDrawInsteadOfPartialRenderTargetWrite = true;
 471         fUseDrawInsteadOfAllRenderTargetWrites = true;
 472     }
 473
 474 #ifdef SK_BUILD_FOR_WIN
 475     // On ANGLE deferring flushes can lead to GPU starvation
 476     fPreferVRAMUseOverFlushes = !isANGLE;
 477 #endif
 478
 479     if (kChromium_GrGLDriver == ctxInfo.driver()) {
 480         fMustClearUploadedBufferData = true;
 481     }
 482
 483     if (kGL_GrGLStandard == standard) {
 484         // ARB allows mixed size FBO attachments, EXT does not.
 485         if (ctxInfo.version() >= GR_GL_VER(3, 0) ||
 486             ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
 487             fOversizedStencilSupport = true;
 488         } else {
 489             SkASSERT(ctxInfo.hasExtension("GL_EXT_framebuffer_object"));
 490         }
 491     } else {
 492         // ES 3.0 supports mixed size FBO attachments, 2.0 does not.
 493         fOversizedStencilSupport = ctxInfo.version() >= GR_GL_VER(3, 0);
 494     }
 495
 496     if (kGL_GrGLStandard == standard) {
 497         // 3.1 has draw_instanced but not instanced_arrays, for the time being we only care about
 498         // instanced arrays, but we could make this more granular if we wanted
 499         fDrawInstancedSupport =
 500                 version >= GR_GL_VER(3, 2) ||
 501                 (ctxInfo.hasExtension("GL_ARB_draw_instanced") &&
 502                  ctxInfo.hasExtension("GL_ARB_instanced_arrays"));
 503     } else {
 504         fDrawInstancedSupport =
 505                 version >= GR_GL_VER(3, 0) ||
 506                 (ctxInfo.hasExtension("GL_EXT_draw_instanced") &&
 507                  ctxInfo.hasExtension("GL_EXT_instanced_arrays"));
 508     }
 509
 510     if (kGL_GrGLStandard == standard) {
 511         fDrawIndirectSupport = version >= GR_GL_VER(4,0) ||
 512                                ctxInfo.hasExtension("GL_ARB_draw_indirect");
 513         fBaseInstanceSupport = version >= GR_GL_VER(4,2);
 514         fMultiDrawIndirectSupport = version >= GR_GL_VER(4,3) ||
 515                                     (fDrawIndirectSupport &&
 516                                      !fBaseInstanceSupport && // The ARB extension has no base inst.
 517                                      ctxInfo.hasExtension("GL_ARB_multi_draw_indirect"));
 518         fDrawRangeElementsSupport = version >= GR_GL_VER(2,0);
 519     } else {
 520         fDrawIndirectSupport = version >= GR_GL_VER(3,1);
 521         fMultiDrawIndirectSupport = fDrawIndirectSupport &&
 522                                     ctxInfo.hasExtension("GL_EXT_multi_draw_indirect");
 523         fBaseInstanceSupport = fDrawIndirectSupport &&
 524                                ctxInfo.hasExtension("GL_EXT_base_instance");
 525         fDrawRangeElementsSupport = version >= GR_GL_VER(3,0);
 526     }
 527
 528     this->initShaderPrecisionTable(ctxInfo, gli, shaderCaps);
 529
 530     if (contextOptions.fUseShaderSwizzling) {
 531         fTextureSwizzleSupport = false;
 532     }
 533
 534     if (kGL_GrGLStandard == standard) {
 535         if ((version >= GR_GL_VER(4, 0) || ctxInfo.hasExtension("GL_ARB_sample_shading")) &&
 536             ctxInfo.vendor() != kIntel_GrGLVendor) {
 537             fSampleShadingSupport = true;
 538         }
 539     } else if (ctxInfo.hasExtension("GL_OES_sample_shading")) {
 540         fSampleShadingSupport = true;
 541     }
 542
 543     // TODO: support CHROMIUM_sync_point and maybe KHR_fence_sync
 544     if (kGL_GrGLStandard == standard) {
 545         if (version >= GR_GL_VER(3, 2) || ctxInfo.hasExtension("GL_ARB_sync")) {
 546             fFenceSyncSupport = true;
 547         }
 548     } else if (version >= GR_GL_VER(3, 0)) {
 549         fFenceSyncSupport = true;
 550     }
 551
 552     // Safely moving textures between contexts requires fences.
 553     fCrossContextTextureSupport = fFenceSyncSupport;
 554
 555     // We support manual mip-map generation (via iterative downsampling draw calls). This fixes
 556     // bugs on some cards/drivers that produce incorrect mip-maps for sRGB textures when using
 557     // glGenerateMipmap. Our implementation requires mip-level sampling control. Additionally,
 558     // it can be much slower (especially on mobile GPUs), so we opt-in only when necessary:
 559     if (fMipMapLevelAndLodControlSupport &&
 560         (contextOptions.fDoManualMipmapping ||
 561          (kIntel_GrGLVendor == ctxInfo.vendor()) ||
 562          (kNVIDIA_GrGLDriver == ctxInfo.driver() && isMAC) ||
 563          (kATI_GrGLVendor == ctxInfo.vendor()))) {
 564         fDoManualMipmapping = true;
 565     }
 566
 567     fSRGBDecodeDisableSupport = ctxInfo.hasExtension("GL_EXT_texture_sRGB_decode");
 568     fSRGBDecodeDisableAffectsMipmaps = fSRGBDecodeDisableSupport &&
 569         kChromium_GrGLDriver != ctxInfo.driver();
 570
 571     // See http://crbug.com/710443
 572 #ifdef SK_BUILD_FOR_MAC
 573     if (kIntel6xxx_GrGLRenderer == ctxInfo.renderer()) {
 574         fClearToBoundaryValuesIsBroken = true;
 575     }
 576 #endif
 577     if (kQualcomm_GrGLVendor == ctxInfo.vendor()) {
 578         fDrawArraysBaseVertexIsBroken = true;
 579     }
 580
 581     // Requires fTextureRedSupport, fTextureSwizzleSupport, msaa support, ES compatibility have
 582     // already been detected.
 583     this->initConfigTable(contextOptions, ctxInfo, gli, shaderCaps);
 584
 585     this->applyOptionsOverrides(contextOptions);
 586     shaderCaps->applyOptionsOverrides(contextOptions);
 587 }
 588
 589 const char* get_glsl_version_decl_string(GrGLStandard standard, GrGLSLGeneration generation,
 590                                          bool isCoreProfile) {
 591     switch (generation) {
 592         case k110_GrGLSLGeneration:
 593             if (kGLES_GrGLStandard == standard) {
 594                 // ES2s shader language is based on version 1.20 but is version
 595                 // 1.00 of the ES language.
 596                 return "#version 100\n";
 597             } else {
 598                 SkASSERT(kGL_GrGLStandard == standard);
 599                 return "#version 110\n";
 600             }
 601         case k130_GrGLSLGeneration:
 602             SkASSERT(kGL_GrGLStandard == standard);
 603             return "#version 130\n";
 604         case k140_GrGLSLGeneration:
 605             SkASSERT(kGL_GrGLStandard == standard);
 606             return "#version 140\n";
 607         case k150_GrGLSLGeneration:
 608             SkASSERT(kGL_GrGLStandard == standard);
 609             if (isCoreProfile) {
 610                 return "#version 150\n";
 611             } else {
 612                 return "#version 150 compatibility\n";
 613             }
 614         case k330_GrGLSLGeneration:
 615             if (kGLES_GrGLStandard == standard) {
 616                 return "#version 300 es\n";
 617             } else {
 618                 SkASSERT(kGL_GrGLStandard == standard);
 619                 if (isCoreProfile) {
 620                     return "#version 330\n";
 621                 } else {
 622                     return "#version 330 compatibility\n";
 623                 }
 624             }
 625         case k400_GrGLSLGeneration:
 626             SkASSERT(kGL_GrGLStandard == standard);
 627             if (isCoreProfile) {
 628                 return "#version 400\n";
 629             } else {
 630                 return "#version 400 compatibility\n";
 631             }
 632         case k420_GrGLSLGeneration:
 633             SkASSERT(kGL_GrGLStandard == standard);
 634             if (isCoreProfile) {
 635                 return "#version 420\n";
 636             }
 637             else {
 638                 return "#version 420 compatibility\n";
 639             }
 640         case k310es_GrGLSLGeneration:
 641             SkASSERT(kGLES_GrGLStandard == standard);
 642             return "#version 310 es\n";
 643         case k320es_GrGLSLGeneration:
 644             SkASSERT(kGLES_GrGLStandard == standard);
 645             return "#version 320 es\n";
 646     }
 647     return "<no version>";
 648 }
 649
 650 void GrGLCaps::initGLSL(const GrGLContextInfo& ctxInfo) {
 651     GrGLStandard standard = ctxInfo.standard();
 652     GrGLVersion version = ctxInfo.version();
 653
 654     /**************************************************************************
 655     * Caps specific to GrShaderCaps
 656     **************************************************************************/
 657
 658     GrShaderCaps* shaderCaps = fShaderCaps.get();
 659     shaderCaps->fGLSLGeneration = ctxInfo.glslGeneration();
 660     if (kGLES_GrGLStandard == standard) {
 661         if (ctxInfo.hasExtension("GL_EXT_shader_framebuffer_fetch")) {
 662             shaderCaps->fFBFetchNeedsCustomOutput = (version >= GR_GL_VER(3, 0));
 663             shaderCaps->fFBFetchSupport = true;
 664             shaderCaps->fFBFetchColorName = "gl_LastFragData[0]";
 665             shaderCaps->fFBFetchExtensionString = "GL_EXT_shader_framebuffer_fetch";
 666         }
 667         else if (ctxInfo.hasExtension("GL_NV_shader_framebuffer_fetch")) {
 668             // Actually, we haven't seen an ES3.0 device with this extension yet, so we don't know
 669             shaderCaps->fFBFetchNeedsCustomOutput = false;
 670             shaderCaps->fFBFetchSupport = true;
 671             shaderCaps->fFBFetchColorName = "gl_LastFragData[0]";
 672             shaderCaps->fFBFetchExtensionString = "GL_NV_shader_framebuffer_fetch";
 673         }
 674         else if (ctxInfo.hasExtension("GL_ARM_shader_framebuffer_fetch")) {
 675             // The arm extension also requires an additional flag which we will set onResetContext
 676             shaderCaps->fFBFetchNeedsCustomOutput = false;
 677             shaderCaps->fFBFetchSupport = true;
 678             shaderCaps->fFBFetchColorName = "gl_LastFragColorARM";
 679             shaderCaps->fFBFetchExtensionString = "GL_ARM_shader_framebuffer_fetch";
 680         }
 681         shaderCaps->fUsesPrecisionModifiers = true;
 682     }
 683
 684     // Currently the extension is advertised but fb fetch is broken on 500 series Adrenos like the
 685     // Galaxy S7.
 686     // TODO: Once this is fixed we can update the check here to look at a driver version number too.
 687     if (kAdreno5xx_GrGLRenderer == ctxInfo.renderer()) {
 688         shaderCaps->fFBFetchSupport = false;
 689     }
 690
 691     shaderCaps->fBindlessTextureSupport = ctxInfo.hasExtension("GL_NV_bindless_texture");
 692
 693     if (kGL_GrGLStandard == standard) {
 694         shaderCaps->fFlatInterpolationSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
 695     } else {
 696         shaderCaps->fFlatInterpolationSupport =
 697             ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // This is the value for GLSL ES 3.0.
 698     }
 699
 700     if (kGL_GrGLStandard == standard) {
 701         shaderCaps->fNoPerspectiveInterpolationSupport =
 702             ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
 703     } else {
 704         if (ctxInfo.hasExtension("GL_NV_shader_noperspective_interpolation")) {
 705             shaderCaps->fNoPerspectiveInterpolationSupport = true;
 706             shaderCaps->fNoPerspectiveInterpolationExtensionString =
 707                 "GL_NV_shader_noperspective_interpolation";
 708         }
 709     }
 710
 711     if (kGL_GrGLStandard == standard) {
 712         shaderCaps->fMultisampleInterpolationSupport =
 713                 ctxInfo.glslGeneration() >= k400_GrGLSLGeneration;
 714     } else {
 715         if (ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) {
 716             shaderCaps->fMultisampleInterpolationSupport = true;
 717         } else if (ctxInfo.hasExtension("GL_OES_shader_multisample_interpolation")) {
 718             shaderCaps->fMultisampleInterpolationSupport = true;
 719             shaderCaps->fMultisampleInterpolationExtensionString =
 720                 "GL_OES_shader_multisample_interpolation";
 721         }
 722     }
 723
 724     if (kGL_GrGLStandard == standard) {
 725         shaderCaps->fSampleVariablesSupport = ctxInfo.glslGeneration() >= k400_GrGLSLGeneration;
 726     } else {
 727         if (ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) {
 728             shaderCaps->fSampleVariablesSupport = true;
 729         } else if (ctxInfo.hasExtension("GL_OES_sample_variables")) {
 730             shaderCaps->fSampleVariablesSupport = true;
 731             shaderCaps->fSampleVariablesExtensionString = "GL_OES_sample_variables";
 732         }
 733     }
 734
 735     if (shaderCaps->fSampleVariablesSupport &&
 736         ctxInfo.hasExtension("GL_NV_sample_mask_override_coverage")) {
 737         // Pre-361 NVIDIA has a bug with NV_sample_mask_override_coverage.
 738         shaderCaps->fSampleMaskOverrideCoverageSupport =
 739             kNVIDIA_GrGLDriver != ctxInfo.driver() ||
 740             ctxInfo.driverVersion() >= GR_GL_DRIVER_VER(361,00);
 741     }
 742
 743     // Adreno GPUs have a tendency to drop tiles when there is a divide-by-zero in a shader
 744     shaderCaps->fDropsTileOnZeroDivide = kQualcomm_GrGLVendor == ctxInfo.vendor();
 745
 746     // On the NexusS and GalaxyNexus, the use of 'any' causes the compilation error "Calls to any
 747     // function that may require a gradient calculation inside a conditional block may return
 748     // undefined results". This appears to be an issue with the 'any' call since even the simple
 749     // "result=black; if (any()) result=white;" code fails to compile. This issue comes into play
 750     // from our GrTextureDomain processor.
 751     shaderCaps->fCanUseAnyFunctionInShader = kImagination_GrGLVendor != ctxInfo.vendor();
 752
 753     shaderCaps->fVersionDeclString = get_glsl_version_decl_string(standard,
 754                                                                   shaderCaps->fGLSLGeneration,
 755                                                                   fIsCoreProfile);
 756
 757     if (kGLES_GrGLStandard == standard && k110_GrGLSLGeneration == shaderCaps->fGLSLGeneration) {
 758         shaderCaps->fShaderDerivativeExtensionString = "GL_OES_standard_derivatives";
 759     }
 760
 761     // Frag Coords Convention support is not part of ES
 762     // Known issue on at least some Intel platforms:
 763     // http://code.google.com/p/skia/issues/detail?id=946
 764     if (kIntel_GrGLVendor != ctxInfo.vendor() &&
 765         kGLES_GrGLStandard != standard &&
 766         (ctxInfo.glslGeneration() >= k150_GrGLSLGeneration ||
 767          ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions"))) {
 768         shaderCaps->fFragCoordConventionsExtensionString = "GL_ARB_fragment_coord_conventions";
 769     }
 770
 771     if (kGLES_GrGLStandard == standard) {
 772         shaderCaps->fSecondaryOutputExtensionString = "GL_EXT_blend_func_extended";
 773     }
 774
 775     if (ctxInfo.hasExtension("GL_OES_EGL_image_external")) {
 776         if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) {
 777             shaderCaps->fExternalTextureSupport = true;
 778         } else if (ctxInfo.hasExtension("GL_OES_EGL_image_external_essl3") ||
 779                    ctxInfo.hasExtension("OES_EGL_image_external_essl3")) {
 780             // At least one driver has been found that has this extension without the "GL_" prefix.
 781             shaderCaps->fExternalTextureSupport = true;
 782         }
 783     }
 784
 785     if (shaderCaps->fExternalTextureSupport) {
 786         if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) {
 787             shaderCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external";
 788         } else {
 789             shaderCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external_essl3";
 790         }
 791     }
 792
 793     if (kGL_GrGLStandard == standard) {
 794         shaderCaps->fTexelFetchSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
 795     } else {
 796         shaderCaps->fTexelFetchSupport =
 797             ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0.
 798     }
 799
 800     if (shaderCaps->fTexelFetchSupport) {
 801         if (kGL_GrGLStandard == standard) {
 802             shaderCaps->fTexelBufferSupport = ctxInfo.version() >= GR_GL_VER(3, 1) &&
 803                                             ctxInfo.glslGeneration() >= k330_GrGLSLGeneration;
 804         } else {
 805             if (ctxInfo.version() >= GR_GL_VER(3, 2) &&
 806                 ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) {
 807                 shaderCaps->fTexelBufferSupport = true;
 808             } else if (ctxInfo.hasExtension("GL_OES_texture_buffer")) {
 809                 shaderCaps->fTexelBufferSupport = true;
 810                 shaderCaps->fTexelBufferExtensionString = "GL_OES_texture_buffer";
 811             } else if (ctxInfo.hasExtension("GL_EXT_texture_buffer")) {
 812                 shaderCaps->fTexelBufferSupport = true;
 813                 shaderCaps->fTexelBufferExtensionString = "GL_EXT_texture_buffer";
 814             }
 815         }
 816     }
 817
 818     // The Tegra3 compiler will sometimes never return if we have min(abs(x), 1.0), so we must do
 819     // the abs first in a separate expression.
 820     if (kTegra3_GrGLRenderer == ctxInfo.renderer()) {
 821         shaderCaps->fCanUseMinAndAbsTogether = false;
 822     }
 823
 824     // On Intel GPU there is an issue where it reads the second argument to atan "- %s.x" as an int
 825     // thus must us -1.0 * %s.x to work correctly
 826     if (kIntel_GrGLVendor == ctxInfo.vendor()) {
 827         shaderCaps->fMustForceNegatedAtanParamToFloat = true;
 828     }
 829
 830     // On Adreno devices with framebuffer fetch support, there is a bug where they always return
 831     // the original dst color when reading the outColor even after being written to. By using a
 832     // local outColor we can work around this bug.
 833     if (shaderCaps->fFBFetchSupport && kQualcomm_GrGLVendor == ctxInfo.vendor()) {
 834         shaderCaps->fRequiresLocalOutputColorForFBFetch = true;
 835     }
 836
 837 #ifdef SK_BUILD_FOR_MAC
 838     // On at least some MacBooks, geometry shaders fall apart if we use more than one invocation. To
 839     // work around this, we always use a single invocation and wrap the shader in a loop. The long-
 840     // term plan for this WAR is for it to eventually be baked into SkSL.
 841     shaderCaps->fMustImplementGSInvocationsWithLoop = true;
 842 #endif
 843 }
 844
 845 bool GrGLCaps::hasPathRenderingSupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
 846     bool hasChromiumPathRendering = ctxInfo.hasExtension("GL_CHROMIUM_path_rendering");
 847
 848     if (!(ctxInfo.hasExtension("GL_NV_path_rendering") || hasChromiumPathRendering)) {
 849         return false;
 850     }
 851
 852     if (kGL_GrGLStandard == ctxInfo.standard()) {
 853         if (ctxInfo.version() < GR_GL_VER(4, 3) &&
 854             !ctxInfo.hasExtension("GL_ARB_program_interface_query")) {
 855             return false;
 856         }
 857     } else {
 858         if (!hasChromiumPathRendering &&
 859             ctxInfo.version() < GR_GL_VER(3, 1)) {
 860             return false;
 861         }
 862     }
 863     // We only support v1.3+ of GL_NV_path_rendering which allows us to
 864     // set individual fragment inputs with ProgramPathFragmentInputGen. The API
 865     // additions are detected by checking the existence of the function.
 866     // We also use *Then* functions that not all drivers might have. Check
 867     // them for consistency.
 868     if (!gli->fFunctions.fStencilThenCoverFillPath ||
 869         !gli->fFunctions.fStencilThenCoverStrokePath ||
 870         !gli->fFunctions.fStencilThenCoverFillPathInstanced ||
 871         !gli->fFunctions.fStencilThenCoverStrokePathInstanced ||
 872         !gli->fFunctions.fProgramPathFragmentInputGen) {
 873         return false;
 874     }
 875     return true;
 876 }
 877
 878 bool GrGLCaps::readPixelsSupported(GrPixelConfig surfaceConfig,
 879                                    GrPixelConfig readConfig,
 880                                    std::function<void (GrGLenum, GrGLint*)> getIntegerv,
 881                                    std::function<bool ()> bindRenderTarget,
 882                                    std::function<void ()> unbindRenderTarget) const {
 883     // If it's not possible to even have a color attachment of surfaceConfig then read pixels is
 884     // not supported regardless of readConfig.
 885     if (!this->canConfigBeFBOColorAttachment(surfaceConfig)) {
 886         return false;
 887     }
 888
 889     if (GrPixelConfigIsSint(surfaceConfig) != GrPixelConfigIsSint(readConfig)) {
 890         return false;
 891     }
 892
 893     GrGLenum readFormat;
 894     GrGLenum readType;
 895     if (!this->getReadPixelsFormat(surfaceConfig, readConfig, &readFormat, &readType)) {
 896         return false;
 897     }
 898
 899     if (kGL_GrGLStandard == fStandard) {
 900         // Some OpenGL implementations allow GL_ALPHA as a format to glReadPixels. However,
 901         // the manual (https://www.opengl.org/sdk/docs/man/) says only these formats are allowed:
 902         // GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL, GL_RED, GL_GREEN, GL_BLUE,
 903         // GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. We check for the subset that we would use.
 904         // The manual does not seem to fully match the spec as the spec allows integer formats
 905         // when the bound color buffer is an integer buffer. It doesn't specify which integer
 906         // formats are allowed, so perhaps all of them are. We only use GL_RGBA_INTEGER currently.
 907         if (readFormat != GR_GL_RED && readFormat != GR_GL_RG && readFormat != GR_GL_RGB &&
 908             readFormat != GR_GL_RGBA && readFormat != GR_GL_BGRA &&
 909             readFormat != GR_GL_RGBA_INTEGER) {
 910             return false;
 911         }
 912         // There is also a set of allowed types, but all the types we use are in the set:
 913         // GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT,
 914         // GL_HALF_FLOAT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV,
 915         // GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4,
 916         // GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV,
 917         // GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV,GL_UNSIGNED_INT_10_10_10_2,
 918         // GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_INT_24_8, GL_UNSIGNED_INT_10F_11F_11F_REV,
 919         // GL_UNSIGNED_INT_5_9_9_9_REV, or GL_FLOAT_32_UNSIGNED_INT_24_8_REV.
 920         return true;
 921     }
 922
 923     // See Section 16.1.2 in the ES 3.2 specification.
 924     switch (fConfigTable[surfaceConfig].fFormatType) {
 925         case kNormalizedFixedPoint_FormatType:
 926             if (GR_GL_RGBA == readFormat && GR_GL_UNSIGNED_BYTE == readType) {
 927                 return true;
 928             }
 929             break;
 930         case kInteger_FormatType:
 931             if (GR_GL_RGBA_INTEGER == readFormat && GR_GL_INT == readType) {
 932                 return true;
 933             }
 934             break;
 935         case kFloat_FormatType:
 936             if (GR_GL_RGBA == readFormat && GR_GL_FLOAT == readType) {
 937                 return true;
 938             }
 939             break;
 940     }
 941
 942     if (0 == fConfigTable[surfaceConfig].fSecondReadPixelsFormat.fFormat) {
 943         ReadPixelsFormat* rpFormat =
 944             const_cast<ReadPixelsFormat*>(&fConfigTable[surfaceConfig].fSecondReadPixelsFormat);
 945         GrGLint format = 0, type = 0;
 946         if (!bindRenderTarget()) {
 947             return false;
 948         }
 949         getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_FORMAT, &format);
 950         getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_TYPE, &type);
 951         rpFormat->fFormat = format;
 952         rpFormat->fType = type;
 953         unbindRenderTarget();
 954     }
 955
 956     return fConfigTable[surfaceConfig].fSecondReadPixelsFormat.fFormat == readFormat &&
 957            fConfigTable[surfaceConfig].fSecondReadPixelsFormat.fType == readType;
 958 }
 959
 960 void GrGLCaps::initFSAASupport(const GrContextOptions& contextOptions, const GrGLContextInfo& ctxInfo,
 961                                const GrGLInterface* gli) {
 962     // We need dual source blending and the ability to disable multisample in order to support mixed
 963     // samples in every corner case. We only use mixed samples if the stencil-and-cover path
 964     // renderer is available and enabled; no other path renderers support this feature.
 965     if (fMultisampleDisableSupport &&
 966         this->shaderCaps()->dualSourceBlendingSupport() &&
 967         this->shaderCaps()->pathRenderingSupport() &&
 968         (contextOptions.fGpuPathRenderers & GrContextOptions::GpuPathRenderers::kStencilAndCover)) {
 969         fUsesMixedSamples = ctxInfo.hasExtension("GL_NV_framebuffer_mixed_samples") ||
 970                 ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_mixed_samples");
 971         // Workaround NVIDIA bug related to glInvalidateFramebuffer and mixed samples.
 972         if (fUsesMixedSamples && (kNVIDIA_GrGLDriver == ctxInfo.driver() ||
 973                                   kChromium_GrGLDriver == ctxInfo.driver())) {
 974             fDiscardRenderTargetSupport = false;
 975             fInvalidateFBType = kNone_InvalidateFBType;
 976         }
 977     }
 978
 979     if (kGL_GrGLStandard != ctxInfo.standard()) {
 980         // We prefer the EXT/IMG extension over ES3 MSAA because we've observed
 981         // ES3 driver bugs on at least one device with a tiled GPU (N10).
 982         if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) {
 983             fMSFBOType = kES_EXT_MsToTexture_MSFBOType;
 984         } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) {
 985             fMSFBOType = kES_IMG_MsToTexture_MSFBOType;
 986         } else if (fUsesMixedSamples) {
 987             fMSFBOType = kMixedSamples_MSFBOType;
 988         } else if (ctxInfo.version() >= GR_GL_VER(3,0) ||
 989                    ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
 990             fMSFBOType = kStandard_MSFBOType;
 991         } else if (ctxInfo.hasExtension("GL_ANGLE_framebuffer_multisample")) {
 992             fMSFBOType = kEXT_MSFBOType;
 993         } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {
 994             fMSFBOType = kES_Apple_MSFBOType;
 995         }
 996
 997         // Above determined the preferred MSAA approach, now decide whether glBlitFramebuffer
 998         // is available.
 999         if (ctxInfo.version() >= GR_GL_VER(3, 0)) {
1000             fBlitFramebufferFlags = kNoFormatConversionForMSAASrc_BlitFramebufferFlag |
1001                                     kNoMSAADst_BlitFramebufferFlag |
1002                                     kRectsMustMatchForMSAASrc_BlitFramebufferFlag;
1003         } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample") ||
1004                    ctxInfo.hasExtension("GL_ANGLE_framebuffer_blit")) {
1005             // The CHROMIUM extension uses the ANGLE version of glBlitFramebuffer and includes its
1006             // limitations.
1007             fBlitFramebufferFlags = kNoScalingOrMirroring_BlitFramebufferFlag |
1008                                     kResolveMustBeFull_BlitFrambufferFlag |
1009                                     kNoMSAADst_BlitFramebufferFlag |
1010                                     kNoFormatConversion_BlitFramebufferFlag |
1011                                     kRectsMustMatchForMSAASrc_BlitFramebufferFlag;
1012         }
1013     } else {
1014         if (fUsesMixedSamples) {
1015             fMSFBOType = kMixedSamples_MSFBOType;
1016             fBlitFramebufferFlags = 0;
1017         } else if (ctxInfo.version() >= GR_GL_VER(3,0) ||
1018                    ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
1019             fMSFBOType = kStandard_MSFBOType;
1020             fBlitFramebufferFlags = 0;
1021         } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&
1022                    ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {
1023             fMSFBOType = kEXT_MSFBOType;
1024             fBlitFramebufferFlags = 0;
1025         }
1026     }
1027
1028     if (GrGLCaps::kES_IMG_MsToTexture_MSFBOType == fMSFBOType) {
1029         GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &fMaxStencilSampleCount);
1030     } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) {
1031         GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &fMaxStencilSampleCount);
1032     }
1033     // We only have a use for raster multisample if there is coverage modulation from mixed samples.
1034     if (fUsesMixedSamples && ctxInfo.hasExtension("GL_EXT_raster_multisample")) {
1035         GR_GL_GetIntegerv(gli, GR_GL_MAX_RASTER_SAMPLES, &fMaxRasterSamples);
1036         // This is to guard against platforms that may not support as many samples for
1037         // glRasterSamples as they do for framebuffers.
1038         fMaxStencilSampleCount = SkTMin(fMaxStencilSampleCount, fMaxRasterSamples);
1039     }
1040     fMaxColorSampleCount = fMaxStencilSampleCount;
1041 }
1042
1043 void GrGLCaps::initBlendEqationSupport(const GrGLContextInfo& ctxInfo) {
1044     GrShaderCaps* shaderCaps = static_cast<GrShaderCaps*>(fShaderCaps.get());
1045
1046     // Disabling advanced blend on various platforms with major known issues. We also block Chrome
1047     // for now until its own blacklists can be updated.
1048     if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer() ||
1049         kAdreno5xx_GrGLRenderer == ctxInfo.renderer() ||
1050         kIntel_GrGLDriver == ctxInfo.driver() ||
1051         kChromium_GrGLDriver == ctxInfo.driver()) {
1052         return;
1053     }
1054
1055     if (ctxInfo.hasExtension("GL_NV_blend_equation_advanced_coherent")) {
1056         fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport;
1057         shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kAutomatic_AdvBlendEqInteraction;
1058     } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced_coherent")) {
1059         fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport;
1060         shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kGeneralEnable_AdvBlendEqInteraction;
1061     } else if (kNVIDIA_GrGLDriver == ctxInfo.driver() &&
1062                ctxInfo.driverVersion() < GR_GL_DRIVER_VER(337,00)) {
1063         // Non-coherent advanced blend has an issue on NVIDIA pre 337.00.
1064         return;
1065     } else if (ctxInfo.hasExtension("GL_NV_blend_equation_advanced")) {
1066         fBlendEquationSupport = kAdvanced_BlendEquationSupport;
1067         shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kAutomatic_AdvBlendEqInteraction;
1068     } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced")) {
1069         fBlendEquationSupport = kAdvanced_BlendEquationSupport;
1070         shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kGeneralEnable_AdvBlendEqInteraction;
1071         // TODO: Use kSpecificEnables_AdvBlendEqInteraction if "blend_support_all_equations" is
1072         // slow on a particular platform.
1073     } else {
1074         return; // No advanced blend support.
1075     }
1076
1077     SkASSERT(this->advancedBlendEquationSupport());
1078
1079     if (kNVIDIA_GrGLDriver == ctxInfo.driver() &&
1080         ctxInfo.driverVersion() < GR_GL_DRIVER_VER(355,00)) {
1081         // Blacklist color-dodge and color-burn on pre-355.00 NVIDIA.
1082         fAdvBlendEqBlacklist |= (1 << kColorDodge_GrBlendEquation) |
1083                                 (1 << kColorBurn_GrBlendEquation);
1084     }
1085     if (kARM_GrGLVendor == ctxInfo.vendor()) {
1086         // Blacklist color-burn on ARM until the fix is released.
1087         fAdvBlendEqBlacklist |= (1 << kColorBurn_GrBlendEquation);
1088     }
1089 }
1090
1091 namespace {
1092 const GrGLuint kUnknownBitCount = GrGLStencilAttachment::kUnknownBitCount;
1093 }
1094
1095 void GrGLCaps::initStencilSupport(const GrGLContextInfo& ctxInfo) {
1096
1097     // Build up list of legal stencil formats (though perhaps not supported on
1098     // the particular gpu/driver) from most preferred to least.
1099
1100     // these consts are in order of most preferred to least preferred
1101     // we don't bother with GL_STENCIL_INDEX1 or GL_DEPTH32F_STENCIL8
1102
1103     static const StencilFormat
1104                   // internal Format      stencil bits      total bits        packed?
1105         gS8    = {GR_GL_STENCIL_INDEX8,   8,                8,                false},
1106         gS16   = {GR_GL_STENCIL_INDEX16,  16,               16,               false},
1107         gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8,                32,               true },
1108         gS4    = {GR_GL_STENCIL_INDEX4,   4,                4,                false},
1109     //  gS     = {GR_GL_STENCIL_INDEX,    kUnknownBitCount, kUnknownBitCount, false},
1110         gDS    = {GR_GL_DEPTH_STENCIL,    kUnknownBitCount, kUnknownBitCount, true };
1111
1112     if (kGL_GrGLStandard == ctxInfo.standard()) {
1113         bool supportsPackedDS =
1114             ctxInfo.version() >= GR_GL_VER(3,0) ||
1115             ctxInfo.hasExtension("GL_EXT_packed_depth_stencil") ||
1116             ctxInfo.hasExtension("GL_ARB_framebuffer_object");
1117
1118         // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we
1119         // require FBO support we can expect these are legal formats and don't
1120         // check. These also all support the unsized GL_STENCIL_INDEX.
1121         fStencilFormats.push_back() = gS8;
1122         fStencilFormats.push_back() = gS16;
1123         if (supportsPackedDS) {
1124             fStencilFormats.push_back() = gD24S8;
1125         }
1126         fStencilFormats.push_back() = gS4;
1127         if (supportsPackedDS) {
1128             fStencilFormats.push_back() = gDS;
1129         }
1130     } else {
1131         // ES2 has STENCIL_INDEX8 without extensions but requires extensions
1132         // for other formats.
1133         // ES doesn't support using the unsized format.
1134
1135         fStencilFormats.push_back() = gS8;
1136         //fStencilFormats.push_back() = gS16;
1137         if (ctxInfo.version() >= GR_GL_VER(3,0) ||
1138             ctxInfo.hasExtension("GL_OES_packed_depth_stencil")) {
1139             fStencilFormats.push_back() = gD24S8;
1140         }
1141         if (ctxInfo.hasExtension("GL_OES_stencil4")) {
1142             fStencilFormats.push_back() = gS4;
1143         }
1144     }
1145 }
1146
1147 SkString GrGLCaps::dump() const {
1148
1149     SkString r = INHERITED::dump();
1150
1151     r.appendf("--- GL-Specific ---\n");
1152     for (int i = 0; i < fStencilFormats.count(); ++i) {
1153         r.appendf("Stencil Format %d, stencil bits: %02d, total bits: %02d\n",
1154                  i,
1155                  fStencilFormats[i].fStencilBits,
1156                  fStencilFormats[i].fTotalBits);
1157     }
1158
1159     static const char* kMSFBOExtStr[] = {
1160         "None",
1161         "EXT",
1162         "Standard",
1163         "Apple",
1164         "IMG MS To Texture",
1165         "EXT MS To Texture",
1166         "MixedSamples",
1167     };
1168     GR_STATIC_ASSERT(0 == kNone_MSFBOType);
1169     GR_STATIC_ASSERT(1 == kEXT_MSFBOType);
1170     GR_STATIC_ASSERT(2 == kStandard_MSFBOType);
1171     GR_STATIC_ASSERT(3 == kES_Apple_MSFBOType);
1172     GR_STATIC_ASSERT(4 == kES_IMG_MsToTexture_MSFBOType);
1173     GR_STATIC_ASSERT(5 == kES_EXT_MsToTexture_MSFBOType);
1174     GR_STATIC_ASSERT(6 == kMixedSamples_MSFBOType);
1175     GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMSFBOExtStr) == kLast_MSFBOType + 1);
1176
1177     static const char* kInvalidateFBTypeStr[] = {
1178         "None",
1179         "Discard",
1180         "Invalidate",
1181     };
1182     GR_STATIC_ASSERT(0 == kNone_InvalidateFBType);
1183     GR_STATIC_ASSERT(1 == kDiscard_InvalidateFBType);
1184     GR_STATIC_ASSERT(2 == kInvalidate_InvalidateFBType);
1185     GR_STATIC_ASSERT(SK_ARRAY_COUNT(kInvalidateFBTypeStr) == kLast_InvalidateFBType + 1);
1186
1187     static const char* kMapBufferTypeStr[] = {
1188         "None",
1189         "MapBuffer",
1190         "MapBufferRange",
1191         "Chromium",
1192     };
1193     GR_STATIC_ASSERT(0 == kNone_MapBufferType);
1194     GR_STATIC_ASSERT(1 == kMapBuffer_MapBufferType);
1195     GR_STATIC_ASSERT(2 == kMapBufferRange_MapBufferType);
1196     GR_STATIC_ASSERT(3 == kChromium_MapBufferType);
1197     GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMapBufferTypeStr) == kLast_MapBufferType + 1);
1198
1199     r.appendf("Core Profile: %s\n", (fIsCoreProfile ? "YES" : "NO"));
1200     r.appendf("MSAA Type: %s\n", kMSFBOExtStr[fMSFBOType]);
1201     r.appendf("Invalidate FB Type: %s\n", kInvalidateFBTypeStr[fInvalidateFBType]);
1202     r.appendf("Map Buffer Type: %s\n", kMapBufferTypeStr[fMapBufferType]);
1203     r.appendf("Max FS Uniform Vectors: %d\n", fMaxFragmentUniformVectors);
1204     r.appendf("Unpack Row length support: %s\n", (fUnpackRowLengthSupport ? "YES": "NO"));
1205     r.appendf("Unpack Flip Y support: %s\n", (fUnpackFlipYSupport ? "YES": "NO"));
1206     r.appendf("Pack Row length support: %s\n", (fPackRowLengthSupport ? "YES": "NO"));
1207     r.appendf("Pack Flip Y support: %s\n", (fPackFlipYSupport ? "YES": "NO"));
1208
1209     r.appendf("Texture Usage support: %s\n", (fTextureUsageSupport ? "YES": "NO"));
1210     r.appendf("GL_R support: %s\n", (fTextureRedSupport ? "YES": "NO"));
1211     r.appendf("GL_ARB_imaging support: %s\n", (fImagingSupport ? "YES": "NO"));
1212     r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
1213     r.appendf("Direct state access support: %s\n", (fDirectStateAccessSupport ? "YES": "NO"));
1214     r.appendf("Debug support: %s\n", (fDebugSupport ? "YES": "NO"));
1215     r.appendf("Draw instanced support: %s\n", (fDrawInstancedSupport ? "YES" : "NO"));
1216     r.appendf("Draw indirect support: %s\n", (fDrawIndirectSupport ? "YES" : "NO"));
1217     r.appendf("Multi draw indirect support: %s\n", (fMultiDrawIndirectSupport ? "YES" : "NO"));
1218     r.appendf("Base instance support: %s\n", (fBaseInstanceSupport ? "YES" : "NO"));
1219     r.appendf("RGBA 8888 pixel ops are slow: %s\n", (fRGBA8888PixelsOpsAreSlow ? "YES" : "NO"));
1220     r.appendf("Partial FBO read is slow: %s\n", (fPartialFBOReadIsSlow ? "YES" : "NO"));
1221     r.appendf("Bind uniform location support: %s\n", (fBindUniformLocationSupport ? "YES" : "NO"));
1222     r.appendf("Rectangle texture support: %s\n", (fRectangleTextureSupport? "YES" : "NO"));
1223     r.appendf("Texture swizzle support: %s\n", (fTextureSwizzleSupport ? "YES" : "NO"));
1224     r.appendf("BGRA to RGBA readback conversions are slow: %s\n",
1225               (fRGBAToBGRAReadbackConversionsAreSlow ? "YES" : "NO"));
1226
1227     r.append("Configs\n-------\n");
1228     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
1229         r.appendf("  cfg: %d flags: 0x%04x, b_internal: 0x%08x s_internal: 0x%08x, e_format: "
1230                   "0x%08x, e_format_teximage: 0x%08x, e_type: 0x%08x, i_for_teximage: 0x%08x, "
1231                   "i_for_renderbuffer: 0x%08x\n",
1232                   i,
1233                   fConfigTable[i].fFlags,
1234                   fConfigTable[i].fFormats.fBaseInternalFormat,
1235                   fConfigTable[i].fFormats.fSizedInternalFormat,
1236                   fConfigTable[i].fFormats.fExternalFormat[kOther_ExternalFormatUsage],
1237                   fConfigTable[i].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage],
1238                   fConfigTable[i].fFormats.fExternalType,
1239                   fConfigTable[i].fFormats.fInternalFormatTexImage,
1240                   fConfigTable[i].fFormats.fInternalFormatRenderbuffer);
1241     }
1242
1243     return r;
1244 }
1245
1246 static GrGLenum precision_to_gl_float_type(GrSLPrecision p) {
1247     switch (p) {
1248     case kLow_GrSLPrecision:
1249         return GR_GL_LOW_FLOAT;
1250     case kMedium_GrSLPrecision:
1251         return GR_GL_MEDIUM_FLOAT;
1252     case kHigh_GrSLPrecision:
1253         return GR_GL_HIGH_FLOAT;
1254     default:
1255         SkFAIL("Unexpected precision type.");
1256         return -1;
1257     }
1258 }
1259
1260 static GrGLenum shader_type_to_gl_shader(GrShaderType type) {
1261     switch (type) {
1262     case kVertex_GrShaderType:
1263         return GR_GL_VERTEX_SHADER;
1264     case kGeometry_GrShaderType:
1265         return GR_GL_GEOMETRY_SHADER;
1266     case kFragment_GrShaderType:
1267         return GR_GL_FRAGMENT_SHADER;
1268     }
1269     SkFAIL("Unknown shader type.");
1270     return -1;
1271 }
1272
1273 void GrGLCaps::initShaderPrecisionTable(const GrGLContextInfo& ctxInfo,
1274                                         const GrGLInterface* intf,
1275                                         GrShaderCaps* shaderCaps) {
1276     if (kGLES_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(4, 1) ||
1277         ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {
1278         for (int s = 0; s < kGrShaderTypeCount; ++s) {
1279             if (kGeometry_GrShaderType != s) {
1280                 GrShaderType shaderType = static_cast<GrShaderType>(s);
1281                 GrGLenum glShader = shader_type_to_gl_shader(shaderType);
1282                 GrShaderCaps::PrecisionInfo* first = nullptr;
1283                 shaderCaps->fShaderPrecisionVaries = false;
1284                 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
1285                     GrSLPrecision precision = static_cast<GrSLPrecision>(p);
1286                     GrGLenum glPrecision = precision_to_gl_float_type(precision);
1287                     GrGLint range[2];
1288                     GrGLint bits;
1289                     GR_GL_GetShaderPrecisionFormat(intf, glShader, glPrecision, range, &bits);
1290                     if (bits) {
1291                         shaderCaps->fFloatPrecisions[s][p].fLogRangeLow = range[0];
1292                         shaderCaps->fFloatPrecisions[s][p].fLogRangeHigh = range[1];
1293                         shaderCaps->fFloatPrecisions[s][p].fBits = bits;
1294                         if (!first) {
1295                             first = &shaderCaps->fFloatPrecisions[s][p];
1296                         }
1297                         else if (!shaderCaps->fShaderPrecisionVaries) {
1298                             shaderCaps->fShaderPrecisionVaries =
1299                                                      (*first != shaderCaps->fFloatPrecisions[s][p]);
1300                         }
1301                     }
1302                 }
1303             }
1304         }
1305     }
1306     else {
1307         // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float.
1308         shaderCaps->fShaderPrecisionVaries = false;
1309         for (int s = 0; s < kGrShaderTypeCount; ++s) {
1310             if (kGeometry_GrShaderType != s) {
1311                 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
1312                     shaderCaps->fFloatPrecisions[s][p].fLogRangeLow = 127;
1313                     shaderCaps->fFloatPrecisions[s][p].fLogRangeHigh = 127;
1314                     shaderCaps->fFloatPrecisions[s][p].fBits = 23;
1315                 }
1316             }
1317         }
1318     }
1319     // GetShaderPrecisionFormat doesn't accept GL_GEOMETRY_SHADER as a shader type. Assume they're
1320     // the same as the vertex shader. Only fragment shaders were ever allowed to omit support for
1321     // highp. GS was added after GetShaderPrecisionFormat was added to the list of features that
1322     // are recommended against.
1323     if (shaderCaps->fGeometryShaderSupport) {
1324         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
1325             shaderCaps->fFloatPrecisions[kGeometry_GrShaderType][p] =
1326                                                shaderCaps->fFloatPrecisions[kVertex_GrShaderType][p];
1327         }
1328     }
1329     shaderCaps->initSamplerPrecisionTable();
1330 }
1331
1332 bool GrGLCaps::bgraIsInternalFormat() const {
1333     return fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat == GR_GL_BGRA;
1334 }
1335
1336 bool GrGLCaps::getTexImageFormats(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig,
1337                                   GrGLenum* internalFormat, GrGLenum* externalFormat,
1338                                   GrGLenum* externalType) const {
1339     if (!this->getExternalFormat(surfaceConfig, externalConfig, kTexImage_ExternalFormatUsage,
1340                                  externalFormat, externalType)) {
1341         return false;
1342     }
1343     *internalFormat = fConfigTable[surfaceConfig].fFormats.fInternalFormatTexImage;
1344     return true;
1345 }
1346
1347 bool GrGLCaps::getCompressedTexImageFormats(GrPixelConfig surfaceConfig,
1348                                             GrGLenum* internalFormat) const {
1349     if (!GrPixelConfigIsCompressed(surfaceConfig)) {
1350         return false;
1351     }
1352     *internalFormat = fConfigTable[surfaceConfig].fFormats.fInternalFormatTexImage;
1353     return true;
1354 }
1355
1356 bool GrGLCaps::getReadPixelsFormat(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig,
1357                                    GrGLenum* externalFormat, GrGLenum* externalType) const {
1358     if (!this->getExternalFormat(surfaceConfig, externalConfig, kOther_ExternalFormatUsage,
1359                                  externalFormat, externalType)) {
1360         return false;
1361     }
1362     return true;
1363 }
1364
1365 bool GrGLCaps::getRenderbufferFormat(GrPixelConfig config, GrGLenum* internalFormat) const {
1366     if (GrPixelConfigIsCompressed(config)) {
1367         return false;
1368     }
1369     *internalFormat = fConfigTable[config].fFormats.fInternalFormatRenderbuffer;
1370     return true;
1371 }
1372
1373 bool GrGLCaps::getExternalFormat(GrPixelConfig surfaceConfig, GrPixelConfig memoryConfig,
1374                                  ExternalFormatUsage usage, GrGLenum* externalFormat,
1375                                  GrGLenum* externalType) const {
1376     SkASSERT(externalFormat && externalType);
1377     if (GrPixelConfigIsCompressed(memoryConfig)) {
1378         return false;
1379     }
1380
1381     bool surfaceIsAlphaOnly = GrPixelConfigIsAlphaOnly(surfaceConfig);
1382     bool memoryIsAlphaOnly = GrPixelConfigIsAlphaOnly(memoryConfig);
1383
1384     // We don't currently support moving RGBA data into and out of ALPHA surfaces. It could be
1385     // made to work in many cases using glPixelStore and what not but is not needed currently.
1386     if (surfaceIsAlphaOnly && !memoryIsAlphaOnly) {
1387         return false;
1388     }
1389
1390     *externalFormat = fConfigTable[memoryConfig].fFormats.fExternalFormat[usage];
1391     *externalType = fConfigTable[memoryConfig].fFormats.fExternalType;
1392
1393     // When GL_RED is supported as a texture format, our alpha-only textures are stored using
1394     // GL_RED and we swizzle in order to map all components to 'r'. However, in this case the
1395     // surface is not alpha-only and we want alpha to really mean the alpha component of the
1396     // texture, not the red component.
1397     if (memoryIsAlphaOnly && !surfaceIsAlphaOnly) {
1398         if (this->textureRedSupport()) {
1399             SkASSERT(GR_GL_RED == *externalFormat);
1400             *externalFormat = GR_GL_ALPHA;
1401         }
1402     }
1403
1404     return true;
1405 }
1406
1407 void GrGLCaps::initConfigTable(const GrContextOptions& contextOptions,
1408                                const GrGLContextInfo& ctxInfo, const GrGLInterface* gli,
1409                                GrShaderCaps* shaderCaps) {
1410     /*
1411         Comments on renderability of configs on various GL versions.
1412           OpenGL < 3.0:
1413             no built in support for render targets.
1414             GL_EXT_framebuffer_object adds possible support for any sized format with base internal
1415               format RGB, RGBA and NV float formats we don't use.
1416               This is the following:
1417                 R3_G3_B2, RGB4, RGB5, RGB8, RGB10, RGB12, RGB16, RGBA2, RGBA4, RGB5_A1, RGBA8
1418                 RGB10_A2, RGBA12,RGBA16
1419               Though, it is hard to believe the more obscure formats such as RGBA12 would work
1420               since they aren't required by later standards and the driver can simply return
1421               FRAMEBUFFER_UNSUPPORTED for anything it doesn't allow.
1422             GL_ARB_framebuffer_object adds everything added by the EXT extension and additionally
1423               any sized internal format with a base internal format of ALPHA, LUMINANCE,
1424               LUMINANCE_ALPHA, INTENSITY, RED, and RG.
1425               This adds a lot of additional renderable sized formats, including ALPHA8.
1426               The GL_ARB_texture_rg brings in the RED and RG formats (8, 8I, 8UI, 16, 16I, 16UI,
1427               16F, 32I, 32UI, and 32F variants).
1428               Again, the driver has an escape hatch via FRAMEBUFFER_UNSUPPORTED.
1429
1430             For both the above extensions we limit ourselves to those that are also required by
1431             OpenGL 3.0.
1432
1433           OpenGL 3.0:
1434             Any format with base internal format ALPHA, RED, RG, RGB or RGBA is "color-renderable"
1435             but are not required to be supported as renderable textures/renderbuffer.
1436             Required renderable color formats:
1437                 - RGBA32F, RGBA32I, RGBA32UI, RGBA16, RGBA16F, RGBA16I,
1438                   RGBA16UI, RGBA8, RGBA8I, RGBA8UI, SRGB8_ALPHA8, and
1439                   RGB10_A2.
1440                 - R11F_G11F_B10F.
1441                 - RG32F, RG32I, RG32UI, RG16, RG16F, RG16I, RG16UI, RG8, RG8I,
1442                   and RG8UI.
1443                 - R32F, R32I, R32UI, R16F, R16I, R16UI, R16, R8, R8I, and R8UI.
1444                 - ALPHA8
1445
1446           OpenGL 3.1, 3.2, 3.3
1447             Same as 3.0 except ALPHA8 requires GL_ARB_compatibility/compatibility profile.
1448           OpengGL 3.3, 4.0, 4.1
1449             Adds RGB10_A2UI.
1450           OpengGL 4.2
1451             Adds
1452                 - RGB5_A1, RGBA4
1453                 - RGB565
1454           OpenGL 4.4
1455             Does away with the separate list and adds a column to the sized internal color format
1456             table. However, no new formats become required color renderable.
1457
1458           ES 2.0
1459             color renderable: RGBA4, RGB5_A1, RGB565
1460             GL_EXT_texture_rg adds support for R8, RG5 as a color render target
1461             GL_OES_rgb8_rgba8 adds support for RGB8 and RGBA8
1462             GL_ARM_rgba8 adds support for RGBA8 (but not RGB8)
1463             GL_EXT_texture_format_BGRA8888 does not add renderbuffer support
1464             GL_CHROMIUM_renderbuffer_format_BGRA8888 adds BGRA8 as color-renderable
1465             GL_APPLE_texture_format_BGRA8888 does not add renderbuffer support
1466
1467           ES 3.0
1468                 - RGBA32I, RGBA32UI, RGBA16I, RGBA16UI, RGBA8, RGBA8I,
1469                   RGBA8UI, SRGB8_ALPHA8, RGB10_A2, RGB10_A2UI, RGBA4, and
1470                   RGB5_A1.
1471                 - RGB8 and RGB565.
1472                 - RG32I, RG32UI, RG16I, RG16UI, RG8, RG8I, and RG8UI.
1473                 - R32I, R32UI, R16I, R16UI, R8, R8I, and R8UI
1474           ES 3.1
1475             Adds RGB10_A2, RGB10_A2UI,
1476           ES 3.2
1477             Adds R16F, RG16F, RGBA16F, R32F, RG32F, RGBA32F, R11F_G11F_B10F.
1478     */
1479     uint32_t nonMSAARenderFlags = ConfigInfo::kRenderable_Flag |
1480                                   ConfigInfo::kFBOColorAttachment_Flag;
1481     uint32_t allRenderFlags = nonMSAARenderFlags;
1482     if (kNone_MSFBOType != fMSFBOType) {
1483         allRenderFlags |= ConfigInfo::kRenderableWithMSAA_Flag;
1484     }
1485     GrGLStandard standard = ctxInfo.standard();
1486     GrGLVersion version = ctxInfo.version();
1487
1488     bool texStorageSupported = false;
1489     if (kGL_GrGLStandard == standard) {
1490         // The EXT version can apply to either GL or GLES.
1491         texStorageSupported = version >= GR_GL_VER(4,2) ||
1492                               ctxInfo.hasExtension("GL_ARB_texture_storage") ||
1493                               ctxInfo.hasExtension("GL_EXT_texture_storage");
1494     } else {
1495         texStorageSupported = version >= GR_GL_VER(3,0) ||
1496                               ctxInfo.hasExtension("GL_EXT_texture_storage");
1497     }
1498
1499     // TODO: remove after command buffer supports full ES 3.0
1500     if (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0) &&
1501         kChromium_GrGLDriver == ctxInfo.driver()) {
1502         texStorageSupported = false;
1503     }
1504
1505     bool texelBufferSupport = this->shaderCaps()->texelBufferSupport();
1506
1507     fConfigTable[kUnknown_GrPixelConfig].fFormats.fBaseInternalFormat = 0;
1508     fConfigTable[kUnknown_GrPixelConfig].fFormats.fSizedInternalFormat = 0;
1509     fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
1510     fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalType = 0;
1511     fConfigTable[kUnknown_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1512     fConfigTable[kUnknown_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1513
1514     fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1515     fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
1516     fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1517         GR_GL_RGBA;
1518     fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
1519     fConfigTable[kRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1520     fConfigTable[kRGBA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1521     if (kGL_GrGLStandard == standard) {
1522         // We require some form of FBO support and all GLs with FBO support can render to RGBA8
1523         fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= allRenderFlags;
1524     } else {
1525         if (version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_OES_rgb8_rgba8") ||
1526             ctxInfo.hasExtension("GL_ARM_rgba8")) {
1527             fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= allRenderFlags;
1528         }
1529     }
1530     if (texStorageSupported) {
1531         fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1532     }
1533     if (texelBufferSupport) {
1534         fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1535     }
1536     fConfigTable[kRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1537
1538     fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1539         GR_GL_BGRA;
1540     fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalType  = GR_GL_UNSIGNED_BYTE;
1541     fConfigTable[kBGRA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1542     if (kGL_GrGLStandard == standard) {
1543         fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1544         fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
1545         if (version >= GR_GL_VER(1, 2) || ctxInfo.hasExtension("GL_EXT_bgra")) {
1546             // Since the internal format is RGBA8, it is also renderable.
1547             fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1548                                                             allRenderFlags;
1549         }
1550     } else {
1551         fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_BGRA;
1552         fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_BGRA8;
1553         if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) {
1554             // The APPLE extension doesn't make this renderable.
1555             fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1556             if (version < GR_GL_VER(3,0) && !ctxInfo.hasExtension("GL_EXT_texture_storage")) {
1557                 // On ES2 the internal format of a BGRA texture is RGBA with the APPLE extension.
1558                 // Though, that seems to not be the case if the texture storage extension is
1559                 // present. The specs don't exactly make that clear.
1560                 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1561                 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
1562             }
1563         } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) {
1564             fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1565                                                             nonMSAARenderFlags;
1566             if (ctxInfo.hasExtension("GL_CHROMIUM_renderbuffer_format_BGRA8888") &&
1567                 (this->usesMSAARenderBuffers() || this->fMSFBOType == kMixedSamples_MSFBOType)) {
1568                 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |=
1569                     ConfigInfo::kRenderableWithMSAA_Flag;
1570             }
1571         }
1572     }
1573     if (texStorageSupported) {
1574         fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1575     }
1576     fConfigTable[kBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1577
1578     // We only enable srgb support if both textures and FBOs support srgb,
1579     // *and* we can disable sRGB decode-on-read, to support "legacy" mode.
1580     if (kGL_GrGLStandard == standard) {
1581         if (ctxInfo.version() >= GR_GL_VER(3,0)) {
1582             fSRGBSupport = true;
1583         } else if (ctxInfo.hasExtension("GL_EXT_texture_sRGB")) {
1584             if (ctxInfo.hasExtension("GL_ARB_framebuffer_sRGB") ||
1585                 ctxInfo.hasExtension("GL_EXT_framebuffer_sRGB")) {
1586                 fSRGBSupport = true;
1587             }
1588         }
1589         // All the above srgb extensions support toggling srgb writes
1590         if (fSRGBSupport) {
1591             fSRGBWriteControl = true;
1592         }
1593     } else {
1594         fSRGBSupport = ctxInfo.version() >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_sRGB");
1595 #if defined(SK_CPU_X86)
1596         if (kPowerVRRogue_GrGLRenderer == ctxInfo.renderer()) {
1597             // NexusPlayer has strange bugs with sRGB (skbug.com/4148). This is a targeted fix to
1598             // blacklist that device (and any others that might be sharing the same driver).
1599             fSRGBSupport = false;
1600         }
1601 #endif
1602         // ES through 3.1 requires EXT_srgb_write_control to support toggling
1603         // sRGB writing for destinations.
1604         // See https://bug.skia.org/5329 for Adreno4xx issue.
1605         fSRGBWriteControl = kAdreno4xx_GrGLRenderer != ctxInfo.renderer() &&
1606             ctxInfo.hasExtension("GL_EXT_sRGB_write_control");
1607     }
1608     if (contextOptions.fRequireDecodeDisableForSRGB && !fSRGBDecodeDisableSupport) {
1609         // To support "legacy" L32 mode, we require the ability to turn off sRGB decode. Clients
1610         // can opt-out of that requirement, if they intend to always do linear blending.
1611         fSRGBSupport = false;
1612     }
1613
1614     // This is very conservative, if we're on a platform where N32 is BGRA, and using ES, disable
1615     // all sRGB support. Too much code relies on creating surfaces with N32 + sRGB colorspace,
1616     // and sBGRA is basically impossible to support on any version of ES (with our current code).
1617     // In particular, ES2 doesn't support sBGRA at all, and even in ES3, there is no valid pair
1618     // of formats that can be used for TexImage calls to upload BGRA data to sRGBA (which is what
1619     // we *have* to use as the internal format, because sBGRA doesn't exist). This primarily
1620     // affects Windows.
1621     if (kSkia8888_GrPixelConfig == kBGRA_8888_GrPixelConfig && kGLES_GrGLStandard == standard) {
1622         fSRGBSupport = false;
1623     }
1624
1625     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA;
1626     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
1627     // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the
1628     // external format is GL_RGBA. See below for note about ES2.0 and glTex[Sub]Image.
1629     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1630         GR_GL_RGBA;
1631     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
1632     fConfigTable[kSRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1633     if (fSRGBSupport) {
1634         fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1635                                                          allRenderFlags;
1636     }
1637     if (texStorageSupported) {
1638         fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1639     }
1640     fConfigTable[kSRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1641     // sBGRA is not a "real" thing in OpenGL, but GPUs support it, and on platforms where
1642     // kN32 == BGRA, we need some way to work with it. (The default framebuffer on Windows
1643     // is in this format, for example).
1644     fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA;
1645     fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
1646     // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the
1647     // external format is GL_BGRA.
1648     fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1649         GR_GL_BGRA;
1650     fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
1651     fConfigTable[kSBGRA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1652     if (fSRGBSupport && kGL_GrGLStandard == standard) {
1653         fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1654             allRenderFlags;
1655     }
1656
1657     if (texStorageSupported) {
1658         fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1659     }
1660     fConfigTable[kSBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1661
1662     bool hasIntegerTextures;
1663     if (standard == kGL_GrGLStandard) {
1664         hasIntegerTextures = version >= GR_GL_VER(3, 0) ||
1665                              ctxInfo.hasExtension("GL_EXT_texture_integer");
1666     } else {
1667         hasIntegerTextures = (version >= GR_GL_VER(3, 0));
1668     }
1669     // We may have limited GLSL to an earlier version that doesn't have integer sampler types.
1670     if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) {
1671         hasIntegerTextures = false;
1672     }
1673     fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fBaseInternalFormat  = GR_GL_RGBA_INTEGER;
1674     fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8I;
1675     fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = GR_GL_RGBA_INTEGER;
1676     fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fExternalType = GR_GL_BYTE;
1677     fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormatType = kInteger_FormatType;
1678     // We currently only support using integer textures as srcs, not for rendering (even though GL
1679     // allows it).
1680     if (hasIntegerTextures) {
1681         fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1682                                                              ConfigInfo::kFBOColorAttachment_Flag;
1683         if (texStorageSupported) {
1684             fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFlags |=
1685                 ConfigInfo::kCanUseTexStorage_Flag;
1686         }
1687     }
1688
1689     fConfigTable[kRGB_565_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGB;
1690     if (this->ES2CompatibilitySupport()) {
1691         fConfigTable[kRGB_565_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB565;
1692     } else {
1693         fConfigTable[kRGB_565_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB5;
1694     }
1695     fConfigTable[kRGB_565_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1696         GR_GL_RGB;
1697     fConfigTable[kRGB_565_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_SHORT_5_6_5;
1698     fConfigTable[kRGB_565_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1699     fConfigTable[kRGB_565_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1700     if (kGL_GrGLStandard == standard) {
1701         if (version >= GR_GL_VER(4, 2) || ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {
1702             fConfigTable[kRGB_565_GrPixelConfig].fFlags |= allRenderFlags;
1703         }
1704     } else {
1705         fConfigTable[kRGB_565_GrPixelConfig].fFlags |= allRenderFlags;
1706     }
1707     // 565 is not a sized internal format on desktop GL. So on desktop with
1708     // 565 we always use an unsized internal format to let the system pick
1709     // the best sized format to convert the 565 data to. Since TexStorage
1710     // only allows sized internal formats we disallow it.
1711     //
1712     // TODO: As of 4.2, regular GL supports 565. This logic is due for an
1713     // update.
1714     if (texStorageSupported && kGL_GrGLStandard != standard) {
1715         fConfigTable[kRGB_565_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1716     }
1717     fConfigTable[kRGB_565_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1718
1719     fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1720     fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA4;
1721     fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1722         GR_GL_RGBA;
1723     fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
1724     fConfigTable[kRGBA_4444_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1725     fConfigTable[kRGBA_4444_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1726     if (kGL_GrGLStandard == standard) {
1727         if (version >= GR_GL_VER(4, 2)) {
1728             fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= allRenderFlags;
1729         }
1730     } else {
1731         fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= allRenderFlags;
1732     }
1733     if (texStorageSupported) {
1734         fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1735     }
1736     fConfigTable[kRGBA_4444_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1737
1738     fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
1739     fConfigTable[kAlpha_8_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1740     fConfigTable[kAlpha_8_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1741     if (this->textureRedSupport()) {
1742         fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED;
1743         fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R8;
1744         fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1745             GR_GL_RED;
1746         fConfigTable[kAlpha_8_GrPixelConfig].fSwizzle = GrSwizzle::RRRR();
1747         if (texelBufferSupport) {
1748             fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1749         }
1750     } else {
1751         fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_ALPHA;
1752         fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_ALPHA8;
1753         fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1754             GR_GL_ALPHA;
1755         fConfigTable[kAlpha_8_GrPixelConfig].fSwizzle = GrSwizzle::AAAA();
1756     }
1757     if (this->textureRedSupport() ||
1758         (kStandard_MSFBOType == this->msFBOType() && ctxInfo.renderer() != kOSMesa_GrGLRenderer)) {
1759         // OpenGL 3.0+ (and GL_ARB_framebuffer_object) supports ALPHA8 as renderable.
1760         // However, osmesa fails if it used even when GL_ARB_framebuffer_object is present.
1761         // Core profile removes ALPHA8 support, but we should have chosen R8 in that case.
1762         fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= allRenderFlags;
1763     }
1764     if (texStorageSupported) {
1765         fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1766     }
1767
1768     fConfigTable[kGray_8_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
1769     fConfigTable[kGray_8_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1770     fConfigTable[kGray_8_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1771     if (this->textureRedSupport()) {
1772         fConfigTable[kGray_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED;
1773         fConfigTable[kGray_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R8;
1774         fConfigTable[kGray_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1775             GR_GL_RED;
1776         fConfigTable[kGray_8_GrPixelConfig].fSwizzle = GrSwizzle::RRRA();
1777         if (texelBufferSupport) {
1778             fConfigTable[kGray_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1779         }
1780     } else {
1781         fConfigTable[kGray_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_LUMINANCE;
1782         fConfigTable[kGray_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_LUMINANCE8;
1783         fConfigTable[kGray_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1784             GR_GL_LUMINANCE;
1785         fConfigTable[kGray_8_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1786     }
1787 #if 0 // Leaving Gray8 as non-renderable, to keep things simple and match raster
1788     if (this->textureRedSupport() ||
1789         (kDesktop_ARB_MSFBOType == this->msFBOType() &&
1790          ctxInfo.renderer() != kOSMesa_GrGLRenderer)) {
1791         // desktop ARB extension/3.0+ supports LUMINANCE8 as renderable.
1792         // However, osmesa fails if it used even when GL_ARB_framebuffer_object is present.
1793         // Core profile removes LUMINANCE8 support, but we should have chosen R8 in that case.
1794         fConfigTable[kGray_8_GrPixelConfig].fFlags |= allRenderFlags;
1795     }
1796 #endif
1797     if (texStorageSupported) {
1798         fConfigTable[kGray_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1799     }
1800
1801     // Check for [half] floating point texture support
1802     // NOTE: We disallow floating point textures on ES devices if linear filtering modes are not
1803     // supported. This is for simplicity, but a more granular approach is possible. Coincidentally,
1804     // [half] floating point textures became part of the standard in ES3.1 / OGL 3.0.
1805     bool hasFPTextures = false;
1806     bool hasHalfFPTextures = false;
1807     bool rgIsTexturable = false;
1808     // for now we don't support floating point MSAA on ES
1809     uint32_t fpRenderFlags = (kGL_GrGLStandard == standard) ? allRenderFlags : nonMSAARenderFlags;
1810
1811     if (kGL_GrGLStandard == standard) {
1812         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_texture_float")) {
1813             hasFPTextures = true;
1814             hasHalfFPTextures = true;
1815             rgIsTexturable = true;
1816         }
1817     } else {
1818         if (version >= GR_GL_VER(3, 1)) {
1819             hasFPTextures = true;
1820             hasHalfFPTextures = true;
1821             rgIsTexturable = true;
1822         } else {
1823             if (ctxInfo.hasExtension("GL_OES_texture_float_linear") &&
1824                 ctxInfo.hasExtension("GL_OES_texture_float")) {
1825                 hasFPTextures = true;
1826             }
1827             if (ctxInfo.hasExtension("GL_OES_texture_half_float_linear") &&
1828                 ctxInfo.hasExtension("GL_OES_texture_half_float")) {
1829                 hasHalfFPTextures = true;
1830             }
1831         }
1832     }
1833
1834     for (auto fpconfig : {kRGBA_float_GrPixelConfig, kRG_float_GrPixelConfig}) {
1835         const GrGLenum format = kRGBA_float_GrPixelConfig == fpconfig ? GR_GL_RGBA : GR_GL_RG;
1836         fConfigTable[fpconfig].fFormats.fBaseInternalFormat = format;
1837         fConfigTable[fpconfig].fFormats.fSizedInternalFormat =
1838             kRGBA_float_GrPixelConfig == fpconfig ? GR_GL_RGBA32F : GR_GL_RG32F;
1839         fConfigTable[fpconfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = format;
1840         fConfigTable[fpconfig].fFormats.fExternalType = GR_GL_FLOAT;
1841         fConfigTable[fpconfig].fFormatType = kFloat_FormatType;
1842         if (hasFPTextures) {
1843             fConfigTable[fpconfig].fFlags = rgIsTexturable ? ConfigInfo::kTextureable_Flag : 0;
1844             // For now we only enable rendering to float on desktop, because on ES we'd have to
1845             // solve many precision issues and no clients actually want this yet.
1846             if (kGL_GrGLStandard == standard /* || version >= GR_GL_VER(3,2) ||
1847                 ctxInfo.hasExtension("GL_EXT_color_buffer_float")*/) {
1848                 fConfigTable[fpconfig].fFlags |= fpRenderFlags;
1849             }
1850         }
1851         if (texStorageSupported) {
1852             fConfigTable[fpconfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1853         }
1854         if (texelBufferSupport) {
1855             fConfigTable[fpconfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1856         }
1857         fConfigTable[fpconfig].fSwizzle = GrSwizzle::RGBA();
1858     }
1859
1860     if (this->textureRedSupport()) {
1861         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED;
1862         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R16F;
1863         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage]
1864             = GR_GL_RED;
1865         fConfigTable[kAlpha_half_GrPixelConfig].fSwizzle = GrSwizzle::RRRR();
1866         if (texelBufferSupport) {
1867             fConfigTable[kAlpha_half_GrPixelConfig].fFlags |=
1868                 ConfigInfo::kCanUseWithTexelBuffer_Flag;
1869         }
1870     } else {
1871         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_ALPHA;
1872         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_ALPHA16F;
1873         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage]
1874             = GR_GL_ALPHA;
1875         fConfigTable[kAlpha_half_GrPixelConfig].fSwizzle = GrSwizzle::AAAA();
1876     }
1877     // ANGLE always returns GL_HALF_FLOAT_OES for GL_IMPLEMENTATION_COLOR_READ_TYPE, even though
1878     // ES3 would typically return GL_HALF_FLOAT. The correct fix is for us to respect the value
1879     // returned when we query, but that turns into a bigger refactor, so just work around it.
1880     if (kGL_GrGLStandard == ctxInfo.standard() ||
1881         (ctxInfo.version() >= GR_GL_VER(3, 0) && kANGLE_GrGLDriver != ctxInfo.driver())) {
1882         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT;
1883     } else {
1884         fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT_OES;
1885     }
1886     fConfigTable[kAlpha_half_GrPixelConfig].fFormatType = kFloat_FormatType;
1887     if (texStorageSupported) {
1888         fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1889     }
1890     if (hasHalfFPTextures) {
1891         fConfigTable[kAlpha_half_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1892         // ES requires either 3.2 or the combination of EXT_color_buffer_half_float and support for
1893         // GL_RED internal format.
1894         if (kGL_GrGLStandard == standard || version >= GR_GL_VER(3, 2) ||
1895             (this->textureRedSupport() &&
1896              ctxInfo.hasExtension("GL_EXT_color_buffer_half_float"))) {
1897             fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= fpRenderFlags;
1898         }
1899     }
1900
1901     fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1902     fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA16F;
1903     fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1904         GR_GL_RGBA;
1905     // See comment above, re: ANGLE and ES3.
1906     if (kGL_GrGLStandard == ctxInfo.standard() ||
1907         (ctxInfo.version() >= GR_GL_VER(3, 0) && kANGLE_GrGLDriver != ctxInfo.driver())) {
1908         fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT;
1909     } else {
1910         fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT_OES;
1911     }
1912     fConfigTable[kRGBA_half_GrPixelConfig].fFormatType = kFloat_FormatType;
1913     if (hasHalfFPTextures) {
1914         fConfigTable[kRGBA_half_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1915         // ES requires 3.2 or EXT_color_buffer_half_float.
1916         if (kGL_GrGLStandard == standard || version >= GR_GL_VER(3,2) ||
1917              ctxInfo.hasExtension("GL_EXT_color_buffer_half_float")) {
1918             fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= fpRenderFlags;
1919         }
1920     }
1921     if (texStorageSupported) {
1922         fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1923     }
1924     if (texelBufferSupport) {
1925         fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1926     }
1927     fConfigTable[kRGBA_half_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1928
1929     // Compressed texture support
1930
1931     // glCompressedTexImage2D is available on all OpenGL ES devices. It is available on standard
1932     // OpenGL after version 1.3. We'll assume at least that level of OpenGL support.
1933
1934     // TODO: Fix command buffer bindings and remove this.
1935     fCompressedTexSubImageSupport = SkToBool(gli->fFunctions.fCompressedTexSubImage2D);
1936
1937     // No sized/unsized internal format distinction for compressed formats, no external format.
1938     // Below we set the external formats and types to 0.
1939     {
1940         fConfigTable[kETC1_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
1941         fConfigTable[kETC1_GrPixelConfig].fFormats.fSizedInternalFormat =
1942                                                                          GR_GL_COMPRESSED_ETC1_RGB8;
1943         fConfigTable[kETC1_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
1944         fConfigTable[kETC1_GrPixelConfig].fFormats.fExternalType = 0;
1945         fConfigTable[kETC1_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1946         if (kGL_GrGLStandard == standard) {
1947             if (version >= GR_GL_VER(4, 3) || ctxInfo.hasExtension("GL_ARB_ES3_compatibility")) {
1948                 fConfigTable[kETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1949             }
1950         } else {
1951             if (version >= GR_GL_VER(3, 0) ||
1952                 ctxInfo.hasExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
1953                 // ETC2 is a superset of ETC1, so we can just check for that, too.
1954                 (ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGB8_texture") &&
1955                  ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGBA8_texture"))) {
1956                 fConfigTable[kETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1957             }
1958         }
1959         fConfigTable[kETC1_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1960     }
1961
1962     // Bulk populate the texture internal/external formats here and then deal with exceptions below.
1963
1964     // ES 2.0 requires that the internal/external formats match.
1965     bool useSizedTexFormats = (kGL_GrGLStandard == ctxInfo.standard() ||
1966                                ctxInfo.version() >= GR_GL_VER(3,0));
1967     // All ES versions (thus far) require sized internal formats for render buffers.
1968     // TODO: Always use sized internal format?
1969     bool useSizedRbFormats = kGLES_GrGLStandard == ctxInfo.standard();
1970
1971     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
1972         // Almost always we want to pass fExternalFormat[kOther_ExternalFormatUsage] as the <format>
1973         // param to glTex[Sub]Image.
1974         fConfigTable[i].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage] =
1975             fConfigTable[i].fFormats.fExternalFormat[kOther_ExternalFormatUsage];
1976         fConfigTable[i].fFormats.fInternalFormatTexImage = useSizedTexFormats ?
1977             fConfigTable[i].fFormats.fSizedInternalFormat :
1978             fConfigTable[i].fFormats.fBaseInternalFormat;
1979         fConfigTable[i].fFormats.fInternalFormatRenderbuffer = useSizedRbFormats ?
1980             fConfigTable[i].fFormats.fSizedInternalFormat :
1981             fConfigTable[i].fFormats.fBaseInternalFormat;
1982     }
1983     // OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format>
1984     // param to Tex(Sub)Image. ES 2.0 requires the <internalFormat> and <format> params to match.
1985     // Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the <format> param.
1986     // On OpenGL and ES 3.0+ GL_SRGB_ALPHA does not work for the <format> param to glTexImage.
1987     if (ctxInfo.standard() == kGLES_GrGLStandard && ctxInfo.version() == GR_GL_VER(2,0)) {
1988         fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage] =
1989             GR_GL_SRGB_ALPHA;
1990
1991         // Additionally, because we had to "invent" sBGRA, there is no way to make it work
1992         // in ES 2.0, because there is no <internalFormat> we can use. So just make that format
1993         // unsupported. (If we have no sRGB support at all, this will get overwritten below).
1994         fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = 0;
1995     }
1996
1997     // If BGRA is supported as an internal format it must always be specified to glTex[Sub]Image
1998     // as a base format.
1999     // GL_EXT_texture_format_BGRA8888:
2000     //      This extension GL_BGRA as an unsized internal format. However, it is written against ES
2001     //      2.0 and therefore doesn't define a value for GL_BGRA8 as ES 2.0 uses unsized internal
2002     //      formats.
2003     // GL_APPLE_texture_format_BGRA8888:
2004     //     ES 2.0: the extension makes BGRA an external format but not an internal format.
2005     //     ES 3.0: the extension explicitly states GL_BGRA8 is not a valid internal format for
2006     //             glTexImage (just for glTexStorage).
2007     if (useSizedTexFormats && this->bgraIsInternalFormat())  {
2008         fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fInternalFormatTexImage = GR_GL_BGRA;
2009     }
2010
2011     // If we don't have texture swizzle support then the shader generator must insert the
2012     // swizzle into shader code.
2013     if (!this->textureSwizzleSupport()) {
2014         for (int i = 0; i < kGrPixelConfigCnt; ++i) {
2015             shaderCaps->fConfigTextureSwizzle[i] = fConfigTable[i].fSwizzle;
2016         }
2017     }
2018
2019     // Shader output swizzles will default to RGBA. When we've use GL_RED instead of GL_ALPHA to
2020     // implement kAlpha_8_GrPixelConfig we need to swizzle the shader outputs so the alpha channel
2021     // gets written to the single component.
2022     if (this->textureRedSupport()) {
2023         for (int i = 0; i < kGrPixelConfigCnt; ++i) {
2024             GrPixelConfig config = static_cast<GrPixelConfig>(i);
2025             if (GrPixelConfigIsAlphaOnly(config) &&
2026                 fConfigTable[i].fFormats.fBaseInternalFormat == GR_GL_RED) {
2027                 shaderCaps->fConfigOutputSwizzle[i] = GrSwizzle::AAAA();
2028             }
2029         }
2030     }
2031
2032     // We currently only support images on rgba textures formats. We could add additional formats
2033     // if desired. The shader builder would have to be updated to add swizzles where appropriate
2034     // (e.g. where we use GL_RED textures to implement alpha configs).
2035     if (this->shaderCaps()->imageLoadStoreSupport()) {
2036         fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFlags |=
2037                 ConfigInfo::kCanUseAsImageStorage_Flag;
2038         // In OpenGL ES a texture may only be used with BindImageTexture if it has been made
2039         // immutable via TexStorage. We create non-integer textures as mutable textures using
2040         // TexImage because we may lazily add MIP levels. Thus, on ES we currently disable image
2041         // storage support for non-integer textures.
2042         if (kGL_GrGLStandard == ctxInfo.standard()) {
2043             fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseAsImageStorage_Flag;
2044             fConfigTable[kRGBA_float_GrPixelConfig].fFlags |=
2045                     ConfigInfo::kCanUseAsImageStorage_Flag;
2046             fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseAsImageStorage_Flag;
2047         }
2048     }
2049
2050 #ifdef SK_DEBUG
2051     // Make sure we initialized everything.
2052     ConfigInfo defaultEntry;
2053     for (int i = 0; i < kGrPixelConfigCnt; ++i) {
2054         // Make sure we didn't set renderable and not blittable or renderable with msaa and not
2055         // renderable.
2056         SkASSERT(!((ConfigInfo::kRenderable_Flag) && !(ConfigInfo::kFBOColorAttachment_Flag)));
2057         SkASSERT(!((ConfigInfo::kRenderableWithMSAA_Flag) && !(ConfigInfo::kRenderable_Flag)));
2058         SkASSERT(defaultEntry.fFormats.fBaseInternalFormat !=
2059                  fConfigTable[i].fFormats.fBaseInternalFormat);
2060         SkASSERT(defaultEntry.fFormats.fSizedInternalFormat !=
2061                  fConfigTable[i].fFormats.fSizedInternalFormat);
2062         for (int j = 0; j < kExternalFormatUsageCnt; ++j) {
2063             SkASSERT(defaultEntry.fFormats.fExternalFormat[j] !=
2064                      fConfigTable[i].fFormats.fExternalFormat[j]);
2065         }
2066         SkASSERT(defaultEntry.fFormats.fExternalType != fConfigTable[i].fFormats.fExternalType);
2067     }
2068 #endif
2069 }
2070
2071 bool GrGLCaps::initDescForDstCopy(const GrRenderTargetProxy* src, GrSurfaceDesc* desc,
2072                                   bool* rectsMustMatch, bool* disallowSubrect) const {
2073     // By default, we don't require rects to match.
2074     *rectsMustMatch = false;
2075
2076     // By default, we allow subrects.
2077     *disallowSubrect = false;
2078
2079     // If the src is a texture, we can implement the blit as a draw assuming the config is
2080     // renderable.
2081     if (src->asTextureProxy() && this->isConfigRenderable(src->config(), false)) {
2082         desc->fOrigin = kBottomLeft_GrSurfaceOrigin;
2083         desc->fFlags = kRenderTarget_GrSurfaceFlag;
2084         desc->fConfig = src->config();
2085         return true;
2086     }
2087
2088     {
2089         // The only way we could see a non-GR_GL_TEXTURE_2D texture would be if it were
2090         // wrapped. In that case the proxy would already be instantiated.
2091         const GrTexture* srcTexture = src->priv().peekTexture();
2092         const GrGLTexture* glSrcTexture = static_cast<const GrGLTexture*>(srcTexture);
2093         if (glSrcTexture && glSrcTexture->target() != GR_GL_TEXTURE_2D) {
2094             // Not supported for FBO blit or CopyTexSubImage
2095             return false;
2096         }
2097     }
2098
2099     // We look for opportunities to use CopyTexSubImage, or fbo blit. If neither are
2100     // possible and we return false to fallback to creating a render target dst for render-to-
2101     // texture. This code prefers CopyTexSubImage to fbo blit and avoids triggering temporary fbo
2102     // creation. It isn't clear that avoiding temporary fbo creation is actually optimal.
2103     GrSurfaceOrigin originForBlitFramebuffer = kDefault_GrSurfaceOrigin;
2104     bool rectsMustMatchForBlitFramebuffer = false;
2105     bool disallowSubrectForBlitFramebuffer = false;
2106     if (src->numColorSamples() &&
2107         (this->blitFramebufferSupportFlags() & kResolveMustBeFull_BlitFrambufferFlag)) {
2108         rectsMustMatchForBlitFramebuffer = true;
2109         disallowSubrectForBlitFramebuffer = true;
2110         // Mirroring causes rects to mismatch later, don't allow it.
2111         originForBlitFramebuffer = src->origin();
2112     } else if (src->numColorSamples() && (this->blitFramebufferSupportFlags() &
2113                                           kRectsMustMatchForMSAASrc_BlitFramebufferFlag)) {
2114         rectsMustMatchForBlitFramebuffer = true;
2115         // Mirroring causes rects to mismatch later, don't allow it.
2116         originForBlitFramebuffer = src->origin();
2117     } else if (this->blitFramebufferSupportFlags() & kNoScalingOrMirroring_BlitFramebufferFlag) {
2118         originForBlitFramebuffer = src->origin();
2119     }
2120
2121     // Check for format issues with glCopyTexSubImage2D
2122     if (this->bgraIsInternalFormat() && kBGRA_8888_GrPixelConfig == src->config()) {
2123         // glCopyTexSubImage2D doesn't work with this config. If the bgra can be used with fbo blit
2124         // then we set up for that, otherwise fail.
2125         if (this->canConfigBeFBOColorAttachment(kBGRA_8888_GrPixelConfig)) {
2126             desc->fOrigin = originForBlitFramebuffer;
2127             desc->fConfig = kBGRA_8888_GrPixelConfig;
2128             *rectsMustMatch = rectsMustMatchForBlitFramebuffer;
2129             *disallowSubrect = disallowSubrectForBlitFramebuffer;
2130             return true;
2131         }
2132         return false;
2133     }
2134
2135     {
2136         bool srcIsMSAARenderbuffer = GrFSAAType::kUnifiedMSAA == src->fsaaType() &&
2137                                      this->usesMSAARenderBuffers();
2138         if (srcIsMSAARenderbuffer) {
2139             // It's illegal to call CopyTexSubImage2D on a MSAA renderbuffer. Set up for FBO
2140             // blit or fail.
2141             if (this->canConfigBeFBOColorAttachment(src->config())) {
2142                 desc->fOrigin = originForBlitFramebuffer;
2143                 desc->fConfig = src->config();
2144                 *rectsMustMatch = rectsMustMatchForBlitFramebuffer;
2145                 *disallowSubrect = disallowSubrectForBlitFramebuffer;
2146                 return true;
2147             }
2148             return false;
2149         }
2150     }
2151
2152     // We'll do a CopyTexSubImage. Make the dst a plain old texture.
2153     desc->fConfig = src->config();
2154     desc->fOrigin = src->origin();
2155     desc->fFlags = kNone_GrSurfaceFlags;
2156     return true;
2157 }
2158
2159 void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) {
2160     if (options.fEnableInstancedRendering) {
2161         fInstancedSupport = gr_instanced::GLInstancedRendering::CheckSupport(*this);
2162 #ifndef SK_BUILD_FOR_MAC
2163         // OS X doesn't seem to write correctly to floating point textures when using
2164         // glDraw*Indirect, regardless of the underlying GPU.
2165         fAvoidInstancedDrawsToFPTargets = true;
2166 #endif
2167     }
2168 }