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

skia/ext/convolver.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
 #include <algorithm>
 
 #include "skia/ext/convolver.h"
 #include "third_party/skia/include/core/SkTypes.h"
 
 namespace skia {
 
@@ skipping 214 matching lines @@
 ConvolutionFilter1D::ConvolutionFilter1D()
     : max_filter_(0) {
 }
 
 ConvolutionFilter1D::~ConvolutionFilter1D() {
 }
 
 void ConvolutionFilter1D::AddFilter(int filter_offset,
                                     const float* filter_values,
                                     int filter_length) {
-  FilterInstance instance;
-  instance.data_location = static_cast<int>(filter_values_.size());
-  instance.offset = filter_offset;
-  instance.length = filter_length;
-  filters_.push_back(instance);
+  SkASSERT(filter_length > 0);
 
-  SkASSERT(filter_length > 0);
-  for (int i = 0; i < filter_length; i++)
-    filter_values_.push_back(FloatToFixed(filter_values[i]));
+  std::vector<Fixed> fixed_values;
+  fixed_values.reserve(filter_length);
 
-  max_filter_ = std::max(max_filter_, filter_length);
+  for (int i = 0; i < filter_length; ++i)
+    fixed_values.push_back(FloatToFixed(filter_values[i]));
+
+  AddFilter(filter_offset, &fixed_values[0], filter_length);
 }
 
 void ConvolutionFilter1D::AddFilter(int filter_offset,
                                     const Fixed* filter_values,
                                     int filter_length) {
+  // It is common for leading/trailing filter values to be zeros. In such
+  // cases it is beneficial to only store the central factors.
+  // For a scaling to 1/4th in each dimension using a Lanczos-2 filter on
+  // a 1080p image this optimization gives a ~10% speed improvement.
+  int first_non_zero = 0;
+  while (first_non_zero < filter_length && filter_values[first_non_zero] == 0)
+    first_non_zero++;
+
+  if (first_non_zero < filter_length) {
+    // Here we have at least one non-zero factor.
+    int last_non_zero = filter_length - 1;
+    while (last_non_zero >= 0 && filter_values[last_non_zero] == 0)
+      last_non_zero--;
+
+    filter_offset += first_non_zero;
+    filter_length = last_non_zero + 1 - first_non_zero;
+    SkASSERT(filter_length > 0);
+
+    for (int i = first_non_zero; i <= last_non_zero; i++)
+      filter_values_.push_back(filter_values[i]);
+  } else {
+    // Here all the factors were zeroes.
+    filter_length = 0;
+  }
+
   FilterInstance instance;
-  instance.data_location = static_cast<int>(filter_values_.size());
+
+  // We pushed filter_length elements onto filter_values_
+  instance.data_location = (static_cast<int>(filter_values_.size()) -
+                            filter_length);
   instance.offset = filter_offset;
   instance.length = filter_length;
   filters_.push_back(instance);
 
-  SkASSERT(filter_length > 0);
-  for (int i = 0; i < filter_length; i++)
-    filter_values_.push_back(filter_values[i]);
-
   max_filter_ = std::max(max_filter_, filter_length);
 }
 
 // BGRAConvolve2D -------------------------------------------------------------
 
 void BGRAConvolve2D(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) {
   int max_y_filter_size = filter_y.max_filter();
 
   // The next row in the input that we will generate a horizontally
   // convolved row for. If the filter doesn't start at the beginning of the
   // image (this is the case when we are only resizing a subset), then we
   // don't want to generate any output rows before that. Compute the starting
   // row for convolution as the first pixel for the first vertical filter.
   int filter_offset, filter_length;
   const ConvolutionFilter1D::Fixed* filter_values =
       filter_y.FilterForValue(0, &filter_offset, &filter_length);
   int next_x_row = filter_offset;
 
   // We loop over each row in the input doing a horizontal convolution. This
   // will result in a horizontally convolved image. We write the results into
   // a circular buffer of convolved rows and do vertical convolution as rows
   // are available. This prevents us from having to store the entire
   // intermediate image and helps cache coherency.
   CircularRowBuffer row_buffer(filter_x.num_values(), max_y_filter_size,
                                filter_offset);
 
   // Loop over every possible output row, processing just enough horizontal
   // convolutions to run each subsequent vertical convolution.
-  int output_row_byte_width = filter_x.num_values() * 4;
+  SkASSERT(output_byte_row_stride >= filter_x.num_values() * 4);
   int num_output_rows = filter_y.num_values();
   for (int out_y = 0; out_y < num_output_rows; out_y++) {
     filter_values = filter_y.FilterForValue(out_y,
                                             &filter_offset, &filter_length);
 
     // Generate output rows until we have enough to run the current filter.
     while (next_x_row < filter_offset + filter_length) {
       if (source_has_alpha) {
         ConvolveHorizontally<true>(
             &source_data[next_x_row * source_byte_row_stride],
             filter_x, row_buffer.AdvanceRow());
       } else {
         ConvolveHorizontally<false>(
             &source_data[next_x_row * source_byte_row_stride],
             filter_x, row_buffer.AdvanceRow());
       }
       next_x_row++;
     }
 
     // Compute where in the output image this row of final data will go.
-    unsigned char* cur_output_row = &output[out_y * output_row_byte_width];
+    unsigned char* cur_output_row = &output[out_y * output_byte_row_stride];
 
     // Get the list of rows that the circular buffer has, in order.
     int first_row_in_circular_buffer;
     unsigned char* const* rows_to_convolve =
         row_buffer.GetRowAddresses(&first_row_in_circular_buffer);
 
     // Now compute the start of the subset of those rows that the filter
     // needs.
     unsigned char* const* first_row_for_filter =
         &rows_to_convolve[filter_offset - first_row_in_circular_buffer];
 
     if (source_has_alpha) {
       ConvolveVertically<true>(filter_values, filter_length,
                                first_row_for_filter,
                                filter_x.num_values(), cur_output_row);
     } else {
       ConvolveVertically<false>(filter_values, filter_length,
                                 first_row_for_filter,
                                 filter_x.num_values(), cur_output_row);
     }
   }
 }
 
 }  // namespace skia
-