SkScaledCodec class

include/codec/SkScanlineDecoder.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkScanlineDecoder_DEFINED
 #define SkScanlineDecoder_DEFINED
 
@@ skipping 17 matching lines @@
      *  Write the next countLines scanlines into dst.
      *
      *  @param dst Must be non-null, and large enough to hold countLines
      *      scanlines of size rowBytes.
      *  @param countLines Number of lines to write.
      *  @param rowBytes Number of bytes per row. Must be large enough to hold
      *      a scanline based on the SkImageInfo used to create this object.
      */
     SkCodec::Result getScanlines(void* dst, int countLines, size_t rowBytes) {
         if ((rowBytes < fDstInfo.minRowBytes() && countLines > 1 ) || countLines <= 0
-                || fCurrScanline + countLines > fDstInfo.height()) {
+                || fCurrScanline + countLines > fSrcInfo.height()) {
             return SkCodec::kInvalidParameters;
         }
         const SkCodec::Result result = this->onGetScanlines(dst, countLines, rowBytes);
         fCurrScanline += countLines;
         return result;
     }
 
     /**
      *  Skip count scanlines.
      *
      *  The default version just calls onGetScanlines and discards the dst.
      *  NOTE: If skipped lines are the only lines with alpha, this default
      *  will make reallyHasAlpha return true, when it could have returned
      *  false.
      */
     SkCodec::Result skipScanlines(int countLines) {
-        if (fCurrScanline + countLines > fDstInfo.height()) {
+        if (fCurrScanline + countLines > fSrcInfo.height()) {
             // Arguably, we could just skip the scanlines which are remaining,
             // and return kSuccess. We choose to return invalid so the client
             // can catch their bug.
             return SkCodec::kInvalidParameters;
         }
         const SkCodec::Result result = this->onSkipScanlines(countLines);
         fCurrScanline += countLines;
         return result;
     }
 
     /**
      *  Some images may initially report that they have alpha due to the format
      *  of the encoded data, but then never use any colors which have alpha
      *  less than 100%. This function can be called *after* decoding to
      *  determine if such an image truly had alpha. Calling it before decoding
      *  is undefined.
      *  FIXME: see skbug.com/3582.
      */
     bool reallyHasAlpha() const {
         return this->onReallyHasAlpha();
     }
 
+    bool setSampleX(int sampleX) {

[scroggo, 2015/07/27 15:09:19]

Please add comments explaining what this does.

[emmaleer, 2015/07/27 18:31:38]

Acknowledged.

+        return this->onSetSampleX(sampleX);
+    }
+
 protected:
-    SkScanlineDecoder(const SkImageInfo& requested)
+    SkScanlineDecoder(const SkImageInfo& requested, const SkImageInfo src)

[scroggo, 2015/07/27 15:09:19]

This should be a const reference. That way we do not do a copy when passing the
parameter. (The field needs to not be a reference, and we'll still do a copy
when it is initialized.)

[emmaleer, 2015/07/27 18:31:38]

Acknowledged.

         : fDstInfo(requested)
-        , fCurrScanline(0) {}
+        , fCurrScanline(0)
+        , fSrcInfo(src) {}
 
     virtual bool onReallyHasAlpha() const { return false; }
 
+    virtual bool onSetSampleX(int SampleX){ return false; }
+
     const SkImageInfo& dstInfo() const { return fDstInfo; }
 
 private:
     const SkImageInfo   fDstInfo;
     int                 fCurrScanline;
+    const SkImageInfo   fSrcInfo;
 
     // Naive default version just calls onGetScanlines on temp memory.
     virtual SkCodec::Result onSkipScanlines(int countLines) {
         SkAutoMalloc storage(fDstInfo.minRowBytes());
         // Note that we pass 0 to rowBytes so we continue to use the same memory.
         // Also note that while getScanlines checks that rowBytes is big enough,
         // onGetScanlines bypasses that check.
         // Calling the virtual method also means we do not double count
         // countLines.
         return this->onGetScanlines(storage.get(), countLines, 0);
     }
 
     virtual SkCodec::Result onGetScanlines(void* dst, int countLines,
                                                     size_t rowBytes) = 0;
 
 };
 #endif // SkScanlineDecoder_DEFINED