[PDF] Fix shader fallback mapping when clipped

src/pdf/SkPDFShader.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
 
 #include "SkData.h"
 #include "SkPDFCanon.h"
 #include "SkPDFCatalog.h"
 #include "SkPDFDevice.h"
 #include "SkPDFFormXObject.h"
 #include "SkPDFGraphicState.h"
 #include "SkPDFResourceDict.h"
 #include "SkPDFUtils.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkThread.h"
 #include "SkTSet.h"
 #include "SkTypes.h"
 
-static bool inverseTransformBBox(const SkMatrix& matrix, SkRect* bbox) {
+static bool inverse_transform_bbox(const SkMatrix& matrix, SkRect* bbox) {
     SkMatrix inverse;
     if (!matrix.invert(&inverse)) {
         return false;
     }
     inverse.mapRect(bbox);
     return true;
 }
 
 static void unitToPointsMatrix(const SkPoint pts[2], SkMatrix* matrix) {
     SkVector    vec = pts[1] - pts[0];
@@ skipping 804 matching lines @@
     SkMatrix perspectiveInverseOnly = SkMatrix::I();
     if (finalMatrix.hasPerspective()) {
         if (!split_perspective(finalMatrix,
                                &finalMatrix, &perspectiveInverseOnly)) {
             return NULL;
         }
     }
 
     SkRect bbox;
     bbox.set(state.fBBox);
-    if (!inverseTransformBBox(finalMatrix, &bbox)) {
+    if (!inverse_transform_bbox(finalMatrix, &bbox)) {
         return NULL;
     }
 
     SkAutoTUnref<SkPDFArray> domain(new SkPDFArray);
     domain->reserve(4);
     domain->appendScalar(bbox.fLeft);
     domain->appendScalar(bbox.fRight);
     domain->appendScalar(bbox.fTop);
     domain->appendScalar(bbox.fBottom);
 
@@ skipping 52 matching lines @@
     // The image shader pattern cell will be drawn into a separate device
     // in pattern cell space (no scaling on the bitmap, though there may be
     // translations so that all content is in the device, coordinates > 0).
 
     // Map clip bounds to shader space to ensure the device is large enough
     // to handle fake clamping.
     SkMatrix finalMatrix = state.fCanvasTransform;
     finalMatrix.preConcat(state.fShaderTransform);
     SkRect deviceBounds;
     deviceBounds.set(state.fBBox);
-    if (!inverseTransformBBox(finalMatrix, &deviceBounds)) {
+    if (!inverse_transform_bbox(finalMatrix, &deviceBounds)) {
         return NULL;
     }
 
     const SkBitmap* image = &state.fImage;
     SkRect bitmapBounds;
     image->getBounds(&bitmapBounds);
 
     // For tiling modes, the bounds should be extended to include the bitmap,
     // otherwise the bitmap gets clipped out and the shader is empty and awful.
     // For clamp modes, we're only interested in the clip region, whether
@@ skipping 257 matching lines @@
     if (fType == SkShader::kNone_GradientType) {
         SkShader::BitmapType bitmapType;
         SkMatrix matrix;
         bitmapType = shader.asABitmap(&fImage, &matrix, fImageTileModes);
         if (bitmapType != SkShader::kDefault_BitmapType) {
             // Generic fallback for unsupported shaders:
             //  * allocate a bbox-sized bitmap
             //  * shade the whole area
             //  * use the result as a bitmap shader
 
+            // bbox is in device space. While that's exactly what we want for sizing our bitmap,
+            // we need to map it into shader space for adjustments (to match
+            // SkPDFImageShader::Create's behavior).
+            SkRect shaderRect = SkRect::Make(bbox);
+            if (!inverse_transform_bbox(canvasTransform, &shaderRect)) {
+                fImage.reset();
+                return;
+            }
+
             // Clamp the bitmap size to about 1M pixels
             static const SkScalar kMaxBitmapArea = 1024 * 1024;
             SkScalar bitmapArea = rasterScale * bbox.width() * rasterScale * bbox.height();
             if (bitmapArea > kMaxBitmapArea) {
                 rasterScale *= SkScalarSqrt(SkScalarDiv(kMaxBitmapArea, bitmapArea));
             }
 
             SkISize size = SkISize::Make(SkScalarRoundToInt(rasterScale * bbox.width()),
                                          SkScalarRoundToInt(rasterScale * bbox.height()));
-            SkSize scale = SkSize::Make(SkIntToScalar(size.width()) / SkIntToScalar(bbox.width()),
-                                        SkIntToScalar(size.height()) / SkIntToScalar(bbox.height()));
+            SkSize scale = SkSize::Make(SkIntToScalar(size.width()) / shaderRect.width(),
+                                        SkIntToScalar(size.height()) / shaderRect.height());
 
             fImage.allocN32Pixels(size.width(), size.height());
             fImage.eraseColor(SK_ColorTRANSPARENT);
 
             SkPaint p;
             p.setShader(const_cast<SkShader*>(&shader));
 
             SkCanvas canvas(fImage);
             canvas.scale(scale.width(), scale.height());
-            canvas.translate(-SkIntToScalar(bbox.x()), -SkIntToScalar(bbox.y()));
+            canvas.translate(-shaderRect.x(), -shaderRect.y());
             canvas.drawPaint(p);
 
-            fShaderTransform.setTranslate(SkIntToScalar(bbox.x()), SkIntToScalar(bbox.y()));
+            fShaderTransform.setTranslate(shaderRect.x(), shaderRect.y());
             fShaderTransform.preScale(1 / scale.width(), 1 / scale.height());
         } else {
             SkASSERT(matrix.isIdentity());
         }
         fPixelGeneration = fImage.getGenerationID();
     } else {
         AllocateGradientInfoStorage();
         shader.asAGradient(&fInfo);
     }
 }
@@ skipping 69 matching lines @@
     return false;
 }
 
 void SkPDFShader::State::AllocateGradientInfoStorage() {
     fColorData.set(sk_malloc_throw(
                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
     fInfo.fColorOffsets =
             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
 }