Home | History | Annotate | Download | only in neon
      1 /*
      2  *  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #include "./vp9_rtcd.h"
     12 #include "vp9/common/vp9_common.h"
     13 #include "vpx_ports/mem.h"
     14 
     15 void vp9_convolve8_neon(const uint8_t *src, ptrdiff_t src_stride,
     16                         uint8_t *dst, ptrdiff_t dst_stride,
     17                         const int16_t *filter_x, int x_step_q4,
     18                         const int16_t *filter_y, int y_step_q4,
     19                         int w, int h) {
     20   /* Given our constraints: w <= 64, h <= 64, taps == 8 we can reduce the
     21    * maximum buffer size to 64 * 64 + 7 (+ 1 to make it divisible by 4).
     22    */
     23   DECLARE_ALIGNED_ARRAY(8, uint8_t, temp, 64 * 72);
     24 
     25   // Account for the vertical phase needing 3 lines prior and 4 lines post
     26   int intermediate_height = h + 7;
     27 
     28   if (x_step_q4 != 16 || y_step_q4 != 16)
     29     return vp9_convolve8_c(src, src_stride,
     30                            dst, dst_stride,
     31                            filter_x, x_step_q4,
     32                            filter_y, y_step_q4,
     33                            w, h);
     34 
     35   /* Filter starting 3 lines back. The neon implementation will ignore the
     36    * given height and filter a multiple of 4 lines. Since this goes in to
     37    * the temp buffer which has lots of extra room and is subsequently discarded
     38    * this is safe if somewhat less than ideal.
     39    */
     40   vp9_convolve8_horiz_neon(src - src_stride * 3, src_stride,
     41                            temp, 64,
     42                            filter_x, x_step_q4, filter_y, y_step_q4,
     43                            w, intermediate_height);
     44 
     45   /* Step into the temp buffer 3 lines to get the actual frame data */
     46   vp9_convolve8_vert_neon(temp + 64 * 3, 64,
     47                           dst, dst_stride,
     48                           filter_x, x_step_q4, filter_y, y_step_q4,
     49                           w, h);
     50 }
     51 
     52 void vp9_convolve8_avg_neon(const uint8_t *src, ptrdiff_t src_stride,
     53                             uint8_t *dst, ptrdiff_t dst_stride,
     54                             const int16_t *filter_x, int x_step_q4,
     55                             const int16_t *filter_y, int y_step_q4,
     56                             int w, int h) {
     57   DECLARE_ALIGNED_ARRAY(8, uint8_t, temp, 64 * 72);
     58   int intermediate_height = h + 7;
     59 
     60   if (x_step_q4 != 16 || y_step_q4 != 16)
     61     return vp9_convolve8_avg_c(src, src_stride,
     62                                dst, dst_stride,
     63                                filter_x, x_step_q4,
     64                                filter_y, y_step_q4,
     65                                w, h);
     66 
     67   /* This implementation has the same issues as above. In addition, we only want
     68    * to average the values after both passes.
     69    */
     70   vp9_convolve8_horiz_neon(src - src_stride * 3, src_stride,
     71                            temp, 64,
     72                            filter_x, x_step_q4, filter_y, y_step_q4,
     73                            w, intermediate_height);
     74   vp9_convolve8_avg_vert_neon(temp + 64 * 3,
     75                               64, dst, dst_stride,
     76                               filter_x, x_step_q4, filter_y, y_step_q4,
     77                               w, h);
     78 }
     79