| Index: chromium/patches/to_upstream/37_VP8_armv6_optimizations.patch
|
| diff --git a/chromium/patches/to_upstream/37_VP8_armv6_optimizations.patch b/chromium/patches/to_upstream/37_VP8_armv6_optimizations.patch
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..bf72c26c110d7c0cc261ec82cb80b71176a88c2e
|
| --- /dev/null
|
| +++ b/chromium/patches/to_upstream/37_VP8_armv6_optimizations.patch
|
| @@ -0,0 +1,2811 @@
|
| +From f2a35674d0ab9fc1852c088482fd51bf12e5ed45 Mon Sep 17 00:00:00 2001
|
| +From: "Ronald S. Bultje" <rsbultje@gmail.com>
|
| +Date: Wed, 24 Aug 2011 13:58:37 -0700
|
| +Subject: [PATCH] VP8: armv6 optimizations.
|
| +
|
| +From 52.503s (~40fps) to 27.973sec (~80fps) decoding of 480p sintel
|
| +trailer, i.e. a ~2x speedup overall, on a Nexus S.
|
| +---
|
| + libavcodec/arm/Makefile | 3 +-
|
| + libavcodec/arm/asm.S | 12 +
|
| + libavcodec/arm/vp8dsp_armv6.S | 2328 ++++++++++++++++++++++++++++++++++++++
|
| + libavcodec/arm/vp8dsp_init_arm.c | 324 ++++--
|
| + libavcodec/arm/vp8dsp_neon.S | 29 -
|
| + 5 files changed, 2577 insertions(+), 119 deletions(-)
|
| + create mode 100644 libavcodec/arm/vp8dsp_armv6.S
|
| +
|
| +diff --git a/libavcodec/arm/Makefile b/libavcodec/arm/Makefile
|
| +index 3374f0e..cc5a2a7 100644
|
| +--- a/libavcodec/arm/Makefile
|
| ++++ b/libavcodec/arm/Makefile
|
| +@@ -11,7 +11,8 @@ ARMV6-OBJS-$(CONFIG_MPEGAUDIODSP) += arm/mpegaudiodsp_fixed_armv6.o
|
| + OBJS-$(CONFIG_VP5_DECODER) += arm/vp56dsp_init_arm.o
|
| + OBJS-$(CONFIG_VP6_DECODER) += arm/vp56dsp_init_arm.o
|
| + OBJS-$(CONFIG_VP8_DECODER) += arm/vp8dsp_init_arm.o
|
| +-ARMV6-OBJS-$(CONFIG_VP8_DECODER) += arm/vp8_armv6.o
|
| ++ARMV6-OBJS-$(CONFIG_VP8_DECODER) += arm/vp8_armv6.o \
|
| ++ arm/vp8dsp_armv6.o
|
| +
|
| + OBJS-$(CONFIG_H264DSP) += arm/h264dsp_init_arm.o
|
| + OBJS-$(CONFIG_H264PRED) += arm/h264pred_init_arm.o
|
| +diff --git a/libavcodec/arm/asm.S b/libavcodec/arm/asm.S
|
| +index a7d3ace..c398f37 100644
|
| +--- a/libavcodec/arm/asm.S
|
| ++++ b/libavcodec/arm/asm.S
|
| +@@ -97,6 +97,12 @@ T add \rn, \rn, \rm
|
| + T ldr \rt, [\rn]
|
| + .endm
|
| +
|
| ++.macro ldr_dpren rt, rn, rm:vararg
|
| ++A ldr \rt, [\rn, -\rm]
|
| ++T sub \rt, \rn, \rm
|
| ++T ldr \rt, [\rt]
|
| ++.endm
|
| ++
|
| + .macro ldr_post rt, rn, rm:vararg
|
| + A ldr \rt, [\rn], \rm
|
| + T ldr \rt, [\rn]
|
| +@@ -133,6 +139,12 @@ T ldrh \rt, [\rn]
|
| + T add \rn, \rn, \rm
|
| + .endm
|
| +
|
| ++.macro ldrb_post rt, rn, rm
|
| ++A ldrb \rt, [\rn], \rm
|
| ++T ldrb \rt, [\rn]
|
| ++T add \rn, \rn, \rm
|
| ++.endm
|
| ++
|
| + .macro str_post rt, rn, rm:vararg
|
| + A str \rt, [\rn], \rm
|
| + T str \rt, [\rn]
|
| +diff --git a/libavcodec/arm/vp8dsp_armv6.S b/libavcodec/arm/vp8dsp_armv6.S
|
| +new file mode 100644
|
| +index 0000000..4e7b783
|
| +--- /dev/null
|
| ++++ b/libavcodec/arm/vp8dsp_armv6.S
|
| +@@ -0,0 +1,2328 @@
|
| ++/**
|
| ++ * VP8 ARMv6 optimisations
|
| ++ *
|
| ++ * Copyright (c) 2011 The WebM project authors. All Rights Reserved.
|
| ++ * Copyright (c) 2010 Rob Clark <rob@ti.com>
|
| ++ * Copyright (c) 2011 Mans Rullgard <mans@mansr.com>
|
| ++ *
|
| ++ * This file is part of Libav.
|
| ++ *
|
| ++ * Libav is free software; you can redistribute it and/or
|
| ++ * modify it under the terms of the GNU Lesser General Public
|
| ++ * License as published by the Free Software Foundation; either
|
| ++ * version 2.1 of the License, or (at your option) any later version.
|
| ++ *
|
| ++ * Libav is distributed in the hope that it will be useful,
|
| ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
| ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
| ++ * Lesser General Public License for more details.
|
| ++ *
|
| ++ * You should have received a copy of the GNU Lesser General Public
|
| ++ * License along with Libav; if not, write to the Free Software
|
| ++ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
| ++ *
|
| ++ * This code was partially ported from libvpx, which uses this license:
|
| ++ *
|
| ++ * Use of this source code is governed by a BSD-style license
|
| ++ * that can be found in the LICENSE file in the root of the source
|
| ++ * tree. An additional intellectual property rights grant can be found
|
| ++ * in the file PATENTS. All contributing project authors may
|
| ++ * be found in the AUTHORS file in the root of the source tree.
|
| ++ *
|
| ++ * (Note that the "LICENSE", "AUTHORS" and "PATENTS" files can be
|
| ++ * found in the libvpx source tree.)
|
| ++ */
|
| ++
|
| ++#include "asm.S"
|
| ++
|
| ++@ idct
|
| ++
|
| ++@ void vp8_luma_dc_wht(DCTELEM block[4][4][16], DCTELEM dc[16])
|
| ++function ff_vp8_luma_dc_wht_armv6, export=1
|
| ++ push {r4 - r10, lr}
|
| ++
|
| ++ @ load dc[] and zero memory
|
| ++ mov r12, #0
|
| ++ ldr r2, [r1] @ dc0[0,1]
|
| ++ ldr r3, [r1, #4] @ dc0[2,3]
|
| ++ ldr r4, [r1, #8] @ dc1[0,1]
|
| ++ ldr r5, [r1, #12] @ dc1[2,3]
|
| ++ ldr r6, [r1, #16] @ dc2[0,1]
|
| ++ ldr r7, [r1, #20] @ dc2[2,3]
|
| ++ ldr r8, [r1, #24] @ dc3[0,1]
|
| ++ ldr r9, [r1, #28] @ dc3[2,3]
|
| ++ str r12,[r1]
|
| ++ str r12,[r1, #4]
|
| ++ str r12,[r1, #8]
|
| ++ str r12,[r1, #12]
|
| ++ str r12,[r1, #16]
|
| ++ str r12,[r1, #20]
|
| ++ str r12,[r1, #24]
|
| ++ str r12,[r1, #28]
|
| ++
|
| ++ @ loop1
|
| ++ uadd16 r12, r2, r8 @ t0[0,1]
|
| ++ uadd16 r14, r3, r9 @ t0[2,3]
|
| ++ usub16 r2, r2, r8 @ t3[0,1]
|
| ++ usub16 r3, r3, r9 @ t3[2,3]
|
| ++ uadd16 r8, r4, r6 @ t1[0,1]
|
| ++ uadd16 r9, r5, r7 @ t1[2,3]
|
| ++ usub16 r4, r4, r6 @ t2[0,1]
|
| ++ usub16 r5, r5, r7 @ t2[2,3]
|
| ++
|
| ++ uadd16 r6, r12, r8 @ dc0[0,1]
|
| ++ uadd16 r7, r14, r9 @ dc0[2,3]
|
| ++ usub16 r12, r12, r8 @ dc2[0,1]
|
| ++ usub16 r14, r14, r9 @ dc2[2,3]
|
| ++ uadd16 r8, r2, r4 @ dc1[0,1]
|
| ++ uadd16 r9, r3, r5 @ dc1[2,3]
|
| ++ usub16 r2, r2, r4 @ dc3[0,1]
|
| ++ usub16 r3, r3, r5 @ dc3[2,3]
|
| ++
|
| ++ mov r1, #3
|
| ++ orr r1, r1, #0x30000 @ 3 | 3 (round)
|
| ++
|
| ++ @ "transpose"
|
| ++ pkhbt r4, r6, r8, lsl #16 @ dc{0,1}[0]
|
| ++ pkhtb r6, r8, r6, asr #16 @ dc{0,1}[1]
|
| ++ pkhbt r5, r12, r2, lsl #16 @ dc{2,3}[0]
|
| ++ pkhtb r12, r2, r12, asr #16 @ dc{2,3}[1]
|
| ++ pkhbt r8, r7, r9, lsl #16 @ dc{0,1}[2]
|
| ++ uadd16 r4, r4, r1
|
| ++ uadd16 r5, r5, r1
|
| ++ pkhtb r7, r9, r7, asr #16 @ dc{0,1}[3]
|
| ++ pkhbt r2, r14, r3, lsl #16 @ dc{2,3}[2]
|
| ++ pkhtb r14, r3, r14, asr #16 @ dc{2,3}[3]
|
| ++
|
| ++ @ loop2
|
| ++ uadd16 r9, r4, r7 @ t0[0,1]
|
| ++ uadd16 r3, r5, r14 @ t0[2,3]
|
| ++ usub16 r4, r4, r7 @ t3[0,1]
|
| ++ usub16 r5, r5, r14 @ t3[2,3]
|
| ++ uadd16 r7, r6, r8 @ t1[0,1]
|
| ++ uadd16 r14, r12, r2 @ t1[2,3]
|
| ++ usub16 r6, r6, r8 @ t2[0,1]
|
| ++ usub16 r12, r12, r2 @ t2[2,3]
|
| ++
|
| ++ uadd16 r8, r9, r7 @ block[0,1][0]
|
| ++ uadd16 r2, r3, r14 @ block[2,3][0]
|
| ++ usub16 r9, r9, r7 @ block[0,1][2]
|
| ++ usub16 r3, r3, r14 @ block[2,3][2]
|
| ++ uadd16 r7, r4, r6 @ block[0,1][1]
|
| ++ uadd16 r14, r5, r12 @ block[2,3][1]
|
| ++ usub16 r4, r4, r6 @ block[0,1][3]
|
| ++ usub16 r5, r5, r12 @ block[2,3][3]
|
| ++
|
| ++ @ store
|
| ++ mov r6, r8, asr #19 @ block[1][0]
|
| ++ mov r12, r7, asr #19 @ block[1][1]
|
| ++ mov r1, r9, asr #19 @ block[1][2]
|
| ++ mov r10, r4, asr #19 @ block[1][3]
|
| ++ sxth r8, r8
|
| ++ sxth r7, r7
|
| ++ sxth r9, r9
|
| ++ sxth r4, r4
|
| ++ asr r8, #3 @ block[0][0]
|
| ++ asr r7, #3 @ block[0][1]
|
| ++ asr r9, #3 @ block[0][2]
|
| ++ asr r4, #3 @ block[0][3]
|
| ++
|
| ++ strh r8, [r0], #32
|
| ++ strh r7, [r0], #32
|
| ++ strh r9, [r0], #32
|
| ++ strh r4, [r0], #32
|
| ++ strh r6, [r0], #32
|
| ++ strh r12,[r0], #32
|
| ++ strh r1, [r0], #32
|
| ++ strh r10,[r0], #32
|
| ++
|
| ++ mov r6, r2, asr #19 @ block[3][0]
|
| ++ mov r12, r14, asr #19 @ block[3][1]
|
| ++ mov r1, r3, asr #19 @ block[3][2]
|
| ++ mov r10, r5, asr #19 @ block[3][3]
|
| ++ sxth r2, r2
|
| ++ sxth r14, r14
|
| ++ sxth r3, r3
|
| ++ sxth r5, r5
|
| ++ asr r2, #3 @ block[2][0]
|
| ++ asr r14, #3 @ block[2][1]
|
| ++ asr r3, #3 @ block[2][2]
|
| ++ asr r5, #3 @ block[2][3]
|
| ++
|
| ++ strh r2, [r0], #32
|
| ++ strh r14,[r0], #32
|
| ++ strh r3, [r0], #32
|
| ++ strh r5, [r0], #32
|
| ++ strh r6, [r0], #32
|
| ++ strh r12,[r0], #32
|
| ++ strh r1, [r0], #32
|
| ++ strh r10,[r0], #32
|
| ++
|
| ++ pop {r4 - r10, pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_luma_dc_wht_dc(DCTELEM block[4][4][16], DCTELEM dc[16])
|
| ++function ff_vp8_luma_dc_wht_dc_armv6, export=1
|
| ++ ldrsh r2, [r1]
|
| ++ mov r3, #0
|
| ++ add r2, r2, #3
|
| ++ strh r3, [r1]
|
| ++ asr r2, r2, #3
|
| ++ .rept 16
|
| ++ strh r2, [r0], #32
|
| ++ .endr
|
| ++ bx lr
|
| ++endfunc
|
| ++
|
| ++@ void vp8_idct_add(uint8_t *dst, DCTELEM block[16], int stride)
|
| ++function ff_vp8_idct_add_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++ sub sp, sp, #32
|
| ++
|
| ++ mov r3, #0x00004E00 @ cos
|
| ++ orr r3, r3, #0x0000007B @ cospi8sqrt2minus1 = 20091
|
| ++ mov r4, #0x00008A00 @ sin
|
| ++ orr r4, r4, #0x0000008C @ sinpi8sqrt2 = 35468
|
| ++ mov r5, #0x2 @ i=2
|
| ++1:
|
| ++ ldr r6, [r1, #8] @ i5 | i4 = block1[1] | block1[0]
|
| ++ ldr r12,[r1, #24] @ i13 | i12 = block3[1] | block3[0]
|
| ++ ldr r14,[r1, #16] @ i9 | i8 = block2[1] | block2[0]
|
| ++
|
| ++ smulwt r9, r3, r6 @ (ip[5] * cospi8sqrt2minus1) >> 16
|
| ++ smulwb r7, r3, r6 @ (ip[4] * cospi8sqrt2minus1) >> 16
|
| ++ smulwt r10, r4, r6 @ (ip[5] * sinpi8sqrt2) >> 16
|
| ++ smulwb r8, r4, r6 @ (ip[4] * sinpi8sqrt2) >> 16
|
| ++ pkhbt r7, r7, r9, lsl #16 @ 5c | 4c
|
| ++ smulwt r11, r3, r12 @ (ip[13] * cospi8sqrt2minus1) >> 16
|
| ++ pkhbt r8, r8, r10, lsl #16 @ 5s | 4s = t2 first half
|
| ++ uadd16 r6, r6, r7 @ 5c+5 | 4c+4 = t3 first half
|
| ++ smulwt r7, r4, r12 @ (ip[13] * sinpi8sqrt2) >> 16
|
| ++ smulwb r9, r3, r12 @ (ip[12] * cospi8sqrt2minus1) >> 16
|
| ++ smulwb r10, r4, r12 @ (ip[12] * sinpi8sqrt2) >> 16
|
| ++
|
| ++ subs r5, r5, #1 @ i--
|
| ++ pkhbt r9, r9, r11, lsl #16 @ 13c | 12c
|
| ++ ldr r11,[r1] @ i1 | i0
|
| ++ pkhbt r10, r10, r7, lsl #16 @ 13s | 12s = t3 second half
|
| ++ uadd16 r7, r12, r9 @ 13c+13 | 12c+12 = t2 second half
|
| ++ usub16 r7, r8, r7 @ c = t2
|
| ++ uadd16 r6, r6, r10 @ d = t3
|
| ++ uadd16 r10, r11, r14 @ a = t0
|
| ++ usub16 r8, r11, r14 @ b = t1
|
| ++ uadd16 r9, r10, r6 @ a+d = tmp{0,1}[0]
|
| ++ usub16 r10, r10, r6 @ a-d = tmp{0,1}[3]
|
| ++ uadd16 r6, r8, r7 @ b+c = tmp{0,1}[1]
|
| ++ usub16 r7, r8, r7 @ b-c = tmp{0,1}[2]
|
| ++ mov r8, #0
|
| ++ str r6, [sp, #8] @ o5 | o4
|
| ++ str r7, [sp, #16] @ o9 | o8
|
| ++ str r10,[sp, #24] @ o13 | o12
|
| ++ str r9, [sp], #4 @ o1 | o0
|
| ++ str r8, [r1, #24]
|
| ++ str r8, [r1, #16]
|
| ++ str r8, [r1, #8]
|
| ++ str r8, [r1], #4
|
| ++ bne 1b
|
| ++
|
| ++ mov r5, #0x2 @ i=2
|
| ++ sub sp, sp, #8
|
| ++2:
|
| ++ ldr r6, [sp, #8] @ i5 | i4 = tmp{0,1}[1]
|
| ++ ldr r14,[sp, #4] @ i3 | i2 = tmp{2,3}[0]
|
| ++ ldr r12,[sp, #12] @ i7 | i6 = tmp{2,3}[1]
|
| ++ ldr r1, [sp], #16 @ i1 | i0 = tmp{0,1}[0]
|
| ++ smulwt r9, r3, r6 @ (ip[5] * cospi8sqrt2minus1) >> 16
|
| ++ smulwt r7, r3, r1 @ (ip[1] * cospi8sqrt2minus1) >> 16
|
| ++ smulwt r10, r4, r6 @ (ip[5] * sinpi8sqrt2) >> 16
|
| ++ smulwt r8, r4, r1 @ (ip[1] * sinpi8sqrt2) >> 16
|
| ++ pkhbt r11, r1, r6, lsl #16 @ i4 | i0 = t0/t1 first half
|
| ++ pkhbt r7, r7, r9, lsl #16 @ 5c | 1c
|
| ++ pkhbt r8, r8, r10, lsl #16 @ 5s | 1s = temp1 = t2 first half
|
| ++ pkhtb r1, r6, r1, asr #16 @ i5 | i1
|
| ++ uadd16 r1, r7, r1 @ 5c+5 | 1c+1 = temp2 (d) = t3 first half
|
| ++ pkhbt r9, r14, r12, lsl #16 @ i6 | i2 = t0/t1 second half
|
| ++ uadd16 r10, r11, r9 @ a = t0
|
| ++ usub16 r9, r11, r9 @ b = t1
|
| ++ pkhtb r6, r12, r14, asr #16 @ i7 | i3
|
| ++ subs r5, r5, #0x1 @ i--
|
| ++ smulwt r7, r3, r6 @ (ip[7] * cospi8sqrt2minus1) >> 16
|
| ++ smulwt r11, r4, r6 @ (ip[7] * sinpi8sqrt2) >> 16
|
| ++ smulwb r12, r3, r6 @ (ip[3] * cospi8sqrt2minus1) >> 16
|
| ++ smulwb r14, r4, r6 @ (ip[3] * sinpi8sqrt2) >> 16
|
| ++
|
| ++ pkhbt r7, r12, r7, lsl #16 @ 7c | 3c
|
| ++ pkhbt r11, r14, r11, lsl #16 @ 7s | 3s = temp1 (d) = t3 second half
|
| ++ mov r14, #0x4 @ set up 4's
|
| ++ orr r14, r14, #0x40000 @ 4|4
|
| ++ uadd16 r6, r7, r6 @ 7c+7 | 3c+3 = temp2 (c) = t2 second half
|
| ++ usub16 r12, r8, r6 @ c (o5 | o1) = t2
|
| ++ uadd16 r6, r11, r1 @ d (o7 | o3) = t3
|
| ++ uadd16 r10, r10, r14 @ t0 + 4
|
| ++ uadd16 r9, r9, r14 @ t1 + 4
|
| ++ uadd16 r7, r10, r6 @ a+d = dst{0,1}[0]
|
| ++ usub16 r6, r10, r6 @ a-d = dst{0,1}[3]
|
| ++ uadd16 r10, r9, r12 @ b+c = dst{0,1}[1]
|
| ++ usub16 r1, r9, r12 @ b-c = dst{0,1}[2]
|
| ++
|
| ++ mov r9, r6, asr #3 @ o[1][3]
|
| ++ mov r12, r1, asr #3 @ o[1][2]
|
| ++ pkhtb r8, r12, r7, asr #19 @ o[1][0,2]
|
| ++ pkhtb r11, r9, r10, asr #19 @ o[1][1,3]
|
| ++ ldr r12,[r0]
|
| ++ ldr r9, [r0, r2]
|
| ++ sxth r7, r7
|
| ++ sxth r6, r6
|
| ++ sxth r10, r10
|
| ++ sxth r1, r1
|
| ++ asr r7, #3 @ o[0][0]
|
| ++ asr r10, #3 @ o[0][1]
|
| ++ pkhbt r7, r7, r1, lsl #13 @ o[0][0,2]
|
| ++ pkhbt r10, r10, r6, lsl #13 @ o[0][1,3]
|
| ++
|
| ++ uxtab16 r7, r7, r12
|
| ++ uxtab16 r10, r10, r12, ror #8
|
| ++ uxtab16 r8, r8, r9
|
| ++ uxtab16 r11, r11, r9, ror #8
|
| ++ usat16 r7, #8, r7
|
| ++ usat16 r10, #8, r10
|
| ++ usat16 r8, #8, r8
|
| ++ usat16 r11, #8, r11
|
| ++ orr r7, r7, r10, lsl #8
|
| ++ orr r8, r8, r11, lsl #8
|
| ++ str r8, [r0, r2]
|
| ++ str_post r7, r0, r2, lsl #1
|
| ++
|
| ++ bne 2b
|
| ++
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_idct_dc_add(uint8_t *dst, DCTELEM block[16], int stride)
|
| ++function ff_vp8_idct_dc_add_armv6, export=1
|
| ++ push {r4 - r5, lr}
|
| ++ ldrsh r3, [r1]
|
| ++ mov r4, #0
|
| ++ add r3, r3, #4
|
| ++ asr r3, #3
|
| ++ strh r4, [r1], #32
|
| ++ ldr r4, [r0, r2]
|
| ++ ldr_post r5, r0, r2, lsl #1
|
| ++ pkhbt r3, r3, r3, lsl #16
|
| ++
|
| ++ uxtab16 lr, r3, r5 @ a1+2 | a1+0
|
| ++ uxtab16 r5, r3, r5, ror #8 @ a1+3 | a1+1
|
| ++ uxtab16 r12, r3, r4
|
| ++ uxtab16 r4, r3, r4, ror #8
|
| ++ usat16 lr, #8, lr
|
| ++ usat16 r5, #8, r5
|
| ++ usat16 r12, #8, r12
|
| ++ usat16 r4, #8, r4
|
| ++ orr lr, lr, r5, lsl #8
|
| ++ orr r12, r12, r4, lsl #8
|
| ++ ldr r5, [r0]
|
| ++ ldr r4, [r0, r2]
|
| ++ sub r0, r0, r2, lsl #1
|
| ++ str r12,[r0, r2]
|
| ++ str_post lr, r0, r2, lsl #1
|
| ++
|
| ++ uxtab16 lr, r3, r5
|
| ++ uxtab16 r5, r3, r5, ror #8
|
| ++ uxtab16 r12, r3, r4
|
| ++ uxtab16 r4, r3, r4, ror #8
|
| ++ usat16 lr, #8, lr
|
| ++ usat16 r5, #8, r5
|
| ++ usat16 r12, #8, r12
|
| ++ usat16 r4, #8, r4
|
| ++ orr lr, lr, r5, lsl #8
|
| ++ orr r12, r12, r4, lsl #8
|
| ++
|
| ++ str r12,[r0, r2]
|
| ++ str_post lr, r0, r2, lsl #1
|
| ++
|
| ++ pop {r4 - r5, pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_idct_dc_add4uv(uint8_t *dst, DCTELEM block[4][16], int stride)
|
| ++function ff_vp8_idct_dc_add4uv_armv6, export=1
|
| ++ push {lr}
|
| ++
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++ sub r0, r0, r2, lsl #2
|
| ++ add r0, r0, #4
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++ sub r0, r0, #4
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++ sub r0, r0, r2, lsl #2
|
| ++ add r0, r0, #4
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++
|
| ++ pop {pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_idct_dc_add4y(uint8_t *dst, DCTELEM block[4][16], int stride)
|
| ++function ff_vp8_idct_dc_add4y_armv6, export=1
|
| ++ push {lr}
|
| ++
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++ sub r0, r0, r2, lsl #2
|
| ++ add r0, r0, #4
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++ sub r0, r0, r2, lsl #2
|
| ++ add r0, r0, #4
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++ sub r0, r0, r2, lsl #2
|
| ++ add r0, r0, #4
|
| ++ bl ff_vp8_idct_dc_add_armv6
|
| ++
|
| ++ pop {pc}
|
| ++endfunc
|
| ++
|
| ++@ loopfilter
|
| ++
|
| ++@ void vp8_v_loop_filter16_simple(uint8_t *dst, int stride, int flim)
|
| ++function ff_vp8_v_loop_filter16_simple_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ ldr_dpren r3, r0, r1, lsl #1 @ p1
|
| ++ ldr_dpren r4, r0, r1 @ p0
|
| ++ ldr r5, [r0] @ q0
|
| ++ ldr r6, [r0, r1] @ q1
|
| ++ orr r2, r2, r2, lsl #16
|
| ++ mov r9, #4 @ count
|
| ++ mov lr, #0 @ need 0 in a couple places
|
| ++ orr r12, r2, r2, lsl #8 @ splat int -> byte
|
| ++ ldr r2, c0x80808080
|
| ++
|
| ++1:
|
| ++ @ vp8_simple_filter_mask()
|
| ++ 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)
|
| ++ orr r10, r10, r11 @ abs(p0 - q0)
|
| ++ uqadd8 r10, r10, r10 @ abs(p0 - q0) * 2
|
| ++ uhadd8 r8, r8, lr @ abs(p1 - q2) >> 1
|
| ++ uqadd8 r10, r10, r8 @ abs(p0 - q0)*2 + abs(p1 - q1)/2
|
| ++ mvn r8, #0
|
| ++ usub8 r10, r12, r10 @ compare to flimit. usub8 sets GE flags
|
| ++ sel r10, r8, lr @ filter mask: F or 0
|
| ++ cmp r10, #0
|
| ++ beq 2f @ skip filtering if all masks are 0x00
|
| ++
|
| ++ @ vp8_simple_filter()
|
| ++ 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 = p1 - q1
|
| ++ qsub8 r6, r5, r4 @ q0 - p0
|
| ++ qadd8 r3, r3, r6 @ += q0 - p0
|
| ++ ldr r7, c0x04040404
|
| ++ qadd8 r3, r3, r6 @ += q0 - p0
|
| ++ ldr r8, c0x03030303
|
| ++ qadd8 r3, r3, r6 @ vp8_filter = p1-q1 + 3*(q0-p0))
|
| ++ @STALL
|
| ++ and r3, r3, r10 @ vp8_filter &= mask
|
| ++
|
| ++ qadd8 r7, r3, r7 @ Filter1 = vp8_filter + 4
|
| ++ qadd8 r8, r3, r8 @ Filter2 = vp8_filter + 3
|
| ++
|
| ++ shadd8 r7, r7, lr
|
| ++ shadd8 r8, r8, lr
|
| ++ shadd8 r7, r7, lr
|
| ++ shadd8 r8, r8, lr
|
| ++ shadd8 r7, r7, lr @ Filter1 >>= 3
|
| ++ shadd8 r8, r8, lr @ Filter2 >>= 3
|
| ++
|
| ++ qsub8 r5, r5, r7 @ u = q0 - Filter1
|
| ++ qadd8 r4, r4, r8 @ u = p0 + Filter2
|
| ++ eor r5, r5, r2 @ *oq0 = u^0x80
|
| ++ eor r4, r4, r2 @ *op0 = u^0x80
|
| ++T sub r7, r0, r1
|
| ++ str r5, [r0] @ store oq0 result
|
| ++A str r4, [r0, -r1] @ store op0 result
|
| ++T str r4, [r7]
|
| ++
|
| ++2:
|
| ++ subs r9, r9, #1 @ counter--
|
| ++ add r0, r0, #4 @ next row
|
| ++T itttt ne
|
| ++A ldrne r3, [r0, -r1, lsl #1] @ p1
|
| ++T subne r3, r0, r1, lsl #1
|
| ++T ldrne r3, [r3] @ p1
|
| ++A ldrne r4, [r0, -r1] @ p0
|
| ++T subne r4, r0, r1
|
| ++T ldrne r4, [r4] @ p0
|
| ++T itt ne
|
| ++ ldrne r5, [r0] @ q0
|
| ++ ldrne r6, [r0, r1] @ q1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++c0x01010101: .long 0x01010101
|
| ++c0x03030303: .long 0x03030303
|
| ++c0x04040404: .long 0x04040404
|
| ++c0x7F7F7F7F: .long 0x7F7F7F7F
|
| ++c0x80808080: .long 0x80808080
|
| ++
|
| ++@ void vp8_v_loop_filter16_inner(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ and
|
| ++@ void vp8_v_loop_filter8uv_inner(uint8_t *dstU, uint8_t *dstV, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ call:
|
| ++@ void vp8_v_loop_filter_inner(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh, int count)
|
| ++function ff_vp8_v_loop_filter_inner_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++ ldr r5, [sp, #40] @ counter
|
| ++ ldr r6, [sp, #36] @ load thresh address
|
| ++ sub sp, sp, #16 @ create temp buffer
|
| ++
|
| ++ ldr r10,[r0, r1] @ p2
|
| ++ ldr_post r9, r0, r1, lsl #1 @ p3
|
| ++ ldr r12,[r0, r1] @ p0
|
| ++ ldr_post r11, r0, r1, lsl #1 @ p1
|
| ++
|
| ++ orr r2, r2, r2, lsl #16
|
| ++ orr r3, r3, r3, lsl #16
|
| ++ orr r6, r6, r6, lsl #16
|
| ++ orr r4, r2, r2, lsl #8 @ flimE splat int -> byte
|
| ++ orr r2, r3, r3, lsl #8 @ flimI splat int -> byte
|
| ++ orr r3, r6, r6, lsl #8 @ thresh splat int -> byte
|
| ++
|
| ++1:
|
| ++ @ vp8_filter_mask() function
|
| ++ @ calculate breakout conditions
|
| ++ uqsub8 r6, r9, r10 @ p3 - p2
|
| ++ uqsub8 r7, r10, r9 @ p2 - p3
|
| ++ uqsub8 r8, r10, r11 @ p2 - p1
|
| ++ uqsub8 r10, r11, r10 @ p1 - p2
|
| ++
|
| ++ orr r6, r6, r7 @ abs (p3-p2)
|
| ++ orr r8, r8, r10 @ abs (p2-p1)
|
| ++ uqsub8 lr, r6, r2 @ compare to limit. lr: vp8_filter_mask
|
| ++ uqsub8 r8, r8, r2 @ compare to limit
|
| ++ uqsub8 r6, r11, r12 @ p1 - p0
|
| ++ orr lr, lr, r8
|
| ++ uqsub8 r7, r12, r11 @ p0 - p1
|
| ++ ldr r10,[r0, r1] @ q1
|
| ++ ldr_post r9, r0, r1, lsl #1 @ q0
|
| ++ orr r6, r6, r7 @ abs (p1-p0)
|
| ++ uqsub8 r7, r6, r2 @ compare to limit
|
| ++ uqsub8 r8, r6, r3 @ compare to thresh -- save r8 for later
|
| ++ orr lr, lr, r7
|
| ++
|
| ++ uqsub8 r6, r11, r10 @ p1 - q1
|
| ++ uqsub8 r7, r10, r11 @ q1 - p1
|
| ++ uqsub8 r11, r12, r9 @ p0 - q0
|
| ++ uqsub8 r12, r9, r12 @ q0 - p0
|
| ++ orr r6, r6, r7 @ abs (p1-q1)
|
| ++ ldr r7, c0x7F7F7F7F
|
| ++ orr r12, r11, r12 @ abs (p0-q0)
|
| ++ ldr_post r11, r0, r1 @ q2
|
| ++ uqadd8 r12, r12, r12 @ abs (p0-q0) * 2
|
| ++ and r6, r7, r6, lsr #1 @ abs (p1-q1) / 2
|
| ++ uqsub8 r7, r9, r10 @ q0 - q1
|
| ++ uqadd8 r12, r12, r6 @ abs (p0-q0)*2 + abs (p1-q1)/2
|
| ++ uqsub8 r6, r10, r9 @ q1 - q0
|
| ++ uqsub8 r12, r12, r4 @ compare to flimit
|
| ++ uqsub8 r9, r11, r10 @ q2 - q1
|
| ++
|
| ++ orr lr, lr, r12
|
| ++
|
| ++ ldr_post r12, r0, r1 @ q3
|
| ++ uqsub8 r10, r10, r11 @ q1 - q2
|
| ++ orr r6, r7, r6 @ abs (q1-q0)
|
| ++ orr r10, r9, r10 @ abs (q2-q1)
|
| ++ uqsub8 r7, r6, r2 @ compare to limit
|
| ++ uqsub8 r10, r10, r2 @ compare to limit
|
| ++ uqsub8 r6, r6, r3 @ compare to thresh -- save r6 for later
|
| ++ orr lr, lr, r7
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ uqsub8 r10, r12, r11 @ q3 - q2
|
| ++ uqsub8 r9, r11, r12 @ q2 - q3
|
| ++
|
| ++ mvn r11, #0 @ r11 == -1
|
| ++
|
| ++ orr r10, r10, r9 @ abs (q3-q2)
|
| ++ uqsub8 r10, r10, r2 @ compare to limit
|
| ++
|
| ++ mov r12, #0
|
| ++ orr lr, lr, r10
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ usub8 lr, r12, lr @ use usub8 instead of ssub8
|
| ++ sel lr, r11, r12 @ filter mask: lr
|
| ++
|
| ++ cmp lr, #0
|
| ++ beq 2f @ skip filtering
|
| ++
|
| ++ sub r0, r0, r1, lsl #1 @ move r0 pointer down by 6 lines
|
| ++
|
| ++ @vp8_hevmask() function
|
| ++ @calculate high edge variance
|
| ++ orr r10, r6, r8 @ calculate vp8_hevmask
|
| ++
|
| ++ usub8 r10, r12, r10 @ use usub8 instead of ssub8
|
| ++ sel r6, r12, r11 @ obtain vp8_hevmask: r6
|
| ++
|
| ++ @vp8_filter() function
|
| ++ ldr r8, [r0, r1] @ p0
|
| ++ ldr_post r7, r0, r1, lsl #1 @ p1
|
| ++ ldr r12, c0x80808080
|
| ++ ldr r10,[r0, r1] @ q1
|
| ++ ldr_post r9, r0, r1, lsl #1 @ q0
|
| ++
|
| ++ eor r7, r7, r12 @ p1 offset to convert to a signed value
|
| ++ eor r8, r8, r12 @ p0 offset to convert to a signed value
|
| ++ eor r9, r9, r12 @ q0 offset to convert to a signed value
|
| ++ eor r10, r10, r12 @ q1 offset to convert to a signed value
|
| ++
|
| ++ str r9, [sp] @ store qs0 temporarily
|
| ++ str r8, [sp, #4] @ store ps0 temporarily
|
| ++ str r10,[sp, #8] @ store qs1 temporarily
|
| ++ str r7, [sp, #12] @ store ps1 temporarily
|
| ++
|
| ++ qsub8 r7, r7, r10 @ vp8_signed_char_clamp(ps1-qs1)
|
| ++ qsub8 r8, r9, r8 @ vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
|
| ++
|
| ++ and r7, r7, r6 @ vp8_filter (r7) &= hev
|
| ++
|
| ++ qadd8 r7, r7, r8
|
| ++ ldr r9, c0x03030303 @ r9 = 3 --modified for vp8
|
| ++
|
| ++ qadd8 r7, r7, r8
|
| ++ ldr r10, c0x04040404
|
| ++
|
| ++ qadd8 r7, r7, r8
|
| ++ and r7, r7, lr @ vp8_filter &= mask@
|
| ++
|
| ++ qadd8 r8, r7, r9 @ Filter2 (r8) = vp8_signed_char_clamp(vp8_filter+3)
|
| ++ qadd8 r7, r7, r10 @ vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
|
| ++
|
| ++ mov r9, #0
|
| ++ shadd8 r8, r8, r9 @ Filter2 >>= 3
|
| ++ shadd8 r7, r7, r9 @ vp8_filter >>= 3
|
| ++ shadd8 r8, r8, r9
|
| ++ shadd8 r7, r7, r9
|
| ++ shadd8 lr, r8, r9 @ lr: Filter2
|
| ++ shadd8 r7, r7, r9 @ r7: filter
|
| ++
|
| ++ @calculate output
|
| ++
|
| ++ ldr r8, [sp] @ load qs0
|
| ++ ldr r9, [sp, #4] @ load ps0
|
| ++
|
| ++ ldr r10, c0x01010101
|
| ++
|
| ++ qsub8 r8, r8, r7 @ u = vp8_signed_char_clamp(qs0 - vp8_filter)
|
| ++ qadd8 r9, r9, lr @ u = vp8_signed_char_clamp(ps0 + Filter2)
|
| ++
|
| ++ mov lr, #0
|
| ++ sadd8 r7, r7, r10 @ vp8_filter += 1
|
| ++ shadd8 r7, r7, lr @ vp8_filter >>= 1
|
| ++
|
| ++ ldr r11,[sp, #12] @ load ps1
|
| ++ ldr r10,[sp, #8] @ load qs1
|
| ++
|
| ++ bic r7, r7, r6 @ vp8_filter &= ~hev
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ qadd8 r11, r11, r7 @ u = vp8_signed_char_clamp(ps1 + vp8_filter)
|
| ++ qsub8 r10, r10, r7 @ u = vp8_signed_char_clamp(qs1 - vp8_filter)
|
| ++
|
| ++ eor r11, r11, r12 @ *op1 = u^0x80
|
| ++ eor r9, r9, r12 @ *op0 = u^0x80
|
| ++ eor r8, r8, r12 @ *oq0 = u^0x80
|
| ++ eor r10, r10, r12 @ *oq1 = u^0x80
|
| ++ str r9, [r0, r1] @ store op0 result
|
| ++ str_post r11, r0, r1, lsl #1 @ store op1
|
| ++ str r10,[r0, r1] @ store oq1
|
| ++ str_post r8, r0, r1, lsl #1 @ store oq0 result
|
| ++
|
| ++ sub r0, r0, r1, lsl #1
|
| ++
|
| ++2:
|
| ++ add r0, r0, #4
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ subs r5, r5, #1
|
| ++T ittt ne
|
| ++ ldrne r10,[r0, r1] @ p2
|
| ++A ldrne r9, [r0], r1, lsl #1 @ p3
|
| ++T ldrne r9, [r0] @ p3
|
| ++T addne r0, r0, r1, lsl #1
|
| ++T ittt ne
|
| ++ ldrne r12,[r0, r1] @ p0
|
| ++A ldrne r11,[r0], r1, lsl #1 @ p1
|
| ++T ldrne r11,[r0] @ p3
|
| ++T addne r0, r0, r1, lsl #1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #16
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_v_loop_filter16(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ and
|
| ++@ void vp8_v_loop_filter8uv(uint8_t *dstU, uint8_t *dstV, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ call:
|
| ++@ void vp8_v_loop_filter(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh, int count)
|
| ++function ff_vp8_v_loop_filter_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++ ldr r5, [sp, #40] @ counter
|
| ++ ldr r6, [sp, #36] @ load thresh address
|
| ++ sub sp, sp, #16 @ create temp buffer
|
| ++
|
| ++ ldr r10,[r0, r1] @ p2
|
| ++ ldr_post r9, r0, r1, lsl #1 @ p3
|
| ++ ldr r12,[r0, r1] @ p0
|
| ++ ldr_post r11, r0, r1, lsl #1 @ p1
|
| ++
|
| ++ orr r2, r2, r2, lsl #16
|
| ++ orr r3, r3, r3, lsl #16
|
| ++ orr r6, r6, r6, lsl #16
|
| ++ orr r4, r2, r2, lsl #8 @ flimE splat int -> byte
|
| ++ orr r2, r3, r3, lsl #8 @ flimI splat int -> byte
|
| ++ orr r3, r6, r6, lsl #8 @ thresh splat int -> byte
|
| ++
|
| ++1:
|
| ++ @ vp8_filter_mask() function
|
| ++ @ calculate breakout conditions
|
| ++ uqsub8 r6, r9, r10 @ p3 - p2
|
| ++ uqsub8 r7, r10, r9 @ p2 - p3
|
| ++ uqsub8 r8, r10, r11 @ p2 - p1
|
| ++ uqsub8 r10, r11, r10 @ p1 - p2
|
| ++
|
| ++ orr r6, r6, r7 @ abs (p3-p2)
|
| ++ orr r8, r8, r10 @ abs (p2-p1)
|
| ++ uqsub8 lr, r6, r2 @ compare to limit. lr: vp8_filter_mask
|
| ++ uqsub8 r8, r8, r2 @ compare to limit
|
| ++
|
| ++ uqsub8 r6, r11, r12 @ p1 - p0
|
| ++ orr lr, lr, r8
|
| ++ uqsub8 r7, r12, r11 @ p0 - p1
|
| ++ ldr r10,[r0, r1] @ q1
|
| ++ ldr_post r9, r0, r1, lsl #1 @ q0
|
| ++ orr r6, r6, r7 @ abs (p1-p0)
|
| ++ uqsub8 r7, r6, r2 @ compare to limit
|
| ++ uqsub8 r8, r6, r3 @ compare to thresh -- save r8 for later
|
| ++ orr lr, lr, r7
|
| ++
|
| ++ uqsub8 r6, r11, r10 @ p1 - q1
|
| ++ uqsub8 r7, r10, r11 @ q1 - p1
|
| ++ uqsub8 r11, r12, r9 @ p0 - q0
|
| ++ uqsub8 r12, r9, r12 @ q0 - p0
|
| ++ orr r6, r6, r7 @ abs (p1-q1)
|
| ++ ldr r7, c0x7F7F7F7F
|
| ++ orr r12, r11, r12 @ abs (p0-q0)
|
| ++ ldr_post r11, r0, r1 @ q2
|
| ++ uqadd8 r12, r12, r12 @ abs (p0-q0) * 2
|
| ++ and r6, r7, r6, lsr #1 @ abs (p1-q1) / 2
|
| ++ uqsub8 r7, r9, r10 @ q0 - q1
|
| ++ uqadd8 r12, r12, r6 @ abs (p0-q0)*2 + abs (p1-q1)/2
|
| ++ uqsub8 r6, r10, r9 @ q1 - q0
|
| ++ uqsub8 r12, r12, r4 @ compare to flimit
|
| ++ uqsub8 r9, r11, r10 @ q2 - q1
|
| ++
|
| ++ orr lr, lr, r12
|
| ++
|
| ++ ldr_post r12, r0, r1 @ q3
|
| ++
|
| ++ uqsub8 r10, r10, r11 @ q1 - q2
|
| ++ orr r6, r7, r6 @ abs (q1-q0)
|
| ++ orr r10, r9, r10 @ abs (q2-q1)
|
| ++ uqsub8 r7, r6, r2 @ compare to limit
|
| ++ uqsub8 r10, r10, r2 @ compare to limit
|
| ++ uqsub8 r6, r6, r3 @ compare to thresh -- save r6 for later
|
| ++ orr lr, lr, r7
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ uqsub8 r10, r12, r11 @ q3 - q2
|
| ++ uqsub8 r9, r11, r12 @ q2 - q3
|
| ++
|
| ++ mvn r11, #0 @ r11 == -1
|
| ++
|
| ++ orr r10, r10, r9 @ abs (q3-q2)
|
| ++ uqsub8 r10, r10, r2 @ compare to limit
|
| ++
|
| ++ mov r12, #0
|
| ++
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ usub8 lr, r12, lr @ use usub8 instead of ssub8
|
| ++ sel lr, r11, r12 @ filter mask: lr
|
| ++
|
| ++ cmp lr, #0
|
| ++ beq 2f @ skip filtering
|
| ++
|
| ++ @vp8_hevmask() function
|
| ++ @calculate high edge variance
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 6 lines
|
| ++ sub r0, r0, r1, lsl #1
|
| ++
|
| ++ orr r10, r6, r8
|
| ++
|
| ++ usub8 r10, r12, r10
|
| ++ sel r6, r12, r11 @ hev mask: r6
|
| ++
|
| ++ @vp8_mbfilter() function
|
| ++ @p2, q2 are only needed at the end. Do not need to load them in now.
|
| ++ ldr r8, [r0, r1] @ p0
|
| ++ ldr_post r7, r0, r1, lsl #1 @ p1
|
| ++ ldr r12, c0x80808080
|
| ++ ldr_post r9, r0, r1 @ q0
|
| ++ ldr r10,[r0] @ q1
|
| ++
|
| ++ eor r7, r7, r12 @ ps1
|
| ++ eor r8, r8, r12 @ ps0
|
| ++ eor r9, r9, r12 @ qs0
|
| ++ eor r10, r10, r12 @ qs1
|
| ++
|
| ++ qsub8 r12, r9, r8 @ vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
|
| ++ str r7, [sp, #12] @ store ps1 temporarily
|
| ++ qsub8 r7, r7, r10 @ vp8_signed_char_clamp(ps1-qs1)
|
| ++ str r10,[sp, #8] @ store qs1 temporarily
|
| ++ qadd8 r7, r7, r12
|
| ++ str r9, [sp] @ store qs0 temporarily
|
| ++ qadd8 r7, r7, r12
|
| ++ str r8, [sp, #4] @ store ps0 temporarily
|
| ++ qadd8 r7, r7, r12 @ vp8_filter: r7
|
| ++
|
| ++ ldr r10, c0x03030303 @ r10 = 3 --modified for vp8
|
| ++ ldr r9, c0x04040404
|
| ++
|
| ++ and r7, r7, lr @ vp8_filter &= mask (lr is free)
|
| ++
|
| ++ mov r12, r7 @ Filter2: r12
|
| ++ and r12, r12, r6 @ Filter2 &= hev
|
| ++
|
| ++ @save bottom 3 bits so that we round one side +4 and the other +3
|
| ++ qadd8 r8, r12, r9 @ Filter1 (r8) = vp8_signed_char_clamp(Filter2+4)
|
| ++ qadd8 r12, r12, r10 @ Filter2 (r12) = vp8_signed_char_clamp(Filter2+3)
|
| ++
|
| ++ mov r10, #0
|
| ++ shadd8 r8, r8, r10 @ Filter1 >>= 3
|
| ++ shadd8 r12, r12, r10 @ Filter2 >>= 3
|
| ++ shadd8 r8, r8, r10
|
| ++ shadd8 r12, r12, r10
|
| ++ shadd8 r8, r8, r10 @ r8: Filter1
|
| ++ shadd8 r12, r12, r10 @ r12: Filter2
|
| ++
|
| ++ ldr r9, [sp] @ load qs0
|
| ++ ldr r11,[sp, #4] @ load ps0
|
| ++
|
| ++ qsub8 r9, r9, r8 @ qs0 = vp8_signed_char_clamp(qs0 - Filter1)
|
| ++ qadd8 r11, r11, r12 @ ps0 = vp8_signed_char_clamp(ps0 + Filter2)
|
| ++
|
| ++ bic r12, r7, r6 @ vp8_filter &= ~hev ( r6 is free)
|
| ++
|
| ++ @roughly 3/7th difference across boundary
|
| ++ mov lr, #0x1b @ 27
|
| ++ mov r7, #0x3f @ 63
|
| ++
|
| ++ sxtb16 r6, r12
|
| ++ sxtb16 r10, r12, ror #8
|
| ++ smlabb r8, r6, lr, r7
|
| ++ smlatb r6, r6, lr, r7
|
| ++ smlabb r7, r10, lr, r7
|
| ++ smultb r10, r10, lr
|
| ++ ssat r8, #8, r8, asr #7
|
| ++ ssat r6, #8, r6, asr #7
|
| ++ add r10, r10, #63
|
| ++ ssat r7, #8, r7, asr #7
|
| ++ ssat r10, #8, r10, asr #7
|
| ++
|
| ++ ldr lr, c0x80808080
|
| ++
|
| ++ pkhbt r6, r8, r6, lsl #16
|
| ++ pkhbt r10, r7, r10, lsl #16
|
| ++ uxtb16 r6, r6
|
| ++ uxtb16 r10, r10
|
| ++
|
| ++ sub r0, r0, r1
|
| ++
|
| ++ orr r10, r6, r10, lsl #8 @ u = vp8_signed_char_clamp((63 + Filter2 * 27)>>7)
|
| ++
|
| ++ qsub8 r8, r9, r10 @ s = vp8_signed_char_clamp(qs0 - u)
|
| ++ qadd8 r10, r11, r10 @ s = vp8_signed_char_clamp(ps0 + u)
|
| ++ eor r8, r8, lr @ *oq0 = s^0x80
|
| ++ str r8, [r0] @ store *oq0
|
| ++ sub r0, r0, r1
|
| ++ eor r10, r10, lr @ *op0 = s^0x80
|
| ++ str r10,[r0] @ store *op0
|
| ++
|
| ++ @roughly 2/7th difference across boundary
|
| ++ mov lr, #0x12 @ 18
|
| ++ mov r7, #0x3f @ 63
|
| ++
|
| ++ sxtb16 r6, r12
|
| ++ sxtb16 r10, r12, ror #8
|
| ++ smlabb r8, r6, lr, r7
|
| ++ smlatb r6, r6, lr, r7
|
| ++ smlabb r9, r10, lr, r7
|
| ++ smlatb r10, r10, lr, r7
|
| ++ ssat r8, #8, r8, asr #7
|
| ++ ssat r6, #8, r6, asr #7
|
| ++ ssat r9, #8, r9, asr #7
|
| ++ ssat r10, #8, r10, asr #7
|
| ++
|
| ++ ldr lr, c0x80808080
|
| ++
|
| ++ pkhbt r6, r8, r6, lsl #16
|
| ++ pkhbt r10, r9, r10, lsl #16
|
| ++
|
| ++ ldr r9, [sp, #8] @ load qs1
|
| ++ ldr r11, [sp, #12] @ load ps1
|
| ++
|
| ++ uxtb16 r6, r6
|
| ++ uxtb16 r10, r10
|
| ++
|
| ++ sub r0, r0, r1
|
| ++
|
| ++ orr r10, r6, r10, lsl #8 @ u = vp8_signed_char_clamp((63 + Filter2 * 18)>>7)
|
| ++
|
| ++ qadd8 r11, r11, r10 @ s = vp8_signed_char_clamp(ps1 + u)
|
| ++ qsub8 r8, r9, r10 @ s = vp8_signed_char_clamp(qs1 - u)
|
| ++ eor r11, r11, lr @ *op1 = s^0x80
|
| ++ str_post r11, r0, r1 @ store *op1
|
| ++ eor r8, r8, lr @ *oq1 = s^0x80
|
| ++ add r0, r0, r1, lsl #1
|
| ++
|
| ++ mov r7, #0x3f @ 63
|
| ++
|
| ++ str_post r8, r0, r1 @ store *oq1
|
| ++
|
| ++ @roughly 1/7th difference across boundary
|
| ++ mov lr, #0x9 @ 9
|
| ++ ldr r9, [r0] @ load q2
|
| ++
|
| ++ sxtb16 r6, r12
|
| ++ sxtb16 r10, r12, ror #8
|
| ++ smlabb r8, r6, lr, r7
|
| ++ smlatb r6, r6, lr, r7
|
| ++ smlabb r12, r10, lr, r7
|
| ++ smlatb r10, r10, lr, r7
|
| ++ ssat r8, #8, r8, asr #7
|
| ++ ssat r6, #8, r6, asr #7
|
| ++ ssat r12, #8, r12, asr #7
|
| ++ ssat r10, #8, r10, asr #7
|
| ++
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ pkhbt r6, r8, r6, lsl #16
|
| ++ pkhbt r10, r12, r10, lsl #16
|
| ++
|
| ++ sub r0, r0, r1
|
| ++ ldr lr, c0x80808080
|
| ++
|
| ++ ldr r11, [r0] @ load p2
|
| ++
|
| ++ uxtb16 r6, r6
|
| ++ uxtb16 r10, r10
|
| ++
|
| ++ eor r9, r9, lr
|
| ++ eor r11, r11, lr
|
| ++
|
| ++ orr r10, r6, r10, lsl #8 @ u = vp8_signed_char_clamp((63 + Filter2 * 9)>>7)
|
| ++
|
| ++ qadd8 r8, r11, r10 @ s = vp8_signed_char_clamp(ps2 + u)
|
| ++ qsub8 r10, r9, r10 @ s = vp8_signed_char_clamp(qs2 - u)
|
| ++ eor r8, r8, lr @ *op2 = s^0x80
|
| ++ str_post r8, r0, r1, lsl #2 @ store *op2
|
| ++ add r0, r0, r1
|
| ++ eor r10, r10, lr @ *oq2 = s^0x80
|
| ++ str_post r10, r0, r1, lsl #1 @ store *oq2
|
| ++
|
| ++2:
|
| ++ add r0, r0, #4
|
| ++ sub r0, r0, r1, lsl #3
|
| ++ subs r5, r5, #1
|
| ++
|
| ++T ittt ne
|
| ++ ldrne r10,[r0, r1] @ p2
|
| ++A ldrne r9, [r0], r1, lsl #1 @ p3
|
| ++T ldrne r9, [r0] @ p3
|
| ++T addne r0, r0, r1, lsl #1
|
| ++T ittt ne
|
| ++ ldrne r12,[r0, r1] @ p0
|
| ++A ldrne r11,[r0], r1, lsl #1 @ p1
|
| ++T ldrne r11,[r0] @ p3
|
| ++T addne r0, r0, r1, lsl #1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #16
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++.macro TRANSPOSE_MATRIX i0, i1, i2, i3, o3, o2, o1, o0
|
| ++ @ input: $0, $1, $2, $3
|
| ++ @ output: $4, $5, $6, $7
|
| ++ @ i0: 03 02 01 00
|
| ++ @ i1: 13 12 11 10
|
| ++ @ i2: 23 22 21 20
|
| ++ @ i3: 33 32 31 30
|
| ++ @ o3 o2 o1 o0
|
| ++
|
| ++ uxtb16 \o1, \i1 @ xx 12 xx 10
|
| ++ uxtb16 \o0, \i0 @ xx 02 xx 00
|
| ++ uxtb16 \o3, \i3 @ xx 32 xx 30
|
| ++ uxtb16 \o2, \i2 @ xx 22 xx 20
|
| ++ orr \o1, \o0, \o1, lsl #8 @ 12 02 10 00
|
| ++ orr \o3, \o2, \o3, lsl #8 @ 32 22 30 20
|
| ++
|
| ++ uxtb16 \i1, \i1, ror #8 @ xx 13 xx 11
|
| ++ uxtb16 \i3, \i3, ror #8 @ xx 33 xx 31
|
| ++ uxtb16 \i0, \i0, ror #8 @ xx 03 xx 01
|
| ++ uxtb16 \i2, \i2, ror #8 @ xx 23 xx 21
|
| ++ orr \i0, \i0, \i1, lsl #8 @ 13 03 11 01
|
| ++ orr \i2, \i2, \i3, lsl #8 @ 33 23 31 21
|
| ++
|
| ++ pkhtb \o2, \o3, \o1, asr #16 @ 32 22 12 02 -- p1
|
| ++ pkhbt \o0, \o1, \o3, lsl #16 @ 30 20 10 00 -- p3
|
| ++
|
| ++ pkhtb \o3, \i2, \i0, asr #16 @ 33 23 13 03 -- p0
|
| ++ pkhbt \o1, \i0, \i2, lsl #16 @ 31 21 11 01 -- p2
|
| ++.endm
|
| ++
|
| ++@ void vp8_h_loop_filter16_simple(uint8_t *dst, int stride, int flim)
|
| ++function ff_vp8_h_loop_filter16_simple_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++ orr r12, r2, r2, lsl #16
|
| ++ ldr r2, c0x80808080
|
| ++ orr r12, r12, r12, lsl #8
|
| ++
|
| ++ @ load soure data to r7, r8, r9, r10
|
| ++ sub r0, r0, #2
|
| ++ ldr r8, [r0, r1]
|
| ++ ldr_post r7, r0, r1, lsl #1
|
| ++ ldr r10,[r0, r1]
|
| ++ ldr_post r9, r0, r1, lsl #1
|
| ++ add r0, r0, #2
|
| ++
|
| ++ mov r11, #4 @ count (r11) for 4-in-parallel
|
| ++1:
|
| ++ @transpose r7, r8, r9, r10 to r3, r4, r5, r6
|
| ++ TRANSPOSE_MATRIX r7, r8, r9, r10, r6, r5, r4, r3
|
| ++
|
| ++ @ vp8_simple_filter_mask() function
|
| ++ 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)
|
| ++ mov r8, #0
|
| ++ uqadd8 r9, r9, r9 @ abs(p0 - q0) * 2
|
| ++ uhadd8 r7, r7, r8 @ abs(p1 - q1) / 2
|
| ++ uqadd8 r7, r7, r9 @ abs(p0 - q0)*2 + abs(p1 - q1)/2
|
| ++ mvn r10, #0 @ r10 == -1
|
| ++
|
| ++ usub8 r7, r12, r7 @ compare to flimit
|
| ++ sel lr, r10, r8 @ filter mask
|
| ++
|
| ++ cmp lr, #0
|
| ++ beq 2f @ 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 = p1 - q1
|
| ++ qsub8 r6, r5, r4 @ q0 - p0
|
| ++
|
| ++ qadd8 r3, r3, r6 @ vp8_filter += q0 - p0
|
| ++ ldr r9, c0x03030303 @ r9 = 3
|
| ++
|
| ++ qadd8 r3, r3, r6 @ vp8_filter += q0 - p0
|
| ++ ldr r7, c0x04040404
|
| ++
|
| ++ qadd8 r3, r3, r6 @ vp8_filter = p1-q1 + 3*(q0-p0))
|
| ++ @STALL
|
| ++ and r3, r3, lr @ vp8_filter &= mask
|
| ++
|
| ++ qadd8 r9, r3, r9 @ Filter2 = vp8_filter + 3
|
| ++ qadd8 r3, r3, r7 @ Filter1 = vp8_filter + 4
|
| ++
|
| ++ shadd8 r9, r9, r8
|
| ++ shadd8 r3, r3, r8
|
| ++ shadd8 r9, r9, r8
|
| ++ shadd8 r3, r3, r8
|
| ++ shadd8 r9, r9, r8 @ Filter2 >>= 3
|
| ++ shadd8 r3, r3, r8 @ Filter1 >>= 3
|
| ++
|
| ++ @calculate output
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ qadd8 r4, r4, r9 @ u = p0 + Filter2
|
| ++ qsub8 r5, r5, r3 @ u = q0 - Filter1
|
| ++ eor r4, r4, r2 @ *op0 = u^0x80
|
| ++ eor r5, r5, r2 @ *oq0 = u^0x80
|
| ++
|
| ++ strb r4, [r0, #-1] @ store the result
|
| ++ mov r4, r4, lsr #8
|
| ++ strb_post r5, r0, r1
|
| ++ mov r5, r5, lsr #8
|
| ++
|
| ++ strb r4, [r0, #-1]
|
| ++ mov r4, r4, lsr #8
|
| ++ strb_post r5, r0, r1
|
| ++ mov r5, r5, lsr #8
|
| ++
|
| ++ strb r4, [r0, #-1]
|
| ++ mov r4, r4, lsr #8
|
| ++ strb_post r5, r0, r1
|
| ++ mov r5, r5, lsr #8
|
| ++
|
| ++ strb r4, [r0, #-1]
|
| ++ strb_post r5, r0, r1
|
| ++
|
| ++2:
|
| ++ subs r11, r11, #1
|
| ++
|
| ++ @ load soure data to r7, r8, r9, r10
|
| ++ sub r0, r0, #2
|
| ++T ittt ne
|
| ++ ldrne r8, [r0, r1]
|
| ++A ldrne r7, [r0], r1, lsl #1
|
| ++T ldrne r7, [r0]
|
| ++T addne r0, r0, r1, lsl #1
|
| ++T ittt ne
|
| ++ ldrne r10,[r0, r1]
|
| ++A ldrne r9, [r0], r1, lsl #1
|
| ++T ldrne r9, [r0]
|
| ++T addne r0, r0, r1, lsl #1
|
| ++ add r0, r0, #2
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_h_loop_filter16_inner(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ and
|
| ++@ void vp8_h_loop_filter8uv_inner(uint8_t *dstU, uint8_t *dstV, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ call:
|
| ++@ void vp8_h_loop_filter_inner(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh, int count)
|
| ++function ff_vp8_h_loop_filter_inner_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ sub r0, r0, #4 @ move r0 pointer down by 4
|
| ++ ldr r5, [sp, #40] @ counter
|
| ++ ldr r9, [sp, #36] @ load thresh address
|
| ++ sub sp, sp, #16 @ create temp buffer
|
| ++
|
| ++ ldr r7, [r0, r1] @ transpose will make it into p3-p0
|
| ++ ldr_post r6, r0, r1, lsl #1 @ load source data
|
| ++ ldr lr, [r0, r1]
|
| ++ ldr_post r8, r0, r1, lsl #1
|
| ++
|
| ++ orr r2, r2, r2, lsl #16
|
| ++ orr r3, r3, r3, lsl #16
|
| ++ orr r9, r9, r9, lsl #16
|
| ++ orr r4, r2, r2, lsl #8 @ flimE splat int -> byte
|
| ++ orr r2, r3, r3, lsl #8 @ flimI splat int -> byte
|
| ++ orr r3, r9, r9, lsl #8 @ thresh splat int -> byte
|
| ++
|
| ++1:
|
| ++ @ vp8_filter_mask() function
|
| ++ @ calculate breakout conditions
|
| ++ @ transpose the source data for 4-in-parallel operation
|
| ++ TRANSPOSE_MATRIX r6, r7, r8, lr, r12, r11, r10, r9
|
| ++
|
| ++ uqsub8 r7, r9, r10 @ p3 - p2
|
| ++ uqsub8 r8, r10, r9 @ p2 - p3
|
| ++ uqsub8 r9, r10, r11 @ p2 - p1
|
| ++ uqsub8 r10, r11, r10 @ p1 - p2
|
| ++ orr r7, r7, r8 @ abs (p3-p2)
|
| ++ orr r10, r9, r10 @ abs (p2-p1)
|
| ++ uqsub8 lr, r7, r2 @ compare to limit. lr: vp8_filter_mask
|
| ++ uqsub8 r10, r10, r2 @ compare to limit
|
| ++
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ uqsub8 r6, r11, r12 @ p1 - p0
|
| ++ uqsub8 r7, r12, r11 @ p0 - p1
|
| ++ add r0, r0, #4 @ move r0 pointer up by 4
|
| ++ orr r6, r6, r7 @ abs (p1-p0)
|
| ++ str r11,[sp, #12] @ save p1
|
| ++ uqsub8 r10, r6, r2 @ compare to limit
|
| ++ uqsub8 r11, r6, r3 @ compare to thresh
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ @ transpose uses 8 regs(r6 - r12 and lr). Need to save reg value now
|
| ++ @ transpose the source data for 4-in-parallel operation
|
| ++ str r11,[sp] @ push r11 to stack
|
| ++ ldr r7, [r0, r1]
|
| ++ ldr_post r6, r0, r1, lsl #1 @ load source data
|
| ++ str r12,[sp, #4] @ save current reg before load q0 - q3 data
|
| ++ str lr, [sp, #8]
|
| ++ ldr lr, [r0, r1]
|
| ++ ldr_post r8, r0, r1, lsl #1
|
| ++
|
| ++ TRANSPOSE_MATRIX r6, r7, r8, lr, r12, r11, r10, r9
|
| ++
|
| ++ ldr lr, [sp, #8] @ load back (f)limit accumulator
|
| ++
|
| ++ uqsub8 r6, r12, r11 @ q3 - q2
|
| ++ uqsub8 r7, r11, r12 @ q2 - q3
|
| ++ uqsub8 r12, r11, r10 @ q2 - q1
|
| ++ uqsub8 r11, r10, r11 @ q1 - q2
|
| ++ orr r6, r6, r7 @ abs (q3-q2)
|
| ++ orr r7, r12, r11 @ abs (q2-q1)
|
| ++ uqsub8 r6, r6, r2 @ compare to limit
|
| ++ uqsub8 r7, r7, r2 @ compare to limit
|
| ++ ldr r11,[sp, #4] @ load back p0
|
| ++ ldr r12,[sp, #12] @ load back p1
|
| ++ orr lr, lr, r6
|
| ++ orr lr, lr, r7
|
| ++
|
| ++ uqsub8 r6, r11, r9 @ p0 - q0
|
| ++ uqsub8 r7, r9, r11 @ q0 - p0
|
| ++ uqsub8 r8, r12, r10 @ p1 - q1
|
| ++ uqsub8 r11, r10, r12 @ q1 - p1
|
| ++ orr r6, r6, r7 @ abs (p0-q0)
|
| ++ ldr r7, c0x7F7F7F7F
|
| ++ orr r8, r8, r11 @ abs (p1-q1)
|
| ++ uqadd8 r6, r6, r6 @ abs (p0-q0) * 2
|
| ++ and r8, r7, r8, lsr #1 @ abs (p1-q1) / 2
|
| ++ uqsub8 r11, r10, r9 @ q1 - q0
|
| ++ uqadd8 r6, r8, r6 @ abs (p0-q0)*2 + abs (p1-q1)/2
|
| ++ uqsub8 r12, r9, r10 @ q0 - q1
|
| ++ uqsub8 r6, r6, r4 @ compare to flimit
|
| ++
|
| ++ orr r9, r11, r12 @ abs (q1-q0)
|
| ++ uqsub8 r8, r9, r2 @ compare to limit
|
| ++ uqsub8 r10, r9, r3 @ compare to thresh
|
| ++ orr lr, lr, r6
|
| ++ orr lr, lr, r8
|
| ++
|
| ++ mvn r11, #0 @ r11 == -1
|
| ++ mov r12, #0
|
| ++
|
| ++ usub8 lr, r12, lr
|
| ++ ldr r9, [sp] @ load the compared result
|
| ++ sel lr, r11, r12 @ filter mask: lr
|
| ++
|
| ++ cmp lr, #0
|
| ++ beq 2f @ skip filtering
|
| ++
|
| ++ @vp8_hevmask() function
|
| ++ @calculate high edge variance
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++
|
| ++ orr r9, r9, r10
|
| ++
|
| ++ ldrh r7, [r0, #-2]
|
| ++ ldrh_post r8, r0, r1
|
| ++
|
| ++ usub8 r9, r12, r9
|
| ++ sel r6, r12, r11 @ hev mask: r6
|
| ++
|
| ++ @vp8_filter() function
|
| ++ @ load soure data to r6, r11, r12, lr
|
| ++ ldrh r9, [r0, #-2]
|
| ++ ldrh_post r10, r0, r1
|
| ++
|
| ++ pkhbt r12, r7, r8, lsl #16
|
| ++
|
| ++ ldrh r7, [r0, #-2]
|
| ++ ldrh_post r8, r0, r1
|
| ++
|
| ++ pkhbt r11, r9, r10, lsl #16
|
| ++
|
| ++ ldrh r9, [r0, #-2]
|
| ++ ldrh_post r10, r0, r1
|
| ++
|
| ++ @ Transpose needs 8 regs(r6 - r12, and lr). Save r6 and lr first
|
| ++ str r6, [sp]
|
| ++ str lr, [sp, #4]
|
| ++
|
| ++ pkhbt r6, r7, r8, lsl #16
|
| ++ pkhbt lr, r9, r10, lsl #16
|
| ++
|
| ++ @transpose r12, r11, r6, lr to r7, r8, r9, r10
|
| ++ TRANSPOSE_MATRIX r12, r11, r6, lr, r10, r9, r8, r7
|
| ++
|
| ++ @load back hev_mask r6 and filter_mask lr
|
| ++ ldr r12, c0x80808080
|
| ++ ldr r6, [sp]
|
| ++ ldr lr, [sp, #4]
|
| ++
|
| ++ eor r7, r7, r12 @ p1 offset to convert to a signed value
|
| ++ eor r8, r8, r12 @ p0 offset to convert to a signed value
|
| ++ eor r9, r9, r12 @ q0 offset to convert to a signed value
|
| ++ eor r10, r10, r12 @ q1 offset to convert to a signed value
|
| ++
|
| ++ str r9, [sp] @ store qs0 temporarily
|
| ++ str r8, [sp, #4] @ store ps0 temporarily
|
| ++ str r10,[sp, #8] @ store qs1 temporarily
|
| ++ str r7, [sp, #12] @ store ps1 temporarily
|
| ++
|
| ++ qsub8 r7, r7, r10 @ vp8_signed_char_clamp(ps1-qs1)
|
| ++ qsub8 r8, r9, r8 @ vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
|
| ++
|
| ++ and r7, r7, r6 @ vp8_filter (r7) &= hev (r7 : filter)
|
| ++
|
| ++ qadd8 r7, r7, r8
|
| ++ ldr r9, c0x03030303 @ r9 = 3 --modified for vp8
|
| ++
|
| ++ qadd8 r7, r7, r8
|
| ++ ldr r10, c0x04040404
|
| ++
|
| ++ qadd8 r7, r7, r8
|
| ++
|
| ++ and r7, r7, lr @ vp8_filter &= mask
|
| ++
|
| ++ qadd8 r8, r7, r9 @ Filter2 (r8) = vp8_signed_char_clamp(vp8_filter+3)
|
| ++ qadd8 r7, r7, r10 @ vp8_filter = vp8_signed_char_clamp(vp8_filter+4)
|
| ++
|
| ++ mov r9, #0
|
| ++ shadd8 r8, r8, r9 @ Filter2 >>= 3
|
| ++ shadd8 r7, r7, r9 @ vp8_filter >>= 3
|
| ++ shadd8 r8, r8, r9
|
| ++ shadd8 r7, r7, r9
|
| ++ shadd8 lr, r8, r9 @ lr: filter2
|
| ++ shadd8 r7, r7, r9 @ r7: filter
|
| ++
|
| ++ @calculate output
|
| ++ ldr r8, [sp] @ load qs0
|
| ++ ldr r9, [sp, #4] @ load ps0
|
| ++
|
| ++ ldr r10, c0x01010101
|
| ++
|
| ++ qsub8 r8, r8, r7 @ u = vp8_signed_char_clamp(qs0 - vp8_filter)
|
| ++ qadd8 r9, r9, lr @ u = vp8_signed_char_clamp(ps0 + Filter2)
|
| ++
|
| ++ eor r8, r8, r12
|
| ++ eor r9, r9, r12
|
| ++
|
| ++ mov lr, #0
|
| ++
|
| ++ sadd8 r7, r7, r10
|
| ++ shadd8 r7, r7, lr
|
| ++
|
| ++ ldr r10,[sp, #8] @ load qs1
|
| ++ ldr r11,[sp, #12] @ load ps1
|
| ++
|
| ++ bic r7, r7, r6 @ r7: vp8_filter
|
| ++
|
| ++ qsub8 r10, r10, r7 @ u = vp8_signed_char_clamp(qs1 - vp8_filter)
|
| ++ qadd8 r11, r11, r7 @ u = vp8_signed_char_clamp(ps1 + vp8_filter)
|
| ++ eor r10, r10, r12
|
| ++ eor r11, r11, r12
|
| ++
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ @we can use TRANSPOSE_MATRIX macro to transpose output - input: q1, q0, p0, p1
|
| ++ TRANSPOSE_MATRIX r11, r9, r8, r10, lr, r12, r7, r6
|
| ++
|
| ++ strh r6, [r0, #-2] @ store the result
|
| ++ mov r6, r6, lsr #16
|
| ++ strh_post r6, r0, r1
|
| ++
|
| ++ strh r7, [r0, #-2]
|
| ++ mov r7, r7, lsr #16
|
| ++ strh_post r7, r0, r1
|
| ++
|
| ++ strh r12, [r0, #-2]
|
| ++ mov r12, r12, lsr #16
|
| ++ strh_post r12, r0, r1
|
| ++
|
| ++ strh lr, [r0, #-2]
|
| ++ mov lr, lr, lsr #16
|
| ++ strh_post lr, r0, r1
|
| ++
|
| ++2:
|
| ++ sub r0, r0, #4
|
| ++ subs r5, r5, #1
|
| ++
|
| ++T ittt ne
|
| ++ ldrne r7, [r0, r1]
|
| ++A ldrne r6, [r0], r1, lsl #1 @ load source data
|
| ++T ldrne r6, [r0] @ load source data
|
| ++T addne r0, r0, r1, lsl #1
|
| ++T ittt ne
|
| ++ ldrne lr, [r0, r1]
|
| ++A ldrne r8, [r0], r1, lsl #1
|
| ++T ldrne r8, [r0]
|
| ++T addne r0, r0, r1, lsl #1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #16
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void vp8_h_loop_filter16(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ and
|
| ++@ void vp8_h_loop_filter8uv(uint8_t *dstU, uint8_t *dstV, int stride,
|
| ++@ int fE, int fI, int hev_thresh)
|
| ++@ call:
|
| ++@ void vp8_h_loop_filter(uint8_t *dst, int stride,
|
| ++@ int fE, int fI, int hev_thresh, int count)
|
| ++function ff_vp8_h_loop_filter_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ sub r0, r0, #4 @ move r0 pointer down by 4
|
| ++ ldr r5, [sp, #40] @ counter
|
| ++ ldr r9, [sp, #36] @ load thresh address
|
| ++ sub sp, sp, #16 @ create temp buffer
|
| ++
|
| ++ ldr r7, [r0, r1] @ transpose will make it into p3-p0
|
| ++ ldr_post r6, r0, r1, lsl #1 @ load source data
|
| ++ ldr lr, [r0, r1]
|
| ++ ldr_post r8, r0, r1, lsl #1
|
| ++
|
| ++ orr r2, r2, r2, lsl #16
|
| ++ orr r3, r3, r3, lsl #16
|
| ++ orr r9, r9, r9, lsl #16
|
| ++ orr r4, r2, r2, lsl #8 @ flimE splat int -> byte
|
| ++ orr r2, r3, r3, lsl #8 @ flimI splat int -> byte
|
| ++ orr r3, r9, r9, lsl #8 @ thresh splat int -> byte
|
| ++
|
| ++1:
|
| ++ @ vp8_filter_mask() function
|
| ++ @ calculate breakout conditions
|
| ++ @ transpose the source data for 4-in-parallel operation
|
| ++ TRANSPOSE_MATRIX r6, r7, r8, lr, r12, r11, r10, r9
|
| ++
|
| ++ uqsub8 r7, r9, r10 @ p3 - p2
|
| ++ uqsub8 r8, r10, r9 @ p2 - p3
|
| ++ uqsub8 r9, r10, r11 @ p2 - p1
|
| ++ uqsub8 r10, r11, r10 @ p1 - p2
|
| ++ orr r7, r7, r8 @ abs (p3-p2)
|
| ++ orr r10, r9, r10 @ abs (p2-p1)
|
| ++ uqsub8 lr, r7, r2 @ compare to limit. lr: vp8_filter_mask
|
| ++ uqsub8 r10, r10, r2 @ compare to limit
|
| ++
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ uqsub8 r6, r11, r12 @ p1 - p0
|
| ++ uqsub8 r7, r12, r11 @ p0 - p1
|
| ++ add r0, r0, #4 @ move r0 pointer up by 4
|
| ++ orr r6, r6, r7 @ abs (p1-p0)
|
| ++ str r11,[sp, #12] @ save p1
|
| ++ uqsub8 r10, r6, r2 @ compare to limit
|
| ++ uqsub8 r11, r6, r3 @ compare to thresh
|
| ++ orr lr, lr, r10
|
| ++
|
| ++ @ transpose uses 8 regs(r6 - r12 and lr). Need to save reg value now
|
| ++ @ transpose the source data for 4-in-parallel operation
|
| ++ str r11,[sp] @ push r11 to stack
|
| ++ ldr r7, [r0, r1]
|
| ++ ldr_post r6, r0, r1, lsl #1 @ load source data
|
| ++ str r12,[sp, #4] @ save current reg before load q0 - q3 data
|
| ++ str lr, [sp, #8]
|
| ++ ldr lr, [r0, r1]
|
| ++ ldr_post r8, r0, r1, lsl #1
|
| ++
|
| ++ TRANSPOSE_MATRIX r6, r7, r8, lr, r12, r11, r10, r9
|
| ++
|
| ++ ldr lr, [sp, #8] @ load back (f)limit accumulator
|
| ++
|
| ++ uqsub8 r6, r12, r11 @ q3 - q2
|
| ++ uqsub8 r7, r11, r12 @ q2 - q3
|
| ++ uqsub8 r12, r11, r10 @ q2 - q1
|
| ++ uqsub8 r11, r10, r11 @ q1 - q2
|
| ++ orr r6, r6, r7 @ abs (q3-q2)
|
| ++ orr r7, r12, r11 @ abs (q2-q1)
|
| ++ uqsub8 r6, r6, r2 @ compare to limit
|
| ++ uqsub8 r7, r7, r2 @ compare to limit
|
| ++ ldr r11,[sp, #4] @ load back p0
|
| ++ ldr r12,[sp, #12] @ load back p1
|
| ++ orr lr, lr, r6
|
| ++ orr lr, lr, r7
|
| ++
|
| ++ uqsub8 r6, r11, r9 @ p0 - q0
|
| ++ uqsub8 r7, r9, r11 @ q0 - p0
|
| ++ uqsub8 r8, r12, r10 @ p1 - q1
|
| ++ uqsub8 r11, r10, r12 @ q1 - p1
|
| ++ orr r6, r6, r7 @ abs (p0-q0)
|
| ++ ldr r7, c0x7F7F7F7F
|
| ++ orr r8, r8, r11 @ abs (p1-q1)
|
| ++ uqadd8 r6, r6, r6 @ abs (p0-q0) * 2
|
| ++ and r8, r7, r8, lsr #1 @ abs (p1-q1) / 2
|
| ++ uqsub8 r11, r10, r9 @ q1 - q0
|
| ++ uqadd8 r6, r8, r6 @ abs (p0-q0)*2 + abs (p1-q1)/2
|
| ++ uqsub8 r12, r9, r10 @ q0 - q1
|
| ++ uqsub8 r6, r6, r4 @ compare to flimit
|
| ++
|
| ++ orr r9, r11, r12 @ abs (q1-q0)
|
| ++ uqsub8 r8, r9, r2 @ compare to limit
|
| ++ uqsub8 r10, r9, r3 @ compare to thresh
|
| ++ orr lr, lr, r6
|
| ++ orr lr, lr, r8
|
| ++
|
| ++ mvn r11, #0 @ r11 == -1
|
| ++ mov r12, #0
|
| ++
|
| ++ usub8 lr, r12, lr
|
| ++ ldr r9, [sp] @ load the compared result
|
| ++ sel lr, r11, r12 @ filter mask: lr
|
| ++
|
| ++ cmp lr, #0
|
| ++ beq 2f @ skip filtering
|
| ++
|
| ++
|
| ++ @vp8_hevmask() function
|
| ++ @calculate high edge variance
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++
|
| ++ orr r9, r9, r10
|
| ++
|
| ++ ldrh r7, [r0, #-2]
|
| ++ ldrh_post r8, r0, r1
|
| ++
|
| ++ usub8 r9, r12, r9
|
| ++ sel r6, r12, r11 @ hev mask: r6
|
| ++
|
| ++
|
| ++ @ vp8_mbfilter() function
|
| ++ @ p2, q2 are only needed at the end. do not need to load them in now.
|
| ++ @ Transpose needs 8 regs(r6 - r12, and lr). Save r6 and lr first
|
| ++ @ load soure data to r6, r11, r12, lr
|
| ++ ldrh r9, [r0, #-2]
|
| ++ ldrh_post r10, r0, r1
|
| ++
|
| ++ pkhbt r12, r7, r8, lsl #16
|
| ++
|
| ++ ldrh r7, [r0, #-2]
|
| ++ ldrh_post r8, r0, r1
|
| ++
|
| ++ pkhbt r11, r9, r10, lsl #16
|
| ++
|
| ++ ldrh r9, [r0, #-2]
|
| ++ ldrh_post r10, r0, r1
|
| ++
|
| ++ str r6, [sp] @ save r6
|
| ++ str lr, [sp, #4] @ save lr
|
| ++
|
| ++ pkhbt r6, r7, r8, lsl #16
|
| ++ pkhbt lr, r9, r10, lsl #16
|
| ++
|
| ++ @transpose r12, r11, r6, lr to p1, p0, q0, q1
|
| ++ TRANSPOSE_MATRIX r12, r11, r6, lr, r10, r9, r8, r7
|
| ++
|
| ++ @load back hev_mask r6 and filter_mask lr
|
| ++ ldr r12, c0x80808080
|
| ++ ldr r6, [sp]
|
| ++ ldr lr, [sp, #4]
|
| ++
|
| ++ eor r7, r7, r12 @ ps1
|
| ++ eor r8, r8, r12 @ ps0
|
| ++ eor r9, r9, r12 @ qs0
|
| ++ eor r10, r10, r12 @ qs1
|
| ++
|
| ++ qsub8 r12, r9, r8 @ vp8_signed_char_clamp(vp8_filter + 3 * ( qs0 - ps0))
|
| ++ str r7, [sp, #12] @ store ps1 temporarily
|
| ++ qsub8 r7, r7, r10 @ vp8_signed_char_clamp(ps1-qs1)
|
| ++ str r10,[sp, #8] @ store qs1 temporarily
|
| ++ qadd8 r7, r7, r12
|
| ++ str r9, [sp] @ store qs0 temporarily
|
| ++ qadd8 r7, r7, r12
|
| ++ str r8, [sp, #4] @ store ps0 temporarily
|
| ++ qadd8 r7, r7, r12 @ vp8_filter: r7
|
| ++
|
| ++ ldr r10, c0x03030303 @ r10 = 3 --modified for vp8
|
| ++ ldr r9, c0x04040404
|
| ++
|
| ++ and r7, r7, lr @ vp8_filter &= mask (lr is free)
|
| ++
|
| ++ mov r12, r7 @ Filter2: r12
|
| ++ and r12, r12, r6 @ Filter2 &= hev
|
| ++
|
| ++ @save bottom 3 bits so that we round one side +4 and the other +3
|
| ++ qadd8 r8, r12, r9 @ Filter1 (r8) = vp8_signed_char_clamp(Filter2+4)
|
| ++ qadd8 r12, r12, r10 @ Filter2 (r12) = vp8_signed_char_clamp(Filter2+3)
|
| ++
|
| ++ mov r10, #0
|
| ++ shadd8 r8, r8, r10 @ Filter1 >>= 3
|
| ++ shadd8 r12, r12, r10 @ Filter2 >>= 3
|
| ++ shadd8 r8, r8, r10
|
| ++ shadd8 r12, r12, r10
|
| ++ shadd8 r8, r8, r10 @ r8: Filter1
|
| ++ shadd8 r12, r12, r10 @ r12: Filter2
|
| ++
|
| ++ ldr r9, [sp] @ load qs0
|
| ++ ldr r11,[sp, #4] @ load ps0
|
| ++
|
| ++ qsub8 r9, r9, r8 @ qs0 = vp8_signed_char_clamp(qs0 - Filter1)
|
| ++ qadd8 r11, r11, r12 @ ps0 = vp8_signed_char_clamp(ps0 + Filter2)
|
| ++
|
| ++ bic r12, r7, r6 @vp8_filter &= ~hev ( r6 is free)
|
| ++
|
| ++ @roughly 3/7th difference across boundary
|
| ++ mov lr, #0x1b @ 27
|
| ++ mov r7, #0x3f @ 63
|
| ++
|
| ++ sxtb16 r6, r12
|
| ++ sxtb16 r10, r12, ror #8
|
| ++ smlabb r8, r6, lr, r7
|
| ++ smlatb r6, r6, lr, r7
|
| ++ smlabb r7, r10, lr, r7
|
| ++ smultb r10, r10, lr
|
| ++ ssat r8, #8, r8, asr #7
|
| ++ ssat r6, #8, r6, asr #7
|
| ++ add r10, r10, #63
|
| ++ ssat r7, #8, r7, asr #7
|
| ++ ssat r10, #8, r10, asr #7
|
| ++
|
| ++ ldr lr, c0x80808080
|
| ++
|
| ++ pkhbt r6, r8, r6, lsl #16
|
| ++ pkhbt r10, r7, r10, lsl #16
|
| ++ uxtb16 r6, r6
|
| ++ uxtb16 r10, r10
|
| ++
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++
|
| ++ orr r10, r6, r10, lsl #8 @ u = vp8_signed_char_clamp((63 + Filter2 * 27)>>7)
|
| ++
|
| ++ qsub8 r8, r9, r10 @ s = vp8_signed_char_clamp(qs0 - u)
|
| ++ qadd8 r10, r11, r10 @ s = vp8_signed_char_clamp(ps0 + u)
|
| ++ eor r8, r8, lr @ *oq0 = s^0x80
|
| ++ eor r10, r10, lr @ *op0 = s^0x80
|
| ++
|
| ++ strb r10,[r0, #-1] @ store op0 result
|
| ++ strb_post r8, r0, r1 @ store oq0 result
|
| ++ mov r10, r10, lsr #8
|
| ++ mov r8, r8, lsr #8
|
| ++ strb r10,[r0, #-1]
|
| ++ strb_post r8, r0, r1
|
| ++ mov r10, r10, lsr #8
|
| ++ mov r8, r8, lsr #8
|
| ++ strb r10,[r0, #-1]
|
| ++ strb_post r8, r0, r1
|
| ++ mov r10, r10, lsr #8
|
| ++ mov r8, r8, lsr #8
|
| ++ strb r10,[r0, #-1]
|
| ++ strb_post r8, r0, r1
|
| ++
|
| ++ @roughly 2/7th difference across boundary
|
| ++ mov lr, #0x12 @ 18
|
| ++ mov r7, #0x3f @ 63
|
| ++
|
| ++ sxtb16 r6, r12
|
| ++ sxtb16 r10, r12, ror #8
|
| ++ smlabb r8, r6, lr, r7
|
| ++ smlatb r6, r6, lr, r7
|
| ++ smlabb r9, r10, lr, r7
|
| ++ smlatb r10, r10, lr, r7
|
| ++ ssat r8, #8, r8, asr #7
|
| ++ ssat r6, #8, r6, asr #7
|
| ++ ssat r9, #8, r9, asr #7
|
| ++ ssat r10, #8, r10, asr #7
|
| ++
|
| ++ sub r0, r0, r1, lsl #2 @ move r0 pointer down by 4 lines
|
| ++
|
| ++ pkhbt r6, r8, r6, lsl #16
|
| ++ pkhbt r10, r9, r10, lsl #16
|
| ++
|
| ++ ldr r9, [sp, #8] @ load qs1
|
| ++ ldr r11,[sp, #12] @ load ps1
|
| ++ ldr lr, c0x80808080
|
| ++
|
| ++ uxtb16 r6, r6
|
| ++ uxtb16 r10, r10
|
| ++
|
| ++ add r0, r0, #2
|
| ++
|
| ++ orr r10, r6, r10, lsl #8 @ u = vp8_signed_char_clamp((63 + Filter2 * 18)>>7)
|
| ++
|
| ++ qsub8 r8, r9, r10 @ s = vp8_signed_char_clamp(qs1 - u)
|
| ++ qadd8 r10, r11, r10 @ s = vp8_signed_char_clamp(ps1 + u)
|
| ++ eor r8, r8, lr @ *oq1 = s^0x80
|
| ++ eor r10, r10, lr @ *op1 = s^0x80
|
| ++
|
| ++ ldrb r11,[r0, #-5] @ load p2 for 1/7th difference across boundary
|
| ++ strb r10,[r0, #-4] @ store op1
|
| ++ strb r8, [r0, #-1] @ store oq1
|
| ++ ldrb_post r9, r0, r1 @ load q2 for 1/7th difference across boundary
|
| ++
|
| ++ mov r10, r10, lsr #8
|
| ++ mov r8, r8, lsr #8
|
| ++
|
| ++ ldrb r6, [r0, #-5]
|
| ++ strb r10,[r0, #-4]
|
| ++ strb r8, [r0, #-1]
|
| ++ ldrb_post r7, r0, r1
|
| ++
|
| ++ mov r10, r10, lsr #8
|
| ++ mov r8, r8, lsr #8
|
| ++ orr r11, r11, r6, lsl #8
|
| ++ orr r9, r9, r7, lsl #8
|
| ++
|
| ++ ldrb r6, [r0, #-5]
|
| ++ strb r10,[r0, #-4]
|
| ++ strb r8, [r0, #-1]
|
| ++ ldrb_post r7, r0, r1
|
| ++
|
| ++ mov r10, r10, lsr #8
|
| ++ mov r8, r8, lsr #8
|
| ++ orr r11, r11, r6, lsl #16
|
| ++ orr r9, r9, r7, lsl #16
|
| ++
|
| ++ ldrb r6, [r0, #-5]
|
| ++ strb r10,[r0, #-4]
|
| ++ strb r8, [r0, #-1]
|
| ++ ldrb_post r7, r0, r1
|
| ++ orr r11, r11, r6, lsl #24
|
| ++ orr r9, r9, r7, lsl #24
|
| ++
|
| ++ @roughly 1/7th difference across boundary
|
| ++ eor r9, r9, lr
|
| ++ eor r11, r11, lr
|
| ++
|
| ++ mov lr, #0x9 @ 9
|
| ++ mov r7, #0x3f @ 63
|
| ++
|
| ++ sxtb16 r6, r12
|
| ++ sxtb16 r10, r12, ror #8
|
| ++ smlabb r8, r6, lr, r7
|
| ++ smlatb r6, r6, lr, r7
|
| ++ smlabb r12, r10, lr, r7
|
| ++ smlatb r10, r10, lr, r7
|
| ++ ssat r8, #8, r8, asr #7
|
| ++ ssat r6, #8, r6, asr #7
|
| ++ ssat r12, #8, r12, asr #7
|
| ++ ssat r10, #8, r10, asr #7
|
| ++
|
| ++ sub r0, r0, r1, lsl #2
|
| ++
|
| ++ pkhbt r6, r8, r6, lsl #16
|
| ++ pkhbt r10, r12, r10, lsl #16
|
| ++
|
| ++ uxtb16 r6, r6
|
| ++ uxtb16 r10, r10
|
| ++
|
| ++ ldr lr, c0x80808080
|
| ++
|
| ++ orr r10, r6, r10, lsl #8 @ u = vp8_signed_char_clamp((63 + Filter2 * 9)>>7)
|
| ++
|
| ++ qadd8 r8, r11, r10 @ s = vp8_signed_char_clamp(ps2 + u)
|
| ++ qsub8 r10, r9, r10 @ s = vp8_signed_char_clamp(qs2 - u)
|
| ++ eor r8, r8, lr @ *op2 = s^0x80
|
| ++ eor r10, r10, lr @ *oq2 = s^0x80
|
| ++
|
| ++ strb r8, [r0, #-5] @ store *op2
|
| ++ strb_post r10, r0, r1 @ store *oq2
|
| ++ mov r8, r8, lsr #8
|
| ++ mov r10, r10, lsr #8
|
| ++ strb r8, [r0, #-5]
|
| ++ strb_post r10, r0, r1
|
| ++ mov r8, r8, lsr #8
|
| ++ mov r10, r10, lsr #8
|
| ++ strb r8, [r0, #-5]
|
| ++ strb_post r10, r0, r1
|
| ++ mov r8, r8, lsr #8
|
| ++ mov r10, r10, lsr #8
|
| ++ strb r8, [r0, #-5]
|
| ++ strb_post r10, r0, r1
|
| ++
|
| ++ @adjust r0 pointer for next loop
|
| ++ sub r0, r0, #2
|
| ++
|
| ++2:
|
| ++ sub r0, r0, #4
|
| ++ subs r5, r5, #1
|
| ++
|
| ++T ittt ne
|
| ++ ldrne r7, [r0, r1]
|
| ++A ldrne r6, [r0], r1, lsl #1 @ load source data
|
| ++T ldrne r6, [r0]
|
| ++T addne r0, r0, r1, lsl #1
|
| ++T ittt ne
|
| ++ ldrne lr, [r0, r1]
|
| ++A ldrne r8, [r0], r1, lsl #1
|
| ++T ldrne r8, [r0]
|
| ++T addne r0, r0, r1, lsl #1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #16
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ MC
|
| ++
|
| ++@ void put_vp8_pixels16(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int h, int mx, int my)
|
| ++function ff_put_vp8_pixels16_armv6, export=1
|
| ++ push {r4 - r11}
|
| ++ ldr r12,[sp, #32] @ h
|
| ++1:
|
| ++ subs r12, r12, #2
|
| ++ ldr r5, [r2, #4]
|
| ++ ldr r6, [r2, #8]
|
| ++ ldr r7, [r2, #12]
|
| ++ ldr_post r4, r2, r3
|
| ++ ldr r9, [r2, #4]
|
| ++ ldr r10,[r2, #8]
|
| ++ ldr r11,[r2, #12]
|
| ++ ldr_post r8, r2, r3
|
| ++ strd r6, r7, [r0, #8]
|
| ++ strd_post r4, r5, r0, r1
|
| ++ strd r10, r11,[r0, #8]
|
| ++ strd_post r8, r9, r0, r1
|
| ++ bgt 1b
|
| ++ pop {r4 - r11}
|
| ++ bx lr
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_pixels8(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int h, int mx, int my)
|
| ++function ff_put_vp8_pixels8_armv6, export=1
|
| ++ push {r4 - r11}
|
| ++ ldr r12,[sp, #32] @ h
|
| ++1:
|
| ++ subs r12, r12, #4
|
| ++ ldr r5, [r2, #4]
|
| ++ ldr_post r4, r2, r3
|
| ++ ldr r7, [r2, #4]
|
| ++ ldr_post r6, r2, r3
|
| ++ ldr r9, [r2, #4]
|
| ++ ldr_post r8, r2, r3
|
| ++ ldr r11,[r2, #4]
|
| ++ ldr_post r10, r2, r3
|
| ++ strd_post r4, r5, r0, r1
|
| ++ strd_post r6, r7, r0, r1
|
| ++ strd_post r8, r9, r0, r1
|
| ++ strd_post r10, r11, r0, r1
|
| ++ bgt 1b
|
| ++ pop {r4 - r11}
|
| ++ bx lr
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_pixels4(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int h, int mx, int my)
|
| ++function ff_put_vp8_pixels4_armv6, export=1
|
| ++ ldr r12, [sp, #0] @ h
|
| ++ push {r4 - r6, lr}
|
| ++1:
|
| ++ subs r12, r12, #4
|
| ++ ldr r5, [r2, r3]
|
| ++ ldr_post r4, r2, r3, lsl #1
|
| ++ ldr lr, [r2, r3]
|
| ++ ldr_post r6, r2, r3, lsl #1
|
| ++ str r5, [r0, r1]
|
| ++ str_post r4, r0, r1, lsl #1
|
| ++ str lr, [r0, r1]
|
| ++ str_post r6, r0, r1, lsl #1
|
| ++ bgt 1b
|
| ++ pop {r4 - r6, pc}
|
| ++endfunc
|
| ++
|
| ++@ note: worst case sum of all 6-tap filter values * 255 is 0x7f80 so 16 bit
|
| ++@ arithmatic can be used to apply filters
|
| ++const sixtap_filters_13245600, align=4
|
| ++ .short 2, 108, -11, 36, -8, 1, 0, 0
|
| ++ .short 3, 77, -16, 77, -16, 3, 0, 0
|
| ++ .short 1, 36, -8, 108, -11, 2, 0, 0
|
| ++endconst
|
| ++const fourtap_filters_1324, align=4
|
| ++ .short -6, 12, 123, -1
|
| ++ .short -9, 50, 93, -6
|
| ++ .short -6, 93, 50, -9
|
| ++ .short -1, 123, 12, -6
|
| ++endconst
|
| ++
|
| ++@ void put_vp8_epel_h6(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int w, int h, int mx)
|
| ++function ff_put_vp8_epel_h6_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ sub r2, r2, #2
|
| ++ movrel lr, sixtap_filters_13245600 - 16
|
| ++ ldr r12,[sp, #44] @ vp8_filter index
|
| ++ ldr r4, [sp, #36] @ width
|
| ++ add lr, lr, r12, lsl #3
|
| ++ sub r3, r3, r4 @ src_stride - block_width
|
| ++ sub r1, r1, r4 @ dst_stride - block_width
|
| ++ lsr r4, #2
|
| ++
|
| ++ str r4, [sp, #36] @ "4-in-parallel" loop counter @40
|
| ++ str r3, [sp, #44] @ src_stride - block_width @48
|
| ++ push {r1} @ dst_stride - block_width @0
|
| ++ @ height @44
|
| ++
|
| ++ ldr r1, [lr], #4 @ coefficients
|
| ++ ldr r3, [lr], #4
|
| ++ ldr lr, [lr]
|
| ++1:
|
| ++ @ 3 loads, 10 shuffles and then mul/acc/add/shr
|
| ++ @ o0: i0/i1/i2/i3/i4/i5 -> i0/i2 (ld1) | i1/i3 (ld1) | i4/i5 (ld2)
|
| ++ @ o1: i1/i2/i3/i4/i5/i6 -> i1/i3 (ld1) | i2/i4 (ld2) | i5/i6 (ld2/3)
|
| ++ @ o2: i2/i3/i4/i5/i6/i7 -> i2/i4 (ld2) | i3/i5 (ld2) | i6/i7 (ld3)
|
| ++ @ o3: i3/i4/i5/i6/i7/i8 -> i3/i5 (ld2) | i4/i6 (ld2/3) | i7/i8 (ld3)
|
| ++ ldr r7, [r2, #5] @ ld3 -> src[5-8]
|
| ++ ldr r6, [r2, #2] @ ld2 -> src[2-5]
|
| ++ ldr r5, [r2], #4 @ ld1 -> src[0-3]
|
| ++
|
| ++ pkhtb r7, r7, r7, asr #8 @ src[8,7,7,6]
|
| ++ uxtb16 r9, r6, ror #8 @ src[5] | src[3]
|
| ++ uxtb16 r6, r6 @ src[4] | src[2]
|
| ++ uxtb16 r8, r5, ror #8 @ src[3] | src[1]
|
| ++ uxtb16 r11, r7, ror #8 @ src[8] | src[7]
|
| ++ uxtb16 r7, r7 @ src[7] | src[6]
|
| ++ pkhtb r10, r9, r6, asr #16 @ src[5] | src[4]
|
| ++ uxtb16 r5, r5 @ src[2] | src[0]
|
| ++
|
| ++ smuad r11, r11, lr @ filter[3][2] -> r11
|
| ++ subs r4, r4, #1
|
| ++ pkhbt r12, r10, r7, lsl #16 @ src[6] | src[4]
|
| ++ smuad r7, r7, lr @ filter[2][2] -> r7
|
| ++ smuad r5, r5, r1 @ filter[0][0] -> r5
|
| ++ smlad r11, r9, r1, r11 @ filter[3][0] -> r11
|
| ++ smlad r7, r9, r3, r7 @ filter[2][1] -> r7
|
| ++ smuad r9, r8, r1 @ filter[1][0] -> r9
|
| ++ smlad r5, r8, r3, r5 @ filter[0][1] -> r5
|
| ++ pkhtb r8, r12, r10, asr #16 @ src[6] | src[5]
|
| ++ smlad r11, r12, r3, r11 @ filter[3][1] -> r11
|
| ++ smlad r9, r6, r3, r9 @ filter[1][1] -> r9
|
| ++ smlad r5, r10, lr, r5 @ filter[0][2] -> r5
|
| ++ smlad r7, r6, r1, r7 @ filter[2][0] -> r7
|
| ++ smlad r9, r8, lr, r9 @ filter[1][2] -> r9
|
| ++
|
| ++ add r5, r5, #0x40 @ round_shift_and_clamp[0]
|
| ++ add r9, r9, #0x40 @ round_shift_and_clamp[1]
|
| ++ add r7, r7, #0x40 @ round_shift_and_clamp[2]
|
| ++ add r11, r11, #0x40 @ round_shift_and_clamp[3]
|
| ++
|
| ++ usat r5, #8, r5, asr #7
|
| ++ usat r9, #8, r9, asr #7
|
| ++ usat r7, #8, r7, asr #7
|
| ++ usat r11, #8, r11, asr #7
|
| ++
|
| ++ strb r5, [r0], #1 @ store res[0]
|
| ++ strb r9, [r0], #1 @ store res[1]
|
| ++ strb r7, [r0], #1 @ store res[2]
|
| ++ strb r11,[r0], #1 @ store res[3]
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ ldr r12,[sp, #44] @ height = outer-loop counter
|
| ++ subs r12, r12, #1
|
| ++T itttt ne
|
| ++ ldrne r4, [sp, #40] @ 4-in-parallel loop counter
|
| ++ ldrne r5, [sp, #48]
|
| ++ ldrne r6, [sp]
|
| ++ strne r12,[sp, #44]
|
| ++ add r2, r2, r5 @ move to next input/output lines
|
| ++ add r0, r0, r6
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #4 @ restore stack after push{r1} above
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_epel_v6(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int w, int h, int my)
|
| ++function ff_put_vp8_epel_v6_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ movrel lr, sixtap_filters_13245600 - 16
|
| ++ ldr r12,[sp, #44] @ vp8_filter index
|
| ++ ldr r4, [sp, #36] @ width
|
| ++ add lr, lr, r12, lsl #3
|
| ++ sub r1, r1, r4 @ dst_stride - block_width
|
| ++ lsr r4, #2
|
| ++
|
| ++ str r4, [sp, #36] @ "4-in-parallel" loop counter @40
|
| ++ str r3, [sp, #44] @ src_stride - block_width @48
|
| ++ push {r1} @ dst_stride - block_width @0
|
| ++ @ height @44
|
| ++1:
|
| ++ add r1, r3, r3, lsl #1 @ stride * 3
|
| ++ ldr_dpren r5, r2, r3 @ src[0,1,2,3 + stride * 1]
|
| ++ ldr r6, [r2, r3] @ src[0,1,2,3 + stride * 3]
|
| ++ ldr r7, [r2, r3, lsl #1] @ src[0,1,2,3 + stride * 4]
|
| ++ ldr r8, [r2, r1] @ src[0,1,2,3 + stride * 5]
|
| ++
|
| ++ @ byte -> word and "transpose"
|
| ++ uxtb16 r9, r5, ror #8 @ src[3 + stride*1] | src[1 + stride*1]
|
| ++ uxtb16 r10, r6, ror #8 @ src[3 + stride*3] | src[1 + stride*3]
|
| ++ uxtb16 r11, r7, ror #8 @ src[3 + stride*4] | src[1 + stride*4]
|
| ++ uxtb16 r12, r8, ror #8 @ src[3 + stride*5] | src[1 + stride*5]
|
| ++ uxtb16 r5, r5 @ src[2 + stride*1] | src[0 + stride*1]
|
| ++ uxtb16 r6, r6 @ src[2 + stride*3] | src[0 + stride*3]
|
| ++ uxtb16 r7, r7 @ src[2 + stride*4] | src[0 + stride*4]
|
| ++ uxtb16 r8, r8 @ src[2 + stride*5] | src[0 + stride*5]
|
| ++ pkhbt r1, r9, r10, lsl #16 @ src[1 + stride*3] | src[1 + stride*1]
|
| ++ pkhtb r9, r10, r9, asr #16 @ src[3 + stride*3] | src[3 + stride*1]
|
| ++ pkhbt r10, r11, r12, lsl #16 @ src[1 + stride*5] | src[1 + stride*4]
|
| ++ pkhtb r11, r12, r11, asr #16 @ src[3 + stride*5] | src[3 + stride*4]
|
| ++ pkhbt r12, r5, r6, lsl #16 @ src[0 + stride*3] | src[0 + stride*1]
|
| ++ pkhtb r5, r6, r5, asr #16 @ src[2 + stride*3] | src[2 + stride*1]
|
| ++ pkhbt r6, r7, r8, lsl #16 @ src[0 + stride*5] | src[0 + stride*4]
|
| ++ pkhtb r7, r8, r7, asr #16 @ src[2 + stride*5] | src[2 + stride*4]
|
| ++
|
| ++ ldr r8, [lr, #4] @ stall - if only I had more registers...
|
| ++ smuad r12, r12, r8 @ filter[0][1]
|
| ++ smuad r1, r1, r8 @ filter[1][1]
|
| ++ smuad r5, r5, r8 @ filter[2][1]
|
| ++ smuad r9, r9, r8 @ filter[3][1]
|
| ++ ldr r8, [lr, #8] @ stall - if only I had more registers...
|
| ++ smlad r12, r6, r8, r12 @ filter[0][2]
|
| ++ smlad r1, r10, r8, r1 @ filter[1][2]
|
| ++ ldr_dpren r6, r2, r3, lsl #1 @ src[0,1,2,3 + stride * 0]
|
| ++ ldr r10,[r2], #4 @ src[0,1,2,3 + stride * 2]
|
| ++ smlad r5, r7, r8, r5 @ filter[2][2]
|
| ++ smlad r9, r11, r8, r9 @ filter[3][2]
|
| ++
|
| ++ uxtb16 r7, r6, ror #8 @ src[3 + stride*0] | src[1 + stride*0]
|
| ++ uxtb16 r11, r10, ror #8 @ src[3 + stride*2] | src[1 + stride*2]
|
| ++ uxtb16 r6, r6 @ src[2 + stride*0] | src[0 + stride*0]
|
| ++ uxtb16 r10, r10 @ src[2 + stride*2] | src[0 + stride*2]
|
| ++
|
| ++ pkhbt r8, r7, r11, lsl #16 @ src[1 + stride*2] | src[1 + stride*0]
|
| ++ pkhtb r7, r11, r7, asr #16 @ src[3 + stride*2] | src[3 + stride*0]
|
| ++ pkhbt r11, r6, r10, lsl #16 @ src[0 + stride*2] | src[0 + stride*0]
|
| ++ pkhtb r6, r10, r6, asr #16 @ src[2 + stride*2] | src[2 + stride*0]
|
| ++
|
| ++ ldr r10,[lr] @ stall - if only I had more registers...
|
| ++ subs r4, r4, #1 @ counter--
|
| ++ smlad r12, r11, r10, r12 @ filter[0][0]
|
| ++ smlad r1, r8, r10, r1 @ filter[1][0]
|
| ++ smlad r5, r6, r10, r5 @ filter[2][0]
|
| ++ smlad r9, r7, r10, r9 @ filter[3][0]
|
| ++
|
| ++ add r12, r12, #0x40 @ round_shift_and_clamp[0]
|
| ++ add r1, r1, #0x40 @ round_shift_and_clamp[1]
|
| ++ add r5, r5, #0x40 @ round_shift_and_clamp[2]
|
| ++ add r9, r9, #0x40 @ round_shift_and_clamp[3]
|
| ++
|
| ++ usat r12, #8, r12, asr #7
|
| ++ usat r1, #8, r1, asr #7
|
| ++ usat r5, #8, r5, asr #7
|
| ++ usat r9, #8, r9, asr #7
|
| ++
|
| ++ strb r12,[r0], #1 @ store res[0]
|
| ++ strb r1, [r0], #1 @ store res[1]
|
| ++ strb r5, [r0], #1 @ store res[2]
|
| ++ strb r9, [r0], #1 @ store res[3]
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ ldr r12,[sp, #44] @ height = outer-loop counter
|
| ++ subs r12, r12, #1
|
| ++T itttt ne
|
| ++ ldrne r4, [sp, #40] @ 4-in-parallel loop counter
|
| ++ ldrne r6, [sp, #0]
|
| ++ subne r2, r2, r4, lsl #2
|
| ++ strne r12,[sp, #44]
|
| ++ add r0, r0, r6
|
| ++ add r2, r2, r3 @ move to next input/output lines
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #4 @ restore stack after push{r1} above
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_epel_h4(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int w, int h, int mx)
|
| ++function ff_put_vp8_epel_h4_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ subs r2, r2, #1
|
| ++ movrel lr, fourtap_filters_1324 - 4
|
| ++ ldr r4, [sp, #36] @ width
|
| ++ ldr r12,[sp, #44] @ vp8_filter index
|
| ++ add lr, lr, r12, lsl #2
|
| ++ sub r3, r3, r4 @ src_stride - block_width
|
| ++ sub r1, r1, r4 @ dst_stride - block_width
|
| ++ ldr r5, [lr]
|
| ++ ldr r6, [lr, #4]
|
| ++ asr r4, #2
|
| ++
|
| ++ ldr lr, [sp, #40] @ height = outer-loop counter
|
| ++ str r4, [sp, #36] @ "4-in-parallel" inner loop counter
|
| ++1:
|
| ++ @ 3 loads, 5 uxtb16s and then mul/acc/add/shr
|
| ++ @ o0: i0/i1/i2/i3 -> i0/i2(ld1) + i1/i3(ld1)
|
| ++ @ o1: i1/i2/i3/i4 -> i1/i3(ld1) + i2/i4(ld2)
|
| ++ @ o2: i2/i3/i4/i5 -> i2/i4(ld2) + i3/i5(ld2)
|
| ++ @ o3: i3/i4/i5/i6 -> i3/i5(ld2) + i4/i6(ld3)
|
| ++ ldr r9, [r2, #3] @ load source data
|
| ++ ldr r8, [r2, #2]
|
| ++ ldr r7, [r2], #4
|
| ++
|
| ++ uxtb16 r9, r9, ror #8 @ src[6] | src[4]
|
| ++ uxtb16 r10, r8, ror #8 @ src[5] | src[3]
|
| ++ uxtb16 r8, r8 @ src[4] | src[2]
|
| ++ uxtb16 r11, r7, ror #8 @ src[3] | src[1]
|
| ++ uxtb16 r7, r7 @ src[2] | src[0]
|
| ++
|
| ++ smuad r9, r9, r6 @ filter[3][1] -> r9
|
| ++ smuad r12, r10, r6 @ filter[2][1] -> r12
|
| ++ smuad r7, r7, r5 @ filter[0][0] -> r7
|
| ++ smlad r9, r10, r5, r9 @ filter[3][0] -> r9
|
| ++ smuad r10, r11, r5 @ filter[1][0] -> r10
|
| ++ smlad r12, r8, r5, r12 @ filter[2][0] -> r12
|
| ++ smlad r7, r11, r6, r7 @ filter[0][1] -> r7
|
| ++ smlad r10, r8, r6, r10 @ filter[1][1] -> r10
|
| ++
|
| ++ subs r4, r4, #1 @ counter--
|
| ++
|
| ++ add r7, r7, #0x40 @ round_shift_and_clamp[0]
|
| ++ add r10, r10, #0x40 @ round_shift_and_clamp[1]
|
| ++ add r12, r12, #0x40 @ round_shift_and_clamp[2]
|
| ++ add r9, r9, #0x40 @ round_shift_and_clamp[3]
|
| ++
|
| ++ usat r7, #8, r7, asr #7
|
| ++ usat r10, #8, r10, asr #7
|
| ++ usat r12, #8, r12, asr #7
|
| ++ usat r9, #8, r9, asr #7
|
| ++
|
| ++ strb r7, [r0], #1 @ store res[0]
|
| ++ strb r10,[r0], #1 @ store res[1]
|
| ++ strb r12,[r0], #1 @ store res[2]
|
| ++ strb r9, [r0], #1 @ store res[3]
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ subs lr, lr, #1
|
| ++T it ne
|
| ++ ldrne r4, [sp, #36] @ 4-in-parallel loop counter
|
| ++ add r2, r2, r3 @ move to next input/output lines
|
| ++ add r0, r0, r1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_epel_v4(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int w, int h, int my)
|
| ++function ff_put_vp8_epel_v4_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ movrel lr, fourtap_filters_1324 - 4
|
| ++ ldr r12,[sp, #44] @ vp8_filter index
|
| ++ ldr r4, [sp, #36] @ width
|
| ++ add lr, lr, r12, lsl #2
|
| ++ sub r1, r1, r4 @ dst_stride - block_width
|
| ++ asr r4, #2
|
| ++ ldr r5, [lr]
|
| ++ ldr r6, [lr, #4]
|
| ++
|
| ++ str r4, [sp, #36] @ "4-in-parallel" loop counter @40
|
| ++ str r3, [sp, #44] @ src_stride @48
|
| ++ push {r1} @ dst_stride - block_width @36
|
| ++ @ height @44
|
| ++1:
|
| ++ ldr lr, [r2, r3, lsl #1] @ load source pixels
|
| ++ ldr r12,[r2, r3]
|
| ++ ldr_dpren r7, r2, r3
|
| ++ ldr r11,[r2], #4
|
| ++
|
| ++ @ byte -> word and "transpose"
|
| ++ uxtb16 r8, lr, ror #8 @ src[3 + stride*3] | src[1 + stride*3]
|
| ++ uxtb16 r9, r12, ror #8 @ src[3 + stride*2] | src[1 + stride*2]
|
| ++ uxtb16 r3, r7, ror #8 @ src[3 + stride*0] | src[1 + stride*0]
|
| ++ uxtb16 r1, r11, ror #8 @ src[3 + stride*1] | src[1 + stride*1]
|
| ++ uxtb16 lr, lr @ src[2 + stride*3] | src[0 + stride*3]
|
| ++ uxtb16 r12, r12 @ src[2 + stride*2] | src[0 + stride*2]
|
| ++ uxtb16 r7, r7 @ src[2 + stride*0] | src[0 + stride*0]
|
| ++ uxtb16 r11, r11 @ src[2 + stride*1] | src[0 + stride*1]
|
| ++ pkhbt r10, r1, r8, lsl #16 @ src[1 + stride*3] | src[1 + stride*1]
|
| ++ pkhtb r1, r8, r1, asr #16 @ src[3 + stride*3] | src[3 + stride*1]
|
| ++ pkhbt r8, r3, r9, lsl #16 @ src[1 + stride*2] | src[1 + stride*0]
|
| ++ pkhtb r3, r9, r3, asr #16 @ src[3 + stride*2] | src[3 + stride*0]
|
| ++ pkhbt r9, r11, lr, lsl #16 @ src[0 + stride*3] | src[0 + stride*1]
|
| ++ pkhtb r11, lr, r11, asr #16 @ src[2 + stride*3] | src[2 + stride*1]
|
| ++ pkhbt lr, r7, r12, lsl #16 @ src[0 + stride*2] | src[0 + stride*0]
|
| ++ pkhtb r7, r12, r7, asr #16 @ src[2 + stride*2] | src[2 + stride*0]
|
| ++
|
| ++ smuad r9, r9, r6 @ filter[0][1]
|
| ++ smuad r10, r10, r6 @ filter[1][1]
|
| ++ smuad r11, r11, r6 @ filter[2][1]
|
| ++ smuad r1, r1, r6 @ filter[3][1]
|
| ++ smlad r9, lr, r5, r9 @ filter[0][0]
|
| ++ smlad r10, r8, r5, r10 @ filter[1][0]
|
| ++ smlad r11, r7, r5, r11 @ filter[2][0]
|
| ++ smlad r1, r3, r5, r1 @ filter[3][0]
|
| ++
|
| ++ subs r4, r4, #1 @ counter--
|
| ++ ldr r3, [sp, #48] @ FIXME prevent clobber of r3 above?
|
| ++
|
| ++ add r9, r9, #0x40 @ round_shift_and_clamp[0]
|
| ++ add r10, r10, #0x40 @ round_shift_and_clamp[1]
|
| ++ add r11, r11, #0x40 @ round_shift_and_clamp[2]
|
| ++ add r1, r1, #0x40 @ round_shift_and_clamp[3]
|
| ++
|
| ++ usat r9, #8, r9, asr #7
|
| ++ usat r10, #8, r10, asr #7
|
| ++ usat r11, #8, r11, asr #7
|
| ++ usat r1, #8, r1, asr #7
|
| ++
|
| ++ strb r9, [r0], #1 @ store result
|
| ++ strb r10,[r0], #1
|
| ++ strb r11,[r0], #1
|
| ++ strb r1, [r0], #1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ ldr r12,[sp, #44] @ height = outer-loop counter
|
| ++ subs r12, r12, #1
|
| ++T ittt ne
|
| ++ ldrne r4, [sp, #40] @ 4-in-parallel loop counter
|
| ++ ldrne r9, [sp, #0]
|
| ++ strne r12,[sp, #44]
|
| ++ sub r2, r2, r4, lsl #2
|
| ++ add r0, r0, r9
|
| ++ add r2, r2, r3 @ move to next input/output lines
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ add sp, sp, #4 @ restore stack after push{r1} above
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_bilin_h(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int w, int h, int mx)
|
| ++function ff_put_vp8_bilin_h_armv6, export=1
|
| ++ push {r4 - r9, lr}
|
| ++
|
| ++ ldr r8, [sp, #36] @ vp8_filter index
|
| ++ ldr r12,[sp, #32] @ height = outer-loop counter
|
| ++ ldr r4, [sp, #28] @ width
|
| ++ lsl r5, r8, #16 @ mx << 16
|
| ++ sub r3, r3, r4 @ src_stride - block_width
|
| ++ sub r1, r1, r4 @ dst_stride - block_width
|
| ++ asr r4, #2
|
| ++ sub r5, r5, r8 @ (mx << 16) | (-mx)
|
| ++ str r4, [sp, #28] @ "4-in-parallel" loop counter
|
| ++ add r5, r5, #8 @ (8 - mx) | (mx << 16) = filter coefficients
|
| ++1:
|
| ++ ldrb r6, [r2], #1 @ load source data
|
| ++ ldrb r7, [r2], #1
|
| ++ ldrb r8, [r2], #1
|
| ++ ldrb r9, [r2], #1
|
| ++ ldrb lr, [r2]
|
| ++
|
| ++ pkhbt r6, r6, r7, lsl #16 @ src[1] | src[0]
|
| ++ pkhbt r7, r7, r8, lsl #16 @ src[2] | src[1]
|
| ++ pkhbt r8, r8, r9, lsl #16 @ src[3] | src[2]
|
| ++ pkhbt r9, r9, lr, lsl #16 @ src[4] | src[3]
|
| ++
|
| ++ smuad r6, r6, r5 @ apply the filter
|
| ++ smuad r7, r7, r5
|
| ++ smuad r8, r8, r5
|
| ++ smuad r9, r9, r5
|
| ++
|
| ++ subs r4, r4, #1 @ counter--
|
| ++
|
| ++ add r6, r6, #0x4 @ round_shift_and_clamp
|
| ++ add r7, r7, #0x4
|
| ++ add r8, r8, #0x4
|
| ++ add r9, r9, #0x4
|
| ++
|
| ++ asr r6, #3
|
| ++ asr r7, #3
|
| ++ pkhbt r6, r6, r8, lsl #13
|
| ++ pkhbt r7, r7, r9, lsl #13
|
| ++ orr r6, r6, r7, lsl #8
|
| ++ str r6, [r0], #4 @ store result
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ ldr r4, [sp, #28] @ 4-in-parallel loop counter
|
| ++ subs r12, r12, #1
|
| ++
|
| ++ add r2, r2, r3 @ move to next input/output lines
|
| ++ add r0, r0, r1
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ pop {r4 - r9, pc}
|
| ++endfunc
|
| ++
|
| ++@ void put_vp8_bilin_v(uint8_t *dst, int dststride, uint8_t *src,
|
| ++@ int srcstride, int w, int h, int my)
|
| ++function ff_put_vp8_bilin_v_armv6, export=1
|
| ++ push {r4 - r11, lr}
|
| ++
|
| ++ ldr r11,[sp, #44] @ vp8_filter index
|
| ++ ldr r4, [sp, #36] @ width
|
| ++ mov r5, r11, lsl #16 @ mx << 16
|
| ++ ldr r12,[sp, #40] @ height = outer-loop counter
|
| ++ sub r1, r1, r4
|
| ++ sub r5, r5, r11 @ (mx << 16) | (-mx)
|
| ++ asr r4, #2
|
| ++ add r5, r5, #8 @ (8 - mx) | (mx << 16) = filter coefficients
|
| ++ str r4, [sp, #36] @ "4-in-parallel" loop counter
|
| ++1:
|
| ++ ldrb r10,[r2, r3] @ load the data
|
| ++ ldrb r6, [r2], #1
|
| ++ ldrb r11,[r2, r3]
|
| ++ ldrb r7, [r2], #1
|
| ++ ldrb lr, [r2, r3]
|
| ++ ldrb r8, [r2], #1
|
| ++ ldrb r9, [r2, r3]
|
| ++ pkhbt r6, r6, r10, lsl #16
|
| ++ ldrb r10,[r2], #1
|
| ++ pkhbt r7, r7, r11, lsl #16
|
| ++ pkhbt r8, r8, lr, lsl #16
|
| ++ pkhbt r9, r10, r9, lsl #16
|
| ++
|
| ++ smuad r6, r6, r5 @ apply the filter
|
| ++ smuad r7, r7, r5
|
| ++ smuad r8, r8, r5
|
| ++ smuad r9, r9, r5
|
| ++
|
| ++ subs r4, r4, #1 @ counter--
|
| ++
|
| ++ add r6, r6, #0x4 @ round_shift_and_clamp
|
| ++ add r7, r7, #0x4
|
| ++ add r8, r8, #0x4
|
| ++ add r9, r9, #0x4
|
| ++
|
| ++ asr r6, #3
|
| ++ asr r7, #3
|
| ++ pkhbt r6, r6, r8, lsl #13
|
| ++ pkhbt r7, r7, r9, lsl #13
|
| ++ orr r6, r6, r7, lsl #8
|
| ++ str r6, [r0], #4 @ store result
|
| ++
|
| ++ bne 1b
|
| ++
|
| ++ ldr r4, [sp, #36] @ 4-in-parallel loop counter
|
| ++ subs r12, r12, #1
|
| ++
|
| ++ add r2, r2, r3 @ move to next input/output lines
|
| ++ add r0, r0, r1
|
| ++ sub r2, r2, r4, lsl #2
|
| ++
|
| ++ bne 1b
|
| ++ pop {r4 - r11, pc}
|
| ++endfunc
|
| +diff --git a/libavcodec/arm/vp8dsp_init_arm.c b/libavcodec/arm/vp8dsp_init_arm.c
|
| +index 269c6e3..74d9581 100644
|
| +--- a/libavcodec/arm/vp8dsp_init_arm.c
|
| ++++ b/libavcodec/arm/vp8dsp_init_arm.c
|
| +@@ -19,13 +19,17 @@
|
| + #include <stdint.h>
|
| + #include "libavcodec/vp8dsp.h"
|
| +
|
| +-void ff_vp8_luma_dc_wht_neon(DCTELEM block[4][4][16], DCTELEM dc[16]);
|
| +-void ff_vp8_luma_dc_wht_dc_neon(DCTELEM block[4][4][16], DCTELEM dc[16]);
|
| ++void ff_vp8_luma_dc_wht_dc_armv6(DCTELEM block[4][4][16], DCTELEM dc[16]);
|
| +
|
| +-void ff_vp8_idct_add_neon(uint8_t *dst, DCTELEM block[16], int stride);
|
| +-void ff_vp8_idct_dc_add_neon(uint8_t *dst, DCTELEM block[16], int stride);
|
| +-void ff_vp8_idct_dc_add4y_neon(uint8_t *dst, DCTELEM block[4][16], int stride);
|
| +-void ff_vp8_idct_dc_add4uv_neon(uint8_t *dst, DCTELEM block[4][16], int stride);
|
| ++#define idct_funcs(opt) \
|
| ++void ff_vp8_luma_dc_wht_ ## opt(DCTELEM block[4][4][16], DCTELEM dc[16]); \
|
| ++void ff_vp8_idct_add_ ## opt(uint8_t *dst, DCTELEM block[16], int stride); \
|
| ++void ff_vp8_idct_dc_add_ ## opt(uint8_t *dst, DCTELEM block[16], int stride); \
|
| ++void ff_vp8_idct_dc_add4y_ ## opt(uint8_t *dst, DCTELEM block[4][16], int stride); \
|
| ++void ff_vp8_idct_dc_add4uv_ ## opt(uint8_t *dst, DCTELEM block[4][16], int stride)
|
| ++
|
| ++idct_funcs(neon);
|
| ++idct_funcs(armv6);
|
| +
|
| + void ff_vp8_v_loop_filter16_neon(uint8_t *dst, int stride,
|
| + int flim_E, int flim_I, int hev_thresh);
|
| +@@ -47,29 +51,106 @@ void ff_vp8_h_loop_filter8uv_inner_neon(uint8_t *dstU, uint8_t *dstV,
|
| + int stride, int flim_E, int flim_I,
|
| + int hev_thresh);
|
| +
|
| +-void ff_vp8_v_loop_filter16_simple_neon(uint8_t *dst, int stride, int flim);
|
| +-void ff_vp8_h_loop_filter16_simple_neon(uint8_t *dst, int stride, int flim);
|
| ++void ff_vp8_v_loop_filter_inner_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I,
|
| ++ int hev_thresh, int count);
|
| ++void ff_vp8_h_loop_filter_inner_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I,
|
| ++ int hev_thresh, int count);
|
| ++void ff_vp8_v_loop_filter_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I,
|
| ++ int hev_thresh, int count);
|
| ++void ff_vp8_h_loop_filter_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I,
|
| ++ int hev_thresh, int count);
|
| +
|
| ++static void ff_vp8_v_loop_filter16_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I, int hev_thresh)
|
| ++{
|
| ++ ff_vp8_v_loop_filter_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);
|
| ++}
|
| ++
|
| ++static void ff_vp8_h_loop_filter16_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I, int hev_thresh)
|
| ++{
|
| ++ ff_vp8_h_loop_filter_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);
|
| ++}
|
| +
|
| +-#define VP8_MC(n) \
|
| +- void ff_put_vp8_##n##_neon(uint8_t *dst, int dststride, \
|
| +- uint8_t *src, int srcstride, \
|
| +- int h, int x, int y)
|
| ++static void ff_vp8_v_loop_filter8uv_armv6(uint8_t *dstU, uint8_t *dstV, int stride,
|
| ++ int flim_E, int flim_I, int hev_thresh)
|
| ++{
|
| ++ ff_vp8_v_loop_filter_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++ ff_vp8_v_loop_filter_armv6(dstV, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++}
|
| ++
|
| ++static void ff_vp8_h_loop_filter8uv_armv6(uint8_t *dstU, uint8_t *dstV, int stride,
|
| ++ int flim_E, int flim_I, int hev_thresh)
|
| ++{
|
| ++ ff_vp8_h_loop_filter_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++ ff_vp8_h_loop_filter_armv6(dstV, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++}
|
| ++
|
| ++static void ff_vp8_v_loop_filter16_inner_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I, int hev_thresh)
|
| ++{
|
| ++ ff_vp8_v_loop_filter_inner_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);
|
| ++}
|
| ++
|
| ++static void ff_vp8_h_loop_filter16_inner_armv6(uint8_t *dst, int stride,
|
| ++ int flim_E, int flim_I, int hev_thresh)
|
| ++{
|
| ++ ff_vp8_h_loop_filter_inner_armv6(dst, stride, flim_E, flim_I, hev_thresh, 4);
|
| ++}
|
| ++
|
| ++static void ff_vp8_v_loop_filter8uv_inner_armv6(uint8_t *dstU, uint8_t *dstV,
|
| ++ int stride, int flim_E, int flim_I,
|
| ++ int hev_thresh)
|
| ++{
|
| ++ ff_vp8_v_loop_filter_inner_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++ ff_vp8_v_loop_filter_inner_armv6(dstV, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++}
|
| ++
|
| ++static void ff_vp8_h_loop_filter8uv_inner_armv6(uint8_t *dstU, uint8_t *dstV,
|
| ++ int stride, int flim_E, int flim_I,
|
| ++ int hev_thresh)
|
| ++{
|
| ++ ff_vp8_h_loop_filter_inner_armv6(dstU, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++ ff_vp8_h_loop_filter_inner_armv6(dstV, stride, flim_E, flim_I, hev_thresh, 2);
|
| ++}
|
| ++
|
| ++#define simple_lf_funcs(opt) \
|
| ++void ff_vp8_v_loop_filter16_simple_ ## opt(uint8_t *dst, int stride, int flim); \
|
| ++void ff_vp8_h_loop_filter16_simple_ ## opt(uint8_t *dst, int stride, int flim)
|
| ++
|
| ++simple_lf_funcs(neon);
|
| ++simple_lf_funcs(armv6);
|
| ++
|
| ++#define VP8_MC_OPT(n, opt) \
|
| ++ void ff_put_vp8_##n##_##opt(uint8_t *dst, int dststride, \
|
| ++ uint8_t *src, int srcstride, \
|
| ++ int h, int x, int y)
|
| ++
|
| ++#define VP8_MC(n) \
|
| ++ VP8_MC_OPT(n, neon)
|
| +
|
| + #define VP8_EPEL(w) \
|
| +- VP8_MC(pixels ## w); \
|
| + VP8_MC(epel ## w ## _h4); \
|
| + VP8_MC(epel ## w ## _h6); \
|
| +- VP8_MC(epel ## w ## _v4); \
|
| + VP8_MC(epel ## w ## _h4v4); \
|
| + VP8_MC(epel ## w ## _h6v4); \
|
| ++ VP8_MC(epel ## w ## _v4); \
|
| + VP8_MC(epel ## w ## _v6); \
|
| + VP8_MC(epel ## w ## _h4v6); \
|
| + VP8_MC(epel ## w ## _h6v6)
|
| +
|
| + VP8_EPEL(16);
|
| ++VP8_MC(pixels16);
|
| ++VP8_MC_OPT(pixels16, armv6);
|
| + VP8_EPEL(8);
|
| ++VP8_MC(pixels8);
|
| ++VP8_MC_OPT(pixels8, armv6);
|
| + VP8_EPEL(4);
|
| ++VP8_MC_OPT(pixels4, armv6);
|
| +
|
| + VP8_MC(bilin16_h);
|
| + VP8_MC(bilin16_v);
|
| +@@ -81,83 +162,148 @@ VP8_MC(bilin4_h);
|
| + VP8_MC(bilin4_v);
|
| + VP8_MC(bilin4_hv);
|
| +
|
| ++#define VP8_V6_MC(n) \
|
| ++void ff_put_vp8_##n##_armv6(uint8_t *dst, int dststride, uint8_t *src, \
|
| ++ int srcstride, int w, int h, int mxy)
|
| ++
|
| ++VP8_V6_MC(epel_v6);
|
| ++VP8_V6_MC(epel_h6);
|
| ++VP8_V6_MC(epel_v4);
|
| ++VP8_V6_MC(epel_h4);
|
| ++VP8_V6_MC(bilin_v);
|
| ++VP8_V6_MC(bilin_h);
|
| ++
|
| ++#define VP8_EPEL_HV(SIZE, TAPNUMX, TAPNUMY, NAME, HNAME, VNAME, MAXHEIGHT) \
|
| ++static void ff_put_vp8_##NAME##SIZE##_##HNAME##VNAME##_armv6( \
|
| ++ uint8_t *dst, int dststride, uint8_t *src, \
|
| ++ int srcstride, int h, int mx, int my) \
|
| ++{ \
|
| ++ DECLARE_ALIGNED(4, uint8_t, tmp)[SIZE * (MAXHEIGHT + TAPNUMY - 1)]; \
|
| ++ uint8_t *tmpptr = tmp + SIZE * (TAPNUMY / 2 - 1); \
|
| ++ src -= srcstride * (TAPNUMY / 2 - 1); \
|
| ++ ff_put_vp8_ ## NAME ## _ ## HNAME ## _armv6(tmp, SIZE, src, srcstride, \
|
| ++ SIZE, h + TAPNUMY - 1, mx); \
|
| ++ ff_put_vp8_ ## NAME ## _ ## VNAME ## _armv6(dst, dststride, tmpptr, SIZE, \
|
| ++ SIZE, h, my); \
|
| ++}
|
| ++
|
| ++VP8_EPEL_HV(16, 6, 6, epel, h6, v6, 16);
|
| ++VP8_EPEL_HV(16, 2, 2, bilin, h, v, 16);
|
| ++VP8_EPEL_HV(8, 6, 6, epel, h6, v6, 16);
|
| ++VP8_EPEL_HV(8, 4, 6, epel, h4, v6, 16);
|
| ++VP8_EPEL_HV(8, 6, 4, epel, h6, v4, 16);
|
| ++VP8_EPEL_HV(8, 4, 4, epel, h4, v4, 16);
|
| ++VP8_EPEL_HV(8, 2, 2, bilin, h, v, 16);
|
| ++VP8_EPEL_HV(4, 6, 6, epel, h6, v6, 8);
|
| ++VP8_EPEL_HV(4, 4, 6, epel, h4, v6, 8);
|
| ++VP8_EPEL_HV(4, 6, 4, epel, h6, v4, 8);
|
| ++VP8_EPEL_HV(4, 4, 4, epel, h4, v4, 8);
|
| ++VP8_EPEL_HV(4, 2, 2, bilin, h, v, 8);
|
| ++
|
| ++extern void put_vp8_epel4_v6_c(uint8_t *dst, int d, uint8_t *src, int s, int h, int mx, int my);
|
| ++#undef printf
|
| ++#define VP8_EPEL_H_OR_V(SIZE, NAME, HV) \
|
| ++static void ff_put_vp8_##NAME##SIZE##_##HV##_armv6( \
|
| ++ uint8_t *dst, int dststride, uint8_t *src, \
|
| ++ int srcstride, int h, int mx, int my) \
|
| ++{ \
|
| ++ ff_put_vp8_## NAME ## _ ## HV ## _armv6(dst, dststride, src, srcstride, \
|
| ++ SIZE, h, mx | my); \
|
| ++}
|
| ++
|
| ++VP8_EPEL_H_OR_V(4, epel, h6);
|
| ++VP8_EPEL_H_OR_V(4, epel, h4);
|
| ++VP8_EPEL_H_OR_V(4, epel, v6);
|
| ++VP8_EPEL_H_OR_V(4, epel, v4);
|
| ++VP8_EPEL_H_OR_V(4, bilin, v);
|
| ++VP8_EPEL_H_OR_V(4, bilin, h);
|
| ++VP8_EPEL_H_OR_V(8, epel, h6);
|
| ++VP8_EPEL_H_OR_V(8, epel, h4);
|
| ++VP8_EPEL_H_OR_V(8, epel, v6);
|
| ++VP8_EPEL_H_OR_V(8, epel, v4);
|
| ++VP8_EPEL_H_OR_V(8, bilin, v);
|
| ++VP8_EPEL_H_OR_V(8, bilin, h);
|
| ++VP8_EPEL_H_OR_V(16, epel, h6);
|
| ++VP8_EPEL_H_OR_V(16, epel, v6);
|
| ++VP8_EPEL_H_OR_V(16, bilin, v);
|
| ++VP8_EPEL_H_OR_V(16, bilin, h);
|
| ++
|
| + av_cold void ff_vp8dsp_init_arm(VP8DSPContext *dsp)
|
| + {
|
| ++#define set_func_ptrs(opt) \
|
| ++ dsp->vp8_luma_dc_wht = ff_vp8_luma_dc_wht_##opt; \
|
| ++ dsp->vp8_luma_dc_wht_dc = ff_vp8_luma_dc_wht_dc_armv6; \
|
| ++ \
|
| ++ dsp->vp8_idct_add = ff_vp8_idct_add_##opt; \
|
| ++ dsp->vp8_idct_dc_add = ff_vp8_idct_dc_add_##opt; \
|
| ++ dsp->vp8_idct_dc_add4y = ff_vp8_idct_dc_add4y_##opt; \
|
| ++ dsp->vp8_idct_dc_add4uv = ff_vp8_idct_dc_add4uv_##opt; \
|
| ++ \
|
| ++ dsp->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16_##opt; \
|
| ++ dsp->vp8_h_loop_filter16y = ff_vp8_h_loop_filter16_##opt; \
|
| ++ dsp->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_##opt; \
|
| ++ dsp->vp8_h_loop_filter8uv = ff_vp8_h_loop_filter8uv_##opt; \
|
| ++ \
|
| ++ dsp->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16_inner_##opt; \
|
| ++ dsp->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16_inner_##opt; \
|
| ++ dsp->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_##opt; \
|
| ++ dsp->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_##opt; \
|
| ++ \
|
| ++ dsp->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter16_simple_##opt; \
|
| ++ dsp->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter16_simple_##opt; \
|
| ++ \
|
| ++ dsp->put_vp8_epel_pixels_tab[0][0][0] = ff_put_vp8_pixels16_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[0][0][2] = ff_put_vp8_epel16_h6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[0][2][0] = ff_put_vp8_epel16_v6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[0][2][2] = ff_put_vp8_epel16_h6v6_##opt; \
|
| ++ \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][0][0] = ff_put_vp8_pixels8_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][0][1] = ff_put_vp8_epel8_h4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][0][2] = ff_put_vp8_epel8_h6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][1][0] = ff_put_vp8_epel8_v4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][1][1] = ff_put_vp8_epel8_h4v4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][1][2] = ff_put_vp8_epel8_h6v4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][2][0] = ff_put_vp8_epel8_v6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][2][1] = ff_put_vp8_epel8_h4v6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[1][2][2] = ff_put_vp8_epel8_h6v6_##opt; \
|
| ++ \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][0][0] = ff_put_vp8_pixels4_armv6; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][0][1] = ff_put_vp8_epel4_h4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][0][2] = ff_put_vp8_epel4_h6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][1][0] = ff_put_vp8_epel4_v4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][1][1] = ff_put_vp8_epel4_h4v4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][1][2] = ff_put_vp8_epel4_h6v4_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][2][0] = ff_put_vp8_epel4_v6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][2][1] = ff_put_vp8_epel4_h4v6_##opt; \
|
| ++ dsp->put_vp8_epel_pixels_tab[2][2][2] = ff_put_vp8_epel4_h6v6_##opt; \
|
| ++ \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[0][0][0] = ff_put_vp8_pixels16_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[0][0][2] = ff_put_vp8_bilin16_h_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[0][2][0] = ff_put_vp8_bilin16_v_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[0][2][2] = ff_put_vp8_bilin16_hv_##opt; \
|
| ++ \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][0][0] = ff_put_vp8_pixels8_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][0][1] = ff_put_vp8_bilin8_h_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][0][2] = ff_put_vp8_bilin8_h_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][1][0] = ff_put_vp8_bilin8_v_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][1][1] = ff_put_vp8_bilin8_hv_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][1][2] = ff_put_vp8_bilin8_hv_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][2][0] = ff_put_vp8_bilin8_v_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][2][1] = ff_put_vp8_bilin8_hv_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[1][2][2] = ff_put_vp8_bilin8_hv_##opt; \
|
| ++ \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][0][0] = ff_put_vp8_pixels4_armv6; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][0][1] = ff_put_vp8_bilin4_h_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][0][2] = ff_put_vp8_bilin4_h_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][1][0] = ff_put_vp8_bilin4_v_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][1][1] = ff_put_vp8_bilin4_hv_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][1][2] = ff_put_vp8_bilin4_hv_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][2][0] = ff_put_vp8_bilin4_v_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][2][1] = ff_put_vp8_bilin4_hv_##opt; \
|
| ++ dsp->put_vp8_bilinear_pixels_tab[2][2][2] = ff_put_vp8_bilin4_hv_##opt
|
| + if (HAVE_NEON) {
|
| +- dsp->vp8_luma_dc_wht = ff_vp8_luma_dc_wht_neon;
|
| +- dsp->vp8_luma_dc_wht_dc = ff_vp8_luma_dc_wht_dc_neon;
|
| +-
|
| +- dsp->vp8_idct_add = ff_vp8_idct_add_neon;
|
| +- dsp->vp8_idct_dc_add = ff_vp8_idct_dc_add_neon;
|
| +- dsp->vp8_idct_dc_add4y = ff_vp8_idct_dc_add4y_neon;
|
| +- dsp->vp8_idct_dc_add4uv = ff_vp8_idct_dc_add4uv_neon;
|
| +-
|
| +- dsp->vp8_v_loop_filter16y = ff_vp8_v_loop_filter16_neon;
|
| +- dsp->vp8_h_loop_filter16y = ff_vp8_h_loop_filter16_neon;
|
| +- dsp->vp8_v_loop_filter8uv = ff_vp8_v_loop_filter8uv_neon;
|
| +- dsp->vp8_h_loop_filter8uv = ff_vp8_h_loop_filter8uv_neon;
|
| +-
|
| +- dsp->vp8_v_loop_filter16y_inner = ff_vp8_v_loop_filter16_inner_neon;
|
| +- dsp->vp8_h_loop_filter16y_inner = ff_vp8_h_loop_filter16_inner_neon;
|
| +- dsp->vp8_v_loop_filter8uv_inner = ff_vp8_v_loop_filter8uv_inner_neon;
|
| +- dsp->vp8_h_loop_filter8uv_inner = ff_vp8_h_loop_filter8uv_inner_neon;
|
| +-
|
| +- dsp->vp8_v_loop_filter_simple = ff_vp8_v_loop_filter16_simple_neon;
|
| +- dsp->vp8_h_loop_filter_simple = ff_vp8_h_loop_filter16_simple_neon;
|
| +-
|
| +- dsp->put_vp8_epel_pixels_tab[0][0][0] = ff_put_vp8_pixels16_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[0][0][2] = ff_put_vp8_epel16_h6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[0][2][0] = ff_put_vp8_epel16_v6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[0][2][2] = ff_put_vp8_epel16_h6v6_neon;
|
| +-
|
| +- dsp->put_vp8_epel_pixels_tab[1][0][0] = ff_put_vp8_pixels8_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][0][1] = ff_put_vp8_epel8_h4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][0][2] = ff_put_vp8_epel8_h6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][1][0] = ff_put_vp8_epel8_v4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][1][1] = ff_put_vp8_epel8_h4v4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][1][2] = ff_put_vp8_epel8_h6v4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][2][0] = ff_put_vp8_epel8_v6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][2][1] = ff_put_vp8_epel8_h4v6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[1][2][2] = ff_put_vp8_epel8_h6v6_neon;
|
| +-
|
| +- dsp->put_vp8_epel_pixels_tab[2][0][0] = ff_put_vp8_pixels4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][0][1] = ff_put_vp8_epel4_h4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][0][2] = ff_put_vp8_epel4_h6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][1][0] = ff_put_vp8_epel4_v4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][1][1] = ff_put_vp8_epel4_h4v4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][1][2] = ff_put_vp8_epel4_h6v4_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][2][0] = ff_put_vp8_epel4_v6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][2][1] = ff_put_vp8_epel4_h4v6_neon;
|
| +- dsp->put_vp8_epel_pixels_tab[2][2][2] = ff_put_vp8_epel4_h6v6_neon;
|
| +-
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][0][0] = ff_put_vp8_pixels16_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][0][1] = ff_put_vp8_bilin16_h_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][0][2] = ff_put_vp8_bilin16_h_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][1][0] = ff_put_vp8_bilin16_v_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][1][1] = ff_put_vp8_bilin16_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][1][2] = ff_put_vp8_bilin16_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][2][0] = ff_put_vp8_bilin16_v_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][2][1] = ff_put_vp8_bilin16_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[0][2][2] = ff_put_vp8_bilin16_hv_neon;
|
| +-
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][0][0] = ff_put_vp8_pixels8_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][0][1] = ff_put_vp8_bilin8_h_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][0][2] = ff_put_vp8_bilin8_h_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][1][0] = ff_put_vp8_bilin8_v_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][1][1] = ff_put_vp8_bilin8_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][1][2] = ff_put_vp8_bilin8_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][2][0] = ff_put_vp8_bilin8_v_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][2][1] = ff_put_vp8_bilin8_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[1][2][2] = ff_put_vp8_bilin8_hv_neon;
|
| +-
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][0][0] = ff_put_vp8_pixels4_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][0][1] = ff_put_vp8_bilin4_h_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][0][2] = ff_put_vp8_bilin4_h_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][1][0] = ff_put_vp8_bilin4_v_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][1][1] = ff_put_vp8_bilin4_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][1][2] = ff_put_vp8_bilin4_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][2][0] = ff_put_vp8_bilin4_v_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][2][1] = ff_put_vp8_bilin4_hv_neon;
|
| +- dsp->put_vp8_bilinear_pixels_tab[2][2][2] = ff_put_vp8_bilin4_hv_neon;
|
| ++ set_func_ptrs(neon);
|
| ++ } else if (HAVE_ARMV6) {
|
| ++ set_func_ptrs(armv6);
|
| + }
|
| + }
|
| +diff --git a/libavcodec/arm/vp8dsp_neon.S b/libavcodec/arm/vp8dsp_neon.S
|
| +index 1b9f24e..8e79982 100644
|
| +--- a/libavcodec/arm/vp8dsp_neon.S
|
| ++++ b/libavcodec/arm/vp8dsp_neon.S
|
| +@@ -76,18 +76,6 @@ function ff_vp8_luma_dc_wht_neon, export=1
|
| + bx lr
|
| + endfunc
|
| +
|
| +-function ff_vp8_luma_dc_wht_dc_neon, export=1
|
| +- ldrsh r2, [r1]
|
| +- mov r3, #0
|
| +- add r2, r2, #3
|
| +- strh r3, [r1]
|
| +- asr r2, r2, #3
|
| +- .rept 16
|
| +- strh r2, [r0], #32
|
| +- .endr
|
| +- bx lr
|
| +-endfunc
|
| +-
|
| + function ff_vp8_idct_add_neon, export=1
|
| + vld1.16 {q0-q1}, [r1,:128]
|
| + movw r3, #20091
|
| +@@ -741,23 +729,6 @@ function ff_put_vp8_pixels8_neon, export=1
|
| + bx lr
|
| + endfunc
|
| +
|
| +-function ff_put_vp8_pixels4_neon, export=1
|
| +- ldr r12, [sp, #0] @ h
|
| +- push {r4-r6,lr}
|
| +-1:
|
| +- subs r12, r12, #4
|
| +- ldr_post r4, r2, r3
|
| +- ldr_post r5, r2, r3
|
| +- ldr_post r6, r2, r3
|
| +- ldr_post lr, r2, r3
|
| +- str_post r4, r0, r1
|
| +- str_post r5, r0, r1
|
| +- str_post r6, r0, r1
|
| +- str_post lr, r0, r1
|
| +- bgt 1b
|
| +- pop {r4-r6,pc}
|
| +-endfunc
|
| +-
|
| + /* 4/6-tap 8th-pel MC */
|
| +
|
| + .macro vp8_epel8_h6 d, a, b
|
| +--
|
| +1.7.5.4
|
| +
|
|
|
Chromium Code Reviews
Issue 9290059:
Initial commit of all previous Chrome build scripts. (Closed)
Base URL: http://git.chromium.org/chromium/third_party/ffmpeg.git@master