Home | History | Annotate | Download | only in x86 
      1 /*
      2  *  Copyright (c) 2010 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 
     12 #include "vpx_ports/config.h"
     13 #include "loopfilter.h"
     14 
     15 prototype_loopfilter(vp8_loop_filter_horizontal_edge_c);
     16 prototype_loopfilter(vp8_loop_filter_vertical_edge_c);
     17 prototype_loopfilter(vp8_mbloop_filter_horizontal_edge_c);
     18 prototype_loopfilter(vp8_mbloop_filter_vertical_edge_c);
     19 prototype_loopfilter(vp8_loop_filter_simple_horizontal_edge_c);
     20 prototype_loopfilter(vp8_loop_filter_simple_vertical_edge_c);
     21 
     22 prototype_loopfilter(vp8_mbloop_filter_vertical_edge_mmx);
     23 prototype_loopfilter(vp8_mbloop_filter_horizontal_edge_mmx);
     24 prototype_loopfilter(vp8_loop_filter_vertical_edge_mmx);
     25 prototype_loopfilter(vp8_loop_filter_horizontal_edge_mmx);
     26 prototype_loopfilter(vp8_loop_filter_simple_vertical_edge_mmx);
     27 prototype_loopfilter(vp8_loop_filter_simple_horizontal_edge_mmx);
     28 
     29 prototype_loopfilter(vp8_loop_filter_vertical_edge_sse2);
     30 prototype_loopfilter(vp8_loop_filter_horizontal_edge_sse2);
     31 prototype_loopfilter(vp8_mbloop_filter_vertical_edge_sse2);
     32 prototype_loopfilter(vp8_mbloop_filter_horizontal_edge_sse2);
     33 prototype_loopfilter(vp8_loop_filter_simple_vertical_edge_sse2);
     34 prototype_loopfilter(vp8_loop_filter_simple_horizontal_edge_sse2);
     35 prototype_loopfilter(vp8_fast_loop_filter_vertical_edges_sse2);
     36 
     37 extern loop_filter_uvfunction vp8_loop_filter_horizontal_edge_uv_sse2;
     38 extern loop_filter_uvfunction vp8_loop_filter_vertical_edge_uv_sse2;
     39 extern loop_filter_uvfunction vp8_mbloop_filter_horizontal_edge_uv_sse2;
     40 extern loop_filter_uvfunction vp8_mbloop_filter_vertical_edge_uv_sse2;
     41 
     42 #if HAVE_MMX
     43 // Horizontal MB filtering
     44 void vp8_loop_filter_mbh_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
     45                              int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
     46 {
     47     (void) simpler_lpf;
     48     vp8_mbloop_filter_horizontal_edge_mmx(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
     49 
     50     if (u_ptr)
     51         vp8_mbloop_filter_horizontal_edge_mmx(u_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1);
     52 
     53     if (v_ptr)
     54         vp8_mbloop_filter_horizontal_edge_mmx(v_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1);
     55 }
     56 
     57 
     58 void vp8_loop_filter_mbhs_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
     59                               int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
     60 {
     61     (void) u_ptr;
     62     (void) v_ptr;
     63     (void) uv_stride;
     64     (void) simpler_lpf;
     65     vp8_loop_filter_simple_horizontal_edge_mmx(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
     66 }
     67 
     68 
     69 // Vertical MB Filtering
     70 void vp8_loop_filter_mbv_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
     71                              int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
     72 {
     73     (void) simpler_lpf;
     74     vp8_mbloop_filter_vertical_edge_mmx(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
     75 
     76     if (u_ptr)
     77         vp8_mbloop_filter_vertical_edge_mmx(u_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1);
     78 
     79     if (v_ptr)
     80         vp8_mbloop_filter_vertical_edge_mmx(v_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, 1);
     81 }
     82 
     83 
     84 void vp8_loop_filter_mbvs_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
     85                               int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
     86 {
     87     (void) u_ptr;
     88     (void) v_ptr;
     89     (void) uv_stride;
     90     (void) simpler_lpf;
     91     vp8_loop_filter_simple_vertical_edge_mmx(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
     92 }
     93 
     94 
     95 // Horizontal B Filtering
     96 void vp8_loop_filter_bh_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
     97                             int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
     98 {
     99     (void) simpler_lpf;
    100     vp8_loop_filter_horizontal_edge_mmx(y_ptr + 4 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    101     vp8_loop_filter_horizontal_edge_mmx(y_ptr + 8 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    102     vp8_loop_filter_horizontal_edge_mmx(y_ptr + 12 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    103 
    104     if (u_ptr)
    105         vp8_loop_filter_horizontal_edge_mmx(u_ptr + 4 * uv_stride, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1);
    106 
    107     if (v_ptr)
    108         vp8_loop_filter_horizontal_edge_mmx(v_ptr + 4 * uv_stride, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1);
    109 }
    110 
    111 
    112 void vp8_loop_filter_bhs_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    113                              int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    114 {
    115     (void) u_ptr;
    116     (void) v_ptr;
    117     (void) uv_stride;
    118     (void) simpler_lpf;
    119     vp8_loop_filter_simple_horizontal_edge_mmx(y_ptr + 4 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    120     vp8_loop_filter_simple_horizontal_edge_mmx(y_ptr + 8 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    121     vp8_loop_filter_simple_horizontal_edge_mmx(y_ptr + 12 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    122 }
    123 
    124 
    125 // Vertical B Filtering
    126 void vp8_loop_filter_bv_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    127                             int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    128 {
    129     (void) simpler_lpf;
    130     vp8_loop_filter_vertical_edge_mmx(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    131     vp8_loop_filter_vertical_edge_mmx(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    132     vp8_loop_filter_vertical_edge_mmx(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    133 
    134     if (u_ptr)
    135         vp8_loop_filter_vertical_edge_mmx(u_ptr + 4, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1);
    136 
    137     if (v_ptr)
    138         vp8_loop_filter_vertical_edge_mmx(v_ptr + 4, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, 1);
    139 }
    140 
    141 
    142 void vp8_loop_filter_bvs_mmx(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    143                              int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    144 {
    145     (void) u_ptr;
    146     (void) v_ptr;
    147     (void) uv_stride;
    148     (void) simpler_lpf;
    149     vp8_loop_filter_simple_vertical_edge_mmx(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    150     vp8_loop_filter_simple_vertical_edge_mmx(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    151     vp8_loop_filter_simple_vertical_edge_mmx(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    152 }
    153 #endif
    154 
    155 
    156 // Horizontal MB filtering
    157 #if HAVE_SSE2
    158 void vp8_loop_filter_mbh_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    159                               int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    160 {
    161     (void) simpler_lpf;
    162     vp8_mbloop_filter_horizontal_edge_sse2(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
    163 
    164     if (u_ptr)
    165         vp8_mbloop_filter_horizontal_edge_uv_sse2(u_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, v_ptr);
    166 }
    167 
    168 
    169 void vp8_loop_filter_mbhs_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    170                                int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    171 {
    172     (void) u_ptr;
    173     (void) v_ptr;
    174     (void) uv_stride;
    175     (void) simpler_lpf;
    176     vp8_loop_filter_simple_horizontal_edge_sse2(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
    177 }
    178 
    179 
    180 // Vertical MB Filtering
    181 void vp8_loop_filter_mbv_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    182                               int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    183 {
    184     (void) simpler_lpf;
    185     vp8_mbloop_filter_vertical_edge_sse2(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
    186 
    187     if (u_ptr)
    188         vp8_mbloop_filter_vertical_edge_uv_sse2(u_ptr, uv_stride, lfi->uvmbflim, lfi->uvlim, lfi->uvmbthr, v_ptr);
    189 }
    190 
    191 
    192 void vp8_loop_filter_mbvs_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    193                                int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    194 {
    195     (void) u_ptr;
    196     (void) v_ptr;
    197     (void) uv_stride;
    198     (void) simpler_lpf;
    199     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr, y_stride, lfi->mbflim, lfi->lim, lfi->mbthr, 2);
    200 }
    201 
    202 
    203 // Horizontal B Filtering
    204 void vp8_loop_filter_bh_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    205                              int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    206 {
    207     (void) simpler_lpf;
    208     vp8_loop_filter_horizontal_edge_sse2(y_ptr + 4 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    209     vp8_loop_filter_horizontal_edge_sse2(y_ptr + 8 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    210     vp8_loop_filter_horizontal_edge_sse2(y_ptr + 12 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    211 
    212     if (u_ptr)
    213         vp8_loop_filter_horizontal_edge_uv_sse2(u_ptr + 4 * uv_stride, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, v_ptr + 4 * uv_stride);
    214 }
    215 
    216 
    217 void vp8_loop_filter_bhs_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    218                               int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    219 {
    220     (void) u_ptr;
    221     (void) v_ptr;
    222     (void) uv_stride;
    223     (void) simpler_lpf;
    224     vp8_loop_filter_simple_horizontal_edge_sse2(y_ptr + 4 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    225     vp8_loop_filter_simple_horizontal_edge_sse2(y_ptr + 8 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    226     vp8_loop_filter_simple_horizontal_edge_sse2(y_ptr + 12 * y_stride, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    227 }
    228 
    229 
    230 // Vertical B Filtering
    231 void vp8_loop_filter_bv_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    232                              int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    233 {
    234     (void) simpler_lpf;
    235     vp8_loop_filter_vertical_edge_sse2(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    236     vp8_loop_filter_vertical_edge_sse2(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    237     vp8_loop_filter_vertical_edge_sse2(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    238 
    239     if (u_ptr)
    240         vp8_loop_filter_vertical_edge_uv_sse2(u_ptr + 4, uv_stride, lfi->uvflim, lfi->uvlim, lfi->uvthr, v_ptr + 4);
    241 }
    242 
    243 
    244 void vp8_loop_filter_bvs_sse2(unsigned char *y_ptr, unsigned char *u_ptr, unsigned char *v_ptr,
    245                               int y_stride, int uv_stride, loop_filter_info *lfi, int simpler_lpf)
    246 {
    247     (void) u_ptr;
    248     (void) v_ptr;
    249     (void) uv_stride;
    250     (void) simpler_lpf;
    251     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    252     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    253     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    254 }
    255 
    256 #endif
    257 
    258 #if 0
    259 void vp8_fast_loop_filter_vertical_edges_sse(unsigned char *y_ptr,
    260         int y_stride,
    261         loop_filter_info *lfi)
    262 {
    263 
    264     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr + 4, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    265     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr + 8, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    266     vp8_loop_filter_simple_vertical_edge_sse2(y_ptr + 12, y_stride, lfi->flim, lfi->lim, lfi->thr, 2);
    267 }
    268 #endif
    269