blob: 7448d86d83187de979c8442ca24f0bd827c0eef3 [file] [log] [blame]
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkPDFShader.h"
#include "SkData.h"
#include "SkPDFCanon.h"
#include "SkPDFDevice.h"
#include "SkPDFDocumentPriv.h"
#include "SkPDFFormXObject.h"
#include "SkPDFGradientShader.h"
#include "SkPDFGraphicState.h"
#include "SkPDFResourceDict.h"
#include "SkPDFUtils.h"
#include "SkScalar.h"
#include "SkStream.h"
#include "SkSurface.h"
#include "SkTemplates.h"
static void draw_image_matrix(SkCanvas* canvas, const SkImage* img,
const SkMatrix& matrix, const SkPaint& paint) {
SkAutoCanvasRestore acr(canvas, true);
canvas->concat(matrix);
canvas->drawImage(img, 0, 0, &paint);
}
static void draw_bitmap_matrix(SkCanvas* canvas, const SkBitmap& bm,
const SkMatrix& matrix, const SkPaint& paint) {
SkAutoCanvasRestore acr(canvas, true);
canvas->concat(matrix);
canvas->drawBitmap(bm, 0, 0, &paint);
}
static sk_sp<SkPDFStream> make_image_shader(SkPDFDocument* doc,
const SkPDFImageShaderKey& key,
SkImage* image) {
SkASSERT(image);
// The image shader pattern cell will be drawn into a separate device
// in pattern cell space (no scaling on the bitmap, though there may be
// translations so that all content is in the device, coordinates > 0).
// Map clip bounds to shader space to ensure the device is large enough
// to handle fake clamping.
SkMatrix finalMatrix = key.fCanvasTransform;
finalMatrix.preConcat(key.fShaderTransform);
SkRect deviceBounds = SkRect::Make(key.fBBox);
if (!SkPDFUtils::InverseTransformBBox(finalMatrix, &deviceBounds)) {
return nullptr;
}
SkRect bitmapBounds = SkRect::Make(image->bounds());
// For tiling modes, the bounds should be extended to include the bitmap,
// otherwise the bitmap gets clipped out and the shader is empty and awful.
// For clamp modes, we're only interested in the clip region, whether
// or not the main bitmap is in it.
SkShader::TileMode tileModes[2];
tileModes[0] = key.fImageTileModes[0];
tileModes[1] = key.fImageTileModes[1];
if (tileModes[0] != SkShader::kClamp_TileMode ||
tileModes[1] != SkShader::kClamp_TileMode) {
deviceBounds.join(bitmapBounds);
}
SkISize patternDeviceSize = {SkScalarCeilToInt(deviceBounds.width()),
SkScalarCeilToInt(deviceBounds.height())};
auto patternDevice = sk_make_sp<SkPDFDevice>(patternDeviceSize, doc);
SkCanvas canvas(patternDevice);
SkRect patternBBox = SkRect::Make(image->bounds());
// Translate the canvas so that the bitmap origin is at (0, 0).
canvas.translate(-deviceBounds.left(), -deviceBounds.top());
patternBBox.offset(-deviceBounds.left(), -deviceBounds.top());
// Undo the translation in the final matrix
finalMatrix.preTranslate(deviceBounds.left(), deviceBounds.top());
// If the bitmap is out of bounds (i.e. clamp mode where we only see the
// stretched sides), canvas will clip this out and the extraneous data
// won't be saved to the PDF.
canvas.drawImage(image, 0, 0);
SkScalar width = SkIntToScalar(image->width());
SkScalar height = SkIntToScalar(image->height());
SkPaint paint;
paint.setColor(key.fPaintColor);
// Tiling is implied. First we handle mirroring.
if (tileModes[0] == SkShader::kMirror_TileMode) {
SkMatrix xMirror;
xMirror.setScale(-1, 1);
xMirror.postTranslate(2 * width, 0);
draw_image_matrix(&canvas, image, xMirror, paint);
patternBBox.fRight += width;
}
if (tileModes[1] == SkShader::kMirror_TileMode) {
SkMatrix yMirror;
yMirror.setScale(SK_Scalar1, -SK_Scalar1);
yMirror.postTranslate(0, 2 * height);
draw_image_matrix(&canvas, image, yMirror, paint);
patternBBox.fBottom += height;
}
if (tileModes[0] == SkShader::kMirror_TileMode &&
tileModes[1] == SkShader::kMirror_TileMode) {
SkMatrix mirror;
mirror.setScale(-1, -1);
mirror.postTranslate(2 * width, 2 * height);
draw_image_matrix(&canvas, image, mirror, paint);
}
// Then handle Clamping, which requires expanding the pattern canvas to
// cover the entire surfaceBBox.
SkBitmap bitmap;
if (tileModes[0] == SkShader::kClamp_TileMode ||
tileModes[1] == SkShader::kClamp_TileMode) {
// For now, the easiest way to access the colors in the corners and sides is
// to just make a bitmap from the image.
if (!SkPDFUtils::ToBitmap(image, &bitmap)) {
bitmap.allocN32Pixels(image->width(), image->height());
bitmap.eraseColor(0x00000000);
}
}
// If both x and y are in clamp mode, we start by filling in the corners.
// (Which are just a rectangles of the corner colors.)
if (tileModes[0] == SkShader::kClamp_TileMode &&
tileModes[1] == SkShader::kClamp_TileMode) {
SkASSERT(!bitmap.drawsNothing());
SkPaint paint;
SkRect rect;
rect = SkRect::MakeLTRB(deviceBounds.left(), deviceBounds.top(), 0, 0);
if (!rect.isEmpty()) {
paint.setColor(bitmap.getColor(0, 0));
canvas.drawRect(rect, paint);
}
rect = SkRect::MakeLTRB(width, deviceBounds.top(),
deviceBounds.right(), 0);
if (!rect.isEmpty()) {
paint.setColor(bitmap.getColor(bitmap.width() - 1, 0));
canvas.drawRect(rect, paint);
}
rect = SkRect::MakeLTRB(width, height,
deviceBounds.right(), deviceBounds.bottom());
if (!rect.isEmpty()) {
paint.setColor(bitmap.getColor(bitmap.width() - 1,
bitmap.height() - 1));
canvas.drawRect(rect, paint);
}
rect = SkRect::MakeLTRB(deviceBounds.left(), height,
0, deviceBounds.bottom());
if (!rect.isEmpty()) {
paint.setColor(bitmap.getColor(0, bitmap.height() - 1));
canvas.drawRect(rect, paint);
}
}
// Then expand the left, right, top, then bottom.
if (tileModes[0] == SkShader::kClamp_TileMode) {
SkASSERT(!bitmap.drawsNothing());
SkIRect subset = SkIRect::MakeXYWH(0, 0, 1, bitmap.height());
if (deviceBounds.left() < 0) {
SkBitmap left;
SkAssertResult(bitmap.extractSubset(&left, subset));
SkMatrix leftMatrix;
leftMatrix.setScale(-deviceBounds.left(), 1);
leftMatrix.postTranslate(deviceBounds.left(), 0);
draw_bitmap_matrix(&canvas, left, leftMatrix, paint);
if (tileModes[1] == SkShader::kMirror_TileMode) {
leftMatrix.postScale(SK_Scalar1, -SK_Scalar1);
leftMatrix.postTranslate(0, 2 * height);
draw_bitmap_matrix(&canvas, left, leftMatrix, paint);
}
patternBBox.fLeft = 0;
}
if (deviceBounds.right() > width) {
SkBitmap right;
subset.offset(bitmap.width() - 1, 0);
SkAssertResult(bitmap.extractSubset(&right, subset));
SkMatrix rightMatrix;
rightMatrix.setScale(deviceBounds.right() - width, 1);
rightMatrix.postTranslate(width, 0);
draw_bitmap_matrix(&canvas, right, rightMatrix, paint);
if (tileModes[1] == SkShader::kMirror_TileMode) {
rightMatrix.postScale(SK_Scalar1, -SK_Scalar1);
rightMatrix.postTranslate(0, 2 * height);
draw_bitmap_matrix(&canvas, right, rightMatrix, paint);
}
patternBBox.fRight = deviceBounds.width();
}
}
if (tileModes[1] == SkShader::kClamp_TileMode) {
SkASSERT(!bitmap.drawsNothing());
SkIRect subset = SkIRect::MakeXYWH(0, 0, bitmap.width(), 1);
if (deviceBounds.top() < 0) {
SkBitmap top;
SkAssertResult(bitmap.extractSubset(&top, subset));
SkMatrix topMatrix;
topMatrix.setScale(SK_Scalar1, -deviceBounds.top());
topMatrix.postTranslate(0, deviceBounds.top());
draw_bitmap_matrix(&canvas, top, topMatrix, paint);
if (tileModes[0] == SkShader::kMirror_TileMode) {
topMatrix.postScale(-1, 1);
topMatrix.postTranslate(2 * width, 0);
draw_bitmap_matrix(&canvas, top, topMatrix, paint);
}
patternBBox.fTop = 0;
}
if (deviceBounds.bottom() > height) {
SkBitmap bottom;
subset.offset(0, bitmap.height() - 1);
SkAssertResult(bitmap.extractSubset(&bottom, subset));
SkMatrix bottomMatrix;
bottomMatrix.setScale(SK_Scalar1, deviceBounds.bottom() - height);
bottomMatrix.postTranslate(0, height);
draw_bitmap_matrix(&canvas, bottom, bottomMatrix, paint);
if (tileModes[0] == SkShader::kMirror_TileMode) {
bottomMatrix.postScale(-1, 1);
bottomMatrix.postTranslate(2 * width, 0);
draw_bitmap_matrix(&canvas, bottom, bottomMatrix, paint);
}
patternBBox.fBottom = deviceBounds.height();
}
}
auto imageShader = sk_make_sp<SkPDFStream>(patternDevice->content());
sk_sp<SkPDFDict> resourceDict = patternDevice->makeResourceDict();
SkPDFUtils::PopulateTilingPatternDict(imageShader->dict(), patternBBox,
std::move(resourceDict), finalMatrix);
return imageShader;
}
// Generic fallback for unsupported shaders:
// * allocate a surfaceBBox-sized bitmap
// * shade the whole area
// * use the result as a bitmap shader
static sk_sp<SkPDFObject> make_fallback_shader(SkPDFDocument* doc,
SkShader* shader,
const SkMatrix& canvasTransform,
const SkIRect& surfaceBBox,
SkColor paintColor) {
// TODO(vandebo) This drops SKComposeShader on the floor. We could
// handle compose shader by pulling things up to a layer, drawing with
// the first shader, applying the xfer mode and drawing again with the
// second shader, then applying the layer to the original drawing.
SkPDFImageShaderKey key = {
canvasTransform,
SkMatrix::I(),
surfaceBBox,
{{0, 0, 0, 0}, 0}, // don't need the key; won't de-dup.
{SkShader::kClamp_TileMode, SkShader::kClamp_TileMode},
paintColor};
key.fShaderTransform = shader->getLocalMatrix();
// surfaceBBox is in device space. While that's exactly what we
// want for sizing our bitmap, we need to map it into
// shader space for adjustments (to match
// MakeImageShader's behavior).
SkRect shaderRect = SkRect::Make(surfaceBBox);
if (!SkPDFUtils::InverseTransformBBox(canvasTransform, &shaderRect)) {
return nullptr;
}
// Clamp the bitmap size to about 1M pixels
static const SkScalar kMaxBitmapArea = 1024 * 1024;
SkScalar bitmapArea = surfaceBBox.width() * surfaceBBox.height();
SkScalar rasterScale = 1.0f;
if (bitmapArea > kMaxBitmapArea) {
rasterScale *= SkScalarSqrt(kMaxBitmapArea / bitmapArea);
}
SkISize size = {SkScalarRoundToInt(rasterScale * surfaceBBox.width()),
SkScalarRoundToInt(rasterScale * surfaceBBox.height())};
SkSize scale = {SkIntToScalar(size.width()) / shaderRect.width(),
SkIntToScalar(size.height()) / shaderRect.height()};
auto surface = SkSurface::MakeRasterN32Premul(size.width(), size.height());
SkCanvas* canvas = surface->getCanvas();
canvas->clear(SK_ColorTRANSPARENT);
SkPaint p;
p.setShader(sk_ref_sp(shader));
p.setColor(paintColor);
canvas->scale(scale.width(), scale.height());
canvas->translate(-shaderRect.x(), -shaderRect.y());
canvas->drawPaint(p);
key.fShaderTransform.setTranslate(shaderRect.x(), shaderRect.y());
key.fShaderTransform.preScale(1 / scale.width(), 1 / scale.height());
sk_sp<SkImage> image = surface->makeImageSnapshot();
return make_image_shader(doc, key, image.get());
}
static SkColor adjust_color(SkShader* shader, SkColor paintColor) {
if (SkImage* img = shader->isAImage(nullptr, nullptr)) {
if (img->isAlphaOnly()) {
return paintColor;
}
}
// only preserve the alpha.
return paintColor & SK_ColorBLACK;
}
sk_sp<SkPDFObject> SkPDFMakeShader(SkPDFDocument* doc,
SkShader* shader,
const SkMatrix& canvasTransform,
const SkIRect& surfaceBBox,
SkColor paintColor) {
SkASSERT(shader);
SkASSERT(doc);
if (SkShader::kNone_GradientType != shader->asAGradient(nullptr)) {
return SkPDFGradientShader::Make(doc, shader, canvasTransform, surfaceBBox);
}
if (surfaceBBox.isEmpty()) {
return nullptr;
}
SkBitmap image;
SkPDFImageShaderKey key = {
canvasTransform,
SkMatrix::I(),
surfaceBBox,
{{0, 0, 0, 0}, 0},
{SkShader::kClamp_TileMode, SkShader::kClamp_TileMode},
adjust_color(shader, paintColor)};
SkASSERT(shader->asAGradient(nullptr) == SkShader::kNone_GradientType) ;
if (SkImage* skimg = shader->isAImage(&key.fShaderTransform, key.fImageTileModes)) {
key.fBitmapKey = SkBitmapKeyFromImage(skimg);
SkPDFCanon* canon = doc->canon();
sk_sp<SkPDFObject>* shaderPtr = canon->fImageShaderMap.find(key);
if (shaderPtr) {
return *shaderPtr;
}
sk_sp<SkPDFObject> pdfShader = make_image_shader(doc, key, skimg);
canon->fImageShaderMap.set(std::move(key), pdfShader);
return pdfShader;
}
// Don't bother to de-dup fallback shader.
return make_fallback_shader(doc, shader, canvasTransform, surfaceBBox, key.fPaintColor);
}