hide SkBitmap::setConfig

src/images/SkImageDecoder.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkImageDecoder.h"
 #include "SkBitmap.h"
@@ skipping 106 matching lines @@
     return alloc;
 }
 
 void SkImageDecoder::setSampleSize(int size) {
     if (size < 1) {
         size = 1;
     }
     fSampleSize = size;
 }
 
-bool SkImageDecoder::chooseFromOneChoice(SkBitmap::Config config, int width,
-                                         int height) const {
+// TODO: change Chooser virtual to take colorType, so we can stop calling SkColorTypeToBitmapConfig
+//
+bool SkImageDecoder::chooseFromOneChoice(SkColorType colorType, int width, int height) const {
     Chooser* chooser = fChooser;
-
+    
     if (NULL == chooser) {    // no chooser, we just say YES to decoding :)
         return true;
     }
     chooser->begin(1);
-    chooser->inspect(0, config, width, height);
+    chooser->inspect(0, SkColorTypeToBitmapConfig(colorType), width, height);
     return chooser->choose() == 0;
 }
 
 bool SkImageDecoder::allocPixelRef(SkBitmap* bitmap,
                                    SkColorTable* ctable) const {
     return bitmap->allocPixels(fAllocator, ctable);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkImageDecoder::setPrefConfigTable(const PrefConfigTable& prefTable) {
     fUsePrefTable = true;
     fPrefTable = prefTable;
 }
 
-SkBitmap::Config SkImageDecoder::getPrefConfig(SrcDepth srcDepth,
-                                               bool srcHasAlpha) const {
+// TODO: use colortype in fPrefTable, fDefaultPref and GetDeviceConfig()
+//       so we can stop using SkBitmapConfigToColorType()
+//
+SkColorType SkImageDecoder::getPrefColorType(SrcDepth srcDepth, bool srcHasAlpha) const {
     SkBitmap::Config config = SkBitmap::kNo_Config;
 
     if (fUsePrefTable) {
         switch (srcDepth) {
             case kIndex_SrcDepth:
                 config = srcHasAlpha ? fPrefTable.fPrefFor_8Index_YesAlpha_src
                                      : fPrefTable.fPrefFor_8Index_NoAlpha_src;
                 break;
             case k8BitGray_SrcDepth:
                 config = fPrefTable.fPrefFor_8Gray_src;
                 break;
             case k32Bit_SrcDepth:
                 config = srcHasAlpha ? fPrefTable.fPrefFor_8bpc_YesAlpha_src
                                      : fPrefTable.fPrefFor_8bpc_NoAlpha_src;
                 break;
         }
     } else {
         config = fDefaultPref;
     }
 
     if (SkBitmap::kNo_Config == config) {
         config = SkImageDecoder::GetDeviceConfig();
     }
-    return config;
+    return SkBitmapConfigToColorType(config);
 }
 
 bool SkImageDecoder::decode(SkStream* stream, SkBitmap* bm,
                             SkBitmap::Config pref, Mode mode) {
     // we reset this to false before calling onDecode
     fShouldCancelDecode = false;
     // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
     fDefaultPref = pref;
 
     // pass a temporary bitmap, so that if we return false, we are assured of
@@ skipping 38 matching lines @@
         // savings are more important than speed here. This also means
         // that the pixels in dst can not be reused (though there is no
         // allocation, which was already done on src).
         int x = (dstX - srcX) / sampleSize;
         int y = (dstY - srcY) / sampleSize;
         SkIRect subset = SkIRect::MakeXYWH(x, y, w, h);
         return src->extractSubset(dst, subset);
     }
     // if the destination has no pixels then we must allocate them.
     if (dst->isNull()) {
-        dst->setConfig(src->config(), w, h, 0, src->alphaType());
+        dst->setInfo(src->info().makeWH(w, h));
 
         if (!this->allocPixelRef(dst, NULL)) {
             SkDEBUGF(("failed to allocate pixels needed to crop the bitmap"));
             return false;
         }
     }
     // check to see if the destination is large enough to decode the desired
     // region. If this assert fails we will just draw as much of the source
     // into the destination that we can.
     if (dst->width() < w || dst->height() < h) {
@@ skipping 56 matching lines @@
             if (kUnknown_Format == *format) {
                 if (stream->rewind()) {
                     *format = GetStreamFormat(stream);
                 }
             }
         }
         delete codec;
     }
     return success;
 }