Provides multiple implementations of Android's SkBitmapRegionDecoder

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(nullptr));
     gm->modifyGrContextOptions(options);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
+BRDSrc::BRDSrc(Path path, SkBitmapRegionDecoder::Strategy strategy, Mode mode,
+        SkColorType dstColorType, uint32_t sampleSize)
+    : fPath(path)
+    , fStrategy(strategy)
+    , fMode(mode)
+    , fColorType(dstColorType)
+    , fSampleSize(sampleSize)
+{}
+
+bool BRDSrc::veto(SinkFlags flags) const {
+    // No need to test to non-raster or indirect backends.
+    return flags.type != SinkFlags::kRaster
+        || flags.approach != SinkFlags::kDirect;
+}
+
+static SkBitmapRegionDecoder* create_brd(Path path, SkBitmapRegionDecoder::Strategy strategy) {
+    SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
+    if (!encoded) {
+        return NULL;
+    }
+    return SkBitmapRegionDecoder::CreateBitmapRegionDecoder(new SkMemoryStream(encoded), strategy);
+}
+
+Error BRDSrc::draw(SkCanvas* canvas) const {
+    if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
+        return Error::Nonfatal("Testing to multiple backends is uninteresting.");
+    }
+
+    SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath, fStrategy));
+    if (nullptr == brd.get()) {
+        return Error::Nonfatal(SkStringPrintf("Could not create brd for %s.", fPath.c_str()));
+    }
+
+    switch (fMode) {
+        case kFullImage_Mode: {
+            SkAutoTDelete<SkBitmap> bitmap(brd->decodeRegion(0, 0, brd->width(),
+                    brd->height(), fSampleSize, fColorType));
+            if (nullptr == bitmap.get() || fColorType != bitmap->colorType()) {
+                return Error::Nonfatal("Cannot convert to color type.\n");
+            }
+            canvas->drawBitmap(*bitmap, 0, 0);
+            return "";
+        }
+        case kDivisor_Mode: {
+            uint32_t divisor = 2;
+            // Use a border to test subsets that extend outside the image.
+            // We will not allow the border to be larger than the image dimensions.  Allowing
+            // these large borders causes off by one errors that indicate a problem with the
+            // test suite, not a problem with the implementation.
+            uint32_t maxBorder = SkTMin(brd->width(), brd->height()) / (fSampleSize * divisor);
+            uint32_t scaledBorder = SkTMin(5u, maxBorder);
+            uint32_t unscaledBorder = scaledBorder * fSampleSize;
+
+            uint32_t width = brd->width();

[scroggo, 2015/09/02 21:32:24]

nit: These could have been defined above, so you only access brd->width() once.

Also, can any of these fields be const?

[msarett, 2015/09/03 19:20:51]

Good point!  Pretty sure lots of them can be const.

+            uint32_t height = brd->height();
+            for (uint32_t x = 0; x < divisor; x++) {
+                for (uint32_t y = 0; y < divisor; y++) {
+                    // Calculate the subset dimensions
+                    uint32_t subsetWidth = width / divisor;
+                    uint32_t subsetHeight = height / divisor;
+                    int left = x * subsetWidth;
+                    int top = y * subsetHeight;
+
+                    // Increase the size of the last subset in each row or column, when the
+                    // divisor does not divide evenly into the image dimensions
+                    subsetWidth += (x + 1 == divisor) ? (width % divisor) : 0;
+                    subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
+
+                    // Increase the size of the subset in order to have a border on each side
+                    int decodeLeft = left - unscaledBorder;
+                    int decodeTop = top - unscaledBorder;
+                    uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
+                    uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
+
+                    SkAutoTDelete<SkBitmap> bitmap(brd->decodeRegion(decodeLeft,

[scroggo, 2015/09/02 21:32:24]

What should we do about the fact that WEBP gives us a different subset in the
case of an odd left or top? A FIXME? Handle it inside the BRD?

[msarett, 2015/09/03 19:20:51]

I think it should be handled in BRD.  We want BRD to handle everything, since I
think we will either call it from Android code or simply use it to replicate and
test (as close as we can) the code that we will have in Android.

Having said that, it should be a FIXME since we aren't currently handling it in
BRD.  The BRD implementation that uses SkScaledCodec (WIP, not in this CL)
already handles it partly (fails when the subsets aren't on even boundaries).

+                            decodeTop, decodeWidth, decodeHeight, fSampleSize, fColorType));
+                    if (nullptr == bitmap.get() || fColorType != bitmap->colorType()) {
+                        return Error::Nonfatal("Cannot convert to color type.\n");
+                    }
+                    canvas->drawBitmapRect(*bitmap,
+                            SkRect::MakeXYWH(scaledBorder, scaledBorder,
+                                    subsetWidth / fSampleSize, subsetHeight / fSampleSize),
+                            SkRect::MakeXYWH(left / fSampleSize, top / fSampleSize,
+                                    subsetWidth / fSampleSize, subsetHeight / fSampleSize),
+                            nullptr);
+                }
+            }
+            return "";
+        }
+        default:
+            SkASSERT(false);
+            return "Error: Should not be reached.\n";
+    }
+}
+
+SkISize BRDSrc::size() const {
+    SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath, fStrategy));
+    if (brd) {
+        return SkISize::Make(SkTMax(1, brd->width() / (int) fSampleSize),
+                SkTMax(1, brd->height() / (int) fSampleSize));
+    }
+    return SkISize::Make(0, 0);
+}
+
+static SkString get_scaled_name(Path path, float scale) {

[scroggo, 2015/09/02 21:32:24]

Copying SkStrings is cheap, but const &ing them is cheaper!

[msarett, 2015/09/03 19:20:51]

:)

+    return SkStringPrintf("%s_%.3f", SkOSPath::Basename(path.c_str()).c_str(), scale);
+}
+
+Name BRDSrc::name() const {
+    // We will replicate the names used by CodecSrc so that images can
+    // be compared in Gold.
+    if (1 == fSampleSize) {
+        return SkOSPath::Basename(fPath.c_str());
+    }
+    return get_scaled_name(fPath, BRDSrc::GetScale(fSampleSize));
+}
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
 CodecSrc::CodecSrc(Path path, Mode mode, DstColorType dstColorType, float scale)
     : fPath(path)
     , fMode(mode)
     , fDstColorType(dstColorType)
     , fScale(scale)
 {}
 
 bool CodecSrc::veto(SinkFlags flags) const {
     // No need to test decoding to non-raster or indirect backend.
     // TODO: Once we implement GPU paths (e.g. JPEG YUV), we should use a deferred decode to
@@ skipping 409 matching lines @@
             return SkISize::Make(0, 0);
         }
     }
     SkISize size = codec->getScaledDimensions(fScale);
     return size;
 }
 
 Name CodecSrc::name() const {
     if (1.0f == fScale) {
         return SkOSPath::Basename(fPath.c_str());
-    } else {
-        return SkStringPrintf("%s_%.3f", SkOSPath::Basename(fPath.c_str()).c_str(), fScale);
     }
+    return get_scaled_name(fPath, fScale);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 ImageSrc::ImageSrc(Path path, int divisor) : fPath(path), fDivisor(divisor) {}
 
 bool ImageSrc::veto(SinkFlags flags) const {
     // No need to test decoding to non-raster or indirect backend.
     // TODO: Instead, use lazy decoding to allow the GPU to handle cases like YUV.
     return flags.type != SinkFlags::kRaster
@@ skipping 577 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM