Generic PDF shader fallback

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"
@@ skipping 471 matching lines @@
     SkAutoFree fColorData;    // This provides storage for arrays in fInfo.
     SkMatrix fCanvasTransform;
     SkMatrix fShaderTransform;
     SkIRect fBBox;
 
     SkBitmap fImage;
     uint32_t fPixelGeneration;
     SkShader::TileMode fImageTileModes[2];
 
     State(const SkShader& shader, const SkMatrix& canvasTransform,
-          const SkIRect& bbox);
+          const SkIRect& bbox, SkScalar rasterScale);
 
     bool operator==(const State& b) const;
 
     SkPDFShader::State* CreateAlphaToLuminosityState() const;
     SkPDFShader::State* CreateOpaqueState() const;
 
     bool GradientHasAlpha() const;
 
 private:
     State(const State& other);
@@ skipping 147 matching lines @@
     SkAutoMutexAcquire lock(CanonicalShadersMutex());
     ShaderCanonicalEntry entry(shader, NULL);
     int index = CanonicalShaders().find(entry);
     SkASSERT(index >= 0);
     CanonicalShaders().removeShuffle(index);
 }
 
 // static
 SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
                                        const SkMatrix& matrix,
-                                       const SkIRect& surfaceBBox) {
+                                       const SkIRect& surfaceBBox,
+                                       SkScalar rasterScale) {
     SkAutoMutexAcquire lock(CanonicalShadersMutex());
     return GetPDFShaderByState(
-            SkNEW_ARGS(State, (shader, matrix, surfaceBBox)));
+            SkNEW_ARGS(State, (shader, matrix, surfaceBBox, rasterScale)));
 }
 
 // static
 SkTDArray<SkPDFShader::ShaderCanonicalEntry>& SkPDFShader::CanonicalShaders() {
     SkPDFShader::CanonicalShadersMutex().assertHeld();
     static SkTDArray<ShaderCanonicalEntry> gCanonicalShaders;
     return gCanonicalShaders;
 }
 
 SK_DECLARE_STATIC_MUTEX(gCanonicalShadersMutex);
@@ skipping 558 matching lines @@
                 break;
             case SkShader::kSweep_GradientType:
             case SkShader::kNone_GradientType:
             case SkShader::kColor_GradientType:
                 break;
         }
     }
     return true;
 }
 
-SkPDFShader::State::State(const SkShader& shader,
-                          const SkMatrix& canvasTransform, const SkIRect& bbox)
+SkPDFShader::State::State(const SkShader& shader, const SkMatrix& canvasTransform,
+                          const SkIRect& bbox, SkScalar rasterScale)
         : fCanvasTransform(canvasTransform),
           fBBox(bbox),
           fPixelGeneration(0) {
     fInfo.fColorCount = 0;
     fInfo.fColors = NULL;
     fInfo.fColorOffsets = NULL;
     fShaderTransform = shader.getLocalMatrix();
     fImageTileModes[0] = fImageTileModes[1] = SkShader::kClamp_TileMode;
 
     fType = shader.asAGradient(&fInfo);
 
     if (fType == SkShader::kNone_GradientType) {
         SkShader::BitmapType bitmapType;
         SkMatrix matrix;
         bitmapType = shader.asABitmap(&fImage, &matrix, fImageTileModes);
         if (bitmapType != SkShader::kDefault_BitmapType) {
-            fImage.reset();
-            return;
+            // Generic fallback for unsupported shaders:
+            //  * allocate a bbox-sized bitmap
+            //  * shade the whole area
+            //  * use the result as a bitmap shader
+
+            // 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()));
+
+            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.drawPaint(p);
+
+            fShaderTransform.setTranslate(SkIntToScalar(bbox.x()), SkIntToScalar(bbox.y()));
+            fShaderTransform.preScale(1 / scale.width(), 1 / scale.height());
+        } else {
+            SkASSERT(matrix.isIdentity());
         }
-        SkASSERT(matrix.isIdentity());
         fPixelGeneration = fImage.getGenerationID();
     } else {
         AllocateGradientInfoStorage();
         shader.asAGradient(&fInfo);
     }
 }
 
 SkPDFShader::State::State(const SkPDFShader::State& other)
   : fType(other.fType),
     fCanvasTransform(other.fCanvasTransform),
@@ skipping 65 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);
 }