Move ETC1 and LATC enums value to GrPixelConfig

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 "GrGLStencilBuffer.h"
@@ skipping 182 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()) {
+    if (kIndex_8_GrPixelConfig == srcConfig || kIndex_8_GrPixelConfig == texture->config() ||
+        GrPixelConfigIsCompressed(srcConfig) || GrPixelConfigIsCompressed(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().bgraFormatSupport() &&
+        if (this->glCaps().isConfigTexturable(kBGRA_8888_GrPixelConfig) &&
             !this->glCaps().bgraIsInternalFormat() &&
             kBGRA_8888_GrPixelConfig == srcConfig &&
             kRGBA_8888_GrPixelConfig == texture->config()) {
             return true;
         } else {
             return false;
         }
     } else {
         return true;
     }
@@ skipping 301 matching lines @@
 }
 
 bool GrGpuGL::uploadTexData(const GrGLTexture::Desc& desc,
                             bool isNewTexture,
                             int left, int top, int width, int height,
                             GrPixelConfig dataConfig,
                             const void* data,
                             size_t rowBytes) {
     SkASSERT(NULL != 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;
 
     // paletted textures cannot be partially updated
     // 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 &&
-                         desc.fConfig != kIndex_8_GrPixelConfig &&
+                         kIndex_8_GrPixelConfig != desc.fConfig &&
                          this->glCaps().texStorageSupport();
 
     if (useTexStorage && kGL_GrGLStandard == this->glStandard()) {
         // 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;
     }
 
@@ skipping 863 matching lines @@
         return false;
     }
 }
 
 bool GrGpuGL::onReadPixels(GrRenderTarget* target,
                            int left, int top,
                            int width, int height,
                            GrPixelConfig config,
                            void* buffer,
                            size_t rowBytes) {
-    GrGLenum format;
-    GrGLenum type;
+    // We cannot read pixels into a compressed buffer
+    if (GrPixelConfigIsCompressed(config)) {
+        return false;
+    }
+
+    GrGLenum format = 0;
+    GrGLenum type = 0;
     bool flipY = kBottomLeft_GrSurfaceOrigin == target->origin();
     if (!this->configToGLFormats(config, false, NULL, &format, &type)) {
         return false;
     }
     size_t bpp = GrBytesPerPixel(config);
     if (!adjust_pixel_ops_params(target->width(), target->height(), bpp,
                                  &left, &top, &width, &height,
                                  const_cast<const void**>(&buffer),
                                  &rowBytes)) {
         return false;
@@ skipping 706 matching lines @@
         GR_GL_LINEAR,
         GR_GL_LINEAR
     };
     GrTextureParams::FilterMode filterMode = params.filterMode();
     if (!this->caps()->mipMapSupport() && GrTextureParams::kMipMap_FilterMode == filterMode) {
         filterMode = GrTextureParams::kBilerp_FilterMode;
     }
     newTexParams.fMinFilter = glMinFilterModes[filterMode];
     newTexParams.fMagFilter = glMagFilterModes[filterMode];
 
-    if (GrTextureParams::kMipMap_FilterMode == filterMode && texture->mipMapsAreDirty()) {
-//        GL_CALL(Hint(GR_GL_GENERATE_MIPMAP_HINT,GR_GL_NICEST));
+    if (GrTextureParams::kMipMap_FilterMode == filterMode &&
+        texture->mipMapsAreDirty() && !GrPixelConfigIsCompressed(texture->config())) {
         GL_CALL(GenerateMipmap(GR_GL_TEXTURE_2D));
         texture->dirtyMipMaps(false);
     }
 
     newTexParams.fWrapS = tile_to_gl_wrap(params.getTileModeX());
     newTexParams.fWrapT = tile_to_gl_wrap(params.getTileModeY());
     memcpy(newTexParams.fSwizzleRGBA,
            GrGLShaderBuilder::GetTexParamSwizzle(texture->config(), this->glCaps()),
            sizeof(newTexParams.fSwizzleRGBA));
     if (setAll || newTexParams.fMagFilter != oldTexParams.fMagFilter) {
@@ skipping 213 matching lines @@
     if (NULL == internalFormat) {
         internalFormat = &dontCare;
     }
     if (NULL == externalFormat) {
         externalFormat = &dontCare;
     }
     if (NULL == externalType) {
         externalType = &dontCare;
     }
 
+    if(!this->glCaps().isConfigTexturable(config)) {
+        return false;
+    }
+
     switch (config) {
         case kRGBA_8888_GrPixelConfig:
             *internalFormat = GR_GL_RGBA;
             *externalFormat = GR_GL_RGBA;
             if (getSizedInternalFormat) {
                 *internalFormat = GR_GL_RGBA8;
             } else {
                 *internalFormat = GR_GL_RGBA;
             }
             *externalType = GR_GL_UNSIGNED_BYTE;
             break;
         case kBGRA_8888_GrPixelConfig:
-            if (!this->glCaps().bgraFormatSupport()) {
-                return false;
-            }
             if (this->glCaps().bgraIsInternalFormat()) {
                 if (getSizedInternalFormat) {
                     *internalFormat = GR_GL_BGRA8;
                 } else {
                     *internalFormat = GR_GL_BGRA;
                 }
             } else {
                 if (getSizedInternalFormat) {
                     *internalFormat = GR_GL_RGBA8;
                 } else {
@@ skipping 21 matching lines @@
             *internalFormat = GR_GL_RGBA;
             *externalFormat = GR_GL_RGBA;
             if (getSizedInternalFormat) {
                 *internalFormat = GR_GL_RGBA4;
             } else {
                 *internalFormat = GR_GL_RGBA;
             }
             *externalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
             break;
         case kIndex_8_GrPixelConfig:
-            if (this->caps()->eightBitPaletteSupport()) {
-                // glCompressedTexImage doesn't take external params
-                *externalFormat = GR_GL_PALETTE8_RGBA8;
-                // no sized/unsized internal format distinction here
-                *internalFormat = GR_GL_PALETTE8_RGBA8;
-                // unused with CompressedTexImage
-                *externalType = GR_GL_UNSIGNED_BYTE;
-            } else {
-                return false;
-            }
+            // glCompressedTexImage doesn't take external params
+            *externalFormat = GR_GL_PALETTE8_RGBA8;
+            // no sized/unsized internal format distinction here
+            *internalFormat = GR_GL_PALETTE8_RGBA8;
+            // unused with CompressedTexImage
+            *externalType = GR_GL_UNSIGNED_BYTE;
             break;
         case kAlpha_8_GrPixelConfig:
             if (this->glCaps().textureRedSupport()) {
                 *internalFormat = GR_GL_RED;
                 *externalFormat = GR_GL_RED;
                 if (getSizedInternalFormat) {
                     *internalFormat = GR_GL_R8;
                 } else {
                     *internalFormat = GR_GL_RED;
                 }
                 *externalType = GR_GL_UNSIGNED_BYTE;
             } else {
                 *internalFormat = GR_GL_ALPHA;
                 *externalFormat = GR_GL_ALPHA;
                 if (getSizedInternalFormat) {
                     *internalFormat = GR_GL_ALPHA8;
                 } else {
                     *internalFormat = GR_GL_ALPHA;
                 }
                 *externalType = GR_GL_UNSIGNED_BYTE;
             }
             break;
+        case kETC1_GrPixelConfig:
+            *internalFormat = GR_GL_COMPRESSED_RGB8_ETC1;
+            break;
+        case kLATC_GrPixelConfig:
+            switch(this->glCaps().latcAlias()) {
+                case GrGLCaps::kLATC_LATCAlias:
+                    *internalFormat = GR_GL_COMPRESSED_LUMINANCE_LATC1;
+                    break;
+                case GrGLCaps::kRGTC_LATCAlias:
+                    *internalFormat = GR_GL_COMPRESSED_RED_RGTC1;
+                    break;
+                case GrGLCaps::k3DC_LATCAlias:
+                    *internalFormat = GR_GL_COMPRESSED_3DC_X;
+                    break;
+            }
+            break;
         default:
             return false;
     }
     return true;
 }
 
 void GrGpuGL::setTextureUnit(int unit) {
     SkASSERT(unit >= 0 && unit < fHWBoundTextures.count());
     if (unit != fHWActiveTextureUnitIdx) {
         GL_CALL(ActiveTexture(GR_GL_TEXTURE0 + unit));
@@ skipping 56 matching lines @@
     }
     const GrGLRenderTarget* srcRT = static_cast<const GrGLRenderTarget*>(src->asRenderTarget());
     // If the src is multisampled (and uses an extension where there is a separate MSAA
     // renderbuffer) then it is an invalid operation to call CopyTexSubImage
     if (NULL != srcRT && srcRT->renderFBOID() != srcRT->textureFBOID()) {
         return false;
     }
     if (gpu->glCaps().isConfigRenderable(src->config(), src->desc().fSampleCnt > 0) &&
         NULL != dst->asTexture() &&
         dst->origin() == src->origin() &&
-        kIndex_8_GrPixelConfig != src->config()) {
+        kIndex_8_GrPixelConfig != src->config() &&
+        !GrPixelConfigIsCompressed(src->config())) {
         if (NULL != wouldNeedTempFBO) {
             *wouldNeedTempFBO = NULL == src->asRenderTarget();
         }
         return true;
     } else {
         return false;
     }
 }
 
 // If a temporary FBO was created, its non-zero ID is returned. The viewport that the copy rect is
@@ skipping 230 matching lines @@
             this->setVertexArrayID(gpu, 0);
         }
         int attrCount = gpu->glCaps().maxVertexAttributes();
         if (fDefaultVertexArrayAttribState.count() != attrCount) {
             fDefaultVertexArrayAttribState.resize(attrCount);
         }
         attribState = &fDefaultVertexArrayAttribState;
     }
     return attribState;
 }