Add an SkImageGeneratorCG
This will serve as a replacement for SkImageDecoder_CG.
BUG=skia:4914
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1718273004
Review URL: https://codereview.chromium.org/1718273004
diff --git a/dm/DM.cpp b/dm/DM.cpp
index 1e3e5d0..d1768aa 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -343,9 +343,6 @@
case CodecSrc::kSubset_Mode:
folder.append("codec_subset");
break;
- case CodecSrc::kGen_Mode:
- folder.append("gen");
- break;
}
switch (dstColorType) {
@@ -426,6 +423,40 @@
push_src("image", folder, src);
}
+static void push_image_gen_src(Path path, ImageGenSrc::Mode mode, SkAlphaType alphaType, bool isGpu)
+{
+ SkString folder;
+ switch (mode) {
+ case ImageGenSrc::kCodec_Mode:
+ folder.append("gen_codec");
+ break;
+ case ImageGenSrc::kPlatform_Mode:
+ folder.append("gen_platform");
+ break;
+ }
+
+ if (isGpu) {
+ folder.append("_gpu");
+ } else {
+ switch (alphaType) {
+ case kOpaque_SkAlphaType:
+ folder.append("_opaque");
+ break;
+ case kPremul_SkAlphaType:
+ folder.append("_premul");
+ break;
+ case kUnpremul_SkAlphaType:
+ folder.append("_unpremul");
+ break;
+ default:
+ break;
+ }
+ }
+
+ ImageGenSrc* src = new ImageGenSrc(path, mode, alphaType, isGpu);
+ push_src("image", folder, src);
+}
+
static void push_codec_srcs(Path path) {
SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
if (!encoded) {
@@ -445,7 +476,6 @@
SkTArray<CodecSrc::Mode> nativeModes;
nativeModes.push_back(CodecSrc::kCodec_Mode);
nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
- nativeModes.push_back(CodecSrc::kGen_Mode);
switch (codec->getEncodedFormat()) {
case SkEncodedFormat::kJPEG_SkEncodedFormat:
nativeModes.push_back(CodecSrc::kScanline_Mode);
@@ -487,19 +517,6 @@
}
for (CodecSrc::Mode mode : nativeModes) {
- // SkCodecImageGenerator only runs for the default colorType
- // recommended by SkCodec. There is no need to generate multiple
- // tests for different colorTypes.
- // TODO (msarett): Add scaling support to SkCodecImageGenerator.
- if (CodecSrc::kGen_Mode == mode) {
- // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
- if (kGray_8_SkColorType != codec->getInfo().colorType()) {
- push_codec_src(path, mode, CodecSrc::kGetFromCanvas_DstColorType,
- codec->getInfo().alphaType(), 1.0f);
- }
- continue;
- }
-
for (float scale : nativeScales) {
for (CodecSrc::DstColorType colorType : colorTypes) {
for (SkAlphaType alphaType : alphaModes) {
@@ -549,6 +566,39 @@
}
}
}
+
+ static const char* const rawExts[] = {
+ "arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
+ "ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
+ };
+
+ // There is not currently a reason to test RAW images on image generator.
+ // If we want to enable these tests, we will need to fix skbug.com/5079.
+ for (const char* ext : rawExts) {
+ if (path.endsWith(ext)) {
+ return;
+ }
+ }
+
+ // Push image generator GPU test.
+ // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
+ if (kGray_8_SkColorType != codec->getInfo().colorType()) {
+ push_image_gen_src(path, ImageGenSrc::kCodec_Mode, codec->getInfo().alphaType(), true);
+ }
+
+ // Push image generator CPU tests.
+ for (SkAlphaType alphaType : alphaModes) {
+ push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+ if (kWEBP_SkEncodedFormat != codec->getEncodedFormat() &&
+ kWBMP_SkEncodedFormat != codec->getEncodedFormat() &&
+ kUnpremul_SkAlphaType != alphaType)
+ {
+ push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
+ }
+#endif
+ }
}
static bool brd_color_type_supported(SkBitmapRegionDecoder::Strategy strategy,
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index 9e45ce9..84af854 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -14,6 +14,7 @@
#include "SkDocument.h"
#include "SkError.h"
#include "SkImageGenerator.h"
+#include "SkImageGeneratorCG.h"
#include "SkMallocPixelRef.h"
#include "SkMultiPictureDraw.h"
#include "SkNullCanvas.h"
@@ -263,15 +264,7 @@
{}
bool CodecSrc::veto(SinkFlags flags) const {
- // Test CodecImageGenerator on 8888, 565, and gpu
- if (kGen_Mode == fMode) {
- // For image generator, we want to test kDirect approaches for kRaster and kGPU,
- // while skipping everything else.
- return (flags.type != SinkFlags::kRaster && flags.type != SinkFlags::kGPU) ||
- flags.approach != SinkFlags::kDirect;
- }
-
- // Test all other modes to direct raster backends (8888 and 565).
+ // Test to direct raster backends (8888 and 565).
return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
}
@@ -333,42 +326,12 @@
return true;
}
-Error test_gen(SkCanvas* canvas, SkData* data) {
- SkAutoTDelete<SkImageGenerator> gen = SkCodecImageGenerator::NewFromEncodedCodec(data);
- if (!gen) {
- return "Could not create image generator.";
- }
-
- // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
- // Currently, we will avoid creating a CodecSrc for this case (see DM.cpp).
- SkASSERT(kGray_8_SkColorType != gen->getInfo().colorType());
-
- if (kOpaque_SkAlphaType != gen->getInfo().alphaType() &&
- kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
- return Error::Nonfatal("Skip testing non-opaque images to 565.");
- }
-
- SkAutoTDelete<SkImage> image(SkImage::NewFromGenerator(gen.detach(), nullptr));
- if (!image) {
- return "Could not create image from codec image generator.";
- }
-
- canvas->drawImage(image, 0, 0);
- return "";
-}
-
Error CodecSrc::draw(SkCanvas* canvas) const {
SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
if (!encoded) {
return SkStringPrintf("Couldn't read %s.", fPath.c_str());
}
- // The CodecImageGenerator test does not share much code with the other tests,
- // so we will handle it in its own function.
- if (kGen_Mode == fMode) {
- return test_gen(canvas, encoded);
- }
-
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec.get()) {
return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
@@ -802,6 +765,118 @@
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+ImageGenSrc::ImageGenSrc(Path path, Mode mode, SkAlphaType alphaType, bool isGpu)
+ : fPath(path)
+ , fMode(mode)
+ , fDstAlphaType(alphaType)
+ , fIsGpu(isGpu)
+ , fRunSerially(serial_from_path_name(path))
+{}
+
+bool ImageGenSrc::veto(SinkFlags flags) const {
+ if (fIsGpu) {
+ return flags.type != SinkFlags::kGPU || flags.approach != SinkFlags::kDirect;
+ }
+
+ return flags.type != SinkFlags::kRaster || flags.approach != SinkFlags::kDirect;
+}
+
+Error ImageGenSrc::draw(SkCanvas* canvas) const {
+ if (kRGB_565_SkColorType == canvas->imageInfo().colorType()) {
+ return Error::Nonfatal("Uninteresting to test image generator to 565.");
+ }
+
+ SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
+ if (!encoded) {
+ return SkStringPrintf("Couldn't read %s.", fPath.c_str());
+ }
+
+ SkAutoTDelete<SkImageGenerator> gen(nullptr);
+ switch (fMode) {
+ case kCodec_Mode:
+ gen.reset(SkCodecImageGenerator::NewFromEncodedCodec(encoded));
+ if (!gen) {
+ return "Could not create codec image generator.";
+ }
+ break;
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+ case kPlatform_Mode:
+ gen.reset(SkImageGeneratorCG::NewFromEncodedCG(encoded));
+ if (!gen) {
+ return "Could not create CG image generator.";
+ }
+ break;
+#endif
+ default:
+ SkASSERT(false);
+ return "Invalid image generator mode";
+ }
+
+ // Test deferred decoding path on GPU
+ if (fIsGpu) {
+ // FIXME: The gpu backend does not draw kGray sources correctly. (skbug.com/4822)
+ // We have disabled these tests in DM.cpp.
+ SkASSERT(kGray_8_SkColorType != gen->getInfo().colorType());
+
+ SkAutoTDelete<SkImage> image(SkImage::NewFromGenerator(gen.detach(), nullptr));
+ if (!image) {
+ return "Could not create image from codec image generator.";
+ }
+ canvas->drawImage(image, 0, 0);
+ return "";
+ }
+
+ // Test various color and alpha types on CPU
+ SkImageInfo decodeInfo = gen->getInfo().makeAlphaType(fDstAlphaType);
+
+ if (kGray_8_SkColorType == decodeInfo.colorType() &&
+ kOpaque_SkAlphaType != decodeInfo.alphaType()) {
+ return Error::Nonfatal("Avoid requesting non-opaque kGray8 decodes.");
+ }
+
+ SkAutoTUnref<SkColorTable> colorTable(nullptr);
+ SkPMColor* colorPtr = nullptr;
+ 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())) {
+ return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
+ decodeInfo.width(), decodeInfo.height());
+ }
+
+ if (!gen->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), colorPtr,
+ colorCountPtr))
+ {
+ return SkStringPrintf("Image generator could not getPixels() for %s\n", fPath.c_str());
+ }
+
+ premultiply_if_necessary(bitmap);
+ canvas->drawBitmap(bitmap, 0, 0);
+ return "";
+}
+
+SkISize ImageGenSrc::size() const {
+ SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
+ if (nullptr == codec) {
+ return SkISize::Make(0, 0);
+ }
+ return codec->getInfo().dimensions();
+}
+
+Name ImageGenSrc::name() const {
+ return SkOSPath::Basename(fPath.c_str());
+}
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
static const SkRect kSKPViewport = {0,0, 1000,1000};
SKPSrc::SKPSrc(Path path) : fPath(path) {}
diff --git a/dm/DMSrcSink.h b/dm/DMSrcSink.h
index 638d138..b6ee5f0 100644
--- a/dm/DMSrcSink.h
+++ b/dm/DMSrcSink.h
@@ -112,7 +112,6 @@
kStripe_Mode, // Tests the skipping of scanlines
kCroppedScanline_Mode, // Tests (jpeg) cropped scanline optimization
kSubset_Mode, // For codecs that support subsets directly.
- kGen_Mode, // Test SkCodecImageGenerator (includes YUV)
};
enum DstColorType {
kGetFromCanvas_DstColorType,
@@ -187,6 +186,27 @@
uint32_t fSampleSize;
};
+class ImageGenSrc : public Src {
+public:
+ enum Mode {
+ kCodec_Mode, // Use CodecImageGenerator
+ kPlatform_Mode, // Uses CG or WIC
+ };
+ ImageGenSrc(Path, Mode, SkAlphaType, bool);
+
+ Error draw(SkCanvas*) const override;
+ SkISize size() const override;
+ Name name() const override;
+ bool veto(SinkFlags) const override;
+ bool serial() const override { return fRunSerially; }
+private:
+ Path fPath;
+ Mode fMode;
+ SkAlphaType fDstAlphaType;
+ bool fIsGpu;
+ bool fRunSerially;
+};
+
class SKPSrc : public Src {
public:
explicit SKPSrc(Path path);
diff --git a/gyp/ports.gyp b/gyp/ports.gyp
index 2c41ecf..db72625 100644
--- a/gyp/ports.gyp
+++ b/gyp/ports.gyp
@@ -150,6 +150,8 @@
'sources': [
'../src/ports/SkFontHost_mac.cpp',
'../src/utils/mac/SkStream_mac.cpp',
+
+ '../src/ports/SkImageGeneratorCG.cpp',
],
}],
[ 'skia_os == "ios"', {
@@ -160,6 +162,8 @@
'sources': [
'../src/ports/SkFontHost_mac.cpp',
'../src/utils/mac/SkStream_mac.cpp',
+
+ '../src/ports/SkImageGeneratorCG.cpp',
],
}],
[ 'skia_os == "win"', {
diff --git a/src/ports/SkImageGeneratorCG.cpp b/src/ports/SkImageGeneratorCG.cpp
new file mode 100644
index 0000000..cf00ea7
--- /dev/null
+++ b/src/ports/SkImageGeneratorCG.cpp
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkImageGeneratorCG.h"
+#include "SkUnpremultiply.h"
+
+#ifdef SK_BUILD_FOR_MAC
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+#ifdef SK_BUILD_FOR_IOS
+#include <CoreGraphics/CoreGraphics.h>
+#include <ImageIO/ImageIO.h>
+#include <MobileCoreServices/MobileCoreServices.h>
+#endif
+
+static CGImageSourceRef data_to_CGImageSrc(SkData* data) {
+ CGDataProviderRef cgData = CGDataProviderCreateWithData(data, data->data(), data->size(),
+ nullptr);
+ if (!cgData) {
+ return nullptr;
+ }
+ CGImageSourceRef imageSrc = CGImageSourceCreateWithDataProvider(cgData, 0);
+ CGDataProviderRelease(cgData);
+ return imageSrc;
+}
+
+SkImageGenerator* SkImageGeneratorCG::NewFromEncodedCG(SkData* data) {
+ CGImageSourceRef imageSrc = data_to_CGImageSrc(data);
+ if (!imageSrc) {
+ return nullptr;
+ }
+
+ // Make sure we call CFRelease to free the imageSrc. Since CFRelease actually takes
+ // a const void*, we must cast the imageSrc to a const void*.
+ SkAutoTCallVProc<const void, CFRelease> autoImageSrc(imageSrc);
+
+ CFDictionaryRef properties = CGImageSourceCopyPropertiesAtIndex(imageSrc, 0, nullptr);
+ if (!properties) {
+ return nullptr;
+ }
+
+ CFNumberRef widthRef = (CFNumberRef) (CFDictionaryGetValue(properties,
+ kCGImagePropertyPixelWidth));
+ CFNumberRef heightRef = (CFNumberRef) (CFDictionaryGetValue(properties,
+ kCGImagePropertyPixelHeight));
+ if (nullptr == widthRef || nullptr == heightRef) {
+ return nullptr;
+ }
+ bool hasAlpha = (bool) (CFDictionaryGetValue(properties,
+ kCGImagePropertyHasAlpha));
+
+ int width, height;
+ if (!CFNumberGetValue(widthRef, kCFNumberIntType, &width) ||
+ !CFNumberGetValue(heightRef, kCFNumberIntType, &height)) {
+ return nullptr;
+ }
+
+ SkAlphaType alphaType = hasAlpha ? kPremul_SkAlphaType : kOpaque_SkAlphaType;
+ SkImageInfo info = SkImageInfo::Make(width, height, kN32_SkColorType, alphaType);
+
+ // FIXME: We have the opportunity to extract color space information here,
+ // though I think it makes sense to wait until we understand how
+ // we want to communicate it to the generator.
+
+ return new SkImageGeneratorCG(info, autoImageSrc.detach(), data);
+}
+
+SkImageGeneratorCG::SkImageGeneratorCG(const SkImageInfo& info, const void* imageSrc, SkData* data)
+ : INHERITED(info)
+ , fImageSrc(imageSrc)
+ , fData(SkRef(data))
+{}
+
+SkData* SkImageGeneratorCG::onRefEncodedData(SK_REFENCODEDDATA_CTXPARAM) {
+ return SkRef(fData.get());
+}
+
+bool SkImageGeneratorCG::onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
+ SkPMColor ctable[], int* ctableCount) {
+ if (kN32_SkColorType != info.colorType()) {
+ // FIXME: Support other colorTypes.
+ return false;
+ }
+
+ switch (info.alphaType()) {
+ case kOpaque_SkAlphaType:
+ if (kOpaque_SkAlphaType != this->getInfo().alphaType()) {
+ return false;
+ }
+ break;
+ case kPremul_SkAlphaType:
+ break;
+ default:
+ return false;
+ }
+
+ CGImageRef image = CGImageSourceCreateImageAtIndex((CGImageSourceRef) fImageSrc.get(), 0,
+ nullptr);
+ if (!image) {
+ return false;
+ }
+ SkAutoTCallVProc<CGImage, CGImageRelease> autoImage(image);
+
+ // FIXME: Using this function (as opposed to swizzling ourselves) greatly
+ // restricts the color and alpha types that we support. If we
+ // swizzle ourselves, we can add support for:
+ // kUnpremul_SkAlphaType
+ // 16-bit per component RGBA
+ // kGray_8_SkColorType
+ // kIndex_8_SkColorType
+ // Additionally, it would be interesting to compare the performance
+ // of SkSwizzler with CG's built in swizzler.
+ if (!SkCopyPixelsFromCGImage(info, rowBytes, pixels, image)) {
+ return false;
+ }
+
+ return true;
+}
diff --git a/src/ports/SkImageGeneratorCG.h b/src/ports/SkImageGeneratorCG.h
new file mode 100644
index 0000000..cdfeae0
--- /dev/null
+++ b/src/ports/SkImageGeneratorCG.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkTypes.h"
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+
+#include "SkCGUtils.h"
+#include "SkData.h"
+#include "SkImageGenerator.h"
+#include "SkTemplates.h"
+
+class SkImageGeneratorCG : public SkImageGenerator {
+public:
+ /*
+ * Refs the data if an image generator can be returned. Otherwise does
+ * not affect the data.
+ */
+ static SkImageGenerator* NewFromEncodedCG(SkData* data);
+
+protected:
+ SkData* onRefEncodedData(SK_REFENCODEDDATA_CTXPARAM) override;
+
+ bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes, SkPMColor ctable[],
+ int* ctableCount) override;
+
+private:
+ /*
+ * Takes ownership of the imageSrc
+ * Refs the data
+ */
+ SkImageGeneratorCG(const SkImageInfo& info, const void* imageSrc, SkData* data);
+
+ SkAutoTCallVProc<const void, CFRelease> fImageSrc;
+ SkAutoTUnref<SkData> fData;
+
+ typedef SkImageGenerator INHERITED;
+};
+
+#endif //defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
diff --git a/tools/dm_flags.json b/tools/dm_flags.json
index 5999c1a..4edcff3 100644
--- a/tools/dm_flags.json
+++ b/tools/dm_flags.json
@@ -38,6 +38,34 @@
"gm",
"_",
"tilemodesProcess",
+ "_",
+ "image",
+ "gen_platf",
+ "rgba32abf.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "rgb24prof.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "rgb24lprof.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "8bpp-pixeldata-cropped.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "4bpp-pixeldata-cropped.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "32bpp-pixeldata-cropped.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "24bpp-pixeldata-cropped.bmp",
"serialize-8888",
"gm",
"_",
@@ -1955,6 +1983,34 @@
"image",
"_",
"interlaced3.png",
+ "_",
+ "image",
+ "gen_platf",
+ "rgba32abf.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "rgb24prof.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "rgb24lprof.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "8bpp-pixeldata-cropped.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "4bpp-pixeldata-cropped.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "32bpp-pixeldata-cropped.bmp",
+ "_",
+ "image",
+ "gen_platf",
+ "24bpp-pixeldata-cropped.bmp",
"serialize-8888",
"gm",
"_",
diff --git a/tools/dm_flags.py b/tools/dm_flags.py
index a790184..0de32fc 100755
--- a/tools/dm_flags.py
+++ b/tools/dm_flags.py
@@ -113,6 +113,16 @@
blacklist.extend('_ image _ interlaced2.png'.split(' '))
blacklist.extend('_ image _ interlaced3.png'.split(' '))
+ # CG fails on questionable bmps
+ if 'Mac' in bot or 'iOS' in bot:
+ blacklist.extend('_ image gen_platf rgba32abf.bmp'.split(' '))
+ blacklist.extend('_ image gen_platf rgb24prof.bmp'.split(' '))
+ blacklist.extend('_ image gen_platf rgb24lprof.bmp'.split(' '))
+ blacklist.extend('_ image gen_platf 8bpp-pixeldata-cropped.bmp'.split(' '))
+ blacklist.extend('_ image gen_platf 4bpp-pixeldata-cropped.bmp'.split(' '))
+ blacklist.extend('_ image gen_platf 32bpp-pixeldata-cropped.bmp'.split(' '))
+ blacklist.extend('_ image gen_platf 24bpp-pixeldata-cropped.bmp'.split(' '))
+
# skia:4095
for test in ['not_native32_bitmap_config',
'bleed_image',