SkScaledCodec class

src/codec/SkCodec_libpng.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_libpng.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkBitmap.h"
 #include "SkMath.h"
+#include "SkScaledCodec.h"
 #include "SkScanlineDecoder.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper macros
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef png_jmpbuf
@@ skipping 444 matching lines @@
             //would have exited before now if the colorType was supported by png
             SkASSERT(false);
     }  
 
     // Copy the color table to the client if they request kIndex8 mode
     copy_color_table(requestedInfo, fColorTable, ctable, ctableCount);
 
     // Create the swizzler.  SkPngCodec retains ownership of the color table.
     const SkPMColor* colors = get_color_ptr(fColorTable.get());
     fSwizzler.reset(SkSwizzler::CreateSwizzler(fSrcConfig, colors, requestedInfo,
-            options.fZeroInitialized));
+                    options.fZeroInitialized, this->getInfo().width()));
     if (!fSwizzler) {
         // FIXME: CreateSwizzler could fail for another reason.
         return kUnimplemented;
     }
     return kSuccess;
 }
 
 
 bool SkPngCodec::handleRewind() {
     switch (this->rewindIfNeeded()) {
@@ skipping 108 matching lines @@
 class SkPngScanlineDecoder : public SkScanlineDecoder {
 public:
     SkPngScanlineDecoder(const SkImageInfo& srcInfo, SkPngCodec* codec)
         : INHERITED(srcInfo)
         , fCodec(codec)
         , fHasAlpha(false)
     {}
 
     SkCodec::Result onStart(const SkImageInfo& dstInfo,
                             const SkCodec::Options& options,
-                            SkPMColor ctable[], int* ctableCount) override
-    {
+                            SkPMColor ctable[], int* ctableCount) override {
         if (!fCodec->handleRewind()) {
             return SkCodec::kCouldNotRewind;
         }
 
         if (!conversion_possible(dstInfo, this->getInfo())) {
             return SkCodec::kInvalidConversion;
         }
 
         // Check to see if scaling was requested.
         if (dstInfo.dimensions() != this->getInfo().dimensions()) {
-            return SkCodec::kInvalidScale;
+            if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
+                return SkCodec::kInvalidScale;   
+            }
         }
 
         const SkCodec::Result result = fCodec->initializeSwizzler(dstInfo, options, ctable,
                                                                   ctableCount);
         if (result != SkCodec::kSuccess) {
             return result;
         }
 
         fHasAlpha = false;
-        fStorage.reset(dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
+        fStorage.reset(this->getInfo().width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
         fSrcRow = static_cast<uint8_t*>(fStorage.get());
 
         return SkCodec::kSuccess;
     }
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
         if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
             SkCodecPrintf("setjmp long jump!\n");
             return SkCodec::kInvalidInput;
         }
@@ skipping 18 matching lines @@
         //calling png_read_rows in a loop is insignificantly slower than calling it once with count 
         //as png_read_rows has it's own loop which calls png_read_row count times.
         for (int i = 0; i < count; i++) {
             png_read_rows(fCodec->fPng_ptr, &fSrcRow, png_bytepp_NULL, 1);
         }
         return SkCodec::kSuccess;
     }
 
     bool onReallyHasAlpha() const override { return fHasAlpha; }
 
+    SkEncodedFormat onGetEncodedFormat() const override { 
+        return kPNG_SkEncodedFormat;
+    }
+
+
 private:
     SkAutoTDelete<SkPngCodec>   fCodec;
     bool                        fHasAlpha;
     SkAutoMalloc                fStorage;
     uint8_t*                    fSrcRow;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 
@@ skipping 10 matching lines @@
 
     SkCodec::Result onStart(const SkImageInfo& dstInfo,
                             const SkCodec::Options& options,
                             SkPMColor ctable[], int* ctableCount) override
     {
         if (!fCodec->handleRewind()) {
             return SkCodec::kCouldNotRewind;
         }
 
         if (!conversion_possible(dstInfo, this->getInfo())) {
-            return SkCodec::kInvalidConversion;
+            return SkCodec::kInvalidConversion;    
         }
 
         // Check to see if scaling was requested.
         if (dstInfo.dimensions() != this->getInfo().dimensions()) {
-            return SkCodec::kInvalidScale;
+            if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
+                return SkCodec::kInvalidScale;
+            }
         }
 
         const SkCodec::Result result = fCodec->initializeSwizzler(dstInfo, options, ctable,
                                                                   ctableCount);
         if (result != SkCodec::kSuccess) {
             return result;
         }
 
         fHasAlpha = false;
         fCurrentRow = 0;
         fHeight = dstInfo.height();
-        fSrcRowBytes = dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig);
+        fSrcRowBytes = this->getInfo().width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig);
         fGarbageRow.reset(fSrcRowBytes);
         fGarbageRowPtr = static_cast<uint8_t*>(fGarbageRow.get());
         fCanSkipRewind = true;
 
         return SkCodec::kSuccess;
     }
 
     SkCodec::Result onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
         // rewind stream if have previously called onGetScanlines,
         // since we need entire progressive image to get scanlines
@@ skipping 42 matching lines @@
     }
 
     SkCodec::Result onSkipScanlines(int count) override {
         //when ongetScanlines is called it will skip to fCurrentRow
         fCurrentRow += count;
         return SkCodec::kSuccess;
     }
 
     bool onReallyHasAlpha() const override { return fHasAlpha; }
 
+    bool onRequiresPostYSampling() override {
+        return true;
+    }
+
+    SkEncodedFormat onGetEncodedFormat() const override { 
+        return kPNG_SkEncodedFormat;
+    }
+
 private:
     SkAutoTDelete<SkPngCodec>   fCodec;
     bool                        fHasAlpha;
     int                         fCurrentRow;
     int                         fHeight;
     size_t                      fSrcRowBytes;
     SkAutoMalloc                fGarbageRow;
     uint8_t*                    fGarbageRowPtr;
     // FIXME: This imitates behavior in SkCodec::rewindIfNeeded. That function
     // is called whenever some action is taken that reads the stream and
@@ skipping 19 matching lines @@
 
     const SkImageInfo& srcInfo = codec->getInfo();
     if (codec->fNumberPasses > 1) {
         // interlaced image
         return SkNEW_ARGS(SkPngInterlacedScanlineDecoder, (srcInfo, codec.detach()));
     }
 
     return SkNEW_ARGS(SkPngScanlineDecoder, (srcInfo, codec.detach()));
 }