Allow compressed texture data to be updated.

src/gpu/gl/GrGpuGL.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 "GrGpuGL.h"
 #include "GrGLNameAllocator.h"
@@ skipping 183 matching lines @@
 GrPixelConfig GrGpuGL::preferredWritePixelsConfig(GrPixelConfig writeConfig,
                                                   GrPixelConfig surfaceConfig) const {
     if (GR_GL_RGBA_8888_PIXEL_OPS_SLOW && kRGBA_8888_GrPixelConfig == writeConfig) {
         return kBGRA_8888_GrPixelConfig;
     } else {
         return writeConfig;
     }
 }
 
 bool GrGpuGL::canWriteTexturePixels(const GrTexture* texture, GrPixelConfig srcConfig) const {
-    if (kIndex_8_GrPixelConfig == srcConfig || kIndex_8_GrPixelConfig == texture->config() ||
-        GrPixelConfigIsCompressed(srcConfig) || GrPixelConfigIsCompressed(texture->config())) {
+    if (kIndex_8_GrPixelConfig == srcConfig || kIndex_8_GrPixelConfig == texture->config()) {
         return false;
     }
     if (srcConfig != texture->config() && kGLES_GrGLStandard == this->glStandard()) {
         // In general ES2 requires the internal format of the texture and the format of the src
         // pixels to match. However, It may or may not be possible to upload BGRA data to a RGBA
         // texture. It depends upon which extension added BGRA. The Apple extension allows it
         // (BGRA's internal format is RGBA) while the EXT extension does not (BGRA is its own
         // internal format).
         if (this->glCaps().isConfigTexturable(kBGRA_8888_GrPixelConfig) &&
             !this->glCaps().bgraIsInternalFormat() &&
@@ skipping 255 matching lines @@
     GL_CALL(BindTexture(GR_GL_TEXTURE_2D, glTex->textureID()));
     GrGLTexture::Desc desc;
     desc.fFlags = glTex->desc().fFlags;
     desc.fWidth = glTex->width();
     desc.fHeight = glTex->height();
     desc.fConfig = glTex->config();
     desc.fSampleCnt = glTex->desc().fSampleCnt;
     desc.fTextureID = glTex->textureID();
     desc.fOrigin = glTex->origin();
 
-    if (this->uploadTexData(desc, false,
-                            left, top, width, height,
-                            config, buffer, rowBytes)) {
+    bool success = false;
+    if (GrPixelConfigIsCompressed(desc.fConfig)) {

[robertphillips, 2014/06/11 19:11:12]

Doesn't there need to be a check somewhere regarding 'config'?

[krajcevski, 2014/06/11 19:20:47]

Done.

+        success = this->uploadCompressedTexData(desc, buffer, false,
+                                                left, top, width, height);
+    } else {
+        success = this->uploadTexData(desc, false,
+                                      left, top, width, height,
+                                      config, buffer, rowBytes);
+    }
+
+    if (success) {
         texture->impl()->dirtyMipMaps(true);
         return true;
-    } else {
-        return false;
     }
+
+    return false;
 }
 
 namespace {
 bool adjust_pixel_ops_params(int surfaceWidth,
                              int surfaceHeight,
                              size_t bpp,
                              int* left, int* top, int* width, int* height,
                              const void** data,
                              size_t* rowBytes) {
     if (!*rowBytes) {
@@ skipping 198 matching lines @@
         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));
     }
     return succeeded;
 }
 
 bool GrGpuGL::uploadCompressedTexData(const GrGLTexture::Desc& desc,
-                                      const void* data) {
-    SkASSERT(NULL != data);
+                                      const void* data,
+                                      bool isNewTexture,
+                                      int left, int top, int width, int height) {
+    SkASSERT(NULL != data || isNewTexture);
 
     // No support for software flip y, yet...
     SkASSERT(kBottomLeft_GrSurfaceOrigin != desc.fOrigin);
 
+    if (-1 == width) {
+        width = desc.fWidth;
+    }
+
+    if (-1 == height) {
+        height = desc.fHeight;
+    }
+
     // Make sure that the width and height that we pass to OpenGL
     // is a multiple of the block size.
-    int dataSize = GrCompressedFormatDataSize(desc.fConfig, desc.fWidth, desc.fHeight);
+    int 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;
     }
 
     bool succeeded = true;
     CLEAR_ERROR_BEFORE_ALLOC(this->glInterface());
-    GL_ALLOC_CALL(this->glInterface(),
-                  CompressedTexImage2D(GR_GL_TEXTURE_2D,
-                                       0, // level
-                                       internalFormat,
-                                       desc.fWidth, desc.fHeight,
-                                       0, // border
-                                       dataSize,
-                                       data));
+
+    if (isNewTexture) {
+        GL_ALLOC_CALL(this->glInterface(),
+                      CompressedTexImage2D(GR_GL_TEXTURE_2D,
+                                           0, // level
+                                           internalFormat,
+                                           width, height,
+                                           0, // border
+                                           dataSize,
+                                           data));
+    } else {
+        GL_ALLOC_CALL(this->glInterface(),
+                      CompressedTexSubImage2D(GR_GL_TEXTURE_2D,
+                                              0, // level
+                                              left, top,
+                                              width, height,
+                                              internalFormat,
+                                              dataSize,
+                                              data));
+    }
 
     GrGLenum error = check_alloc_error(desc, this->glInterface());
     if (error != GR_GL_NO_ERROR) {
         succeeded = false;
     }
     return succeeded;
 }
 
 static bool renderbuffer_storage_msaa(GrGLContext& ctx,
                                       int sampleCount,
@@ skipping 2226 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }