1300 lines
53 KiB
NASM
1300 lines
53 KiB
NASM
;
|
|
; Copyright (c) 2013 The WebM project authors. All Rights Reserved.
|
|
;
|
|
; 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.
|
|
;
|
|
|
|
;TODO(cd): adjust these constant to be able to use vqdmulh for faster
|
|
; dct_const_round_shift(a * b) within butterfly calculations.
|
|
cospi_1_64 EQU 16364
|
|
cospi_2_64 EQU 16305
|
|
cospi_3_64 EQU 16207
|
|
cospi_4_64 EQU 16069
|
|
cospi_5_64 EQU 15893
|
|
cospi_6_64 EQU 15679
|
|
cospi_7_64 EQU 15426
|
|
cospi_8_64 EQU 15137
|
|
cospi_9_64 EQU 14811
|
|
cospi_10_64 EQU 14449
|
|
cospi_11_64 EQU 14053
|
|
cospi_12_64 EQU 13623
|
|
cospi_13_64 EQU 13160
|
|
cospi_14_64 EQU 12665
|
|
cospi_15_64 EQU 12140
|
|
cospi_16_64 EQU 11585
|
|
cospi_17_64 EQU 11003
|
|
cospi_18_64 EQU 10394
|
|
cospi_19_64 EQU 9760
|
|
cospi_20_64 EQU 9102
|
|
cospi_21_64 EQU 8423
|
|
cospi_22_64 EQU 7723
|
|
cospi_23_64 EQU 7005
|
|
cospi_24_64 EQU 6270
|
|
cospi_25_64 EQU 5520
|
|
cospi_26_64 EQU 4756
|
|
cospi_27_64 EQU 3981
|
|
cospi_28_64 EQU 3196
|
|
cospi_29_64 EQU 2404
|
|
cospi_30_64 EQU 1606
|
|
cospi_31_64 EQU 804
|
|
|
|
|
|
EXPORT |vp9_idct32x32_1024_add_neon|
|
|
ARM
|
|
REQUIRE8
|
|
PRESERVE8
|
|
|
|
AREA ||.text||, CODE, READONLY, ALIGN=2
|
|
|
|
AREA Block, CODE, READONLY
|
|
|
|
; --------------------------------------------------------------------------
|
|
; Load from transposed_buffer
|
|
; q13 = transposed_buffer[first_offset]
|
|
; q14 = transposed_buffer[second_offset]
|
|
; for proper address calculation, the last offset used when manipulating
|
|
; transposed_buffer must be passed in. use 0 for first use.
|
|
MACRO
|
|
LOAD_FROM_TRANSPOSED $prev_offset, $first_offset, $second_offset
|
|
; address calculation with proper stride and loading
|
|
add r0, #($first_offset - $prev_offset )*8*2
|
|
vld1.s16 {q14}, [r0]
|
|
add r0, #($second_offset - $first_offset)*8*2
|
|
vld1.s16 {q13}, [r0]
|
|
; (used) two registers (q14, q13)
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Load from output (used as temporary storage)
|
|
; reg1 = output[first_offset]
|
|
; reg2 = output[second_offset]
|
|
; for proper address calculation, the last offset used when manipulating
|
|
; output, whether reading or storing) must be passed in. use 0 for first
|
|
; use.
|
|
MACRO
|
|
LOAD_FROM_OUTPUT $prev_offset, $first_offset, $second_offset, $reg1, $reg2
|
|
; address calculation with proper stride and loading
|
|
add r1, #($first_offset - $prev_offset )*32*2
|
|
vld1.s16 {$reg1}, [r1]
|
|
add r1, #($second_offset - $first_offset)*32*2
|
|
vld1.s16 {$reg2}, [r1]
|
|
; (used) two registers ($reg1, $reg2)
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Store into output (sometimes as as temporary storage)
|
|
; output[first_offset] = reg1
|
|
; output[second_offset] = reg2
|
|
; for proper address calculation, the last offset used when manipulating
|
|
; output, whether reading or storing) must be passed in. use 0 for first
|
|
; use.
|
|
MACRO
|
|
STORE_IN_OUTPUT $prev_offset, $first_offset, $second_offset, $reg1, $reg2
|
|
; address calculation with proper stride and storing
|
|
add r1, #($first_offset - $prev_offset )*32*2
|
|
vst1.16 {$reg1}, [r1]
|
|
add r1, #($second_offset - $first_offset)*32*2
|
|
vst1.16 {$reg2}, [r1]
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Combine-add results with current destination content
|
|
; q6-q9 contain the results (out[j * 32 + 0-31])
|
|
MACRO
|
|
STORE_COMBINE_CENTER_RESULTS
|
|
; load dest[j * dest_stride + 0-31]
|
|
vld1.s16 {d8}, [r10], r2
|
|
vld1.s16 {d11}, [r9], r11
|
|
vld1.s16 {d9}, [r10]
|
|
vld1.s16 {d10}, [r9]
|
|
; ROUND_POWER_OF_TWO
|
|
vrshr.s16 q7, q7, #6
|
|
vrshr.s16 q8, q8, #6
|
|
vrshr.s16 q9, q9, #6
|
|
vrshr.s16 q6, q6, #6
|
|
; add to dest[j * dest_stride + 0-31]
|
|
vaddw.u8 q7, q7, d9
|
|
vaddw.u8 q8, q8, d10
|
|
vaddw.u8 q9, q9, d11
|
|
vaddw.u8 q6, q6, d8
|
|
; clip pixel
|
|
vqmovun.s16 d9, q7
|
|
vqmovun.s16 d10, q8
|
|
vqmovun.s16 d11, q9
|
|
vqmovun.s16 d8, q6
|
|
; store back into dest[j * dest_stride + 0-31]
|
|
vst1.16 {d9}, [r10], r11
|
|
vst1.16 {d10}, [r9], r2
|
|
vst1.16 {d8}, [r10]
|
|
vst1.16 {d11}, [r9]
|
|
; update pointers (by dest_stride * 2)
|
|
sub r9, r9, r2, lsl #1
|
|
add r10, r10, r2, lsl #1
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Combine-add results with current destination content
|
|
; q6-q9 contain the results (out[j * 32 + 0-31])
|
|
MACRO
|
|
STORE_COMBINE_CENTER_RESULTS_LAST
|
|
; load dest[j * dest_stride + 0-31]
|
|
vld1.s16 {d8}, [r10], r2
|
|
vld1.s16 {d11}, [r9], r11
|
|
vld1.s16 {d9}, [r10]
|
|
vld1.s16 {d10}, [r9]
|
|
; ROUND_POWER_OF_TWO
|
|
vrshr.s16 q7, q7, #6
|
|
vrshr.s16 q8, q8, #6
|
|
vrshr.s16 q9, q9, #6
|
|
vrshr.s16 q6, q6, #6
|
|
; add to dest[j * dest_stride + 0-31]
|
|
vaddw.u8 q7, q7, d9
|
|
vaddw.u8 q8, q8, d10
|
|
vaddw.u8 q9, q9, d11
|
|
vaddw.u8 q6, q6, d8
|
|
; clip pixel
|
|
vqmovun.s16 d9, q7
|
|
vqmovun.s16 d10, q8
|
|
vqmovun.s16 d11, q9
|
|
vqmovun.s16 d8, q6
|
|
; store back into dest[j * dest_stride + 0-31]
|
|
vst1.16 {d9}, [r10], r11
|
|
vst1.16 {d10}, [r9], r2
|
|
vst1.16 {d8}, [r10]!
|
|
vst1.16 {d11}, [r9]!
|
|
; update pointers (by dest_stride * 2)
|
|
sub r9, r9, r2, lsl #1
|
|
add r10, r10, r2, lsl #1
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Combine-add results with current destination content
|
|
; q4-q7 contain the results (out[j * 32 + 0-31])
|
|
MACRO
|
|
STORE_COMBINE_EXTREME_RESULTS
|
|
; load dest[j * dest_stride + 0-31]
|
|
vld1.s16 {d4}, [r7], r2
|
|
vld1.s16 {d7}, [r6], r11
|
|
vld1.s16 {d5}, [r7]
|
|
vld1.s16 {d6}, [r6]
|
|
; ROUND_POWER_OF_TWO
|
|
vrshr.s16 q5, q5, #6
|
|
vrshr.s16 q6, q6, #6
|
|
vrshr.s16 q7, q7, #6
|
|
vrshr.s16 q4, q4, #6
|
|
; add to dest[j * dest_stride + 0-31]
|
|
vaddw.u8 q5, q5, d5
|
|
vaddw.u8 q6, q6, d6
|
|
vaddw.u8 q7, q7, d7
|
|
vaddw.u8 q4, q4, d4
|
|
; clip pixel
|
|
vqmovun.s16 d5, q5
|
|
vqmovun.s16 d6, q6
|
|
vqmovun.s16 d7, q7
|
|
vqmovun.s16 d4, q4
|
|
; store back into dest[j * dest_stride + 0-31]
|
|
vst1.16 {d5}, [r7], r11
|
|
vst1.16 {d6}, [r6], r2
|
|
vst1.16 {d7}, [r6]
|
|
vst1.16 {d4}, [r7]
|
|
; update pointers (by dest_stride * 2)
|
|
sub r6, r6, r2, lsl #1
|
|
add r7, r7, r2, lsl #1
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Combine-add results with current destination content
|
|
; q4-q7 contain the results (out[j * 32 + 0-31])
|
|
MACRO
|
|
STORE_COMBINE_EXTREME_RESULTS_LAST
|
|
; load dest[j * dest_stride + 0-31]
|
|
vld1.s16 {d4}, [r7], r2
|
|
vld1.s16 {d7}, [r6], r11
|
|
vld1.s16 {d5}, [r7]
|
|
vld1.s16 {d6}, [r6]
|
|
; ROUND_POWER_OF_TWO
|
|
vrshr.s16 q5, q5, #6
|
|
vrshr.s16 q6, q6, #6
|
|
vrshr.s16 q7, q7, #6
|
|
vrshr.s16 q4, q4, #6
|
|
; add to dest[j * dest_stride + 0-31]
|
|
vaddw.u8 q5, q5, d5
|
|
vaddw.u8 q6, q6, d6
|
|
vaddw.u8 q7, q7, d7
|
|
vaddw.u8 q4, q4, d4
|
|
; clip pixel
|
|
vqmovun.s16 d5, q5
|
|
vqmovun.s16 d6, q6
|
|
vqmovun.s16 d7, q7
|
|
vqmovun.s16 d4, q4
|
|
; store back into dest[j * dest_stride + 0-31]
|
|
vst1.16 {d5}, [r7], r11
|
|
vst1.16 {d6}, [r6], r2
|
|
vst1.16 {d7}, [r6]!
|
|
vst1.16 {d4}, [r7]!
|
|
; update pointers (by dest_stride * 2)
|
|
sub r6, r6, r2, lsl #1
|
|
add r7, r7, r2, lsl #1
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Touches q8-q12, q15 (q13-q14 are preserved)
|
|
; valid output registers are anything but q8-q11
|
|
MACRO
|
|
DO_BUTTERFLY $regC, $regD, $regA, $regB, $first_constant, $second_constant, $reg1, $reg2, $reg3, $reg4
|
|
; TODO(cd): have special case to re-use constants when they are similar for
|
|
; consecutive butterflies
|
|
; TODO(cd): have special case when both constants are the same, do the
|
|
; additions/subtractions before the multiplies.
|
|
; generate the constants
|
|
; generate scalar constants
|
|
mov r8, #$first_constant & 0xFF00
|
|
mov r12, #$second_constant & 0xFF00
|
|
add r8, #$first_constant & 0x00FF
|
|
add r12, #$second_constant & 0x00FF
|
|
; generate vector constants
|
|
vdup.16 d30, r8
|
|
vdup.16 d31, r12
|
|
; (used) two for inputs (regA-regD), one for constants (q15)
|
|
; do some multiplications (ordered for maximum latency hiding)
|
|
vmull.s16 q8, $regC, d30
|
|
vmull.s16 q10, $regA, d31
|
|
vmull.s16 q9, $regD, d30
|
|
vmull.s16 q11, $regB, d31
|
|
vmull.s16 q12, $regC, d31
|
|
; (used) five for intermediate (q8-q12), one for constants (q15)
|
|
; do some addition/subtractions (to get back two register)
|
|
vsub.s32 q8, q8, q10
|
|
vsub.s32 q9, q9, q11
|
|
; do more multiplications (ordered for maximum latency hiding)
|
|
vmull.s16 q10, $regD, d31
|
|
vmull.s16 q11, $regA, d30
|
|
vmull.s16 q15, $regB, d30
|
|
; (used) six for intermediate (q8-q12, q15)
|
|
; do more addition/subtractions
|
|
vadd.s32 q11, q12, q11
|
|
vadd.s32 q10, q10, q15
|
|
; (used) four for intermediate (q8-q11)
|
|
; dct_const_round_shift
|
|
vqrshrn.s32 $reg1, q8, #14
|
|
vqrshrn.s32 $reg2, q9, #14
|
|
vqrshrn.s32 $reg3, q11, #14
|
|
vqrshrn.s32 $reg4, q10, #14
|
|
; (used) two for results, well four d registers
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
; Touches q8-q12, q15 (q13-q14 are preserved)
|
|
; valid output registers are anything but q8-q11
|
|
MACRO
|
|
DO_BUTTERFLY_STD $first_constant, $second_constant, $reg1, $reg2, $reg3, $reg4
|
|
DO_BUTTERFLY d28, d29, d26, d27, $first_constant, $second_constant, $reg1, $reg2, $reg3, $reg4
|
|
MEND
|
|
; --------------------------------------------------------------------------
|
|
|
|
;void vp9_idct32x32_1024_add_neon(int16_t *input, uint8_t *dest, int dest_stride);
|
|
;
|
|
; r0 int16_t *input,
|
|
; r1 uint8_t *dest,
|
|
; r2 int dest_stride)
|
|
; loop counters
|
|
; r4 bands loop counter
|
|
; r5 pass loop counter
|
|
; r8 transpose loop counter
|
|
; combine-add pointers
|
|
; r6 dest + 31 * dest_stride, descending (30, 29, 28, ...)
|
|
; r7 dest + 0 * dest_stride, ascending (1, 2, 3, ...)
|
|
; r9 dest + 15 * dest_stride, descending (14, 13, 12, ...)
|
|
; r10 dest + 16 * dest_stride, ascending (17, 18, 19, ...)
|
|
|
|
|vp9_idct32x32_1024_add_neon| PROC
|
|
; This function does one pass of idct32x32 transform.
|
|
;
|
|
; This is done by transposing the input and then doing a 1d transform on
|
|
; columns. In the first pass, the transposed columns are the original
|
|
; rows. In the second pass, after the transposition, the colums are the
|
|
; original columns.
|
|
; The 1d transform is done by looping over bands of eight columns (the
|
|
; idct32_bands loop). For each band, the transform input transposition
|
|
; is done on demand, one band of four 8x8 matrices at a time. The four
|
|
; matrices are transposed by pairs (the idct32_transpose_pair loop).
|
|
push {r4-r11}
|
|
vpush {d8-d15}
|
|
; stack operation
|
|
; internal buffer used to transpose 8 lines into before transforming them
|
|
; int16_t transpose_buffer[32 * 8];
|
|
; at sp + [4096, 4607]
|
|
; results of the first pass (transpose and transform rows)
|
|
; int16_t pass1[32 * 32];
|
|
; at sp + [0, 2047]
|
|
; results of the second pass (transpose and transform columns)
|
|
; int16_t pass2[32 * 32];
|
|
; at sp + [2048, 4095]
|
|
sub sp, sp, #512+2048+2048
|
|
|
|
; r6 = dest + 31 * dest_stride
|
|
; r7 = dest + 0 * dest_stride
|
|
; r9 = dest + 15 * dest_stride
|
|
; r10 = dest + 16 * dest_stride
|
|
rsb r6, r2, r2, lsl #5
|
|
rsb r9, r2, r2, lsl #4
|
|
add r10, r1, r2, lsl #4
|
|
mov r7, r1
|
|
add r6, r6, r1
|
|
add r9, r9, r1
|
|
; r11 = -dest_stride
|
|
neg r11, r2
|
|
; r3 = input
|
|
mov r3, r0
|
|
; parameters for first pass
|
|
; r0 = transpose_buffer[32 * 8]
|
|
add r0, sp, #4096
|
|
; r1 = pass1[32 * 32]
|
|
mov r1, sp
|
|
|
|
mov r5, #0 ; initialize pass loop counter
|
|
idct32_pass_loop
|
|
mov r4, #4 ; initialize bands loop counter
|
|
idct32_bands_loop
|
|
mov r8, #2 ; initialize transpose loop counter
|
|
idct32_transpose_pair_loop
|
|
; Load two horizontally consecutive 8x8 16bit data matrices. The first one
|
|
; into q0-q7 and the second one into q8-q15. There is a stride of 64,
|
|
; adjusted to 32 because of the two post-increments.
|
|
vld1.s16 {q8}, [r3]!
|
|
vld1.s16 {q0}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q9}, [r3]!
|
|
vld1.s16 {q1}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q10}, [r3]!
|
|
vld1.s16 {q2}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q11}, [r3]!
|
|
vld1.s16 {q3}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q12}, [r3]!
|
|
vld1.s16 {q4}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q13}, [r3]!
|
|
vld1.s16 {q5}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q14}, [r3]!
|
|
vld1.s16 {q6}, [r3]!
|
|
add r3, #32
|
|
vld1.s16 {q15}, [r3]!
|
|
vld1.s16 {q7}, [r3]!
|
|
|
|
; Transpose the two 8x8 16bit data matrices.
|
|
vswp d17, d24
|
|
vswp d23, d30
|
|
vswp d21, d28
|
|
vswp d19, d26
|
|
vswp d1, d8
|
|
vswp d7, d14
|
|
vswp d5, d12
|
|
vswp d3, d10
|
|
vtrn.32 q8, q10
|
|
vtrn.32 q9, q11
|
|
vtrn.32 q12, q14
|
|
vtrn.32 q13, q15
|
|
vtrn.32 q0, q2
|
|
vtrn.32 q1, q3
|
|
vtrn.32 q4, q6
|
|
vtrn.32 q5, q7
|
|
vtrn.16 q8, q9
|
|
vtrn.16 q10, q11
|
|
vtrn.16 q12, q13
|
|
vtrn.16 q14, q15
|
|
vtrn.16 q0, q1
|
|
vtrn.16 q2, q3
|
|
vtrn.16 q4, q5
|
|
vtrn.16 q6, q7
|
|
|
|
; Store both matrices after each other. There is a stride of 32, which
|
|
; adjusts to nothing because of the post-increments.
|
|
vst1.16 {q8}, [r0]!
|
|
vst1.16 {q9}, [r0]!
|
|
vst1.16 {q10}, [r0]!
|
|
vst1.16 {q11}, [r0]!
|
|
vst1.16 {q12}, [r0]!
|
|
vst1.16 {q13}, [r0]!
|
|
vst1.16 {q14}, [r0]!
|
|
vst1.16 {q15}, [r0]!
|
|
vst1.16 {q0}, [r0]!
|
|
vst1.16 {q1}, [r0]!
|
|
vst1.16 {q2}, [r0]!
|
|
vst1.16 {q3}, [r0]!
|
|
vst1.16 {q4}, [r0]!
|
|
vst1.16 {q5}, [r0]!
|
|
vst1.16 {q6}, [r0]!
|
|
vst1.16 {q7}, [r0]!
|
|
|
|
; increment pointers by adjusted stride (not necessary for r0/out)
|
|
; go back by 7*32 for the seven lines moved fully by read and add
|
|
; go back by 32 for the eigth line only read
|
|
; advance by 16*2 to go the next pair
|
|
sub r3, r3, #7*32*2 + 32 - 16*2
|
|
; transpose pair loop processing
|
|
subs r8, r8, #1
|
|
bne idct32_transpose_pair_loop
|
|
|
|
; restore r0/input to its original value
|
|
sub r0, r0, #32*8*2
|
|
|
|
; Instead of doing the transforms stage by stage, it is done by loading
|
|
; some input values and doing as many stages as possible to minimize the
|
|
; storing/loading of intermediate results. To fit within registers, the
|
|
; final coefficients are cut into four blocks:
|
|
; BLOCK A: 16-19,28-31
|
|
; BLOCK B: 20-23,24-27
|
|
; BLOCK C: 8-10,11-15
|
|
; BLOCK D: 0-3,4-7
|
|
; Blocks A and C are straight calculation through the various stages. In
|
|
; block B, further calculations are performed using the results from
|
|
; block A. In block D, further calculations are performed using the results
|
|
; from block C and then the final calculations are done using results from
|
|
; block A and B which have been combined at the end of block B.
|
|
|
|
; --------------------------------------------------------------------------
|
|
; BLOCK A: 16-19,28-31
|
|
; --------------------------------------------------------------------------
|
|
; generate 16,17,30,31
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[1 * 32] * cospi_31_64 - input[31 * 32] * cospi_1_64;
|
|
;temp2 = input[1 * 32] * cospi_1_64 + input[31 * 32] * cospi_31_64;
|
|
;step1b[16][i] = dct_const_round_shift(temp1);
|
|
;step1b[31][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 0, 1, 31
|
|
DO_BUTTERFLY_STD cospi_31_64, cospi_1_64, d0, d1, d4, d5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[17 * 32] * cospi_15_64 - input[15 * 32] * cospi_17_64;
|
|
;temp2 = input[17 * 32] * cospi_17_64 + input[15 * 32] * cospi_15_64;
|
|
;step1b[17][i] = dct_const_round_shift(temp1);
|
|
;step1b[30][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 31, 17, 15
|
|
DO_BUTTERFLY_STD cospi_15_64, cospi_17_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;step2[16] = step1b[16][i] + step1b[17][i];
|
|
;step2[17] = step1b[16][i] - step1b[17][i];
|
|
;step2[30] = -step1b[30][i] + step1b[31][i];
|
|
;step2[31] = step1b[30][i] + step1b[31][i];
|
|
vadd.s16 q4, q0, q1
|
|
vsub.s16 q13, q0, q1
|
|
vadd.s16 q6, q2, q3
|
|
vsub.s16 q14, q2, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;temp1 = step1b[30][i] * cospi_28_64 - step1b[17][i] * cospi_4_64;
|
|
;temp2 = step1b[30][i] * cospi_4_64 - step1b[17][i] * cospi_28_64;
|
|
;step3[17] = dct_const_round_shift(temp1);
|
|
;step3[30] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_28_64, cospi_4_64, d10, d11, d14, d15
|
|
; --------------------------------------------------------------------------
|
|
; generate 18,19,28,29
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[9 * 32] * cospi_23_64 - input[23 * 32] * cospi_9_64;
|
|
;temp2 = input[9 * 32] * cospi_9_64 + input[23 * 32] * cospi_23_64;
|
|
;step1b[18][i] = dct_const_round_shift(temp1);
|
|
;step1b[29][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 15, 9, 23
|
|
DO_BUTTERFLY_STD cospi_23_64, cospi_9_64, d0, d1, d4, d5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[25 * 32] * cospi_7_64 - input[7 * 32] * cospi_25_64;
|
|
;temp2 = input[25 * 32] * cospi_25_64 + input[7 * 32] * cospi_7_64;
|
|
;step1b[19][i] = dct_const_round_shift(temp1);
|
|
;step1b[28][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 23, 25, 7
|
|
DO_BUTTERFLY_STD cospi_7_64, cospi_25_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;step2[18] = -step1b[18][i] + step1b[19][i];
|
|
;step2[19] = step1b[18][i] + step1b[19][i];
|
|
;step2[28] = step1b[28][i] + step1b[29][i];
|
|
;step2[29] = step1b[28][i] - step1b[29][i];
|
|
vsub.s16 q13, q3, q2
|
|
vadd.s16 q3, q3, q2
|
|
vsub.s16 q14, q1, q0
|
|
vadd.s16 q2, q1, q0
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;temp1 = step1b[18][i] * (-cospi_4_64) - step1b[29][i] * (-cospi_28_64);
|
|
;temp2 = step1b[18][i] * (-cospi_28_64) + step1b[29][i] * (-cospi_4_64);
|
|
;step3[29] = dct_const_round_shift(temp1);
|
|
;step3[18] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD (-cospi_4_64), (-cospi_28_64), d2, d3, d0, d1
|
|
; --------------------------------------------------------------------------
|
|
; combine 16-19,28-31
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;step1[16] = step1b[16][i] + step1b[19][i];
|
|
;step1[17] = step1b[17][i] + step1b[18][i];
|
|
;step1[18] = step1b[17][i] - step1b[18][i];
|
|
;step1[29] = step1b[30][i] - step1b[29][i];
|
|
;step1[30] = step1b[30][i] + step1b[29][i];
|
|
;step1[31] = step1b[31][i] + step1b[28][i];
|
|
vadd.s16 q8, q4, q2
|
|
vadd.s16 q9, q5, q0
|
|
vadd.s16 q10, q7, q1
|
|
vadd.s16 q15, q6, q3
|
|
vsub.s16 q13, q5, q0
|
|
vsub.s16 q14, q7, q1
|
|
STORE_IN_OUTPUT 0, 16, 31, q8, q15
|
|
STORE_IN_OUTPUT 31, 17, 30, q9, q10
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;temp1 = step1b[29][i] * cospi_24_64 - step1b[18][i] * cospi_8_64;
|
|
;temp2 = step1b[29][i] * cospi_8_64 + step1b[18][i] * cospi_24_64;
|
|
;step2[18] = dct_const_round_shift(temp1);
|
|
;step2[29] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d0, d1, d2, d3
|
|
STORE_IN_OUTPUT 30, 29, 18, q1, q0
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;step1[19] = step1b[16][i] - step1b[19][i];
|
|
;step1[28] = step1b[31][i] - step1b[28][i];
|
|
vsub.s16 q13, q4, q2
|
|
vsub.s16 q14, q6, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;temp1 = step1b[28][i] * cospi_24_64 - step1b[19][i] * cospi_8_64;
|
|
;temp2 = step1b[28][i] * cospi_8_64 + step1b[19][i] * cospi_24_64;
|
|
;step2[19] = dct_const_round_shift(temp1);
|
|
;step2[28] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d8, d9, d12, d13
|
|
STORE_IN_OUTPUT 18, 19, 28, q4, q6
|
|
; --------------------------------------------------------------------------
|
|
|
|
|
|
; --------------------------------------------------------------------------
|
|
; BLOCK B: 20-23,24-27
|
|
; --------------------------------------------------------------------------
|
|
; generate 20,21,26,27
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[5 * 32] * cospi_27_64 - input[27 * 32] * cospi_5_64;
|
|
;temp2 = input[5 * 32] * cospi_5_64 + input[27 * 32] * cospi_27_64;
|
|
;step1b[20][i] = dct_const_round_shift(temp1);
|
|
;step1b[27][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 7, 5, 27
|
|
DO_BUTTERFLY_STD cospi_27_64, cospi_5_64, d0, d1, d4, d5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[21 * 32] * cospi_11_64 - input[11 * 32] * cospi_21_64;
|
|
;temp2 = input[21 * 32] * cospi_21_64 + input[11 * 32] * cospi_11_64;
|
|
;step1b[21][i] = dct_const_round_shift(temp1);
|
|
;step1b[26][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 27, 21, 11
|
|
DO_BUTTERFLY_STD cospi_11_64, cospi_21_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;step2[20] = step1b[20][i] + step1b[21][i];
|
|
;step2[21] = step1b[20][i] - step1b[21][i];
|
|
;step2[26] = -step1b[26][i] + step1b[27][i];
|
|
;step2[27] = step1b[26][i] + step1b[27][i];
|
|
vsub.s16 q13, q0, q1
|
|
vadd.s16 q0, q0, q1
|
|
vsub.s16 q14, q2, q3
|
|
vadd.s16 q2, q2, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;temp1 = step1b[26][i] * cospi_12_64 - step1b[21][i] * cospi_20_64;
|
|
;temp2 = step1b[26][i] * cospi_20_64 + step1b[21][i] * cospi_12_64;
|
|
;step3[21] = dct_const_round_shift(temp1);
|
|
;step3[26] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_12_64, cospi_20_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; generate 22,23,24,25
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[13 * 32] * cospi_19_64 - input[19 * 32] * cospi_13_64;
|
|
;temp2 = input[13 * 32] * cospi_13_64 + input[19 * 32] * cospi_19_64;
|
|
;step1b[22][i] = dct_const_round_shift(temp1);
|
|
;step1b[25][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 11, 13, 19
|
|
DO_BUTTERFLY_STD cospi_19_64, cospi_13_64, d10, d11, d14, d15
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 1
|
|
;temp1 = input[29 * 32] * cospi_3_64 - input[3 * 32] * cospi_29_64;
|
|
;temp2 = input[29 * 32] * cospi_29_64 + input[3 * 32] * cospi_3_64;
|
|
;step1b[23][i] = dct_const_round_shift(temp1);
|
|
;step1b[24][i] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 19, 29, 3
|
|
DO_BUTTERFLY_STD cospi_3_64, cospi_29_64, d8, d9, d12, d13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;step2[22] = -step1b[22][i] + step1b[23][i];
|
|
;step2[23] = step1b[22][i] + step1b[23][i];
|
|
;step2[24] = step1b[24][i] + step1b[25][i];
|
|
;step2[25] = step1b[24][i] - step1b[25][i];
|
|
vsub.s16 q14, q4, q5
|
|
vadd.s16 q5, q4, q5
|
|
vsub.s16 q13, q6, q7
|
|
vadd.s16 q6, q6, q7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;temp1 = step1b[22][i] * (-cospi_20_64) - step1b[25][i] * (-cospi_12_64);
|
|
;temp2 = step1b[22][i] * (-cospi_12_64) + step1b[25][i] * (-cospi_20_64);
|
|
;step3[25] = dct_const_round_shift(temp1);
|
|
;step3[22] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD (-cospi_20_64), (-cospi_12_64), d8, d9, d14, d15
|
|
; --------------------------------------------------------------------------
|
|
; combine 20-23,24-27
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;step1[22] = step1b[22][i] + step1b[21][i];
|
|
;step1[23] = step1b[23][i] + step1b[20][i];
|
|
vadd.s16 q10, q7, q1
|
|
vadd.s16 q11, q5, q0
|
|
;step1[24] = step1b[24][i] + step1b[27][i];
|
|
;step1[25] = step1b[25][i] + step1b[26][i];
|
|
vadd.s16 q12, q6, q2
|
|
vadd.s16 q15, q4, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;step3[16] = step1b[16][i] + step1b[23][i];
|
|
;step3[17] = step1b[17][i] + step1b[22][i];
|
|
;step3[22] = step1b[17][i] - step1b[22][i];
|
|
;step3[23] = step1b[16][i] - step1b[23][i];
|
|
LOAD_FROM_OUTPUT 28, 16, 17, q14, q13
|
|
vadd.s16 q8, q14, q11
|
|
vadd.s16 q9, q13, q10
|
|
vsub.s16 q13, q13, q10
|
|
vsub.s16 q11, q14, q11
|
|
STORE_IN_OUTPUT 17, 17, 16, q9, q8
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;step3[24] = step1b[31][i] - step1b[24][i];
|
|
;step3[25] = step1b[30][i] - step1b[25][i];
|
|
;step3[30] = step1b[30][i] + step1b[25][i];
|
|
;step3[31] = step1b[31][i] + step1b[24][i];
|
|
LOAD_FROM_OUTPUT 16, 30, 31, q14, q9
|
|
vsub.s16 q8, q9, q12
|
|
vadd.s16 q10, q14, q15
|
|
vsub.s16 q14, q14, q15
|
|
vadd.s16 q12, q9, q12
|
|
STORE_IN_OUTPUT 31, 30, 31, q10, q12
|
|
; --------------------------------------------------------------------------
|
|
; TODO(cd) do some register allocation change to remove these push/pop
|
|
vpush {q8} ; [24]
|
|
vpush {q11} ; [23]
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;temp1 = (step1b[25][i] - step1b[22][i]) * cospi_16_64;
|
|
;temp2 = (step1b[25][i] + step1b[22][i]) * cospi_16_64;
|
|
;step1[22] = dct_const_round_shift(temp1);
|
|
;step1[25] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d26, d27, d28, d29
|
|
STORE_IN_OUTPUT 31, 25, 22, q14, q13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;temp1 = (step1b[24][i] - step1b[23][i]) * cospi_16_64;
|
|
;temp2 = (step1b[24][i] + step1b[23][i]) * cospi_16_64;
|
|
;step1[23] = dct_const_round_shift(temp1);
|
|
;step1[24] = dct_const_round_shift(temp2);
|
|
; TODO(cd) do some register allocation change to remove these push/pop
|
|
vpop {q13} ; [23]
|
|
vpop {q14} ; [24]
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d26, d27, d28, d29
|
|
STORE_IN_OUTPUT 22, 24, 23, q14, q13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;step1[20] = step1b[23][i] - step1b[20][i];
|
|
;step1[27] = step1b[24][i] - step1b[27][i];
|
|
vsub.s16 q14, q5, q0
|
|
vsub.s16 q13, q6, q2
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;temp1 = step1b[20][i] * (-cospi_8_64) - step1b[27][i] * (-cospi_24_64);
|
|
;temp2 = step1b[20][i] * (-cospi_24_64) + step1b[27][i] * (-cospi_8_64);
|
|
;step2[27] = dct_const_round_shift(temp1);
|
|
;step2[20] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD (-cospi_8_64), (-cospi_24_64), d10, d11, d12, d13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;step1[21] = step1b[22][i] - step1b[21][i];
|
|
;step1[26] = step1b[25][i] - step1b[26][i];
|
|
vsub.s16 q14, q7, q1
|
|
vsub.s16 q13, q4, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;temp1 = step1b[21][i] * (-cospi_8_64) - step1b[26][i] * (-cospi_24_64);
|
|
;temp2 = step1b[21][i] * (-cospi_24_64) + step1b[26][i] * (-cospi_8_64);
|
|
;step2[26] = dct_const_round_shift(temp1);
|
|
;step2[21] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD (-cospi_8_64), (-cospi_24_64), d0, d1, d2, d3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;step3[18] = step1b[18][i] + step1b[21][i];
|
|
;step3[19] = step1b[19][i] + step1b[20][i];
|
|
;step3[20] = step1b[19][i] - step1b[20][i];
|
|
;step3[21] = step1b[18][i] - step1b[21][i];
|
|
LOAD_FROM_OUTPUT 23, 18, 19, q14, q13
|
|
vadd.s16 q8, q14, q1
|
|
vadd.s16 q9, q13, q6
|
|
vsub.s16 q13, q13, q6
|
|
vsub.s16 q1, q14, q1
|
|
STORE_IN_OUTPUT 19, 18, 19, q8, q9
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;step3[27] = step1b[28][i] - step1b[27][i];
|
|
;step3[28] = step1b[28][i] + step1b[27][i];
|
|
;step3[29] = step1b[29][i] + step1b[26][i];
|
|
;step3[26] = step1b[29][i] - step1b[26][i];
|
|
LOAD_FROM_OUTPUT 19, 28, 29, q8, q9
|
|
vsub.s16 q14, q8, q5
|
|
vadd.s16 q10, q8, q5
|
|
vadd.s16 q11, q9, q0
|
|
vsub.s16 q0, q9, q0
|
|
STORE_IN_OUTPUT 29, 28, 29, q10, q11
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;temp1 = (step1b[27][i] - step1b[20][i]) * cospi_16_64;
|
|
;temp2 = (step1b[27][i] + step1b[20][i]) * cospi_16_64;
|
|
;step1[20] = dct_const_round_shift(temp1);
|
|
;step1[27] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d26, d27, d28, d29
|
|
STORE_IN_OUTPUT 29, 20, 27, q13, q14
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;temp1 = (step1b[26][i] - step1b[21][i]) * cospi_16_64;
|
|
;temp2 = (step1b[26][i] + step1b[21][i]) * cospi_16_64;
|
|
;step1[21] = dct_const_round_shift(temp1);
|
|
;step1[26] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY d0, d1, d2, d3, cospi_16_64, cospi_16_64, d2, d3, d0, d1
|
|
STORE_IN_OUTPUT 27, 21, 26, q1, q0
|
|
; --------------------------------------------------------------------------
|
|
|
|
|
|
; --------------------------------------------------------------------------
|
|
; BLOCK C: 8-10,11-15
|
|
; --------------------------------------------------------------------------
|
|
; generate 8,9,14,15
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;temp1 = input[2 * 32] * cospi_30_64 - input[30 * 32] * cospi_2_64;
|
|
;temp2 = input[2 * 32] * cospi_2_64 + input[30 * 32] * cospi_30_64;
|
|
;step2[8] = dct_const_round_shift(temp1);
|
|
;step2[15] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 3, 2, 30
|
|
DO_BUTTERFLY_STD cospi_30_64, cospi_2_64, d0, d1, d4, d5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;temp1 = input[18 * 32] * cospi_14_64 - input[14 * 32] * cospi_18_64;
|
|
;temp2 = input[18 * 32] * cospi_18_64 + input[14 * 32] * cospi_14_64;
|
|
;step2[9] = dct_const_round_shift(temp1);
|
|
;step2[14] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 30, 18, 14
|
|
DO_BUTTERFLY_STD cospi_14_64, cospi_18_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;step3[8] = step1b[8][i] + step1b[9][i];
|
|
;step3[9] = step1b[8][i] - step1b[9][i];
|
|
;step3[14] = step1b[15][i] - step1b[14][i];
|
|
;step3[15] = step1b[15][i] + step1b[14][i];
|
|
vsub.s16 q13, q0, q1
|
|
vadd.s16 q0, q0, q1
|
|
vsub.s16 q14, q2, q3
|
|
vadd.s16 q2, q2, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;temp1 = step1b[14][i] * cospi_24_64 - step1b[9][i] * cospi_8_64;
|
|
;temp2 = step1b[14][i] * cospi_8_64 + step1b[9][i] * cospi_24_64;
|
|
;step1[9] = dct_const_round_shift(temp1);
|
|
;step1[14] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; generate 10,11,12,13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;temp1 = input[10 * 32] * cospi_22_64 - input[22 * 32] * cospi_10_64;
|
|
;temp2 = input[10 * 32] * cospi_10_64 + input[22 * 32] * cospi_22_64;
|
|
;step2[10] = dct_const_round_shift(temp1);
|
|
;step2[13] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 14, 10, 22
|
|
DO_BUTTERFLY_STD cospi_22_64, cospi_10_64, d10, d11, d14, d15
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 2
|
|
;temp1 = input[26 * 32] * cospi_6_64 - input[6 * 32] * cospi_26_64;
|
|
;temp2 = input[26 * 32] * cospi_26_64 + input[6 * 32] * cospi_6_64;
|
|
;step2[11] = dct_const_round_shift(temp1);
|
|
;step2[12] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 22, 26, 6
|
|
DO_BUTTERFLY_STD cospi_6_64, cospi_26_64, d8, d9, d12, d13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;step3[10] = step1b[11][i] - step1b[10][i];
|
|
;step3[11] = step1b[11][i] + step1b[10][i];
|
|
;step3[12] = step1b[12][i] + step1b[13][i];
|
|
;step3[13] = step1b[12][i] - step1b[13][i];
|
|
vsub.s16 q14, q4, q5
|
|
vadd.s16 q5, q4, q5
|
|
vsub.s16 q13, q6, q7
|
|
vadd.s16 q6, q6, q7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;temp1 = step1b[10][i] * (-cospi_8_64) - step1b[13][i] * (-cospi_24_64);
|
|
;temp2 = step1b[10][i] * (-cospi_24_64) + step1b[13][i] * (-cospi_8_64);
|
|
;step1[13] = dct_const_round_shift(temp1);
|
|
;step1[10] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD (-cospi_8_64), (-cospi_24_64), d8, d9, d14, d15
|
|
; --------------------------------------------------------------------------
|
|
; combine 8-10,11-15
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;step2[8] = step1b[8][i] + step1b[11][i];
|
|
;step2[9] = step1b[9][i] + step1b[10][i];
|
|
;step2[10] = step1b[9][i] - step1b[10][i];
|
|
vadd.s16 q8, q0, q5
|
|
vadd.s16 q9, q1, q7
|
|
vsub.s16 q13, q1, q7
|
|
;step2[13] = step1b[14][i] - step1b[13][i];
|
|
;step2[14] = step1b[14][i] + step1b[13][i];
|
|
;step2[15] = step1b[15][i] + step1b[12][i];
|
|
vsub.s16 q14, q3, q4
|
|
vadd.s16 q10, q3, q4
|
|
vadd.s16 q15, q2, q6
|
|
STORE_IN_OUTPUT 26, 8, 15, q8, q15
|
|
STORE_IN_OUTPUT 15, 9, 14, q9, q10
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;temp1 = (step1b[13][i] - step1b[10][i]) * cospi_16_64;
|
|
;temp2 = (step1b[13][i] + step1b[10][i]) * cospi_16_64;
|
|
;step3[10] = dct_const_round_shift(temp1);
|
|
;step3[13] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d2, d3, d6, d7
|
|
STORE_IN_OUTPUT 14, 13, 10, q3, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;step2[11] = step1b[8][i] - step1b[11][i];
|
|
;step2[12] = step1b[15][i] - step1b[12][i];
|
|
vsub.s16 q13, q0, q5
|
|
vsub.s16 q14, q2, q6
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;temp1 = (step1b[12][i] - step1b[11][i]) * cospi_16_64;
|
|
;temp2 = (step1b[12][i] + step1b[11][i]) * cospi_16_64;
|
|
;step3[11] = dct_const_round_shift(temp1);
|
|
;step3[12] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d2, d3, d6, d7
|
|
STORE_IN_OUTPUT 10, 11, 12, q1, q3
|
|
; --------------------------------------------------------------------------
|
|
|
|
|
|
; --------------------------------------------------------------------------
|
|
; BLOCK D: 0-3,4-7
|
|
; --------------------------------------------------------------------------
|
|
; generate 4,5,6,7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;temp1 = input[4 * 32] * cospi_28_64 - input[28 * 32] * cospi_4_64;
|
|
;temp2 = input[4 * 32] * cospi_4_64 + input[28 * 32] * cospi_28_64;
|
|
;step3[4] = dct_const_round_shift(temp1);
|
|
;step3[7] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 6, 4, 28
|
|
DO_BUTTERFLY_STD cospi_28_64, cospi_4_64, d0, d1, d4, d5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 3
|
|
;temp1 = input[20 * 32] * cospi_12_64 - input[12 * 32] * cospi_20_64;
|
|
;temp2 = input[20 * 32] * cospi_20_64 + input[12 * 32] * cospi_12_64;
|
|
;step3[5] = dct_const_round_shift(temp1);
|
|
;step3[6] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 28, 20, 12
|
|
DO_BUTTERFLY_STD cospi_12_64, cospi_20_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;step1[4] = step1b[4][i] + step1b[5][i];
|
|
;step1[5] = step1b[4][i] - step1b[5][i];
|
|
;step1[6] = step1b[7][i] - step1b[6][i];
|
|
;step1[7] = step1b[7][i] + step1b[6][i];
|
|
vsub.s16 q13, q0, q1
|
|
vadd.s16 q0, q0, q1
|
|
vsub.s16 q14, q2, q3
|
|
vadd.s16 q2, q2, q3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;temp1 = (step1b[6][i] - step1b[5][i]) * cospi_16_64;
|
|
;temp2 = (step1b[5][i] + step1b[6][i]) * cospi_16_64;
|
|
;step2[5] = dct_const_round_shift(temp1);
|
|
;step2[6] = dct_const_round_shift(temp2);
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d2, d3, d6, d7
|
|
; --------------------------------------------------------------------------
|
|
; generate 0,1,2,3
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;temp1 = (input[0 * 32] - input[16 * 32]) * cospi_16_64;
|
|
;temp2 = (input[0 * 32] + input[16 * 32]) * cospi_16_64;
|
|
;step1[1] = dct_const_round_shift(temp1);
|
|
;step1[0] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 12, 0, 16
|
|
DO_BUTTERFLY_STD cospi_16_64, cospi_16_64, d10, d11, d14, d15
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 4
|
|
;temp1 = input[8 * 32] * cospi_24_64 - input[24 * 32] * cospi_8_64;
|
|
;temp2 = input[8 * 32] * cospi_8_64 + input[24 * 32] * cospi_24_64;
|
|
;step1[2] = dct_const_round_shift(temp1);
|
|
;step1[3] = dct_const_round_shift(temp2);
|
|
LOAD_FROM_TRANSPOSED 16, 8, 24
|
|
DO_BUTTERFLY_STD cospi_24_64, cospi_8_64, d28, d29, d12, d13
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 5
|
|
;step2[0] = step1b[0][i] + step1b[3][i];
|
|
;step2[1] = step1b[1][i] + step1b[2][i];
|
|
;step2[2] = step1b[1][i] - step1b[2][i];
|
|
;step2[3] = step1b[0][i] - step1b[3][i];
|
|
vadd.s16 q4, q7, q6
|
|
vsub.s16 q7, q7, q6
|
|
vsub.s16 q6, q5, q14
|
|
vadd.s16 q5, q5, q14
|
|
; --------------------------------------------------------------------------
|
|
; combine 0-3,4-7
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 6
|
|
;step3[0] = step1b[0][i] + step1b[7][i];
|
|
;step3[1] = step1b[1][i] + step1b[6][i];
|
|
;step3[2] = step1b[2][i] + step1b[5][i];
|
|
;step3[3] = step1b[3][i] + step1b[4][i];
|
|
vadd.s16 q8, q4, q2
|
|
vadd.s16 q9, q5, q3
|
|
vadd.s16 q10, q6, q1
|
|
vadd.s16 q11, q7, q0
|
|
;step3[4] = step1b[3][i] - step1b[4][i];
|
|
;step3[5] = step1b[2][i] - step1b[5][i];
|
|
;step3[6] = step1b[1][i] - step1b[6][i];
|
|
;step3[7] = step1b[0][i] - step1b[7][i];
|
|
vsub.s16 q12, q7, q0
|
|
vsub.s16 q13, q6, q1
|
|
vsub.s16 q14, q5, q3
|
|
vsub.s16 q15, q4, q2
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[0] = step1b[0][i] + step1b[15][i];
|
|
;step1[1] = step1b[1][i] + step1b[14][i];
|
|
;step1[14] = step1b[1][i] - step1b[14][i];
|
|
;step1[15] = step1b[0][i] - step1b[15][i];
|
|
LOAD_FROM_OUTPUT 12, 14, 15, q0, q1
|
|
vadd.s16 q2, q8, q1
|
|
vadd.s16 q3, q9, q0
|
|
vsub.s16 q4, q9, q0
|
|
vsub.s16 q5, q8, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[14 * 32] = step1b[14][i] + step1b[17][i];
|
|
;output[15 * 32] = step1b[15][i] + step1b[16][i];
|
|
;output[16 * 32] = step1b[15][i] - step1b[16][i];
|
|
;output[17 * 32] = step1b[14][i] - step1b[17][i];
|
|
LOAD_FROM_OUTPUT 15, 16, 17, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
|
|
cmp r5, #0
|
|
bgt idct32_bands_end_2nd_pass
|
|
|
|
idct32_bands_end_1st_pass
|
|
STORE_IN_OUTPUT 17, 16, 17, q6, q7
|
|
STORE_IN_OUTPUT 17, 14, 15, q8, q9
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 0 * 32] = step1b[0][i] + step1b[31][i];
|
|
;output[ 1 * 32] = step1b[1][i] + step1b[30][i];
|
|
;output[30 * 32] = step1b[1][i] - step1b[30][i];
|
|
;output[31 * 32] = step1b[0][i] - step1b[31][i];
|
|
LOAD_FROM_OUTPUT 15, 30, 31, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_IN_OUTPUT 31, 30, 31, q6, q7
|
|
STORE_IN_OUTPUT 31, 0, 1, q4, q5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[2] = step1b[2][i] + step1b[13][i];
|
|
;step1[3] = step1b[3][i] + step1b[12][i];
|
|
;step1[12] = step1b[3][i] - step1b[12][i];
|
|
;step1[13] = step1b[2][i] - step1b[13][i];
|
|
LOAD_FROM_OUTPUT 1, 12, 13, q0, q1
|
|
vadd.s16 q2, q10, q1
|
|
vadd.s16 q3, q11, q0
|
|
vsub.s16 q4, q11, q0
|
|
vsub.s16 q5, q10, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[12 * 32] = step1b[12][i] + step1b[19][i];
|
|
;output[13 * 32] = step1b[13][i] + step1b[18][i];
|
|
;output[18 * 32] = step1b[13][i] - step1b[18][i];
|
|
;output[19 * 32] = step1b[12][i] - step1b[19][i];
|
|
LOAD_FROM_OUTPUT 13, 18, 19, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
STORE_IN_OUTPUT 19, 18, 19, q6, q7
|
|
STORE_IN_OUTPUT 19, 12, 13, q8, q9
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 2 * 32] = step1b[2][i] + step1b[29][i];
|
|
;output[ 3 * 32] = step1b[3][i] + step1b[28][i];
|
|
;output[28 * 32] = step1b[3][i] - step1b[28][i];
|
|
;output[29 * 32] = step1b[2][i] - step1b[29][i];
|
|
LOAD_FROM_OUTPUT 13, 28, 29, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_IN_OUTPUT 29, 28, 29, q6, q7
|
|
STORE_IN_OUTPUT 29, 2, 3, q4, q5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[4] = step1b[4][i] + step1b[11][i];
|
|
;step1[5] = step1b[5][i] + step1b[10][i];
|
|
;step1[10] = step1b[5][i] - step1b[10][i];
|
|
;step1[11] = step1b[4][i] - step1b[11][i];
|
|
LOAD_FROM_OUTPUT 3, 10, 11, q0, q1
|
|
vadd.s16 q2, q12, q1
|
|
vadd.s16 q3, q13, q0
|
|
vsub.s16 q4, q13, q0
|
|
vsub.s16 q5, q12, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[10 * 32] = step1b[10][i] + step1b[21][i];
|
|
;output[11 * 32] = step1b[11][i] + step1b[20][i];
|
|
;output[20 * 32] = step1b[11][i] - step1b[20][i];
|
|
;output[21 * 32] = step1b[10][i] - step1b[21][i];
|
|
LOAD_FROM_OUTPUT 11, 20, 21, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
STORE_IN_OUTPUT 21, 20, 21, q6, q7
|
|
STORE_IN_OUTPUT 21, 10, 11, q8, q9
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 4 * 32] = step1b[4][i] + step1b[27][i];
|
|
;output[ 5 * 32] = step1b[5][i] + step1b[26][i];
|
|
;output[26 * 32] = step1b[5][i] - step1b[26][i];
|
|
;output[27 * 32] = step1b[4][i] - step1b[27][i];
|
|
LOAD_FROM_OUTPUT 11, 26, 27, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_IN_OUTPUT 27, 26, 27, q6, q7
|
|
STORE_IN_OUTPUT 27, 4, 5, q4, q5
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[6] = step1b[6][i] + step1b[9][i];
|
|
;step1[7] = step1b[7][i] + step1b[8][i];
|
|
;step1[8] = step1b[7][i] - step1b[8][i];
|
|
;step1[9] = step1b[6][i] - step1b[9][i];
|
|
LOAD_FROM_OUTPUT 5, 8, 9, q0, q1
|
|
vadd.s16 q2, q14, q1
|
|
vadd.s16 q3, q15, q0
|
|
vsub.s16 q4, q15, q0
|
|
vsub.s16 q5, q14, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 8 * 32] = step1b[8][i] + step1b[23][i];
|
|
;output[ 9 * 32] = step1b[9][i] + step1b[22][i];
|
|
;output[22 * 32] = step1b[9][i] - step1b[22][i];
|
|
;output[23 * 32] = step1b[8][i] - step1b[23][i];
|
|
LOAD_FROM_OUTPUT 9, 22, 23, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
STORE_IN_OUTPUT 23, 22, 23, q6, q7
|
|
STORE_IN_OUTPUT 23, 8, 9, q8, q9
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 6 * 32] = step1b[6][i] + step1b[25][i];
|
|
;output[ 7 * 32] = step1b[7][i] + step1b[24][i];
|
|
;output[24 * 32] = step1b[7][i] - step1b[24][i];
|
|
;output[25 * 32] = step1b[6][i] - step1b[25][i];
|
|
LOAD_FROM_OUTPUT 9, 24, 25, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_IN_OUTPUT 25, 24, 25, q6, q7
|
|
STORE_IN_OUTPUT 25, 6, 7, q4, q5
|
|
|
|
; restore r0 by removing the last offset from the last
|
|
; operation (LOAD_FROM_TRANSPOSED 16, 8, 24) => 24*8*2
|
|
sub r0, r0, #24*8*2
|
|
; restore r1 by removing the last offset from the last
|
|
; operation (STORE_IN_OUTPUT 24, 6, 7) => 7*32*2
|
|
; advance by 8 columns => 8*2
|
|
sub r1, r1, #7*32*2 - 8*2
|
|
; advance by 8 lines (8*32*2)
|
|
; go back by the two pairs from the loop (32*2)
|
|
add r3, r3, #8*32*2 - 32*2
|
|
|
|
; bands loop processing
|
|
subs r4, r4, #1
|
|
bne idct32_bands_loop
|
|
|
|
; parameters for second pass
|
|
; the input of pass2 is the result of pass1. we have to remove the offset
|
|
; of 32 columns induced by the above idct32_bands_loop
|
|
sub r3, r1, #32*2
|
|
; r1 = pass2[32 * 32]
|
|
add r1, sp, #2048
|
|
|
|
; pass loop processing
|
|
add r5, r5, #1
|
|
b idct32_pass_loop
|
|
|
|
idct32_bands_end_2nd_pass
|
|
STORE_COMBINE_CENTER_RESULTS
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 0 * 32] = step1b[0][i] + step1b[31][i];
|
|
;output[ 1 * 32] = step1b[1][i] + step1b[30][i];
|
|
;output[30 * 32] = step1b[1][i] - step1b[30][i];
|
|
;output[31 * 32] = step1b[0][i] - step1b[31][i];
|
|
LOAD_FROM_OUTPUT 17, 30, 31, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_COMBINE_EXTREME_RESULTS
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[2] = step1b[2][i] + step1b[13][i];
|
|
;step1[3] = step1b[3][i] + step1b[12][i];
|
|
;step1[12] = step1b[3][i] - step1b[12][i];
|
|
;step1[13] = step1b[2][i] - step1b[13][i];
|
|
LOAD_FROM_OUTPUT 31, 12, 13, q0, q1
|
|
vadd.s16 q2, q10, q1
|
|
vadd.s16 q3, q11, q0
|
|
vsub.s16 q4, q11, q0
|
|
vsub.s16 q5, q10, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[12 * 32] = step1b[12][i] + step1b[19][i];
|
|
;output[13 * 32] = step1b[13][i] + step1b[18][i];
|
|
;output[18 * 32] = step1b[13][i] - step1b[18][i];
|
|
;output[19 * 32] = step1b[12][i] - step1b[19][i];
|
|
LOAD_FROM_OUTPUT 13, 18, 19, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
STORE_COMBINE_CENTER_RESULTS
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 2 * 32] = step1b[2][i] + step1b[29][i];
|
|
;output[ 3 * 32] = step1b[3][i] + step1b[28][i];
|
|
;output[28 * 32] = step1b[3][i] - step1b[28][i];
|
|
;output[29 * 32] = step1b[2][i] - step1b[29][i];
|
|
LOAD_FROM_OUTPUT 19, 28, 29, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_COMBINE_EXTREME_RESULTS
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[4] = step1b[4][i] + step1b[11][i];
|
|
;step1[5] = step1b[5][i] + step1b[10][i];
|
|
;step1[10] = step1b[5][i] - step1b[10][i];
|
|
;step1[11] = step1b[4][i] - step1b[11][i];
|
|
LOAD_FROM_OUTPUT 29, 10, 11, q0, q1
|
|
vadd.s16 q2, q12, q1
|
|
vadd.s16 q3, q13, q0
|
|
vsub.s16 q4, q13, q0
|
|
vsub.s16 q5, q12, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[10 * 32] = step1b[10][i] + step1b[21][i];
|
|
;output[11 * 32] = step1b[11][i] + step1b[20][i];
|
|
;output[20 * 32] = step1b[11][i] - step1b[20][i];
|
|
;output[21 * 32] = step1b[10][i] - step1b[21][i];
|
|
LOAD_FROM_OUTPUT 11, 20, 21, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
STORE_COMBINE_CENTER_RESULTS
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 4 * 32] = step1b[4][i] + step1b[27][i];
|
|
;output[ 5 * 32] = step1b[5][i] + step1b[26][i];
|
|
;output[26 * 32] = step1b[5][i] - step1b[26][i];
|
|
;output[27 * 32] = step1b[4][i] - step1b[27][i];
|
|
LOAD_FROM_OUTPUT 21, 26, 27, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_COMBINE_EXTREME_RESULTS
|
|
; --------------------------------------------------------------------------
|
|
; part of stage 7
|
|
;step1[6] = step1b[6][i] + step1b[9][i];
|
|
;step1[7] = step1b[7][i] + step1b[8][i];
|
|
;step1[8] = step1b[7][i] - step1b[8][i];
|
|
;step1[9] = step1b[6][i] - step1b[9][i];
|
|
LOAD_FROM_OUTPUT 27, 8, 9, q0, q1
|
|
vadd.s16 q2, q14, q1
|
|
vadd.s16 q3, q15, q0
|
|
vsub.s16 q4, q15, q0
|
|
vsub.s16 q5, q14, q1
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 8 * 32] = step1b[8][i] + step1b[23][i];
|
|
;output[ 9 * 32] = step1b[9][i] + step1b[22][i];
|
|
;output[22 * 32] = step1b[9][i] - step1b[22][i];
|
|
;output[23 * 32] = step1b[8][i] - step1b[23][i];
|
|
LOAD_FROM_OUTPUT 9, 22, 23, q0, q1
|
|
vadd.s16 q8, q4, q1
|
|
vadd.s16 q9, q5, q0
|
|
vsub.s16 q6, q5, q0
|
|
vsub.s16 q7, q4, q1
|
|
STORE_COMBINE_CENTER_RESULTS_LAST
|
|
; --------------------------------------------------------------------------
|
|
; part of final stage
|
|
;output[ 6 * 32] = step1b[6][i] + step1b[25][i];
|
|
;output[ 7 * 32] = step1b[7][i] + step1b[24][i];
|
|
;output[24 * 32] = step1b[7][i] - step1b[24][i];
|
|
;output[25 * 32] = step1b[6][i] - step1b[25][i];
|
|
LOAD_FROM_OUTPUT 23, 24, 25, q0, q1
|
|
vadd.s16 q4, q2, q1
|
|
vadd.s16 q5, q3, q0
|
|
vsub.s16 q6, q3, q0
|
|
vsub.s16 q7, q2, q1
|
|
STORE_COMBINE_EXTREME_RESULTS_LAST
|
|
; --------------------------------------------------------------------------
|
|
; restore pointers to their initial indices for next band pass by
|
|
; removing/adding dest_stride * 8. The actual increment by eight
|
|
; is taken care of within the _LAST macros.
|
|
add r6, r6, r2, lsl #3
|
|
add r9, r9, r2, lsl #3
|
|
sub r7, r7, r2, lsl #3
|
|
sub r10, r10, r2, lsl #3
|
|
|
|
; restore r0 by removing the last offset from the last
|
|
; operation (LOAD_FROM_TRANSPOSED 16, 8, 24) => 24*8*2
|
|
sub r0, r0, #24*8*2
|
|
; restore r1 by removing the last offset from the last
|
|
; operation (LOAD_FROM_OUTPUT 23, 24, 25) => 25*32*2
|
|
; advance by 8 columns => 8*2
|
|
sub r1, r1, #25*32*2 - 8*2
|
|
; advance by 8 lines (8*32*2)
|
|
; go back by the two pairs from the loop (32*2)
|
|
add r3, r3, #8*32*2 - 32*2
|
|
|
|
; bands loop processing
|
|
subs r4, r4, #1
|
|
bne idct32_bands_loop
|
|
|
|
; stack operation
|
|
add sp, sp, #512+2048+2048
|
|
vpop {d8-d15}
|
|
pop {r4-r11}
|
|
bx lr
|
|
ENDP ; |vp9_idct32x32_1024_add_neon|
|
|
END
|