SkPDFDevice.cpp File Reference

#include "src/pdf/SkPDFDevice.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkClipOp.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkFont.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkM44.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathEffect.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkPathUtils.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkShader.h"
#include "include/core/SkSize.h"
#include "include/core/SkSpan.h"
#include "include/core/SkStrokeRec.h"
#include "include/core/SkSurface.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/docs/SkPDFDocument.h"
#include "include/encode/SkJpegEncoder.h"
#include "include/pathops/SkPathOps.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkScopeExit.h"
#include "src/base/SkTLazy.h"
#include "src/base/SkUTF.h"
#include "src/core/SkAdvancedTypefaceMetrics.h"
#include "src/core/SkAnnotationKeys.h"
#include "src/core/SkBitmapDevice.h"
#include "src/core/SkBlendModePriv.h"
#include "src/core/SkColorSpacePriv.h"
#include "src/core/SkDevice.h"
#include "src/core/SkDraw.h"
#include "src/core/SkGlyph.h"
#include "src/core/SkMask.h"
#include "src/core/SkMaskFilterBase.h"
#include "src/core/SkPaintPriv.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkSpecialImage.h"
#include "src/core/SkStrikeSpec.h"
#include "src/pdf/SkBitmapKey.h"
#include "src/pdf/SkClusterator.h"
#include "src/pdf/SkPDFBitmap.h"
#include "src/pdf/SkPDFDocumentPriv.h"
#include "src/pdf/SkPDFFont.h"
#include "src/pdf/SkPDFFormXObject.h"
#include "src/pdf/SkPDFGraphicState.h"
#include "src/pdf/SkPDFResourceDict.h"
#include "src/pdf/SkPDFShader.h"
#include "src/pdf/SkPDFTag.h"
#include "src/pdf/SkPDFTypes.h"
#include "src/pdf/SkPDFUtils.h"
#include "src/shaders/SkColorShader.h"
#include "src/shaders/SkShaderBase.h"
#include "src/text/GlyphRun.h"
#include "src/utils/SkClipStackUtils.h"
#include <algorithm>
#include <cstdint>
#include <cstring>
#include <utility>
#include <vector>

Go to the source code of this file.

Classes
class	ScopedContentEntry

Macros
#define	SK_PDF_MASK_QUALITY   50

Functions
sk_sp< SkImage >	mask_to_greyscale_image (SkMaskBuilder *mask)
sk_sp< SkImage >	alpha_image_to_greyscale_image (const SkImage *mask)
static int	add_resource (THashSet< SkPDFIndirectReference > &resources, SkPDFIndirectReference ref)
static void	draw_points (SkCanvas::PointMode mode, size_t count, const SkPoint *points, const SkPaint &paint, const SkIRect &bounds, SkDevice *device)
static void	transform_shader (SkPaint *paint, const SkMatrix &ctm)
static SkTCopyOnFirstWrite< SkPaint >	clean_paint (const SkPaint &srcPaint)
static void	set_style (SkTCopyOnFirstWrite< SkPaint > *paint, SkPaint::Style style)
static bool	calculate_inverse_path (const SkRect &bounds, const SkPath &invPath, SkPath *outPath)
static SkUnichar	map_glyph (const std::vector< SkUnichar > &glyphToUnicode, SkGlyphID glyph)
static SkRect	get_glyph_bounds_device_space (const SkGlyph *glyph, SkScalar xScale, SkScalar yScale, SkPoint xy, const SkMatrix &ctm)
static bool	contains (const SkRect &r, SkPoint p)
static bool	needs_new_font (SkPDFFont *font, const SkGlyph *glyph, SkAdvancedTypefaceMetrics::FontType fontType)
static std::vector< SkPDFIndirectReference >	sort (const THashSet< SkPDFIndirectReference > &src)
static bool	treat_as_regular_pdf_blend_mode (SkBlendMode blendMode)
static void	populate_graphic_state_entry_from_paint (SkPDFDocument *doc, const SkMatrix &matrix, const SkClipStack *clipStack, SkIRect deviceBounds, const SkPaint &paint, const SkMatrix &initialTransform, SkScalar textScale, SkPDFGraphicStackState::Entry *entry, THashSet< SkPDFIndirectReference > *shaderResources, THashSet< SkPDFIndirectReference > *graphicStateResources)
static SkSize	rect_to_size (const SkRect &r)
static sk_sp< SkImage >	color_filter (const SkImage *image, SkColorFilter *colorFilter)
static bool	is_integer (SkScalar x)
static bool	is_integral (const SkRect &r)

Macro Definition Documentation

SK_PDF_MASK_QUALITY

#define SK_PDF_MASK_QUALITY   50

Definition at line 95 of file SkPDFDevice.cpp.

Function Documentation

add_resource()

static int add_resource ( THashSet< SkPDFIndirectReference > &  resources, SkPDFIndirectReference  ref  )

static

Definition at line 181 of file SkPDFDevice.cpp.

                                                                                                 {
    resources.add(ref);
    return ref.fValue;
}

alpha_image_to_greyscale_image()

sk_sp< SkImage > alpha_image_to_greyscale_image

(

const SkImage *

mask

)

Definition at line 168 of file SkPDFDevice.cpp.

                                                                   {
    int w = mask->width(), h = mask->height();
    SkBitmap greyBitmap;
    greyBitmap.allocPixels(SkImageInfo::Make(w, h, kGray_8_SkColorType, kOpaque_SkAlphaType));
    // TODO: support gpu images in pdf
    if (!mask->readPixels(nullptr, SkImageInfo::MakeA8(w, h),
                          greyBitmap.getPixels(), greyBitmap.rowBytes(), 0, 0)) {
        return nullptr;
    }
    greyBitmap.setImmutable();
    return greyBitmap.asImage();
}

calculate_inverse_path()

static bool calculate_inverse_path ( const SkRect &  bounds, const SkPath &  invPath, SkPath *  outPath  )

static

Definition at line 250 of file SkPDFDevice.cpp.

                                                    {
    SkASSERT(invPath.isInverseFillType());
    return Op(SkPath::Rect(bounds), invPath, kIntersect_SkPathOp, outPath);
}

clean_paint()

static SkTCopyOnFirstWrite< SkPaint > clean_paint ( const SkPaint &  srcPaint )

static

Definition at line 223 of file SkPDFDevice.cpp.

                                                                         {
    SkTCopyOnFirstWrite<SkPaint> paint(srcPaint);
    // If the paint will definitely draw opaquely, replace kSrc with
    // kSrcOver.  http://crbug.com/473572
    if (!paint->isSrcOver() &&
        SkBlendFastPath::kSrcOver == CheckFastPath(*paint, false))
    {
        paint.writable()->setBlendMode(SkBlendMode::kSrcOver);
    }
    if (paint->getColorFilter()) {
        // We assume here that PDFs all draw in sRGB.
        SkPaintPriv::RemoveColorFilter(paint.writable(), sk_srgb_singleton());
    }
    SkASSERT(!paint->getColorFilter());
    return paint;
}

color_filter()

static sk_sp< SkImage > color_filter ( const SkImage *  image, SkColorFilter *  colorFilter  )

static

Definition at line 1492 of file SkPDFDevice.cpp.

                                                               {
    auto surface = SkSurfaces::Raster(SkImageInfo::MakeN32Premul(image->dimensions()));
    SkASSERT(surface);
    SkCanvas* canvas = surface->getCanvas();
    canvas->clear(SK_ColorTRANSPARENT);
    SkPaint paint;
    paint.setColorFilter(sk_ref_sp(colorFilter));
    canvas->drawImage(image, 0, 0, SkSamplingOptions(), &paint);
    return surface->makeImageSnapshot();
}

contains()

static bool contains ( const SkRect &  r, SkPoint  p  )

static

Definition at line 795 of file SkPDFDevice.cpp.

                                                 {
   return r.left() <= p.x() && p.x() <= r.right() &&
          r.top()  <= p.y() && p.y() <= r.bottom();
}

draw_points()

static void draw_points ( SkCanvas::PointMode  mode, size_t  count, const SkPoint *  points, const SkPaint &  paint, const SkIRect &  bounds, SkDevice *  device  )

static

Definition at line 186 of file SkPDFDevice.cpp.

                                          {
    SkRasterClip rc(bounds);
    SkDraw draw;
    draw.fDst = SkPixmap(SkImageInfo::MakeUnknown(bounds.right(), bounds.bottom()), nullptr, 0);
    draw.fCTM = &device->localToDevice();
    draw.fRC = &rc;
    draw.drawPoints(mode, count, points, paint, device);
}

get_glyph_bounds_device_space()

static SkRect get_glyph_bounds_device_space ( const SkGlyph *  glyph, SkScalar  xScale, SkScalar  yScale, SkPoint  xy, const SkMatrix &  ctm  )

static

Definition at line 786 of file SkPDFDevice.cpp.

                                                                             {
    SkRect glyphBounds = SkMatrix::Scale(xScale, yScale).mapRect(glyph->rect());
    glyphBounds.offset(xy);
    ctm.mapRect(&glyphBounds); // now in dev space.
    return glyphBounds;
}

is_integer()

static bool is_integer ( SkScalar  x )

static

Definition at line 1506 of file SkPDFDevice.cpp.

                                   {
    return x == SkScalarTruncToScalar(x);
}

is_integral()

static bool is_integral ( const SkRect &  r )

static

Definition at line 1510 of file SkPDFDevice.cpp.

                                         {
    return is_integer(r.left()) &&
           is_integer(r.top()) &&
           is_integer(r.right()) &&
           is_integer(r.bottom());
}

map_glyph()

static SkUnichar map_glyph ( const std::vector< SkUnichar > &  glyphToUnicode, SkGlyphID  glyph  )

static

Definition at line 775 of file SkPDFDevice.cpp.

                                                                                        {
    return glyph < glyphToUnicode.size() ? glyphToUnicode[SkToInt(glyph)] : -1;
}

mask_to_greyscale_image()

sk_sp< SkImage > mask_to_greyscale_image

(

SkMaskBuilder *

mask

)

Definition at line 142 of file SkPDFDevice.cpp.

                                                            {
    sk_sp<SkImage> img;
    SkPixmap pm(SkImageInfo::Make(mask->fBounds.width(), mask->fBounds.height(),
                                  kGray_8_SkColorType, kOpaque_SkAlphaType),
                mask->fImage, mask->fRowBytes);
    const int imgQuality = SK_PDF_MASK_QUALITY;
    if (imgQuality <= 100 && imgQuality >= 0) {
        SkDynamicMemoryWStream buffer;
        SkJpegEncoder::Options jpegOptions;
        jpegOptions.fQuality = imgQuality;
        if (SkJpegEncoder::Encode(&buffer, pm, jpegOptions)) {
            img = SkImages::DeferredFromEncodedData(buffer.detachAsData());
            SkASSERT(img);
            if (img) {
                SkMaskBuilder::FreeImage(mask->image());
            }
        }
    }
    if (!img) {
        img = SkImages::RasterFromPixmap(
                pm, [](const void* p, void*) { SkMaskBuilder::FreeImage(const_cast<void*>(p)); }, nullptr);
    }
    *mask = SkMaskBuilder();  // destructive;
    return img;
}

needs_new_font()

static bool needs_new_font ( SkPDFFont *  font, const SkGlyph *  glyph, SkAdvancedTypefaceMetrics::FontType  fontType  )

static

Definition at line 839 of file SkPDFDevice.cpp.

                                                                       {
    if (!font || !font->hasGlyph(glyph->getGlyphID())) {
        return true;
    }
    if (fontType == SkAdvancedTypefaceMetrics::kOther_Font) {
        return false;
    }
    if (glyph->isEmpty()) {
        return false;
    }
 
    bool bitmapOnly = nullptr == glyph->path();
    bool convertedToType3 = (font->getType() == SkAdvancedTypefaceMetrics::kOther_Font);
    return convertedToType3 != bitmapOnly;
}

populate_graphic_state_entry_from_paint()

static void populate_graphic_state_entry_from_paint ( SkPDFDocument *  doc, const SkMatrix &  matrix, const SkClipStack *  clipStack, SkIRect  deviceBounds, const SkPaint &  paint, const SkMatrix &  initialTransform, SkScalar  textScale, SkPDFGraphicStackState::Entry *  entry, THashSet< SkPDFIndirectReference > *  shaderResources, THashSet< SkPDFIndirectReference > *  graphicStateResources  )

static

Definition at line 1214 of file SkPDFDevice.cpp.

                                                                 {
    NOT_IMPLEMENTED(paint.getPathEffect() != nullptr, false);
    NOT_IMPLEMENTED(paint.getMaskFilter() != nullptr, false);
    NOT_IMPLEMENTED(paint.getColorFilter() != nullptr, false);
 
    entry->fMatrix = matrix;
    entry->fClipStackGenID = clipStack ? clipStack->getTopmostGenID()
                                       : SkClipStack::kWideOpenGenID;
    SkColor4f color = paint.getColor4f();
    entry->fColor = {color.fR, color.fG, color.fB, 1};
    entry->fShaderIndex = -1;
 
    // PDF treats a shader as a color, so we only set one or the other.
    SkShader* shader = paint.getShader();
    if (shader) {
        // note: we always present the alpha as 1 for the shader, knowing that it will be
        //       accounted for when we create our newGraphicsState (below)
        if (as_SB(shader)->type() == SkShaderBase::ShaderType::kColor) {
            auto colorShader = static_cast<SkColorShader*>(shader);
            // We don't have to set a shader just for a color.
            color = SkColor4f::FromColor(colorShader->color());
            entry->fColor = {color.fR, color.fG, color.fB, 1};
        } else {
            // PDF positions patterns relative to the initial transform, so
            // we need to apply the current transform to the shader parameters.
            SkMatrix transform = matrix;
            transform.postConcat(initialTransform);
 
            // PDF doesn't support kClamp_TileMode, so we simulate it by making
            // a pattern the size of the current clip.
            SkRect clipStackBounds = clipStack ? clipStack->bounds(deviceBounds)
                                               : SkRect::Make(deviceBounds);
 
            // We need to apply the initial transform to bounds in order to get
            // bounds in a consistent coordinate system.
            initialTransform.mapRect(&clipStackBounds);
            SkIRect bounds;
            clipStackBounds.roundOut(&bounds);
 
            auto c = paint.getColor4f();
            SkPDFIndirectReference pdfShader = SkPDFMakeShader(doc, shader, transform, bounds,
                                                               {c.fR, c.fG, c.fB, 1.0f});
 
            if (pdfShader) {
                // pdfShader has been canonicalized so we can directly compare pointers.
                entry->fShaderIndex = add_resource(*shaderResources, pdfShader);
            }
        }
    }
 
    SkPDFIndirectReference newGraphicState;
    if (color == paint.getColor4f()) {
        newGraphicState = SkPDFGraphicState::GetGraphicStateForPaint(doc, paint);
    } else {
        SkPaint newPaint = paint;
        newPaint.setColor4f(color, nullptr);
        newGraphicState = SkPDFGraphicState::GetGraphicStateForPaint(doc, newPaint);
    }
    entry->fGraphicStateIndex = add_resource(*graphicStateResources, newGraphicState);
    entry->fTextScaleX = textScale;
}

rect_to_size()

static SkSize rect_to_size ( const SkRect &  r )

static

Definition at line 1490 of file SkPDFDevice.cpp.

{ return {r.width(), r.height()}; }

set_style()

static void set_style ( SkTCopyOnFirstWrite< SkPaint > *  paint, SkPaint::Style  style  )

static

Definition at line 240 of file SkPDFDevice.cpp.

                                                                               {
    if (paint->get()->getStyle() != style) {
        paint->writable()->setStyle(style);
    }
}

sort()

static std::vector< SkPDFIndirectReference > sort ( const THashSet< SkPDFIndirectReference > &  src )

static

Definition at line 1061 of file SkPDFDevice.cpp.

                                                                                           {
    std::vector<SkPDFIndirectReference> dst;
    dst.reserve(src.count());
    for (SkPDFIndirectReference ref : src) {
        dst.push_back(ref);
    }
    std::sort(dst.begin(), dst.end(),
            [](SkPDFIndirectReference a, SkPDFIndirectReference b) { return a.fValue < b.fValue; });
    return dst;
}

transform_shader()

static void transform_shader ( SkPaint *  paint, const SkMatrix &  ctm  )

static

Definition at line 200 of file SkPDFDevice.cpp.

                                                                  {
    SkASSERT(!ctm.isIdentity());
#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK)
    // A shader's matrix is:  CTM x LocalMatrix x WrappingLocalMatrix.  We want to
    // switch to device space, where CTM = I, while keeping the original behavior.
    //
    //               I * LocalMatrix * NewWrappingMatrix = CTM * LocalMatrix
    //                   LocalMatrix * NewWrappingMatrix = CTM * LocalMatrix
    //  InvLocalMatrix * LocalMatrix * NewWrappingMatrix = InvLocalMatrix * CTM * LocalMatrix
    //                                 NewWrappingMatrix = InvLocalMatrix * CTM * LocalMatrix
    //
    SkMatrix lm = SkPDFUtils::GetShaderLocalMatrix(paint->getShader());
    SkMatrix lmInv;
    if (lm.invert(&lmInv)) {
        SkMatrix m = SkMatrix::Concat(SkMatrix::Concat(lmInv, ctm), lm);
        paint->setShader(paint->getShader()->makeWithLocalMatrix(m));
    }
    return;
#endif
    paint->setShader(paint->getShader()->makeWithLocalMatrix(ctm));
}

treat_as_regular_pdf_blend_mode()

static bool treat_as_regular_pdf_blend_mode ( SkBlendMode  blendMode )

static

Definition at line 1210 of file SkPDFDevice.cpp.

                                                                   {
    return nullptr != SkPDFUtils::BlendModeName(blendMode);
}