Implement DPI for perspective bitmaps in PDF - we save the bitmap at the resolution requested.

src/pdf/SkPDFDevice.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 "SkPDFDevice.h"
 
 #include "SkAnnotation.h"
@@ skipping 32 matching lines @@
     int upperBounds;
 
     bool operator==(const TypefaceFallbackData& b) const {
         return typeface == b.typeface &&
                lowerBounds == b.lowerBounds &&
                upperBounds == b.upperBounds;
     }
 };
 #endif
 
+#define DPI_FOR_RASTER_SCALE_ONE 72
+
 // Utility functions
 
 static void emit_pdf_color(SkColor color, SkWStream* result) {
     SkASSERT(SkColorGetA(color) == 0xFF);  // We handle alpha elsewhere.
     SkScalar colorMax = SkIntToScalar(0xFF);
     SkPDFScalar::Append(
             SkScalarDiv(SkIntToScalar(SkColorGetR(color)), colorMax), result);
     result->writeText(" ");
     SkPDFScalar::Append(
             SkScalarDiv(SkIntToScalar(SkColorGetG(color)), colorMax), result);
@@ skipping 2101 matching lines @@
                                      const SkPaint& paint) {
     SkMatrix matrix = origMatrix;
     SkRegion perspectiveBounds;
     const SkRegion* clipRegion = &origClipRegion;
     SkBitmap perspectiveBitmap;
     const SkBitmap* bitmap = &origBitmap;
     SkBitmap tmpSubsetBitmap;
 
     // Rasterize the bitmap using perspective in a new bitmap.
     if (origMatrix.hasPerspective()) {
+        if (fRasterDpi == 0) {
+            return;
+        }
         SkBitmap* subsetBitmap;
         if (srcRect) {
             if (!origBitmap.extractSubset(&tmpSubsetBitmap, *srcRect)) {
                return;
             }
             subsetBitmap = &tmpSubsetBitmap;
         } else {
             subsetBitmap = &tmpSubsetBitmap;
             *subsetBitmap = origBitmap;
         }
         srcRect = NULL;
 
-        // Transform the bitmap in the new space.
+        // Transform the bitmap in the new space, without taking into
+        // account the initial transform.
         SkPath perspectiveOutline;
         perspectiveOutline.addRect(
                 SkRect::MakeWH(SkIntToScalar(subsetBitmap->width()),
                                SkIntToScalar(subsetBitmap->height())));
         perspectiveOutline.transform(origMatrix);
 
         // TODO(edisonn): perf - use current clip too.
         // Retrieve the bounds of the new shape.
         SkRect bounds = perspectiveOutline.getBounds();
 
-        // TODO(edisonn): add DPI settings. Currently 1 pixel/point, which does
-        // not look great, but it is not producing large PDFs.
+        // Transform the bitmap in the new space, taking into
+        // account the initial transform.
+        SkMatrix total = origMatrix;
+        total.postConcat(fInitialTransform);
+        total.postScale(SkIntToScalar(fRasterDpi) /
+                            SkIntToScalar(DPI_FOR_RASTER_SCALE_ONE),
+                        SkIntToScalar(fRasterDpi) /
+                            SkIntToScalar(DPI_FOR_RASTER_SCALE_ONE));
+        SkPath physicalPerspectiveOutline;
+        physicalPerspectiveOutline.addRect(
+                SkRect::MakeWH(SkIntToScalar(subsetBitmap->width()),
+                               SkIntToScalar(subsetBitmap->height())));
+        physicalPerspectiveOutline.transform(total);
+
+        SkScalar scaleX = physicalPerspectiveOutline.getBounds().width() /
+                              bounds.width();
+        SkScalar scaleY = physicalPerspectiveOutline.getBounds().height() /
+                              bounds.height();
 
         // TODO(edisonn): A better approach would be to use a bitmap shader
         // (in clamp mode) and draw a rect over the entire bounding box. Then
         // intersect perspectiveOutline to the clip. That will avoid introducing
         // alpha to the image while still giving good behavior at the edge of
         // the image.  Avoiding alpha will reduce the pdf size and generation
         // CPU time some.
 
-        perspectiveBitmap.setConfig(SkBitmap::kARGB_8888_Config,
-                                    SkScalarCeilToInt(bounds.width()),
-                                    SkScalarCeilToInt(bounds.height()));
+        perspectiveBitmap.setConfig(
+                SkBitmap::kARGB_8888_Config,
+                SkScalarCeilToInt(
+                        physicalPerspectiveOutline.getBounds().width()),
+                SkScalarCeilToInt(
+                        physicalPerspectiveOutline.getBounds().height()));
         perspectiveBitmap.allocPixels();
         perspectiveBitmap.eraseColor(SK_ColorTRANSPARENT);
 
         SkBitmapDevice device(perspectiveBitmap);
         SkCanvas canvas(&device);
 
         SkScalar deltaX = bounds.left();
         SkScalar deltaY = bounds.top();
 
         SkMatrix offsetMatrix = origMatrix;
         offsetMatrix.postTranslate(-deltaX, -deltaY);
+        offsetMatrix.postScale(scaleX, scaleY);
 
         // Translate the draw in the new canvas, so we perfectly fit the
         // shape in the bitmap.
         canvas.setMatrix(offsetMatrix);
 
         canvas.drawBitmap(*subsetBitmap, SkIntToScalar(0), SkIntToScalar(0));
 
         // Make sure the final bits are in the bitmap.
         canvas.flush();
 
-        // In the new space, we use the identity matrix translated.
-        matrix.setTranslate(deltaX, deltaY);
+        // In the new space, we use the identity matrix translated
+        // and scaled to reflect DPI.
+        matrix.setScale(1 / scaleX, 1 / scaleY);
+        matrix.postTranslate(deltaX, deltaY);
+
         perspectiveBounds.setRect(
                 SkIRect::MakeXYWH(SkScalarFloorToInt(bounds.x()),
                                   SkScalarFloorToInt(bounds.y()),
                                   SkScalarCeilToInt(bounds.width()),
                                   SkScalarCeilToInt(bounds.height())));
         clipRegion = &perspectiveBounds;
         srcRect = NULL;
         bitmap = &perspectiveBitmap;
     }
 
@@ skipping 32 matching lines @@
 }
 
 bool SkPDFDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
                                SkCanvas::Config8888) {
     return false;
 }
 
 bool SkPDFDevice::allowImageFilter(SkImageFilter*) {
     return false;
 }