Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/codecs/libffmpegFLAC/coldfire.S

533 lines
16 KiB
ArmAsm
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2005 by Thom Johansen
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/* The following are assembler optimised version of the LPC filtering
routines needed for FLAC decoding. They is optimised for use with the
MCF5249 processor, or any other similar ColdFire core with the EMAC unit.
*/
/* This routine deals with sample widths 16 and lower. All LPC filtering up to
order 10 is done in specially optimised unrolled loops, while every order
above this is handled by a slower default routine.
*/
.section .icode,"ax",@progbits
.global lpc_decode_emac
.align 2
lpc_decode_emac:
lea.l (-44, %sp), %sp
movem.l %d2-%d7/%a2-%a6, (%sp)
movem.l (44+4, %sp), %d0-%d2/%a0-%a1
/* d0 = blocksize, d1 = qlevel, d2 = pred_order
a0 = data, a1 = coeffs
*/
/* the data pointer always lags behind history pointer by 'pred_order'
samples. since we have one loop for each order, we can hard code this
and free a register by not saving data pointer.
*/
move.l %d2, %d3
neg.l %d3
lea.l (%a0, %d3.l*4), %a0 | history
clr.l %d3
move.l %d3, %macsr | we'll need integer mode for this
tst.l %d0
jeq .exit | zero samples to process, exit
moveq.l #10, %d3
cmp.l %d3, %d2
jgt .default | order is over 10, jump to default case
jmp.l (2, %pc, %d2.l*4) | jump to loop corresponding to pred_order
| jumptable:
bra.w .exit | zero order filter isn't possible, exit function
bra.w .order1
bra.w .order2
bra.w .order3
bra.w .order4
bra.w .order5
bra.w .order6
bra.w .order7
bra.w .order8
bra.w .order9
| last jump table entry coincides with target, so leave it out
.order10:
movem.l (%a1), %d3-%d7/%a1-%a5 | load lpc coefs
move.l (%a0)+, %a6 | load first history sample
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (%a0)+, %a6, %acc0
mac.l %a6, %d6, (%a0)+, %a6, %acc0
mac.l %a6, %d5, (%a0)+, %a6, %acc0
mac.l %a6, %d4, (%a0)+, %a6, %acc0
mac.l %a6, %d3, (-9*4, %a0), %a6, %acc0 | load for the next iteration
movclr.l %acc0, %d2 | get sum
asr.l %d1, %d2 | shift sum by qlevel bits
add.l %d2, (%a0) | add residual and save
lea.l (-8*4, %a0), %a0 | point history back at second element
subq.l #1, %d0 | decrement sample count
jne 1b | are we done?
jra .exit
.order9:
movem.l (%a1), %d4-%d7/%a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (%a0)+, %a6, %acc0
mac.l %a6, %d6, (%a0)+, %a6, %acc0
mac.l %a6, %d5, (%a0)+, %a6, %acc0
mac.l %a6, %d4, (-8*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
lea.l (-7*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.order8:
movem.l (%a1), %d5-%d7/%a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (%a0)+, %a6, %acc0
mac.l %a6, %d6, (%a0)+, %a6, %acc0
mac.l %a6, %d5, (-7*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
lea.l (-6*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.order7:
movem.l (%a1), %d6-%d7/%a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (%a0)+, %a6, %acc0
mac.l %a6, %d6, (-6*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
lea.l (-5*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.order6:
movem.l (%a1), %d7/%a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (-5*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
lea.l (-4*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.order5:
movem.l (%a1), %a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (-4*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
lea.l (-3*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.order4:
movem.l (%a1), %a2-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (-3*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
subq.l #8, %a0
subq.l #1, %d0
jne 1b
jra .exit
.order3:
movem.l (%a1), %a3-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (-2*4, %a0), %a6, %acc0
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
subq.l #4, %a0
subq.l #1, %d0
jne 1b
jra .exit
.order2:
movem.l (%a1), %a4-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, %acc0 | data for next iteration is already loaded
movclr.l %acc0, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
subq.l #1, %d0
jne 1b
jra .exit
.order1:
| no point in using mac here
move.l (%a1), %a5
1:
move.l %a5, %d2
muls.l (%a0)+, %d2
asr.l %d1, %d2
add.l %d2, (%a0)
subq.l #1, %d0
jne 1b
jra .exit
.default:
/* we do the filtering in an unrolled by 4 loop as far as we can, and then
do the rest by jump table. */
lea.l (%a1, %d2.l*4), %a2 | need to start in the other end of coefs
move.l %a0, %a3 | working copy of history pointer
move.l %d2, %d3
lsr.l #2, %d3 | coefs/4, num of iterations needed in next loop
move.l (%a3)+, %a5 | preload data for loop
1:
lea.l (-4*4, %a2), %a2 | move lpc coef pointer four samples backwards
movem.l (%a2), %d4-%d7 | load four coefs
mac.l %a5, %d7, (%a3)+, %a5, %acc0
mac.l %a5, %d6, (%a3)+, %a5, %acc0
mac.l %a5, %d5, (%a3)+, %a5, %acc0
mac.l %a5, %d4, (%a3)+, %a5, %acc0
subq.l #1, %d3 | any more unrolled loop operations left?
jne 1b
moveq.l #3, %d3 | mask 0x00000003
and.l %d2, %d3 | get the remaining samples to be filtered
jmp.l (2, %pc, %d3*2) | then jump into mac.l chain
| jumptable:
bra.b 3f | none left
bra.b 2f | one left
bra.b 1f | two left
| three left
move.l -(%a2), %d4
mac.l %a5, %d4, (%a3)+, %a5, %acc0
1:
move.l -(%a2), %d4
mac.l %a5, %d4, (%a3)+, %a5, %acc0
2:
move.l -(%a2), %d4
mac.l %a5, %d4, (%a3)+, %a5, %acc0
3:
movclr.l %acc0, %d3 | get result
asr.l %d1, %d3 | shift qlevel bits right
add.l %a5, %d3 | add residual, which is in a5 by now
move.l %d3, -(%a3) | save, a3 is also one past save location
addq.l #4, %a0 | increment history pointer
subq.l #1, %d0 | decrement sample count
jne .default | are we done?
jra .exit | if so, fall through to exit
/* This routine deals with sample widths 24 and lower. All LPC filtering up to
order 8 is done in specially optimised unrolled loops, while every order
above this is handled by a slower default routine.
*/
.global lpc_decode_emac_wide
.align 2
lpc_decode_emac_wide:
lea.l (-44, %sp), %sp
movem.l %d2-%d7/%a2-%a6, (%sp)
movem.l (44+4, %sp), %d0-%d1/%d3/%a0-%a1
/* d0 = blocksize, d1 = qlevel, d3 = pred_order
a0 = data, a1 = coeffs
*/
/* the data pointer always lags behind history pointer by 'pred_order'
samples. since we have one loop for each order, we can hard code this
and free a register by not saving data pointer.
*/
move.l %d3, %d2
neg.l %d2
lea.l (%a0, %d2.l*4), %a0 | history
clr.l %d2
move.l %d2, %macsr | we'll need integer mode for this
tst.l %d0
jeq .exit | zero samples to process, exit
moveq.l #32, %d2
sub.l %d1, %d2 | calculate shift amount for extension byte
moveq.l #8, %d4
cmp.l %d4, %d3
jgt .wdefault | order is over 8, jump to default case
jmp.l (2, %pc, %d3.l*4) | jump to loop corresponding to pred_order
| jumptable:
bra.w .exit | zero order filter isn't possible, exit function
bra.w .worder1
bra.w .worder2
bra.w .worder3
bra.w .worder4
bra.w .worder5
bra.w .worder6
bra.w .worder7
| last jump table entry coincides with target, so leave it out
.worder8:
movem.l (%a1), %d5-%d7/%a1-%a5 | load lpc coefs
move.l (%a0)+, %a6 | load first history sample
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (%a0)+, %a6, %acc0
mac.l %a6, %d6, (%a0)+, %a6, %acc0
mac.l %a6, %d5, (-7*4, %a0), %a6, %acc0 | load for the next iteration
move.l %accext01, %d4 | get top 8 bits of sum
movclr.l %acc0, %d3 | then botten 32 bits
lsr.l %d1, %d3 | shift bottom bits qlevel bits right
asl.l %d2, %d4 | shift top bits 32 - qlevel bits left
or.l %d4, %d3 | now combine results
add.l %d3, (%a0) | add residual and save
lea.l (-6*4, %a0), %a0 | point history back at second element
subq.l #1, %d0 | decrement sample count
jne 1b | are we done?
jra .exit
.worder7:
movem.l (%a1), %d6-%d7/%a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (%a0)+, %a6, %acc0
mac.l %a6, %d6, (-6*4, %a0), %a6, %acc0
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %d3, (%a0)
lea.l (-5*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.worder6:
movem.l (%a1), %d7/%a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (%a0)+, %a6, %acc0
mac.l %a6, %d7, (-5*4, %a0), %a6, %acc0
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %d3, (%a0)
lea.l (-4*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.worder5:
movem.l (%a1), %a1-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (%a0)+, %a6, %acc0
mac.l %a6, %a1, (-4*4, %a0), %a6, %acc0
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %d3, (%a0)
lea.l (-3*4, %a0), %a0
subq.l #1, %d0
jne 1b
jra .exit
.worder4:
movem.l (%a1), %a2-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (%a0)+, %a6, %acc0
mac.l %a6, %a2, (-3*4, %a0), %a6, %acc0
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %d3, (%a0)
subq.l #8, %a0
subq.l #1, %d0
jne 1b
jra .exit
.worder3:
movem.l (%a1), %a3-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, (%a0)+, %a6, %acc0
mac.l %a6, %a3, (-2*4, %a0), %a6, %acc0
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %d3, (%a0)
subq.l #4, %a0
subq.l #1, %d0
jne 1b
jra .exit
.worder2:
movem.l (%a1), %a4-%a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0)+, %a6, %acc0
mac.l %a6, %a4, %acc0 | data for next iteration is already loaded
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %d3, (%a0)
subq.l #1, %d0
jne 1b
jra .exit
.worder1:
move.l (%a1), %a5
move.l (%a0)+, %a6
1:
mac.l %a6, %a5, (%a0), %a6, %acc0
move.l %accext01, %d4
movclr.l %acc0, %d3
lsr.l %d1, %d3
asl.l %d2, %d4
or.l %d4, %d3
add.l %a6, %d3 | residual is already in a6
move.l %d3, (%a0)+
subq.l #1, %d0
jne 1b
jra .exit
.wdefault:
/* we do the filtering in an unrolled by 4 loop as far as we can, and then
do the rest by jump table. */
lea.l (%a1, %d3.l*4), %a2 | need to start in the other end of coefs
move.l %a0, %a3 | working copy of history pointer
move.l %d3, %d4
lsr.l #2, %d4 | coefs/4, num of iterations needed in next loop
move.l (%a3)+, %a5 | preload data for loop
1:
lea.l (-4*4, %a2), %a2 | move lpc coef pointer four samples backwards
movem.l (%a2), %d5-%d7/%a4 | load four coefs
mac.l %a5, %a4, (%a3)+, %a5, %acc0
mac.l %a5, %d7, (%a3)+, %a5, %acc0
mac.l %a5, %d6, (%a3)+, %a5, %acc0
mac.l %a5, %d5, (%a3)+, %a5, %acc0
subq.l #1, %d4 | any more unrolled loop operations left?
jne 1b
moveq.l #3, %d4 | mask 0x00000003
and.l %d3, %d4 | get the remaining samples to be filtered
jmp.l (2, %pc, %d4*2) | then jump into mac.l chain
| jumptable:
bra.b 3f | none left
bra.b 2f | one left
bra.b 1f | two left
| three left
move.l -(%a2), %d4
mac.l %a5, %d4, (%a3)+, %a5, %acc0
1:
move.l -(%a2), %d4
mac.l %a5, %d4, (%a3)+, %a5, %acc0
2:
move.l -(%a2), %d4
mac.l %a5, %d4, (%a3)+, %a5, %acc0
3:
move.l %accext01, %d5 | get high 32 bits of result
movclr.l %acc0, %d4 | get low 32 bits of result
lsr.l %d1, %d4 | shift qlevel bits right
asl.l %d2, %d5 | shift 32 - qlevel bits left
or.l %d5, %d4 | combine top and low bits after shift
add.l %a5, %d4 | add residual, which is in a5 by now
move.l %d4, -(%a3) | save, a3 is also one past save location
addq.l #4, %a0 | increment history pointer
subq.l #1, %d0 | decrement sample count
jne .wdefault | are we done?
| if so, fall through to exit
.exit:
movem.l (%sp), %d2-%d7/%a2-%a6
lea.l (44, %sp), %sp
rts
Reference in a new issue View git blame Copy permalink