blob: 0da70b7124ecee065ca108b04a8ec7ede52ca5ba [file] [log] [blame]
/*
* 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 "src/pdf/SkPDFBitmap.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkData.h"
#include "include/core/SkEncodedImageFormat.h"
#include "include/core/SkExecutor.h"
#include "include/core/SkImage.h"
#include "include/core/SkStream.h"
#include "include/private/SkColorData.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkImageInfoPriv.h"
#include "src/pdf/SkDeflate.h"
#include "src/pdf/SkJpegInfo.h"
#include "src/pdf/SkPDFDocumentPriv.h"
#include "src/pdf/SkPDFTypes.h"
#include "src/pdf/SkPDFUtils.h"
////////////////////////////////////////////////////////////////////////////////
// write a single byte to a stream n times.
static void fill_stream(SkWStream* out, char value, size_t n) {
char buffer[4096];
memset(buffer, value, sizeof(buffer));
for (size_t i = 0; i < n / sizeof(buffer); ++i) {
out->write(buffer, sizeof(buffer));
}
out->write(buffer, n % sizeof(buffer));
}
/* It is necessary to average the color component of transparent
pixels with their surrounding neighbors since the PDF renderer may
separately re-sample the alpha and color channels when the image is
not displayed at its native resolution. Since an alpha of zero
gives no information about the color component, the pathological
case is a white image with sharp transparency bounds - the color
channel goes to black, and the should-be-transparent pixels are
rendered as grey because of the separate soft mask and color
resizing. e.g.: gm/bitmappremul.cpp */
static SkColor get_neighbor_avg_color(const SkPixmap& bm, int xOrig, int yOrig) {
SkASSERT(kBGRA_8888_SkColorType == bm.colorType());
unsigned r = 0, g = 0, b = 0, n = 0;
// Clamp the range to the edge of the bitmap.
int ymin = std::max(0, yOrig - 1);
int ymax = std::min(yOrig + 1, bm.height() - 1);
int xmin = std::max(0, xOrig - 1);
int xmax = std::min(xOrig + 1, bm.width() - 1);
for (int y = ymin; y <= ymax; ++y) {
const SkColor* scanline = bm.addr32(0, y);
for (int x = xmin; x <= xmax; ++x) {
SkColor color = scanline[x];
if (color != SK_ColorTRANSPARENT) {
r += SkColorGetR(color);
g += SkColorGetG(color);
b += SkColorGetB(color);
n++;
}
}
}
return n > 0 ? SkColorSetRGB(SkToU8(r / n), SkToU8(g / n), SkToU8(b / n))
: SK_ColorTRANSPARENT;
}
namespace {
enum class SkPDFStreamFormat { DCT, Flate, Uncompressed };
}
template <typename T>
static void emit_image_stream(SkPDFDocument* doc,
SkPDFIndirectReference ref,
T writeStream,
SkISize size,
const char* colorSpace,
SkPDFIndirectReference sMask,
int length,
SkPDFStreamFormat format) {
SkPDFDict pdfDict("XObject");
pdfDict.insertName("Subtype", "Image");
pdfDict.insertInt("Width", size.width());
pdfDict.insertInt("Height", size.height());
pdfDict.insertName("ColorSpace", colorSpace);
if (sMask) {
pdfDict.insertRef("SMask", sMask);
}
pdfDict.insertInt("BitsPerComponent", 8);
#ifdef SK_PDF_BASE85_BINARY
auto filters = SkPDFMakeArray();
filters->appendName("ASCII85Decode");
switch (format) {
case SkPDFStreamFormat::DCT: filters->appendName("DCTDecode"); break;
case SkPDFStreamFormat::Flate: filters->appendName("FlateDecode"); break;
case SkPDFStreamFormat::Uncompressed: break;
}
pdfDict.insertObject("Filter", std::move(filters));
#else
switch (format) {
case SkPDFStreamFormat::DCT: pdfDict.insertName("Filter", "DCTDecode"); break;
case SkPDFStreamFormat::Flate: pdfDict.insertName("Filter", "FlateDecode"); break;
case SkPDFStreamFormat::Uncompressed: break;
}
#endif
if (format == SkPDFStreamFormat::DCT) {
pdfDict.insertInt("ColorTransform", 0);
}
pdfDict.insertInt("Length", length);
doc->emitStream(pdfDict, std::move(writeStream), ref);
}
static void do_deflated_alpha(const SkPixmap& pm, SkPDFDocument* doc, SkPDFIndirectReference ref) {
SkPDF::Metadata::CompressionLevel compressionLevel = doc->metadata().fCompressionLevel;
SkPDFStreamFormat format = compressionLevel == SkPDF::Metadata::CompressionLevel::None
? SkPDFStreamFormat::Uncompressed
: SkPDFStreamFormat::Flate;
SkDynamicMemoryWStream buffer;
SkWStream* stream = &buffer;
std::optional<SkDeflateWStream> deflateWStream;
if (format == SkPDFStreamFormat::Flate) {
deflateWStream.emplace(&buffer, SkToInt(compressionLevel));
stream = &*deflateWStream;
}
if (kAlpha_8_SkColorType == pm.colorType()) {
SkASSERT(pm.rowBytes() == (size_t)pm.width());
stream->write(pm.addr8(), pm.width() * pm.height());
} else {
SkASSERT(pm.alphaType() == kUnpremul_SkAlphaType);
SkASSERT(pm.colorType() == kBGRA_8888_SkColorType);
SkASSERT(pm.rowBytes() == (size_t)pm.width() * 4);
const uint32_t* ptr = pm.addr32();
const uint32_t* stop = ptr + pm.height() * pm.width();
uint8_t byteBuffer[4092];
uint8_t* bufferStop = byteBuffer + std::size(byteBuffer);
uint8_t* dst = byteBuffer;
while (ptr != stop) {
*dst++ = 0xFF & ((*ptr++) >> SK_BGRA_A32_SHIFT);
if (dst == bufferStop) {
stream->write(byteBuffer, sizeof(byteBuffer));
dst = byteBuffer;
}
}
stream->write(byteBuffer, dst - byteBuffer);
}
if (deflateWStream) {
deflateWStream->finalize();
}
#ifdef SK_PDF_BASE85_BINARY
SkPDFUtils::Base85Encode(buffer.detachAsStream(), &buffer);
#endif
int length = SkToInt(buffer.bytesWritten());
emit_image_stream(doc, ref, [&buffer](SkWStream* stream) { buffer.writeToAndReset(stream); },
pm.info().dimensions(), "DeviceGray", SkPDFIndirectReference(),
length, format);
}
static void do_deflated_image(const SkPixmap& pm,
SkPDFDocument* doc,
bool isOpaque,
SkPDFIndirectReference ref) {
SkPDFIndirectReference sMask;
if (!isOpaque) {
sMask = doc->reserveRef();
}
SkPDF::Metadata::CompressionLevel compressionLevel = doc->metadata().fCompressionLevel;
SkPDFStreamFormat format = compressionLevel == SkPDF::Metadata::CompressionLevel::None
? SkPDFStreamFormat::Uncompressed
: SkPDFStreamFormat::Flate;
SkDynamicMemoryWStream buffer;
SkWStream* stream = &buffer;
std::optional<SkDeflateWStream> deflateWStream;
if (format == SkPDFStreamFormat::Flate) {
deflateWStream.emplace(&buffer, SkToInt(compressionLevel));
stream = &*deflateWStream;
}
const char* colorSpace = "DeviceGray";
switch (pm.colorType()) {
case kAlpha_8_SkColorType:
fill_stream(stream, '\x00', pm.width() * pm.height());
break;
case kGray_8_SkColorType:
SkASSERT(sMask.fValue = -1);
SkASSERT(pm.rowBytes() == (size_t)pm.width());
stream->write(pm.addr8(), pm.width() * pm.height());
break;
default:
colorSpace = "DeviceRGB";
SkASSERT(pm.alphaType() == kUnpremul_SkAlphaType);
SkASSERT(pm.colorType() == kBGRA_8888_SkColorType);
SkASSERT(pm.rowBytes() == (size_t)pm.width() * 4);
uint8_t byteBuffer[3072];
static_assert(std::size(byteBuffer) % 3 == 0, "");
uint8_t* bufferStop = byteBuffer + std::size(byteBuffer);
uint8_t* dst = byteBuffer;
for (int y = 0; y < pm.height(); ++y) {
const SkColor* src = pm.addr32(0, y);
for (int x = 0; x < pm.width(); ++x) {
SkColor color = *src++;
if (SkColorGetA(color) == SK_AlphaTRANSPARENT) {
color = get_neighbor_avg_color(pm, x, y);
}
*dst++ = SkColorGetR(color);
*dst++ = SkColorGetG(color);
*dst++ = SkColorGetB(color);
if (dst == bufferStop) {
stream->write(byteBuffer, sizeof(byteBuffer));
dst = byteBuffer;
}
}
}
stream->write(byteBuffer, dst - byteBuffer);
}
if (deflateWStream) {
deflateWStream->finalize();
}
#ifdef SK_PDF_BASE85_BINARY
SkPDFUtils::Base85Encode(buffer.detachAsStream(), &buffer);
#endif
int length = SkToInt(buffer.bytesWritten());
emit_image_stream(doc, ref, [&buffer](SkWStream* stream) { buffer.writeToAndReset(stream); },
pm.info().dimensions(), colorSpace, sMask, length, format);
if (!isOpaque) {
do_deflated_alpha(pm, doc, sMask);
}
}
static bool do_jpeg(sk_sp<SkData> data, SkPDFDocument* doc, SkISize size,
SkPDFIndirectReference ref) {
SkISize jpegSize;
SkEncodedInfo::Color jpegColorType;
SkEncodedOrigin exifOrientation;
if (!SkGetJpegInfo(data->data(), data->size(), &jpegSize,
&jpegColorType, &exifOrientation)) {
return false;
}
bool yuv = jpegColorType == SkEncodedInfo::kYUV_Color;
bool goodColorType = yuv || jpegColorType == SkEncodedInfo::kGray_Color;
if (jpegSize != size // Safety check.
|| !goodColorType
|| kTopLeft_SkEncodedOrigin != exifOrientation) {
return false;
}
#ifdef SK_PDF_BASE85_BINARY
SkDynamicMemoryWStream buffer;
SkPDFUtils::Base85Encode(SkMemoryStream::MakeDirect(data->data(), data->size()), &buffer);
data = buffer.detachAsData();
#endif
emit_image_stream(doc, ref,
[&data](SkWStream* dst) { dst->write(data->data(), data->size()); },
jpegSize, yuv ? "DeviceRGB" : "DeviceGray",
SkPDFIndirectReference(), SkToInt(data->size()), SkPDFStreamFormat::DCT);
return true;
}
static SkBitmap to_pixels(const SkImage* image) {
SkBitmap bm;
int w = image->width(),
h = image->height();
switch (image->colorType()) {
case kAlpha_8_SkColorType:
bm.allocPixels(SkImageInfo::MakeA8(w, h));
break;
case kGray_8_SkColorType:
bm.allocPixels(SkImageInfo::Make(w, h, kGray_8_SkColorType, kOpaque_SkAlphaType));
break;
default: {
// TODO: makeColorSpace(sRGB) or actually tag the images
SkAlphaType at = bm.isOpaque() ? kOpaque_SkAlphaType : kUnpremul_SkAlphaType;
bm.allocPixels(SkImageInfo::Make(w, h, kBGRA_8888_SkColorType, at));
}
}
// TODO: support GPU images in PDFs
if (!image->readPixels(nullptr, bm.pixmap(), 0, 0)) {
bm.eraseColor(SkColorSetARGB(0xFF, 0, 0, 0));
}
return bm;
}
void serialize_image(const SkImage* img,
int encodingQuality,
SkPDFDocument* doc,
SkPDFIndirectReference ref) {
SkASSERT(img);
SkASSERT(doc);
SkASSERT(encodingQuality >= 0);
SkISize dimensions = img->dimensions();
if (sk_sp<SkData> data = img->refEncodedData()) {
if (do_jpeg(std::move(data), doc, dimensions, ref)) {
return;
}
}
SkBitmap bm = to_pixels(img);
const SkPixmap& pm = bm.pixmap();
bool isOpaque = pm.isOpaque() || pm.computeIsOpaque();
if (encodingQuality <= 100 && isOpaque) {
if (sk_sp<SkData> data = img->encodeToData(SkEncodedImageFormat::kJPEG, encodingQuality)) {
if (do_jpeg(std::move(data), doc, dimensions, ref)) {
return;
}
}
}
do_deflated_image(pm, doc, isOpaque, ref);
}
SkPDFIndirectReference SkPDFSerializeImage(const SkImage* img,
SkPDFDocument* doc,
int encodingQuality) {
SkASSERT(img);
SkASSERT(doc);
SkPDFIndirectReference ref = doc->reserveRef();
if (SkExecutor* executor = doc->executor()) {
SkRef(img);
doc->incrementJobCount();
executor->add([img, encodingQuality, doc, ref]() {
serialize_image(img, encodingQuality, doc, ref);
SkSafeUnref(img);
doc->signalJobComplete();
});
return ref;
}
serialize_image(img, encodingQuality, doc, ref);
return ref;
}