DM testing for skipping and scaling

dm/DMSrcSink.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 "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCodec.h"
@@ skipping 46 matching lines @@
     return gm->getName();
 }
 
 void GMSrc::modifyGrContextOptions(GrContextOptions* options) const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     gm->modifyGrContextOptions(options);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
-CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType)
+CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, float scale)
     : fPath(path)
     , fMode(mode)
     , fDstColorType(dstColorType)
+    , fScale(scale)
 {}
 
 Error CodecSrc::draw(SkCanvas* canvas) const {
     SkImageInfo canvasInfo;
     if (NULL == canvas->peekPixels(&canvasInfo, NULL)) {
         // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
         // let the GPU handle it.
         return Error::Nonfatal("No need to test decoding to non-raster backend.");
     }
 
@@ skipping 20 matching lines @@
             decodeInfo = codec->getInfo().makeColorType(kGray_8_SkColorType);
             if (kRGB_565_SkColorType == canvasColorType) {
                 return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
             }
             break;
         default:
             decodeInfo = decodeInfo.makeColorType(canvasColorType);
             break;
     }
 
+    // Try to scale the image if it is desired
+    SkISize size = codec->getScaledDimensions(fScale);
+    if (size == decodeInfo.dimensions() && 1.0f != fScale) {
+        return Error::Nonfatal("Test without scaling is uninteresting.");
+    }
+    decodeInfo = decodeInfo.makeWH(size.width(), size.height());
+
     // Construct a color table for the decode if necessary
     SkAutoTUnref<SkColorTable> colorTable(NULL);
     SkPMColor* colorPtr = NULL;
     int* colorCountPtr = NULL;
     int maxColors = 256;
     if (kIndex_8_SkColorType == decodeInfo.colorType()) {
         SkPMColor colors[256];
         colorTable.reset(SkNEW_ARGS(SkColorTable, (colors, maxColors)));
         colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
         colorCountPtr = &maxColors;
@@ skipping 67 matching lines @@
             const int extraY = h % divisor;
             /*
             * if w or h are not evenly divided by divisor need to adjust width and height of end
             * subsets to cover entire image.
             * Add extraX and extraY to largestSubsetBm's width and height to adjust width
             * and height of end subsets.
             * subsetBm is extracted from largestSubsetBm.
             * subsetBm's size is determined based on the current subset and may be larger for end
             * subsets.
             */
-            SkImageInfo largestSubsetDecodeInfo = 
+            SkImageInfo largestSubsetDecodeInfo =
                     decodeInfo.makeWH(subsetWidth + extraX, subsetHeight + extraY);
             SkBitmap largestSubsetBm;
             if (!largestSubsetBm.tryAllocPixels(largestSubsetDecodeInfo, NULL, colorTable.get())) {
                 return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                         largestSubsetDecodeInfo.width(), largestSubsetDecodeInfo.height());
             }
             char* line = SkNEW_ARRAY(char, decodeInfo.minRowBytes());
             SkAutoTDeleteArray<char> lineDeleter(line);
             for (int col = 0; col < divisor; col++) {
                 //currentSubsetWidth may be larger than subsetWidth for rightmost subsets
@@ skipping 10 matching lines @@
                             NULL, colorPtr, colorCountPtr);
                     if (NULL == subsetScanlineDecoder) {
                         if (x == 0 && y == 0) {
                             //first try, image may not be compatible
                             return Error::Nonfatal("Cannot use scanline decoder for all images");
                         } else {
                             return "Error scanline decoder is NULL";
                         }
                     }
                     //skip to first line of subset
-                    const SkImageGenerator::Result skipResult = 
+                    const SkImageGenerator::Result skipResult =
                             subsetScanlineDecoder->skipScanlines(y);
                     switch (skipResult) {
                         case SkImageGenerator::kSuccess:
                         case SkImageGenerator::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("%s failed after attempting to skip %d scanlines"
                                     "with error message %d", fPath.c_str(), y, (int) skipResult);
                     }
                     //create and set size of subsetBm
@@ skipping 15 matching lines @@
                             default:
                                 return SkStringPrintf("%s failed after %d scanlines with error" 
                                         "message %d", fPath.c_str(), y-1, (int) subsetResult);
                         }
                     }
                     canvas->drawBitmap(subsetBm, SkIntToScalar(x), SkIntToScalar(y));
                 }
             }
             break;
         }
+        // This mode tests the skipping of scanlines.

[scroggo, 2015/06/11 20:12:48]

Maybe the description belongs in the header, by the declaration of kStripe_Mode?

[msarett, 2015/06/11 21:20:27]

Done.

+        case kStripe_Mode: {
+            int width = decodeInfo.width();

[scroggo, 2015/06/11 20:12:48]

Can these be const?

[msarett, 2015/06/11 21:20:27]

Done.

+            int height = decodeInfo.height();
+            // This value is chosen arbitrarily.  We exercise more cases by choosing a value that
+            // does not align with image blocks.
+            const int stripeHeight = 37;
+            const int numStripes = (height + stripeHeight - 1) / stripeHeight;
+
+            // Create bitmap
+            SkBitmap bitmap;
+            if (!bitmap.tryAllocPixels(decodeInfo, NULL, colorTable.get())) {
+                return SkStringPrintf("Cannot allocate pixels for %s %dx%d", fPath.c_str(),
+                        width, height);
+            }
+
+            // Decode odd stripes
+            SkScanlineDecoder* decoder = codec->getScanlineDecoder(decodeInfo, NULL, colorPtr,
+                    colorCountPtr);
+            if (NULL == decoder) {
+                return Error::Nonfatal("Cannot use scanline decoder for all images");
+            }
+            for (int i = 0; i < numStripes; i += 2) {
+                // Skip a stripe
+                const int linesToSkip = SkTMin(stripeHeight, height - i * stripeHeight);

[scroggo, 2015/06/11 20:12:48]

Will this ever be less than stripeHeight? It seems like we would either have a
full stripe to skip, or there is less than a full stripe to skip, in which case
we won't have anything to read down below.

Ok, I think I see: down below, we might read 0 scanlines?

[msarett, 2015/06/11 21:20:27]

Yes, we might read 0 scanlines below.

+                decoder->skipScanlines(linesToSkip);

[scroggo, 2015/06/11 20:12:48]

I think we want to return an error if this or getScanlines fails.

[msarett, 2015/06/11 21:20:27]

Done.

+
+                // Read a stripe
+                const int startY = SkTMin((i + 1) * stripeHeight, height - 1);

[scroggo, 2015/06/11 20:12:48]

When will we use height - 1? It seems like if the first value is too large,
we've gone past the end. Or do we special case so that we'll read the last line?
Is that so the final skip was meaningful? Maybe add a comment; this seems a
little tricky to me.

[msarett, 2015/06/11 21:20:27]

Yes this is tricky and a bug.  The original code was:
const int startY = (i + 1) * stripeHeight;
Which can go past the end of the image, but works with the code below because
linesToRead would then be 0.

I added SkTMin becuase bitmap.getAddr() will fail in Debug mode if startY >=
height.  But now this will cause us to always read at least one line below,
which we don't want.

The fix should clear things up.

+                const int linesToRead = SkTMax(0, SkTMin(stripeHeight, height - startY));
+                decoder->getScanlines(bitmap.getAddr(0, startY), linesToRead, bitmap.rowBytes());
+            }
+
+            // Decode even stripes
+            decoder = codec->getScanlineDecoder(decodeInfo, NULL, colorPtr, colorCountPtr);

[scroggo, 2015/06/11 20:12:48]

I think we want to return an error if decoder is null. (Since it should always
succeed the second time).

[msarett, 2015/06/11 21:20:27]

Done.

+            for (int i = 0; i < numStripes; i += 2) {
+                // Read a stripe
+                const int startY = i * stripeHeight;
+                const int linesToRead = SkTMin(stripeHeight, height - startY);
+                decoder->getScanlines(bitmap.getAddr(0, startY), linesToRead, bitmap.rowBytes());
+
+                // Skip a stripe
+                const int linesToSkip = SkTMax(0, SkTMin(stripeHeight,
+                        height - (i + 1) * stripeHeight));
+                decoder->skipScanlines(linesToSkip);
+            }
+            canvas->drawBitmap(bitmap, 0, 0);
+        }
     }
     return "";
 }
 
 SkISize CodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
     if (NULL != codec) {
-        return codec->getInfo().dimensions();
+        SkISize size = codec->getScaledDimensions(fScale);
+        return size;
     } else {
         return SkISize::Make(0, 0);
     }
 }
 
 Name CodecSrc::name() const {
-    return SkOSPath::Basename(fPath.c_str());
+    if (1.0f == fScale) {
+        return SkOSPath::Basename(fPath.c_str());
+    } else {
+        return SkStringPrintf("%s_%.3f", SkOSPath::Basename(fPath.c_str()).c_str(), fScale);
+    }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ImageSrc::ImageSrc(Path path, int divisor) : fPath(path), fDivisor(divisor) {}
 
 Error ImageSrc::draw(SkCanvas* canvas) const {
     SkImageInfo canvasInfo;
     if (NULL == canvas->peekPixels(&canvasInfo, NULL)) {
         // TODO: Instead, use lazy decoding to allow the GPU to handle cases like YUV.
@@ skipping 591 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM