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

/*
 * Copyright (c) 2014 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"

.macro loadregoffsh2  group, index, base, offgroup, offindex
       .altmacro
       loadregoffsh2_ \group, %(\index), \base, \offgroup, %(\offindex)
       .noaltmacro
.endm

.macro loadregoffsh2_ group, index, base, offgroup, offindex
        ldr     \group\index, [\base, \offgroup\offindex, lsl #2]
.endm

.macro eorlslreg  check, data, group, index
        .altmacro
        eorlslreg_ \check, \data, \group, %(\index)
        .noaltmacro
.endm

.macro eorlslreg_ check, data, group, index
        eor     \check, \check, \data, lsl \group\index
.endm

.macro decr_modulo var, by, modulus
 .set \var, \var - \by
 .if \var == 0
  .set \var, \modulus
 .endif
.endm

 .macro load_group1  size, channels, r0, r1, r2, r3, pointer_dead=0
  .if \size == 2
        ldrd    \r0, \r1, [IN], #(\size + 8 - \channels) * 4
  .else // size == 4
   .if IDX1 > 4 || \channels==8
        ldm     IN!, {\r0, \r1, \r2, \r3}
   .else
        ldm     IN, {\r0, \r1, \r2, \r3}
    .if !\pointer_dead
        add     IN, IN, #(4 + 8 - \channels) * 4
     .endif
   .endif
  .endif
        decr_modulo IDX1, \size, \channels
 .endm

 .macro load_group2  size, channels, r0, r1, r2, r3, pointer_dead=0
  .if \size == 2
   .if IDX1 > 2
        ldm     IN!, {\r2, \r3}
   .else
//A   .ifc \r2, ip
//A    .if \pointer_dead
//A       ldm     IN, {\r2, \r3}
//A    .else
//A       ldr     \r2, [IN], #4
//A       ldr     \r3, [IN], #(\size - 1 + 8 - \channels) * 4
//A    .endif
//A   .else
        ldrd    \r2, \r3, [IN], #(\size + 8 - \channels) * 4
//A   .endif
   .endif
  .endif
        decr_modulo IDX1, \size, \channels
 .endm

.macro implement_pack  inorder, channels, shift
.if \inorder
.ifc \shift, mixed

CHECK   .req    a1
COUNT   .req    a2
IN      .req    a3
OUT     .req    a4
DAT0    .req    v1
DAT1    .req    v2
DAT2    .req    v3
DAT3    .req    v4
SHIFT0  .req    v5
SHIFT1  .req    v6
SHIFT2  .req    sl
SHIFT3  .req    fp
SHIFT4  .req    ip
SHIFT5  .req    lr

 .macro output4words
  .set SIZE_GROUP1, IDX1
  .if SIZE_GROUP1 > 4
   .set SIZE_GROUP1, 4
  .endif
  .set SIZE_GROUP2, 4 - SIZE_GROUP1
        load_group1  SIZE_GROUP1, \channels, DAT0, DAT1, DAT2, DAT3
        load_group2  SIZE_GROUP2, \channels, DAT0, DAT1, DAT2, DAT3
   .if \channels == 2
        lsl     DAT0, SHIFT0
        lsl     DAT1, SHIFT1
        lsl     DAT2, SHIFT0
        lsl     DAT3, SHIFT1
   .elseif \channels == 6
    .if IDX2 == 6
        lsl     DAT0, SHIFT0
        lsl     DAT1, SHIFT1
        lsl     DAT2, SHIFT2
        lsl     DAT3, SHIFT3
    .elseif IDX2 == 2
        lsl     DAT0, SHIFT4
        lsl     DAT1, SHIFT5
        lsl     DAT2, SHIFT0
        lsl     DAT3, SHIFT1
    .else // IDX2 == 4
        lsl     DAT0, SHIFT2
        lsl     DAT1, SHIFT3
        lsl     DAT2, SHIFT4
        lsl     DAT3, SHIFT5
    .endif
   .elseif \channels == 8
    .if IDX2 == 8
        uxtb    SHIFT0, SHIFT4, ror #0
        uxtb    SHIFT1, SHIFT4, ror #8
        uxtb    SHIFT2, SHIFT4, ror #16
        uxtb    SHIFT3, SHIFT4, ror #24
    .else
        uxtb    SHIFT0, SHIFT5, ror #0
        uxtb    SHIFT1, SHIFT5, ror #8
        uxtb    SHIFT2, SHIFT5, ror #16
        uxtb    SHIFT3, SHIFT5, ror #24
    .endif
        lsl     DAT0, SHIFT0
        lsl     DAT1, SHIFT1
        lsl     DAT2, SHIFT2
        lsl     DAT3, SHIFT3
   .endif
        eor     CHECK, CHECK, DAT0, lsr #8 - (\channels - IDX2)
        eor     CHECK, CHECK, DAT1, lsr #7 - (\channels - IDX2)
   decr_modulo IDX2, 2, \channels
        eor     CHECK, CHECK, DAT2, lsr #8 - (\channels - IDX2)
        eor     CHECK, CHECK, DAT3, lsr #7 - (\channels - IDX2)
   decr_modulo IDX2, 2, \channels
        stm     OUT!, {DAT0 - DAT3}
 .endm

 .set WORDS_PER_LOOP, \channels  // calculate LCM (channels, 4)
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .set WORDS_PER_LOOP, WORDS_PER_LOOP * 4
 .set SAMPLES_PER_LOOP, WORDS_PER_LOOP / \channels

function ff_mlp_pack_output_inorder_\channels\()ch_mixedshift_armv6, export=1
 .if SAMPLES_PER_LOOP > 1
        tst     COUNT, #SAMPLES_PER_LOOP - 1  // always seems to be in practice
        it      ne
        bne     X(ff_mlp_pack_output)         // but just in case, branch to C implementation if not
 .endif
        teq     COUNT, #0
        it      eq
        bxeq    lr
        push    {v1-v6,sl,fp,lr}
        ldr     SHIFT0, [sp, #(9+1)*4]  // get output_shift from stack
        ldr     SHIFT1, =0x08080808
        ldr     SHIFT4, [SHIFT0]
 .if \channels == 2
        uadd8   SHIFT4, SHIFT4, SHIFT1 // increase all shifts by 8
        uxtb    SHIFT0, SHIFT4, ror #0
        uxtb    SHIFT1, SHIFT4, ror #8
 .else
        ldr     SHIFT5, [SHIFT0, #4]
        uadd8   SHIFT4, SHIFT4, SHIFT1 // increase all shifts by 8
        uadd8   SHIFT5, SHIFT5, SHIFT1
  .if \channels == 6
        uxtb    SHIFT0, SHIFT4, ror #0
        uxtb    SHIFT1, SHIFT4, ror #8
        uxtb    SHIFT2, SHIFT4, ror #16
        uxtb    SHIFT3, SHIFT4, ror #24
        uxtb    SHIFT4, SHIFT5, ror #0
        uxtb    SHIFT5, SHIFT5, ror #8
  .endif
 .endif
 .set IDX1, \channels
 .set IDX2, \channels
0:
 .rept WORDS_PER_LOOP / 4
        output4words
 .endr
        subs    COUNT, COUNT, #SAMPLES_PER_LOOP
        bne     0b
        pop     {v1-v6,sl,fp,pc}
        .ltorg
endfunc
 .purgem output4words

        .unreq  CHECK
        .unreq  COUNT
        .unreq  IN
        .unreq  OUT
        .unreq  DAT0
        .unreq  DAT1
        .unreq  DAT2
        .unreq  DAT3
        .unreq  SHIFT0
        .unreq  SHIFT1
        .unreq  SHIFT2
        .unreq  SHIFT3
        .unreq  SHIFT4
        .unreq  SHIFT5

.else // not mixed

CHECK   .req    a1
COUNT   .req    a2
IN      .req    a3
OUT     .req    a4
DAT0    .req    v1
DAT1    .req    v2
DAT2    .req    v3
DAT3    .req    v4
DAT4    .req    v5
DAT5    .req    v6
DAT6    .req    sl // use these rather than the otherwise unused
DAT7    .req    fp // ip and lr so that we can load them usinf LDRD

 .macro output4words  tail, head, r0, r1, r2, r3, r4, r5, r6, r7, pointer_dead=0
  .if \head
   .set SIZE_GROUP1, IDX1
   .if SIZE_GROUP1 > 4
    .set SIZE_GROUP1, 4
   .endif
   .set SIZE_GROUP2, 4 - SIZE_GROUP1
        load_group1  SIZE_GROUP1, \channels, \r0, \r1, \r2, \r3, \pointer_dead
  .endif
  .if \tail
        eor     CHECK, CHECK, \r4, lsr #8 - (\channels - IDX2)
        eor     CHECK, CHECK, \r5, lsr #7 - (\channels - IDX2)
   decr_modulo IDX2, 2, \channels
  .endif
  .if \head
        load_group2  SIZE_GROUP2, \channels, \r0, \r1, \r2, \r3, \pointer_dead
  .endif
  .if \tail
        eor     CHECK, CHECK, \r6, lsr #8 - (\channels - IDX2)
        eor     CHECK, CHECK, \r7, lsr #7 - (\channels - IDX2)
   decr_modulo IDX2, 2, \channels
        stm     OUT!, {\r4, \r5, \r6, \r7}
  .endif
  .if \head
        lsl     \r0, #8 + \shift
        lsl     \r1, #8 + \shift
        lsl     \r2, #8 + \shift
        lsl     \r3, #8 + \shift
  .endif
 .endm

 .set WORDS_PER_LOOP, \channels  // calculate LCM (channels, 8)
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .set WORDS_PER_LOOP, WORDS_PER_LOOP * 8
 .set SAMPLES_PER_LOOP, WORDS_PER_LOOP / \channels

function ff_mlp_pack_output_inorder_\channels\()ch_\shift\()shift_armv6, export=1
 .if SAMPLES_PER_LOOP > 1
        tst     COUNT, #SAMPLES_PER_LOOP - 1  // always seems to be in practice
        it      ne
        bne     X(ff_mlp_pack_output)         // but just in case, branch to C implementation if not
 .endif
        subs    COUNT, COUNT, #SAMPLES_PER_LOOP
        it      lo
        bxlo    lr
        push    {v1-v6,sl,fp,lr}
 .set IDX1, \channels
 .set IDX2, \channels
        output4words  0, 1, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
0:      beq     1f
 .rept WORDS_PER_LOOP / 8
        output4words  1, 1, DAT4, DAT5, DAT6, DAT7, DAT0, DAT1, DAT2, DAT3
        output4words  1, 1, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
 .endr
        subs    COUNT, COUNT, #SAMPLES_PER_LOOP
        bne     0b
1:
 .rept WORDS_PER_LOOP / 8 - 1
        output4words  1, 1, DAT4, DAT5, DAT6, DAT7, DAT0, DAT1, DAT2, DAT3
        output4words  1, 1, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
 .endr
        output4words  1, 1, DAT4, DAT5, DAT6, DAT7, DAT0, DAT1, DAT2, DAT3, pointer_dead=1
        output4words  1, 0, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
        pop     {v1-v6,sl,fp,pc}
endfunc
 .purgem output4words

        .unreq  CHECK
        .unreq  COUNT
        .unreq  IN
        .unreq  OUT
        .unreq  DAT0
        .unreq  DAT1
        .unreq  DAT2
        .unreq  DAT3
        .unreq  DAT4
        .unreq  DAT5
        .unreq  DAT6
        .unreq  DAT7

.endif // mixed
.else // not inorder
.ifc \shift, mixed

// This case not currently handled

.else // not mixed

#if !CONFIG_THUMB

CHECK   .req    a1
COUNT   .req    a2
IN      .req    a3
OUT     .req    a4
DAT0    .req    v1
DAT1    .req    v2
DAT2    .req    v3
DAT3    .req    v4
CHAN0   .req    v5
CHAN1   .req    v6
CHAN2   .req    sl
CHAN3   .req    fp
CHAN4   .req    ip
CHAN5   .req    lr

 .macro output4words
  .if \channels == 8
   .if IDX1 == 8
        uxtb    CHAN0, CHAN4, ror #0
        uxtb    CHAN1, CHAN4, ror #8
        uxtb    CHAN2, CHAN4, ror #16
        uxtb    CHAN3, CHAN4, ror #24
   .else
        uxtb    CHAN0, CHAN5, ror #0
        uxtb    CHAN1, CHAN5, ror #8
        uxtb    CHAN2, CHAN5, ror #16
        uxtb    CHAN3, CHAN5, ror #24
   .endif
        ldr     DAT0, [IN, CHAN0, lsl #2]
        ldr     DAT1, [IN, CHAN1, lsl #2]
        ldr     DAT2, [IN, CHAN2, lsl #2]
        ldr     DAT3, [IN, CHAN3, lsl #2]
   .if IDX1 == 4
        add     IN, IN, #8*4
   .endif
        decr_modulo IDX1, 4, \channels
  .else
   .set SIZE_GROUP1, IDX1
   .if SIZE_GROUP1 > 4
    .set SIZE_GROUP1, 4
   .endif
   .set SIZE_GROUP2, 4 - SIZE_GROUP1
   .if SIZE_GROUP1 == 2
        loadregoffsh2  DAT, 0, IN, CHAN, 0 + (\channels - IDX1)
        loadregoffsh2  DAT, 1, IN, CHAN, 1 + (\channels - IDX1)
        add     IN, IN, #8*4
   .else // SIZE_GROUP1 == 4
        loadregoffsh2  DAT, 0, IN, CHAN, 0 + (\channels - IDX1)
        loadregoffsh2  DAT, 1, IN, CHAN, 1 + (\channels - IDX1)
        loadregoffsh2  DAT, 2, IN, CHAN, 2 + (\channels - IDX1)
        loadregoffsh2  DAT, 3, IN, CHAN, 3 + (\channels - IDX1)
    .if IDX1 == 4
        add     IN, IN, #8*4
    .endif
   .endif
        decr_modulo IDX1, SIZE_GROUP1, \channels
   .if SIZE_GROUP2 == 2
        loadregoffsh2  DAT, 2, IN, CHAN, 0 + (\channels - IDX1)
        loadregoffsh2  DAT, 3, IN, CHAN, 1 + (\channels - IDX1)
    .if IDX1 == 2
        add     IN, IN, #8*4
    .endif
   .endif
        decr_modulo IDX1, SIZE_GROUP2, \channels
  .endif
  .if \channels == 8 // in this case we can corrupt CHAN0-3
        rsb     CHAN0, CHAN0, #8
        rsb     CHAN1, CHAN1, #8
        rsb     CHAN2, CHAN2, #8
        rsb     CHAN3, CHAN3, #8
        lsl     DAT0, #8 + \shift
        lsl     DAT1, #8 + \shift
        lsl     DAT2, #8 + \shift
        lsl     DAT3, #8 + \shift
        eor     CHECK, CHECK, DAT0, lsr CHAN0
        eor     CHECK, CHECK, DAT1, lsr CHAN1
        eor     CHECK, CHECK, DAT2, lsr CHAN2
        eor     CHECK, CHECK, DAT3, lsr CHAN3
  .else
   .if \shift != 0
        lsl     DAT0, #\shift
        lsl     DAT1, #\shift
        lsl     DAT2, #\shift
        lsl     DAT3, #\shift
   .endif
        bic     DAT0, DAT0, #0xff000000
        bic     DAT1, DAT1, #0xff000000
        bic     DAT2, DAT2, #0xff000000
        bic     DAT3, DAT3, #0xff000000
        eorlslreg CHECK, DAT0, CHAN, 0 + (\channels - IDX2)
        eorlslreg CHECK, DAT1, CHAN, 1 + (\channels - IDX2)
   decr_modulo IDX2, 2, \channels
        eorlslreg CHECK, DAT2, CHAN, 0 + (\channels - IDX2)
        eorlslreg CHECK, DAT3, CHAN, 1 + (\channels - IDX2)
   decr_modulo IDX2, 2, \channels
        lsl     DAT0, #8
        lsl     DAT1, #8
        lsl     DAT2, #8
        lsl     DAT3, #8
  .endif
        stm     OUT!, {DAT0 - DAT3}
 .endm

 .set WORDS_PER_LOOP, \channels  // calculate LCM (channels, 4)
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .if (WORDS_PER_LOOP % 2) == 0
  .set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
 .endif
 .set WORDS_PER_LOOP, WORDS_PER_LOOP * 4
 .set SAMPLES_PER_LOOP, WORDS_PER_LOOP / \channels

function ff_mlp_pack_output_outoforder_\channels\()ch_\shift\()shift_armv6, export=1
 .if SAMPLES_PER_LOOP > 1
        tst     COUNT, #SAMPLES_PER_LOOP - 1  // always seems to be in practice
        it      ne
        bne     X(ff_mlp_pack_output)         // but just in case, branch to C implementation if not
 .endif
        teq     COUNT, #0
        it      eq
        bxeq    lr
        push    {v1-v6,sl,fp,lr}
        ldr     CHAN0, [sp, #(9+0)*4]  // get ch_assign from stack
        ldr     CHAN4, [CHAN0]
 .if \channels == 2
        uxtb    CHAN0, CHAN4, ror #0
        uxtb    CHAN1, CHAN4, ror #8
 .else
        ldr     CHAN5, [CHAN0, #4]
  .if \channels == 6
        uxtb    CHAN0, CHAN4, ror #0
        uxtb    CHAN1, CHAN4, ror #8
        uxtb    CHAN2, CHAN4, ror #16
        uxtb    CHAN3, CHAN4, ror #24
        uxtb    CHAN4, CHAN5, ror #0
        uxtb    CHAN5, CHAN5, ror #8
  .endif
 .endif
 .set IDX1, \channels
 .set IDX2, \channels
0:
 .rept WORDS_PER_LOOP / 4
        output4words
 .endr
        subs    COUNT, COUNT, #SAMPLES_PER_LOOP
        bne     0b
        pop     {v1-v6,sl,fp,pc}
        .ltorg
endfunc
 .purgem output4words

        .unreq  CHECK
        .unreq  COUNT
        .unreq  IN
        .unreq  OUT
        .unreq  DAT0
        .unreq  DAT1
        .unreq  DAT2
        .unreq  DAT3
        .unreq  CHAN0
        .unreq  CHAN1
        .unreq  CHAN2
        .unreq  CHAN3
        .unreq  CHAN4
        .unreq  CHAN5

#endif // !CONFIG_THUMB

.endif // mixed
.endif // inorder
.endm // implement_pack

.macro pack_channels  inorder, channels
        implement_pack  \inorder, \channels, 0
        implement_pack  \inorder, \channels, 1
        implement_pack  \inorder, \channels, 2
        implement_pack  \inorder, \channels, 3
        implement_pack  \inorder, \channels, 4
        implement_pack  \inorder, \channels, 5
        implement_pack  \inorder, \channels, mixed
.endm

.macro pack_order  inorder
        pack_channels  \inorder, 2
        pack_channels  \inorder, 6
        pack_channels  \inorder, 8
.endm

        pack_order  0
        pack_order  1
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2014 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	.macro loadregoffsh2 group, index, base, offgroup, offindex
	25	.altmacro
	26	loadregoffsh2_ \group, %(\index), \base, \offgroup, %(\offindex)
	27	.noaltmacro
	28	.endm
	29
	30	.macro loadregoffsh2_ group, index, base, offgroup, offindex
	31	ldr \group\index, [\base, \offgroup\offindex, lsl #2]
	32	.endm
	33
	34	.macro eorlslreg check, data, group, index
	35	.altmacro
	36	eorlslreg_ \check, \data, \group, %(\index)
	37	.noaltmacro
	38	.endm
	39
	40	.macro eorlslreg_ check, data, group, index
	41	eor \check, \check, \data, lsl \group\index
	42	.endm
	43
	44	.macro decr_modulo var, by, modulus
	45	.set \var, \var - \by
	46	.if \var == 0
	47	.set \var, \modulus
	48	.endif
	49	.endm
	50
	51	.macro load_group1 size, channels, r0, r1, r2, r3, pointer_dead=0
	52	.if \size == 2
	53	ldrd \r0, \r1, [IN], #(\size + 8 - \channels) * 4
	54	.else // size == 4
	55	.if IDX1 > 4 \|\| \channels==8
	56	ldm IN!, {\r0, \r1, \r2, \r3}
	57	.else
	58	ldm IN, {\r0, \r1, \r2, \r3}
	59	.if !\pointer_dead
	60	add IN, IN, #(4 + 8 - \channels) * 4
	61	.endif
	62	.endif
	63	.endif
	64	decr_modulo IDX1, \size, \channels
65	.endm
66
67	.macro load_group2 size, channels, r0, r1, r2, r3, pointer_dead=0
68	.if \size == 2
69	.if IDX1 > 2
70	ldm IN!, {\r2, \r3}
71	.else
72	//A .ifc \r2, ip
73	//A .if \pointer_dead
74	//A ldm IN, {\r2, \r3}
75	//A .else
76	//A ldr \r2, [IN], #4
77	//A ldr \r3, [IN], #(\size - 1 + 8 - \channels) * 4
78	//A .endif
79	//A .else
80	ldrd \r2, \r3, [IN], #(\size + 8 - \channels) * 4
81	//A .endif
82	.endif
83	.endif
84	decr_modulo IDX1, \size, \channels
85	.endm
86
87	.macro implement_pack inorder, channels, shift
88	.if \inorder
89	.ifc \shift, mixed
90
91	CHECK .req a1
92	COUNT .req a2
93	IN .req a3
94	OUT .req a4
95	DAT0 .req v1
96	DAT1 .req v2
97	DAT2 .req v3
98	DAT3 .req v4
99	SHIFT0 .req v5
100	SHIFT1 .req v6
101	SHIFT2 .req sl
102	SHIFT3 .req fp
103	SHIFT4 .req ip
104	SHIFT5 .req lr
105
106	.macro output4words
107	.set SIZE_GROUP1, IDX1
108	.if SIZE_GROUP1 > 4
109	.set SIZE_GROUP1, 4
110	.endif
111	.set SIZE_GROUP2, 4 - SIZE_GROUP1
112	load_group1 SIZE_GROUP1, \channels, DAT0, DAT1, DAT2, DAT3
113	load_group2 SIZE_GROUP2, \channels, DAT0, DAT1, DAT2, DAT3
114	.if \channels == 2
115	lsl DAT0, SHIFT0
116	lsl DAT1, SHIFT1
117	lsl DAT2, SHIFT0
118	lsl DAT3, SHIFT1
119	.elseif \channels == 6
120	.if IDX2 == 6
121	lsl DAT0, SHIFT0
122	lsl DAT1, SHIFT1
123	lsl DAT2, SHIFT2
124	lsl DAT3, SHIFT3
125	.elseif IDX2 == 2
126	lsl DAT0, SHIFT4
127	lsl DAT1, SHIFT5
128	lsl DAT2, SHIFT0
129	lsl DAT3, SHIFT1
130	.else // IDX2 == 4
131	lsl DAT0, SHIFT2
132	lsl DAT1, SHIFT3
133	lsl DAT2, SHIFT4
134	lsl DAT3, SHIFT5
135	.endif
136	.elseif \channels == 8
137	.if IDX2 == 8
138	uxtb SHIFT0, SHIFT4, ror #0
139	uxtb SHIFT1, SHIFT4, ror #8
140	uxtb SHIFT2, SHIFT4, ror #16
141	uxtb SHIFT3, SHIFT4, ror #24
142	.else
143	uxtb SHIFT0, SHIFT5, ror #0
144	uxtb SHIFT1, SHIFT5, ror #8
145	uxtb SHIFT2, SHIFT5, ror #16
146	uxtb SHIFT3, SHIFT5, ror #24
147	.endif
148	lsl DAT0, SHIFT0
149	lsl DAT1, SHIFT1
150	lsl DAT2, SHIFT2
151	lsl DAT3, SHIFT3
152	.endif
153	eor CHECK, CHECK, DAT0, lsr #8 - (\channels - IDX2)
154	eor CHECK, CHECK, DAT1, lsr #7 - (\channels - IDX2)
155	decr_modulo IDX2, 2, \channels
156	eor CHECK, CHECK, DAT2, lsr #8 - (\channels - IDX2)
157	eor CHECK, CHECK, DAT3, lsr #7 - (\channels - IDX2)
158	decr_modulo IDX2, 2, \channels
159	stm OUT!, {DAT0 - DAT3}
160	.endm
161
162	.set WORDS_PER_LOOP, \channels // calculate LCM (channels, 4)
163	.if (WORDS_PER_LOOP % 2) == 0
164	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
165	.endif
166	.if (WORDS_PER_LOOP % 2) == 0
167	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
168	.endif
169	.set WORDS_PER_LOOP, WORDS_PER_LOOP * 4
170	.set SAMPLES_PER_LOOP, WORDS_PER_LOOP / \channels
171
172	function ff_mlp_pack_output_inorder_\channels\()ch_mixedshift_armv6, export=1
173	.if SAMPLES_PER_LOOP > 1
174	tst COUNT, #SAMPLES_PER_LOOP - 1 // always seems to be in practice
175	it ne
176	bne X(ff_mlp_pack_output) // but just in case, branch to C implementation if not
177	.endif
178	teq COUNT, #0
179	it eq
180	bxeq lr
181	push {v1-v6,sl,fp,lr}
182	ldr SHIFT0, [sp, #(9+1)*4] // get output_shift from stack
183	ldr SHIFT1, =0x08080808
184	ldr SHIFT4, [SHIFT0]
185	.if \channels == 2
186	uadd8 SHIFT4, SHIFT4, SHIFT1 // increase all shifts by 8
187	uxtb SHIFT0, SHIFT4, ror #0
188	uxtb SHIFT1, SHIFT4, ror #8
189	.else
190	ldr SHIFT5, [SHIFT0, #4]
191	uadd8 SHIFT4, SHIFT4, SHIFT1 // increase all shifts by 8
192	uadd8 SHIFT5, SHIFT5, SHIFT1
193	.if \channels == 6
194	uxtb SHIFT0, SHIFT4, ror #0
195	uxtb SHIFT1, SHIFT4, ror #8
196	uxtb SHIFT2, SHIFT4, ror #16
197	uxtb SHIFT3, SHIFT4, ror #24
198	uxtb SHIFT4, SHIFT5, ror #0
199	uxtb SHIFT5, SHIFT5, ror #8
200	.endif
201	.endif
202	.set IDX1, \channels
203	.set IDX2, \channels
204	0:
205	.rept WORDS_PER_LOOP / 4
206	output4words
207	.endr
208	subs COUNT, COUNT, #SAMPLES_PER_LOOP
209	bne 0b
210	pop {v1-v6,sl,fp,pc}
211	.ltorg
212	endfunc
213	.purgem output4words
214
215	.unreq CHECK
216	.unreq COUNT
217	.unreq IN
218	.unreq OUT
219	.unreq DAT0
220	.unreq DAT1
221	.unreq DAT2
222	.unreq DAT3
223	.unreq SHIFT0
224	.unreq SHIFT1
225	.unreq SHIFT2
226	.unreq SHIFT3
227	.unreq SHIFT4
228	.unreq SHIFT5
229
230	.else // not mixed
231
232	CHECK .req a1
233	COUNT .req a2
234	IN .req a3
235	OUT .req a4
236	DAT0 .req v1
237	DAT1 .req v2
238	DAT2 .req v3
239	DAT3 .req v4
240	DAT4 .req v5
241	DAT5 .req v6
242	DAT6 .req sl // use these rather than the otherwise unused
243	DAT7 .req fp // ip and lr so that we can load them usinf LDRD
244
245	.macro output4words tail, head, r0, r1, r2, r3, r4, r5, r6, r7, pointer_dead=0
246	.if \head
247	.set SIZE_GROUP1, IDX1
248	.if SIZE_GROUP1 > 4
249	.set SIZE_GROUP1, 4
250	.endif
251	.set SIZE_GROUP2, 4 - SIZE_GROUP1
252	load_group1 SIZE_GROUP1, \channels, \r0, \r1, \r2, \r3, \pointer_dead
253	.endif
254	.if \tail
255	eor CHECK, CHECK, \r4, lsr #8 - (\channels - IDX2)
256	eor CHECK, CHECK, \r5, lsr #7 - (\channels - IDX2)
257	decr_modulo IDX2, 2, \channels
258	.endif
259	.if \head
260	load_group2 SIZE_GROUP2, \channels, \r0, \r1, \r2, \r3, \pointer_dead
261	.endif
262	.if \tail
263	eor CHECK, CHECK, \r6, lsr #8 - (\channels - IDX2)
264	eor CHECK, CHECK, \r7, lsr #7 - (\channels - IDX2)
265	decr_modulo IDX2, 2, \channels
266	stm OUT!, {\r4, \r5, \r6, \r7}
267	.endif
268	.if \head
269	lsl \r0, #8 + \shift
270	lsl \r1, #8 + \shift
271	lsl \r2, #8 + \shift
272	lsl \r3, #8 + \shift
273	.endif
274	.endm
275
276	.set WORDS_PER_LOOP, \channels // calculate LCM (channels, 8)
277	.if (WORDS_PER_LOOP % 2) == 0
278	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
279	.endif
280	.if (WORDS_PER_LOOP % 2) == 0
281	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
282	.endif
283	.if (WORDS_PER_LOOP % 2) == 0
284	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
285	.endif
286	.set WORDS_PER_LOOP, WORDS_PER_LOOP * 8
287	.set SAMPLES_PER_LOOP, WORDS_PER_LOOP / \channels
288
289	function ff_mlp_pack_output_inorder_\channels\()ch_\shift\()shift_armv6, export=1
290	.if SAMPLES_PER_LOOP > 1
291	tst COUNT, #SAMPLES_PER_LOOP - 1 // always seems to be in practice
292	it ne
293	bne X(ff_mlp_pack_output) // but just in case, branch to C implementation if not
294	.endif
295	subs COUNT, COUNT, #SAMPLES_PER_LOOP
296	it lo
297	bxlo lr
298	push {v1-v6,sl,fp,lr}
299	.set IDX1, \channels
300	.set IDX2, \channels
301	output4words 0, 1, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
302	0: beq 1f
303	.rept WORDS_PER_LOOP / 8
304	output4words 1, 1, DAT4, DAT5, DAT6, DAT7, DAT0, DAT1, DAT2, DAT3
305	output4words 1, 1, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
306	.endr
307	subs COUNT, COUNT, #SAMPLES_PER_LOOP
308	bne 0b
309	1:
310	.rept WORDS_PER_LOOP / 8 - 1
311	output4words 1, 1, DAT4, DAT5, DAT6, DAT7, DAT0, DAT1, DAT2, DAT3
312	output4words 1, 1, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
313	.endr
314	output4words 1, 1, DAT4, DAT5, DAT6, DAT7, DAT0, DAT1, DAT2, DAT3, pointer_dead=1
315	output4words 1, 0, DAT0, DAT1, DAT2, DAT3, DAT4, DAT5, DAT6, DAT7
316	pop {v1-v6,sl,fp,pc}
317	endfunc
318	.purgem output4words
319
320	.unreq CHECK
321	.unreq COUNT
322	.unreq IN
323	.unreq OUT
324	.unreq DAT0
325	.unreq DAT1
326	.unreq DAT2
327	.unreq DAT3
328	.unreq DAT4
329	.unreq DAT5
330	.unreq DAT6
331	.unreq DAT7
332
333	.endif // mixed
334	.else // not inorder
335	.ifc \shift, mixed
336
337	// This case not currently handled
338
339	.else // not mixed
340
341	#if !CONFIG_THUMB
342
343	CHECK .req a1
344	COUNT .req a2
345	IN .req a3
346	OUT .req a4
347	DAT0 .req v1
348	DAT1 .req v2
349	DAT2 .req v3
350	DAT3 .req v4
351	CHAN0 .req v5
352	CHAN1 .req v6
353	CHAN2 .req sl
354	CHAN3 .req fp
355	CHAN4 .req ip
356	CHAN5 .req lr
357
358	.macro output4words
359	.if \channels == 8
360	.if IDX1 == 8
361	uxtb CHAN0, CHAN4, ror #0
362	uxtb CHAN1, CHAN4, ror #8
363	uxtb CHAN2, CHAN4, ror #16
364	uxtb CHAN3, CHAN4, ror #24
365	.else
366	uxtb CHAN0, CHAN5, ror #0
367	uxtb CHAN1, CHAN5, ror #8
368	uxtb CHAN2, CHAN5, ror #16
369	uxtb CHAN3, CHAN5, ror #24
370	.endif
371	ldr DAT0, [IN, CHAN0, lsl #2]
372	ldr DAT1, [IN, CHAN1, lsl #2]
373	ldr DAT2, [IN, CHAN2, lsl #2]
374	ldr DAT3, [IN, CHAN3, lsl #2]
375	.if IDX1 == 4
376	add IN, IN, #8*4
377	.endif
378	decr_modulo IDX1, 4, \channels
379	.else
380	.set SIZE_GROUP1, IDX1
381	.if SIZE_GROUP1 > 4
382	.set SIZE_GROUP1, 4
383	.endif
384	.set SIZE_GROUP2, 4 - SIZE_GROUP1
385	.if SIZE_GROUP1 == 2
386	loadregoffsh2 DAT, 0, IN, CHAN, 0 + (\channels - IDX1)
387	loadregoffsh2 DAT, 1, IN, CHAN, 1 + (\channels - IDX1)
388	add IN, IN, #8*4
389	.else // SIZE_GROUP1 == 4
390	loadregoffsh2 DAT, 0, IN, CHAN, 0 + (\channels - IDX1)
391	loadregoffsh2 DAT, 1, IN, CHAN, 1 + (\channels - IDX1)
392	loadregoffsh2 DAT, 2, IN, CHAN, 2 + (\channels - IDX1)
393	loadregoffsh2 DAT, 3, IN, CHAN, 3 + (\channels - IDX1)
394	.if IDX1 == 4
395	add IN, IN, #8*4
396	.endif
397	.endif
398	decr_modulo IDX1, SIZE_GROUP1, \channels
399	.if SIZE_GROUP2 == 2
400	loadregoffsh2 DAT, 2, IN, CHAN, 0 + (\channels - IDX1)
401	loadregoffsh2 DAT, 3, IN, CHAN, 1 + (\channels - IDX1)
402	.if IDX1 == 2
403	add IN, IN, #8*4
404	.endif
405	.endif
406	decr_modulo IDX1, SIZE_GROUP2, \channels
407	.endif
408	.if \channels == 8 // in this case we can corrupt CHAN0-3
409	rsb CHAN0, CHAN0, #8
410	rsb CHAN1, CHAN1, #8
411	rsb CHAN2, CHAN2, #8
412	rsb CHAN3, CHAN3, #8
413	lsl DAT0, #8 + \shift
414	lsl DAT1, #8 + \shift
415	lsl DAT2, #8 + \shift
416	lsl DAT3, #8 + \shift
417	eor CHECK, CHECK, DAT0, lsr CHAN0
418	eor CHECK, CHECK, DAT1, lsr CHAN1
419	eor CHECK, CHECK, DAT2, lsr CHAN2
420	eor CHECK, CHECK, DAT3, lsr CHAN3
421	.else
422	.if \shift != 0
423	lsl DAT0, #\shift
424	lsl DAT1, #\shift
425	lsl DAT2, #\shift
426	lsl DAT3, #\shift
427	.endif
428	bic DAT0, DAT0, #0xff000000
429	bic DAT1, DAT1, #0xff000000
430	bic DAT2, DAT2, #0xff000000
431	bic DAT3, DAT3, #0xff000000
432	eorlslreg CHECK, DAT0, CHAN, 0 + (\channels - IDX2)
433	eorlslreg CHECK, DAT1, CHAN, 1 + (\channels - IDX2)
434	decr_modulo IDX2, 2, \channels
435	eorlslreg CHECK, DAT2, CHAN, 0 + (\channels - IDX2)
436	eorlslreg CHECK, DAT3, CHAN, 1 + (\channels - IDX2)
437	decr_modulo IDX2, 2, \channels
438	lsl DAT0, #8
439	lsl DAT1, #8
440	lsl DAT2, #8
441	lsl DAT3, #8
442	.endif
443	stm OUT!, {DAT0 - DAT3}
444	.endm
445
446	.set WORDS_PER_LOOP, \channels // calculate LCM (channels, 4)
447	.if (WORDS_PER_LOOP % 2) == 0
448	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
449	.endif
450	.if (WORDS_PER_LOOP % 2) == 0
451	.set WORDS_PER_LOOP, WORDS_PER_LOOP / 2
452	.endif
453	.set WORDS_PER_LOOP, WORDS_PER_LOOP * 4
454	.set SAMPLES_PER_LOOP, WORDS_PER_LOOP / \channels
455
456	function ff_mlp_pack_output_outoforder_\channels\()ch_\shift\()shift_armv6, export=1
457	.if SAMPLES_PER_LOOP > 1
458	tst COUNT, #SAMPLES_PER_LOOP - 1 // always seems to be in practice
459	it ne
460	bne X(ff_mlp_pack_output) // but just in case, branch to C implementation if not
461	.endif
462	teq COUNT, #0
463	it eq
464	bxeq lr
465	push {v1-v6,sl,fp,lr}
466	ldr CHAN0, [sp, #(9+0)*4] // get ch_assign from stack
467	ldr CHAN4, [CHAN0]
468	.if \channels == 2
469	uxtb CHAN0, CHAN4, ror #0
470	uxtb CHAN1, CHAN4, ror #8
471	.else
472	ldr CHAN5, [CHAN0, #4]
473	.if \channels == 6
474	uxtb CHAN0, CHAN4, ror #0
475	uxtb CHAN1, CHAN4, ror #8
476	uxtb CHAN2, CHAN4, ror #16
477	uxtb CHAN3, CHAN4, ror #24
478	uxtb CHAN4, CHAN5, ror #0
479	uxtb CHAN5, CHAN5, ror #8
480	.endif
481	.endif
482	.set IDX1, \channels
483	.set IDX2, \channels
484	0:
485	.rept WORDS_PER_LOOP / 4
486	output4words
487	.endr
488	subs COUNT, COUNT, #SAMPLES_PER_LOOP
489	bne 0b
490	pop {v1-v6,sl,fp,pc}
491	.ltorg
492	endfunc
493	.purgem output4words
494
495	.unreq CHECK
496	.unreq COUNT
497	.unreq IN
498	.unreq OUT
499	.unreq DAT0
500	.unreq DAT1
501	.unreq DAT2
502	.unreq DAT3
503	.unreq CHAN0
504	.unreq CHAN1
505	.unreq CHAN2
506	.unreq CHAN3
507	.unreq CHAN4
508	.unreq CHAN5
509
510	#endif // !CONFIG_THUMB
511
512	.endif // mixed
513	.endif // inorder
514	.endm // implement_pack
515
516	.macro pack_channels inorder, channels
517	implement_pack \inorder, \channels, 0
518	implement_pack \inorder, \channels, 1
519	implement_pack \inorder, \channels, 2
520	implement_pack \inorder, \channels, 3
521	implement_pack \inorder, \channels, 4
522	implement_pack \inorder, \channels, 5
523	implement_pack \inorder, \channels, mixed
524	.endm
525
526	.macro pack_order inorder
527	pack_channels \inorder, 2
528	pack_channels \inorder, 6
529	pack_channels \inorder, 8
530	.endm
531
532	pack_order 0
533	pack_order 1