Support the non-native (RGBA/BGRA) swizzle

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 "SkAndroidCodec.h"
 #include "SkCodec.h"
@@ skipping 92 matching lines @@
     }
     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;
+        default:

[scroggo, 2016/04/22 20:12:32]

Why is this necessary?

[msarett, 2016/04/22 20:25:23]

We're not testing kNonNative mode for BRD, but now that it exists, we need to
handle it in the switch statement.

+            SkASSERT(false);
+            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()));
     }
 
     if (!brd->conversionSupported(colorType)) {
         return Error::Nonfatal("Cannot convert to color type.");
     }
@@ skipping 141 matching lines @@
     , fDstAlphaType(dstAlphaType)
     , fScale(scale)
     , fRunSerially(serial_from_path_name(path))
 {}
 
 bool CodecSrc::veto(SinkFlags flags) const {
     // Test to direct raster backends (8888 and 565).
     return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
 }
 
+// Allows us to test decodes to non-native 8888.
+void swap_rb_if_necessary(SkBitmap& bitmap, CodecSrc::DstColorType dstColorType) {
+    if (CodecSrc::kNonNative8888_Always_DstColorType != dstColorType) {
+        return;
+    }
+
+    for (int y = 0; y < bitmap.height(); y++) {
+        uint32_t* row = (uint32_t*) bitmap.getAddr(0, y);
+        SkOpts::RGBA_to_BGRA(row, row, bitmap.width());
+    }
+}
+
 // FIXME: Currently we cannot draw unpremultiplied sources. skbug.com/3338 and skbug.com/3339.
 // This allows us to still test unpremultiplied decodes.
 void premultiply_if_necessary(SkBitmap& bitmap) {
     if (kUnpremul_SkAlphaType != bitmap.alphaType()) {
         return;
     }
 
     switch (bitmap.colorType()) {
         case kN32_SkColorType:
             for (int y = 0; y < bitmap.height(); y++) {
@@ skipping 26 matching lines @@
             }
             *decodeInfo = decodeInfo->makeColorType(kIndex_8_SkColorType);
             break;
         case CodecSrc::kGrayscale_Always_DstColorType:
             if (kRGB_565_SkColorType == canvasColorType ||
                     kOpaque_SkAlphaType != decodeInfo->alphaType()) {
                 return false;
             }
             *decodeInfo = decodeInfo->makeColorType(kGray_8_SkColorType);
             break;
+        case CodecSrc::kNonNative8888_Always_DstColorType:
+#ifdef SK_PMCOLOR_IS_RGBA
+            *decodeInfo = decodeInfo->makeColorType(kBGRA_8888_SkColorType);
+#else
+            *decodeInfo = decodeInfo->makeColorType(kRGBA_8888_SkColorType);
+#endif
+            break;
         default:
             if (kRGB_565_SkColorType == canvasColorType &&
                     kOpaque_SkAlphaType != decodeInfo->alphaType()) {
                 return false;
             }
             *decodeInfo = decodeInfo->makeColorType(canvasColorType);
             break;
     }
 
     return true;
@@ skipping 41 matching lines @@
     }
 
     SkBitmap bitmap;
     SkPixelRefFactory* factory = nullptr;
     SkMallocPixelRef::ZeroedPRFactory zeroFactory;
     SkCodec::Options options;
     if (kCodecZeroInit_Mode == fMode) {
         factory = &zeroFactory;
         options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
     }
-    if (!bitmap.tryAllocPixels(decodeInfo, factory, colorTable.get())) {
+
+    SkImageInfo bitmapInfo = decodeInfo;
+    if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
+            kBGRA_8888_SkColorType == decodeInfo.colorType()) {
+        bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
+    }
+    if (!bitmap.tryAllocPixels(bitmapInfo, factory, colorTable.get())) {
         return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     switch (fMode) {
         case kCodecZeroInit_Mode:
         case kCodec_Mode: {
             switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), &options,
                     colorPtr, colorCountPtr)) {
                 case SkCodec::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
                 case SkCodec::kIncompleteInput:
                     break;
                 default:
                     // Everything else is considered a failure.
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             premultiply_if_necessary(bitmap);
+            swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kScanline_Mode: {
             if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, NULL, colorPtr,
                                                                 colorCountPtr)) {
                 return "Could not start scanline decoder";
             }
 
             void* dst = bitmap.getAddr(0, 0);
@@ skipping 14 matching lines @@
                         // We complete the loop, even if this call begins to fail
                         // due to an incomplete image.  This ensures any uninitialized
                         // memory will be filled with the proper value.
                         codec->getScanlines(dstPtr, 1, bitmap.rowBytes());
                     }
                     break;
                 }
             }
 
             premultiply_if_necessary(bitmap);
+            swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kStripe_Mode: {
             const 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;
 
@@ skipping 35 matching lines @@
                 const int linesToRead = SkTMin(stripeHeight, height - startY);
                 codec->getScanlines(bitmap.getAddr(0, startY), linesToRead, bitmap.rowBytes());
 
                 // Skip a stripe
                 const int linesToSkip = SkTMin(stripeHeight, height - (i + 1) * stripeHeight);
                 if (linesToSkip > 0) {
                     codec->skipScanlines(linesToSkip);
                 }
             }
             premultiply_if_necessary(bitmap);
+            swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kCroppedScanline_Mode: {
             const int width = decodeInfo.width();
             const int height = decodeInfo.height();
             // This value is chosen because, as we move across the image, it will sometimes
             // align with the jpeg block sizes and it will sometimes not.  This allows us
             // to test interestingly different code paths in the implementation.
             const int tileSize = 36;
 
             SkCodec::Options opts;
             SkIRect subset;
             for (int x = 0; x < width; x += tileSize) {
                 subset = SkIRect::MakeXYWH(x, 0, SkTMin(tileSize, width - x), height);
                 opts.fSubset = &subset;
                 if (SkCodec::kSuccess != codec->startScanlineDecode(decodeInfo, &opts,
                         colorPtr, colorCountPtr)) {
                     return "Could not start scanline decoder.";
                 }
 
                 codec->getScanlines(bitmap.getAddr(x, 0), height, bitmap.rowBytes());
             }
 
             premultiply_if_necessary(bitmap);
+            swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             break;
         }
         case kSubset_Mode: {
             // Arbitrarily choose a divisor.
             int divisor = 2;
             // Total width/height of the image.
             const int W = codec->getInfo().width();
             const int H = codec->getInfo().height();
             if (divisor > W || divisor > H) {
@@ skipping 39 matching lines @@
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         default:
                             return SkStringPrintf("subset codec failed to decode (%d, %d, %d, %d) "
                                                   "from %s with dimensions (%d x %d)\t error %d",
                                                   x, y, decodeInfo.width(), decodeInfo.height(),
                                                   fPath.c_str(), W, H, result);
                     }
                     premultiply_if_necessary(subsetBm);
+                    swap_rb_if_necessary(bitmap, fDstColorType);
                     canvas->drawBitmap(subsetBm, SkIntToScalar(left), SkIntToScalar(top));
                     // translate by the scaled height.
                     top += decodeInfo.height();
                 }
                 // translate by the scaled width.
                 left += decodeInfo.width();
             }
             return "";
         }
         default:
@@ skipping 68 matching lines @@
     int* colorCountPtr = nullptr;
     int maxColors = 256;
     if (kIndex_8_SkColorType == decodeInfo.colorType()) {
         SkPMColor colors[256];
         colorTable.reset(new SkColorTable(colors, maxColors));
         colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
         colorCountPtr = &maxColors;
     }
 
     SkBitmap bitmap;
-    if (!bitmap.tryAllocPixels(decodeInfo, nullptr, colorTable.get())) {
+    SkImageInfo bitmapInfo = decodeInfo;
+    if (kRGBA_8888_SkColorType == decodeInfo.colorType() ||
+            kBGRA_8888_SkColorType == decodeInfo.colorType()) {
+        bitmapInfo = bitmapInfo.makeColorType(kN32_SkColorType);
+    }
+    if (!bitmap.tryAllocPixels(bitmapInfo, nullptr, colorTable.get())) {
         return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     // Create options for the codec.
     SkAndroidCodec::AndroidOptions options;
     options.fColorPtr = colorPtr;
     options.fColorCount = colorCountPtr;
     options.fSampleSize = fSampleSize;
 
     switch (fMode) {
         case kFullImage_Mode: {
             switch (codec->getAndroidPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(),
                     &options)) {
                 case SkCodec::kSuccess:
                 case SkCodec::kIncompleteInput:
                     break;
                 default:
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             premultiply_if_necessary(bitmap);
+            swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmap(bitmap, 0, 0);
             return "";
         }
         case kDivisor_Mode: {
             const int width = codec->getInfo().width();
             const int height = codec->getInfo().height();
             const int divisor = 2;
             if (width < divisor || height < divisor) {
                 return Error::Nonfatal("Divisor is larger than image dimension.");
             }
@@ skipping 38 matching lines @@
                             break;
                         default:
                             return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
                     }
                 }
             }
 
             SkRect rect = SkRect::MakeXYWH(0, 0, (SkScalar) finalScaledWidth,
                     (SkScalar) finalScaledHeight);
             premultiply_if_necessary(bitmap);
+            swap_rb_if_necessary(bitmap, fDstColorType);
             canvas->drawBitmapRect(bitmap, rect, rect, nullptr);
             return "";
         }
         default:
             SkASSERT(false);
             return "Error: Should not be reached.";
     }
 }
 
 SkISize AndroidCodecSrc::size() const {
@@ skipping 703 matching lines @@
             skr.visit(i, drawsAsSingletonPictures);
         }
         sk_sp<SkPicture> macroPic(macroRec.finishRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return check_against_reference(bitmap, src, fSink);
     });
 }
 
 }  // namespace DM