Home | History | Annotate | Download | only in pdf
      1 
      2 /*
      3  * Copyright 2011 Google Inc.
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 
      9 
     10 #include "SkPDFShader.h"
     11 
     12 #include "SkData.h"
     13 #include "SkPDFCatalog.h"
     14 #include "SkPDFDevice.h"
     15 #include "SkPDFFormXObject.h"
     16 #include "SkPDFGraphicState.h"
     17 #include "SkPDFResourceDict.h"
     18 #include "SkPDFUtils.h"
     19 #include "SkScalar.h"
     20 #include "SkStream.h"
     21 #include "SkTemplates.h"
     22 #include "SkThread.h"
     23 #include "SkTSet.h"
     24 #include "SkTypes.h"
     25 
     26 static bool inverseTransformBBox(const SkMatrix& matrix, SkRect* bbox) {
     27     SkMatrix inverse;
     28     if (!matrix.invert(&inverse)) {
     29         return false;
     30     }
     31     inverse.mapRect(bbox);
     32     return true;
     33 }
     34 
     35 static void unitToPointsMatrix(const SkPoint pts[2], SkMatrix* matrix) {
     36     SkVector    vec = pts[1] - pts[0];
     37     SkScalar    mag = vec.length();
     38     SkScalar    inv = mag ? SkScalarInvert(mag) : 0;
     39 
     40     vec.scale(inv);
     41     matrix->setSinCos(vec.fY, vec.fX);
     42     matrix->preScale(mag, mag);
     43     matrix->postTranslate(pts[0].fX, pts[0].fY);
     44 }
     45 
     46 /* Assumes t + startOffset is on the stack and does a linear interpolation on t
     47    between startOffset and endOffset from prevColor to curColor (for each color
     48    component), leaving the result in component order on the stack. It assumes
     49    there are always 3 components per color.
     50    @param range                  endOffset - startOffset
     51    @param curColor[components]   The current color components.
     52    @param prevColor[components]  The previous color components.
     53    @param result                 The result ps function.
     54  */
     55 static void interpolateColorCode(SkScalar range, SkScalar* curColor,
     56                                  SkScalar* prevColor, SkString* result) {
     57     SkASSERT(range != SkIntToScalar(0));
     58     static const int kColorComponents = 3;
     59 
     60     // Figure out how to scale each color component.
     61     SkScalar multiplier[kColorComponents];
     62     for (int i = 0; i < kColorComponents; i++) {
     63         multiplier[i] = SkScalarDiv(curColor[i] - prevColor[i], range);
     64     }
     65 
     66     // Calculate when we no longer need to keep a copy of the input parameter t.
     67     // If the last component to use t is i, then dupInput[0..i - 1] = true
     68     // and dupInput[i .. components] = false.
     69     bool dupInput[kColorComponents];
     70     dupInput[kColorComponents - 1] = false;
     71     for (int i = kColorComponents - 2; i >= 0; i--) {
     72         dupInput[i] = dupInput[i + 1] || multiplier[i + 1] != 0;
     73     }
     74 
     75     if (!dupInput[0] && multiplier[0] == 0) {
     76         result->append("pop ");
     77     }
     78 
     79     for (int i = 0; i < kColorComponents; i++) {
     80         // If the next components needs t and this component will consume a
     81         // copy, make another copy.
     82         if (dupInput[i] && multiplier[i] != 0) {
     83             result->append("dup ");
     84         }
     85 
     86         if (multiplier[i] == 0) {
     87             result->appendScalar(prevColor[i]);
     88             result->append(" ");
     89         } else {
     90             if (multiplier[i] != 1) {
     91                 result->appendScalar(multiplier[i]);
     92                 result->append(" mul ");
     93             }
     94             if (prevColor[i] != 0) {
     95                 result->appendScalar(prevColor[i]);
     96                 result->append(" add ");
     97             }
     98         }
     99 
    100         if (dupInput[i]) {
    101             result->append("exch\n");
    102         }
    103     }
    104 }
    105 
    106 /* Generate Type 4 function code to map t=[0,1) to the passed gradient,
    107    clamping at the edges of the range.  The generated code will be of the form:
    108        if (t < 0) {
    109            return colorData[0][r,g,b];
    110        } else {
    111            if (t < info.fColorOffsets[1]) {
    112                return linearinterpolation(colorData[0][r,g,b],
    113                                           colorData[1][r,g,b]);
    114            } else {
    115                if (t < info.fColorOffsets[2]) {
    116                    return linearinterpolation(colorData[1][r,g,b],
    117                                               colorData[2][r,g,b]);
    118                } else {
    119 
    120                 ...    } else {
    121                            return colorData[info.fColorCount - 1][r,g,b];
    122                        }
    123                 ...
    124            }
    125        }
    126  */
    127 static void gradientFunctionCode(const SkShader::GradientInfo& info,
    128                                  SkString* result) {
    129     /* We want to linearly interpolate from the previous color to the next.
    130        Scale the colors from 0..255 to 0..1 and determine the multipliers
    131        for interpolation.
    132        C{r,g,b}(t, section) = t - offset_(section-1) + t * Multiplier{r,g,b}.
    133      */
    134     static const int kColorComponents = 3;
    135     typedef SkScalar ColorTuple[kColorComponents];
    136     SkAutoSTMalloc<4, ColorTuple> colorDataAlloc(info.fColorCount);
    137     ColorTuple *colorData = colorDataAlloc.get();
    138     const SkScalar scale = SkScalarInvert(SkIntToScalar(255));
    139     for (int i = 0; i < info.fColorCount; i++) {
    140         colorData[i][0] = SkScalarMul(SkColorGetR(info.fColors[i]), scale);
    141         colorData[i][1] = SkScalarMul(SkColorGetG(info.fColors[i]), scale);
    142         colorData[i][2] = SkScalarMul(SkColorGetB(info.fColors[i]), scale);
    143     }
    144 
    145     // Clamp the initial color.
    146     result->append("dup 0 le {pop ");
    147     result->appendScalar(colorData[0][0]);
    148     result->append(" ");
    149     result->appendScalar(colorData[0][1]);
    150     result->append(" ");
    151     result->appendScalar(colorData[0][2]);
    152     result->append(" }\n");
    153 
    154     // The gradient colors.
    155     int gradients = 0;
    156     for (int i = 1 ; i < info.fColorCount; i++) {
    157         if (info.fColorOffsets[i] == info.fColorOffsets[i - 1]) {
    158             continue;
    159         }
    160         gradients++;
    161 
    162         result->append("{dup ");
    163         result->appendScalar(info.fColorOffsets[i]);
    164         result->append(" le {");
    165         if (info.fColorOffsets[i - 1] != 0) {
    166             result->appendScalar(info.fColorOffsets[i - 1]);
    167             result->append(" sub\n");
    168         }
    169 
    170         interpolateColorCode(info.fColorOffsets[i] - info.fColorOffsets[i - 1],
    171                              colorData[i], colorData[i - 1], result);
    172         result->append("}\n");
    173     }
    174 
    175     // Clamp the final color.
    176     result->append("{pop ");
    177     result->appendScalar(colorData[info.fColorCount - 1][0]);
    178     result->append(" ");
    179     result->appendScalar(colorData[info.fColorCount - 1][1]);
    180     result->append(" ");
    181     result->appendScalar(colorData[info.fColorCount - 1][2]);
    182 
    183     for (int i = 0 ; i < gradients + 1; i++) {
    184         result->append("} ifelse\n");
    185     }
    186 }
    187 
    188 /* Map a value of t on the stack into [0, 1) for Repeat or Mirror tile mode. */
    189 static void tileModeCode(SkShader::TileMode mode, SkString* result) {
    190     if (mode == SkShader::kRepeat_TileMode) {
    191         result->append("dup truncate sub\n");  // Get the fractional part.
    192         result->append("dup 0 le {1 add} if\n");  // Map (-1,0) => (0,1)
    193         return;
    194     }
    195 
    196     if (mode == SkShader::kMirror_TileMode) {
    197         // Map t mod 2 into [0, 1, 1, 0].
    198         //               Code                     Stack
    199         result->append("abs "                 // Map negative to positive.
    200                        "dup "                 // t.s t.s
    201                        "truncate "            // t.s t
    202                        "dup "                 // t.s t t
    203                        "cvi "                 // t.s t T
    204                        "2 mod "               // t.s t (i mod 2)
    205                        "1 eq "                // t.s t true|false
    206                        "3 1 roll "            // true|false t.s t
    207                        "sub "                 // true|false 0.s
    208                        "exch "                // 0.s true|false
    209                        "{1 exch sub} if\n");  // 1 - 0.s|0.s
    210     }
    211 }
    212 
    213 /**
    214  *  Returns PS function code that applies inverse perspective
    215  *  to a x, y point.
    216  *  The function assumes that the stack has at least two elements,
    217  *  and that the top 2 elements are numeric values.
    218  *  After executing this code on a PS stack, the last 2 elements are updated
    219  *  while the rest of the stack is preserved intact.
    220  *  inversePerspectiveMatrix is the inverse perspective matrix.
    221  */
    222 static SkString apply_perspective_to_coordinates(
    223         const SkMatrix& inversePerspectiveMatrix) {
    224     SkString code;
    225     if (!inversePerspectiveMatrix.hasPerspective()) {
    226         return code;
    227     }
    228 
    229     // Perspective matrix should be:
    230     // 1   0  0
    231     // 0   1  0
    232     // p0 p1 p2
    233 
    234     const SkScalar p0 = inversePerspectiveMatrix[SkMatrix::kMPersp0];
    235     const SkScalar p1 = inversePerspectiveMatrix[SkMatrix::kMPersp1];
    236     const SkScalar p2 = inversePerspectiveMatrix[SkMatrix::kMPersp2];
    237 
    238     // y = y / (p2 + p0 x + p1 y)
    239     // x = x / (p2 + p0 x + p1 y)
    240 
    241     // Input on stack: x y
    242     code.append(" dup ");               // x y y
    243     code.appendScalar(p1);              // x y y p1
    244     code.append(" mul "                 // x y y*p1
    245                 " 2 index ");           // x y y*p1 x
    246     code.appendScalar(p0);              // x y y p1 x p0
    247     code.append(" mul ");               // x y y*p1 x*p0
    248     code.appendScalar(p2);              // x y y p1 x*p0 p2
    249     code.append(" add "                 // x y y*p1 x*p0+p2
    250                 "add "                  // x y y*p1+x*p0+p2
    251                 "3 1 roll "             // y*p1+x*p0+p2 x y
    252                 "2 index "              // z x y y*p1+x*p0+p2
    253                 "div "                  // y*p1+x*p0+p2 x y/(y*p1+x*p0+p2)
    254                 "3 1 roll "             // y/(y*p1+x*p0+p2) y*p1+x*p0+p2 x
    255                 "exch "                 // y/(y*p1+x*p0+p2) x y*p1+x*p0+p2
    256                 "div "                  // y/(y*p1+x*p0+p2) x/(y*p1+x*p0+p2)
    257                 "exch\n");              // x/(y*p1+x*p0+p2) y/(y*p1+x*p0+p2)
    258     return code;
    259 }
    260 
    261 static SkString linearCode(const SkShader::GradientInfo& info,
    262                            const SkMatrix& perspectiveRemover) {
    263     SkString function("{");
    264 
    265     function.append(apply_perspective_to_coordinates(perspectiveRemover));
    266 
    267     function.append("pop\n");  // Just ditch the y value.
    268     tileModeCode(info.fTileMode, &function);
    269     gradientFunctionCode(info, &function);
    270     function.append("}");
    271     return function;
    272 }
    273 
    274 static SkString radialCode(const SkShader::GradientInfo& info,
    275                            const SkMatrix& perspectiveRemover) {
    276     SkString function("{");
    277 
    278     function.append(apply_perspective_to_coordinates(perspectiveRemover));
    279 
    280     // Find the distance from the origin.
    281     function.append("dup "      // x y y
    282                     "mul "      // x y^2
    283                     "exch "     // y^2 x
    284                     "dup "      // y^2 x x
    285                     "mul "      // y^2 x^2
    286                     "add "      // y^2+x^2
    287                     "sqrt\n");  // sqrt(y^2+x^2)
    288 
    289     tileModeCode(info.fTileMode, &function);
    290     gradientFunctionCode(info, &function);
    291     function.append("}");
    292     return function;
    293 }
    294 
    295 /* The math here is all based on the description in Two_Point_Radial_Gradient,
    296    with one simplification, the coordinate space has been scaled so that
    297    Dr = 1.  This means we don't need to scale the entire equation by 1/Dr^2.
    298  */
    299 static SkString twoPointRadialCode(const SkShader::GradientInfo& info,
    300                                    const SkMatrix& perspectiveRemover) {
    301     SkScalar dx = info.fPoint[0].fX - info.fPoint[1].fX;
    302     SkScalar dy = info.fPoint[0].fY - info.fPoint[1].fY;
    303     SkScalar sr = info.fRadius[0];
    304     SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) - SK_Scalar1;
    305     bool posRoot = info.fRadius[1] > info.fRadius[0];
    306 
    307     // We start with a stack of (x y), copy it and then consume one copy in
    308     // order to calculate b and the other to calculate c.
    309     SkString function("{");
    310 
    311     function.append(apply_perspective_to_coordinates(perspectiveRemover));
    312 
    313     function.append("2 copy ");
    314 
    315     // Calculate -b and b^2.
    316     function.appendScalar(dy);
    317     function.append(" mul exch ");
    318     function.appendScalar(dx);
    319     function.append(" mul add ");
    320     function.appendScalar(sr);
    321     function.append(" sub 2 mul neg dup dup mul\n");
    322 
    323     // Calculate c
    324     function.append("4 2 roll dup mul exch dup mul add ");
    325     function.appendScalar(SkScalarMul(sr, sr));
    326     function.append(" sub\n");
    327 
    328     // Calculate the determinate
    329     function.appendScalar(SkScalarMul(SkIntToScalar(4), a));
    330     function.append(" mul sub abs sqrt\n");
    331 
    332     // And then the final value of t.
    333     if (posRoot) {
    334         function.append("sub ");
    335     } else {
    336         function.append("add ");
    337     }
    338     function.appendScalar(SkScalarMul(SkIntToScalar(2), a));
    339     function.append(" div\n");
    340 
    341     tileModeCode(info.fTileMode, &function);
    342     gradientFunctionCode(info, &function);
    343     function.append("}");
    344     return function;
    345 }
    346 
    347 /* Conical gradient shader, based on the Canvas spec for radial gradients
    348    See: http://www.w3.org/TR/2dcontext/#dom-context-2d-createradialgradient
    349  */
    350 static SkString twoPointConicalCode(const SkShader::GradientInfo& info,
    351                                     const SkMatrix& perspectiveRemover) {
    352     SkScalar dx = info.fPoint[1].fX - info.fPoint[0].fX;
    353     SkScalar dy = info.fPoint[1].fY - info.fPoint[0].fY;
    354     SkScalar r0 = info.fRadius[0];
    355     SkScalar dr = info.fRadius[1] - info.fRadius[0];
    356     SkScalar a = SkScalarMul(dx, dx) + SkScalarMul(dy, dy) -
    357                  SkScalarMul(dr, dr);
    358 
    359     // First compute t, if the pixel falls outside the cone, then we'll end
    360     // with 'false' on the stack, otherwise we'll push 'true' with t below it
    361 
    362     // We start with a stack of (x y), copy it and then consume one copy in
    363     // order to calculate b and the other to calculate c.
    364     SkString function("{");
    365 
    366     function.append(apply_perspective_to_coordinates(perspectiveRemover));
    367 
    368     function.append("2 copy ");
    369 
    370     // Calculate b and b^2; b = -2 * (y * dy + x * dx + r0 * dr).
    371     function.appendScalar(dy);
    372     function.append(" mul exch ");
    373     function.appendScalar(dx);
    374     function.append(" mul add ");
    375     function.appendScalar(SkScalarMul(r0, dr));
    376     function.append(" add -2 mul dup dup mul\n");
    377 
    378     // c = x^2 + y^2 + radius0^2
    379     function.append("4 2 roll dup mul exch dup mul add ");
    380     function.appendScalar(SkScalarMul(r0, r0));
    381     function.append(" sub dup 4 1 roll\n");
    382 
    383     // Contents of the stack at this point: c, b, b^2, c
    384 
    385     // if a = 0, then we collapse to a simpler linear case
    386     if (a == 0) {
    387 
    388         // t = -c/b
    389         function.append("pop pop div neg dup ");
    390 
    391         // compute radius(t)
    392         function.appendScalar(dr);
    393         function.append(" mul ");
    394         function.appendScalar(r0);
    395         function.append(" add\n");
    396 
    397         // if r(t) < 0, then it's outside the cone
    398         function.append("0 lt {pop false} {true} ifelse\n");
    399 
    400     } else {
    401 
    402         // quadratic case: the Canvas spec wants the largest
    403         // root t for which radius(t) > 0
    404 
    405         // compute the discriminant (b^2 - 4ac)
    406         function.appendScalar(SkScalarMul(SkIntToScalar(4), a));
    407         function.append(" mul sub dup\n");
    408 
    409         // if d >= 0, proceed
    410         function.append("0 ge {\n");
    411 
    412         // an intermediate value we'll use to compute the roots:
    413         // q = -0.5 * (b +/- sqrt(d))
    414         function.append("sqrt exch dup 0 lt {exch -1 mul} if");
    415         function.append(" add -0.5 mul dup\n");
    416 
    417         // first root = q / a
    418         function.appendScalar(a);
    419         function.append(" div\n");
    420 
    421         // second root = c / q
    422         function.append("3 1 roll div\n");
    423 
    424         // put the larger root on top of the stack
    425         function.append("2 copy gt {exch} if\n");
    426 
    427         // compute radius(t) for larger root
    428         function.append("dup ");
    429         function.appendScalar(dr);
    430         function.append(" mul ");
    431         function.appendScalar(r0);
    432         function.append(" add\n");
    433 
    434         // if r(t) > 0, we have our t, pop off the smaller root and we're done
    435         function.append(" 0 gt {exch pop true}\n");
    436 
    437         // otherwise, throw out the larger one and try the smaller root
    438         function.append("{pop dup\n");
    439         function.appendScalar(dr);
    440         function.append(" mul ");
    441         function.appendScalar(r0);
    442         function.append(" add\n");
    443 
    444         // if r(t) < 0, push false, otherwise the smaller root is our t
    445         function.append("0 le {pop false} {true} ifelse\n");
    446         function.append("} ifelse\n");
    447 
    448         // d < 0, clear the stack and push false
    449         function.append("} {pop pop pop false} ifelse\n");
    450     }
    451 
    452     // if the pixel is in the cone, proceed to compute a color
    453     function.append("{");
    454     tileModeCode(info.fTileMode, &function);
    455     gradientFunctionCode(info, &function);
    456 
    457     // otherwise, just write black
    458     function.append("} {0 0 0} ifelse }");
    459 
    460     return function;
    461 }
    462 
    463 static SkString sweepCode(const SkShader::GradientInfo& info,
    464                           const SkMatrix& perspectiveRemover) {
    465     SkString function("{exch atan 360 div\n");
    466     tileModeCode(info.fTileMode, &function);
    467     gradientFunctionCode(info, &function);
    468     function.append("}");
    469     return function;
    470 }
    471 
    472 class SkPDFShader::State {
    473 public:
    474     SkShader::GradientType fType;
    475     SkShader::GradientInfo fInfo;
    476     SkAutoFree fColorData;    // This provides storage for arrays in fInfo.
    477     SkMatrix fCanvasTransform;
    478     SkMatrix fShaderTransform;
    479     SkIRect fBBox;
    480 
    481     SkBitmap fImage;
    482     uint32_t fPixelGeneration;
    483     SkShader::TileMode fImageTileModes[2];
    484 
    485     State(const SkShader& shader, const SkMatrix& canvasTransform,
    486           const SkIRect& bbox);
    487 
    488     bool operator==(const State& b) const;
    489 
    490     SkPDFShader::State* CreateAlphaToLuminosityState() const;
    491     SkPDFShader::State* CreateOpaqueState() const;
    492 
    493     bool GradientHasAlpha() const;
    494 
    495 private:
    496     State(const State& other);
    497     State operator=(const State& rhs);
    498     void AllocateGradientInfoStorage();
    499 };
    500 
    501 class SkPDFFunctionShader : public SkPDFDict, public SkPDFShader {
    502     SK_DECLARE_INST_COUNT(SkPDFFunctionShader)
    503 public:
    504     explicit SkPDFFunctionShader(SkPDFShader::State* state);
    505     virtual ~SkPDFFunctionShader() {
    506         if (isValid()) {
    507             RemoveShader(this);
    508         }
    509         fResources.unrefAll();
    510     }
    511 
    512     virtual bool isValid() { return fResources.count() > 0; }
    513 
    514     void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
    515                       SkTSet<SkPDFObject*>* newResourceObjects) {
    516         GetResourcesHelper(&fResources,
    517                            knownResourceObjects,
    518                            newResourceObjects);
    519     }
    520 
    521 private:
    522     static SkPDFObject* RangeObject();
    523 
    524     SkTDArray<SkPDFObject*> fResources;
    525     SkAutoTDelete<const SkPDFShader::State> fState;
    526 
    527     SkPDFStream* makePSFunction(const SkString& psCode, SkPDFArray* domain);
    528     typedef SkPDFDict INHERITED;
    529 };
    530 
    531 /**
    532  * A shader for PDF gradients. This encapsulates the function shader
    533  * inside a tiling pattern while providing a common pattern interface.
    534  * The encapsulation allows the use of a SMask for transparency gradients.
    535  */
    536 class SkPDFAlphaFunctionShader : public SkPDFStream, public SkPDFShader {
    537 public:
    538     explicit SkPDFAlphaFunctionShader(SkPDFShader::State* state);
    539     virtual ~SkPDFAlphaFunctionShader() {
    540         if (isValid()) {
    541             RemoveShader(this);
    542         }
    543     }
    544 
    545     virtual bool isValid() {
    546         return fColorShader.get() != NULL;
    547     }
    548 
    549 private:
    550     SkAutoTDelete<const SkPDFShader::State> fState;
    551 
    552     SkPDFGraphicState* CreateSMaskGraphicState();
    553 
    554     void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
    555                       SkTSet<SkPDFObject*>* newResourceObjects) {
    556         fResourceDict->getReferencedResources(knownResourceObjects,
    557                                               newResourceObjects,
    558                                               true);
    559     }
    560 
    561     SkAutoTUnref<SkPDFObject> fColorShader;
    562     SkAutoTUnref<SkPDFResourceDict> fResourceDict;
    563 };
    564 
    565 class SkPDFImageShader : public SkPDFStream, public SkPDFShader {
    566 public:
    567     explicit SkPDFImageShader(SkPDFShader::State* state);
    568     virtual ~SkPDFImageShader() {
    569         if (isValid()) {
    570             RemoveShader(this);
    571         }
    572         fResources.unrefAll();
    573     }
    574 
    575     virtual bool isValid() { return size() > 0; }
    576 
    577     void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
    578                       SkTSet<SkPDFObject*>* newResourceObjects) {
    579         GetResourcesHelper(&fResources.toArray(),
    580                            knownResourceObjects,
    581                            newResourceObjects);
    582     }
    583 
    584 private:
    585     SkTSet<SkPDFObject*> fResources;
    586     SkAutoTDelete<const SkPDFShader::State> fState;
    587 };
    588 
    589 SkPDFShader::SkPDFShader() {}
    590 
    591 // static
    592 SkPDFObject* SkPDFShader::GetPDFShaderByState(State* inState) {
    593     SkPDFObject* result;
    594 
    595     SkAutoTDelete<State> shaderState(inState);
    596     if (shaderState.get()->fType == SkShader::kNone_GradientType &&
    597             shaderState.get()->fImage.isNull()) {
    598         // TODO(vandebo) This drops SKComposeShader on the floor.  We could
    599         // handle compose shader by pulling things up to a layer, drawing with
    600         // the first shader, applying the xfer mode and drawing again with the
    601         // second shader, then applying the layer to the original drawing.
    602         return NULL;
    603     }
    604 
    605     ShaderCanonicalEntry entry(NULL, shaderState.get());
    606     int index = CanonicalShaders().find(entry);
    607     if (index >= 0) {
    608         result = CanonicalShaders()[index].fPDFShader;
    609         result->ref();
    610         return result;
    611     }
    612 
    613     bool valid = false;
    614     // The PDFShader takes ownership of the shaderSate.
    615     if (shaderState.get()->fType == SkShader::kNone_GradientType) {
    616         SkPDFImageShader* imageShader =
    617             new SkPDFImageShader(shaderState.detach());
    618         valid = imageShader->isValid();
    619         result = imageShader;
    620     } else {
    621         if (shaderState.get()->GradientHasAlpha()) {
    622             SkPDFAlphaFunctionShader* gradientShader =
    623                 SkNEW_ARGS(SkPDFAlphaFunctionShader, (shaderState.detach()));
    624             valid = gradientShader->isValid();
    625             result = gradientShader;
    626         } else {
    627             SkPDFFunctionShader* functionShader =
    628                 SkNEW_ARGS(SkPDFFunctionShader, (shaderState.detach()));
    629             valid = functionShader->isValid();
    630             result = functionShader;
    631         }
    632     }
    633     if (!valid) {
    634         delete result;
    635         return NULL;
    636     }
    637     entry.fPDFShader = result;
    638     CanonicalShaders().push(entry);
    639     return result;  // return the reference that came from new.
    640 }
    641 
    642 // static
    643 void SkPDFShader::RemoveShader(SkPDFObject* shader) {
    644     SkAutoMutexAcquire lock(CanonicalShadersMutex());
    645     ShaderCanonicalEntry entry(shader, NULL);
    646     int index = CanonicalShaders().find(entry);
    647     SkASSERT(index >= 0);
    648     CanonicalShaders().removeShuffle(index);
    649 }
    650 
    651 // static
    652 SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
    653                                        const SkMatrix& matrix,
    654                                        const SkIRect& surfaceBBox) {
    655     SkAutoMutexAcquire lock(CanonicalShadersMutex());
    656     return GetPDFShaderByState(
    657             SkNEW_ARGS(State, (shader, matrix, surfaceBBox)));
    658 }
    659 
    660 // static
    661 SkTDArray<SkPDFShader::ShaderCanonicalEntry>& SkPDFShader::CanonicalShaders() {
    662     // This initialization is only thread safe with gcc.
    663     static SkTDArray<ShaderCanonicalEntry> gCanonicalShaders;
    664     return gCanonicalShaders;
    665 }
    666 
    667 // static
    668 SkBaseMutex& SkPDFShader::CanonicalShadersMutex() {
    669     // This initialization is only thread safe with gcc or when
    670     // POD-style mutex initialization is used.
    671     SK_DECLARE_STATIC_MUTEX(gCanonicalShadersMutex);
    672     return gCanonicalShadersMutex;
    673 }
    674 
    675 // static
    676 SkPDFObject* SkPDFFunctionShader::RangeObject() {
    677     // This initialization is only thread safe with gcc.
    678     static SkPDFArray* range = NULL;
    679     // This method is only used with CanonicalShadersMutex, so it's safe to
    680     // populate domain.
    681     if (range == NULL) {
    682         range = new SkPDFArray;
    683         range->reserve(6);
    684         range->appendInt(0);
    685         range->appendInt(1);
    686         range->appendInt(0);
    687         range->appendInt(1);
    688         range->appendInt(0);
    689         range->appendInt(1);
    690     }
    691     return range;
    692 }
    693 
    694 static SkPDFResourceDict* get_gradient_resource_dict(
    695         SkPDFObject* functionShader,
    696         SkPDFObject* gState) {
    697     SkPDFResourceDict* dict = new SkPDFResourceDict();
    698 
    699     if (functionShader != NULL) {
    700         dict->insertResourceAsReference(
    701                 SkPDFResourceDict::kPattern_ResourceType, 0, functionShader);
    702     }
    703     if (gState != NULL) {
    704         dict->insertResourceAsReference(
    705                 SkPDFResourceDict::kExtGState_ResourceType, 0, gState);
    706     }
    707 
    708     return dict;
    709 }
    710 
    711 static void populate_tiling_pattern_dict(SkPDFDict* pattern,
    712                                       SkRect& bbox, SkPDFDict* resources,
    713                                       const SkMatrix& matrix) {
    714     const int kTiling_PatternType = 1;
    715     const int kColoredTilingPattern_PaintType = 1;
    716     const int kConstantSpacing_TilingType = 1;
    717 
    718     pattern->insertName("Type", "Pattern");
    719     pattern->insertInt("PatternType", kTiling_PatternType);
    720     pattern->insertInt("PaintType", kColoredTilingPattern_PaintType);
    721     pattern->insertInt("TilingType", kConstantSpacing_TilingType);
    722     pattern->insert("BBox", SkPDFUtils::RectToArray(bbox))->unref();
    723     pattern->insertScalar("XStep", bbox.width());
    724     pattern->insertScalar("YStep", bbox.height());
    725     pattern->insert("Resources", resources);
    726     if (!matrix.isIdentity()) {
    727         pattern->insert("Matrix", SkPDFUtils::MatrixToArray(matrix))->unref();
    728     }
    729 }
    730 
    731 /**
    732  * Creates a content stream which fills the pattern P0 across bounds.
    733  * @param gsIndex A graphics state resource index to apply, or <0 if no
    734  * graphics state to apply.
    735  */
    736 static SkStream* create_pattern_fill_content(int gsIndex, SkRect& bounds) {
    737     SkDynamicMemoryWStream content;
    738     if (gsIndex >= 0) {
    739         SkPDFUtils::ApplyGraphicState(gsIndex, &content);
    740     }
    741     SkPDFUtils::ApplyPattern(0, &content);
    742     SkPDFUtils::AppendRectangle(bounds, &content);
    743     SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kEvenOdd_FillType,
    744                           &content);
    745 
    746     return content.detachAsStream();
    747 }
    748 
    749 /**
    750  * Creates a ExtGState with the SMask set to the luminosityShader in
    751  * luminosity mode. The shader pattern extends to the bbox.
    752  */
    753 SkPDFGraphicState* SkPDFAlphaFunctionShader::CreateSMaskGraphicState() {
    754     SkRect bbox;
    755     bbox.set(fState.get()->fBBox);
    756 
    757     SkAutoTUnref<SkPDFObject> luminosityShader(
    758             SkPDFShader::GetPDFShaderByState(
    759                  fState->CreateAlphaToLuminosityState()));
    760 
    761     SkAutoTUnref<SkStream> alphaStream(create_pattern_fill_content(-1, bbox));
    762 
    763     SkAutoTUnref<SkPDFResourceDict>
    764         resources(get_gradient_resource_dict(luminosityShader, NULL));
    765 
    766     SkAutoTUnref<SkPDFFormXObject> alphaMask(
    767             new SkPDFFormXObject(alphaStream.get(), bbox, resources.get()));
    768 
    769     return SkPDFGraphicState::GetSMaskGraphicState(
    770             alphaMask.get(), false,
    771             SkPDFGraphicState::kLuminosity_SMaskMode);
    772 }
    773 
    774 SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
    775         : fState(state) {
    776     SkRect bbox;
    777     bbox.set(fState.get()->fBBox);
    778 
    779     fColorShader.reset(
    780             SkPDFShader::GetPDFShaderByState(state->CreateOpaqueState()));
    781 
    782     // Create resource dict with alpha graphics state as G0 and
    783     // pattern shader as P0, then write content stream.
    784     SkAutoTUnref<SkPDFGraphicState> alphaGs(CreateSMaskGraphicState());
    785     fResourceDict.reset(
    786             get_gradient_resource_dict(fColorShader.get(), alphaGs.get()));
    787 
    788     SkAutoTUnref<SkStream> colorStream(
    789             create_pattern_fill_content(0, bbox));
    790     setData(colorStream.get());
    791 
    792     populate_tiling_pattern_dict(this, bbox, fResourceDict.get(),
    793                                  SkMatrix::I());
    794 }
    795 
    796 // Finds affine and persp such that in = affine * persp.
    797 // but it returns the inverse of perspective matrix.
    798 static bool split_perspective(const SkMatrix in, SkMatrix* affine,
    799                               SkMatrix* perspectiveInverse) {
    800     const SkScalar p2 = in[SkMatrix::kMPersp2];
    801 
    802     if (SkScalarNearlyZero(p2)) {
    803         return false;
    804     }
    805 
    806     const SkScalar zero = SkIntToScalar(0);
    807     const SkScalar one = SkIntToScalar(1);
    808 
    809     const SkScalar sx = in[SkMatrix::kMScaleX];
    810     const SkScalar kx = in[SkMatrix::kMSkewX];
    811     const SkScalar tx = in[SkMatrix::kMTransX];
    812     const SkScalar ky = in[SkMatrix::kMSkewY];
    813     const SkScalar sy = in[SkMatrix::kMScaleY];
    814     const SkScalar ty = in[SkMatrix::kMTransY];
    815     const SkScalar p0 = in[SkMatrix::kMPersp0];
    816     const SkScalar p1 = in[SkMatrix::kMPersp1];
    817 
    818     // Perspective matrix would be:
    819     // 1  0  0
    820     // 0  1  0
    821     // p0 p1 p2
    822     // But we need the inverse of persp.
    823     perspectiveInverse->setAll(one,          zero,       zero,
    824                                zero,         one,        zero,
    825                                -p0/p2,     -p1/p2,     1/p2);
    826 
    827     affine->setAll(sx - p0 * tx / p2,       kx - p1 * tx / p2,      tx / p2,
    828                    ky - p0 * ty / p2,       sy - p1 * ty / p2,      ty / p2,
    829                    zero,                    zero,                   one);
    830 
    831     return true;
    832 }
    833 
    834 SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
    835         : SkPDFDict("Pattern"),
    836           fState(state) {
    837     SkString (*codeFunction)(const SkShader::GradientInfo& info,
    838                              const SkMatrix& perspectiveRemover) = NULL;
    839     SkPoint transformPoints[2];
    840 
    841     // Depending on the type of the gradient, we want to transform the
    842     // coordinate space in different ways.
    843     const SkShader::GradientInfo* info = &fState.get()->fInfo;
    844     transformPoints[0] = info->fPoint[0];
    845     transformPoints[1] = info->fPoint[1];
    846     switch (fState.get()->fType) {
    847         case SkShader::kLinear_GradientType:
    848             codeFunction = &linearCode;
    849             break;
    850         case SkShader::kRadial_GradientType:
    851             transformPoints[1] = transformPoints[0];
    852             transformPoints[1].fX += info->fRadius[0];
    853             codeFunction = &radialCode;
    854             break;
    855         case SkShader::kRadial2_GradientType: {
    856             // Bail out if the radii are the same.  Empty fResources signals
    857             // an error and isValid will return false.
    858             if (info->fRadius[0] == info->fRadius[1]) {
    859                 return;
    860             }
    861             transformPoints[1] = transformPoints[0];
    862             SkScalar dr = info->fRadius[1] - info->fRadius[0];
    863             transformPoints[1].fX += dr;
    864             codeFunction = &twoPointRadialCode;
    865             break;
    866         }
    867         case SkShader::kConical_GradientType: {
    868             transformPoints[1] = transformPoints[0];
    869             transformPoints[1].fX += SK_Scalar1;
    870             codeFunction = &twoPointConicalCode;
    871             break;
    872         }
    873         case SkShader::kSweep_GradientType:
    874             transformPoints[1] = transformPoints[0];
    875             transformPoints[1].fX += SK_Scalar1;
    876             codeFunction = &sweepCode;
    877             break;
    878         case SkShader::kColor_GradientType:
    879         case SkShader::kNone_GradientType:
    880         default:
    881             return;
    882     }
    883 
    884     // Move any scaling (assuming a unit gradient) or translation
    885     // (and rotation for linear gradient), of the final gradient from
    886     // info->fPoints to the matrix (updating bbox appropriately).  Now
    887     // the gradient can be drawn on on the unit segment.
    888     SkMatrix mapperMatrix;
    889     unitToPointsMatrix(transformPoints, &mapperMatrix);
    890 
    891     SkMatrix finalMatrix = fState.get()->fCanvasTransform;
    892     finalMatrix.preConcat(fState.get()->fShaderTransform);
    893     finalMatrix.preConcat(mapperMatrix);
    894 
    895     // Preserves as much as posible in the final matrix, and only removes
    896     // the perspective. The inverse of the perspective is stored in
    897     // perspectiveInverseOnly matrix and has 3 useful numbers
    898     // (p0, p1, p2), while everything else is either 0 or 1.
    899     // In this way the shader will handle it eficiently, with minimal code.
    900     SkMatrix perspectiveInverseOnly = SkMatrix::I();
    901     if (finalMatrix.hasPerspective()) {
    902         if (!split_perspective(finalMatrix,
    903                                &finalMatrix, &perspectiveInverseOnly)) {
    904             return;
    905         }
    906     }
    907 
    908     SkRect bbox;
    909     bbox.set(fState.get()->fBBox);
    910     if (!inverseTransformBBox(finalMatrix, &bbox)) {
    911         return;
    912     }
    913 
    914     SkAutoTUnref<SkPDFArray> domain(new SkPDFArray);
    915     domain->reserve(4);
    916     domain->appendScalar(bbox.fLeft);
    917     domain->appendScalar(bbox.fRight);
    918     domain->appendScalar(bbox.fTop);
    919     domain->appendScalar(bbox.fBottom);
    920 
    921     SkString functionCode;
    922     // The two point radial gradient further references fState.get()->fInfo
    923     // in translating from x, y coordinates to the t parameter. So, we have
    924     // to transform the points and radii according to the calculated matrix.
    925     if (fState.get()->fType == SkShader::kRadial2_GradientType) {
    926         SkShader::GradientInfo twoPointRadialInfo = *info;
    927         SkMatrix inverseMapperMatrix;
    928         if (!mapperMatrix.invert(&inverseMapperMatrix)) {
    929             return;
    930         }
    931         inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
    932         twoPointRadialInfo.fRadius[0] =
    933             inverseMapperMatrix.mapRadius(info->fRadius[0]);
    934         twoPointRadialInfo.fRadius[1] =
    935             inverseMapperMatrix.mapRadius(info->fRadius[1]);
    936         functionCode = codeFunction(twoPointRadialInfo, perspectiveInverseOnly);
    937     } else {
    938         functionCode = codeFunction(*info, perspectiveInverseOnly);
    939     }
    940 
    941     SkAutoTUnref<SkPDFDict> pdfShader(new SkPDFDict);
    942     pdfShader->insertInt("ShadingType", 1);
    943     pdfShader->insertName("ColorSpace", "DeviceRGB");
    944     pdfShader->insert("Domain", domain.get());
    945 
    946     SkPDFStream* function = makePSFunction(functionCode, domain.get());
    947     pdfShader->insert("Function", new SkPDFObjRef(function))->unref();
    948     fResources.push(function);  // Pass ownership to resource list.
    949 
    950     insertInt("PatternType", 2);
    951     insert("Matrix", SkPDFUtils::MatrixToArray(finalMatrix))->unref();
    952     insert("Shading", pdfShader.get());
    953 }
    954 
    955 SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state) : fState(state) {
    956     fState.get()->fImage.lockPixels();
    957 
    958     // The image shader pattern cell will be drawn into a separate device
    959     // in pattern cell space (no scaling on the bitmap, though there may be
    960     // translations so that all content is in the device, coordinates > 0).
    961 
    962     // Map clip bounds to shader space to ensure the device is large enough
    963     // to handle fake clamping.
    964     SkMatrix finalMatrix = fState.get()->fCanvasTransform;
    965     finalMatrix.preConcat(fState.get()->fShaderTransform);
    966     SkRect deviceBounds;
    967     deviceBounds.set(fState.get()->fBBox);
    968     if (!inverseTransformBBox(finalMatrix, &deviceBounds)) {
    969         return;
    970     }
    971 
    972     const SkBitmap* image = &fState.get()->fImage;
    973     SkRect bitmapBounds;
    974     image->getBounds(&bitmapBounds);
    975 
    976     // For tiling modes, the bounds should be extended to include the bitmap,
    977     // otherwise the bitmap gets clipped out and the shader is empty and awful.
    978     // For clamp modes, we're only interested in the clip region, whether
    979     // or not the main bitmap is in it.
    980     SkShader::TileMode tileModes[2];
    981     tileModes[0] = fState.get()->fImageTileModes[0];
    982     tileModes[1] = fState.get()->fImageTileModes[1];
    983     if (tileModes[0] != SkShader::kClamp_TileMode ||
    984             tileModes[1] != SkShader::kClamp_TileMode) {
    985         deviceBounds.join(bitmapBounds);
    986     }
    987 
    988     SkMatrix unflip;
    989     unflip.setTranslate(0, SkScalarRoundToScalar(deviceBounds.height()));
    990     unflip.preScale(SK_Scalar1, -SK_Scalar1);
    991     SkISize size = SkISize::Make(SkScalarRoundToInt(deviceBounds.width()),
    992                                  SkScalarRoundToInt(deviceBounds.height()));
    993     // TODO(edisonn): should we pass here the DCT encoder of the destination device?
    994     // TODO(edisonn): NYI Perspective, use SkPDFDeviceFlattener.
    995     SkPDFDevice pattern(size, size, unflip);
    996     SkCanvas canvas(&pattern);
    997 
    998     SkRect patternBBox;
    999     image->getBounds(&patternBBox);
   1000 
   1001     // Translate the canvas so that the bitmap origin is at (0, 0).
   1002     canvas.translate(-deviceBounds.left(), -deviceBounds.top());
   1003     patternBBox.offset(-deviceBounds.left(), -deviceBounds.top());
   1004     // Undo the translation in the final matrix
   1005     finalMatrix.preTranslate(deviceBounds.left(), deviceBounds.top());
   1006 
   1007     // If the bitmap is out of bounds (i.e. clamp mode where we only see the
   1008     // stretched sides), canvas will clip this out and the extraneous data
   1009     // won't be saved to the PDF.
   1010     canvas.drawBitmap(*image, 0, 0);
   1011 
   1012     SkScalar width = SkIntToScalar(image->width());
   1013     SkScalar height = SkIntToScalar(image->height());
   1014 
   1015     // Tiling is implied.  First we handle mirroring.
   1016     if (tileModes[0] == SkShader::kMirror_TileMode) {
   1017         SkMatrix xMirror;
   1018         xMirror.setScale(-1, 1);
   1019         xMirror.postTranslate(2 * width, 0);
   1020         canvas.drawBitmapMatrix(*image, xMirror);
   1021         patternBBox.fRight += width;
   1022     }
   1023     if (tileModes[1] == SkShader::kMirror_TileMode) {
   1024         SkMatrix yMirror;
   1025         yMirror.setScale(SK_Scalar1, -SK_Scalar1);
   1026         yMirror.postTranslate(0, 2 * height);
   1027         canvas.drawBitmapMatrix(*image, yMirror);
   1028         patternBBox.fBottom += height;
   1029     }
   1030     if (tileModes[0] == SkShader::kMirror_TileMode &&
   1031             tileModes[1] == SkShader::kMirror_TileMode) {
   1032         SkMatrix mirror;
   1033         mirror.setScale(-1, -1);
   1034         mirror.postTranslate(2 * width, 2 * height);
   1035         canvas.drawBitmapMatrix(*image, mirror);
   1036     }
   1037 
   1038     // Then handle Clamping, which requires expanding the pattern canvas to
   1039     // cover the entire surfaceBBox.
   1040 
   1041     // If both x and y are in clamp mode, we start by filling in the corners.
   1042     // (Which are just a rectangles of the corner colors.)
   1043     if (tileModes[0] == SkShader::kClamp_TileMode &&
   1044             tileModes[1] == SkShader::kClamp_TileMode) {
   1045         SkPaint paint;
   1046         SkRect rect;
   1047         rect = SkRect::MakeLTRB(deviceBounds.left(), deviceBounds.top(), 0, 0);
   1048         if (!rect.isEmpty()) {
   1049             paint.setColor(image->getColor(0, 0));
   1050             canvas.drawRect(rect, paint);
   1051         }
   1052 
   1053         rect = SkRect::MakeLTRB(width, deviceBounds.top(),
   1054                                 deviceBounds.right(), 0);
   1055         if (!rect.isEmpty()) {
   1056             paint.setColor(image->getColor(image->width() - 1, 0));
   1057             canvas.drawRect(rect, paint);
   1058         }
   1059 
   1060         rect = SkRect::MakeLTRB(width, height,
   1061                                 deviceBounds.right(), deviceBounds.bottom());
   1062         if (!rect.isEmpty()) {
   1063             paint.setColor(image->getColor(image->width() - 1,
   1064                                            image->height() - 1));
   1065             canvas.drawRect(rect, paint);
   1066         }
   1067 
   1068         rect = SkRect::MakeLTRB(deviceBounds.left(), height,
   1069                                 0, deviceBounds.bottom());
   1070         if (!rect.isEmpty()) {
   1071             paint.setColor(image->getColor(0, image->height() - 1));
   1072             canvas.drawRect(rect, paint);
   1073         }
   1074     }
   1075 
   1076     // Then expand the left, right, top, then bottom.
   1077     if (tileModes[0] == SkShader::kClamp_TileMode) {
   1078         SkIRect subset = SkIRect::MakeXYWH(0, 0, 1, image->height());
   1079         if (deviceBounds.left() < 0) {
   1080             SkBitmap left;
   1081             SkAssertResult(image->extractSubset(&left, subset));
   1082 
   1083             SkMatrix leftMatrix;
   1084             leftMatrix.setScale(-deviceBounds.left(), 1);
   1085             leftMatrix.postTranslate(deviceBounds.left(), 0);
   1086             canvas.drawBitmapMatrix(left, leftMatrix);
   1087 
   1088             if (tileModes[1] == SkShader::kMirror_TileMode) {
   1089                 leftMatrix.postScale(SK_Scalar1, -SK_Scalar1);
   1090                 leftMatrix.postTranslate(0, 2 * height);
   1091                 canvas.drawBitmapMatrix(left, leftMatrix);
   1092             }
   1093             patternBBox.fLeft = 0;
   1094         }
   1095 
   1096         if (deviceBounds.right() > width) {
   1097             SkBitmap right;
   1098             subset.offset(image->width() - 1, 0);
   1099             SkAssertResult(image->extractSubset(&right, subset));
   1100 
   1101             SkMatrix rightMatrix;
   1102             rightMatrix.setScale(deviceBounds.right() - width, 1);
   1103             rightMatrix.postTranslate(width, 0);
   1104             canvas.drawBitmapMatrix(right, rightMatrix);
   1105 
   1106             if (tileModes[1] == SkShader::kMirror_TileMode) {
   1107                 rightMatrix.postScale(SK_Scalar1, -SK_Scalar1);
   1108                 rightMatrix.postTranslate(0, 2 * height);
   1109                 canvas.drawBitmapMatrix(right, rightMatrix);
   1110             }
   1111             patternBBox.fRight = deviceBounds.width();
   1112         }
   1113     }
   1114 
   1115     if (tileModes[1] == SkShader::kClamp_TileMode) {
   1116         SkIRect subset = SkIRect::MakeXYWH(0, 0, image->width(), 1);
   1117         if (deviceBounds.top() < 0) {
   1118             SkBitmap top;
   1119             SkAssertResult(image->extractSubset(&top, subset));
   1120 
   1121             SkMatrix topMatrix;
   1122             topMatrix.setScale(SK_Scalar1, -deviceBounds.top());
   1123             topMatrix.postTranslate(0, deviceBounds.top());
   1124             canvas.drawBitmapMatrix(top, topMatrix);
   1125 
   1126             if (tileModes[0] == SkShader::kMirror_TileMode) {
   1127                 topMatrix.postScale(-1, 1);
   1128                 topMatrix.postTranslate(2 * width, 0);
   1129                 canvas.drawBitmapMatrix(top, topMatrix);
   1130             }
   1131             patternBBox.fTop = 0;
   1132         }
   1133 
   1134         if (deviceBounds.bottom() > height) {
   1135             SkBitmap bottom;
   1136             subset.offset(0, image->height() - 1);
   1137             SkAssertResult(image->extractSubset(&bottom, subset));
   1138 
   1139             SkMatrix bottomMatrix;
   1140             bottomMatrix.setScale(SK_Scalar1, deviceBounds.bottom() - height);
   1141             bottomMatrix.postTranslate(0, height);
   1142             canvas.drawBitmapMatrix(bottom, bottomMatrix);
   1143 
   1144             if (tileModes[0] == SkShader::kMirror_TileMode) {
   1145                 bottomMatrix.postScale(-1, 1);
   1146                 bottomMatrix.postTranslate(2 * width, 0);
   1147                 canvas.drawBitmapMatrix(bottom, bottomMatrix);
   1148             }
   1149             patternBBox.fBottom = deviceBounds.height();
   1150         }
   1151     }
   1152 
   1153     // Put the canvas into the pattern stream (fContent).
   1154     SkAutoTUnref<SkStream> content(pattern.content());
   1155     setData(content.get());
   1156     SkPDFResourceDict* resourceDict = pattern.getResourceDict();
   1157     resourceDict->getReferencedResources(fResources, &fResources, false);
   1158 
   1159     populate_tiling_pattern_dict(this, patternBBox,
   1160                                  pattern.getResourceDict(), finalMatrix);
   1161 
   1162     fState.get()->fImage.unlockPixels();
   1163 }
   1164 
   1165 SkPDFStream* SkPDFFunctionShader::makePSFunction(const SkString& psCode,
   1166                                                  SkPDFArray* domain) {
   1167     SkAutoDataUnref funcData(SkData::NewWithCopy(psCode.c_str(),
   1168                                                  psCode.size()));
   1169     SkPDFStream* result = new SkPDFStream(funcData.get());
   1170     result->insertInt("FunctionType", 4);
   1171     result->insert("Domain", domain);
   1172     result->insert("Range", RangeObject());
   1173     return result;
   1174 }
   1175 
   1176 SkPDFShader::ShaderCanonicalEntry::ShaderCanonicalEntry(SkPDFObject* pdfShader,
   1177                                                         const State* state)
   1178     : fPDFShader(pdfShader),
   1179       fState(state) {
   1180 }
   1181 
   1182 bool SkPDFShader::ShaderCanonicalEntry::operator==(
   1183         const ShaderCanonicalEntry& b) const {
   1184     return fPDFShader == b.fPDFShader ||
   1185            (fState != NULL && b.fState != NULL && *fState == *b.fState);
   1186 }
   1187 
   1188 bool SkPDFShader::State::operator==(const SkPDFShader::State& b) const {
   1189     if (fType != b.fType ||
   1190             fCanvasTransform != b.fCanvasTransform ||
   1191             fShaderTransform != b.fShaderTransform ||
   1192             fBBox != b.fBBox) {
   1193         return false;
   1194     }
   1195 
   1196     if (fType == SkShader::kNone_GradientType) {
   1197         if (fPixelGeneration != b.fPixelGeneration ||
   1198                 fPixelGeneration == 0 ||
   1199                 fImageTileModes[0] != b.fImageTileModes[0] ||
   1200                 fImageTileModes[1] != b.fImageTileModes[1]) {
   1201             return false;
   1202         }
   1203     } else {
   1204         if (fInfo.fColorCount != b.fInfo.fColorCount ||
   1205                 memcmp(fInfo.fColors, b.fInfo.fColors,
   1206                        sizeof(SkColor) * fInfo.fColorCount) != 0 ||
   1207                 memcmp(fInfo.fColorOffsets, b.fInfo.fColorOffsets,
   1208                        sizeof(SkScalar) * fInfo.fColorCount) != 0 ||
   1209                 fInfo.fPoint[0] != b.fInfo.fPoint[0] ||
   1210                 fInfo.fTileMode != b.fInfo.fTileMode) {
   1211             return false;
   1212         }
   1213 
   1214         switch (fType) {
   1215             case SkShader::kLinear_GradientType:
   1216                 if (fInfo.fPoint[1] != b.fInfo.fPoint[1]) {
   1217                     return false;
   1218                 }
   1219                 break;
   1220             case SkShader::kRadial_GradientType:
   1221                 if (fInfo.fRadius[0] != b.fInfo.fRadius[0]) {
   1222                     return false;
   1223                 }
   1224                 break;
   1225             case SkShader::kRadial2_GradientType:
   1226             case SkShader::kConical_GradientType:
   1227                 if (fInfo.fPoint[1] != b.fInfo.fPoint[1] ||
   1228                         fInfo.fRadius[0] != b.fInfo.fRadius[0] ||
   1229                         fInfo.fRadius[1] != b.fInfo.fRadius[1]) {
   1230                     return false;
   1231                 }
   1232                 break;
   1233             case SkShader::kSweep_GradientType:
   1234             case SkShader::kNone_GradientType:
   1235             case SkShader::kColor_GradientType:
   1236                 break;
   1237         }
   1238     }
   1239     return true;
   1240 }
   1241 
   1242 SkPDFShader::State::State(const SkShader& shader,
   1243                           const SkMatrix& canvasTransform, const SkIRect& bbox)
   1244         : fCanvasTransform(canvasTransform),
   1245           fBBox(bbox),
   1246           fPixelGeneration(0) {
   1247     fInfo.fColorCount = 0;
   1248     fInfo.fColors = NULL;
   1249     fInfo.fColorOffsets = NULL;
   1250     fShaderTransform = shader.getLocalMatrix();
   1251     fImageTileModes[0] = fImageTileModes[1] = SkShader::kClamp_TileMode;
   1252 
   1253     fType = shader.asAGradient(&fInfo);
   1254 
   1255     if (fType == SkShader::kNone_GradientType) {
   1256         SkShader::BitmapType bitmapType;
   1257         SkMatrix matrix;
   1258         bitmapType = shader.asABitmap(&fImage, &matrix, fImageTileModes);
   1259         if (bitmapType != SkShader::kDefault_BitmapType) {
   1260             fImage.reset();
   1261             return;
   1262         }
   1263         SkASSERT(matrix.isIdentity());
   1264         fPixelGeneration = fImage.getGenerationID();
   1265     } else {
   1266         AllocateGradientInfoStorage();
   1267         shader.asAGradient(&fInfo);
   1268     }
   1269 }
   1270 
   1271 SkPDFShader::State::State(const SkPDFShader::State& other)
   1272   : fType(other.fType),
   1273     fCanvasTransform(other.fCanvasTransform),
   1274     fShaderTransform(other.fShaderTransform),
   1275     fBBox(other.fBBox)
   1276 {
   1277     // Only gradients supported for now, since that is all that is used.
   1278     // If needed, image state copy constructor can be added here later.
   1279     SkASSERT(fType != SkShader::kNone_GradientType);
   1280 
   1281     if (fType != SkShader::kNone_GradientType) {
   1282         fInfo = other.fInfo;
   1283 
   1284         AllocateGradientInfoStorage();
   1285         for (int i = 0; i < fInfo.fColorCount; i++) {
   1286             fInfo.fColors[i] = other.fInfo.fColors[i];
   1287             fInfo.fColorOffsets[i] = other.fInfo.fColorOffsets[i];
   1288         }
   1289     }
   1290 }
   1291 
   1292 /**
   1293  * Create a copy of this gradient state with alpha assigned to RGB luminousity.
   1294  * Only valid for gradient states.
   1295  */
   1296 SkPDFShader::State* SkPDFShader::State::CreateAlphaToLuminosityState() const {
   1297     SkASSERT(fType != SkShader::kNone_GradientType);
   1298 
   1299     SkPDFShader::State* newState = new SkPDFShader::State(*this);
   1300 
   1301     for (int i = 0; i < fInfo.fColorCount; i++) {
   1302         SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
   1303         newState->fInfo.fColors[i] = SkColorSetARGB(255, alpha, alpha, alpha);
   1304     }
   1305 
   1306     return newState;
   1307 }
   1308 
   1309 /**
   1310  * Create a copy of this gradient state with alpha set to fully opaque
   1311  * Only valid for gradient states.
   1312  */
   1313 SkPDFShader::State* SkPDFShader::State::CreateOpaqueState() const {
   1314     SkASSERT(fType != SkShader::kNone_GradientType);
   1315 
   1316     SkPDFShader::State* newState = new SkPDFShader::State(*this);
   1317     for (int i = 0; i < fInfo.fColorCount; i++) {
   1318         newState->fInfo.fColors[i] = SkColorSetA(fInfo.fColors[i],
   1319                                                  SK_AlphaOPAQUE);
   1320     }
   1321 
   1322     return newState;
   1323 }
   1324 
   1325 /**
   1326  * Returns true if state is a gradient and the gradient has alpha.
   1327  */
   1328 bool SkPDFShader::State::GradientHasAlpha() const {
   1329     if (fType == SkShader::kNone_GradientType) {
   1330         return false;
   1331     }
   1332 
   1333     for (int i = 0; i < fInfo.fColorCount; i++) {
   1334         SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
   1335         if (alpha != SK_AlphaOPAQUE) {
   1336             return true;
   1337         }
   1338     }
   1339     return false;
   1340 }
   1341 
   1342 void SkPDFShader::State::AllocateGradientInfoStorage() {
   1343     fColorData.set(sk_malloc_throw(
   1344                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
   1345     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
   1346     fInfo.fColorOffsets =
   1347             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
   1348 }
   1349