SkPDF: with opaque draws, treat SRC mode as SRC_OVER

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 19 matching lines @@
 #include "SkString.h"
 #include "SkSurface.h"
 #include "SkTextFormatParams.h"
 #include "SkTemplates.h"
 #include "SkTypefacePriv.h"
 
 #define DPI_FOR_RASTER_SCALE_ONE 72
 
 // Utility functions
 
+static void fix_paint_xfermode(SkPaint* paint) {

[reed1, 2015/05/26 16:28:23]

"fix" is not very descriptive, if I'm trying to understand what this function
does.

[hal.canary, 2015/05/26 18:24:19]

Done.

+    SkXfermode::Mode mode = SkXfermode::kSrcOver_Mode;
+    if (paint->getXfermode() && paint->getXfermode()->asMode(&mode)) {
+        if (mode == SkXfermode::kSrc_Mode &&
+            paint->getAlpha() == SK_AlphaOPAQUE && !paint->getColorFilter() &&
+            !paint->getPathEffect() && !paint->getMaskFilter() &&
+            !paint->getRasterizer() && !paint->getImageFilter() &&
+            !paint->getLooper()) {
+            paint->setXfermodeMode(SkXfermode::kSrcOver_Mode);
+        }
+    }
+}
+
 static void emit_pdf_color(SkColor color, SkWStream* result) {
     SkASSERT(SkColorGetA(color) == 0xFF);  // We handle alpha elsewhere.
     SkScalar colorScale = SkScalarInvert(0xFF);
     SkPDFUtils::AppendScalar(SkColorGetR(color) * colorScale, result);
     result->writeText(" ");
     SkPDFUtils::AppendScalar(SkColorGetG(color) * colorScale, result);
     result->writeText(" ");
     SkPDFUtils::AppendScalar(SkColorGetB(color) * colorScale, result);
     result->writeText(" ");
 }
@@ skipping 699 matching lines @@
     SkSafeUnref(fAnnotations);
     fNamedDestinations.deleteAll();
 
     if (clearFontUsage) {
         fFontGlyphUsage->reset();
     }
 }
 
 void SkPDFDevice::drawPaint(const SkDraw& d, const SkPaint& paint) {
     SkPaint newPaint = paint;
+    fix_paint_xfermode(&newPaint);
+
     newPaint.setStyle(SkPaint::kFill_Style);
     ScopedContentEntry content(this, d, newPaint);
     internalDrawPaint(newPaint, content.entry());
 }
 
 void SkPDFDevice::internalDrawPaint(const SkPaint& paint,
                                     ContentEntry* contentEntry) {
     if (!contentEntry) {
         return;
     }
     SkRect bbox = SkRect::MakeWH(SkIntToScalar(this->width()),
                                  SkIntToScalar(this->height()));
     SkMatrix inverse;
     if (!contentEntry->fState.fMatrix.invert(&inverse)) {
         return;
     }
     inverse.mapRect(&bbox);
 
     SkPDFUtils::AppendRectangle(bbox, &contentEntry->fContent);
     SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
                           &contentEntry->fContent);
 }
 
-void SkPDFDevice::drawPoints(const SkDraw& d, SkCanvas::PointMode mode,
-                             size_t count, const SkPoint* points,
-                             const SkPaint& passedPaint) {
+void SkPDFDevice::drawPoints(const SkDraw& d,
+                             SkCanvas::PointMode mode,
+                             size_t count,
+                             const SkPoint* points,
+                             const SkPaint& srcPaint) {
+    SkPaint passedPaint = srcPaint;
+    fix_paint_xfermode(&passedPaint);
+
     if (count == 0) {
         return;
     }
 
     if (handlePointAnnotation(points, count, *d.fMatrix, passedPaint)) {
         return;
     }
 
     // SkDraw::drawPoints converts to multiple calls to fDevice->drawPath.
     // We only use this when there's a path effect because of the overhead
@@ skipping 64 matching lines @@
                                    &content.entry()->fContent);
                 SkPDFUtils::ClosePath(&content.entry()->fContent);
                 SkPDFUtils::StrokePath(&content.entry()->fContent);
             }
             break;
         default:
             SkASSERT(false);
     }
 }
 
-void SkPDFDevice::drawRect(const SkDraw& d, const SkRect& rect,
-                           const SkPaint& paint) {
+void SkPDFDevice::drawRect(const SkDraw& d,
+                           const SkRect& rect,
+                           const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    fix_paint_xfermode(&paint);
     SkRect r = rect;
     r.sort();
 
     if (paint.getPathEffect()) {
         if (d.fClip->isEmpty()) {
             return;
         }
         SkPath path;
         path.addRect(r);
         drawPath(d, path, paint, NULL, true);
         return;
     }
 
     if (handleRectAnnotation(r, *d.fMatrix, paint)) {
         return;
     }
 
     ScopedContentEntry content(this, d, paint);
     if (!content.entry()) {
         return;
     }
     SkPDFUtils::AppendRectangle(r, &content.entry()->fContent);
     SkPDFUtils::PaintPath(paint.getStyle(), SkPath::kWinding_FillType,
                           &content.entry()->fContent);
 }
 
-void SkPDFDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint& paint) {
+void SkPDFDevice::drawRRect(const SkDraw& draw,
+                            const SkRRect& rrect,
+                            const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    fix_paint_xfermode(&paint);
     SkPath  path;
     path.addRRect(rrect);
     this->drawPath(draw, path, paint, NULL, true);
 }
 
-void SkPDFDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
+void SkPDFDevice::drawOval(const SkDraw& draw,
+                           const SkRect& oval,
+                           const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    fix_paint_xfermode(&paint);
     SkPath  path;
     path.addOval(oval);
     this->drawPath(draw, path, paint, NULL, true);
 }
 
-void SkPDFDevice::drawPath(const SkDraw& d, const SkPath& origPath,
-                           const SkPaint& paint, const SkMatrix* prePathMatrix,
+void SkPDFDevice::drawPath(const SkDraw& d,
+                           const SkPath& origPath,
+                           const SkPaint& srcPaint,
+                           const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
+    SkPaint paint = srcPaint;
+    fix_paint_xfermode(&paint);
     SkPath modifiedPath;
     SkPath* pathPtr = const_cast<SkPath*>(&origPath);
 
     SkMatrix matrix = *d.fMatrix;
     if (prePathMatrix) {
         if (paint.getPathEffect() || paint.getStyle() != SkPaint::kFill_Style) {
             if (!pathIsMutable) {
                 pathPtr = &modifiedPath;
                 pathIsMutable = true;
             }
@@ skipping 38 matching lines @@
         return;
     }
     SkPDFUtils::EmitPath(*pathPtr, paint.getStyle(),
                          &content.entry()->fContent);
     SkPDFUtils::PaintPath(paint.getStyle(), pathPtr->getFillType(),
                           &content.entry()->fContent);
 }
 
 void SkPDFDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
                                  const SkRect* src, const SkRect& dst,
-                                 const SkPaint& paint,
+                                 const SkPaint& srcPaint,
                                  SkCanvas::DrawBitmapRectFlags flags) {
+    SkPaint paint = srcPaint;
+    if (bitmap.isOpaque()) {
+        fix_paint_xfermode(&paint);
+    }
+
     // TODO: this code path must be updated to respect the flags parameter
     SkMatrix    matrix;
     SkRect      bitmapBounds, tmpSrc, tmpDst;
     SkBitmap    tmpBitmap;
 
     bitmapBounds.isetWH(bitmap.width(), bitmap.height());
 
     // Compute matrix from the two rectangles
     if (src) {
         tmpSrc = *src;
@@ skipping 34 matching lines @@
             dy = SkIntToScalar(srcIR.fTop);
         }
         if (dx || dy) {
             matrix.preTranslate(dx, dy);
         }
     }
     this->drawBitmap(draw, *bitmapPtr, matrix, paint);
 }
 
 void SkPDFDevice::drawBitmap(const SkDraw& d, const SkBitmap& bitmap,
-                             const SkMatrix& matrix, const SkPaint& paint) {
+                             const SkMatrix& matrix, const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    if (bitmap.isOpaque()) {
+        fix_paint_xfermode(&paint);
+    }
+
     if (d.fClip->isEmpty()) {
         return;
     }
 
     SkMatrix transform = matrix;
     transform.postConcat(*d.fMatrix);
     this->internalDrawBitmap(transform, d.fClipStack, *d.fClip, bitmap, NULL,
                              paint);
 }
 
 void SkPDFDevice::drawSprite(const SkDraw& d, const SkBitmap& bitmap,
-                             int x, int y, const SkPaint& paint) {
+                             int x, int y, const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    if (bitmap.isOpaque()) {
+        fix_paint_xfermode(&paint);
+    }
+
     if (d.fClip->isEmpty()) {
         return;
     }
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(x), SkIntToScalar(y));
     this->internalDrawBitmap(matrix, d.fClipStack, *d.fClip, bitmap, NULL,
                              paint);
 }
 
@@ skipping 26 matching lines @@
         SkString tmp(len);
         for (size_t i = 0; i < len; i++) {
             SkASSERT(0 == input[i] >> 8);
             tmp[i] = static_cast<uint8_t>(input[i]);
         }
         return SkPDFUtils::FormatString(tmp.c_str(), tmp.size());
     }
 }
 
 void SkPDFDevice::drawText(const SkDraw& d, const void* text, size_t len,
-                           SkScalar x, SkScalar y, const SkPaint& paint) {
+                           SkScalar x, SkScalar y, const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    fix_paint_xfermode(&paint);
+
     NOT_IMPLEMENTED(paint.getMaskFilter() != NULL, false);
     if (paint.getMaskFilter() != NULL) {
         // Don't pretend we support drawing MaskFilters, it makes for artifacts
         // making text unreadable (e.g. same text twice when using CSS shadows).
         return;
     }
     SkPaint textPaint = calculate_text_paint(paint);
     ScopedContentEntry content(this, d, textPaint, true);
     if (!content.entry()) {
         return;
@@ skipping 28 matching lines @@
                                    availableGlyphs, font->multiByteGlyphs());
         content.entry()->fContent.writeText(encodedString.c_str());
         consumedGlyphCount += availableGlyphs;
         content.entry()->fContent.writeText(" Tj\n");
     }
     content.entry()->fContent.writeText("ET\n");
 }
 
 void SkPDFDevice::drawPosText(const SkDraw& d, const void* text, size_t len,
                               const SkScalar pos[], int scalarsPerPos,
-                              const SkPoint& offset, const SkPaint& paint) {
+                              const SkPoint& offset, const SkPaint& srcPaint) {
+    SkPaint paint = srcPaint;
+    fix_paint_xfermode(&paint);
+
     NOT_IMPLEMENTED(paint.getMaskFilter() != NULL, false);
     if (paint.getMaskFilter() != NULL) {
         // Don't pretend we support drawing MaskFilters, it makes for artifacts
         // making text unreadable (e.g. same text twice when using CSS shadows).
         return;
     }
     SkASSERT(1 == scalarsPerPos || 2 == scalarsPerPos);
     SkPaint textPaint = calculate_text_paint(paint);
     ScopedContentEntry content(this, d, textPaint, true);
     if (!content.entry()) {
@@ skipping 996 matching lines @@
         return;
     }
     SkAutoTUnref<SkPDFObject> image(SkPDFBitmap::Create(fCanon, subsetBitmap));
     if (!image) {
         return;
     }
 
     SkPDFUtils::DrawFormXObject(this->addXObjectResource(image.get()),
                                 &content.entry()->fContent);
 }