[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 320 matching lines @@
     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]);
 typedef void (*ConvolveHorizontally_pointer)(
     const unsigned char* src_data,
     const ConvolutionFilter1D& filter,
-    unsigned char* out_row);
+    unsigned char* out_row,
+    bool has_alpha);
 
 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
+    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 77 matching lines @@
         }
         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) {
           simd.convolve_horizontally(
               &source_data[next_x_row * source_byte_row_stride],
-              filter_x, row_buffer.AdvanceRow());
+              filter_x, row_buffer.AdvanceRow(), source_has_alpha);
         } 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