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 | |
halcanary | 67ec1f8 | 2014-06-27 11:36:20 -0700 | [diff] [blame] | 8 | #include "SkData.h" |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 9 | #include "SkPDFCanon.h" |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 10 | #include "SkPDFFormXObject.h" |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 11 | #include "SkPDFGraphicState.h" |
vandebo@chromium.org | f71b210 | 2011-04-04 19:46:31 +0000 | [diff] [blame] | 12 | #include "SkPDFUtils.h" |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 13 | |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 14 | static const char* as_blend_mode(SkXfermode::Mode mode) { |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 15 | switch (mode) { |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 16 | case SkXfermode::kSrcOver_Mode: |
| 17 | return "Normal"; |
| 18 | case SkXfermode::kMultiply_Mode: |
| 19 | return "Multiply"; |
| 20 | case SkXfermode::kScreen_Mode: |
| 21 | return "Screen"; |
| 22 | case SkXfermode::kOverlay_Mode: |
| 23 | return "Overlay"; |
| 24 | case SkXfermode::kDarken_Mode: |
| 25 | return "Darken"; |
| 26 | case SkXfermode::kLighten_Mode: |
| 27 | return "Lighten"; |
| 28 | case SkXfermode::kColorDodge_Mode: |
| 29 | return "ColorDodge"; |
| 30 | case SkXfermode::kColorBurn_Mode: |
| 31 | return "ColorBurn"; |
| 32 | case SkXfermode::kHardLight_Mode: |
| 33 | return "HardLight"; |
| 34 | case SkXfermode::kSoftLight_Mode: |
| 35 | return "SoftLight"; |
| 36 | case SkXfermode::kDifference_Mode: |
| 37 | return "Difference"; |
| 38 | case SkXfermode::kExclusion_Mode: |
| 39 | return "Exclusion"; |
| 40 | case SkXfermode::kHue_Mode: |
| 41 | return "Hue"; |
| 42 | case SkXfermode::kSaturation_Mode: |
| 43 | return "Saturation"; |
| 44 | case SkXfermode::kColor_Mode: |
| 45 | return "Color"; |
| 46 | case SkXfermode::kLuminosity_Mode: |
| 47 | return "Luminosity"; |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 48 | |
vandebo@chromium.org | 25adce8 | 2011-05-09 08:05:01 +0000 | [diff] [blame] | 49 | // These are handled in SkPDFDevice::setUpContentEntry. |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 50 | case SkXfermode::kClear_Mode: |
| 51 | case SkXfermode::kSrc_Mode: |
| 52 | case SkXfermode::kDst_Mode: |
| 53 | case SkXfermode::kDstOver_Mode: |
| 54 | case SkXfermode::kSrcIn_Mode: |
| 55 | case SkXfermode::kDstIn_Mode: |
| 56 | case SkXfermode::kSrcOut_Mode: |
| 57 | case SkXfermode::kDstOut_Mode: |
vandebo@chromium.org | 3b41621 | 2013-10-30 20:48:05 +0000 | [diff] [blame] | 58 | case SkXfermode::kSrcATop_Mode: |
| 59 | case SkXfermode::kDstATop_Mode: |
| 60 | case SkXfermode::kModulate_Mode: |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 61 | return "Normal"; |
| 62 | |
ctguil@chromium.org | 769fa6a | 2011-08-20 00:36:18 +0000 | [diff] [blame] | 63 | // TODO(vandebo): Figure out if we can support more of these modes. |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 64 | case SkXfermode::kXor_Mode: |
| 65 | case SkXfermode::kPlus_Mode: |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 66 | return nullptr; |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 67 | } |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 68 | return nullptr; |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 69 | } |
| 70 | |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 71 | // If a SkXfermode is unsupported in PDF, this function returns |
| 72 | // SrcOver, otherwise, it returns that Xfermode as a Mode. |
| 73 | static SkXfermode::Mode mode_for_pdf(const SkXfermode* xfermode) { |
| 74 | SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode; |
| 75 | if (xfermode) { |
| 76 | xfermode->asMode(&mode); |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 77 | } |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 78 | switch (mode) { |
| 79 | case SkXfermode::kSrcOver_Mode: |
| 80 | case SkXfermode::kMultiply_Mode: |
| 81 | case SkXfermode::kScreen_Mode: |
| 82 | case SkXfermode::kOverlay_Mode: |
| 83 | case SkXfermode::kDarken_Mode: |
| 84 | case SkXfermode::kLighten_Mode: |
| 85 | case SkXfermode::kColorDodge_Mode: |
| 86 | case SkXfermode::kColorBurn_Mode: |
| 87 | case SkXfermode::kHardLight_Mode: |
| 88 | case SkXfermode::kSoftLight_Mode: |
| 89 | case SkXfermode::kDifference_Mode: |
| 90 | case SkXfermode::kExclusion_Mode: |
| 91 | case SkXfermode::kHue_Mode: |
| 92 | case SkXfermode::kSaturation_Mode: |
| 93 | case SkXfermode::kColor_Mode: |
| 94 | case SkXfermode::kLuminosity_Mode: |
| 95 | // Mode is suppported and handled by pdf graphics state. |
| 96 | return mode; |
| 97 | default: |
| 98 | return SkXfermode::kSrcOver_Mode; // Default mode. |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 99 | } |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 100 | } |
| 101 | |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 102 | SkPDFGraphicState::SkPDFGraphicState(const SkPaint& p) |
| 103 | : fStrokeWidth(p.getStrokeWidth()) |
| 104 | , fStrokeMiter(p.getStrokeMiter()) |
| 105 | , fAlpha(p.getAlpha()) |
| 106 | , fStrokeCap(SkToU8(p.getStrokeCap())) |
| 107 | , fStrokeJoin(SkToU8(p.getStrokeJoin())) |
| 108 | , fMode(SkToU8(mode_for_pdf(p.getXfermode()))) {} |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 109 | |
vandebo@chromium.org | 4854327 | 2011-02-08 19:28:07 +0000 | [diff] [blame] | 110 | // static |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 111 | SkPDFGraphicState* SkPDFGraphicState::GetGraphicStateForPaint( |
halcanary | 792c80f | 2015-02-20 07:21:05 -0800 | [diff] [blame] | 112 | SkPDFCanon* canon, const SkPaint& paint) { |
| 113 | SkASSERT(canon); |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 114 | SkPDFGraphicState key(paint); |
| 115 | if (const SkPDFGraphicState* canonGS = canon->findGraphicState(key)) { |
| 116 | // The returned SkPDFGraphicState must be made non-const, |
| 117 | // since the emitObject() interface is non-const. But We |
| 118 | // promise that there is no way to mutate this object from |
| 119 | // here on out. |
| 120 | return SkRef(const_cast<SkPDFGraphicState*>(canonGS)); |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 121 | } |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 122 | SkPDFGraphicState* pdfGraphicState = new SkPDFGraphicState(paint); |
halcanary | 792c80f | 2015-02-20 07:21:05 -0800 | [diff] [blame] | 123 | canon->addGraphicState(pdfGraphicState); |
halcanary | fb62b3d | 2015-01-21 09:59:14 -0800 | [diff] [blame] | 124 | return pdfGraphicState; |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 125 | } |
| 126 | |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame^] | 127 | sk_sp<SkPDFStream> SkPDFGraphicState::MakeInvertFunction() { |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 128 | // Acrobat crashes if we use a type 0 function, kpdf crashes if we use |
| 129 | // a type 2 function, so we use a type 4 function. |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 130 | auto domainAndRange = sk_make_sp<SkPDFArray>(); |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 131 | domainAndRange->reserve(2); |
| 132 | domainAndRange->appendInt(0); |
| 133 | domainAndRange->appendInt(1); |
| 134 | |
| 135 | static const char psInvert[] = "{1 exch sub}"; |
| 136 | // Do not copy the trailing '\0' into the SkData. |
halcanary | 48810a0 | 2016-03-07 14:57:50 -0800 | [diff] [blame] | 137 | sk_sp<SkData> psInvertStream( |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 138 | SkData::NewWithoutCopy(psInvert, strlen(psInvert))); |
| 139 | |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 140 | auto invertFunction = sk_make_sp<SkPDFStream>(psInvertStream.get()); |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 141 | invertFunction->insertInt("FunctionType", 4); |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 142 | invertFunction->insertObject("Domain", domainAndRange); |
| 143 | invertFunction->insertObject("Range", std::move(domainAndRange)); |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame^] | 144 | return invertFunction; |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 145 | } |
| 146 | |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame^] | 147 | sk_sp<SkPDFDict> SkPDFGraphicState::GetSMaskGraphicState( |
| 148 | SkPDFFormXObject* sMask, |
| 149 | bool invert, |
| 150 | SkPDFSMaskMode sMaskMode, |
| 151 | SkPDFCanon* canon) { |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 152 | // The practical chances of using the same mask more than once are unlikely |
| 153 | // enough that it's not worth canonicalizing. |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 154 | auto sMaskDict = sk_make_sp<SkPDFDict>("Mask"); |
commit-bot@chromium.org | 93a2e21 | 2013-07-23 23:16:03 +0000 | [diff] [blame] | 155 | if (sMaskMode == kAlpha_SMaskMode) { |
| 156 | sMaskDict->insertName("S", "Alpha"); |
| 157 | } else if (sMaskMode == kLuminosity_SMaskMode) { |
| 158 | sMaskDict->insertName("S", "Luminosity"); |
| 159 | } |
halcanary | e94ea62 | 2016-03-09 07:52:09 -0800 | [diff] [blame] | 160 | sMaskDict->insertObjRef("G", sk_ref_sp(sMask)); |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 161 | if (invert) { |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame^] | 162 | // Instead of calling SkPDFGraphicState::MakeInvertFunction, |
| 163 | // let the canon deduplicate this object. |
| 164 | sMaskDict->insertObjRef("TR", canon->makeInvertFunction()); |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 165 | } |
| 166 | |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 167 | auto result = sk_make_sp<SkPDFDict>("ExtGState"); |
halcanary | 8103a34 | 2016-03-08 15:10:16 -0800 | [diff] [blame] | 168 | result->insertObject("SMask", std::move(sMaskDict)); |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame^] | 169 | return result; |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 170 | } |
| 171 | |
halcanary | 1437c1e | 2016-03-13 18:30:24 -0700 | [diff] [blame^] | 172 | sk_sp<SkPDFDict> SkPDFGraphicState::MakeNoSmaskGraphicState() { |
| 173 | auto noSMaskGS = sk_make_sp<SkPDFDict>("ExtGState"); |
halcanary | e6ea244 | 2015-01-21 13:13:22 -0800 | [diff] [blame] | 174 | noSMaskGS->insertName("SMask", "None"); |
| 175 | return noSMaskGS; |
| 176 | } |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 177 | |
halcanary | a060eba | 2015-08-19 12:26:46 -0700 | [diff] [blame] | 178 | void SkPDFGraphicState::emitObject( |
| 179 | SkWStream* stream, |
| 180 | const SkPDFObjNumMap& objNumMap, |
| 181 | const SkPDFSubstituteMap& substitutes) const { |
halcanary | ece8392 | 2016-03-08 08:32:12 -0800 | [diff] [blame] | 182 | auto dict = sk_make_sp<SkPDFDict>("ExtGState"); |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 183 | dict->insertName("Type", "ExtGState"); |
vandebo@chromium.org | 6112c21 | 2011-05-13 03:50:38 +0000 | [diff] [blame] | 184 | |
reed | 80ea19c | 2015-05-12 10:37:34 -0700 | [diff] [blame] | 185 | SkScalar alpha = SkIntToScalar(fAlpha) / 0xFF; |
halcanary | a25b337 | 2015-04-27 14:00:09 -0700 | [diff] [blame] | 186 | dict->insertScalar("CA", alpha); |
| 187 | dict->insertScalar("ca", alpha); |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 188 | |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 189 | SkPaint::Cap strokeCap = (SkPaint::Cap)fStrokeCap; |
| 190 | SkPaint::Join strokeJoin = (SkPaint::Join)fStrokeJoin; |
| 191 | SkXfermode::Mode xferMode = (SkXfermode::Mode)fMode; |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 192 | |
bungeman | 99fe822 | 2015-08-20 07:57:51 -0700 | [diff] [blame] | 193 | static_assert(SkPaint::kButt_Cap == 0, "paint_cap_mismatch"); |
| 194 | static_assert(SkPaint::kRound_Cap == 1, "paint_cap_mismatch"); |
| 195 | static_assert(SkPaint::kSquare_Cap == 2, "paint_cap_mismatch"); |
| 196 | static_assert(SkPaint::kCapCount == 3, "paint_cap_mismatch"); |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 197 | SkASSERT(strokeCap >= 0 && strokeCap <= 2); |
| 198 | dict->insertInt("LC", strokeCap); |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 199 | |
bungeman | 99fe822 | 2015-08-20 07:57:51 -0700 | [diff] [blame] | 200 | static_assert(SkPaint::kMiter_Join == 0, "paint_join_mismatch"); |
| 201 | static_assert(SkPaint::kRound_Join == 1, "paint_join_mismatch"); |
| 202 | static_assert(SkPaint::kBevel_Join == 2, "paint_join_mismatch"); |
| 203 | static_assert(SkPaint::kJoinCount == 3, "paint_join_mismatch"); |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 204 | SkASSERT(strokeJoin >= 0 && strokeJoin <= 2); |
| 205 | dict->insertInt("LJ", strokeJoin); |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 206 | |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 207 | dict->insertScalar("LW", fStrokeWidth); |
| 208 | dict->insertScalar("ML", fStrokeMiter); |
halcanary | a25b337 | 2015-04-27 14:00:09 -0700 | [diff] [blame] | 209 | dict->insertBool("SA", true); // SA = Auto stroke adjustment. |
halcanary | be27a11 | 2015-04-01 13:31:19 -0700 | [diff] [blame] | 210 | dict->insertName("BM", as_blend_mode(xferMode)); |
| 211 | dict->emitObject(stream, objNumMap, substitutes); |
vandebo@chromium.org | 9b49dc0 | 2010-10-20 22:23:29 +0000 | [diff] [blame] | 212 | } |