hide SkBitmap::Config entirely (behind a flag)

third_party/ktx/ktx.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "ktx.h"
 #include "SkBitmap.h"
@@ skipping 340 matching lines @@
 
     // Write the actual image data
     if (!stream->write(etc1Data, dataSize)) {
         return false;
     }
 
     return true;
 }
 
 bool SkKTXFile::WriteBitmapToKTX(SkWStream* stream, const SkBitmap& bitmap) {
-    const SkBitmap::Config config = bitmap.config();
+    const SkColorType ct = bitmap.colorType();
     SkAutoLockPixels alp(bitmap);
 
     const int width = bitmap.width();
     const int height = bitmap.width();
     const uint8_t* src = reinterpret_cast<uint8_t*>(bitmap.getPixels());
     if (NULL == bitmap.getPixels()) {
         return false;
     }
 
     // First thing's first, write out the magic identifier and endianness...
     if (!stream->write(KTX_FILE_IDENTIFIER, KTX_FILE_IDENTIFIER_SIZE) ||
         !stream->write(&kKTX_ENDIANNESS_CODE, 4)) {
         return false;
     }
 
     // Collect our key/value pairs...
     SkTArray<KeyValue> kvPairs;
 
     // Next, write the header based on the bitmap's config.
     Header hdr;
-    switch (config) {
-        case SkBitmap::kIndex8_Config:
+    switch (ct) {
+        case kIndex_8_SkColorType:
             // There is a compressed format for this, but we don't support it yet.
             SkDebugf("Writing indexed bitmap to KTX unsupported.\n");
             // VVV fall through VVV
         default:
-        case SkBitmap::kNo_Config:
+        case kUnknown_SkColorType:
             // Bitmap hasn't been configured.
             return false;
 
-        case SkBitmap::kA8_Config:
+        case kAlpha_8_SkColorType:
             hdr.fGLType = GR_GL_UNSIGNED_BYTE;
             hdr.fGLTypeSize = 1;
             hdr.fGLFormat = GR_GL_RED;
             hdr.fGLInternalFormat = GR_GL_R8;
             hdr.fGLBaseInternalFormat = GR_GL_RED;
             break;
 
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             hdr.fGLType = GR_GL_UNSIGNED_SHORT_5_6_5;
             hdr.fGLTypeSize = 2;
             hdr.fGLFormat = GR_GL_RGB;
             hdr.fGLInternalFormat = GR_GL_RGB;
             hdr.fGLBaseInternalFormat = GR_GL_RGB;
             break;
 
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             hdr.fGLType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
             hdr.fGLTypeSize = 2;
             hdr.fGLFormat = GR_GL_RGBA;
             hdr.fGLInternalFormat = GR_GL_RGBA4;
             hdr.fGLBaseInternalFormat = GR_GL_RGBA;
             kvPairs.push_back(CreateKeyValue("KTXPremultipliedAlpha", "True"));
             break;
 
-        case SkBitmap::kARGB_8888_Config:
+        case kN32_SkColorType:
             hdr.fGLType = GR_GL_UNSIGNED_BYTE;
             hdr.fGLTypeSize = 1;
             hdr.fGLFormat = GR_GL_RGBA;
             hdr.fGLInternalFormat = GR_GL_RGBA8;
             hdr.fGLBaseInternalFormat = GR_GL_RGBA;
             kvPairs.push_back(CreateKeyValue("KTXPremultipliedAlpha", "True"));
             break;
     }
 
     // Everything else in the header is shared.
@@ skipping 35 matching lines @@
         return false;
     }
 
     // Write it into the buffer
     if (!stream->write(&dataSz, 4)) {
         return false;
     }
 
     // Write the pixel data...
     const uint8_t* rowPtr = src;
-    if (SkBitmap::kARGB_8888_Config == config) {
+    if (kN32_SkColorType == ct) {
         for (int j = 0; j < height; ++j) {
             const uint32_t* pixelsPtr = reinterpret_cast<const uint32_t*>(rowPtr);
             for (int i = 0; i < width; ++i) {
                 uint32_t pixel = pixelsPtr[i];
                 uint8_t dstPixel[4];
                 dstPixel[0] = pixel >> SK_R32_SHIFT;
                 dstPixel[1] = pixel >> SK_G32_SHIFT;
                 dstPixel[2] = pixel >> SK_B32_SHIFT;
                 dstPixel[3] = pixel >> SK_A32_SHIFT;
                 if (!stream->write(dstPixel, 4)) {
                     return false;
                 }
             }
             rowPtr += bitmap.rowBytes();
         }
     } else {
         for (int i = 0; i < height; ++i) {
             if (!stream->write(rowPtr, bpp*width)) {
                 return false;
             }
             rowPtr += bitmap.rowBytes();
         }
     }
     
     return true;
 }