VPX: removed step checks from mips convolve code

The check is handled by the predictor table.

Change-Id: I5e5084ebb46be8087c8c9d80b5f76e919a1cd05b

vpx_dsp/mips/convolve2_avg_dspr2.c

@@ -233,9 +233,10 @@ void vpx_convolve2_avg_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                   const int16_t *filter_x, int x_step_q4,
                                   const int16_t *filter_y, int y_step_q4,
                                   int w, int h) {
-  if (16 == y_step_q4) {
   uint32_t pos = 38;
 
+  assert(y_step_q4 == 16);
+
   /* bit positon for extract from acc */
   __asm__ __volatile__ (
     "wrdsp      %[pos],     1           \n\t"
@@ -268,12 +269,5 @@ void vpx_convolve2_avg_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                w, h);
       break;
   }
-  } else {
-    vpx_convolve8_avg_vert_c(src, src_stride,
-                             dst, dst_stride,
-                             filter_x, x_step_q4,
-                             filter_y, y_step_q4,
-                             w, h);
-  }
 }
 #endif

vpx_dsp/mips/convolve2_avg_horiz_dspr2.c

@@ -768,9 +768,10 @@ void vpx_convolve2_avg_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                    const int16_t *filter_x, int x_step_q4,
                                    const int16_t *filter_y, int y_step_q4,
                                    int w, int h) {
-  if (16 == x_step_q4) {
   uint32_t pos = 38;
 
+  assert(x_step_q4 == 16);
+
   /* bit positon for extract from acc */
   __asm__ __volatile__ (
     "wrdsp      %[pos],     1           \n\t"
@@ -820,12 +821,5 @@ void vpx_convolve2_avg_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                 w, h);
       break;
   }
-  } else {
-    vpx_convolve8_avg_horiz_c(src, src_stride,
-                              dst, dst_stride,
-                              filter_x, x_step_q4,
-                              filter_y, y_step_q4,
-                              w, h);
-  }
 }
 #endif

vpx_dsp/mips/convolve2_horiz_dspr2.c

@@ -646,9 +646,10 @@ void vpx_convolve2_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                const int16_t *filter_x, int x_step_q4,
                                const int16_t *filter_y, int y_step_q4,
                                int w, int h) {
-  if (16 == x_step_q4) {
   uint32_t pos = 38;
 
+  assert(x_step_q4 == 16);
+
   prefetch_load((const uint8_t *)filter_x);
 
   /* bit positon for extract from acc */
@@ -700,12 +701,5 @@ void vpx_convolve2_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                             w, h);
       break;
   }
-  } else {
-    vpx_convolve8_horiz_c(src, src_stride,
-                          dst, dst_stride,
-                          filter_x, x_step_q4,
-                          filter_y, y_step_q4,
-                          w, h);
-  }
 }
 #endif

vpx_dsp/mips/convolve2_vert_dspr2.c

@@ -218,9 +218,10 @@ void vpx_convolve2_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                               const int16_t *filter_x, int x_step_q4,
                               const int16_t *filter_y, int y_step_q4,
                               int w, int h) {
-  if (16 == y_step_q4) {
   uint32_t pos = 38;
 
+  assert(y_step_q4 == 16);
+
   /* bit positon for extract from acc */
   __asm__ __volatile__ (
     "wrdsp      %[pos],     1           \n\t"
@@ -253,12 +254,5 @@ void vpx_convolve2_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                            w, h);
       break;
   }
-  } else {
-    vpx_convolve8_vert_c(src, src_stride,
-                         dst, dst_stride,
-                         filter_x, x_step_q4,
-                         filter_y, y_step_q4,
-                         w, h);
-  }
 }
 #endif

vpx_dsp/mips/convolve8_avg_dspr2.c

@@ -347,6 +347,7 @@ void vpx_convolve8_avg_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                   const int16_t *filter_x, int x_step_q4,
                                   const int16_t *filter_y, int y_step_q4,
                                   int w, int h) {
+  assert(y_step_q4 == 16);
   if (((const int32_t *)filter_y)[1] == 0x800000) {
     vpx_convolve_avg(src, src_stride,
                      dst, dst_stride,
@@ -360,7 +361,6 @@ void vpx_convolve8_avg_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                  filter_y, y_step_q4,
                                  w, h);
   } else {
-    if (16 == y_step_q4) {
     uint32_t pos = 38;
 
     /* bit positon for extract from acc */
@@ -395,13 +395,6 @@ void vpx_convolve8_avg_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                  w, h);
         break;
     }
-    } else {
-      vpx_convolve8_avg_vert_c(src, src_stride,
-                               dst, dst_stride,
-                               filter_x, x_step_q4,
-                               filter_y, y_step_q4,
-                               w, h);
-    }
   }
 }
 
@@ -416,17 +409,12 @@ void vpx_convolve8_avg_dspr2(const uint8_t *src, ptrdiff_t src_stride,
 
   assert(w <= 64);
   assert(h <= 64);
+  assert(x_step_q4 == 16);
+  assert(y_step_q4 == 16);
 
   if (intermediate_height < h)
     intermediate_height = h;
 
-  if (x_step_q4 != 16 || y_step_q4 != 16)
-    return vpx_convolve8_avg_c(src, src_stride,
-                               dst, dst_stride,
-                               filter_x, x_step_q4,
-                               filter_y, y_step_q4,
-                               w, h);
-
   vpx_convolve8_horiz(src - (src_stride * 3), src_stride,
                       temp, 64,
                       filter_x, x_step_q4,

vpx_dsp/mips/convolve8_avg_horiz_dspr2.c

@@ -957,6 +957,7 @@ void vpx_convolve8_avg_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                    const int16_t *filter_x, int x_step_q4,
                                    const int16_t *filter_y, int y_step_q4,
                                    int w, int h) {
+  assert(x_step_q4 == 16);
   if (((const int32_t *)filter_x)[1] == 0x800000) {
     vpx_convolve_avg(src, src_stride,
                      dst, dst_stride,
@@ -970,7 +971,6 @@ void vpx_convolve8_avg_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                   filter_y, y_step_q4,
                                   w, h);
   } else {
-    if (16 == x_step_q4) {
     uint32_t pos = 38;
 
     src -= 3;
@@ -1024,13 +1024,6 @@ void vpx_convolve8_avg_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                   w, h);
         break;
     }
-    } else {
-      vpx_convolve8_avg_horiz_c(src, src_stride,
-                                dst, dst_stride,
-                                filter_x, x_step_q4,
-                                filter_y, y_step_q4,
-                                w, h);
-    }
   }
 }
 #endif

vpx_dsp/mips/convolve8_dspr2.c

@@ -936,6 +936,9 @@ void vpx_convolve8_dspr2(const uint8_t *src, ptrdiff_t src_stride,
   int32_t intermediate_height = ((h * y_step_q4) >> 4) + 7;
   uint32_t pos = 38;
 
+  assert(x_step_q4 == 16);
+  assert(y_step_q4 == 16);
+
   /* bit positon for extract from acc */
   __asm__ __volatile__ (
     "wrdsp      %[pos],     1           \n\t"
@@ -946,13 +949,6 @@ void vpx_convolve8_dspr2(const uint8_t *src, ptrdiff_t src_stride,
   if (intermediate_height < h)
     intermediate_height = h;
 
-  if (x_step_q4 != 16 || y_step_q4 != 16)
-    return vpx_convolve8_c(src, src_stride,
-                           dst, dst_stride,
-                           filter_x, x_step_q4,
-                           filter_y, y_step_q4,
-                           w, h);
-
   if ((((const int32_t *)filter_x)[1] == 0x800000)
       && (((const int32_t *)filter_y)[1] == 0x800000))
     return vpx_convolve_copy(src, src_stride,

vpx_dsp/mips/convolve8_horiz_dspr2.c

@@ -841,6 +841,7 @@ void vpx_convolve8_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                                const int16_t *filter_x, int x_step_q4,
                                const int16_t *filter_y, int y_step_q4,
                                int w, int h) {
+  assert(x_step_q4 == 16);
   if (((const int32_t *)filter_x)[1] == 0x800000) {
     vpx_convolve_copy(src, src_stride,
                       dst, dst_stride,
@@ -854,7 +855,6 @@ void vpx_convolve8_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                               filter_y, y_step_q4,
                               w, h);
   } else {
-    if (16 == x_step_q4) {
     uint32_t pos = 38;
 
     prefetch_load((const uint8_t *)filter_x);
@@ -909,13 +909,6 @@ void vpx_convolve8_horiz_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                               w, h);
         break;
     }
-    } else {
-      vpx_convolve8_horiz_c(src, src_stride,
-                            dst, dst_stride,
-                            filter_x, x_step_q4,
-                            filter_y, y_step_q4,
-                            w, h);
-    }
   }
 }
 #endif

vpx_dsp/mips/convolve8_vert_dspr2.c

@@ -333,6 +333,7 @@ void vpx_convolve8_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                               const int16_t *filter_x, int x_step_q4,
                               const int16_t *filter_y, int y_step_q4,
                               int w, int h) {
+  assert(y_step_q4 == 16);
   if (((const int32_t *)filter_y)[1] == 0x800000) {
     vpx_convolve_copy(src, src_stride,
                       dst, dst_stride,
@@ -346,7 +347,6 @@ void vpx_convolve8_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                              filter_y, y_step_q4,
                              w, h);
   } else {
-    if (16 == y_step_q4) {
     uint32_t pos = 38;
 
     /* bit positon for extract from acc */
@@ -381,13 +381,6 @@ void vpx_convolve8_vert_dspr2(const uint8_t *src, ptrdiff_t src_stride,
                              w, h);
         break;
     }
-    } else {
-      vpx_convolve8_vert_c(src, src_stride,
-                           dst, dst_stride,
-                           filter_x, x_step_q4,
-                           filter_y, y_step_q4,
-                           w, h);
-    }
   }
 }
 

vpx_dsp/mips/vpx_convolve8_avg_horiz_msa.c

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <assert.h>
 #include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/mips/vpx_convolve_msa.h"
 
@@ -665,12 +666,7 @@ void vpx_convolve8_avg_horiz_msa(const uint8_t *src, ptrdiff_t src_stride,
                                  int w, int h) {
   int8_t cnt, filt_hor[8];
 
-  if (16 != x_step_q4) {
+  assert(x_step_q4 == 16);
-    vpx_convolve8_avg_horiz_c(src, src_stride, dst, dst_stride,
-                              filter_x, x_step_q4, filter_y, y_step_q4,
-                              w, h);
-    return;
-  }
 
   if (((const int32_t *)filter_x)[1] == 0x800000) {
     vpx_convolve_avg(src, src_stride, dst, dst_stride,

vpx_dsp/mips/vpx_convolve8_avg_msa.c

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <assert.h>
 #include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/mips/vpx_convolve_msa.h"
 
@@ -574,12 +575,8 @@ void vpx_convolve8_avg_msa(const uint8_t *src, ptrdiff_t src_stride,
                            int w, int h) {
   int8_t cnt, filt_hor[8], filt_ver[8];
 
-  if (16 != x_step_q4 || 16 != y_step_q4) {
+  assert(x_step_q4 == 16);
-    vpx_convolve8_avg_c(src, src_stride, dst, dst_stride,
+  assert(y_step_q4 == 16);
-                        filter_x, x_step_q4, filter_y, y_step_q4,
-                        w, h);
-    return;
-  }
 
   if (((const int32_t *)filter_x)[1] == 0x800000 &&
       ((const int32_t *)filter_y)[1] == 0x800000) {

vpx_dsp/mips/vpx_convolve8_avg_vert_msa.c

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <assert.h>
 #include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/mips/vpx_convolve_msa.h"
 
@@ -639,12 +640,7 @@ void vpx_convolve8_avg_vert_msa(const uint8_t *src, ptrdiff_t src_stride,
                                 int w, int h) {
   int8_t cnt, filt_ver[8];
 
-  if (16 != y_step_q4) {
+  assert(y_step_q4 == 16);
-    vpx_convolve8_avg_vert_c(src, src_stride, dst, dst_stride,
-                             filter_x, x_step_q4, filter_y, y_step_q4,
-                             w, h);
-    return;
-  }
 
   if (((const int32_t *)filter_y)[1] == 0x800000) {
     vpx_convolve_avg(src, src_stride, dst, dst_stride,

vpx_dsp/mips/vpx_convolve8_horiz_msa.c

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <assert.h>
 #include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/mips/vpx_convolve_msa.h"
 
@@ -625,12 +626,7 @@ void vpx_convolve8_horiz_msa(const uint8_t *src, ptrdiff_t src_stride,
                              int w, int h) {
   int8_t cnt, filt_hor[8];
 
-  if (16 != x_step_q4) {
+  assert(x_step_q4 == 16);
-    vpx_convolve8_horiz_c(src, src_stride, dst, dst_stride,
-                          filter_x, x_step_q4, filter_y, y_step_q4,
-                          w, h);
-    return;
-  }
 
   if (((const int32_t *)filter_x)[1] == 0x800000) {
     vpx_convolve_copy(src, src_stride, dst, dst_stride,

vpx_dsp/mips/vpx_convolve8_msa.c

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <assert.h>
 #include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/mips/vpx_convolve_msa.h"
 
@@ -548,12 +549,8 @@ void vpx_convolve8_msa(const uint8_t *src, ptrdiff_t src_stride,
                        int32_t w, int32_t h) {
   int8_t cnt, filt_hor[8], filt_ver[8];
 
-  if (16 != x_step_q4 || 16 != y_step_q4) {
+  assert(x_step_q4 == 16);
-    vpx_convolve8_c(src, src_stride, dst, dst_stride,
+  assert(y_step_q4 == 16);
-                    filter_x, x_step_q4, filter_y, y_step_q4,
-                    w, h);
-    return;
-  }
 
   if (((const int32_t *)filter_x)[1] == 0x800000 &&
       ((const int32_t *)filter_y)[1] == 0x800000) {

vpx_dsp/mips/vpx_convolve8_vert_msa.c

@@ -8,6 +8,7 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <assert.h>
 #include "./vpx_dsp_rtcd.h"
 #include "vpx_dsp/mips/vpx_convolve_msa.h"
 
@@ -632,12 +633,7 @@ void vpx_convolve8_vert_msa(const uint8_t *src, ptrdiff_t src_stride,
                             int w, int h) {
   int8_t cnt, filt_ver[8];
 
-  if (16 != y_step_q4) {
+  assert(y_step_q4 == 16);
-    vpx_convolve8_vert_c(src, src_stride, dst, dst_stride,
-                         filter_x, x_step_q4, filter_y, y_step_q4,
-                         w, h);
-    return;
-  }
 
   if (((const int32_t *)filter_y)[1] == 0x800000) {
     vpx_convolve_copy(src, src_stride, dst, dst_stride,