[deb_ffmpeg.git] / ffmpeg / libavcodec / arm / dcadsp_vfp.S

/*
 * Copyright (c) 2013 RISC OS Open Ltd
 * Author: Ben Avison <bavison@riscosopen.org>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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.
 *
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/arm/asm.S"

POUT          .req    a1
PIN           .req    a2
PCOEF         .req    a3
OLDFPSCR      .req    a4
COUNTER       .req    ip

IN0           .req    s4
IN1           .req    s5
IN2           .req    s6
IN3           .req    s7
IN4           .req    s0
IN5           .req    s1
IN6           .req    s2
IN7           .req    s3
COEF0         .req    s8   @ coefficient elements
COEF1         .req    s9
COEF2         .req    s10
COEF3         .req    s11
COEF4         .req    s12
COEF5         .req    s13
COEF6         .req    s14
COEF7         .req    s15
ACCUM0        .req    s16  @ double-buffered multiply-accumulate results
ACCUM4        .req    s20
POST0         .req    s24  @ do long-latency post-multiply in this vector in parallel
POST1         .req    s25
POST2         .req    s26
POST3         .req    s27


.macro inner_loop  decifactor, dir, tail, head
 .ifc "\dir","up"
  .set X, 0
  .set Y, 4
 .else
  .set X, 4*JMAX*4 - 4
  .set Y, -4
 .endif
 .ifnc "\head",""
        vldr    COEF0, [PCOEF, #X + (0*JMAX + 0) * Y]
        vldr    COEF1, [PCOEF, #X + (1*JMAX + 0) * Y]
        vldr    COEF2, [PCOEF, #X + (2*JMAX + 0) * Y]
        vldr    COEF3, [PCOEF, #X + (3*JMAX + 0) * Y]
 .endif
 .ifnc "\tail",""
        vadd.f  POST0, ACCUM0, ACCUM4   @ vector operation
 .endif
 .ifnc "\head",""
        vmul.f  ACCUM0, COEF0, IN0      @ vector = vector * scalar
        vldr    COEF4, [PCOEF, #X + (0*JMAX + 1) * Y]
        vldr    COEF5, [PCOEF, #X + (1*JMAX + 1) * Y]
        vldr    COEF6, [PCOEF, #X + (2*JMAX + 1) * Y]
 .endif
 .ifnc "\head",""
        vldr    COEF7, [PCOEF, #X + (3*JMAX + 1) * Y]
   .ifc "\tail",""
        vmul.f  ACCUM4, COEF4, IN1      @ vector operation
   .endif
        vldr    COEF0, [PCOEF, #X + (0*JMAX + 2) * Y]
        vldr    COEF1, [PCOEF, #X + (1*JMAX + 2) * Y]
   .ifnc "\tail",""
        vmul.f  ACCUM4, COEF4, IN1      @ vector operation
   .endif
        vldr    COEF2, [PCOEF, #X + (2*JMAX + 2) * Y]
        vldr    COEF3, [PCOEF, #X + (3*JMAX + 2) * Y]
 .endif
 .ifnc "\tail",""
        vstmia  POUT!, {POST0-POST3}
 .endif
 .ifnc "\head",""
        vmla.f  ACCUM0, COEF0, IN2      @ vector = vector * scalar
        vldr    COEF4, [PCOEF, #X + (0*JMAX + 3) * Y]
        vldr    COEF5, [PCOEF, #X + (1*JMAX + 3) * Y]
        vldr    COEF6, [PCOEF, #X + (2*JMAX + 3) * Y]
        vldr    COEF7, [PCOEF, #X + (3*JMAX + 3) * Y]
        vmla.f  ACCUM4, COEF4, IN3      @ vector = vector * scalar
  .if \decifactor == 32
        vldr    COEF0, [PCOEF, #X + (0*JMAX + 4) * Y]
        vldr    COEF1, [PCOEF, #X + (1*JMAX + 4) * Y]
        vldr    COEF2, [PCOEF, #X + (2*JMAX + 4) * Y]
        vldr    COEF3, [PCOEF, #X + (3*JMAX + 4) * Y]
        vmla.f  ACCUM0, COEF0, IN4      @ vector = vector * scalar
        vldr    COEF4, [PCOEF, #X + (0*JMAX + 5) * Y]
        vldr    COEF5, [PCOEF, #X + (1*JMAX + 5) * Y]
        vldr    COEF6, [PCOEF, #X + (2*JMAX + 5) * Y]
        vldr    COEF7, [PCOEF, #X + (3*JMAX + 5) * Y]
        vmla.f  ACCUM4, COEF4, IN5      @ vector = vector * scalar
        vldr    COEF0, [PCOEF, #X + (0*JMAX + 6) * Y]
        vldr    COEF1, [PCOEF, #X + (1*JMAX + 6) * Y]
        vldr    COEF2, [PCOEF, #X + (2*JMAX + 6) * Y]
        vldr    COEF3, [PCOEF, #X + (3*JMAX + 6) * Y]
        vmla.f  ACCUM0, COEF0, IN6      @ vector = vector * scalar
        vldr    COEF4, [PCOEF, #X + (0*JMAX + 7) * Y]
        vldr    COEF5, [PCOEF, #X + (1*JMAX + 7) * Y]
        vldr    COEF6, [PCOEF, #X + (2*JMAX + 7) * Y]
        vldr    COEF7, [PCOEF, #X + (3*JMAX + 7) * Y]
        vmla.f  ACCUM4, COEF4, IN7      @ vector = vector * scalar
  .endif
 .endif
.endm

.macro dca_lfe_fir  decifactor
function ff_dca_lfe_fir\decifactor\()_vfp, export=1
        fmrx    OLDFPSCR, FPSCR
        ldr     ip, =0x03030000         @ RunFast mode, short vectors of length 4, stride 1
        fmxr    FPSCR, ip
        vldr    IN0, [PIN, #-0*4]
        vldr    IN1, [PIN, #-1*4]
        vldr    IN2, [PIN, #-2*4]
        vldr    IN3, [PIN, #-3*4]
 .if \decifactor == 32
  .set JMAX, 8
        vpush   {s16-s31}
        vldr    IN4, [PIN, #-4*4]
        vldr    IN5, [PIN, #-5*4]
        vldr    IN6, [PIN, #-6*4]
        vldr    IN7, [PIN, #-7*4]
 .else
  .set JMAX, 4
        vpush   {s16-s27}
 .endif

        mov     COUNTER, #\decifactor/4 - 1
        inner_loop  \decifactor, up,, head
1:      add     PCOEF, PCOEF, #4*JMAX*4
        subs    COUNTER, COUNTER, #1
        inner_loop  \decifactor, up, tail, head
        bne     1b
        inner_loop  \decifactor, up, tail

        mov     COUNTER, #\decifactor/4 - 1
        inner_loop  \decifactor, down,, head
1:      sub     PCOEF, PCOEF, #4*JMAX*4
        subs    COUNTER, COUNTER, #1
        inner_loop  \decifactor, down, tail, head
        bne     1b
        inner_loop  \decifactor, down, tail

 .if \decifactor == 32
        vpop    {s16-s31}
 .else
        vpop    {s16-s27}
 .endif
        fmxr    FPSCR, OLDFPSCR
        bx      lr
endfunc
.endm

        dca_lfe_fir  64
 .ltorg
        dca_lfe_fir  32

        .unreq  POUT
        .unreq  PIN
        .unreq  PCOEF
        .unreq  OLDFPSCR
        .unreq  COUNTER

        .unreq  IN0
        .unreq  IN1
        .unreq  IN2
        .unreq  IN3
        .unreq  IN4
        .unreq  IN5
        .unreq  IN6
        .unreq  IN7
        .unreq  COEF0
        .unreq  COEF1
        .unreq  COEF2
        .unreq  COEF3
        .unreq  COEF4
        .unreq  COEF5
        .unreq  COEF6
        .unreq  COEF7
        .unreq  ACCUM0
        .unreq  ACCUM4
        .unreq  POST0
        .unreq  POST1
        .unreq  POST2
        .unreq  POST3


IN      .req    a1
SBACT   .req    a2
OLDFPSCR .req   a3
IMDCT   .req    a4
WINDOW  .req    v1
OUT     .req    v2
BUF     .req    v3
SCALEINT .req   v4 @ only used in softfp case
COUNT   .req    v5

SCALE   .req    s0

/* Stack layout differs in softfp and hardfp cases:
 *
 * hardfp
 *      fp -> 6 arg words saved by caller
 *            a3,a4,v1-v3,v5,fp,lr on entry (a3 just to pad to 8 bytes)
 *            s16-s23 on entry
 *            align 16
 *     buf -> 8*32*4 bytes buffer
 *            s0 on entry
 *      sp -> 3 arg words for callee
 *
 * softfp
 *      fp -> 7 arg words saved by caller
 *            a4,v1-v5,fp,lr on entry
 *            s16-s23 on entry
 *            align 16
 *     buf -> 8*32*4 bytes buffer
 *      sp -> 4 arg words for callee
 */

/* void ff_dca_qmf_32_subbands_vfp(float samples_in[32][8], int sb_act,
 *                                 SynthFilterContext *synth, FFTContext *imdct,
 *                                 float (*synth_buf_ptr)[512],
 *                                 int *synth_buf_offset, float (*synth_buf2)[32],
 *                                 const float (*window)[512], float *samples_out,
 *                                 float (*raXin)[32], float scale);
 */
function ff_dca_qmf_32_subbands_vfp, export=1
VFP     push    {a3-a4,v1-v3,v5,fp,lr}
NOVFP   push    {a4,v1-v5,fp,lr}
        add     fp, sp, #8*4
        vpush   {s16-s23}
        @ The buffer pointed at by raXin isn't big enough for us to do a
        @ complete matrix transposition as we want to, so allocate an
        @ alternative buffer from the stack. Align to 4 words for speed.
        sub     BUF, sp, #8*32*4
        bic     BUF, BUF, #15
        mov     sp, BUF
        ldr     lr, =0x03330000     @ RunFast mode, short vectors of length 4, stride 2
        fmrx    OLDFPSCR, FPSCR
        fmxr    FPSCR, lr
        @ COUNT is used to count down 2 things at once:
        @ bits 0-4 are the number of word pairs remaining in the output row
        @ bits 5-31 are the number of words to copy (with possible negation)
        @   from the source matrix before we start zeroing the remainder
        mov     COUNT, #(-4 << 5) + 16
        adds    COUNT, COUNT, SBACT, lsl #5
        bmi     2f
1:
        vldr    s8,  [IN, #(0*8+0)*4]
        vldr    s10, [IN, #(0*8+1)*4]
        vldr    s12, [IN, #(0*8+2)*4]
        vldr    s14, [IN, #(0*8+3)*4]
        vldr    s16, [IN, #(0*8+4)*4]
        vldr    s18, [IN, #(0*8+5)*4]
        vldr    s20, [IN, #(0*8+6)*4]
        vldr    s22, [IN, #(0*8+7)*4]
        vneg.f  s8, s8
        vldr    s9,  [IN, #(1*8+0)*4]
        vldr    s11, [IN, #(1*8+1)*4]
        vldr    s13, [IN, #(1*8+2)*4]
        vldr    s15, [IN, #(1*8+3)*4]
        vneg.f  s16, s16
        vldr    s17, [IN, #(1*8+4)*4]
        vldr    s19, [IN, #(1*8+5)*4]
        vldr    s21, [IN, #(1*8+6)*4]
        vldr    s23, [IN, #(1*8+7)*4]
        vstr    d4,  [BUF, #(0*32+0)*4]
        vstr    d5,  [BUF, #(1*32+0)*4]
        vstr    d6,  [BUF, #(2*32+0)*4]
        vstr    d7,  [BUF, #(3*32+0)*4]
        vstr    d8,  [BUF, #(4*32+0)*4]
        vstr    d9,  [BUF, #(5*32+0)*4]
        vstr    d10, [BUF, #(6*32+0)*4]
        vstr    d11, [BUF, #(7*32+0)*4]
        vldr    s9,  [IN, #(3*8+0)*4]
        vldr    s11, [IN, #(3*8+1)*4]
        vldr    s13, [IN, #(3*8+2)*4]
        vldr    s15, [IN, #(3*8+3)*4]
        vldr    s17, [IN, #(3*8+4)*4]
        vldr    s19, [IN, #(3*8+5)*4]
        vldr    s21, [IN, #(3*8+6)*4]
        vldr    s23, [IN, #(3*8+7)*4]
        vneg.f  s9, s9
        vldr    s8,  [IN, #(2*8+0)*4]
        vldr    s10, [IN, #(2*8+1)*4]
        vldr    s12, [IN, #(2*8+2)*4]
        vldr    s14, [IN, #(2*8+3)*4]
        vneg.f  s17, s17
        vldr    s16, [IN, #(2*8+4)*4]
        vldr    s18, [IN, #(2*8+5)*4]
        vldr    s20, [IN, #(2*8+6)*4]
        vldr    s22, [IN, #(2*8+7)*4]
        vstr    d4,  [BUF, #(0*32+2)*4]
        vstr    d5,  [BUF, #(1*32+2)*4]
        vstr    d6,  [BUF, #(2*32+2)*4]
        vstr    d7,  [BUF, #(3*32+2)*4]
        vstr    d8,  [BUF, #(4*32+2)*4]
        vstr    d9,  [BUF, #(5*32+2)*4]
        vstr    d10, [BUF, #(6*32+2)*4]
        vstr    d11, [BUF, #(7*32+2)*4]
        add     IN, IN, #4*8*4
        add     BUF, BUF, #4*4
        subs    COUNT, COUNT, #(4 << 5) + 2
        bpl     1b
2:      @ Now deal with trailing < 4 samples
        adds    COUNT, COUNT, #3 << 5
        bmi     4f  @ sb_act was a multiple of 4
        bics    lr, COUNT, #0x1F
        bne     3f
        @ sb_act was n*4+1
        vldr    s8,  [IN, #(0*8+0)*4]
        vldr    s10, [IN, #(0*8+1)*4]
        vldr    s12, [IN, #(0*8+2)*4]
        vldr    s14, [IN, #(0*8+3)*4]
        vldr    s16, [IN, #(0*8+4)*4]
        vldr    s18, [IN, #(0*8+5)*4]
        vldr    s20, [IN, #(0*8+6)*4]
        vldr    s22, [IN, #(0*8+7)*4]
        vneg.f  s8, s8
        vldr    s9,  zero
        vldr    s11, zero
        vldr    s13, zero
        vldr    s15, zero
        vneg.f  s16, s16
        vldr    s17, zero
        vldr    s19, zero
        vldr    s21, zero
        vldr    s23, zero
        vstr    d4,  [BUF, #(0*32+0)*4]
        vstr    d5,  [BUF, #(1*32+0)*4]
        vstr    d6,  [BUF, #(2*32+0)*4]
        vstr    d7,  [BUF, #(3*32+0)*4]
        vstr    d8,  [BUF, #(4*32+0)*4]
        vstr    d9,  [BUF, #(5*32+0)*4]
        vstr    d10, [BUF, #(6*32+0)*4]
        vstr    d11, [BUF, #(7*32+0)*4]
        add     BUF, BUF, #2*4
        sub     COUNT, COUNT, #1
        b       4f
3:      @ sb_act was n*4+2 or n*4+3, so do the first 2
        vldr    s8,  [IN, #(0*8+0)*4]
        vldr    s10, [IN, #(0*8+1)*4]
        vldr    s12, [IN, #(0*8+2)*4]
        vldr    s14, [IN, #(0*8+3)*4]
        vldr    s16, [IN, #(0*8+4)*4]
        vldr    s18, [IN, #(0*8+5)*4]
        vldr    s20, [IN, #(0*8+6)*4]
        vldr    s22, [IN, #(0*8+7)*4]
        vneg.f  s8, s8
        vldr    s9,  [IN, #(1*8+0)*4]
        vldr    s11, [IN, #(1*8+1)*4]
        vldr    s13, [IN, #(1*8+2)*4]
        vldr    s15, [IN, #(1*8+3)*4]
        vneg.f  s16, s16
        vldr    s17, [IN, #(1*8+4)*4]
        vldr    s19, [IN, #(1*8+5)*4]
        vldr    s21, [IN, #(1*8+6)*4]
        vldr    s23, [IN, #(1*8+7)*4]
        vstr    d4,  [BUF, #(0*32+0)*4]
        vstr    d5,  [BUF, #(1*32+0)*4]
        vstr    d6,  [BUF, #(2*32+0)*4]
        vstr    d7,  [BUF, #(3*32+0)*4]
        vstr    d8,  [BUF, #(4*32+0)*4]
        vstr    d9,  [BUF, #(5*32+0)*4]
        vstr    d10, [BUF, #(6*32+0)*4]
        vstr    d11, [BUF, #(7*32+0)*4]
        add     BUF, BUF, #2*4
        sub     COUNT, COUNT, #(2 << 5) + 1
        bics    lr, COUNT, #0x1F
        bne     4f
        @ sb_act was n*4+3
        vldr    s8,  [IN, #(2*8+0)*4]
        vldr    s10, [IN, #(2*8+1)*4]
        vldr    s12, [IN, #(2*8+2)*4]
        vldr    s14, [IN, #(2*8+3)*4]
        vldr    s16, [IN, #(2*8+4)*4]
        vldr    s18, [IN, #(2*8+5)*4]
        vldr    s20, [IN, #(2*8+6)*4]
        vldr    s22, [IN, #(2*8+7)*4]
        vldr    s9,  zero
        vldr    s11, zero
        vldr    s13, zero
        vldr    s15, zero
        vldr    s17, zero
        vldr    s19, zero
        vldr    s21, zero
        vldr    s23, zero
        vstr    d4,  [BUF, #(0*32+0)*4]
        vstr    d5,  [BUF, #(1*32+0)*4]
        vstr    d6,  [BUF, #(2*32+0)*4]
        vstr    d7,  [BUF, #(3*32+0)*4]
        vstr    d8,  [BUF, #(4*32+0)*4]
        vstr    d9,  [BUF, #(5*32+0)*4]
        vstr    d10, [BUF, #(6*32+0)*4]
        vstr    d11, [BUF, #(7*32+0)*4]
        add     BUF, BUF, #2*4
        sub     COUNT, COUNT, #1
4:      @ Now fill the remainder with 0
        vldr    s8, zero
        vldr    s9, zero
        ands    COUNT, COUNT, #0x1F
        beq     6f
5:      vstr    d4, [BUF, #(0*32+0)*4]
        vstr    d4, [BUF, #(1*32+0)*4]
        vstr    d4, [BUF, #(2*32+0)*4]
        vstr    d4, [BUF, #(3*32+0)*4]
        vstr    d4, [BUF, #(4*32+0)*4]
        vstr    d4, [BUF, #(5*32+0)*4]
        vstr    d4, [BUF, #(6*32+0)*4]
        vstr    d4, [BUF, #(7*32+0)*4]
        add     BUF, BUF, #2*4
        subs    COUNT, COUNT, #1
        bne     5b
6:
        fmxr    FPSCR, OLDFPSCR
        ldr     WINDOW, [fp, #3*4]
        ldr     OUT, [fp, #4*4]
        sub     BUF, BUF, #32*4
NOVFP   ldr     SCALEINT, [fp, #6*4]
        mov     COUNT, #8
VFP     vpush   {SCALE}
VFP     sub     sp, sp, #3*4
NOVFP   sub     sp, sp, #4*4
7:
VFP     ldr     a1, [fp, #-7*4]     @ imdct
NOVFP   ldr     a1, [fp, #-8*4]
        ldmia   fp, {a2-a4}
VFP     stmia   sp, {WINDOW, OUT, BUF}
NOVFP   stmia   sp, {WINDOW, OUT, BUF, SCALEINT}
VFP     vldr    SCALE, [sp, #3*4]
        bl      X(ff_synth_filter_float_vfp)
        add     OUT, OUT, #32*4
        add     BUF, BUF, #32*4
        subs    COUNT, COUNT, #1
        bne     7b

A       sub     sp, fp, #(8+8)*4
T       sub     fp, fp, #(8+8)*4
T       mov     sp, fp
        vpop    {s16-s23}
VFP     pop     {a3-a4,v1-v3,v5,fp,pc}
NOVFP   pop     {a4,v1-v5,fp,pc}
endfunc

        .unreq  IN
        .unreq  SBACT
        .unreq  OLDFPSCR
        .unreq  IMDCT
        .unreq  WINDOW
        .unreq  OUT
        .unreq  BUF
        .unreq  SCALEINT
        .unreq  COUNT

        .unreq  SCALE

        .align 2
zero:   .word   0
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2013 RISC OS Open Ltd
	3	* Author: Ben Avison <bavison@riscosopen.org>
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include "libavutil/arm/asm.S"
	23
	24	POUT .req a1
	25	PIN .req a2
	26	PCOEF .req a3
	27	OLDFPSCR .req a4
	28	COUNTER .req ip
	29
	30	IN0 .req s4
	31	IN1 .req s5
	32	IN2 .req s6
	33	IN3 .req s7
	34	IN4 .req s0
	35	IN5 .req s1
	36	IN6 .req s2
	37	IN7 .req s3
	38	COEF0 .req s8 @ coefficient elements
	39	COEF1 .req s9
	40	COEF2 .req s10
	41	COEF3 .req s11
	42	COEF4 .req s12
	43	COEF5 .req s13
	44	COEF6 .req s14
	45	COEF7 .req s15
	46	ACCUM0 .req s16 @ double-buffered multiply-accumulate results
	47	ACCUM4 .req s20
	48	POST0 .req s24 @ do long-latency post-multiply in this vector in parallel
	49	POST1 .req s25
	50	POST2 .req s26
	51	POST3 .req s27
	52
	53
	54	.macro inner_loop decifactor, dir, tail, head
	55	.ifc "\dir","up"
	56	.set X, 0
	57	.set Y, 4
	58	.else
	59	.set X, 4JMAX4 - 4
	60	.set Y, -4
	61	.endif
	62	.ifnc "\head",""
	63	vldr COEF0, [PCOEF, #X + (0JMAX + 0) Y]
	64	vldr COEF1, [PCOEF, #X + (1JMAX + 0) Y]
65	vldr COEF2, [PCOEF, #X + (2JMAX + 0) Y]
66	vldr COEF3, [PCOEF, #X + (3JMAX + 0) Y]
67	.endif
68	.ifnc "\tail",""
69	vadd.f POST0, ACCUM0, ACCUM4 @ vector operation
70	.endif
71	.ifnc "\head",""
72	vmul.f ACCUM0, COEF0, IN0 @ vector = vector * scalar
73	vldr COEF4, [PCOEF, #X + (0JMAX + 1) Y]
74	vldr COEF5, [PCOEF, #X + (1JMAX + 1) Y]
75	vldr COEF6, [PCOEF, #X + (2JMAX + 1) Y]
76	.endif
77	.ifnc "\head",""
78	vldr COEF7, [PCOEF, #X + (3JMAX + 1) Y]
79	.ifc "\tail",""
80	vmul.f ACCUM4, COEF4, IN1 @ vector operation
81	.endif
82	vldr COEF0, [PCOEF, #X + (0JMAX + 2) Y]
83	vldr COEF1, [PCOEF, #X + (1JMAX + 2) Y]
84	.ifnc "\tail",""
85	vmul.f ACCUM4, COEF4, IN1 @ vector operation
86	.endif
87	vldr COEF2, [PCOEF, #X + (2JMAX + 2) Y]
88	vldr COEF3, [PCOEF, #X + (3JMAX + 2) Y]
89	.endif
90	.ifnc "\tail",""
91	vstmia POUT!, {POST0-POST3}
92	.endif
93	.ifnc "\head",""
94	vmla.f ACCUM0, COEF0, IN2 @ vector = vector * scalar
95	vldr COEF4, [PCOEF, #X + (0JMAX + 3) Y]
96	vldr COEF5, [PCOEF, #X + (1JMAX + 3) Y]
97	vldr COEF6, [PCOEF, #X + (2JMAX + 3) Y]
98	vldr COEF7, [PCOEF, #X + (3JMAX + 3) Y]
99	vmla.f ACCUM4, COEF4, IN3 @ vector = vector * scalar
100	.if \decifactor == 32
101	vldr COEF0, [PCOEF, #X + (0JMAX + 4) Y]
102	vldr COEF1, [PCOEF, #X + (1JMAX + 4) Y]
103	vldr COEF2, [PCOEF, #X + (2JMAX + 4) Y]
104	vldr COEF3, [PCOEF, #X + (3JMAX + 4) Y]
105	vmla.f ACCUM0, COEF0, IN4 @ vector = vector * scalar
106	vldr COEF4, [PCOEF, #X + (0JMAX + 5) Y]
107	vldr COEF5, [PCOEF, #X + (1JMAX + 5) Y]
108	vldr COEF6, [PCOEF, #X + (2JMAX + 5) Y]
109	vldr COEF7, [PCOEF, #X + (3JMAX + 5) Y]
110	vmla.f ACCUM4, COEF4, IN5 @ vector = vector * scalar
111	vldr COEF0, [PCOEF, #X + (0JMAX + 6) Y]
112	vldr COEF1, [PCOEF, #X + (1JMAX + 6) Y]
113	vldr COEF2, [PCOEF, #X + (2JMAX + 6) Y]
114	vldr COEF3, [PCOEF, #X + (3JMAX + 6) Y]
115	vmla.f ACCUM0, COEF0, IN6 @ vector = vector * scalar
116	vldr COEF4, [PCOEF, #X + (0JMAX + 7) Y]
117	vldr COEF5, [PCOEF, #X + (1JMAX + 7) Y]
118	vldr COEF6, [PCOEF, #X + (2JMAX + 7) Y]
119	vldr COEF7, [PCOEF, #X + (3JMAX + 7) Y]
120	vmla.f ACCUM4, COEF4, IN7 @ vector = vector * scalar
121	.endif
122	.endif
123	.endm
124
125	.macro dca_lfe_fir decifactor
126	function ff_dca_lfe_fir\decifactor\()_vfp, export=1
127	fmrx OLDFPSCR, FPSCR
128	ldr ip, =0x03030000 @ RunFast mode, short vectors of length 4, stride 1
129	fmxr FPSCR, ip
130	vldr IN0, [PIN, #-0*4]
131	vldr IN1, [PIN, #-1*4]
132	vldr IN2, [PIN, #-2*4]
133	vldr IN3, [PIN, #-3*4]
134	.if \decifactor == 32
135	.set JMAX, 8
136	vpush {s16-s31}
137	vldr IN4, [PIN, #-4*4]
138	vldr IN5, [PIN, #-5*4]
139	vldr IN6, [PIN, #-6*4]
140	vldr IN7, [PIN, #-7*4]
141	.else
142	.set JMAX, 4
143	vpush {s16-s27}
144	.endif
145
146	mov COUNTER, #\decifactor/4 - 1
147	inner_loop \decifactor, up,, head
148	1: add PCOEF, PCOEF, #4JMAX4
149	subs COUNTER, COUNTER, #1
150	inner_loop \decifactor, up, tail, head
151	bne 1b
152	inner_loop \decifactor, up, tail
153
154	mov COUNTER, #\decifactor/4 - 1
155	inner_loop \decifactor, down,, head
156	1: sub PCOEF, PCOEF, #4JMAX4
157	subs COUNTER, COUNTER, #1
158	inner_loop \decifactor, down, tail, head
159	bne 1b
160	inner_loop \decifactor, down, tail
161
162	.if \decifactor == 32
163	vpop {s16-s31}
164	.else
165	vpop {s16-s27}
166	.endif
167	fmxr FPSCR, OLDFPSCR
168	bx lr
169	endfunc
170	.endm
171
172	dca_lfe_fir 64
173	.ltorg
174	dca_lfe_fir 32
175
176	.unreq POUT
177	.unreq PIN
178	.unreq PCOEF
179	.unreq OLDFPSCR
180	.unreq COUNTER
181
182	.unreq IN0
183	.unreq IN1
184	.unreq IN2
185	.unreq IN3
186	.unreq IN4
187	.unreq IN5
188	.unreq IN6
189	.unreq IN7
190	.unreq COEF0
191	.unreq COEF1
192	.unreq COEF2
193	.unreq COEF3
194	.unreq COEF4
195	.unreq COEF5
196	.unreq COEF6
197	.unreq COEF7
198	.unreq ACCUM0
199	.unreq ACCUM4
200	.unreq POST0
201	.unreq POST1
202	.unreq POST2
203	.unreq POST3
204
205
206	IN .req a1
207	SBACT .req a2
208	OLDFPSCR .req a3
209	IMDCT .req a4
210	WINDOW .req v1
211	OUT .req v2
212	BUF .req v3
213	SCALEINT .req v4 @ only used in softfp case
214	COUNT .req v5
215
216	SCALE .req s0
217
218	/* Stack layout differs in softfp and hardfp cases:
219	*
220	* hardfp
221	* fp -> 6 arg words saved by caller
222	* a3,a4,v1-v3,v5,fp,lr on entry (a3 just to pad to 8 bytes)
223	* s16-s23 on entry
224	* align 16
225	* buf -> 8324 bytes buffer
226	* s0 on entry
227	* sp -> 3 arg words for callee
228	*
229	* softfp
230	* fp -> 7 arg words saved by caller
231	* a4,v1-v5,fp,lr on entry
232	* s16-s23 on entry
233	* align 16
234	* buf -> 8324 bytes buffer
235	* sp -> 4 arg words for callee
236	*/
237
238	/* void ff_dca_qmf_32_subbands_vfp(float samples_in[32][8], int sb_act,
239	* SynthFilterContext synth, FFTContext imdct,
240	* float (*synth_buf_ptr)[512],
241	* int synth_buf_offset, float (synth_buf2)[32],
242	* const float (window)[512], float samples_out,
243	* float (*raXin)[32], float scale);
244	*/
245	function ff_dca_qmf_32_subbands_vfp, export=1
246	VFP push {a3-a4,v1-v3,v5,fp,lr}
247	NOVFP push {a4,v1-v5,fp,lr}
248	add fp, sp, #8*4
249	vpush {s16-s23}
250	@ The buffer pointed at by raXin isn't big enough for us to do a
251	@ complete matrix transposition as we want to, so allocate an
252	@ alternative buffer from the stack. Align to 4 words for speed.
253	sub BUF, sp, #8324
254	bic BUF, BUF, #15
255	mov sp, BUF
256	ldr lr, =0x03330000 @ RunFast mode, short vectors of length 4, stride 2
257	fmrx OLDFPSCR, FPSCR
258	fmxr FPSCR, lr
259	@ COUNT is used to count down 2 things at once:
260	@ bits 0-4 are the number of word pairs remaining in the output row
261	@ bits 5-31 are the number of words to copy (with possible negation)
262	@ from the source matrix before we start zeroing the remainder
263	mov COUNT, #(-4 << 5) + 16
264	adds COUNT, COUNT, SBACT, lsl #5
265	bmi 2f
266	1:
267	vldr s8, [IN, #(08+0)4]
268	vldr s10, [IN, #(08+1)4]
269	vldr s12, [IN, #(08+2)4]
270	vldr s14, [IN, #(08+3)4]
271	vldr s16, [IN, #(08+4)4]
272	vldr s18, [IN, #(08+5)4]
273	vldr s20, [IN, #(08+6)4]
274	vldr s22, [IN, #(08+7)4]
275	vneg.f s8, s8
276	vldr s9, [IN, #(18+0)4]
277	vldr s11, [IN, #(18+1)4]
278	vldr s13, [IN, #(18+2)4]
279	vldr s15, [IN, #(18+3)4]
280	vneg.f s16, s16
281	vldr s17, [IN, #(18+4)4]
282	vldr s19, [IN, #(18+5)4]
283	vldr s21, [IN, #(18+6)4]
284	vldr s23, [IN, #(18+7)4]
285	vstr d4, [BUF, #(032+0)4]
286	vstr d5, [BUF, #(132+0)4]
287	vstr d6, [BUF, #(232+0)4]
288	vstr d7, [BUF, #(332+0)4]
289	vstr d8, [BUF, #(432+0)4]
290	vstr d9, [BUF, #(532+0)4]
291	vstr d10, [BUF, #(632+0)4]
292	vstr d11, [BUF, #(732+0)4]
293	vldr s9, [IN, #(38+0)4]
294	vldr s11, [IN, #(38+1)4]
295	vldr s13, [IN, #(38+2)4]
296	vldr s15, [IN, #(38+3)4]
297	vldr s17, [IN, #(38+4)4]
298	vldr s19, [IN, #(38+5)4]
299	vldr s21, [IN, #(38+6)4]
300	vldr s23, [IN, #(38+7)4]
301	vneg.f s9, s9
302	vldr s8, [IN, #(28+0)4]
303	vldr s10, [IN, #(28+1)4]
304	vldr s12, [IN, #(28+2)4]
305	vldr s14, [IN, #(28+3)4]
306	vneg.f s17, s17
307	vldr s16, [IN, #(28+4)4]
308	vldr s18, [IN, #(28+5)4]
309	vldr s20, [IN, #(28+6)4]
310	vldr s22, [IN, #(28+7)4]
311	vstr d4, [BUF, #(032+2)4]
312	vstr d5, [BUF, #(132+2)4]
313	vstr d6, [BUF, #(232+2)4]
314	vstr d7, [BUF, #(332+2)4]
315	vstr d8, [BUF, #(432+2)4]
316	vstr d9, [BUF, #(532+2)4]
317	vstr d10, [BUF, #(632+2)4]
318	vstr d11, [BUF, #(732+2)4]
319	add IN, IN, #484
320	add BUF, BUF, #4*4
321	subs COUNT, COUNT, #(4 << 5) + 2
322	bpl 1b
323	2: @ Now deal with trailing < 4 samples
324	adds COUNT, COUNT, #3 << 5
325	bmi 4f @ sb_act was a multiple of 4
326	bics lr, COUNT, #0x1F
327	bne 3f
328	@ sb_act was n*4+1
329	vldr s8, [IN, #(08+0)4]
330	vldr s10, [IN, #(08+1)4]
331	vldr s12, [IN, #(08+2)4]
332	vldr s14, [IN, #(08+3)4]
333	vldr s16, [IN, #(08+4)4]
334	vldr s18, [IN, #(08+5)4]
335	vldr s20, [IN, #(08+6)4]
336	vldr s22, [IN, #(08+7)4]
337	vneg.f s8, s8
338	vldr s9, zero
339	vldr s11, zero
340	vldr s13, zero
341	vldr s15, zero
342	vneg.f s16, s16
343	vldr s17, zero
344	vldr s19, zero
345	vldr s21, zero
346	vldr s23, zero
347	vstr d4, [BUF, #(032+0)4]
348	vstr d5, [BUF, #(132+0)4]
349	vstr d6, [BUF, #(232+0)4]
350	vstr d7, [BUF, #(332+0)4]
351	vstr d8, [BUF, #(432+0)4]
352	vstr d9, [BUF, #(532+0)4]
353	vstr d10, [BUF, #(632+0)4]
354	vstr d11, [BUF, #(732+0)4]
355	add BUF, BUF, #2*4
356	sub COUNT, COUNT, #1
357	b 4f
358	3: @ sb_act was n4+2 or n4+3, so do the first 2
359	vldr s8, [IN, #(08+0)4]
360	vldr s10, [IN, #(08+1)4]
361	vldr s12, [IN, #(08+2)4]
362	vldr s14, [IN, #(08+3)4]
363	vldr s16, [IN, #(08+4)4]
364	vldr s18, [IN, #(08+5)4]
365	vldr s20, [IN, #(08+6)4]
366	vldr s22, [IN, #(08+7)4]
367	vneg.f s8, s8
368	vldr s9, [IN, #(18+0)4]
369	vldr s11, [IN, #(18+1)4]
370	vldr s13, [IN, #(18+2)4]
371	vldr s15, [IN, #(18+3)4]
372	vneg.f s16, s16
373	vldr s17, [IN, #(18+4)4]
374	vldr s19, [IN, #(18+5)4]
375	vldr s21, [IN, #(18+6)4]
376	vldr s23, [IN, #(18+7)4]
377	vstr d4, [BUF, #(032+0)4]
378	vstr d5, [BUF, #(132+0)4]
379	vstr d6, [BUF, #(232+0)4]
380	vstr d7, [BUF, #(332+0)4]
381	vstr d8, [BUF, #(432+0)4]
382	vstr d9, [BUF, #(532+0)4]
383	vstr d10, [BUF, #(632+0)4]
384	vstr d11, [BUF, #(732+0)4]
385	add BUF, BUF, #2*4
386	sub COUNT, COUNT, #(2 << 5) + 1
387	bics lr, COUNT, #0x1F
388	bne 4f
389	@ sb_act was n*4+3
390	vldr s8, [IN, #(28+0)4]
391	vldr s10, [IN, #(28+1)4]
392	vldr s12, [IN, #(28+2)4]
393	vldr s14, [IN, #(28+3)4]
394	vldr s16, [IN, #(28+4)4]
395	vldr s18, [IN, #(28+5)4]
396	vldr s20, [IN, #(28+6)4]
397	vldr s22, [IN, #(28+7)4]
398	vldr s9, zero
399	vldr s11, zero
400	vldr s13, zero
401	vldr s15, zero
402	vldr s17, zero
403	vldr s19, zero
404	vldr s21, zero
405	vldr s23, zero
406	vstr d4, [BUF, #(032+0)4]
407	vstr d5, [BUF, #(132+0)4]
408	vstr d6, [BUF, #(232+0)4]
409	vstr d7, [BUF, #(332+0)4]
410	vstr d8, [BUF, #(432+0)4]
411	vstr d9, [BUF, #(532+0)4]
412	vstr d10, [BUF, #(632+0)4]
413	vstr d11, [BUF, #(732+0)4]
414	add BUF, BUF, #2*4
415	sub COUNT, COUNT, #1
416	4: @ Now fill the remainder with 0
417	vldr s8, zero
418	vldr s9, zero
419	ands COUNT, COUNT, #0x1F
420	beq 6f
421	5: vstr d4, [BUF, #(032+0)4]
422	vstr d4, [BUF, #(132+0)4]
423	vstr d4, [BUF, #(232+0)4]
424	vstr d4, [BUF, #(332+0)4]
425	vstr d4, [BUF, #(432+0)4]
426	vstr d4, [BUF, #(532+0)4]
427	vstr d4, [BUF, #(632+0)4]
428	vstr d4, [BUF, #(732+0)4]
429	add BUF, BUF, #2*4
430	subs COUNT, COUNT, #1
431	bne 5b
432	6:
433	fmxr FPSCR, OLDFPSCR
434	ldr WINDOW, [fp, #3*4]
435	ldr OUT, [fp, #4*4]
436	sub BUF, BUF, #32*4
437	NOVFP ldr SCALEINT, [fp, #6*4]
438	mov COUNT, #8
439	VFP vpush {SCALE}
440	VFP sub sp, sp, #3*4
441	NOVFP sub sp, sp, #4*4
442	7:
443	VFP ldr a1, [fp, #-7*4] @ imdct
444	NOVFP ldr a1, [fp, #-8*4]
445	ldmia fp, {a2-a4}
446	VFP stmia sp, {WINDOW, OUT, BUF}
447	NOVFP stmia sp, {WINDOW, OUT, BUF, SCALEINT}
448	VFP vldr SCALE, [sp, #3*4]
449	bl X(ff_synth_filter_float_vfp)
450	add OUT, OUT, #32*4
451	add BUF, BUF, #32*4
452	subs COUNT, COUNT, #1
453	bne 7b
454
455	A sub sp, fp, #(8+8)*4
456	T sub fp, fp, #(8+8)*4
457	T mov sp, fp
458	vpop {s16-s23}
459	VFP pop {a3-a4,v1-v3,v5,fp,pc}
460	NOVFP pop {a4,v1-v5,fp,pc}
461	endfunc
462
463	.unreq IN
464	.unreq SBACT
465	.unreq OLDFPSCR
466	.unreq IMDCT
467	.unreq WINDOW
468	.unreq OUT
469	.unreq BUF
470	.unreq SCALEINT
471	.unreq COUNT
472
473	.unreq SCALE
474
475	.align 2
476	zero: .word 0