SkPngFilters: use normal pointer types.

src/codec/SkPngFilters.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPngFilters.h"
-#include "SkTypes.h"
 
 // Functions in this file look at most 3 pixels (a,b,c) to predict the fourth (d).
 // They're positioned like this:
 //     prev:  c b
 //     row:   a d
 // The Sub filter predicts d=a, Avg d=(a+b)/2,  and Paeth predicts d to be whichever
 // of a, b, or c is closest to p=a+b-c.  (Up also exists, predicting d=b.)
 
 #if defined(__SSE2__)
 
     template <int bpp>
     static __m128i load(const void* p) {
         static_assert(bpp <= 4, "");
 
         uint32_t packed;
         memcpy(&packed, p, bpp);
         return _mm_cvtsi32_si128(packed);
     }
 
     template <int bpp>
     static void store(void* p, __m128i v) {
         static_assert(bpp <= 4, "");
 
         uint32_t packed = _mm_cvtsi128_si32(v);
         memcpy(p, &packed, bpp);
     }
 
     template <int bpp>
-    static void sk_sub_sse2(png_row_infop row_info, png_bytep row, png_const_bytep) {
+    static void sk_sub_sse2(png_row_infop row_info, uint8_t* row, const uint8_t*) {
         // The Sub filter predicts each pixel as the previous pixel, a.
         // There is no pixel to the left of the first pixel.  It's encoded directly.
         // That works with our main loop if we just say that left pixel was zero.
         __m128i a, d = _mm_setzero_si128();
 
         int rb = row_info->rowbytes;
         while (rb > 0) {
             a = d; d = load<bpp>(row);
             d = _mm_add_epi8(d, a);
             store<bpp>(row, d);
 
             row += bpp;
             rb  -= bpp;
         }
     }
 
     template <int bpp>
-    void sk_avg_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_avg_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         // The Avg filter predicts each pixel as the (truncated) average of a and b.
         // There's no pixel to the left of the first pixel.  Luckily, it's
         // predicted to be half of the pixel above it.  So again, this works
         // perfectly with our loop if we make sure a starts at zero.
         const __m128i zero = _mm_setzero_si128();
         __m128i    b;
         __m128i a, d = zero;
 
         int rb = row_info->rowbytes;
         while (rb > 0) {
@@ skipping 20 matching lines @@
         return _mm_or_si128(_mm_subs_epu8(x,y), _mm_subs_epu8(y,x));
     }
 
     // Bytewise c ? t : e.
     static __m128i if_then_else(__m128i c, __m128i t, __m128i e) {
         // SSE 4.1+ would be: return _mm_blendv_epi8(e,t,c);
         return _mm_or_si128(_mm_and_si128(c, t), _mm_andnot_si128(c, e));
     }
 
     template <int bpp>
-    void sk_paeth_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_paeth_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         // Paeth tries to predict pixel d using the pixel to the left of it, a,
         // and two pixels from the previous row, b and c:
         //   prev: c b
         //   row:  a d
         // The Paeth function predicts d to be whichever of a, b, or c is nearest to p=a+b-c.
 
         // The first pixel has no left context, and so uses an Up filter, p = b.
         // This works naturally with our main loop's p = a+b-c if we force a and c to zero.
         // Here we zero b and d, which become c and a respectively at the start of the loop.
         __m128i c, b = _mm_setzero_si128(),
@@ skipping 29 matching lines @@
             // We've reconstructed d!  Leave it for next round to become a, and write it out.
             d = _mm_add_epi8(d, nearest);
             store<bpp>(row, d);
 
             prev += bpp;
             row  += bpp;
             rb   -= bpp;
         }
     }
 
-    void sk_sub3_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_sub3_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         sk_sub_sse2<3>(row_info, row, prev);
     }
-    void sk_sub4_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_sub4_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         sk_sub_sse2<4>(row_info, row, prev);
     }
 
-    void sk_avg3_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_avg3_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         sk_avg_sse2<3>(row_info, row, prev);
     }
-    void sk_avg4_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_avg4_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         sk_avg_sse2<4>(row_info, row, prev);
     }
 
-    void sk_paeth3_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_paeth3_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         sk_paeth_sse2<3>(row_info, row, prev);
     }
-    void sk_paeth4_sse2(png_row_infop row_info, png_bytep row, png_const_bytep prev) {
+    void sk_paeth4_sse2(png_row_infop row_info, uint8_t* row, const uint8_t* prev) {
         sk_paeth_sse2<4>(row_info, row, prev);
     }
 
 #endif