sketch hooking into PNG_FILTER_OPTIMIZATIONS

src/codec/SkPngCodec.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 "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkColorTable.h"
 #include "SkBitmap.h"
 #include "SkMath.h"
 #include "SkPngCodec.h"
+#include "SkPngFilters.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 
+#if defined(__SSE2__)
+    #include "pngstruct.h"
+
+    extern "C" void sk_png_init_filter_functions_sse2(png_structp png, unsigned int bpp) {
+        if (bpp == 3) {
+            png->read_filter[PNG_FILTER_VALUE_SUB  -1] =   sk_sub3_sse2;
+            png->read_filter[PNG_FILTER_VALUE_AVG  -1] =   sk_avg3_sse2;
+            png->read_filter[PNG_FILTER_VALUE_PAETH-1] = sk_paeth3_sse2;
+        }
+        if (bpp == 4) {
+            png->read_filter[PNG_FILTER_VALUE_SUB  -1] =   sk_sub4_sse2;
+            png->read_filter[PNG_FILTER_VALUE_AVG  -1] =   sk_avg4_sse2;
+            png->read_filter[PNG_FILTER_VALUE_PAETH-1] = sk_paeth4_sse2;
+        }
+    }
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // Helper macros
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifndef png_jmpbuf
 #  define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf)
 #endif
 
 /* These were dropped in libpng >= 1.4 */
 #ifndef png_infopp_NULL
@@ skipping 295 matching lines @@
                 png_set_tRNS_to_alpha(png_ptr);
                 png_set_gray_to_rgb(png_ptr);
                 skColorType = kN32_SkColorType;
                 skAlphaType = kUnpremul_SkAlphaType;
             } else {
                 skColorType = kGray_8_SkColorType;
                 skAlphaType = kOpaque_SkAlphaType;
             }
             break;
         case PNG_COLOR_TYPE_GRAY_ALPHA:
-            //FIXME: support gray with alpha as a color type 
-            //convert to RGBA 
+            //FIXME: support gray with alpha as a color type
+            //convert to RGBA
             png_set_gray_to_rgb(png_ptr);
             skColorType = kN32_SkColorType;
             skAlphaType = kUnpremul_SkAlphaType;
             break;
         case PNG_COLOR_TYPE_RGBA:
             skColorType = kN32_SkColorType;
             skAlphaType = kUnpremul_SkAlphaType;
             break;
         default:
             //all the color types have been covered above
@@ skipping 53 matching lines @@
 SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
                                                const Options& options,
                                                SkPMColor ctable[],
                                                int* ctableCount) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
         SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
-    png_read_update_info(fPng_ptr, fInfo_ptr);  
+    png_read_update_info(fPng_ptr, fInfo_ptr);
 
     //srcColorType was determined in read_header() which determined png color type
     const SkColorType srcColorType = this->getInfo().colorType();
 
     switch (srcColorType) {
         case kIndex_8_SkColorType:
             //decode palette to Skia format
             fSrcConfig = SkSwizzler::kIndex;
             if (!this->decodePalette(kPremul_SkAlphaType == requestedInfo.alphaType(),
                     ctableCount)) {
                 return kInvalidInput;
             }
             break;
         case kGray_8_SkColorType:
             fSrcConfig = SkSwizzler::kGray;
-            break; 
+            break;
         case kN32_SkColorType:
             if (this->getInfo().alphaType() == kOpaque_SkAlphaType) {
                     fSrcConfig = SkSwizzler::kRGB;
                 } else {
                     fSrcConfig = SkSwizzler::kRGBA;
             }
             break;
         default:
             //would have exited before now if the colorType was supported by png
             SkASSERT(false);
-    }  
+    }
 
     // Copy the color table to the client if they request kIndex8 mode
     copy_color_table(requestedInfo, fColorTable, ctable, ctableCount);
 
     // Create the swizzler.  SkPngCodec retains ownership of the color table.
     const SkPMColor* colors = get_color_ptr(fColorTable.get());
     fSwizzler.reset(SkSwizzler::CreateSwizzler(fSrcConfig, colors, requestedInfo, options));
     if (!fSwizzler) {
         // FIXME: CreateSwizzler could fail for another reason.
         return kUnimplemented;
@@ skipping 170 matching lines @@
 
         return row;
     }
 
     bool onSkipScanlines(int count) override {
         // Assume that an error in libpng indicates an incomplete input.
         if (setjmp(png_jmpbuf(this->png_ptr()))) {
             SkCodecPrintf("setjmp long jump!\n");
             return false;
         }
-        //there is a potential tradeoff of memory vs speed created by putting this in a loop. 
-        //calling png_read_rows in a loop is insignificantly slower than calling it once with count 
+        //there is a potential tradeoff of memory vs speed created by putting this in a loop.
+        //calling png_read_rows in a loop is insignificantly slower than calling it once with count
         //as png_read_rows has it's own loop which calls png_read_row count times.
         for (int row = 0; row < count; row++) {
             png_read_rows(this->png_ptr(), &fSrcRow, png_bytepp_NULL, 1);
         }
         return true;
     }
 
 private:
     SkAutoTMalloc<uint8_t>      fStorage;
     uint8_t*                    fSrcRow;
@@ skipping 10 matching lines @@
         : INHERITED(srcInfo, stream, chunkReader, png_ptr, info_ptr, bitDepth, numberPasses)
         , fHeight(-1)
         , fCanSkipRewind(false)
     {
         SkASSERT(numberPasses != 1);
     }
 
     Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options,
             SkPMColor ctable[], int* ctableCount) override {
         if (!conversion_possible(dstInfo, this->getInfo())) {
-            return kInvalidConversion;    
+            return kInvalidConversion;
         }
 
         const Result result = this->initializeSwizzler(dstInfo, options, ctable,
                                                        ctableCount);
         if (result != kSuccess) {
             return result;
         }
 
         fHeight = dstInfo.height();
         // FIXME: This need not be called on a second call to onStartScanlineDecode.
@@ skipping 108 matching lines @@
     }
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(imageInfo, streamDeleter.detach(), chunkReader,
                                         png_ptr, info_ptr, bitDepth);
     }
 
     return new SkPngInterlacedScanlineDecoder(imageInfo, streamDeleter.detach(), chunkReader,
                                               png_ptr, info_ptr, bitDepth, numberPasses);
 }