void onPreDraw(SkCanvas*) override {
#ifdef SK_DEBUG
bool result =
#endif
GetResourceAsBitmap(fFilename, &fBitmap);
SkASSERT(result);
}
DEF_TEST(document_dct_encoder, r) {
REQUIRE_PDF_DOCUMENT(document_dct_encoder, r);
SkBitmap bm;
if (GetResourceAsBitmap("mandrill_64.png", &bm)) {
// Lossy encoding works better on photographs.
REPORTER_ASSERT(r, count_bytes(bm, true) < count_bytes(bm, false));
}
}
static void draw_bitmap(SkCanvas* canvas, const char* resource, int x, int y) {
SkBitmap bitmap;
if (GetResourceAsBitmap(resource, &bitmap)) {
canvas->drawBitmap(bitmap, SkIntToScalar(x), SkIntToScalar(y));
} else {
SkDebugf("\nCould not decode file '%s'. Did you forget"
" to set the resourcePath?\n", resource);
}
}
LightingView() : fLightAngle(0.0f) , fColorFactor(0.0f) {
{
SkBitmap diffuseBitmap;
SkAssertResult(GetResourceAsBitmap("images/brickwork-texture.jpg", &diffuseBitmap));
fRect = SkRect::MakeIWH(diffuseBitmap.width(), diffuseBitmap.height());
fDiffuseShader = diffuseBitmap.makeShader();
}
{
SkBitmap normalBitmap;
SkAssertResult(GetResourceAsBitmap("images/brickwork_normal-map.jpg", &normalBitmap));
sk_sp<SkShader> normalMap = normalBitmap.makeShader();
fNormalSource = SkNormalSource::MakeFromNormalMap(std::move(normalMap), SkMatrix::I());
}
}
DEF_TEST(Encode_WebpOptions, r) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/google_chrome.ico", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
SkWebpEncoder::Options options;
options.fCompression = SkWebpEncoder::Compression::kLossless;
options.fQuality = 0.0f;
success = SkWebpEncoder::Encode(&dst0, src, options);
REPORTER_ASSERT(r, success);
options.fQuality = 100.0f;
success = SkWebpEncoder::Encode(&dst1, src, options);
REPORTER_ASSERT(r, success);
options.fCompression = SkWebpEncoder::Compression::kLossy;
options.fQuality = 100.0f;
success = SkWebpEncoder::Encode(&dst2, src, options);
REPORTER_ASSERT(r, success);
options.fCompression = SkWebpEncoder::Compression::kLossy;
options.fQuality = 50.0f;
success = SkWebpEncoder::Encode(&dst3, src, options);
REPORTER_ASSERT(r, success);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
sk_sp<SkData> data3 = dst3.detachAsData();
REPORTER_ASSERT(r, data0->size() > data1->size());
REPORTER_ASSERT(r, data1->size() > data2->size());
REPORTER_ASSERT(r, data2->size() > data3->size());
SkBitmap bm0, bm1, bm2, bm3;
SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
SkImage::MakeFromEncoded(data3)->asLegacyBitmap(&bm3);
REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
REPORTER_ASSERT(r, almost_equals(bm0, bm2, 90));
REPORTER_ASSERT(r, almost_equals(bm2, bm3, 50));
}
virtual void onDraw(SkCanvas* canvas) {
SkBitmap bm, bm4444;
if (!GetResourceAsBitmap("dog.jpg", &bm)) {
SkDebugf("Could not decode the file. Did you forget to set the "
"resourcePath?\n");
return;
}
canvas->drawBitmap(bm, 0, 0);
// This should dither or we will see artifacts in the background of the image.
SkAssertResult(sk_tool_utils::copy_to(&bm4444, kARGB_4444_SkColorType, bm));
canvas->drawBitmap(bm4444, SkIntToScalar(bm.width()), 0);
}
void makeBitmap() override {
if (!GetResourceAsBitmap(fFilename.c_str(), &fBM)) {
fBM.allocN32Pixels(1, 1);
fBM.eraseARGB(255, 255, 0 , 0); // red == bad
}
fSize = fBM.height();
if (fConvertToG8) {
SkBitmap tmp;
fBM.copyTo(&tmp, kGray_8_SkColorType);
fBM = tmp;
}
}
static void test_encode(skiatest::Reporter* r, SkEncodedImageFormat format) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2, dst3;
success = encode(format, &dst0, src);
REPORTER_ASSERT(r, success);
auto encoder1 = make(format, &dst1, src);
for (int i = 0; i < src.height(); i++) {
success = encoder1->encodeRows(1);
REPORTER_ASSERT(r, success);
}
auto encoder2 = make(format, &dst2, src);
for (int i = 0; i < src.height(); i+=3) {
success = encoder2->encodeRows(3);
REPORTER_ASSERT(r, success);
}
auto encoder3 = make(format, &dst3, src);
success = encoder3->encodeRows(200);
REPORTER_ASSERT(r, success);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
sk_sp<SkData> data3 = dst3.detachAsData();
REPORTER_ASSERT(r, data0->equals(data1.get()));
REPORTER_ASSERT(r, data0->equals(data2.get()));
REPORTER_ASSERT(r, data0->equals(data3.get()));
}
DEF_TEST(Encode_PngOptions, r) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2;
SkPngEncoder::Options options;
success = SkPngEncoder::Encode(&dst0, src, options);
REPORTER_ASSERT(r, success);
options.fFilterFlags = SkPngEncoder::FilterFlag::kUp;
success = SkPngEncoder::Encode(&dst1, src, options);
REPORTER_ASSERT(r, success);
options.fZLibLevel = 3;
success = SkPngEncoder::Encode(&dst2, src, options);
REPORTER_ASSERT(r, success);
testPngComments(src, options, r);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
REPORTER_ASSERT(r, data0->size() < data1->size());
REPORTER_ASSERT(r, data1->size() < data2->size());
SkBitmap bm0, bm1, bm2;
SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
REPORTER_ASSERT(r, almost_equals(bm0, bm1, 0));
REPORTER_ASSERT(r, almost_equals(bm0, bm2, 0));
}
DEF_TEST(Encode_JpegDownsample, r) {
SkBitmap bitmap;
bool success = GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
if (!success) {
return;
}
SkPixmap src;
success = bitmap.peekPixels(&src);
REPORTER_ASSERT(r, success);
if (!success) {
return;
}
SkDynamicMemoryWStream dst0, dst1, dst2;
SkJpegEncoder::Options options;
success = SkJpegEncoder::Encode(&dst0, src, options);
REPORTER_ASSERT(r, success);
options.fDownsample = SkJpegEncoder::Downsample::k422;
success = SkJpegEncoder::Encode(&dst1, src, options);
REPORTER_ASSERT(r, success);
options.fDownsample = SkJpegEncoder::Downsample::k444;
success = SkJpegEncoder::Encode(&dst2, src, options);
REPORTER_ASSERT(r, success);
sk_sp<SkData> data0 = dst0.detachAsData();
sk_sp<SkData> data1 = dst1.detachAsData();
sk_sp<SkData> data2 = dst2.detachAsData();
REPORTER_ASSERT(r, data0->size() < data1->size());
REPORTER_ASSERT(r, data1->size() < data2->size());
SkBitmap bm0, bm1, bm2;
SkImage::MakeFromEncoded(data0)->asLegacyBitmap(&bm0);
SkImage::MakeFromEncoded(data1)->asLegacyBitmap(&bm1);
SkImage::MakeFromEncoded(data2)->asLegacyBitmap(&bm2);
REPORTER_ASSERT(r, almost_equals(bm0, bm1, 60));
REPORTER_ASSERT(r, almost_equals(bm1, bm2, 60));
}
int main(int argc, char** argv) {
SkCommandLineFlags::SetUsage(
"Usage: visualize_color_gamut --input <path to input image>"
"--output <path to output image>\n"
"Description: Writes a visualization of the color gamut to the output image\n");
SkCommandLineFlags::Parse(argc, argv);
const char* input = FLAGS_input[0];
const char* output = FLAGS_output[0];
if (!input || !output) {
SkCommandLineFlags::PrintUsage();
return -1;
}
SkAutoTUnref<SkData> data(SkData::NewFromFileName(input));
if (!data) {
SkDebugf("Cannot find input image.\n");
return -1;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
if (!codec) {
SkDebugf("Invalid input image.\n");
return -1;
}
// Load a graph of the CIE XYZ color gamut.
SkBitmap bitmap;
if (!GetResourceAsBitmap("gamut.png", &bitmap)) {
SkDebugf("Program failure.\n");
return -1;
}
SkCanvas canvas(bitmap);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp(codec->getColorSpace());
if (!colorSpace) {
SkDebugf("Image had no embedded color space information. Defaulting to sRGB.\n");
colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
}
// Calculate the points in the gamut from the XYZ values.
SkMatrix44 xyz = colorSpace->xyz();
SkPoint rgb[4];
load_gamut(rgb, xyz);
// Report the XYZ values.
SkDebugf(" X Y Z\n");
SkDebugf("Red %.2f %.2f %.2f\n", xyz.get(0, 0), xyz.get(0, 1), xyz.get(0, 2));
SkDebugf("Green %.2f %.2f %.2f\n", xyz.get(1, 0), xyz.get(1, 1), xyz.get(1, 2));
SkDebugf("Blue %.2f %.2f %.2f\n", xyz.get(2, 0), xyz.get(2, 1), xyz.get(2, 2));
// Report the area of the gamut.
SkDebugf("Area of Gamut: %g\n", calculate_area(rgb));
// Now transform the points so they can be drawn on our canvas. We use 1000 pixels
// to represent the space from 0 to 1. Note that the graph is at an offset of (50, 50).
// Also note that y increases as we move down the canvas.
rgb[0].fX = 50 + 1000*rgb[0].fX;
rgb[0].fY = 50 + 1000*(1 - rgb[0].fY);
rgb[1].fX = 50 + 1000*rgb[1].fX;
rgb[1].fY = 50 + 1000*(1 - rgb[1].fY);
rgb[2].fX = 50 + 1000*rgb[2].fX;
rgb[2].fY = 50 + 1000*(1 - rgb[2].fY);
// Repeat the first point to connect the polygon.
rgb[3] = rgb[0];
SkPaint paint;
canvas.drawPoints(SkCanvas::kPolygon_PointMode, 4, rgb, paint);
// Finally, encode the result to out.png.
SkAutoTUnref<SkData> out(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
if (!out) {
SkDebugf("Failed to encode output.\n");
return -1;
}
SkFILEWStream stream(output);
bool result = stream.write(out->data(), out->size());
if (!result) {
SkDebugf("Failed to write output.\n");
return -1;
}
return 0;
}
int main(int argc, char** argv) {
SkCommandLineFlags::SetUsage(
"Usage: visualize_color_gamut --input <path to input image> "
"--output <path to output image> "
"--sRGB <draw canonical sRGB gamut> "
"--adobeRGB <draw canonical Adobe RGB gamut> "
"--uncorrected <path to reencoded, uncorrected "
" input image>\n"
"Description: Writes a visualization of the color gamut to the output image ."
"Also, if a path is provided, writes uncorrected bytes to an unmarked "
"png, for comparison with the input image.\n");
SkCommandLineFlags::Parse(argc, argv);
const char* input = FLAGS_input[0];
const char* output = FLAGS_output[0];
if (!input || !output) {
SkCommandLineFlags::PrintUsage();
return -1;
}
SkAutoTUnref<SkData> data(SkData::NewFromFileName(input));
if (!data) {
SkDebugf("Cannot find input image.\n");
return -1;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
if (!codec) {
SkDebugf("Invalid input image.\n");
return -1;
}
// Load a graph of the CIE XYZ color gamut.
SkBitmap gamut;
if (!GetResourceAsBitmap("gamut.png", &gamut)) {
SkDebugf("Program failure.\n");
return -1;
}
SkCanvas canvas(gamut);
// Draw the sRGB gamut if requested.
if (FLAGS_sRGB) {
sk_sp<SkColorSpace> sRGBSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
draw_gamut(&canvas, sRGBSpace->xyz(), "sRGB", 0xFFFF9394, false);
}
// Draw the Adobe RGB gamut if requested.
if (FLAGS_adobeRGB) {
sk_sp<SkColorSpace> adobeRGBSpace = SkColorSpace::NewNamed(SkColorSpace::kAdobeRGB_Named);
draw_gamut(&canvas, adobeRGBSpace->xyz(), "Adobe RGB", 0xFF31a9e1, false);
}
// Draw gamut for the input image.
sk_sp<SkColorSpace> colorSpace = sk_ref_sp(codec->getInfo().colorSpace());
if (!colorSpace) {
SkDebugf("Image had no embedded color space information. Defaulting to sRGB.\n");
colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
}
draw_gamut(&canvas, colorSpace->xyz(), input, 0xFF000000, true);
// Finally, encode the result to the output file.
SkAutoTUnref<SkData> out(SkImageEncoder::EncodeData(gamut, SkImageEncoder::kPNG_Type, 100));
if (!out) {
SkDebugf("Failed to encode gamut output.\n");
return -1;
}
SkFILEWStream stream(output);
bool result = stream.write(out->data(), out->size());
if (!result) {
SkDebugf("Failed to write gamut output.\n");
return -1;
}
// Also, if requested, decode and reencode the uncorrected input image.
if (!FLAGS_uncorrected.isEmpty()) {
SkBitmap bitmap;
int width = codec->getInfo().width();
int height = codec->getInfo().height();
SkAlphaType alphaType = codec->getInfo().alphaType();
bitmap.allocN32Pixels(width, height, kOpaque_SkAlphaType == alphaType);
SkImageInfo decodeInfo = SkImageInfo::MakeN32(width, height, alphaType);
if (SkCodec::kSuccess != codec->getPixels(decodeInfo, bitmap.getPixels(),
bitmap.rowBytes())) {
SkDebugf("Could not decode input image.\n");
return -1;
}
out.reset(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
if (!out) {
SkDebugf("Failed to encode uncorrected image.\n");
return -1;
}
SkFILEWStream bitmapStream(FLAGS_uncorrected[0]);
result = bitmapStream.write(out->data(), out->size());
if (!result) {
SkDebugf("Failed to write uncorrected image output.\n");
return -1;
}
}
return 0;
}
void onPreDraw(SkCanvas*) override {
SkAssertResult(GetResourceAsBitmap(fSourceFilename, &fBitmap));
}
