Integration of most changes from the GoogleTV project around the convolver/sc...

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"
+
 // 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
 // object for the filter values contributing to it. You build up the filter
 // list by calling AddFilter for each output pixel (in order).
 //
 // We do 2-dimensional convolution by first convolving each row by one
 // ConvolutionFilter1D, then convolving each column by another one.
 //
 // Entries are stored in fixed point, shifted left by kShiftBits.
 class ConvolutionFilter1D {
  public:
   typedef short Fixed;
 
   // The number of bits that fixed point values are shifted by.
   enum { kShiftBits = 14 };
 
   ConvolutionFilter1D();
   ~ConvolutionFilter1D();
 
   // Convert between floating point and our fixed point representation.
   static Fixed FloatToFixed(float f) {
     return static_cast<Fixed>(f * (1 << kShiftBits));
   }
   static unsigned char FixedToChar(Fixed x) {
     return static_cast<unsigned char>(x >> kShiftBits);
   }
+  static float FixedToFloat(Fixed x) {
+    // The cast relies on Fixed being a short, implying that on
+    // the platforms we care about all (16) bits will fit into
+    // the mantissa of a (32-bit) float.
+    COMPILE_ASSERT(sizeof(Fixed) == 2, fixed_type_should_fit_in_float_mantissa);
+    float raw = static_cast<float>(x);
+    return ldexpf(raw, -kShiftBits);
+  }
 
   // Returns the maximum pixel span of a filter.
   int max_filter() const { return max_filter_; }
 
   // Returns the number of filters in this filter. This is the dimension of the
   // output image.
   int num_values() const { return static_cast<int>(filters_.size()); }
 
   // Appends the given list of scaling values for generating a given output
   // pixel. |filter_offset| is the distance from the edge of the image to where
@@ skipping 20 matching lines @@
   // image in the direction we're convolving. The offset and length of the
   // filter values are put into the corresponding out arguments (see AddFilter
   // above for what these mean), and a pointer to the first scaling factor is
   // returned. There will be |filter_length| values in this array.
   inline const Fixed* FilterForValue(int value_offset,
                                      int* filter_offset,
                                      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];
   }
 
  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;
@@ skipping 30 matching lines @@
 // true and it will work properly, but setting this to false will be a few
 // percent faster if you know the image is opaque.
 //
 // 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);
 
 }  // namespace skia
 
 #endif  // SKIA_EXT_CONVOLVER_H_
-