source/libvpx/vp8/encoder/arm/neon/fastquantizeb_neon.asm - Issue 756673003: libvpx: Pull from upstream

Unified Diff: source/libvpx/vp8/encoder/arm/neon/fastquantizeb_neon.asm

Issue 756673003: libvpx: Pull from upstream (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/deps/third_party/libvpx/

Patch Set: Created 6 years, 1 month ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: source/libvpx/vp8/encoder/arm/neon/fastquantizeb_neon.asm

===================================================================

--- source/libvpx/vp8/encoder/arm/neon/fastquantizeb_neon.asm (revision 293081)

+++ source/libvpx/vp8/encoder/arm/neon/fastquantizeb_neon.asm (working copy)

@@ -1,258 +0,0 @@

-; 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.

- EXPORT |vp8_fast_quantize_b_neon|

- EXPORT |vp8_fast_quantize_b_pair_neon|

- INCLUDE vp8_asm_enc_offsets.asm

- ARM

- REQUIRE8

- PRESERVE8

- AREA ||.text||, CODE, READONLY, ALIGN=4

-;vp8_fast_quantize_b_pair_neon(BLOCK *b1, BLOCK *b2, BLOCKD *d1, BLOCKD *d2);

-|vp8_fast_quantize_b_pair_neon| PROC

- stmfd sp!, {r4-r9}

- vstmdb sp!, {q4-q7}

- ldr r4, [r0, #vp8_block_coeff]

- ldr r5, [r0, #vp8_block_quant_fast]

- ldr r6, [r0, #vp8_block_round]

- vld1.16 {q0, q1}, [r4@128] ; load z

- ldr r7, [r2, #vp8_blockd_qcoeff]

- vabs.s16 q4, q0 ; calculate x = abs(z)

- vabs.s16 q5, q1

- ;right shift 15 to get sign, all 0 if it is positive, all 1 if it is negative

- vshr.s16 q2, q0, #15 ; sz

- vshr.s16 q3, q1, #15

- vld1.s16 {q6, q7}, [r6@128] ; load round_ptr [0-15]

- vld1.s16 {q8, q9}, [r5@128] ; load quant_ptr [0-15]

- ldr r4, [r1, #vp8_block_coeff]

- vadd.s16 q4, q6 ; x + Round

- vadd.s16 q5, q7

- vld1.16 {q0, q1}, [r4@128] ; load z2

- vqdmulh.s16 q4, q8 ; y = ((Round+abs(z)) * Quant) >> 16

- vqdmulh.s16 q5, q9

- vabs.s16 q10, q0 ; calculate x2 = abs(z_2)

- vabs.s16 q11, q1

- vshr.s16 q12, q0, #15 ; sz2

- vshr.s16 q13, q1, #15

- ;modify data to have its original sign

- veor.s16 q4, q2 ; y^sz

- veor.s16 q5, q3

- vadd.s16 q10, q6 ; x2 + Round

- vadd.s16 q11, q7

- ldr r8, [r2, #vp8_blockd_dequant]

- vqdmulh.s16 q10, q8 ; y2 = ((Round+abs(z)) * Quant) >> 16

- vqdmulh.s16 q11, q9

- vshr.s16 q4, #1 ; right shift 1 after vqdmulh

- vshr.s16 q5, #1

- vld1.s16 {q6, q7}, [r8@128] ;load dequant_ptr[i]

- vsub.s16 q4, q2 ; x1=(y^sz)-sz = (y^sz)-(-1) (2's complement)

- vsub.s16 q5, q3

- vshr.s16 q10, #1 ; right shift 1 after vqdmulh

- vshr.s16 q11, #1

- ldr r9, [r2, #vp8_blockd_dqcoeff]

- veor.s16 q10, q12 ; y2^sz2

- veor.s16 q11, q13

- vst1.s16 {q4, q5}, [r7] ; store: qcoeff = x1

- vsub.s16 q10, q12 ; x2=(y^sz)-sz = (y^sz)-(-1) (2's complement)

- vsub.s16 q11, q13

- ldr r6, [r3, #vp8_blockd_qcoeff]

- vmul.s16 q2, q6, q4 ; x * Dequant

- vmul.s16 q3, q7, q5

- adr r0, inv_zig_zag ; load ptr of inverse zigzag table

- vceq.s16 q8, q8 ; set q8 to all 1

- vst1.s16 {q10, q11}, [r6] ; store: qcoeff = x2

- vmul.s16 q12, q6, q10 ; x2 * Dequant

- vmul.s16 q13, q7, q11

- vld1.16 {q6, q7}, [r0@128] ; load inverse scan order

- vtst.16 q14, q4, q8 ; now find eob

- vtst.16 q15, q5, q8 ; non-zero element is set to all 1

- vst1.s16 {q2, q3}, [r9] ; store dqcoeff = x * Dequant

- ldr r7, [r3, #vp8_blockd_dqcoeff]

- vand q0, q6, q14 ; get all valid numbers from scan array

- vand q1, q7, q15

- vst1.s16 {q12, q13}, [r7] ; store dqcoeff = x * Dequant

- vtst.16 q2, q10, q8 ; now find eob

- vtst.16 q3, q11, q8 ; non-zero element is set to all 1

- vmax.u16 q0, q0, q1 ; find maximum value in q0, q1

- vand q10, q6, q2 ; get all valid numbers from scan array

- vand q11, q7, q3

- vmax.u16 q10, q10, q11 ; find maximum value in q10, q11

- vmax.u16 d0, d0, d1

- vmax.u16 d20, d20, d21

- vmovl.u16 q0, d0

- vmovl.u16 q10, d20

- vmax.u32 d0, d0, d1

- vmax.u32 d20, d20, d21

- vpmax.u32 d0, d0, d0

- vpmax.u32 d20, d20, d20

- ldr r4, [r2, #vp8_blockd_eob]

- ldr r5, [r3, #vp8_blockd_eob]

- vst1.8 {d0[0]}, [r4] ; store eob

- vst1.8 {d20[0]}, [r5] ; store eob

- vldmia sp!, {q4-q7}

- ldmfd sp!, {r4-r9}

- bx lr

- ENDP

-;void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d)

-|vp8_fast_quantize_b_neon| PROC

- stmfd sp!, {r4-r7}

- ldr r3, [r0, #vp8_block_coeff]

- ldr r4, [r0, #vp8_block_quant_fast]

- ldr r5, [r0, #vp8_block_round]

- vld1.16 {q0, q1}, [r3@128] ; load z

- vorr.s16 q14, q0, q1 ; check if all zero (step 1)

- ldr r6, [r1, #vp8_blockd_qcoeff]

- ldr r7, [r1, #vp8_blockd_dqcoeff]

- vorr.s16 d28, d28, d29 ; check if all zero (step 2)

- vabs.s16 q12, q0 ; calculate x = abs(z)

- vabs.s16 q13, q1

- ;right shift 15 to get sign, all 0 if it is positive, all 1 if it is negative

- vshr.s16 q2, q0, #15 ; sz

- vmov r2, r3, d28 ; check if all zero (step 3)

- vshr.s16 q3, q1, #15

- vld1.s16 {q14, q15}, [r5@128]; load round_ptr [0-15]

- vld1.s16 {q8, q9}, [r4@128] ; load quant_ptr [0-15]

- vadd.s16 q12, q14 ; x + Round

- vadd.s16 q13, q15

- adr r0, inv_zig_zag ; load ptr of inverse zigzag table

- vqdmulh.s16 q12, q8 ; y = ((Round+abs(z)) * Quant) >> 16

- vqdmulh.s16 q13, q9

- vld1.16 {q10, q11}, [r0@128]; load inverse scan order

- vceq.s16 q8, q8 ; set q8 to all 1

- ldr r4, [r1, #vp8_blockd_dequant]

- vshr.s16 q12, #1 ; right shift 1 after vqdmulh

- vshr.s16 q13, #1

- ldr r5, [r1, #vp8_blockd_eob]

- orr r2, r2, r3 ; check if all zero (step 4)

- cmp r2, #0 ; check if all zero (step 5)

- beq zero_output ; check if all zero (step 6)

- ;modify data to have its original sign

- veor.s16 q12, q2 ; y^sz

- veor.s16 q13, q3

- vsub.s16 q12, q2 ; x1=(y^sz)-sz = (y^sz)-(-1) (2's complement)

- vsub.s16 q13, q3

- vld1.s16 {q2, q3}, [r4@128] ; load dequant_ptr[i]

- vtst.16 q14, q12, q8 ; now find eob

- vtst.16 q15, q13, q8 ; non-zero element is set to all 1

- vst1.s16 {q12, q13}, [r6@128]; store: qcoeff = x1

- vand q10, q10, q14 ; get all valid numbers from scan array

- vand q11, q11, q15

- vmax.u16 q0, q10, q11 ; find maximum value in q0, q1

- vmax.u16 d0, d0, d1

- vmovl.u16 q0, d0

- vmul.s16 q2, q12 ; x * Dequant

- vmul.s16 q3, q13

- vmax.u32 d0, d0, d1

- vpmax.u32 d0, d0, d0

- vst1.s16 {q2, q3}, [r7@128] ; store dqcoeff = x * Dequant

- vst1.8 {d0[0]}, [r5] ; store eob

- ldmfd sp!, {r4-r7}

- bx lr

-zero_output

- strb r2, [r5] ; store eob

- vst1.s16 {q0, q1}, [r6@128] ; qcoeff = 0

- vst1.s16 {q0, q1}, [r7@128] ; dqcoeff = 0

- ldmfd sp!, {r4-r7}

- bx lr

- ENDP

-; default inverse zigzag table is defined in vp8/common/entropy.c

- ALIGN 16 ; enable use of @128 bit aligned loads

-inv_zig_zag

- DCW 0x0001, 0x0002, 0x0006, 0x0007

- DCW 0x0003, 0x0005, 0x0008, 0x000d

- DCW 0x0004, 0x0009, 0x000c, 0x000e

- DCW 0x000a, 0x000b, 0x000f, 0x0010

- END

« no previous file with comments | « source/libvpx/vp8/encoder/arm/boolhuff_arm.c ('k') | source/libvpx/vp8/encoder/arm/neon/fastquantizeb_neon.c » ('j') | no next file with comments »