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,
+        CodecSrc::DstColorType dstColorType, uint32_t sampleSize)
+    : fPath(path)
+    , fStrategy(strategy)
+    , fMode(mode)
+    , fDstColorType(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 {
+    SkColorType colorType = canvas->imageInfo().colorType();
+    if (kRGB_565_SkColorType == colorType &&
+            CodecSrc::kGetFromCanvas_DstColorType != fDstColorType) {
+        return Error::Nonfatal("Testing non-565 to 565 is uninteresting.");
+    }
+    switch (fDstColorType) {
+        case CodecSrc::kGetFromCanvas_DstColorType:
+            break;
+        case CodecSrc::kIndex8_Always_DstColorType:
+            colorType = kIndex_8_SkColorType;
+            break;
+        case CodecSrc::kGrayscale_Always_DstColorType:
+            colorType = kGray_8_SkColorType;
+            break;
+    }
+
+    SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath, fStrategy));
+    if (nullptr == brd.get()) {
+        return Error::Nonfatal(SkStringPrintf("Could not create brd for %s.", fPath.c_str()));
+    }
+
+    const uint32_t width = brd->width();
+    const uint32_t height = brd->height();
+    switch (fMode) {
+        case kFullImage_Mode: {
+            SkAutoTDelete<SkBitmap> bitmap(brd->decodeRegion(0, 0, width, height, fSampleSize,
+                    colorType));
+            if (nullptr == bitmap.get() || colorType != bitmap->colorType()) {
+                return Error::Nonfatal("Cannot convert to color type.\n");
+            }
+            canvas->drawBitmap(*bitmap, 0, 0);
+            return "";
+        }
+        case kDivisor_Mode: {
+            const 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.
+            const uint32_t maxBorder = SkTMin(width, height) / (fSampleSize * divisor);
+            const uint32_t scaledBorder = SkTMin(5u, maxBorder);
+            const uint32_t unscaledBorder = scaledBorder * fSampleSize;
+
+
+            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;
+                    const int left = x * subsetWidth;
+                    const 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
+                    const int decodeLeft = left - unscaledBorder;
+                    const int decodeTop = top - unscaledBorder;
+                    const uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
+                    const uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
+                    SkAutoTDelete<SkBitmap> bitmap(brd->decodeRegion(decodeLeft,
+                            decodeTop, decodeWidth, decodeHeight, fSampleSize, colorType));
+                    if (nullptr == bitmap.get() || colorType != bitmap->colorType()) {
+                        return Error::Nonfatal("Cannot convert to color type.\n");
+                    }
+
+                    // We may need to clear the canvas to avoid uninitialized memory.
+                    // Assume we are scaling a 780x780 image with sampleSize = 8.
+                    // The output image should be 97x97.

[scroggo, 2015/09/04 17:55:06]

I think it's okay that the final image is less than 97 x 97. The Java client
will supply a Bitmap for each quadrant (assuming this use case), and we'll
return four Bitmaps of 48 x 48. If someone is using our native API, they will
specify the scaling and subset they want, and we'll return the size of the
output (I think I need to add that API, actually - just added skbug.com/4302).

For SkImageDecoder, we provide the output bitmap, so we'll just allocate the
memory we need.

[msarett, 2015/09/04 18:54:10]

Yeah I agree with that assessment.  BRD is behaving as we want it to - it's just
a bit strange when combining regions for the purposes of testing.

+                    // Each subset will be 390x390.
+                    // Each scaled subset be 48x48.
+                    // Four scaled subsets will only fill a 96x96 image.
+                    // The bottom row and last column will not be touched.
+                    // This is an unfortunate result of our rounding rules when scaling.
+                    // Maybe we need to consider testing scaled subsets without trying to
+                    // combine them to match the full scaled image?  Or maybe this is the
+                    // best we can do?
+                    canvas->clear(0);
+
+                    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(const Path& path, float scale) {
+    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