Upstream Android modifications to the image encoders/decoders.

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"
 #include "SkImagePriv.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
+#include "SkCanvas.h"
 
 SK_DEFINE_INST_COUNT(SkImageDecoder::Peeker)
 SK_DEFINE_INST_COUNT(SkImageDecoder::Chooser)
 SK_DEFINE_INST_COUNT(SkImageDecoderFactory)
 
+const char *SkImageDecoder::kFormatName[] = {
+    "Unknown Format",
+    "BMP",
+    "GIF",
+    "ICO",
+    "JPEG",
+    "PNG",
+    "WBMP",
+    "WEBP",
+};
+
 static SkBitmap::Config gDeviceConfig = SkBitmap::kNo_Config;
 
 SkBitmap::Config SkImageDecoder::GetDeviceConfig()
 {
     return gDeviceConfig;
 }
 
 void SkImageDecoder::SetDeviceConfig(SkBitmap::Config config)
 {
     gDeviceConfig = config;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImageDecoder::SkImageDecoder()
     : fPeeker(NULL), fChooser(NULL), fAllocator(NULL), fSampleSize(1),
       fDefaultPref(SkBitmap::kNo_Config), fDitherImage(true),
-      fUsePrefTable(false) {
+      fUsePrefTable(false),fPreferQualityOverSpeed(false) {
 }
 
 SkImageDecoder::~SkImageDecoder() {
     SkSafeUnref(fPeeker);
     SkSafeUnref(fChooser);
     SkSafeUnref(fAllocator);
 }
 
 SkImageDecoder::Format SkImageDecoder::getFormat() const {
     return kUnknown_Format;
@@ skipping 74 matching lines @@
         config = fDefaultPref;
     }
 
     if (SkBitmap::kNo_Config == config) {
         config = SkImageDecoder::GetDeviceConfig();
     }
     return config;
 }
 
 bool SkImageDecoder::decode(SkStream* stream, SkBitmap* bm,
-                            SkBitmap::Config pref, Mode mode) {
+                            SkBitmap::Config pref, Mode mode, bool reuseBitmap) {
     // pass a temporary bitmap, so that if we return false, we are assured of
     // leaving the caller's bitmap untouched.
     SkBitmap    tmp;
 
     // we reset this to false before calling onDecode
     fShouldCancelDecode = false;
     // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
     fDefaultPref = pref;
 
+    if (reuseBitmap) {
+        SkAutoLockPixels alp(*bm);

[robertphillips, 2013/03/11 18:25:55]

NULL goes on lhs

[djsollen, 2013/03/11 19:43:24]

Done.

+        if (bm->getPixels() != NULL) {
+            return this->onDecode(stream, bm, mode);
+        }
+    }

[robertphillips, 2013/03/11 18:25:55]

Move tmp down here?

[djsollen, 2013/03/11 19:43:24]

Done.

     if (!this->onDecode(stream, &tmp, mode)) {
         return false;
     }
     bm->swap(tmp);
     return true;
 }
 
+bool SkImageDecoder::decodeRegion(SkBitmap* bm, const SkIRect& rect,
+                                  SkBitmap::Config pref) {
+    // we reset this to false before calling onDecodeRegion
+    fShouldCancelDecode = false;
+    // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
+    fDefaultPref = pref;
+

[robertphillips, 2013/03/11 18:25:55]

just "return this->onDecodeRegion(bm, rect));"

[djsollen, 2013/03/11 19:43:24]

Done.

+    if (!this->onDecodeRegion(bm, rect)) {
+        return false;
+    }
+    return true;
+}
+
+bool SkImageDecoder::buildTileIndex(SkStream* stream,
+                                int *width, int *height) {
+    // we reset this to false before calling onBuildTileIndex
+    fShouldCancelDecode = false;
+
+    return this->onBuildTileIndex(stream, width, height);
+}
+
+void SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
+                                int dstX, int dstY, int width, int height,
+                                int srcX, int srcY) {
+    int w = width / sampleSize;
+    int h = height / sampleSize;
+    // if the destination has no pixels then we must allocate them.
+    if (dst->isNull()) {
+        dst->setConfig(src->getConfig(), w, h);
+        dst->setIsOpaque(src->isOpaque());
+
+        if (!this->allocPixelRef(dst, NULL)) {
+            SkDEBUGF(("failed to allocate pixels needed to crop the bitmap"));
+            return;
+        }
+    }
+    // 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.
+    SkASSERT(dst->width() >= w && dst->height() >= h);
+
+    // Set the Src_Mode for the paint to prevent transparency issue in the
+    // dest in the event that the dest was being re-used.
+    SkPaint paint;
+    paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+
+    SkCanvas canvas(*dst);
+    canvas.drawSprite(*src, (srcX - dstX) / sampleSize,
+                            (srcY - dstY) / sampleSize,
+                            &paint);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm,
                             SkBitmap::Config pref,  Mode mode, Format* format) {
     SkASSERT(file);
     SkASSERT(bm);
 
     SkFILEStream    stream(file);
     if (stream.isValid()) {
         if (SkImageDecoder::DecodeStream(&stream, bm, pref, mode, format)) {
@@ skipping 88 matching lines @@
 
     if (NULL != codec) {
         success = codec->decode(stream, bm, pref, mode);
         if (success && format) {
             *format = codec->getFormat();
         }
         delete codec;
     }
     return success;
 }