SkPDF: Implement Paeth predictor for images.

src/pdf/SkPDFBitmap.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkDeflate.h"
 #include "SkImage_Base.h"
 #include "SkJpegInfo.h"
 #include "SkPDFBitmap.h"
 #include "SkPDFCanon.h"
 #include "SkStream.h"
 #include "SkUnPreMultiply.h"
+#include "SkPngPredictors.h"
 
 void image_get_ro_pixels(const SkImage* image, SkBitmap* dst) {
     if(as_IB(image)->getROPixels(dst)
        && dst->dimensions() == image->dimensions()) {
         if (dst->colorType() != kIndex_8_SkColorType) {
             return;
         }
         // We must check to see if the bitmap has a color table.
         SkAutoLockPixels autoLockPixels(*dst);
         if (!dst->getColorTable()) {
@@ skipping 138 matching lines @@
         case kIndex_8_SkColorType:
         case kGray_8_SkColorType:
             return 1;
         case kUnknown_SkColorType:
         default:
             SkDEBUGFAIL("unexpected color type");
             return 0;
     }
 }
 
-static void bitmap_to_pdf_pixels(const SkBitmap& bitmap, SkWStream* out) {
+//#define SK_PDF_USE_BEST_PNG_PREDICTOR
+//#define SK_PDF_USE_PAETH_PNG_PREDICTOR
+namespace {
+#if defined(SK_PDF_USE_BEST_PNG_PREDICTOR) || defined(SK_PDF_USE_PAETH_PNG_PREDICTOR)
+template<int BPP>
+class PngPredictor {
+public:
+    PngPredictor(int widthInPixels)
+        : fBuffer(2 * (BPP * widthInPixels + 1))
+        , fWidth(widthInPixels)
+        , fFirstline(true) {
+        fScanline = fBuffer.get();
+        fPrevScanline = &fScanline[BPP * widthInPixels + 1];
+    }
+    bool predicts() { return true; }
+    uint8_t* scanline() { return &fScanline[1]; }
+    void write(SkWStream* out) {
+        static_assert(3 == BPP || 1 == BPP, "");
+        #if defined(SK_PDF_USE_BEST_PNG_PREDICTOR)  // smaller
+        auto encode = (3 == BPP) ? &SkPngEncode3 : &SkPngEncode1;
+        #elif defined(SK_PDF_USE_PAETH_PNG_PREDICTOR)  // faster
+        auto encode = (3 == BPP) ? &SkPaethEncode3 : &SkPaethEncode1;
+        #endif
+        fPrevScanline[0] = encode(
+                fWidth, fFirstline ? nullptr : &fPrevScanline[1],
+                &fScanline[1], &fPrevScanline[1]);
+        out->write(fPrevScanline, BPP * fWidth + 1);
+        SkTSwap(fScanline, fPrevScanline);
+        fFirstline = false;
+    }
+private:
+    SkAutoTMalloc<uint8_t> fBuffer;
+    uint8_t* fScanline;
+    uint8_t* fPrevScanline;
+    uint8_t* fScratch;
+    int fWidth;
+    bool fFirstline;
+};
+#else
+template<int BPP>
+class PngPredictor {
+public:
+    PngPredictor(int widthInPixels)
+        : fBuffer(BPP * widthInPixels)
+        , fWidthInBytes(BPP * widthInPixels) {
+    }
+    bool predicts() { return false; }
+    uint8_t* scanline() { return fBuffer.get(); }
+    void write(SkWStream* out) {
+        out->write(fBuffer.get(), fWidthInBytes);
+    }
+private:
+    SkAutoTMalloc<uint8_t> fBuffer;
+    int fWidthInBytes;
+};
+#endif
+}  // namespace
+
+static bool bitmap_to_pdf_pixels(const SkBitmap& bitmap, SkWStream* out) {
     if (!bitmap.getPixels()) {
         size_t size = pixel_count(bitmap) *
                       pdf_color_component_count(bitmap.colorType());
         fill_stream(out, '\x00', size);
-        return;
+        return false;
     }
     SkBitmap copy;
     const SkBitmap& bm = not4444(bitmap, &copy);
     SkAutoLockPixels autoLockPixels(bm);
     SkColorType colorType = bm.colorType();
     switch (colorType) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType: {
             SkASSERT(3 == pdf_color_component_count(colorType));
-            SkAutoTMalloc<uint8_t> scanline(3 * bm.width());
+            PngPredictor<3> pngPredictorFilter(bm.width());
             for (int y = 0; y < bm.height(); ++y) {
                 const uint32_t* src = bm.getAddr32(0, y);
-                uint8_t* dst = scanline.get();
+                uint8_t* dst = pngPredictorFilter.scanline();
                 for (int x = 0; x < bm.width(); ++x) {
                     uint32_t color = *src++;
                     U8CPU alpha = SkGetA32Component(color, colorType);
                     if (alpha != SK_AlphaTRANSPARENT) {
                         pmcolor_to_rgb24(color, dst, colorType);
                     } else {
                         get_neighbor_avg_color(bm, x, y, dst, colorType);
                     }
                     dst += 3;
                 }
-                out->write(scanline.get(), 3 * bm.width());
+                pngPredictorFilter.write(out);
             }
-            return;
+            return pngPredictorFilter.predicts();
         }
         case kRGB_565_SkColorType: {
             SkASSERT(3 == pdf_color_component_count(colorType));
-            SkAutoTMalloc<uint8_t> scanline(3 * bm.width());
+            PngPredictor<3> pngPredictorFilter(bm.width());
             for (int y = 0; y < bm.height(); ++y) {
                 const uint16_t* src = bm.getAddr16(0, y);
-                uint8_t* dst = scanline.get();
+                uint8_t* dst = pngPredictorFilter.scanline();
                 for (int x = 0; x < bm.width(); ++x) {
                     U16CPU color565 = *src++;
                     *dst++ = SkPacked16ToR32(color565);
                     *dst++ = SkPacked16ToG32(color565);
                     *dst++ = SkPacked16ToB32(color565);
                 }
-                out->write(scanline.get(), 3 * bm.width());
+                pngPredictorFilter.write(out);
             }
-            return;
+            return pngPredictorFilter.predicts();
         }
         case kAlpha_8_SkColorType:
             SkASSERT(1 == pdf_color_component_count(colorType));
             fill_stream(out, '\x00', pixel_count(bm));
-            return;
+            return false;
         case kGray_8_SkColorType:
         case kIndex_8_SkColorType:
             SkASSERT(1 == pdf_color_component_count(colorType));
             // these two formats need no transformation to serialize.
             for (int y = 0; y < bm.height(); ++y) {
                 out->write(bm.getAddr8(0, y), bm.width());
             }
-            return;
+            return false;
         case kUnknown_SkColorType:
         case kARGB_4444_SkColorType:
         default:
             SkDEBUGFAIL("unexpected color type");
+            return false;
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-static void bitmap_alpha_to_a8(const SkBitmap& bitmap, SkWStream* out) {
+static bool bitmap_alpha_to_a8(const SkBitmap& bitmap, SkWStream* out) {
     if (!bitmap.getPixels()) {
         fill_stream(out, '\xFF', pixel_count(bitmap));
-        return;
+        return false;
     }
     SkBitmap copy;
     const SkBitmap& bm = not4444(bitmap, &copy);
     SkAutoLockPixels autoLockPixels(bm);
     SkColorType colorType = bm.colorType();
     switch (colorType) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType: {
-            SkAutoTMalloc<uint8_t> scanline(bm.width());
+            PngPredictor<1> pngPredictorFilter(bm.width());
             for (int y = 0; y < bm.height(); ++y) {
-                uint8_t* dst = scanline.get();
+                uint8_t* dst = pngPredictorFilter.scanline();
                 const SkPMColor* src = bm.getAddr32(0, y);
                 for (int x = 0; x < bm.width(); ++x) {
                     *dst++ = SkGetA32Component(*src++, colorType);
                 }
-                out->write(scanline.get(), bm.width());
+                pngPredictorFilter.write(out);
             }
-            return;
+            return pngPredictorFilter.predicts();
         }
         case kAlpha_8_SkColorType:
             for (int y = 0; y < bm.height(); ++y) {
                 out->write(bm.getAddr8(0, y), bm.width());
             }
-            return;
+            return false;
         case kIndex_8_SkColorType: {
             SkColorTable* ct = bm.getColorTable();
             SkASSERT(ct);
             SkAutoTMalloc<uint8_t> scanline(bm.width());
             for (int y = 0; y < bm.height(); ++y) {
                 uint8_t* dst = scanline.get();
                 const uint8_t* src = bm.getAddr8(0, y);
                 for (int x = 0; x < bm.width(); ++x) {
                     *dst++ = SkGetPackedA32((*ct)[*src++]);
                 }
                 out->write(scanline.get(), bm.width());
             }
-            return;
+            return false;
         }
         case kRGB_565_SkColorType:
         case kGray_8_SkColorType:
             SkDEBUGFAIL("color type has no alpha");
-            return;
+            return false;
         case kARGB_4444_SkColorType:
             SkDEBUGFAIL("4444 color type should have been converted to N32");
-            return;
+            return false;
         case kUnknown_SkColorType:
         default:
             SkDEBUGFAIL("unexpected color type");
+            return false;
     }
 }
 
 static SkPDFArray* make_indexed_color_space(const SkColorTable* table) {
     SkPDFArray* result = new SkPDFArray;
     result->reserve(4);
     result->appendName("Indexed");
     result->appendName("DeviceRGB");
     SkASSERT(table);
     if (table->count() < 1) {
@@ skipping 26 matching lines @@
                                SkPDFObject* smask,
                                const SkPDFObjNumMap& objNumMap,
                                const SkPDFSubstituteMap& substitutes) {
     SkBitmap bitmap;
     image_get_ro_pixels(image, &bitmap);      // TODO(halcanary): test
     SkAutoLockPixels autoLockPixels(bitmap);  // with malformed images.
 
     // Write to a temporary buffer to get the compressed length.
     SkDynamicMemoryWStream buffer;
     SkDeflateWStream deflateWStream(&buffer);
+    bool usePngPredictor = false;
     if (alpha) {
-        bitmap_alpha_to_a8(bitmap, &deflateWStream);
+        usePngPredictor = bitmap_alpha_to_a8(bitmap, &deflateWStream);
     } else {
-        bitmap_to_pdf_pixels(bitmap, &deflateWStream);
+        usePngPredictor = bitmap_to_pdf_pixels(bitmap, &deflateWStream);
     }
     deflateWStream.finalize();  // call before detachAsStream().
     SkAutoTDelete<SkStreamAsset> asset(buffer.detachAsStream());
 
     SkPDFDict pdfDict("XObject");
     pdfDict.insertName("Subtype", "Image");
     pdfDict.insertInt("Width", bitmap.width());
     pdfDict.insertInt("Height", bitmap.height());
     if (alpha) {
         pdfDict.insertName("ColorSpace", "DeviceGray");
     } else if (bitmap.colorType() == kIndex_8_SkColorType) {
         SkASSERT(1 == pdf_color_component_count(bitmap.colorType()));
         pdfDict.insertObject("ColorSpace",
                              make_indexed_color_space(bitmap.getColorTable()));
     } else if (1 == pdf_color_component_count(bitmap.colorType())) {
         pdfDict.insertName("ColorSpace", "DeviceGray");
     } else {
         pdfDict.insertName("ColorSpace", "DeviceRGB");
     }
     if (smask) {
         pdfDict.insertObjRef("SMask", SkRef(smask));
     }
     pdfDict.insertInt("BitsPerComponent", 8);
     pdfDict.insertName("Filter", "FlateDecode");
+    if (usePngPredictor) {
+        SkAutoTUnref<SkPDFDict> params(new SkPDFDict);
+        params->insertInt("BitsPerComponent", 8);
+        params->insertInt("Predictor", 15);
+        params->insertInt("Colors", alpha ? 1 : 3);
+        params->insertInt("Columns", bitmap.width());
+        pdfDict.insertObject("DecodeParms", params.detach());
+    }
     pdfDict.insertInt("Length", asset->getLength());
     pdfDict.emitObject(stream, objNumMap, substitutes);
 
     pdf_stream_begin(stream);
     stream->writeStream(asset.get(), asset->getLength());
     pdf_stream_end(stream);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 116 matching lines @@
         }
     }
 
     SkPDFObject* smask =
             image_compute_is_opaque(image) ? nullptr : new PDFAlphaBitmap(image);
     #ifdef SK_PDF_IMAGE_STATS
     gRegularImageObjects.fetch_add(1);
     #endif
     return new PDFDefaultBitmap(image, smask);
 }