Add SkAndroidCodec::getPixels

tests/CodexTest.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 "Resources.h"
 #include "SkAndroidCodec.h"
 #include "SkBitmap.h"
@@ skipping 38 matching lines @@
     md5(bm, &digest);
     REPORTER_ASSERT(r, digest == goodDigest);
 }
 
 /**
  *  Test decoding an SkCodec to a particular SkImageInfo.
  *
  *  Calling getPixels(info) should return expectedResult, and if goodDigest is non nullptr,
  *  the resulting decode should match.
  */
-static void test_info(skiatest::Reporter* r, SkCodec* codec, const SkImageInfo& info,
+template<typename Codec>
+static void test_info(skiatest::Reporter* r, Codec* codec, const SkImageInfo& info,
                       SkCodec::Result expectedResult, const SkMD5::Digest* goodDigest) {
     SkBitmap bm;
     bm.allocPixels(info);
     SkAutoLockPixels autoLockPixels(bm);
 
     SkCodec::Result result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
     REPORTER_ASSERT(r, result == expectedResult);
 
     if (goodDigest) {
         compare_to_good_digest(r, *goodDigest, bm);
     }
 }
 
-static void test_android_info(skiatest::Reporter* r, SkAndroidCodec* codec, const SkImageInfo& info,
-                              SkCodec::Result expectedResult, const SkMD5::Digest* goodDigest) {
-    SkBitmap bm;
-    bm.allocPixels(info);
-    SkAutoLockPixels autoLockPixels(bm);
-
-    SkCodec::Result result = codec->getAndroidPixels(info, bm.getPixels(), bm.rowBytes());
-    REPORTER_ASSERT(r, result == expectedResult);
-
-    if (goodDigest) {
-        compare_to_good_digest(r, *goodDigest, bm);
-    }
-}
-
 SkIRect generate_random_subset(SkRandom* rand, int w, int h) {
     SkIRect rect;
     do {
         rect.fLeft = rand->nextRangeU(0, w);
         rect.fTop = rand->nextRangeU(0, h);
         rect.fRight = rand->nextRangeU(0, w);
         rect.fBottom = rand->nextRangeU(0, h);
         rect.sort();
     } while (rect.isEmpty());
     return rect;
 }
 
-static void test_codec(skiatest::Reporter* r, SkCodec* codec, SkBitmap& bm, const SkImageInfo& info,
+template<typename Codec>
+static void test_codec(skiatest::Reporter* r, Codec* codec, SkBitmap& bm, const SkImageInfo& info,
         const SkISize& size, SkCodec::Result expectedResult, SkMD5::Digest* digest,
         const SkMD5::Digest* goodDigest) {
 
     REPORTER_ASSERT(r, info.dimensions() == size);
     bm.allocPixels(info);
     SkAutoLockPixels autoLockPixels(bm);
 
     SkCodec::Result result = codec->getPixels(info, bm.getPixels(), bm.rowBytes());
     REPORTER_ASSERT(r, result == expectedResult);
 
@@ skipping 32 matching lines @@
                 otherAt = kUnpremul_SkAlphaType;
             } else {
                 otherAt = kPremul_SkAlphaType;
             }
             // The other non-opaque alpha type should always succeed, but not match.
             test_info(r, codec, info.makeAlphaType(otherAt), expectedResult, nullptr);
         }
     }
 }
 
-static void test_android_codec(skiatest::Reporter* r, SkAndroidCodec* codec, SkBitmap& bm,
-        const SkImageInfo& info, const SkISize& size, SkCodec::Result expectedResult,
-        SkMD5::Digest* digest, const SkMD5::Digest* goodDigest) {
-
-    REPORTER_ASSERT(r, info.dimensions() == size);
-    bm.allocPixels(info);
-    SkAutoLockPixels autoLockPixels(bm);
-
-    SkCodec::Result result = codec->getAndroidPixels(info, bm.getPixels(), bm.rowBytes());
-    REPORTER_ASSERT(r, result == expectedResult);
-
-    md5(bm, digest);
-    if (goodDigest) {
-        REPORTER_ASSERT(r, *digest == *goodDigest);
-    }
-
-    {
-        // Test decoding to 565
-        SkImageInfo info565 = info.makeColorType(kRGB_565_SkColorType);
-        SkCodec::Result expected565 = info.alphaType() == kOpaque_SkAlphaType ?
-                expectedResult : SkCodec::kInvalidConversion;
-        test_android_info(r, codec, info565, expected565, nullptr);
-    }
-
-    // Verify that re-decoding gives the same result.  It is interesting to check this after
-    // a decode to 565, since choosing to decode to 565 may result in some of the decode
-    // options being modified.  These options should return to their defaults on another
-    // decode to kN32, so the new digest should match the old digest.
-    test_android_info(r, codec, info, expectedResult, digest);
-
-    {
-        // Check alpha type conversions
-        if (info.alphaType() == kOpaque_SkAlphaType) {
-            test_android_info(r, codec, info.makeAlphaType(kUnpremul_SkAlphaType),
-                    expectedResult, digest);
-            test_android_info(r, codec, info.makeAlphaType(kPremul_SkAlphaType),
-                    expectedResult, digest);
-        } else {
-            // Decoding to opaque should fail
-            test_android_info(r, codec, info.makeAlphaType(kOpaque_SkAlphaType),
-                    SkCodec::kInvalidConversion, nullptr);
-            SkAlphaType otherAt = info.alphaType();
-            if (kPremul_SkAlphaType == otherAt) {
-                otherAt = kUnpremul_SkAlphaType;
-            } else {
-                otherAt = kPremul_SkAlphaType;
-            }
-            // The other non-opaque alpha type should always succeed, but not match.
-            test_android_info(r, codec, info.makeAlphaType(otherAt), expectedResult, nullptr);
-        }
-    }
-}
-
 // FIXME: SkScaledCodec is currently only supported for types used by BRD
 // https://bug.skia.org/4428
 static bool supports_scaled_codec(const char path[]) {
     static const char* const exts[] = {
         "jpg", "jpeg", "png", "webp"
         "JPG", "JPEG", "PNG", "WEBP"
     };
 
     for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
         if (SkStrEndsWith(path, exts[i])) {
@@ skipping 28 matching lines @@
     if (!codec) {
         ERRORF(r, "Unable to decode '%s'", path);
         return;
     }
 
     // Test full image decodes with SkCodec
     SkMD5::Digest codecDigest;
     SkImageInfo info = codec->getInfo().makeColorType(kN32_SkColorType);
     SkBitmap bm;
     SkCodec::Result expectedResult = isIncomplete ? SkCodec::kIncompleteInput : SkCodec::kSuccess;
-    test_codec(r, codec, bm, info, size, expectedResult, &codecDigest, nullptr);
+    test_codec(r, codec.get(), bm, info, size, expectedResult, &codecDigest, nullptr);
 
     // Scanline decoding follows.
     // Need to call startScanlineDecode() first.
     REPORTER_ASSERT(r, codec->getScanlines(bm.getAddr(0, 0), 1, 0)
             == 0);
     REPORTER_ASSERT(r, codec->skipScanlines(1)
             == 0);
 
     const SkCodec::Result startResult = codec->startScanlineDecode(info);
     if (supportsScanlineDecoding) {
@@ skipping 90 matching lines @@
 
     // SkScaledCodec tests
     if ((supportsScanlineDecoding || supportsSubsetDecoding) && supports_scaled_codec(path)) {
 
         SkAutoTDelete<SkStream> stream(resource(path));
         if (!stream) {
             SkDebugf("Missing resource '%s'\n", path);
             return;
         }
 
-        SkAutoTDelete<SkAndroidCodec> codec(nullptr);
+        SkAutoTDelete<SkAndroidCodec> androidCodec(nullptr);
         if (isIncomplete) {
             size_t size = stream->getLength();
             SkAutoTUnref<SkData> data((SkData::NewFromStream(stream, 2 * size / 3)));
-            codec.reset(SkAndroidCodec::NewFromData(data));
+            androidCodec.reset(SkAndroidCodec::NewFromData(data));
         } else {
-            codec.reset(SkAndroidCodec::NewFromStream(stream.detach()));
+            androidCodec.reset(SkAndroidCodec::NewFromStream(stream.detach()));
         }
-        if (!codec) {
+        if (!androidCodec) {
             ERRORF(r, "Unable to decode '%s'", path);
             return;
         }
 
         SkBitmap bm;
         SkMD5::Digest scaledCodecDigest;
-        test_android_codec(r, codec, bm, info, size, expectedResult,
-                &scaledCodecDigest, &codecDigest);
+        test_codec(r, androidCodec.get(), bm, info, size, expectedResult, &scaledCodecDigest,
+                   &codecDigest);
     }
 
     // Test SkCodecImageGenerator
     if (!isIncomplete) {
         SkAutoTDelete<SkStream> stream(resource(path));
         SkAutoTUnref<SkData> fullData(SkData::NewFromStream(stream, stream->getLength()));
         SkAutoTDelete<SkImageGenerator> gen(SkCodecImageGenerator::NewFromEncodedCodec(fullData));
         SkBitmap bm;
         bm.allocPixels(info);
         SkAutoLockPixels autoLockPixels(bm);
@@ skipping 511 matching lines @@
     SkAutoTUnref<SkData> data(SkData::NewFromFileName(fullPath.c_str()));
     if (!data) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     // The limit is less than webp needs to peek or read.
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 25)));
     REPORTER_ASSERT(r, codec);
 
-    test_info(r, codec, codec->getInfo(), SkCodec::kSuccess, nullptr);
+    test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 
     // Similarly, a stream which does not peek should still succeed.
     codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 0)));
     REPORTER_ASSERT(r, codec);
 
-    test_info(r, codec, codec->getInfo(), SkCodec::kSuccess, nullptr);
+    test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
 
 // SkCodec's wbmp decoder was initially more restrictive than SkImageDecoder.
 // It required the second byte to be zero. But SkImageDecoder allowed a couple
 // of bits to be 1 (so long as they do not overlap with 0x9F). Test that
 // SkCodec now supports an image with these bits set.
 DEF_TEST(Codec_wbmp, r) {
     const char* path = "mandrill.wbmp";
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     // Modify the stream to contain a second byte with some bits set.
     SkAutoTUnref<SkData> data(SkCopyStreamToData(stream));
     uint8_t* writeableData = static_cast<uint8_t*>(data->writable_data());
     writeableData[1] = static_cast<uint8_t>(~0x9F);
 
     // SkImageDecoder supports this.
     SkBitmap bitmap;
     REPORTER_ASSERT(r, SkImageDecoder::DecodeMemory(data->data(), data->size(), &bitmap));
 
     // So SkCodec should, too.
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
     REPORTER_ASSERT(r, codec);
     if (!codec) {
         return;
     }
-    test_info(r, codec, codec->getInfo(), SkCodec::kSuccess, nullptr);
+    test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
 
 // wbmp images have a header that can be arbitrarily large, depending on the
 // size of the image. We cap the size at 65535, meaning we only need to look at
 // 8 bytes to determine whether we can read the image. This is important
 // because SkCodec only passes 14 bytes to SkWbmpCodec to determine whether the
 // image is a wbmp.
 DEF_TEST(Codec_wbmp_max_size, r) {
     const unsigned char maxSizeWbmp[] = { 0x00, 0x00,           // Header
                                           0x83, 0xFF, 0x7F,     // W: 65535
@@ skipping 10 matching lines @@
     // Now test an image which is too big. Any image with a larger header (i.e.
     // has bigger width/height) is also too big.
     const unsigned char tooBigWbmp[] = { 0x00, 0x00,           // Header
                                          0x84, 0x80, 0x00,     // W: 65536
                                          0x84, 0x80, 0x00 };   // H: 65536
     stream.reset(new SkMemoryStream(tooBigWbmp, sizeof(tooBigWbmp), false));
     codec.reset(SkCodec::NewFromStream(stream.detach()));
 
     REPORTER_ASSERT(r, !codec);
 }