SIMD implementation of Convolver for Lanczos filter etc.

skia/ext/convolver.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef SKIA_EXT_CONVOLVER_H_
 #define SKIA_EXT_CONVOLVER_H_
 #pragma once
 
 #include <cmath>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/cpu.h"
 
 // avoid confusion with Mac OS X's math library (Carbon)
 #if defined(__APPLE__)
 #undef FloatToFixed
 #undef FixedToFloat
 #endif
 
 namespace skia {
 
 // Represents a filter in one dimension. Each output pixel has one entry in this
@@ skipping 68 matching lines @@
                                      int* filter_length) const {
     const FilterInstance& filter = filters_[value_offset];
     *filter_offset = filter.offset;
     *filter_length = filter.length;
     if (filter.length == 0) {
       return NULL;
     }
     return &filter_values_[filter.data_location];
   }
 
+
+  inline void PaddingForSIMD(int padding_count) {
+    // Padding |padding_count| of more dummy coefficients after the coefficients
+    // of last filter to prevent SIMD instructions which load 8 or 16 bytes
+    // together to access invalid memory areas. We are not trying to align the
+    // coefficients right now due to the opaqueness of <vector> implementation.
+    // This has to be done after all |AddFilter| calls.

[brettw, 2011/02/25 06:43:02]

I get this now, thanks! I presume that in the future we could make sure the 0th
value in the filter is aligned on an 8-byte boundary and get some speed-up?

[jiesun, 2011/03/07 18:57:15]

correct. it is not done in this patch, because I am worried about vector
implementation on different platforms. 

+    for (int i = 0; i < padding_count; ++i)
+      filter_values_.push_back(static_cast<Fixed>(0));
+  }
+
  private:
   struct FilterInstance {
     // Offset within filter_values for this instance of the filter.
     int data_location;
 
     // Distance from the left of the filter to the center. IN PIXELS
     int offset;
 
     // Number of values in this filter instance.
     int length;
@@ skipping 30 matching lines @@
 // The layout in memory is assumed to be 4-bytes per pixel in B-G-R-A order
 // (this is ARGB when loaded into 32-bit words on a little-endian machine).
 void BGRAConvolve2D(const unsigned char* source_data,
                     int source_byte_row_stride,
                     bool source_has_alpha,
                     const ConvolutionFilter1D& xfilter,
                     const ConvolutionFilter1D& yfilter,
                     int output_byte_row_stride,
                     unsigned char* output);
 
+// Note: You should never use these functions externally; these functions are
+// exposed only for testing purpose.
+void BGRAConvolve2D_C(const unsigned char* source_data,
+                      int source_byte_row_stride,
+                      bool source_has_alpha,
+                      const ConvolutionFilter1D& filter_x,
+                      const ConvolutionFilter1D& filter_y,
+                      int output_byte_row_stride,
+                      unsigned char* output);
+
+void BGRAConvolve2D_SSE2(const unsigned char* source_data,
+                         int source_byte_row_stride,
+                         bool source_has_alpha,
+                         const ConvolutionFilter1D& filter_x,
+                         const ConvolutionFilter1D& filter_y,
+                         int output_byte_row_stride,
+                         unsigned char* output);
 }  // namespace skia
 
 #endif  // SKIA_EXT_CONVOLVER_H_