Creating functions for uploading a mipmapped texture.

src/gpu/gl/GrGLGpu.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLGpu.h"
 #include "GrGLGLSL.h"
@@ skipping 455 matching lines @@
 
     int maxSize = this->caps()->maxTextureSize();
     if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
         return NULL;
     }
 
     GrGLTexture::IDDesc idDesc;
     GrSurfaceDesc surfDesc;
 
     idDesc.fTextureID = static_cast<GrGLuint>(desc.fTextureHandle);
-    
+
     switch (ownership) {
         case kAdopt_GrWrapOwnership:
             idDesc.fLifeCycle = GrGpuResource::kAdopted_LifeCycle;
             break;
         case kBorrow_GrWrapOwnership:
             idDesc.fLifeCycle = GrGpuResource::kBorrowed_LifeCycle;
             break;
-    }    
+    }
 
     // next line relies on GrBackendTextureDesc's flags matching GrTexture's
     surfDesc.fFlags = (GrSurfaceFlags) desc.fFlags;
     surfDesc.fWidth = desc.fWidth;
     surfDesc.fHeight = desc.fHeight;
     surfDesc.fConfig = desc.fConfig;
     surfDesc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
     bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag);
     // FIXME:  this should be calling resolve_origin(), but Chrome code is currently
     // assuming the old behaviour, which is that backend textures are always
@@ skipping 29 matching lines @@
     idDesc.fRTFBOID = static_cast<GrGLuint>(wrapDesc.fRenderTargetHandle);
     idDesc.fMSColorRenderbufferID = 0;
     idDesc.fTexFBOID = GrGLRenderTarget::kUnresolvableFBOID;
     switch (ownership) {
         case kAdopt_GrWrapOwnership:
             idDesc.fLifeCycle = GrGpuResource::kAdopted_LifeCycle;
             break;
         case kBorrow_GrWrapOwnership:
             idDesc.fLifeCycle = GrGpuResource::kBorrowed_LifeCycle;
             break;
-    }    
+    }
     idDesc.fSampleConfig = GrRenderTarget::kUnified_SampleConfig;
 
     GrSurfaceDesc desc;
     desc.fConfig = wrapDesc.fConfig;
     desc.fFlags = kCheckAllocation_GrSurfaceFlag;
     desc.fWidth = wrapDesc.fWidth;
     desc.fHeight = wrapDesc.fHeight;
     desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount());
     desc.fOrigin = resolve_origin(wrapDesc.fOrigin, true);
 
@@ skipping 79 matching lines @@
 
 static inline GrGLenum check_alloc_error(const GrSurfaceDesc& desc,
                                          const GrGLInterface* interface) {
     if (SkToBool(desc.fFlags & kCheckAllocation_GrSurfaceFlag)) {
         return GR_GL_GET_ERROR(interface);
     } else {
         return CHECK_ALLOC_ERROR(interface);
     }
 }
 
-bool GrGLGpu::uploadTexData(const GrSurfaceDesc& desc,
-                            bool isNewTexture,
-                            int left, int top, int width, int height,
-                            GrPixelConfig dataConfig,
-                            const void* data,
-                            size_t rowBytes) {
-    SkASSERT(data || isNewTexture);
-
-    // If we're uploading compressed data then we should be using uploadCompressedTexData
-    SkASSERT(!GrPixelConfigIsCompressed(dataConfig));
-
-    size_t bpp = GrBytesPerPixel(dataConfig);
-    if (!adjust_pixel_ops_params(desc.fWidth, desc.fHeight, bpp, &left, &top,
-                                 &width, &height, &data, &rowBytes)) {
-        return false;
-    }
-    size_t trimRowBytes = width * bpp;
-
-    // in case we need a temporary, trimmed copy of the src pixels
-    SkAutoSMalloc<128 * 128> tempStorage;
-
-    // We currently lazily create MIPMAPs when the we see a draw with
-    // GrTextureParams::kMipMap_FilterMode. Using texture storage requires that the
-    // MIP levels are all created when the texture is created. So for now we don't use
-    // texture storage.
-    bool useTexStorage = false &&
-                         isNewTexture &&
-                         this->glCaps().texStorageSupport();
-
-    if (useTexStorage && kGL_GrGLStandard == this->glStandard()) {
+static bool can_use_tex_storage(const GrGLCaps& caps, const GrGLStandard& standard,
+                                const GrSurfaceDesc& desc) {
+    bool useTexStorage = caps.texStorageSupport();
+    if (useTexStorage && kGL_GrGLStandard == standard) {
         // 565 is not a sized internal format on desktop GL. So on desktop with
         // 565 we always use an unsized internal format to let the system pick
         // the best sized format to convert the 565 data to. Since TexStorage
         // only allows sized internal formats we will instead use TexImage2D.
         useTexStorage = desc.fConfig != kRGB_565_GrPixelConfig;
     }
 
-    GrGLenum internalFormat = 0x0; // suppress warning
-    GrGLenum externalFormat = 0x0; // suppress warning
-    GrGLenum externalType = 0x0;   // suppress warning
-
+    return useTexStorage;
+}
+
+static bool can_use_sized_format(bool useTexStorage, const GrGLCaps& caps,
+                                 const GrGLStandard& standard, const GrGLVersion& version,
+                                 GrPixelConfig dataConfig) {
     // glTexStorage requires sized internal formats on both desktop and ES. ES2 requires an unsized
     // format for glTexImage, unlike ES3 and desktop.
     bool useSizedFormat = useTexStorage;
-    if (kGL_GrGLStandard == this->glStandard() ||
-        (this->glVersion() >= GR_GL_VER(3, 0) &&
+    if (kGL_GrGLStandard == standard ||
+        (version >= GR_GL_VER(3, 0) &&
          // ES3 only works with sized BGRA8 format if "GL_APPLE_texture_format_BGRA8888" enabled
-         (kBGRA_8888_GrPixelConfig != dataConfig || !this->glCaps().bgraIsInternalFormat())))  {
+         (kBGRA_8888_GrPixelConfig != dataConfig || !caps.bgraIsInternalFormat()))) {
         useSizedFormat = true;
     }
 
-    if (!this->configToGLFormats(dataConfig, useSizedFormat, &internalFormat,
-                                 &externalFormat, &externalType)) {
-        return false;
-    }
+    return useSizedFormat;
+}
+
+static void prepare_image_for_writing_to_texture(const GrSurfaceDesc& desc, const GrGLCaps& caps,
+                                                 bool swFlipY, bool glFlipY, int width, int height,
+                                                 int bpp, size_t rowBytes, const void*& data,
+                                                 SkAutoSMalloc<128 * 128>& tempStorage,
+                                                 const GrGLInterface* interface,
+                                                 bool& restoreGLRowLength) {
+    if (NULL == interface) {
+        return;
+    }
+
+    size_t trimRowBytes = width * bpp;
 
     /*
      *  check whether to allocate a temporary buffer for flipping y or
      *  because our srcData has extra bytes past each row. If so, we need
      *  to trim those off here, since GL ES may not let us specify
      *  GL_UNPACK_ROW_LENGTH.
      */
-    bool restoreGLRowLength = false;
+    restoreGLRowLength = false;
+
+    if (caps.unpackRowLengthSupport() && !swFlipY) {
+        // can't use this for flipping, only non-neg values allowed. :(
+        if (rowBytes != trimRowBytes) {
+            GrGLint rowLength = static_cast<GrGLint>(rowBytes / bpp);
+            GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_ROW_LENGTH, rowLength));
+            restoreGLRowLength = true;
+        }
+    } else {
+        if (trimRowBytes != rowBytes || swFlipY) {
+            // copy data into our new storage, skipping the trailing bytes
+            size_t trimSize = height * trimRowBytes;
+            const char* src = (const char*)data;
+            if (swFlipY) {
+                src += (height - 1) * rowBytes;
+            }
+            char* dst = (char*)tempStorage.reset(trimSize);
+            for (int y = 0; y < height; y++) {
+                memcpy(dst, src, trimRowBytes);
+                if (swFlipY) {
+                    src -= rowBytes;
+                } else {
+                    src += rowBytes;
+                }
+                dst += trimRowBytes;
+            }
+            // now point data to our copied version
+            data = tempStorage.get();
+        }
+    }
+    if (glFlipY) {
+        GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_TRUE));
+    }
+    GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_ALIGNMENT,
+                                      static_cast<GrGLint>(GrUnpackAlignment(desc.fConfig))));
+}
+
+static void allocate_and_populate_uncompressed_texture(const GrGLInterface* interface,
+                                                       bool useTexStorage,
+                                                       GrGLenum internalFormat,
+                                                       GrGLenum externalFormat,
+                                                       GrGLenum externalType,
+                                                       const GrSurfaceDesc& desc,
+                                                       SkTArray<const void*>& data,
+                                                       bool& succeeded) {
+    CLEAR_ERROR_BEFORE_ALLOC(interface);
+    if (useTexStorage) {
+        // We never resize or change formats of textures.
+        GL_ALLOC_CALL(interface,
+                      TexStorage2D(GR_GL_TEXTURE_2D,
+                                   data.count(),
+                                   internalFormat,
+                                   desc.fWidth, desc.fHeight));
+    } else {
+        int width = desc.fWidth;
+        int height = desc.fHeight;
+        for (int currentMipLevel = 0; currentMipLevel < data.count(); currentMipLevel++) {
+            GL_ALLOC_CALL(interface,
+                          TexImage2D(GR_GL_TEXTURE_2D,
+                                     currentMipLevel,
+                                     internalFormat,
+                                     width, height,
+                                     0, // border
+                                     externalFormat, externalType,
+                                     data[currentMipLevel]));
+            width /= 2;
+            height /= 2;
+        }
+    }
+
+    GrGLenum error = check_alloc_error(desc, interface);
+    if (error != GR_GL_NO_ERROR) {
+        succeeded = false;
+    } else {
+        int width = desc.fWidth;
+        int height = desc.fHeight;
+        for (int currentMipLevel = data.count(); currentMipLevel != 0; currentMipLevel--) {
+            auto currentMipData = data[currentMipLevel];
+            GR_GL_CALL(interface,
+                       TexSubImage2D(GR_GL_TEXTURE_2D,
+                                     currentMipLevel,
+                                     0, // left
+                                     0, // top
+                                     width, height,
+                                     externalFormat, externalType,
+                                     currentMipData));
+            width /= 2;
+            height /= 2;
+        }
+    }
+}
+
+static bool allocate_and_populate_compressed_texture(const GrGLInterface* interface,
+                                                     bool useTexStorage, GrGLenum internalFormat,
+                                                     const GrSurfaceDesc& desc,
+                                                     SkTArray<const void*>& data,
+                                                     size_t dataSize) {
+    CLEAR_ERROR_BEFORE_ALLOC(interface);
+    if (useTexStorage) {
+        // We never resize or change formats of textures.
+        GL_ALLOC_CALL(interface,
+                      TexStorage2D(GR_GL_TEXTURE_2D,
+                                   data.count(),
+                                   internalFormat,
+                                   desc.fWidth, desc.fHeight));
+    } else {
+        int width = desc.fWidth;
+        int height = desc.fHeight;
+        for (int currentMipLevel = 0; currentMipLevel < data.count(); currentMipLevel++) {
+            GL_ALLOC_CALL(interface,
+                          CompressedTexImage2D(GR_GL_TEXTURE_2D,
+                                               data.count(),
+                                               internalFormat,
+                                               width, height,
+                                               0, // border
+                                               SkToInt(dataSize),

[cblume, 2015/07/23 18:18:59]

I think this may be a bug. Each mip level probably has its own size, right? I
shouldn't be reusing one size.

[cblume, 2015/08/14 21:56:55]

Done.

+                                               data[currentMipLevel]));
+            width /= 2;
+            height /= 2;
+        }
+    }
+
+    GrGLenum error = check_alloc_error(desc, interface);
+    if (error != GR_GL_NO_ERROR) {
+        return false;
+    }
+    return true;
+}
+
+static void restore_gl_state(bool restoreGLRowLength, const GrGLInterface* interface,
+                             const GrGLCaps& caps, bool glFlipY) {
+    if (restoreGLRowLength) {
+        SkASSERT(caps.unpackRowLengthSupport());
+        GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
+    }
+    if (glFlipY) {
+        GR_GL_CALL(interface, PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_FALSE));
+    }
+}
+
+bool GrGLGpu::uploadTexData(const GrSurfaceDesc& desc,
+                            bool isNewTexture,
+                            int left, int top, int width, int height,
+                            GrPixelConfig dataConfig,
+                            const void* data,
+                            size_t rowBytes) {
+    SkASSERT(data || isNewTexture);
+
+    // If we're uploading compressed data then we should be using uploadCompressedTexData
+    SkASSERT(!GrPixelConfigIsCompressed(dataConfig));
+
+    size_t bpp = GrBytesPerPixel(dataConfig);
+    if (!adjust_pixel_ops_params(desc.fWidth, desc.fHeight, bpp, &left, &top,
+                                 &width, &height, &data, &rowBytes)) {
+        return false;
+    }
+
+    bool useTexStorage = can_use_tex_storage(this->glCaps(), this->glStandard(),
+                                             desc);
+    bool useSizedFormat = can_use_sized_format(useTexStorage, this->glCaps(), this->glStandard(),
+                                               this->glVersion(), dataConfig);
+
+    GrGLenum internalFormat = 0x0; // suppress warning
+    GrGLenum externalFormat = 0x0; // suppress warning
+    GrGLenum externalType = 0x0;   // suppress warning
+
+    if (!this->configToGLFormats(dataConfig, useSizedFormat, &internalFormat,
+                                 &externalFormat, &externalType)) {
+        return false;
+    }
+
     bool swFlipY = false;
     bool glFlipY = false;
+
+    if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
+        if (glCaps().unpackFlipYSupport()) {
+            glFlipY = true;
+        } else {
+            swFlipY = true;
+        }
+    }
+
+    bool restoreGLRowLength = false;
+
+    // in case we need a temporary, trimmed copy of the src pixels
+    SkAutoSMalloc<128 * 128> tempStorage;
     if (data) {
-        if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
-            if (this->glCaps().unpackFlipYSupport()) {
-                glFlipY = true;
-            } else {
-                swFlipY = true;
-            }
-        }
-        if (this->glCaps().unpackRowLengthSupport() && !swFlipY) {
-            // can't use this for flipping, only non-neg values allowed. :(
-            if (rowBytes != trimRowBytes) {
-                GrGLint rowLength = static_cast<GrGLint>(rowBytes / bpp);
-                GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, rowLength));
-                restoreGLRowLength = true;
-            }
-        } else {
-            if (trimRowBytes != rowBytes || swFlipY) {
-                // copy data into our new storage, skipping the trailing bytes
-                size_t trimSize = height * trimRowBytes;
-                const char* src = (const char*)data;
-                if (swFlipY) {
-                    src += (height - 1) * rowBytes;
-                }
-                char* dst = (char*)tempStorage.reset(trimSize);
-                for (int y = 0; y < height; y++) {
-                    memcpy(dst, src, trimRowBytes);
-                    if (swFlipY) {
-                        src -= rowBytes;
-                    } else {
-                        src += rowBytes;
-                    }
-                    dst += trimRowBytes;
-                }
-                // now point data to our copied version
-                data = tempStorage.get();
-            }
-        }
-        if (glFlipY) {
-            GL_CALL(PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_TRUE));
-        }
-        GL_CALL(PixelStorei(GR_GL_UNPACK_ALIGNMENT,
-              static_cast<GrGLint>(GrUnpackAlignment(dataConfig))));
+        prepare_image_for_writing_to_texture(desc, this->glCaps(), swFlipY, glFlipY, width, height,
+                                             bpp, rowBytes, data, tempStorage, this->glInterface(),
+                                             restoreGLRowLength);
     }
     bool succeeded = true;
     if (isNewTexture &&
         0 == left && 0 == top &&
         desc.fWidth == width && desc.fHeight == height) {
-        CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
-        if (useTexStorage) {
-            // We never resize  or change formats of textures.
-            GL_ALLOC_CALL(this->glInterface(),
-                          TexStorage2D(GR_GL_TEXTURE_2D,
-                                       1, // levels
-                                       internalFormat,
-                                       desc.fWidth, desc.fHeight));
-        } else {
-            GL_ALLOC_CALL(this->glInterface(),
-                          TexImage2D(GR_GL_TEXTURE_2D,
-                                     0, // level
-                                     internalFormat,
-                                     desc.fWidth, desc.fHeight,
-                                     0, // border
-                                     externalFormat, externalType,
-                                     data));
-        }
-        GrGLenum error = check_alloc_error(desc, this->glInterface());
-        if (error != GR_GL_NO_ERROR) {
-            succeeded = false;
-        } else {
-            // if we have data and we used TexStorage to create the texture, we
-            // now upload with TexSubImage.
-            if (data && useTexStorage) {
-                GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
-                                      0, // level
-                                      left, top,
-                                      width, height,
-                                      externalFormat, externalType,
-                                      data));
-            }
-        }
+        const int mipLevelCount = 1;
+        SkTArray<const void*> mipLevels(mipLevelCount);
+        mipLevels[0] = data;
+        allocate_and_populate_uncompressed_texture(this->glInterface(), useTexStorage,
+                                                   internalFormat, externalFormat, externalType,
+                                                   desc, mipLevels, succeeded);
     } else {
         if (swFlipY || glFlipY) {
             top = desc.fHeight - (top + height);
         }
         GL_CALL(TexSubImage2D(GR_GL_TEXTURE_2D,
                               0, // level
                               left, top,
                               width, height,
                               externalFormat, externalType, data));
     }
 
-    if (restoreGLRowLength) {
-        SkASSERT(this->glCaps().unpackRowLengthSupport());
-        GL_CALL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0));
-    }
-    if (glFlipY) {
-        GL_CALL(PixelStorei(GR_GL_UNPACK_FLIP_Y, GR_GL_FALSE));
-    }
+    restore_gl_state(restoreGLRowLength, this->glInterface(), this->glCaps(), glFlipY);
+
     return succeeded;
 }
 
 // TODO: This function is using a lot of wonky semantics like, if width == -1
 // then set width = desc.fWdith ... blah. A better way to do it might be to
 // create a CompressedTexData struct that takes a desc/ptr and figures out
 // the proper upload semantics. Then users can construct this function how they
 // see fit if they want to go against the "standard" way to do it.
 bool GrGLGpu::uploadCompressedTexData(const GrSurfaceDesc& desc,
                                       const void* data,
@@ skipping 15 matching lines @@
 
     if (-1 == height) {
         height = desc.fHeight;
     }
 #ifdef SK_DEBUG
     else {
         SkASSERT(height <= desc.fHeight);
     }
 #endif
 
+    bool useTexStorage = can_use_tex_storage(this->glCaps(), this->glStandard(),
+                                             desc);
+
     // Make sure that the width and height that we pass to OpenGL
     // is a multiple of the block size.
     size_t dataSize = GrCompressedFormatDataSize(desc.fConfig, width, height);
 
     // We only need the internal format for compressed 2D textures.
     GrGLenum internalFormat = 0;
     if (!this->configToGLFormats(desc.fConfig, false, &internalFormat, NULL, NULL)) {
         return false;
     }
 
     if (isNewTexture) {
-        CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
-        GL_ALLOC_CALL(this->glInterface(),
-                      CompressedTexImage2D(GR_GL_TEXTURE_2D,
-                                           0, // level
-                                           internalFormat,
-                                           width, height,
-                                           0, // border
-                                           SkToInt(dataSize),
-                                           data));
-        GrGLenum error = check_alloc_error(desc, this->glInterface());
-        if (error != GR_GL_NO_ERROR) {
-            return false;
-        }
+        const int mipLevelCount = 1;
+        SkTArray<const void*> mipLevels(mipLevelCount);
+        mipLevels[0] = data;
+        return allocate_and_populate_compressed_texture(this->glInterface(), useTexStorage,
+                                                        internalFormat, desc, mipLevels, dataSize);
     } else {
         // Paletted textures can't be updated.
         if (GR_GL_PALETTE8_RGBA8 == internalFormat) {
             return false;
         }
         GL_CALL(CompressedTexSubImage2D(GR_GL_TEXTURE_2D,
                                         0, // level
                                         left, top,
                                         width, height,
                                         internalFormat,
                                         SkToInt(dataSize),
                                         data));
     }
 
     return true;
 }
 
+bool GrGLGpu::uploadMipmappedTexData(const GrSurfaceDesc& desc,
+                                     const SkMipMap& data) {
+    // If we're uploading compressed data then we should be using uploadCompressedMipmappedTexData
+    SkASSERT(!GrPixelConfigIsCompressed(desc.fConfig));
+
+    size_t bpp = GrBytesPerPixel(desc.fConfig);
+
+    bool useTexStorage = can_use_tex_storage(this->glCaps(), this->glStandard(),
+                                             desc);
+    bool useSizedFormat = can_use_sized_format(useTexStorage, this->glCaps(), this->glStandard(),
+                                               this->glVersion(), desc.fConfig);
+
+    GrGLenum internalFormat = 0x0; // suppress warning
+    GrGLenum externalFormat = 0x0; // suppress warning
+    GrGLenum externalType = 0x0;   // suppress warning
+
+    if (!this->configToGLFormats(desc.fConfig, useSizedFormat, &internalFormat,
+                                 &externalFormat, &externalType)) {
+        return false;
+    }
+
+    bool swFlipY = false;
+    bool glFlipY = false;
+
+    if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
+        if (glCaps().unpackFlipYSupport()) {
+            glFlipY = true;
+        } else {
+            swFlipY = true;
+        }
+    }
+
+    bool restoreGLRowLength = false;
+
+    // in case we need a temporary, trimmed copy of the src pixels
+    SkAutoSMalloc<128 * 128> tempStorage;
+
+    bool succeeded = true;
+    auto mipLevelCount = data.getLevelsCount();
+    SkTArray<const void*> mipLevels(mipLevelCount);
+    for (int currentMipLevel = mipLevelCount; currentMipLevel != 0; currentMipLevel--) {
+        SkMipMap::Level currentMipData;
+        if (data.getLevel(currentMipLevel, &currentMipData)) {
+            mipLevels[currentMipLevel] = currentMipData.fPixels;
+
+            prepare_image_for_writing_to_texture(desc, this->glCaps(), swFlipY, glFlipY,
+                                                 currentMipData.fWidth, currentMipData.fHeight,
+                                                 bpp, currentMipData.fRowBytes,
+                                                 mipLevels[currentMipLevel], tempStorage,
+                                                 this->glInterface(), restoreGLRowLength);
+        }
+    }
+    allocate_and_populate_uncompressed_texture(this->glInterface(), useTexStorage, internalFormat,
+                                               externalFormat, externalType, desc, mipLevels,
+                                               succeeded);
+
+    restore_gl_state(restoreGLRowLength, this->glInterface(), this->glCaps(), glFlipY);
+
+    return succeeded;
+}
+
+bool GrGLGpu::uploadCompressedMipmappedTexData(const GrSurfaceDesc& desc,
+                                               const SkMipMap& data) {
+    // No support for software flip y, yet...
+    SkASSERT(kBottomLeft_GrSurfaceOrigin != desc.fOrigin);
+
+    // Make sure that the width and height that we pass to OpenGL
+    // is a multiple of the block size.
+    size_t dataSize = GrCompressedFormatDataSize(desc.fConfig, desc.fWidth, desc.fHeight);
+
+    bool useTexStorage = can_use_tex_storage(this->glCaps(), this->glStandard(),
+                                             desc);
+    bool useSizedFormat = can_use_sized_format(useTexStorage, this->glCaps(), this->glStandard(),
+                                               this->glVersion(), desc.fConfig);
+
+    // We only need the internal format for compressed 2D textures.
+    GrGLenum internalFormat = 0;
+    if (!this->configToGLFormats(desc.fConfig, false, &internalFormat, NULL, NULL)) {
+        return false;
+    }
+
+    auto mipLevelCount = data.getLevelsCount();
+    SkTArray<const void*> mipLevels(mipLevelCount);
+    for (int currentLevelIndex = mipLevelCount; currentLevelIndex != 0; currentLevelIndex--) {
+        SkMipMap::Level currentLevel;
+        if (data.getLevel(currentLevelIndex, &currentLevel)) {
+            mipLevels[currentLevelIndex] = currentLevel.fPixels;
+        }
+    }
+    return allocate_and_populate_compressed_texture(this->glInterface(), useTexStorage,
+                                                    internalFormat, desc, mipLevels, dataSize);
+}
+
 static bool renderbuffer_storage_msaa(const GrGLContext& ctx,
                                       int sampleCount,
                                       GrGLenum format,
                                       int width, int height) {
     CLEAR_ERROR_BEFORE_ALLOC(ctx.interface());
     SkASSERT(GrGLCaps::kNone_MSFBOType != ctx.caps()->msFBOType());
     switch (ctx.caps()->msFBOType()) {
         case GrGLCaps::kDesktop_ARB_MSFBOType:
         case GrGLCaps::kDesktop_EXT_MSFBOType:
         case GrGLCaps::kMixedSamples_MSFBOType:
@@ skipping 142 matching lines @@
 //    SkDEBUGFAIL("null texture");
     return NULL;
 }
 
 #if 0 && defined(SK_DEBUG)
 static size_t as_size_t(int x) {
     return x;
 }
 #endif
 
+static GrGLTexture::IDDesc generate_and_bind_gl_texture(const GrGLInterface* interface,
+                                                        GrGpuResource::LifeCycle lifeCycle) {
+    GrGLTexture::IDDesc idDesc;
+    GR_GL_CALL(interface, GenTextures(1, &idDesc.fTextureID));
+    idDesc.fLifeCycle = lifeCycle;
+    return idDesc;
+}
+
+static GrGLTexture::TexParams set_initial_texture_params(const GrGLInterface* interface) {
+    // Some drivers like to know filter/wrap before seeing glTexImage2D. Some
+    // drivers have a bug where an FBO won't be complete if it includes a
+    // texture that is not mipmap complete (considering the filter in use).
+    GrGLTexture::TexParams initialTexParams;
+    // we only set a subset here so invalidate first
+    initialTexParams.invalidate();
+    initialTexParams.fMinFilter = GR_GL_NEAREST;
+    initialTexParams.fMagFilter = GR_GL_NEAREST;
+    initialTexParams.fWrapS = GR_GL_CLAMP_TO_EDGE;
+    initialTexParams.fWrapT = GR_GL_CLAMP_TO_EDGE;
+    GR_GL_CALL(interface, TexParameteri(GR_GL_TEXTURE_2D,
+                                        GR_GL_TEXTURE_MAG_FILTER,
+                                        initialTexParams.fMagFilter));
+    GR_GL_CALL(interface, TexParameteri(GR_GL_TEXTURE_2D,
+                                        GR_GL_TEXTURE_MIN_FILTER,
+                                        initialTexParams.fMinFilter));
+    GR_GL_CALL(interface, TexParameteri(GR_GL_TEXTURE_2D,
+                                        GR_GL_TEXTURE_WRAP_S,
+                                        initialTexParams.fWrapS));
+    GR_GL_CALL(interface, TexParameteri(GR_GL_TEXTURE_2D,
+                                        GR_GL_TEXTURE_WRAP_T,
+                                        initialTexParams.fWrapT));
+    return initialTexParams;
+}
+
 GrTexture* GrGLGpu::onCreateTexture(const GrSurfaceDesc& desc,
                                     GrGpuResource::LifeCycle lifeCycle,
                                     const void* srcData, size_t rowBytes) {
     // We fail if the MSAA was requested and is not available.
     if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() && desc.fSampleCnt) {
         //SkDebugf("MSAA RT requested but not supported on this platform.");
         return return_null_texture();
     }
 
     bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
 
-    GrGLTexture::IDDesc idDesc;
-    GL_CALL(GenTextures(1, &idDesc.fTextureID));
-    idDesc.fLifeCycle = lifeCycle;
-
+    auto idDesc = generate_and_bind_gl_texture(this->glInterface(), lifeCycle);
     if (!idDesc.fTextureID) {
         return return_null_texture();
     }
 
     this->setScratchTextureUnit();
     GL_CALL(BindTexture(GR_GL_TEXTURE_2D, idDesc.fTextureID));
 
     if (renderTarget && this->glCaps().textureUsageSupport()) {
         // provides a hint about how this texture will be used
         GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
                               GR_GL_TEXTURE_USAGE,
                               GR_GL_FRAMEBUFFER_ATTACHMENT));
     }
 
-    // Some drivers like to know filter/wrap before seeing glTexImage2D. Some
-    // drivers have a bug where an FBO won't be complete if it includes a
-    // texture that is not mipmap complete (considering the filter in use).
-    GrGLTexture::TexParams initialTexParams;
-    // we only set a subset here so invalidate first
-    initialTexParams.invalidate();
-    initialTexParams.fMinFilter = GR_GL_NEAREST;
-    initialTexParams.fMagFilter = GR_GL_NEAREST;
-    initialTexParams.fWrapS = GR_GL_CLAMP_TO_EDGE;
-    initialTexParams.fWrapT = GR_GL_CLAMP_TO_EDGE;
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_MAG_FILTER,
-                          initialTexParams.fMagFilter));
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_MIN_FILTER,
-                          initialTexParams.fMinFilter));
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_WRAP_S,
-                          initialTexParams.fWrapS));
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_WRAP_T,
-                          initialTexParams.fWrapT));
+    auto initialTexParams = set_initial_texture_params(this->glInterface());
+
     if (!this->uploadTexData(desc, true, 0, 0,
                              desc.fWidth, desc.fHeight,
                              desc.fConfig, srcData, rowBytes)) {
         GL_CALL(DeleteTextures(1, &idDesc.fTextureID));
         return return_null_texture();
     }
 
     GrGLTexture* tex;
     if (renderTarget) {
         // unbind the texture from the texture unit before binding it to the frame buffer
@@ skipping 17 matching lines @@
 }
 
 GrTexture* GrGLGpu::onCreateCompressedTexture(const GrSurfaceDesc& desc,
                                               GrGpuResource::LifeCycle lifeCycle,
                                               const void* srcData) {
     // Make sure that we're not flipping Y.
     if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
         return return_null_texture();
     }
 
-    GrGLTexture::IDDesc idDesc;
-    GL_CALL(GenTextures(1, &idDesc.fTextureID));
-    idDesc.fLifeCycle = lifeCycle;
-
+    auto idDesc = generate_and_bind_gl_texture(this->glInterface(), lifeCycle);
     if (!idDesc.fTextureID) {
         return return_null_texture();
     }
 
     this->setScratchTextureUnit();
     GL_CALL(BindTexture(GR_GL_TEXTURE_2D, idDesc.fTextureID));
 
-    // Some drivers like to know filter/wrap before seeing glTexImage2D. Some
-    // drivers have a bug where an FBO won't be complete if it includes a
-    // texture that is not mipmap complete (considering the filter in use).
-    GrGLTexture::TexParams initialTexParams;
-    // we only set a subset here so invalidate first
-    initialTexParams.invalidate();
-    initialTexParams.fMinFilter = GR_GL_NEAREST;
-    initialTexParams.fMagFilter = GR_GL_NEAREST;
-    initialTexParams.fWrapS = GR_GL_CLAMP_TO_EDGE;
-    initialTexParams.fWrapT = GR_GL_CLAMP_TO_EDGE;
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_MAG_FILTER,
-                          initialTexParams.fMagFilter));
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_MIN_FILTER,
-                          initialTexParams.fMinFilter));
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_WRAP_S,
-                          initialTexParams.fWrapS));
-    GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
-                          GR_GL_TEXTURE_WRAP_T,
-                          initialTexParams.fWrapT));
+    auto initialTexParams = set_initial_texture_params(this->glInterface());
 
     if (!this->uploadCompressedTexData(desc, srcData)) {
         GL_CALL(DeleteTextures(1, &idDesc.fTextureID));
         return return_null_texture();
     }
 
     GrGLTexture* tex;
     tex = SkNEW_ARGS(GrGLTexture, (this, desc, idDesc));
     tex->setCachedTexParams(initialTexParams, this->getResetTimestamp());
 #ifdef TRACE_TEXTURE_CREATION
     SkDebugf("--- new compressed texture [%d] size=(%d %d) config=%d\n",
              glTexDesc.fTextureID, desc.fWidth, desc.fHeight, desc.fConfig);
 #endif
     return tex;
 }
 
+GrTexture* GrGLGpu::onCreateMipmappedTexture(const GrSurfaceDesc& desc,
+                                             GrGpuResource::LifeCycle lifeCycle,
+                                             const SkMipMap& srcData)
+{
+    // We fail if the MSAA was requested and is not available.
+    if (GrGLCaps::kNone_MSFBOType == this->glCaps().msFBOType() && desc.fSampleCnt) {
+        //SkDebugf("MSAA RT requested but not supported on this platform.");
+        return return_null_texture();
+    }
+
+    bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
+
+    auto idDesc = generate_and_bind_gl_texture(this->glInterface(), lifeCycle);
+    if (!idDesc.fTextureID) {
+        return return_null_texture();
+    }
+
+    if (renderTarget && this->glCaps().textureUsageSupport()) {
+        // provides a hint about how this texture will be used
+        GL_CALL(TexParameteri(GR_GL_TEXTURE_2D,
+                              GR_GL_TEXTURE_USAGE,
+                              GR_GL_FRAMEBUFFER_ATTACHMENT));
+    }
+
+    auto initialTexParams = set_initial_texture_params(this->glInterface());
+
+    if (!this->uploadMipmappedTexData(desc, srcData)) {
+        GL_CALL(DeleteTextures(1, &idDesc.fTextureID));
+        return return_null_texture();
+    }
+
+    GrGLTexture* tex;
+    if (renderTarget) {
+        // unbind the texture from the texture unit before binding it to the frame buffer
+        GL_CALL(BindTexture(GR_GL_TEXTURE_2D, 0));
+        GrGLRenderTarget::IDDesc rtIDDesc;
+
+        if (!this->createRenderTargetObjects(desc, lifeCycle, idDesc.fTextureID, &rtIDDesc)) {
+            GL_CALL(DeleteTextures(1, &idDesc.fTextureID));
+            return return_null_texture();
+        }
+        tex = SkNEW_ARGS(GrGLTextureRenderTarget, (this, desc, idDesc, rtIDDesc));
+    } else {
+        tex = SkNEW_ARGS(GrGLTexture, (this, desc, idDesc));
+    }
+    tex->setCachedTexParams(initialTexParams, this->getResetTimestamp());
+#ifdef TRACE_TEXTURE_CREATION
+    SkDebugf("--- new mipmapped texture [%d] size=(%d %d) config=%d\n",
+             glTexDesc.fTextureID, desc.fWidth, desc.fHeight, desc.fConfig);
+#endif
+    return tex;
+}
+
+GrTexture* GrGLGpu::onCreateCompressedMipmappedTexture(const GrSurfaceDesc& desc,
+                                                       GrGpuResource::LifeCycle lifeCycle,
+                                                       const SkMipMap& srcData)
+{
+    // Make sure that we're not flipping Y.
+    if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
+        return return_null_texture();
+    }
+
+    auto idDesc = generate_and_bind_gl_texture(this->glInterface(), lifeCycle);
+    if (!idDesc.fTextureID) {
+        return return_null_texture();
+    }
+
+    this->setScratchTextureUnit();
+    GL_CALL(BindTexture(GR_GL_TEXTURE_2D, idDesc.fTextureID));
+
+    auto initialTexParams = set_initial_texture_params(this->glInterface());
+
+    if (!this->uploadCompressedMipmappedTexData(desc, srcData)) {
+        GL_CALL(DeleteTextures(1, &idDesc.fTextureID));
+        return return_null_texture();
+    }
+
+    GrGLTexture* tex;
+    tex = SkNEW_ARGS(GrGLTexture, (this, desc, idDesc));
+    tex->setCachedTexParams(initialTexParams, this->getResetTimestamp());
+#ifdef TRACE_TEXTURE_CREATION
+    SkDebugf("--- new compressed mipmapped texture [%d] size=(%d %d) config=%d\n",
+             glTexDesc.fTextureID, desc.fWidth, desc.fHeight, desc.fConfig);
+#endif
+    return tex;
+}
+
 namespace {
 
 const GrGLuint kUnknownBitCount = GrGLStencilAttachment::kUnknownBitCount;
 
 void inline get_stencil_rb_sizes(const GrGLInterface* gl,
                                  GrGLStencilAttachment::Format* format) {
 
     // we shouldn't ever know one size and not the other
     SkASSERT((kUnknownBitCount == format->fStencilBits) ==
              (kUnknownBitCount == format->fTotalBits));
@@ skipping 1974 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }