SkScaledCodec class

src/codec/SkCodec_wbmp.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
+#include "SkScaledCodec.h"
 #include "SkStream.h"
 #include "SkCodec_wbmp.h"
 
 // Each bit represents a pixel, so width is actually a number of bits.
 // A row will always be stored in bytes, so we round width up to the
 // nearest multiple of 8 to get the number of bits actually in the row.
 // We then divide by 8 to convert to bytes.
 static inline size_t get_src_row_bytes(int width) {
     return SkAlign8(width) >> 3;
 }
@@ skipping 59 matching lines @@
 SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info,
         const SkPMColor* ctable, const Options& opts) {
     // TODO (msarett): Reenable support for 565 if it is desired
     //                 skbug.com/3683
 
     // Create the swizzler based on the desired color type
     switch (info.colorType()) {
         case kIndex_8_SkColorType:
         case kN32_SkColorType:
         case kGray_8_SkColorType:
-            return SkSwizzler::CreateSwizzler(
-                    SkSwizzler::kBit, ctable, info, opts.fZeroInitialized);
+            return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts.fZeroInitialized, 
+                                              this->getInfo().width());
         default:
             return NULL;
     }
 }
 
 SkCodec::Result SkWbmpCodec::readRow(uint8_t* row) {
     if (this->stream()->read(row, fSrcRowBytes) != fSrcRowBytes) {
         return kIncompleteInput;
     }
     return kSuccess;
@@ skipping 95 matching lines @@
             const SkCodec::Options& options, SkPMColor inputColorTable[],
             int* inputColorCount) {
         if (!fCodec->handleRewind()) {
             return SkCodec::kCouldNotRewind;
         }
         if (options.fSubset) {
             // Subsets are not supported.
             return SkCodec::kUnimplemented;
         }
         if (dstInfo.dimensions() != this->getInfo().dimensions()) {
-            return SkCodec::kInvalidScale;
+            if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
+                return SkCodec::kInvalidScale;
+            }
         }
 
         // Fill in the color table
         setup_color_table(dstInfo.colorType(), inputColorTable, inputColorCount);
 
         // Copy the color table to a pointer that can be owned by the scanline decoder
         if (kIndex_8_SkColorType == dstInfo.colorType()) {
             fColorTable.reset(SkNEW_ARGS(SkColorTable, (inputColorTable, 2)));
         }
 
         // Initialize the swizzler
         fSwizzler.reset(fCodec->initializeSwizzler(dstInfo,
                 get_color_ptr(fColorTable.get()), options));
         if (NULL == fSwizzler.get()) {
             return SkCodec::kInvalidInput;
         }
 
         return SkCodec::kSuccess;
     }
 
+    SkEncodedFormat onGetEncodedFormat() const {
+        return kWBMP_SkEncodedFormat;
+    }
+
 private:
     SkAutoTDelete<SkWbmpCodec>   fCodec;
     SkAutoTUnref<SkColorTable>   fColorTable;
     SkAutoTDelete<SkSwizzler>    fSwizzler;
     SkAutoTMalloc<uint8_t>       fSrcBuffer;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkWbmpCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkWbmpCodec> codec(static_cast<SkWbmpCodec*>(
             SkWbmpCodec::NewFromStream(stream)));
     if (!codec) {
         return NULL;
     }
 
     // Return the new scanline decoder
     return SkNEW_ARGS(SkWbmpScanlineDecoder, (codec.detach()));
 }