vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 1 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 2 | * Copyright 2011 Google Inc. |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 3 | * |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
Hal Canary | c640d0d | 2018-06-13 09:59:02 -0400 | [diff] [blame] | 8 | #include "SkPDFGraphicState.h" |
| 9 | |
halcanary | 67ec1f8 | 2014-06-27 11:36:20 -0700 | [diff] [blame] | 10 | #include "SkData.h" |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 11 | #include "SkPDFCanon.h" |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 12 | #include "SkPDFFormXObject.h" |
vandebo@chromium.org | f71b210 | 2011-04-04 19:46:31 +0000 | [diff] [blame] | 13 | #include "SkPDFUtils.h" |
Hal Canary | c640d0d | 2018-06-13 09:59:02 -0400 | [diff] [blame] | 14 | #include "SkPaint.h" |
| 15 | #include "SkTo.h" |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 16 | |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 17 | static const char* as_pdf_blend_mode_name(SkBlendMode mode) { |
| 18 | // PDF32000.book section 11.3.5 "Blend Mode" |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 19 | switch (mode) { |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 20 | case SkBlendMode::kScreen: return "Screen"; |
| 21 | case SkBlendMode::kOverlay: return "Overlay"; |
| 22 | case SkBlendMode::kDarken: return "Darken"; |
| 23 | case SkBlendMode::kLighten: return "Lighten"; |
| 24 | case SkBlendMode::kColorDodge: return "ColorDodge"; |
| 25 | case SkBlendMode::kColorBurn: return "ColorBurn"; |
| 26 | case SkBlendMode::kHardLight: return "HardLight"; |
| 27 | case SkBlendMode::kSoftLight: return "SoftLight"; |
| 28 | case SkBlendMode::kDifference: return "Difference"; |
| 29 | case SkBlendMode::kExclusion: return "Exclusion"; |
| 30 | case SkBlendMode::kMultiply: return "Multiply"; |
| 31 | case SkBlendMode::kHue: return "Hue"; |
| 32 | case SkBlendMode::kSaturation: return "Saturation"; |
| 33 | case SkBlendMode::kColor: return "Color"; |
| 34 | case SkBlendMode::kLuminosity: return "Luminosity"; |
| 35 | // Other blendmodes are either unsupported or handled in |
| 36 | // SkPDFDevice::setUpContentEntry. |
| 37 | default: return "Normal"; |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 38 | } |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 39 | } |
| 40 | |
| 41 | static int to_stroke_cap(uint8_t cap) { |
| 42 | // PDF32000.book section 8.4.3.3 "Line Cap Style" |
| 43 | switch ((SkPaint::Cap)cap) { |
| 44 | case SkPaint::kButt_Cap: return 0; |
| 45 | case SkPaint::kRound_Cap: return 1; |
| 46 | case SkPaint::kSquare_Cap: return 2; |
| 47 | default: SkASSERT(false); return 0; |
| 48 | } |
| 49 | } |
| 50 | |
| 51 | static int to_stroke_join(uint8_t join) { |
| 52 | // PDF32000.book section 8.4.3.4 "Line Join Style" |
| 53 | switch ((SkPaint::Join)join) { |
| 54 | case SkPaint::kMiter_Join: return 0; |
| 55 | case SkPaint::kRound_Join: return 1; |
| 56 | case SkPaint::kBevel_Join: return 2; |
| 57 | default: SkASSERT(false); return 0; |
| 58 | } |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 59 | } |
| 60 | |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 61 | // If a SkXfermode is unsupported in PDF, this function returns |
| 62 | // SrcOver, otherwise, it returns that Xfermode as a Mode. |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 63 | static uint8_t pdf_blend_mode(SkBlendMode mode) { |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 64 | switch (mode) { |
reed | 374772b | 2016-10-05 17:33:02 -0700 | [diff] [blame] | 65 | case SkBlendMode::kSrcOver: |
| 66 | case SkBlendMode::kMultiply: |
| 67 | case SkBlendMode::kScreen: |
| 68 | case SkBlendMode::kOverlay: |
| 69 | case SkBlendMode::kDarken: |
| 70 | case SkBlendMode::kLighten: |
| 71 | case SkBlendMode::kColorDodge: |
| 72 | case SkBlendMode::kColorBurn: |
| 73 | case SkBlendMode::kHardLight: |
| 74 | case SkBlendMode::kSoftLight: |
| 75 | case SkBlendMode::kDifference: |
| 76 | case SkBlendMode::kExclusion: |
| 77 | case SkBlendMode::kHue: |
| 78 | case SkBlendMode::kSaturation: |
| 79 | case SkBlendMode::kColor: |
| 80 | case SkBlendMode::kLuminosity: |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 81 | return SkToU8((unsigned)mode); |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 82 | default: |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 83 | return SkToU8((unsigned)SkBlendMode::kSrcOver); |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 84 | } |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 85 | } |
| 86 | |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 87 | sk_sp<SkPDFDict> SkPDFGraphicState::GetGraphicStateForPaint(SkPDFCanon* canon, |
| 88 | const SkPaint& p) { |
halcanary | 792c80f | 2015-02-20 07:21:05 -0800 | [diff] [blame] | 89 | SkASSERT(canon); |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 90 | if (SkPaint::kFill_Style == p.getStyle()) { |
| 91 | SkPDFFillGraphicState fillKey = {p.getAlpha(), pdf_blend_mode(p.getBlendMode())}; |
| 92 | auto& fillMap = canon->fFillGSMap; |
| 93 | if (sk_sp<SkPDFDict>* statePtr = fillMap.find(fillKey)) { |
| 94 | return *statePtr; |
| 95 | } |
| 96 | auto state = sk_make_sp<SkPDFDict>(); |
| 97 | state->reserve(2); |
| 98 | state->insertScalar("ca", fillKey.fAlpha / 255.0f); |
| 99 | state->insertName("BM", as_pdf_blend_mode_name((SkBlendMode)fillKey.fBlendMode)); |
| 100 | fillMap.set(fillKey, state); |
| 101 | return state; |
| 102 | } else { |
| 103 | SkPDFStrokeGraphicState strokeKey = { |
| 104 | p.getStrokeWidth(), p.getStrokeMiter(), |
| 105 | SkToU8(p.getStrokeCap()), SkToU8(p.getStrokeJoin()), |
| 106 | p.getAlpha(), pdf_blend_mode(p.getBlendMode())}; |
| 107 | auto& sMap = canon->fStrokeGSMap; |
| 108 | if (sk_sp<SkPDFDict>* statePtr = sMap.find(strokeKey)) { |
| 109 | return *statePtr; |
| 110 | } |
| 111 | auto state = sk_make_sp<SkPDFDict>(); |
| 112 | state->reserve(8); |
| 113 | state->insertScalar("CA", strokeKey.fAlpha / 255.0f); |
| 114 | state->insertScalar("ca", strokeKey.fAlpha / 255.0f); |
| 115 | state->insertInt("LC", to_stroke_cap(strokeKey.fStrokeCap)); |
| 116 | state->insertInt("LJ", to_stroke_join(strokeKey.fStrokeJoin)); |
| 117 | state->insertScalar("LW", strokeKey.fStrokeWidth); |
| 118 | state->insertScalar("ML", strokeKey.fStrokeMiter); |
| 119 | state->insertBool("SA", true); // SA = Auto stroke adjustment. |
| 120 | state->insertName("BM", as_pdf_blend_mode_name((SkBlendMode)strokeKey.fBlendMode)); |
| 121 | sMap.set(strokeKey, state); |
| 122 | return state; |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 123 | } |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 124 | } |
| 125 | |
Hal Canary | 80fa7ce | 2017-06-28 16:04:20 -0400 | [diff] [blame] | 126 | //////////////////////////////////////////////////////////////////////////////// |
| 127 | |
Hal Canary | 5c1b360 | 2017-04-17 16:30:06 -0400 | [diff] [blame] | 128 | static sk_sp<SkPDFStream> make_invert_function() { |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 129 | // Acrobat crashes if we use a type 0 function, kpdf crashes if we use |
| 130 | // a type 2 function, so we use a type 4 function. |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 131 | auto domainAndRange = sk_make_sp<SkPDFArray>(); |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 132 | domainAndRange->reserve(2); |
| 133 | domainAndRange->appendInt(0); |
| 134 | domainAndRange->appendInt(1); |
| 135 | |
| 136 | static const char psInvert[] = "{1 exch sub}"; |
| 137 | // Do not copy the trailing '\0' into the SkData. |
halcanary | fe8f0e0 | 2016-07-27 14:14:04 -0700 | [diff] [blame] | 138 | auto invertFunction = sk_make_sp<SkPDFStream>( |
| 139 | SkData::MakeWithoutCopy(psInvert, strlen(psInvert))); |
halcanary | fa25106 | 2016-07-29 10:13:18 -0700 | [diff] [blame] | 140 | invertFunction->dict()->insertInt("FunctionType", 4); |
| 141 | invertFunction->dict()->insertObject("Domain", domainAndRange); |
| 142 | invertFunction->dict()->insertObject("Range", std::move(domainAndRange)); |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame] | 143 | return invertFunction; |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 144 | } |
| 145 | |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame] | 146 | sk_sp<SkPDFDict> SkPDFGraphicState::GetSMaskGraphicState( |
halcanary | dabd4f0 | 2016-08-03 11:16:56 -0700 | [diff] [blame] | 147 | sk_sp<SkPDFObject> sMask, |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame] | 148 | bool invert, |
| 149 | SkPDFSMaskMode sMaskMode, |
| 150 | SkPDFCanon* canon) { |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 151 | // The practical chances of using the same mask more than once are unlikely |
| 152 | // enough that it's not worth canonicalizing. |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 153 | auto sMaskDict = sk_make_sp<SkPDFDict>("Mask"); |
commit-bot@chromium.org | 93a2e21 | 2013-07-23 23:16:03 +0000 | [diff] [blame] | 154 | if (sMaskMode == kAlpha_SMaskMode) { |
| 155 | sMaskDict->insertName("S", "Alpha"); |
| 156 | } else if (sMaskMode == kLuminosity_SMaskMode) { |
| 157 | sMaskDict->insertName("S", "Luminosity"); |
| 158 | } |
halcanary | dabd4f0 | 2016-08-03 11:16:56 -0700 | [diff] [blame] | 159 | sMaskDict->insertObjRef("G", std::move(sMask)); |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 160 | if (invert) { |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame] | 161 | // Instead of calling SkPDFGraphicState::MakeInvertFunction, |
| 162 | // let the canon deduplicate this object. |
Hal Canary | c02de0b | 2017-06-28 13:14:03 -0400 | [diff] [blame] | 163 | sk_sp<SkPDFStream>& invertFunction = canon->fInvertFunction; |
| 164 | if (!invertFunction) { |
| 165 | invertFunction = make_invert_function(); |
| 166 | } |
| 167 | sMaskDict->insertObjRef("TR", invertFunction); |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 168 | } |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 169 | auto result = sk_make_sp<SkPDFDict>("ExtGState"); |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 170 | result->insertObject("SMask", std::move(sMaskDict)); |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame] | 171 | return result; |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 172 | } |