PageRenderTime 33ms CodeModel.GetById 11ms app.highlight 17ms RepoModel.GetById 1ms app.codeStats 0ms

/media/libvpx/vp8/common/arm/neon/loopfiltersimpleverticaledge_neon.asm

http://github.com/zpao/v8monkey
Assembly | 154 lines | 101 code | 29 blank | 24 comment | 0 complexity | 1d35be9864b3ea51b5ed81de3c048ab4 MD5 | raw file
  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    ;EXPORT  |vp8_loop_filter_simple_vertical_edge_neon|
 13    EXPORT |vp8_loop_filter_bvs_neon|
 14    EXPORT |vp8_loop_filter_mbvs_neon|
 15    ARM
 16    PRESERVE8
 17
 18    AREA ||.text||, CODE, READONLY, ALIGN=2
 19
 20; r0    unsigned char *s, PRESERVE
 21; r1    int p, PRESERVE
 22; q1    limit, PRESERVE
 23
 24|vp8_loop_filter_simple_vertical_edge_neon| PROC
 25    sub         r0, r0, #2                  ; move src pointer down by 2 columns
 26    add         r12, r1, r1
 27    add         r3, r0, r1
 28
 29    vld4.8      {d6[0], d7[0], d8[0], d9[0]}, [r0], r12
 30    vld4.8      {d6[1], d7[1], d8[1], d9[1]}, [r3], r12
 31    vld4.8      {d6[2], d7[2], d8[2], d9[2]}, [r0], r12
 32    vld4.8      {d6[3], d7[3], d8[3], d9[3]}, [r3], r12
 33    vld4.8      {d6[4], d7[4], d8[4], d9[4]}, [r0], r12
 34    vld4.8      {d6[5], d7[5], d8[5], d9[5]}, [r3], r12
 35    vld4.8      {d6[6], d7[6], d8[6], d9[6]}, [r0], r12
 36    vld4.8      {d6[7], d7[7], d8[7], d9[7]}, [r3], r12
 37
 38    vld4.8      {d10[0], d11[0], d12[0], d13[0]}, [r0], r12
 39    vld4.8      {d10[1], d11[1], d12[1], d13[1]}, [r3], r12
 40    vld4.8      {d10[2], d11[2], d12[2], d13[2]}, [r0], r12
 41    vld4.8      {d10[3], d11[3], d12[3], d13[3]}, [r3], r12
 42    vld4.8      {d10[4], d11[4], d12[4], d13[4]}, [r0], r12
 43    vld4.8      {d10[5], d11[5], d12[5], d13[5]}, [r3], r12
 44    vld4.8      {d10[6], d11[6], d12[6], d13[6]}, [r0], r12
 45    vld4.8      {d10[7], d11[7], d12[7], d13[7]}, [r3]
 46
 47    vswp        d7, d10
 48    vswp        d12, d9
 49
 50    ;vp8_filter_mask() function
 51    ;vp8_hevmask() function
 52    sub         r0, r0, r1, lsl #4
 53    vabd.u8     q15, q5, q4                 ; abs(p0 - q0)
 54    vabd.u8     q14, q3, q6                 ; abs(p1 - q1)
 55
 56    vqadd.u8    q15, q15, q15               ; abs(p0 - q0) * 2
 57    vshr.u8     q14, q14, #1                ; abs(p1 - q1) / 2
 58    vmov.u8     q0, #0x80                   ; 0x80
 59    vmov.s16    q11, #3
 60    vqadd.u8    q15, q15, q14               ; abs(p0 - q0) * 2 + abs(p1 - q1) / 2
 61
 62    veor        q4, q4, q0                  ; qs0: q0 offset to convert to a signed value
 63    veor        q5, q5, q0                  ; ps0: p0 offset to convert to a signed value
 64    veor        q3, q3, q0                  ; ps1: p1 offset to convert to a signed value
 65    veor        q6, q6, q0                  ; qs1: q1 offset to convert to a signed value
 66
 67    vcge.u8     q15, q1, q15                ; abs(p0 - q0)*2 + abs(p1-q1)/2 > flimit*2 + limit)*-1
 68
 69    vsubl.s8    q2, d8, d10                 ; ( qs0 - ps0)
 70    vsubl.s8    q13, d9, d11
 71
 72    vqsub.s8    q14, q3, q6                  ; vp8_filter = vp8_signed_char_clamp(ps1-qs1)
 73
 74    vmul.s16    q2, q2, q11                 ;  3 * ( qs0 - ps0)
 75    vmul.s16    q13, q13, q11
 76
 77    vmov.u8     q11, #0x03                  ; 0x03
 78    vmov.u8     q12, #0x04                  ; 0x04
 79
 80    vaddw.s8    q2, q2, d28                  ; vp8_filter + 3 * ( qs0 - ps0)
 81    vaddw.s8    q13, q13, d29
 82
 83    vqmovn.s16  d28, q2                      ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
 84    vqmovn.s16  d29, q13
 85
 86    add         r0, r0, #1
 87    add         r3, r0, r1
 88
 89    vand        q14, q14, q15                 ; vp8_filter &= mask
 90
 91    vqadd.s8    q2, q14, q11                 ; Filter2 = vp8_signed_char_clamp(vp8_filter+3)
 92    vqadd.s8    q3, q14, q12                 ; Filter1 = vp8_signed_char_clamp(vp8_filter+4)
 93    vshr.s8     q2, q2, #3                  ; Filter2 >>= 3
 94    vshr.s8     q14, q3, #3                  ; Filter1 >>= 3
 95
 96    ;calculate output
 97    vqadd.s8    q11, q5, q2                 ; u = vp8_signed_char_clamp(ps0 + Filter2)
 98    vqsub.s8    q10, q4, q14                 ; u = vp8_signed_char_clamp(qs0 - Filter1)
 99
100    veor        q6, q11, q0                 ; *op0 = u^0x80
101    veor        q7, q10, q0                 ; *oq0 = u^0x80
102    add         r12, r1, r1
103    vswp        d13, d14
104
105    ;store op1, op0, oq0, oq1
106    vst2.8      {d12[0], d13[0]}, [r0], r12
107    vst2.8      {d12[1], d13[1]}, [r3], r12
108    vst2.8      {d12[2], d13[2]}, [r0], r12
109    vst2.8      {d12[3], d13[3]}, [r3], r12
110    vst2.8      {d12[4], d13[4]}, [r0], r12
111    vst2.8      {d12[5], d13[5]}, [r3], r12
112    vst2.8      {d12[6], d13[6]}, [r0], r12
113    vst2.8      {d12[7], d13[7]}, [r3], r12
114    vst2.8      {d14[0], d15[0]}, [r0], r12
115    vst2.8      {d14[1], d15[1]}, [r3], r12
116    vst2.8      {d14[2], d15[2]}, [r0], r12
117    vst2.8      {d14[3], d15[3]}, [r3], r12
118    vst2.8      {d14[4], d15[4]}, [r0], r12
119    vst2.8      {d14[5], d15[5]}, [r3], r12
120    vst2.8      {d14[6], d15[6]}, [r0], r12
121    vst2.8      {d14[7], d15[7]}, [r3]
122
123    bx          lr
124    ENDP        ; |vp8_loop_filter_simple_vertical_edge_neon|
125
126; r0    unsigned char *y
127; r1    int ystride
128; r2    const unsigned char *blimit
129
130|vp8_loop_filter_bvs_neon| PROC
131    push        {r4, lr}
132    ldrb        r3, [r2]                   ; load blim from mem
133    mov         r4, r0
134    add         r0, r0, #4
135    vdup.s8     q1, r3                     ; duplicate blim
136    bl          vp8_loop_filter_simple_vertical_edge_neon
137    ; vp8_loop_filter_simple_vertical_edge_neon preserves  r1 and q1
138    add         r0, r4, #8
139    bl          vp8_loop_filter_simple_vertical_edge_neon
140    add         r0, r4, #12
141    pop         {r4, lr}
142    b           vp8_loop_filter_simple_vertical_edge_neon
143    ENDP        ;|vp8_loop_filter_bvs_neon|
144
145; r0    unsigned char *y
146; r1    int ystride
147; r2    const unsigned char *blimit
148
149|vp8_loop_filter_mbvs_neon| PROC
150    ldrb        r3, [r2]                   ; load mblim from mem
151    vdup.s8     q1, r3                     ; duplicate mblim
152    b           vp8_loop_filter_simple_vertical_edge_neon
153    ENDP        ;|vp8_loop_filter_bvs_neon|
154    END