libwebp: update to 0.5.0

third_party/libwebp/dsp/filters.c

 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Spatial prediction using various filters
 //
 // Author: Urvang (urvang@google.com)
 
-#include "./filters.h"
+#include "./dsp.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 //------------------------------------------------------------------------------
 // Helpful macro.
 
 # define SANITY_CHECK(in, out)                                                 \
   assert(in != NULL);                                                          \
   assert(out != NULL);                                                         \
@@ skipping 43 matching lines @@
     // Leftmost pixel is predicted from above.
     PredictLine(in, preds - stride, out, 1, inverse);
     PredictLine(in + 1, preds, out + 1, width - 1, inverse);
     ++row;
     preds += stride;
     in += stride;
     out += stride;
   }
 }
 
-static void HorizontalFilter(const uint8_t* data, int width, int height,
-                             int stride, uint8_t* filtered_data) {
-  DoHorizontalFilter(data, width, height, stride, 0, height, 0, filtered_data);
-}
-
-static void HorizontalUnfilter(int width, int height, int stride, int row,
-                               int num_rows, uint8_t* data) {
-  DoHorizontalFilter(data, width, height, stride, row, num_rows, 1, data);
-}
-
 //------------------------------------------------------------------------------
 // Vertical filter.
 
 static WEBP_INLINE void DoVerticalFilter(const uint8_t* in,
                                          int width, int height, int stride,
                                          int row, int num_rows,
                                          int inverse, uint8_t* out) {
   const uint8_t* preds;
   const size_t start_offset = row * stride;
   const int last_row = row + num_rows;
@@ skipping 18 matching lines @@
   // Filter line-by-line.
   while (row < last_row) {
     PredictLine(in, preds, out, width, inverse);
     ++row;
     preds += stride;
     in += stride;
     out += stride;
   }
 }
 
-static void VerticalFilter(const uint8_t* data, int width, int height,
-                           int stride, uint8_t* filtered_data) {
-  DoVerticalFilter(data, width, height, stride, 0, height, 0, filtered_data);
-}
-
-static void VerticalUnfilter(int width, int height, int stride, int row,
-                             int num_rows, uint8_t* data) {
-  DoVerticalFilter(data, width, height, stride, row, num_rows, 1, data);
-}
-
 //------------------------------------------------------------------------------
 // Gradient filter.
 
 static WEBP_INLINE int GradientPredictor(uint8_t a, uint8_t b, uint8_t c) {
   const int g = a + b - c;
   return ((g & ~0xff) == 0) ? g : (g < 0) ? 0 : 255;  // clip to 8bit
 }
 
 static WEBP_INLINE void DoGradientFilter(const uint8_t* in,
                                          int width, int height, int stride,
@@ skipping 28 matching lines @@
                                          preds[w - stride - 1]);
       out[w] = in[w] + (inverse ? pred : -pred);
     }
     ++row;
     preds += stride;
     in += stride;
     out += stride;
   }
 }
 
+#undef SANITY_CHECK
+
+//------------------------------------------------------------------------------
+
+static void HorizontalFilter(const uint8_t* data, int width, int height,
+                             int stride, uint8_t* filtered_data) {
+  DoHorizontalFilter(data, width, height, stride, 0, height, 0, filtered_data);
+}
+
+static void VerticalFilter(const uint8_t* data, int width, int height,
+                           int stride, uint8_t* filtered_data) {
+  DoVerticalFilter(data, width, height, stride, 0, height, 0, filtered_data);
+}
+
+
 static void GradientFilter(const uint8_t* data, int width, int height,
                            int stride, uint8_t* filtered_data) {
   DoGradientFilter(data, width, height, stride, 0, height, 0, filtered_data);
 }
 
+
+//------------------------------------------------------------------------------
+
+static void VerticalUnfilter(int width, int height, int stride, int row,
+                             int num_rows, uint8_t* data) {
+  DoVerticalFilter(data, width, height, stride, row, num_rows, 1, data);
+}
+
+static void HorizontalUnfilter(int width, int height, int stride, int row,
+                               int num_rows, uint8_t* data) {
+  DoHorizontalFilter(data, width, height, stride, row, num_rows, 1, data);
+}
+
 static void GradientUnfilter(int width, int height, int stride, int row,
                              int num_rows, uint8_t* data) {
   DoGradientFilter(data, width, height, stride, row, num_rows, 1, data);
 }
 
-#undef SANITY_CHECK
+//------------------------------------------------------------------------------
+// Init function
 
-// -----------------------------------------------------------------------------
-// Quick estimate of a potentially interesting filter mode to try.
+WebPFilterFunc WebPFilters[WEBP_FILTER_LAST];
+WebPUnfilterFunc WebPUnfilters[WEBP_FILTER_LAST];
 
-#define SMAX 16
-#define SDIFF(a, b) (abs((a) - (b)) >> 4)   // Scoring diff, in [0..SMAX)
+extern void VP8FiltersInitMIPSdspR2(void);
+extern void VP8FiltersInitSSE2(void);
 
-WEBP_FILTER_TYPE EstimateBestFilter(const uint8_t* data,
-                                    int width, int height, int stride) {
-  int i, j;
-  int bins[WEBP_FILTER_LAST][SMAX];
-  memset(bins, 0, sizeof(bins));
+static volatile VP8CPUInfo filters_last_cpuinfo_used =
+    (VP8CPUInfo)&filters_last_cpuinfo_used;
 
-  // We only sample every other pixels. That's enough.
-  for (j = 2; j < height - 1; j += 2) {
-    const uint8_t* const p = data + j * stride;
-    int mean = p[0];
-    for (i = 2; i < width - 1; i += 2) {
-      const int diff0 = SDIFF(p[i], mean);
-      const int diff1 = SDIFF(p[i], p[i - 1]);
-      const int diff2 = SDIFF(p[i], p[i - width]);
-      const int grad_pred =
-          GradientPredictor(p[i - 1], p[i - width], p[i - width - 1]);
-      const int diff3 = SDIFF(p[i], grad_pred);
-      bins[WEBP_FILTER_NONE][diff0] = 1;
-      bins[WEBP_FILTER_HORIZONTAL][diff1] = 1;
-      bins[WEBP_FILTER_VERTICAL][diff2] = 1;
-      bins[WEBP_FILTER_GRADIENT][diff3] = 1;
-      mean = (3 * mean + p[i] + 2) >> 2;
+WEBP_TSAN_IGNORE_FUNCTION void VP8FiltersInit(void) {
+  if (filters_last_cpuinfo_used == VP8GetCPUInfo) return;
+
+  WebPUnfilters[WEBP_FILTER_NONE] = NULL;
+  WebPUnfilters[WEBP_FILTER_HORIZONTAL] = HorizontalUnfilter;
+  WebPUnfilters[WEBP_FILTER_VERTICAL] = VerticalUnfilter;
+  WebPUnfilters[WEBP_FILTER_GRADIENT] = GradientUnfilter;
+
+  WebPFilters[WEBP_FILTER_NONE] = NULL;
+  WebPFilters[WEBP_FILTER_HORIZONTAL] = HorizontalFilter;
+  WebPFilters[WEBP_FILTER_VERTICAL] = VerticalFilter;
+  WebPFilters[WEBP_FILTER_GRADIENT] = GradientFilter;
+
+  if (VP8GetCPUInfo != NULL) {
+#if defined(WEBP_USE_SSE2)
+    if (VP8GetCPUInfo(kSSE2)) {
+      VP8FiltersInitSSE2();
     }
+#endif
+#if defined(WEBP_USE_MIPS_DSP_R2)
+    if (VP8GetCPUInfo(kMIPSdspR2)) {
+      VP8FiltersInitMIPSdspR2();
+    }
+#endif
   }
-  {
-    int filter;
-    WEBP_FILTER_TYPE best_filter = WEBP_FILTER_NONE;
-    int best_score = 0x7fffffff;
-    for (filter = WEBP_FILTER_NONE; filter < WEBP_FILTER_LAST; ++filter) {
-      int score = 0;
-      for (i = 0; i < SMAX; ++i) {
-        if (bins[filter][i] > 0) {
-          score += i;
-        }
-      }
-      if (score < best_score) {
-        best_score = score;
-        best_filter = (WEBP_FILTER_TYPE)filter;
-      }
-    }
-    return best_filter;
-  }
+  filters_last_cpuinfo_used = VP8GetCPUInfo;
 }
-
-#undef SMAX
-#undef SDIFF
-
-//------------------------------------------------------------------------------
-
-const WebPFilterFunc WebPFilters[WEBP_FILTER_LAST] = {
-  NULL,              // WEBP_FILTER_NONE
-  HorizontalFilter,  // WEBP_FILTER_HORIZONTAL
-  VerticalFilter,    // WEBP_FILTER_VERTICAL
-  GradientFilter     // WEBP_FILTER_GRADIENT
-};
-
-const WebPUnfilterFunc WebPUnfilters[WEBP_FILTER_LAST] = {
-  NULL,                // WEBP_FILTER_NONE
-  HorizontalUnfilter,  // WEBP_FILTER_HORIZONTAL
-  VerticalUnfilter,    // WEBP_FILTER_VERTICAL
-  GradientUnfilter     // WEBP_FILTER_GRADIENT
-};
-
-//------------------------------------------------------------------------------
-