skcms_AlphaFormat srcAlpha;

switch (bitmap.alphaType()) {

case kUnknown_SkAlphaType: return;

case kOpaque_SkAlphaType:

case kUnpremul_SkAlphaType: srcAlpha = skcms_AlphaFormat_Unpremul; break;

case kPremul_SkAlphaType: srcAlpha = skcms_AlphaFormat_PremulAsEncoded; break;

}

skcms_PixelFormat srcFmt;

switch (bitmap.colorType()) {

case kUnknown_SkColorType: return;

case kAlpha_8_SkColorType: srcFmt = skcms_PixelFormat_A_8; break;

case kRGB_565_SkColorType: srcFmt = skcms_PixelFormat_BGR_565; break;

case kARGB_4444_SkColorType: srcFmt = skcms_PixelFormat_ABGR_4444; break;

case kRGBA_8888_SkColorType: srcFmt = skcms_PixelFormat_RGBA_8888; break;

case kBGRA_8888_SkColorType: srcFmt = skcms_PixelFormat_BGRA_8888; break;

case kSRGBA_8888_SkColorType: srcFmt = skcms_PixelFormat_RGBA_8888_sRGB; break;

case kRGBA_1010102_SkColorType: srcFmt = skcms_PixelFormat_RGBA_1010102; break;

case kBGRA_1010102_SkColorType: srcFmt = skcms_PixelFormat_BGRA_1010102; break;

case kGray_8_SkColorType: srcFmt = skcms_PixelFormat_G_8; break;

// skcms doesn't have R_8. Pretend it's G_8, but see below for color space trickery:

case kR8_unorm_SkColorType: srcFmt = skcms_PixelFormat_G_8; break;

case kRGBA_F16Norm_SkColorType: srcFmt = skcms_PixelFormat_RGBA_hhhh; break;

case kRGBA_F16_SkColorType: srcFmt = skcms_PixelFormat_RGBA_hhhh; break;

case kRGBA_F32_SkColorType: srcFmt = skcms_PixelFormat_RGBA_ffff; break;

case kR16G16B16A16_unorm_SkColorType: srcFmt = skcms_PixelFormat_RGBA_16161616LE; break;

case kRGB_888x_SkColorType: srcFmt = skcms_PixelFormat_RGBA_8888;

srcAlpha = skcms_AlphaFormat_Opaque; break;

case kRGB_101010x_SkColorType: srcFmt = skcms_PixelFormat_RGBA_1010102;

srcAlpha = skcms_AlphaFormat_Opaque; break;

case kBGR_101010x_SkColorType: srcFmt = skcms_PixelFormat_BGRA_1010102;

srcAlpha = skcms_AlphaFormat_Opaque; break;

case kR8G8_unorm_SkColorType: return;

case kR16G16_unorm_SkColorType: return;

case kR16G16_float_SkColorType: return;

case kA16_unorm_SkColorType: return;

case kA16_float_SkColorType: return;

}

skcms_ICCProfile srcProfile = *skcms_sRGB_profile();

if (auto cs = bitmap.colorSpace()) {

cs->toProfile(&srcProfile);

}

// NOTE: If the color type is R8, we told skcms it's actually G8 above. To get red PNGs,

// we tweak the source color space to throw away any green and blue:

if (bitmap.colorType() == kR8_unorm_SkColorType) {

srcProfile.toXYZD50.vals[0][1] = srcProfile.toXYZD50.vals[0][2] = 0;

srcProfile.toXYZD50.vals[1][1] = srcProfile.toXYZD50.vals[1][2] = 0;

srcProfile.toXYZD50.vals[2][1] = srcProfile.toXYZD50.vals[2][2] = 0;

}

// Our common format that can represent anything we draw and encode as a PNG:

// - 16-bit big-endian RGBA

// - unpremul

// - Rec. 2020 gamut and transfer function

skcms_PixelFormat dstFmt = skcms_PixelFormat_RGBA_16161616BE;

skcms_AlphaFormat dstAlpha = skcms_AlphaFormat_Unpremul;

skcms_ICCProfile dstProfile;

rec2020()->toProfile(&dstProfile);

int N = fSize.width() * fSize.height();

fPixels.reset(new uint64_t[N]);

const void* src = bitmap.getPixels();

void* dst = fPixels.get();

while (N > 0) {

int todo = std::min(N, 1<<27); // Keep todo*8 <= 1B; skcms requires N*bpp < MAX_INT.

if (!skcms_Transform(src, srcFmt, srcAlpha, &srcProfile,

dst, dstFmt, dstAlpha, &dstProfile, todo)) {

SkASSERT(false);

fPixels.reset(nullptr);

break;

}

src = (char*)src + todo*SkColorTypeBytesPerPixel(bitmap.colorType());

dst = (char*)dst + todo*sizeof(uint64_t);

N -= todo;

}

st->write(&fSize, sizeof(fSize));

if (const uint64_t* px = fPixels.get()) {

st->write(px, sizeof(*px) * fSize.width() * fSize.height());

}

// N.B. changing salt will change the hash of all images produced by DM,

// and will cause tens of thousands of new images to be uploaded to Gold.

int salt = 1;

st->write(&salt, sizeof(salt));

const char* md5,

CommandLineFlags::StringArray key,

CommandLineFlags::StringArray properties) const {

if (!fPixels) {

return false;

}

png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);

if (!png) {

return false;

}

png_infop info = png_create_info_struct(png);

if (!info) {

png_destroy_write_struct(&png, &info);

return false;

}

auto write_to_stream = +[](png_structp png, png_bytep ptr, png_size_t len) {

auto st = (SkWStream*)png_get_io_ptr(png);

if (!st->write(ptr, len)) {

png_error(png, "HashAndEncode::encodePNG() failed writing stream");

}

};

png_set_write_fn(png, st, write_to_stream, nullptr);

SkString description;

description.append("Key: ");

for (int i = 0; i < key.size(); i++) {

description.appendf("%s ", key[i]);

}

description.append("Properties: ");

for (int i = 0; i < properties.size(); i++) {

description.appendf("%s ", properties[i]);

}

description.appendf("MD5: %s", md5);

png_text text[2];

text[0].key = (png_charp)"Author";

text[0].text = (png_charp)"DM unified Rec.2020";

text[0].compression = PNG_TEXT_COMPRESSION_NONE;

text[1].key = (png_charp)"Description";

text[1].text = (png_charp)description.c_str();

text[1].compression = PNG_TEXT_COMPRESSION_NONE;

png_set_text(png, info, text, std::size(text));

png_set_IHDR(png, info, (png_uint_32)fSize.width()

, (png_uint_32)fSize.height()

, 16/*bits per channel*/

, PNG_COLOR_TYPE_RGB_ALPHA

, PNG_INTERLACE_NONE

, PNG_COMPRESSION_TYPE_DEFAULT

, PNG_FILTER_TYPE_DEFAULT);

// Fastest encoding and decoding, at slight file size cost is no filtering, compression 1.

png_set_filter(png, PNG_FILTER_TYPE_BASE, PNG_FILTER_NONE);

png_set_compression_level(png, 1);

static const sk_sp<SkData> profile =

SkWriteICCProfile(SkNamedTransferFn::kRec2020, SkNamedGamut::kRec2020);

png_set_iCCP(png, info,

"Rec.2020",

0/*compression type... no idea what options are available here*/,

(png_const_bytep)profile->data(),

(png_uint_32) profile->size());

png_write_info(png, info);

for (int y = 0; y < fSize.height(); y++) {

png_write_row(png, (png_bytep)(fPixels.get() + y*fSize.width()));

}

png_write_end(png, info);

png_destroy_write_struct(&png, &info);

return true;