[MIPS] Added MIPS DSPr2 optimization for BGRAConvolve2D routine

skia/ext/convolver.cc

 // 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 "base/logging.h"
 #include "skia/ext/convolver.h"
 #include "skia/ext/convolver_SSE2.h"
+#include "skia/ext/convolver_mips_dspr2.h"
 #include "third_party/skia/include/core/SkSize.h"
 #include "third_party/skia/include/core/SkTypes.h"
 
 namespace skia {
 
 namespace {
 
 // Converts the argument to an 8-bit unsigned value by clamping to the range
 // 0-255.
 inline unsigned char ClampTo8(int a) {
@@ skipping 317 matching lines @@
     const ConvolutionFilter1D::Fixed* filter_values,
     int filter_length,
     unsigned char* const* source_data_rows,
     int pixel_width,
     unsigned char* out_row,
     bool has_alpha);
 typedef void (*Convolve4RowsHorizontally_pointer)(
     const unsigned char* src_data[4],
     const ConvolutionFilter1D& filter,
     unsigned char* out_row[4]);
+#if SIMD_MIPS_DSPR2
+typedef void (*ConvolveHorizontally_pointer)(
+    const unsigned char* src_data,
+    const ConvolutionFilter1D& filter,
+    unsigned char* out_row,
+    bool has_alpha);

[hubbe, 2013/05/10 19:39:09]

Just add "has_alpha" to all implementations instead of creating a special
typedef for MIPS.

[Stephen White, 2013/05/10 20:31:26]

+1 to that.

+#else
 typedef void (*ConvolveHorizontally_pointer)(
     const unsigned char* src_data,
     const ConvolutionFilter1D& filter,
     unsigned char* out_row);
+#endif
 
 struct ConvolveProcs {
   // This is how many extra pixels may be read by the
   // conolve*horizontally functions.
   int extra_horizontal_reads;
   ConvolveVertically_pointer convolve_vertically;
   Convolve4RowsHorizontally_pointer convolve_4rows_horizontally;
   ConvolveHorizontally_pointer convolve_horizontally;
 };
 
 void SetupSIMD(ConvolveProcs *procs) {
 #ifdef SIMD_SSE2
   base::CPU cpu;
   if (cpu.has_sse2()) {
     procs->extra_horizontal_reads = 3;
     procs->convolve_vertically = &ConvolveVertically_SSE2;
     procs->convolve_4rows_horizontally = &Convolve4RowsHorizontally_SSE2;
     procs->convolve_horizontally = &ConvolveHorizontally_SSE2;
   }
+#elif defined SIMD_MIPS_DSPR2

[Stephen White, 2013/05/10 20:31:26]

You use "#if" above, but "#if defined" here.  Please choose one (preferably #if,
since it matches SIMD_SSE2).

[Stephen White, 2013/05/13 14:08:43]

Sorry, my mistake.  This should be #elif defined(SIMD_MIPS_DSPR2).  It's the
other ones that were wrong (and are now removed).

[Teodora Novkovic, 2013/05/13 16:23:06]

Done.

[Teodora Novkovic, 2013/05/13 16:23:06]

Done.

+    procs->extra_horizontal_reads = 3;
+    procs->convolve_vertically = &ConvolveVertically_mips_dspr2;
+    procs->convolve_horizontally = &ConvolveHorizontally_mips_dspr2;
 #endif
 }
 
 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,
@@ skipping 75 matching lines @@
           src[i] = &source_data[(next_x_row + i) * source_byte_row_stride];
           out_row[i] = row_buffer.AdvanceRow();
         }
         simd.convolve_4rows_horizontally(src, filter_x, out_row);
         next_x_row += 4;
       } else {
         // Check if we need to avoid SSE2 for this row.
         if (simd.convolve_horizontally &&
             next_x_row < last_filter_offset + last_filter_length -
             avoid_simd_rows) {
+#if SIMD_MIPS_DSPR2
+          simd.convolve_horizontally(
+              &source_data[next_x_row * source_byte_row_stride],
+              filter_x, row_buffer.AdvanceRow(), source_has_alpha);
+#else
           simd.convolve_horizontally(
               &source_data[next_x_row * source_byte_row_stride],
               filter_x, row_buffer.AdvanceRow());
+#endif
         } else {
           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());
           }
@@ skipping 188 matching lines @@
 
       for (; i < filter_length; ++i)
         accval += filter_values[i] * source_data[pixel_byte_index];
 
       *target_byte = BringBackTo8(accval, absolute_values);
     }
   }
 }
 
 }  // namespace skia