;
;  Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
;
;  Use of this source code is governed by a BSD-style license and patent
;  grant that can be found in the LICENSE file in the root of the source
;  tree. All contributing project authors may be found in the AUTHORS
;  file in the root of the source tree.
;


    EXPORT |vp8_loop_filter_simple_horizontal_edge_armv6|
    EXPORT |vp8_loop_filter_simple_vertical_edge_armv6|

    AREA    |.text|, CODE, READONLY  ; name this block of code

    MACRO
    TRANSPOSE_MATRIX $a0, $a1, $a2, $a3, $b0, $b1, $b2, $b3
    ; input: $a0, $a1, $a2, $a3; output: $b0, $b1, $b2, $b3
    ; a0: 03 02 01 00
    ; a1: 13 12 11 10
    ; a2: 23 22 21 20
    ; a3: 33 32 31 30
    ;     b3 b2 b1 b0

    uxtb16      $b1, $a1                    ; xx 12 xx 10
    uxtb16      $b0, $a0                    ; xx 02 xx 00
    uxtb16      $b3, $a3                    ; xx 32 xx 30
    uxtb16      $b2, $a2                    ; xx 22 xx 20
    orr         $b1, $b0, $b1, lsl #8       ; 12 02 10 00
    orr         $b3, $b2, $b3, lsl #8       ; 32 22 30 20

    uxtb16      $a1, $a1, ror #8            ; xx 13 xx 11
    uxtb16      $a3, $a3, ror #8            ; xx 33 xx 31
    uxtb16      $a0, $a0, ror #8            ; xx 03 xx 01
    uxtb16      $a2, $a2, ror #8            ; xx 23 xx 21
    orr         $a0, $a0, $a1, lsl #8       ; 13 03 11 01
    orr         $a2, $a2, $a3, lsl #8       ; 33 23 31 21

    pkhtb       $b2, $b3, $b1, asr #16      ; 32 22 12 02   -- p1
    pkhbt       $b0, $b1, $b3, lsl #16      ; 30 20 10 00   -- p3

    pkhtb       $b3, $a2, $a0, asr #16      ; 33 23 13 03   -- p0
    pkhbt       $b1, $a0, $a2, lsl #16      ; 31 21 11 01   -- p2
    MEND


src         RN  r0
pstep       RN  r1

;r0     unsigned char *src_ptr,
;r1     int src_pixel_step,
;r2     const char *flimit,
;r3     const char *limit,
;stack  const char *thresh,
;stack  int  count

;Note: All 16 elements in flimit are equal. So, in the code, only one load is needed
;for flimit. Same way applies to limit and thresh.

;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|vp8_loop_filter_simple_horizontal_edge_armv6| PROC
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    stmdb       sp!, {r4 - r11, lr}

    sub         src, src, pstep, lsl #1     ; move src pointer down by 2 lines

    ldr         r12, [r3], #4               ; limit
    ldr         r3, [src], pstep            ; p1

    ldr         r9, [sp, #36]               ; count for 8-in-parallel
    ldr         r4, [src], pstep            ; p0

    ldr         r7, [r2], #4                ; flimit
    ldr         r5, [src], pstep            ; q0
    ldr         r2, c0x80808080

    ldr         r6, [src]                   ; q1

    uadd8       r7, r7, r7                  ; flimit * 2
    mov         r9, r9, lsl #1              ; 4-in-parallel
    uadd8       r12, r7, r12                ; flimit * 2 + limit

|simple_hnext8|
    ; vp8_simple_filter_mask() function

    uqsub8      r7, r3, r6                  ; p1 - q1
    uqsub8      r8, r6, r3                  ; q1 - p1
    uqsub8      r10, r4, r5                 ; p0 - q0
    uqsub8      r11, r5, r4                 ; q0 - p0
    orr         r8, r8, r7                  ; abs(p1 - q1)
    ldr         lr, c0x7F7F7F7F             ; 01111111 mask
    orr         r10, r10, r11               ; abs(p0 - q0)
    and         r8, lr, r8, lsr #1          ; abs(p1 - q1) / 2
    uqadd8      r10, r10, r10               ; abs(p0 - q0) * 2
    mvn         lr, #0                      ; r10 == -1
    uqadd8      r10, r10, r8                ; abs(p0 - q0)*2 + abs(p1 - q1)/2
    ; STALL waiting on r10 :(
    uqsub8      r10, r10, r12               ; compare to flimit
    mov         r8, #0

    usub8       r10, r8, r10                ; use usub8 instead of ssub8
    ; STALL (maybe?) when are flags set? :/
    sel         r10, lr, r8                 ; filter mask: lr

    cmp         r10, #0
    beq         simple_hskip_filter         ; skip filtering

    ;vp8_simple_filter() function

    eor         r3, r3, r2                  ; p1 offset to convert to a signed value
    eor         r6, r6, r2                  ; q1 offset to convert to a signed value
    eor         r4, r4, r2                  ; p0 offset to convert to a signed value
    eor         r5, r5, r2                  ; q0 offset to convert to a signed value

    qsub8       r3, r3, r6                  ; vp8_filter (r3) = vp8_signed_char_clamp(p1-q1)
    qsub8       r6, r5, r4                  ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( q0 - p0))

    qadd8       r3, r3, r6
    ldr         r8, c0x03030303             ; r8 = 3

    qadd8       r3, r3, r6
    ldr         r7, c0x04040404

    qadd8       r3, r3, r6
    and         r3, r3, lr                  ; vp8_filter &= mask;

    ;save bottom 3 bits so that we round one side +4 and the other +3
    qadd8       r8 , r3 , r8                ; Filter2 (r8) = vp8_signed_char_clamp(vp8_filter+3)
    qadd8       r3 , r3 , r7                ; Filter1 (r3) = vp8_signed_char_clamp(vp8_filter+4)

    mov         r7, #0
    shadd8      r8 , r8 , r7                ; Filter2 >>= 3
    shadd8      r3 , r3 , r7                ; Filter1 >>= 3
    shadd8      r8 , r8 , r7
    shadd8      r3 , r3 , r7
    shadd8      r8 , r8 , r7                ; r8: Filter2
    shadd8      r3 , r3 , r7                ; r7: filter1

    ;calculate output
    sub         src, src, pstep, lsl #1

    qadd8       r4, r4, r8                  ; u = vp8_signed_char_clamp(p0 + Filter2)
    qsub8       r5 ,r5, r3                  ; u = vp8_signed_char_clamp(q0 - Filter1)
    eor         r4, r4, r2                  ; *op0 = u^0x80
    str         r4, [src], pstep            ; store op0 result
    eor         r5, r5, r2                  ; *oq0 = u^0x80
    str         r5, [src], pstep            ; store oq0 result

|simple_hskip_filter|
    add         src, src, #4
    sub         src, src, pstep
    sub         src, src, pstep, lsl #1

    subs        r9, r9, #1

    ;pld            [src]
    ;pld            [src, pstep]
    ;pld            [src, pstep, lsl #1]

    ldrne           r3, [src], pstep            ; p1
    ldrne           r4, [src], pstep            ; p0
    ldrne           r5, [src], pstep            ; q0
    ldrne           r6, [src]                   ; q1

    bne         simple_hnext8

    ldmia       sp!, {r4 - r11, pc}
    ENDP        ; |vp8_loop_filter_simple_horizontal_edge_armv6|


;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
|vp8_loop_filter_simple_vertical_edge_armv6| PROC
;-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    stmdb       sp!, {r4 - r11, lr}

    ldr         r12, [r2], #4               ; r12: flimit
    ldr         r2, c0x80808080
    ldr         r7, [r3], #4                ; limit

    ; load soure data to r7, r8, r9, r10
    ldrh        r3, [src, #-2]
    ldrh        r4, [src], pstep
    uadd8       r12, r12, r12               ; flimit * 2

    ldrh        r5, [src, #-2]
    ldrh        r6, [src], pstep
    uadd8       r12, r12, r7                ; flimit * 2 + limit

    pkhbt       r7, r3, r4, lsl #16

    ldrh        r3, [src, #-2]
    ldrh        r4, [src], pstep
    ldr         r11, [sp, #40]              ; count (r11) for 8-in-parallel

    pkhbt       r8, r5, r6, lsl #16

    ldrh        r5, [src, #-2]
    ldrh        r6, [src], pstep
    mov         r11, r11, lsl #1            ; 4-in-parallel

|simple_vnext8|
    ; vp8_simple_filter_mask() function
    pkhbt       r9, r3, r4, lsl #16
    pkhbt       r10, r5, r6, lsl #16

    ;transpose r7, r8, r9, r10 to r3, r4, r5, r6
    TRANSPOSE_MATRIX r7, r8, r9, r10, r3, r4, r5, r6

    uqsub8      r7, r3, r6                  ; p1 - q1
    uqsub8      r8, r6, r3                  ; q1 - p1
    uqsub8      r9, r4, r5                  ; p0 - q0
    uqsub8      r10, r5, r4                 ; q0 - p0
    orr         r7, r7, r8                  ; abs(p1 - q1)
    orr         r9, r9, r10                 ; abs(p0 - q0)
    ldr         lr, c0x7F7F7F7F             ; 0111 1111 mask
    uqadd8      r9, r9, r9                  ; abs(p0 - q0) * 2
    and         r7, lr, r7, lsr #1          ; abs(p1 - q1) / 2
    mov         r8, #0
    uqadd8      r7, r7, r9                  ; abs(p0 - q0)*2 + abs(p1 - q1)/2
    mvn         r10, #0                     ; r10 == -1
    uqsub8      r7, r7, r12                 ; compare to flimit

    usub8       r7, r8, r7
    sel         r7, r10, r8                 ; filter mask: lr

    cmp         lr, #0
    beq         simple_vskip_filter         ; skip filtering

    ;vp8_simple_filter() function
    eor         r3, r3, r2                  ; p1 offset to convert to a signed value
    eor         r6, r6, r2                  ; q1 offset to convert to a signed value
    eor         r4, r4, r2                  ; p0 offset to convert to a signed value
    eor         r5, r5, r2                  ; q0 offset to convert to a signed value

    qsub8       r3, r3, r6                  ; vp8_filter (r3) = vp8_signed_char_clamp(p1-q1)
    qsub8       r6, r5, r4                  ; vp8_filter = vp8_signed_char_clamp(vp8_filter + 3 * ( q0 - p0))

    qadd8       r3, r3, r6
    ldr         r8, c0x03030303             ; r8 = 3

    qadd8       r3, r3, r6
    ldr         r7, c0x04040404

    qadd8       r3, r3, r6
    and         r3, r3, lr                  ; vp8_filter &= mask

    ;save bottom 3 bits so that we round one side +4 and the other +3
    qadd8       r8 , r3 , r8                ; Filter2 (r8) = vp8_signed_char_clamp(vp8_filter+3)
    qadd8       r3 , r3 , r7                ; Filter1 (r3) = vp8_signed_char_clamp(vp8_filter+4)

    mov         r7, #0
    shadd8      r8 , r8 , r7                ; Filter2 >>= 3
    shadd8      r3 , r3 , r7                ; Filter1 >>= 3
    shadd8      r8 , r8 , r7
    shadd8      r3 , r3 , r7
    shadd8      r8 , r8 , r7                ; r8: filter2
    shadd8      r3 , r3 , r7                ; r7: filter1

    ;calculate output
    sub         src, src, pstep, lsl #2

    qadd8       r4, r4, r8                  ; u = vp8_signed_char_clamp(p0 + Filter2)
    qsub8       r5, r5, r3                  ; u = vp8_signed_char_clamp(q0 - Filter1)
    eor         r4, r4, r2                  ; *op0 = u^0x80
    eor         r5, r5, r2                  ; *oq0 = u^0x80

    strb        r4, [src, #-1]              ; store the result
    mov         r4, r4, lsr #8
    strb        r5, [src], pstep
    mov         r5, r5, lsr #8

    strb        r4, [src, #-1]
    mov         r4, r4, lsr #8
    strb        r5, [src], pstep
    mov         r5, r5, lsr #8

    strb        r4, [src, #-1]
    mov         r4, r4, lsr #8
    strb        r5, [src], pstep
    mov         r5, r5, lsr #8

    strb        r4, [src, #-1]
    strb        r5, [src], pstep

|simple_vskip_filter|
    subs        r11, r11, #1

    ;pld            [src]
    ;pld            [src, pstep]
    ;pld            [src, pstep, lsl #1]

    ; load soure data to r7, r8, r9, r10
    ldrneh      r3, [src, #-2]
    ldrneh      r4, [src], pstep

    ldrneh      r5, [src, #-2]
    ldrneh      r6, [src], pstep

    pkhbt       r7, r3, r4, lsl #16

    ldrneh      r3, [src, #-2]
    ldrneh      r4, [src], pstep

    pkhbt       r8, r5, r6, lsl #16

    ldrneh      r5, [src, #-2]
    ldrneh      r6, [src], pstep

    bne         simple_vnext8

    ldmia       sp!, {r4 - r12, pc}
    ENDP        ; |vp8_loop_filter_simple_vertical_edge_armv6|

; Constant Pool
c0x80808080 DCD     0x80808080
c0x03030303 DCD     0x03030303
c0x04040404 DCD     0x04040404
c0x01010101 DCD     0x01010101
c0x7F7F7F7F DCD     0x7F7F7F7F

    END