| /* |
| * 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 |
