1/*
2 * Copyright 2011 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#include "SkPDFUtils.h"
9
10#include "SkData.h"
11#include "SkFixed.h"
12#include "SkGeometry.h"
13#include "SkImage_Base.h"
14#include "SkPDFResourceDict.h"
15#include "SkPDFTypes.h"
16#include "SkStream.h"
17#include "SkString.h"
18
19#include <cmath>
20
21sk_sp<SkPDFArray> SkPDFUtils::RectToArray(const SkRect& rect) {
22    auto result = sk_make_sp<SkPDFArray>();
23    result->reserve(4);
24    result->appendScalar(rect.fLeft);
25    result->appendScalar(rect.fTop);
26    result->appendScalar(rect.fRight);
27    result->appendScalar(rect.fBottom);
28    return result;
29}
30
31sk_sp<SkPDFArray> SkPDFUtils::MatrixToArray(const SkMatrix& matrix) {
32    SkScalar values[6];
33    if (!matrix.asAffine(values)) {
34        SkMatrix::SetAffineIdentity(values);
35    }
36
37    auto result = sk_make_sp<SkPDFArray>();
38    result->reserve(6);
39    for (size_t i = 0; i < SK_ARRAY_COUNT(values); i++) {
40        result->appendScalar(values[i]);
41    }
42    return result;
43}
44
45// static
46void SkPDFUtils::AppendTransform(const SkMatrix& matrix, SkWStream* content) {
47    SkScalar values[6];
48    if (!matrix.asAffine(values)) {
49        SkMatrix::SetAffineIdentity(values);
50    }
51    for (size_t i = 0; i < SK_ARRAY_COUNT(values); i++) {
52        SkPDFUtils::AppendScalar(values[i], content);
53        content->writeText(" ");
54    }
55    content->writeText("cm\n");
56}
57
58// static
59void SkPDFUtils::MoveTo(SkScalar x, SkScalar y, SkWStream* content) {
60    SkPDFUtils::AppendScalar(x, content);
61    content->writeText(" ");
62    SkPDFUtils::AppendScalar(y, content);
63    content->writeText(" m\n");
64}
65
66// static
67void SkPDFUtils::AppendLine(SkScalar x, SkScalar y, SkWStream* content) {
68    SkPDFUtils::AppendScalar(x, content);
69    content->writeText(" ");
70    SkPDFUtils::AppendScalar(y, content);
71    content->writeText(" l\n");
72}
73
74// static
75void SkPDFUtils::AppendCubic(SkScalar ctl1X, SkScalar ctl1Y,
76                             SkScalar ctl2X, SkScalar ctl2Y,
77                             SkScalar dstX, SkScalar dstY, SkWStream* content) {
78    SkString cmd("y\n");
79    SkPDFUtils::AppendScalar(ctl1X, content);
80    content->writeText(" ");
81    SkPDFUtils::AppendScalar(ctl1Y, content);
82    content->writeText(" ");
83    if (ctl2X != dstX || ctl2Y != dstY) {
84        cmd.set("c\n");
85        SkPDFUtils::AppendScalar(ctl2X, content);
86        content->writeText(" ");
87        SkPDFUtils::AppendScalar(ctl2Y, content);
88        content->writeText(" ");
89    }
90    SkPDFUtils::AppendScalar(dstX, content);
91    content->writeText(" ");
92    SkPDFUtils::AppendScalar(dstY, content);
93    content->writeText(" ");
94    content->writeText(cmd.c_str());
95}
96
97static void append_quad(const SkPoint quad[], SkWStream* content) {
98    SkPoint cubic[4];
99    SkConvertQuadToCubic(quad, cubic);
100    SkPDFUtils::AppendCubic(cubic[1].fX, cubic[1].fY, cubic[2].fX, cubic[2].fY,
101                            cubic[3].fX, cubic[3].fY, content);
102}
103
104// static
105void SkPDFUtils::AppendRectangle(const SkRect& rect, SkWStream* content) {
106    // Skia has 0,0 at top left, pdf at bottom left.  Do the right thing.
107    SkScalar bottom = SkMinScalar(rect.fBottom, rect.fTop);
108
109    SkPDFUtils::AppendScalar(rect.fLeft, content);
110    content->writeText(" ");
111    SkPDFUtils::AppendScalar(bottom, content);
112    content->writeText(" ");
113    SkPDFUtils::AppendScalar(rect.width(), content);
114    content->writeText(" ");
115    SkPDFUtils::AppendScalar(rect.height(), content);
116    content->writeText(" re\n");
117}
118
119// static
120void SkPDFUtils::EmitPath(const SkPath& path, SkPaint::Style paintStyle,
121                          bool doConsumeDegerates, SkWStream* content,
122                          SkScalar tolerance) {
123    // Filling a path with no area results in a drawing in PDF renderers but
124    // Chrome expects to be able to draw some such entities with no visible
125    // result, so we detect those cases and discard the drawing for them.
126    // Specifically: moveTo(X), lineTo(Y) and moveTo(X), lineTo(X), lineTo(Y).
127
128    SkRect rect;
129    bool isClosed; // Both closure and direction need to be checked.
130    SkPath::Direction direction;
131    if (path.isRect(&rect, &isClosed, &direction) &&
132        isClosed &&
133        (SkPath::kCW_Direction == direction ||
134         SkPath::kEvenOdd_FillType == path.getFillType()))
135    {
136        SkPDFUtils::AppendRectangle(rect, content);
137        return;
138    }
139
140    enum SkipFillState {
141        kEmpty_SkipFillState,
142        kSingleLine_SkipFillState,
143        kNonSingleLine_SkipFillState,
144    };
145    SkipFillState fillState = kEmpty_SkipFillState;
146    //if (paintStyle != SkPaint::kFill_Style) {
147    //    fillState = kNonSingleLine_SkipFillState;
148    //}
149    SkPoint lastMovePt = SkPoint::Make(0,0);
150    SkDynamicMemoryWStream currentSegment;
151    SkPoint args[4];
152    SkPath::Iter iter(path, false);
153    for (SkPath::Verb verb = iter.next(args, doConsumeDegerates);
154         verb != SkPath::kDone_Verb;
155         verb = iter.next(args, doConsumeDegerates)) {
156        // args gets all the points, even the implicit first point.
157        switch (verb) {
158            case SkPath::kMove_Verb:
159                MoveTo(args[0].fX, args[0].fY, &currentSegment);
160                lastMovePt = args[0];
161                fillState = kEmpty_SkipFillState;
162                break;
163            case SkPath::kLine_Verb:
164                AppendLine(args[1].fX, args[1].fY, &currentSegment);
165                if ((fillState == kEmpty_SkipFillState) && (args[0] != lastMovePt)) {
166                    fillState = kSingleLine_SkipFillState;
167                    break;
168                }
169                fillState = kNonSingleLine_SkipFillState;
170                break;
171            case SkPath::kQuad_Verb:
172                append_quad(args, &currentSegment);
173                fillState = kNonSingleLine_SkipFillState;
174                break;
175            case SkPath::kConic_Verb: {
176                SkAutoConicToQuads converter;
177                const SkPoint* quads = converter.computeQuads(args, iter.conicWeight(), tolerance);
178                for (int i = 0; i < converter.countQuads(); ++i) {
179                    append_quad(&quads[i * 2], &currentSegment);
180                }
181                fillState = kNonSingleLine_SkipFillState;
182            } break;
183            case SkPath::kCubic_Verb:
184                AppendCubic(args[1].fX, args[1].fY, args[2].fX, args[2].fY,
185                            args[3].fX, args[3].fY, &currentSegment);
186                fillState = kNonSingleLine_SkipFillState;
187                break;
188            case SkPath::kClose_Verb:
189                ClosePath(&currentSegment);
190                currentSegment.writeToStream(content);
191                currentSegment.reset();
192                break;
193            default:
194                SkASSERT(false);
195                break;
196        }
197    }
198    if (currentSegment.bytesWritten() > 0) {
199        currentSegment.writeToStream(content);
200    }
201}
202
203// static
204void SkPDFUtils::ClosePath(SkWStream* content) {
205    content->writeText("h\n");
206}
207
208// static
209void SkPDFUtils::PaintPath(SkPaint::Style style, SkPath::FillType fill,
210                           SkWStream* content) {
211    if (style == SkPaint::kFill_Style) {
212        content->writeText("f");
213    } else if (style == SkPaint::kStrokeAndFill_Style) {
214        content->writeText("B");
215    } else if (style == SkPaint::kStroke_Style) {
216        content->writeText("S");
217    }
218
219    if (style != SkPaint::kStroke_Style) {
220        NOT_IMPLEMENTED(fill == SkPath::kInverseEvenOdd_FillType, false);
221        NOT_IMPLEMENTED(fill == SkPath::kInverseWinding_FillType, false);
222        if (fill == SkPath::kEvenOdd_FillType) {
223            content->writeText("*");
224        }
225    }
226    content->writeText("\n");
227}
228
229// static
230void SkPDFUtils::StrokePath(SkWStream* content) {
231    SkPDFUtils::PaintPath(
232        SkPaint::kStroke_Style, SkPath::kWinding_FillType, content);
233}
234
235// static
236void SkPDFUtils::DrawFormXObject(int objectIndex, SkWStream* content) {
237    content->writeText("/");
238    content->writeText(SkPDFResourceDict::getResourceName(
239            SkPDFResourceDict::kXObject_ResourceType,
240            objectIndex).c_str());
241    content->writeText(" Do\n");
242}
243
244// static
245void SkPDFUtils::ApplyGraphicState(int objectIndex, SkWStream* content) {
246    content->writeText("/");
247    content->writeText(SkPDFResourceDict::getResourceName(
248            SkPDFResourceDict::kExtGState_ResourceType,
249            objectIndex).c_str());
250    content->writeText(" gs\n");
251}
252
253// static
254void SkPDFUtils::ApplyPattern(int objectIndex, SkWStream* content) {
255    // Select Pattern color space (CS, cs) and set pattern object as current
256    // color (SCN, scn)
257    SkString resourceName = SkPDFResourceDict::getResourceName(
258            SkPDFResourceDict::kPattern_ResourceType,
259            objectIndex);
260    content->writeText("/Pattern CS/Pattern cs/");
261    content->writeText(resourceName.c_str());
262    content->writeText(" SCN/");
263    content->writeText(resourceName.c_str());
264    content->writeText(" scn\n");
265}
266
267size_t SkPDFUtils::ColorToDecimal(uint8_t value, char result[5]) {
268    if (value == 255 || value == 0) {
269        result[0] = value ? '1' : '0';
270        result[1] = '\0';
271        return 1;
272    }
273    // int x = 0.5 + (1000.0 / 255.0) * value;
274    int x = SkFixedRoundToInt((SK_Fixed1 * 1000 / 255) * value);
275    result[0] = '.';
276    for (int i = 3; i > 0; --i) {
277        result[i] = '0' + x % 10;
278        x /= 10;
279    }
280    int j;
281    for (j = 3; j > 1; --j) {
282        if (result[j] != '0') {
283            break;
284        }
285    }
286    result[j + 1] = '\0';
287    return j + 1;
288}
289
290void SkPDFUtils::WriteString(SkWStream* wStream, const char* cin, size_t len) {
291    SkDEBUGCODE(static const size_t kMaxLen = 65535;)
292    SkASSERT(len <= kMaxLen);
293
294    size_t extraCharacterCount = 0;
295    for (size_t i = 0; i < len; i++) {
296        if (cin[i] > '~' || cin[i] < ' ') {
297            extraCharacterCount += 3;
298        }
299        if (cin[i] == '\\' || cin[i] == '(' || cin[i] == ')') {
300            ++extraCharacterCount;
301        }
302    }
303    if (extraCharacterCount <= len) {
304        wStream->writeText("(");
305        for (size_t i = 0; i < len; i++) {
306            if (cin[i] > '~' || cin[i] < ' ') {
307                uint8_t c = static_cast<uint8_t>(cin[i]);
308                uint8_t octal[4];
309                octal[0] = '\\';
310                octal[1] = '0' + ( c >> 6        );
311                octal[2] = '0' + ((c >> 3) & 0x07);
312                octal[3] = '0' + ( c       & 0x07);
313                wStream->write(octal, 4);
314            } else {
315                if (cin[i] == '\\' || cin[i] == '(' || cin[i] == ')') {
316                    wStream->writeText("\\");
317                }
318                wStream->write(&cin[i], 1);
319            }
320        }
321        wStream->writeText(")");
322    } else {
323        wStream->writeText("<");
324        for (size_t i = 0; i < len; i++) {
325            uint8_t c = static_cast<uint8_t>(cin[i]);
326            char hexValue[2] = { SkHexadecimalDigits::gUpper[c >> 4],
327                                 SkHexadecimalDigits::gUpper[c & 0xF] };
328            wStream->write(hexValue, 2);
329        }
330        wStream->writeText(">");
331    }
332}
333
334bool SkPDFUtils::InverseTransformBBox(const SkMatrix& matrix, SkRect* bbox) {
335    SkMatrix inverse;
336    if (!matrix.invert(&inverse)) {
337        return false;
338    }
339    inverse.mapRect(bbox);
340    return true;
341}
342
343void SkPDFUtils::PopulateTilingPatternDict(SkPDFDict* pattern,
344                                           SkRect& bbox,
345                                           sk_sp<SkPDFDict> resources,
346                                           const SkMatrix& matrix) {
347    const int kTiling_PatternType = 1;
348    const int kColoredTilingPattern_PaintType = 1;
349    const int kConstantSpacing_TilingType = 1;
350
351    pattern->insertName("Type", "Pattern");
352    pattern->insertInt("PatternType", kTiling_PatternType);
353    pattern->insertInt("PaintType", kColoredTilingPattern_PaintType);
354    pattern->insertInt("TilingType", kConstantSpacing_TilingType);
355    pattern->insertObject("BBox", SkPDFUtils::RectToArray(bbox));
356    pattern->insertScalar("XStep", bbox.width());
357    pattern->insertScalar("YStep", bbox.height());
358    pattern->insertObject("Resources", std::move(resources));
359    if (!matrix.isIdentity()) {
360        pattern->insertObject("Matrix", SkPDFUtils::MatrixToArray(matrix));
361    }
362}
363
364bool SkPDFUtils::ToBitmap(const SkImage* img, SkBitmap* dst) {
365    SkASSERT(img);
366    SkASSERT(dst);
367    SkBitmap bitmap;
368    if(as_IB(img)->getROPixels(&bitmap, nullptr)) {
369        SkASSERT(bitmap.dimensions() == img->dimensions());
370        SkASSERT(!bitmap.drawsNothing());
371        *dst = std::move(bitmap);
372        return true;
373    }
374    return false;
375}
376