source_of_the_sovereign/src/music/main_mixer.S

@ created by ~ipatix~
@ revision 2.1

    /* globals */
    .global main_mixer
    .global mixer_size

    .set    mixer_size, (main_mixer_end - main_mixer) / 4

    /* game code definitions */
    .equ    GAME_BPED, 0
    .equ    GAME_BPEE, 1
    .equ    GAME_BPRE, 2
    .equ    GAME_KWJ6, 3
    .equ    GAME_AE7E, 4
    .equ    GAME_BPRD, 5

    /* SELECT USED GAME HERE */
    .equ    USED_GAME, GAME_BPRE

    .equ    FRAME_LENGTH_5734, 0x60
    .equ    FRAME_LENGTH_7884, 0x84             @ THIS MODE IS NOT SUPPORTED BY THIS ENGINE BECAUSE IT DOESN'T USE AN 8 ALIGNED BUFFER LENGTH
    .equ    FRAME_LENGTH_10512, 0xB0
    .equ    FRAME_LENGTH_13379, 0xE0            @ DEFAULT
    .equ    FRAME_LENGTH_15768, 0x108
    .equ    FRAME_LENGTH_18157, 0x130
    .equ    FRAME_LENGTH_21024, 0x160
    .equ    FRAME_LENGTH_26758, 0x1C0
    .equ    FRAME_LENGTH_31536, 0x210
    .equ    FRAME_LENGTH_36314, 0x260
    .equ    FRAME_LENGTH_40137, 0x2A0
    .equ    FRAME_LENGTH_42048, 0x2C0

    .equ    DECODER_BUFFER_BPE, 0x03001300
    .equ    DECODER_BUFFER_BPR, 0x03002088
    .equ    DECODER_BUFFER_KWJ, 0x03005800

    .equ    BUFFER_IRAM_BPE, 0x03001AA8
    .equ    BUFFER_IRAM_BPR, 0x030028E0
    .equ    BUFFER_IRAM_KWJ, 0x03005840
    .equ    BUFFER_IRAM_AE7, 0x03006D60

    /* stack variables */
    .equ    ARG_FRAME_LENGTH, 0x0               @ TODO actually use this variable
    .equ    ARG_REMAIN_CHN, 0x4                 @ This is the channel count variable    
    .equ    ARG_BUFFER_POS, 0x8                 @ stores the current output buffer pointer
    .equ    ARG_LOOP_START_POS, 0xC             @ stores wave loop start position in channel loop
    .equ    ARG_LOOP_LENGTH, 0x10               @   ''    ''   ''  end position
@   .equ    ARG_UKNOWN, 0x14 
    .equ    ARG_PCM_STRUCT, 0x18                @ pointer to engine the main work area

    /* channel struct */
    .equ    CHN_STATUS, 0x0                     @ [byte] channel status bitfield
    .equ    CHN_MODE, 0x1                       @ [byte] channel mode bitfield
    .equ    CHN_VOL_1, 0x2                      @ [byte] volume right
    .equ    CHN_VOL_2, 0x3                      @ [byte] volume left
    .equ    CHN_ATTACK, 0x4                     @ [byte] wave attack summand
    .equ    CHN_DECAY, 0x5                      @ [byte] wave decay factor
    .equ    CHN_SUSTAIN, 0x6                    @ [byte] wave sustain level
    .equ    CHN_RELEASE, 0x7                    @ [byte] wave release factor
    .equ    CHN_ADSR_LEVEL, 0x9                 @ [byte] current envelope level
    .equ    CHN_FINAL_VOL_1, 0xA                @ [byte] not used anymore!
    .equ    CHN_FINAL_VOL_2, 0xB                @ [byte] not used anymore!
    .equ    CHN_ECHO_VOL, 0xC                   @ [byte] pseudo echo volume
    .equ    CHN_ECHO_REMAIN, 0xD                @ [byte] pseudo echo length
    .equ    CHN_SAMPLE_COUNTDOWN, 0x18              @ [word] sample countdown in mixing loop
    .equ    CHN_FINE_POSITION, 0x1C             @ [word] inter sample position (23 bits)
    .equ    CHN_FREQUENCY, 0x20                 @ [word] sample rate (in Hz)
    .equ    CHN_WAVE_OFFSET, 0x24               @ [word] wave header pointer
    .equ    CHN_POSITION_ABS, 0x28              @ [word] points to the current position in the wave data (relative offset for compressed samples)
    .equ    CHN_BLOCK_COUNT, 0x3C               @ [word] only used for compressed samples: contains the value of the block that is currently decoded

    /* wave header struct */
    .equ    WAVE_LOOP_FLAG, 0x3                 @ [byte] 0x0 = oneshot; 0x40 = looped
    .equ    WAVE_FREQ, 0x4                      @ [word] pitch adjustment value = mid-C samplerate * 1024
    .equ    WAVE_LOOP_START, 0x8                @ [word] loop start position
    .equ    WAVE_LENGTH, 0xC                    @ [word] loop end / wave end position
    .equ    WAVE_DATA, 0x10                     @ [byte array] actual wave data

    /* pulse wave synth configuration offset */
    .equ    SYNTH_BASE_WAVE_DUTY, 0x1           @ [byte]
    .equ    SYNTH_WIDTH_CHANGE_1, 0x2           @ [byte]
    .equ    SYNTH_MOD_AMOUNT, 0x3               @ [byte]
    .equ    SYNTH_WIDTH_CHANGE_2, 0x4           @ [byte]

    /* CHN_STATUS flags - 0x0 = OFF */
    .equ    FLAG_CHN_INIT, 0x80                 @ [bit] write this value to init a channel
    .equ    FLAG_CHN_RELEASE, 0x40              @ [bit] write this value to release (fade out) the channel
    .equ    FLAG_CHN_COMP, 0x20                 @ [bit] is wave being played compressed (yes/no)
    .equ    FLAG_CHN_LOOP, 0x10                 @ [bit] loop (yes/no)
    .equ    FLAG_CHN_ECHO, 0x4                  @ [bit] echo phase
    .equ    FLAG_CHN_ATTACK, 0x3                @ [bit] attack phase
    .equ    FLAG_CHN_DECAY, 0x2                 @ [bit] decay phase
    .equ    FLAG_CHN_SUSTAIN, 0x1               @ [bit] sustain phase

    /* CHN_MODE flags */
    .equ    MODE_FIXED_FREQ, 0x8                @ [bit] set to disable resampling (i.e. playback with output rate)
    .equ    MODE_REVERSE, 0x10                  @ [bit] set to reverse sample playback
    .equ    MODE_COMP, 0x30                     @ [bit] is wave being played compressed or reversed (TODO: rename flag)
    .equ    MODE_SYNTH, 0x40                    @ [bit] READ ONLY, indicates synthzied output

    /* variables of the engine work area */
    .equ    VAR_REVERB, 0x5                     @ [byte] 0-127 = reverb level
    .equ    VAR_MAX_CHN, 0x6                    @ [byte] maximum channels to process
    .equ    VAR_MASTER_VOL, 0x7                 @ [byte] PCM master volume
    .equ    VAR_DEF_PITCH_FAC, 0x18             @ [word] this value get's multiplied with the samplerate for the inter sample distance
    .equ    VAR_FIRST_CHN, 0x50                 @ [CHN struct] relative offset to channel array

    /* just some more defines */
    .equ    REG_DMA3_SRC, 0x040000D4
    .equ    ARM_OP_LEN, 0x4

@#######################################
@*********** GAME CONFIGS **************
@ add the game's name above to the ASM .equ-s before creating new configs
@#######################################


@*********** IF GERMAN POKEMON EMERALD
.if USED_GAME==GAME_BPED

    .equ    hq_buffer_ptr, BUFFER_IRAM_BPE
    .equ    decoder_buffer_target, DECODER_BUFFER_BPE
    .equ    POKE_INIT, 1
    .equ    DMA_FIX, 1
    .equ    ENABLE_DECOMPRESSION, 1
    .equ    ENABLE_CLIPPING, 1

.endif
@*********** IF ENGLISH POKEMON FIRE RED
.if USED_GAME==GAME_BPRD

    .equ    hq_buffer_ptr, 0x03002830
    .equ    decoder_buffer_target, DECODER_BUFFER_BPR
    .equ    POKE_INIT, 1
    .equ    DMA_FIX, 1
    .equ    ENABLE_DECOMPRESSION, 1
    .equ    ENABLE_CLIPPING, 1

.endif
@*********** IF ENGLISH POKEMON EMERALD
.if USED_GAME==GAME_BPEE

    .equ    hq_buffer_ptr, BUFFER_IRAM_BPE
    .equ    decoder_buffer_target, DECODER_BUFFER_BPE
    .equ    POKE_INIT, 1
    .equ    DMA_FIX, 1
    .equ    ENABLE_DECOMPRESSION, 1
    .equ    ENABLE_CLIPPING, 1

.endif
@*********** IF ENGLISH POKEMON FIRE RED
.if USED_GAME==GAME_BPRE

    .equ    hq_buffer_ptr, BUFFER_IRAM_BPR
    .equ    decoder_buffer_target, DECODER_BUFFER_BPR
    .equ    POKE_INIT, 1
    .equ    DMA_FIX, 1
    .equ    ENABLE_DECOMPRESSION, 1
    .equ    ENABLE_CLIPPING, 1

.endif
@*********** IF KAWAs JUKEBOX 2006
.if USED_GAME==GAME_KWJ6

    .equ    hq_buffer_ptr, BUFFER_IRAM_KWJ
    .equ    decoder_buffer_target, DECODER_BUFFER_KWJ
    .equ    POKE_INIT, 0
    .equ    DMA_FIX, 0
    .equ    ENABLE_DECOMPRESSION, 0
    .equ    ENABLE_CLIPPING, 1

.endif
@*********** IF US FIRE EMBLEM
.if USED_GAME==GAME_AE7E

    .equ    hq_buffer_ptr, BUFFER_IRAM_AE7
    .equ    POKE_INIT, 0
    .equ    DMA_FIX, 0
    .equ    ENABLE_DECOMPRESSION, 0
    .equ    ENABLE_CLIPPING, 0
.endif
@***********

    .thumb

main_mixer:
    /* load Reverb level and check if we need to apply it */
    LDRB    R3, [R0, #VAR_REVERB]
    LSR     R3, R3, #2
    BEQ     C_clear_hq_buffer

    ADR     R1, C_setup_reverb_loop
    BX      R1

    .arm
    .align  2

C_setup_reverb_loop:
    /* 
     * reverb is calculated by the following: new_sample = old_sample * reverb_level / 127
     * note that reverb is mono (both sides get mixed together)
     * 
     * reverb get's applied to the frame we are currently looking at and the one after that
     * the magic below simply calculateds the pointer for the one after the current one
     */
    CMP     R4, #2
    ADDEQ   R7, R0, #0x350
    ADDNE   R7, R5, R8
    MOV     R4, R8
    ORR     R3, R3, R3, LSL#16            
    STMFD   SP!, {R8, LR}
    LDR     LR, hq_buffer

C_reverb_loop:
        /* This loop does the reverb processing */
        LDRSB   R0, [R5, R6]
        LDRSB   R1, [R5], #1
        LDRSB   R2, [R7, R6]
        LDRSB   R8, [R7], #1
        LDRSB   R9, [R5, R6]
        LDRSB   R10, [R5], #1
        LDRSB   R11, [R7, R6]
        LDRSB   R12, [R7], #1
        ADD     R0, R0, R1
        ADD     R0, R0, R2
        ADD     R0, R0, R8
        ADDMI   R0, R0, #0x4
        ADD     R1, R9, R10
        ADD     R1, R1, R11
        ADDS    R1, R1, R12
        ADDMI   R1, R1, #0x4
        MUL     R0, R3, R0
        MUL     R1, R3, R1
        STMIA   LR!, {R0, R1}
        SUBS    R4, R4, #2
        BGT     C_reverb_loop
        /* end of loop */
    LDMFD   SP!, {R8, LR}
    ADR     R0, (C_setup_channel_state_loop+1)
    BX      R0

    .thumb

C_clear_hq_buffer:
    /* Incase reverb is disabled the buffer get's set to zero */
    LDR     R3, hq_buffer
    MOV     R1, R8
    MOV     R4, #0
    MOV     R5, #0
    MOV     R6, #0
    MOV     R7, #0
    /*
     * Setting the buffer to zero happens in a very efficient loop
     * Depending on the alignment of the buffer length, twice or quadruple the amount of bytes
     * get cleared at once
     */
    LSR     R1, #3
    BCC     C_clr_hq_buffer_align_8

    STMIA   R3!, {R4, R5, R6, R7}

C_clr_hq_buffer_align_8:
    LSR     R1, #1
    BCC     C_clr_hq_buffer_align_16

    STMIA   R3!, {R4, R5, R6, R7}
    STMIA   R3!, {R4, R5, R6, R7}

C_clr_hq_buffer_align_16:
    /* This repeats until the buffer has been cleared */
    STMIA   R3!, {R4, R5, R6, R7}
    STMIA   R3!, {R4, R5, R6, R7}
    STMIA   R3!, {R4, R5, R6, R7}
    STMIA   R3!, {R4, R5, R6, R7}
    SUB     R1, #1
    BGT     C_clr_hq_buffer_align_16
    /* loop end */
C_setup_channel_state_loop:
    /*
     * okay, before the actual mixing starts
     * the volume and envelope calculation takes place
     */
    MOV     R4, R8  @ R4 = buffer length
    /* 
     * this stroes the buffer length to a backup location
     */
    ADR     R0, hq_buffer_length
    STR     R4, [R0]
    /* init channel loop */
    LDR     R4, [SP, #ARG_PCM_STRUCT]           @ R4 = main work area pointer
    LDR     R0, [R4, #VAR_DEF_PITCH_FAC]        @ R0 = samplingrate pitch factor
    MOV     R12, R0
    LDRB    R0, [R4, #VAR_MAX_CHN]
    ADD     R4, #VAR_FIRST_CHN                  @ R4 = Base channel Offset (Channel #0)

C_channel_state_loop:
        /* this is the main channel processing loop */
        STR     R0, [SP, #ARG_REMAIN_CHN]        
        LDR     R3, [R4, #CHN_WAVE_OFFSET]
        LDRB    R6, [R4, #CHN_STATUS]           @ R6 will hold the channel status
        MOVS    R0, #0xC7                       @ check if any of the channel status flags is set
        TST     R0, R6                          @ check if none of the flags is set
        BEQ     C_skip_channel
        /* check channel flags */
        LSL     R0, R6, #25                     @ shift over the FLAG_CHN_INIT to CARRY
        BCC     C_adsr_echo_check               @ continue with normal channel procedure
        /* check leftmost bit */
        BMI     C_stop_channel                  @ FLAG_CHN_INIT | FLAG_CHN_RELEASE -> stop directly
        /* channel init procedure */
        MOVS    R6, #FLAG_CHN_ATTACK
        MOVS    R0, R3                          @ R0 = CHN_WAVE_OFFSET
        ADD     R0, #WAVE_DATA                  @ R0 = wave data offset

        /* Pokemon games seem to init channels differently than other m4a games */
    .if POKE_INIT==0
        STR     R0, [R4, #CHN_POSITION_ABS]
        LDR     R0, [R3, #WAVE_LENGTH]
        STR     R0, [R4, #CHN_SAMPLE_COUNTDOWN] 
    .else
        LDR     R1, [R4, #CHN_SAMPLE_COUNTDOWN]
        ADD     R0, R0, R1
        STR     R0, [R4, #CHN_POSITION_ABS]
        LDR     R0, [R3, #WAVE_LENGTH]
        SUB     R0, R0, R1
        STR     R0, [R4, #CHN_SAMPLE_COUNTDOWN]
    .endif

        MOVS    R5, #0                          @ initial envelope = #0
        STRB    R5, [R4, #CHN_ADSR_LEVEL]
        STR     R5, [R4, #CHN_FINE_POSITION]
        LDRB    R2, [R3, #WAVE_LOOP_FLAG]
        LSR     R0, R2, #6
        BEQ     C_adsr_attack
        /* loop enabled here */
        MOVS    R0, #FLAG_CHN_LOOP    
        ORR     R6, R0
        B       C_adsr_attack

C_adsr_echo_check:
        /* this is the normal ADSR procedure without init */
        LDRB    R5, [R4, #CHN_ADSR_LEVEL]
        LSL     R0, R6, #29                     @ FLAG_CHN_ECHO --> bit 31 (sign bit)
        BPL     C_adsr_release_check
        /* pseudo echo handler */
        LDRB    R0, [R4, #CHN_ECHO_REMAIN]
        SUB     R0, #1
        STRB    R0, [R4, #CHN_ECHO_REMAIN]
        BHI     C_channel_vol_calc              @ continue normal if channel is still on

C_stop_channel:
        MOVS    R0, #0
        STRB    R0, [R4, #CHN_STATUS]

C_skip_channel:
        /* go to end of the channel loop */
        B       C_end_channel_state_loop

C_adsr_release_check:
        LSL    R0, R6, #25                      @ FLAG_CHN_RELEASE --> bit 31 (sign bit)
        BPL    C_adsr_decay_check
        /* release handler */
        LDRB    R0, [R4, #CHN_RELEASE]
        @SUB     R0, #0xFF                      @ linear decay; TODO make option for triggering it
        @SUB     R0, #1
        @ADD     R5, R5, R0
        MUL     R5, R5, R0
        LSR     R5, #8
        BLE     C_adsr_released
        /* pseudo echo init handler */
        LDRB    R0, [R4, #CHN_ECHO_VOL]
        CMP     R5, R0
        BHI     C_channel_vol_calc

C_adsr_released:
        /* if volume released to #0 */
        LDRB    R5, [R4, #CHN_ECHO_VOL]
        CMP     R5, #0
        BEQ     C_stop_channel
        /* pseudo echo volume handler */
        MOVS    R0, #FLAG_CHN_ECHO
        ORR     R6, R0                          @ set the echo flag
        B       C_adsr_save_and_finalize

C_adsr_decay_check:
        /* check if decay is active */
        MOVS    R2, #(FLAG_CHN_DECAY+FLAG_CHN_SUSTAIN)
        AND     R2, R6
        CMP     R2, #FLAG_CHN_DECAY
        BNE     C_adsr_attack_check             @ decay not active yet
        /* decay handler */
        LDRB    R0, [R4, #CHN_DECAY]
        MUL     R5, R5, R0
        LSR     R5, R5, #8
        LDRB    R0, [R4, #CHN_SUSTAIN]
        CMP     R5, R0
        BHI     C_channel_vol_calc              @ sample didn't decay yet
        /* sustain handler */
        MOVS    R5, R0                          @ current level = sustain level
        BEQ     C_adsr_released                 @ sustain level #0 --> branch
        /* step to next phase otherweise */
        B       C_adsr_next_state

C_adsr_attack_check:
        /* attack handler */
        CMP     R2, #FLAG_CHN_ATTACK
        BNE     C_channel_vol_calc              @ if it isn't in attack attack phase, it has to be in sustain (keep vol) --> branch

C_adsr_attack:
        /* apply attack summand */
        LDRB    R0, [R4, #CHN_ATTACK]
        ADD     R5, R0
        CMP     R5, #0xFF
        BLO     C_adsr_save_and_finalize
        /* cap attack at 0xFF */
        MOVS    R5, #0xFF
 
C_adsr_next_state:
        /* switch to next adsr phase */
        SUB     R6, #1

C_adsr_save_and_finalize:
        /* store channel status */
        STRB    R6, [R4, #CHN_STATUS]

C_channel_vol_calc:
        /* store the calculated ADSR level */
        STRB    R5, [R4, #CHN_ADSR_LEVEL]
        /* apply master volume */
        LDR     R0, [SP, #ARG_PCM_STRUCT]
        LDRB    R0, [R0, #VAR_MASTER_VOL]
        ADD     R0, #1
        MUL     R5, R0
        /* left side volume */
        LDRB    R0, [R4, #CHN_VOL_2]
        MUL     R0, R5
        LSR     R0, #13
        MOV     R10, R0                         @ R10 = left volume
        /* right side volume */
        LDRB    R0, [R4, #CHN_VOL_1]
        MUL     R0, R5
        LSR     R0, #13
        MOV     R11, R0                         @ R11 = right volume
        /*
         * Now we get closer to actual mixing:
         * For looped samples some additional operations are required
         */
        MOVS    R0, #FLAG_CHN_LOOP
        AND     R0, R6
        BEQ     C_skip_sample_loop_setup
        /* loop setup handler */
        ADD     R3, #WAVE_LOOP_START
        LDMIA   R3!, {R0, R1}                   @ R0 = loop start, R1 = loop end
        ADD     R3, R0                          @ R3 = loop start position (absolute)
        STR     R3, [SP, #ARG_LOOP_START_POS]
        SUB     R0, R1, R0

C_skip_sample_loop_setup:
        /* do the rest of the setup */
        STR     R0, [SP, #ARG_LOOP_LENGTH]      @ if loop is off --> R0 = 0x0
        LDR     R5, hq_buffer
        LDR     R2, [R4, #CHN_SAMPLE_COUNTDOWN]
        LDR     R3, [R4, #CHN_POSITION_ABS]
        LDRB    R0, [R4, #CHN_MODE]
        ADR     R1, C_mixing_setup
        BX      R1

    .align  2
hq_buffer:
    .word   hq_buffer_ptr
hq_buffer_length:     @ TODO: Replace with variable on stack
    .word   0xFFFFFFFF

    .arm
    .align  2

C_mixing_setup:
        /* frequency and mixing loading routine */
        LDR     R8, hq_buffer_length
        ORRS    R11, R10, R11, LSL#16           @ R11 = 00RR00LL
        BEQ     C_mixing_epilogue               @ volume #0 --> branch and skip channel processing
        /* normal processing otherwise */
        TST     R0, #MODE_FIXED_FREQ
        BNE     C_setup_fixed_freq_mixing
        TST     R0, #MODE_COMP
        BNE     C_setup_special_mixing          @ compressed? --> branch

        STMFD   SP!, {R4, R9, R12}
        /*
         * This mixer supports 4 different kind of synthesized sounds
         * They are triggered if there is no samples to play
         * This get's checked below
         */
        MOVS    R2, R2
        ORREQ   R0, R0, #MODE_SYNTH
        STREQB  R0, [R4, #CHN_MODE]
        ADD     R4, R4, #CHN_FINE_POSITION
        LDMIA   R4, {R7, LR}                    @ R7 = Fine Position, LR = Frequency
        MUL     R4, LR, R12                     @ R4 = inter sample steps = output rate factor * samplerate
        /* now the first samples get loaded */
        LDRSB   R6, [R3], #1
        LDRSB   R12, [R3]
        TST     R0, #MODE_SYNTH
        BNE     C_setup_synth
        /* incase no synth mode should be used, code contiues here */
        SUB     R12, R12, R6                    @ R12 = DELTA
        /*
         * Mixing goes with volume ranges 0-127
         * They come in 0-255 --> divide by 2
         */
        MOVS    R11, R11, LSR#1
        ADC     R11, R11, #0x8000
        BIC     R11, R11, #0xFF00
        MOV     R1, R7                          @ R1 = inter sample position
        /*
         * There is 2 different mixing codepaths for uncompressed data
         *  path 1: fast mixing, but doesn't supports loop or stop
         *  path 2: not so fast but supports sample loops / stop
         * This checks if there is enough samples aviable for path 1.
         * important: R0 is expected to be #0
         */
        UMLAL   R1, R0, R4, R8
        MOV     R1, R1, LSR#23
        ORR     R0, R1, R0, LSL#9
        CMP     R2, R0                          @ actual comparison
        BLE     C_setup_unbuffered_mixing       @ if not enough samples are available for path 1 --> branch
        /* 
         * This is the mixer path 1.
         * The interesting thing here is that the code will
         * buffer enough samples on stack if enough space
         * on stack is available (or goes over the limit of 0x400 bytes)
         */
        SUB     R2, R2, R0
        LDR     R10, upper_stack_bounds
        ADD     R10, R10, R0
        CMP     R10, SP
        ADD     R10, R3, R0
        ADR     R9, stack_backup
        /*
         * R2 = remaining samples after processing
         * R10 = final sample position
         * SP = original stack location
         * These values will get reloaded after channel processing
         * due to the lack of registers.
         */
        STMIA   R9, {R2, R10, SP}
        CMPCC   R0, #0x400                      @ > 0x400 bytes --> read directly from ROM rather than buffered
        BCS     C_select_highspeed_codepath
        /*
         * The code below inits the DMA to read word aligned
         * samples from ROM to stack
         */
        BIC     R1, R3, #3
        MOV     R9, #0x04000000
        ADD     R9, R9, #0xD4
        ADD     R0, R0, #7
        MOV     R0, R0, LSR#2
        SUB     SP, SP, R0, LSL#2
        AND     R3, R3, #3
        ADD     R3, R3, SP
        ORR     LR, R0, #0x84000000
        STMIA   R9, {R1, SP, LR}                @ actually starts the DMA

        /* Somehow is neccesary for some games not to break */
    .if DMA_FIX==1
        MOV    R0, #0
        MOV    R1, #0
        MOV    R2, #0
        STMIA R9, {R0, R1, R2}
    .endif

C_select_highspeed_codepath:
        /*
         * This code decides which piece of code to load
         * depending on playback-rate / default-rate ratio.
         * Modes > 1.0 run with different volume levels.
         * R4 = inter sample step
         */
        ADR     R0, high_speed_code_resource    @ loads the base pointer of the code
        SUBS    R4, R4, #0x800000
        MOVPL   R11, R11, LSL#1                 @  if >= 1.0*   0-127 --> 0-254 volume level
        ADDPL   R0, R0, #(ARM_OP_LEN*6)         @               6 instructions further
        SUBPLS  R4, R4, #0x800000               @  if >= 2.0*
        ADDPL   R0, R0, #(ARM_OP_LEN*6)
        ADDPL   R4, R4, #0x800000
        LDR     R2, previous_fast_code
        CMP     R0, R2                          @ code doesn't need to be reloaded if it's already in place
        BEQ     C_skip_fast_mixing_creation
        /* This loads the needed code to RAM */
        STR     R0, previous_fast_code
        LDMIA   R0, {R0-R2, R8-R10}             @ load 6 opcodes
        ADR     LR, fast_mixing_instructions

C_fast_mixing_creation_loop:
            /* paste code to destination, see below for patterns */
            STMIA   LR, {R0, R1}
            ADD     LR, LR, #(ARM_OP_LEN*38)
            STMIA   LR, {R0, R1}
            SUB     LR, LR, #(ARM_OP_LEN*35)
            STMIA   LR, {R2, R8-R10}
            ADD     LR, LR, #(ARM_OP_LEN*38)
            STMIA   LR, {R2, R8-R10}
            SUB     LR, LR, #(ARM_OP_LEN*32)
            ADDS    R5, R5, #0x40000000         @ do that for 4 blocks
            BCC     C_fast_mixing_creation_loop

        LDR     R8, hq_buffer_length

C_skip_fast_mixing_creation:
        MOV     R2, #0xFF000000                 @ load the fine position overflow bitmask
C_fast_mixing_loop:
        /* This is the actual processing and interpolation code loop; NOPs will be replaced by the code above */
            LDMIA   R5, {R0, R1, R10, LR}         @ load 4 stereo samples to Registers
            MUL     R9, R7, R12
fast_mixing_instructions:
            NOP                                 @ Block #1
            NOP
            MLANE   R0, R11, R9, R0
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            MULNE   R9, R7, R12
            NOP                                 @ Block #2
            NOP
            MLANE   R1, R11, R9, R1
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            MULNE   R9, R7, R12
            NOP                                 @ Block #3
            NOP
            MLANE   R10, R11, R9, R10
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            MULNE   R9, R7, R12
            NOP                                 @ Block #4
            NOP
            MLANE   LR, R11, R9, LR
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            STMIA   R5!, {R0, R1, R10, LR}        @ write 4 stereo samples
            
            LDMIA   R5, {R0, R1, R10, LR}         @ load the next 4 stereo samples
            MULNE   R9, R7, R12    
            NOP                                 @ Block #1
            NOP
            MLANE   R0, R11, R9, R0
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            MULNE   R9, R7, R12
            NOP                                 @ Block #2
            NOP
            MLANE   R1, R11, R9, R1
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            MULNE   R9, R7, R12
            NOP                                 @ Block #3
            NOP
            MLANE   R10, R11, R9, R10
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            MULNE   R9, R7, R12
            NOP                                 @ Block #4
            NOP
            MLANE   LR, R11, R9, LR
            NOP
            NOP
            NOP
            NOP
            BIC     R7, R7, R2, ASR#1
            STMIA   R5!, {R0, R1, R10, LR}      @ write 4 stereo samples
            SUBS    R8, R8, #8
            BGT     C_fast_mixing_loop
        /* restore previously saved values */
        ADR     R12, stack_backup
        LDMIA   R12, {R2, R3, SP}
        B       C_end_mixing

/* Various variables for the cached mixer */

    .align    2
stack_backup:
    .word    0x0, 0x0, 0x0
upper_stack_bounds:
    .word    0x03007910
previous_fast_code:
    .word    0x0 /* mark as invalid initially */

/* Those instructions below are used by the high speed loop self modifying code */
high_speed_code_resource:
    /* Block for Mix Freq < 1.0 * Output Frequency */
    MOV     R9, R9, ASR#22
    ADDS    R9, R9, R6, LSL#1
    ADDS    R7, R7, R4
    ADDPL   R6, R12, R6
    LDRPLSB R12, [R3, #1]!
    SUBPLS  R12, R12, R6

    /* Block for Mix Freq > 1.0 AND < 2.0 * Output Frequency */
    ADDS    R9, R6, R9, ASR#23
    ADD     R6, R12, R6
    ADDS    R7, R7, R4
    LDRPLSB R6, [R3, #1]!
    LDRSB   R12, [R3, #1]!
    SUBS    R12, R12, R6

    /* Block for Mix Freq > 2.0 * Output Frequency */
    ADDS    R9, R6, R9, ASR#23
    ADD     R7, R7, R4
    ADD     R3, R3, R7, LSR#23
    LDRSB   R6, [R3]
    LDRSB   R12, [R3, #1]!
    SUBS    R12, R12, R6

/* incase a loop or end occurs during mixing, this code is used */
C_setup_unbuffered_mixing:
        ADD     R5, R5, R8, LSL#2               @ R5 = End of HQ buffer

/* This below is the unbuffered mixing loop. R6 = base sample, R12 diff to next */
C_unbuffered_mixing_loop:

        MUL     R9, R7, R12
        MOV     R9, R9, ASR#22
        ADDS    R9, R9, R6, LSL#1
        LDRNE   R0, [R5, -R8, LSL#2]
        MLANE   R0, R11, R9, R0
        STRNE   R0, [R5, -R8, LSL#2]
        ADD     R7, R7, R4
        MOVS    R9, R7, LSR#23
        BEQ     C_unbuffered_mixing_skip_load   @ skip the mixing load if it isn't required
        
        SUBS    R2, R2, R7, LSR#23
        BLLE    C_mixing_loop_or_end
        SUBS    R9, R9, #1
        ADDEQ   R6, R12, R6
        @RETURN LOCATION FROM LOOP HANDLER
        LDRNESB R6, [R3, R9]!
        LDRSB   R12, [R3, #1]!
        SUB     R12, R12, R6
        BIC     R7, R7, #0x3F800000

C_unbuffered_mixing_skip_load:
        SUBS    R8, R8, #1                      @ reduce the sample count for the buffer by #1
        BGT     C_unbuffered_mixing_loop

C_end_mixing:
        SUB     R3, R3, #1                      @ because the mixer always needs 1 byte lookahead, this reverts it
        LDMFD   SP!, {R4, R9, R12}
        STR     R7, [R4, #CHN_FINE_POSITION]
        B       C_mixing_end_store

C_mixing_loop_or_end:
        /* This loads the loop information end loops incase it should */
        ADD     R3, SP, #ARG_LOOP_START_POS+0xC
        LDMIA   R3, {R3, R6}                    @ R3 = Loop Start; R6 = Loop Length
        CMP     R6, #0                          @ check if loop is enabled; if Loop is enabled R6 is != 0
        RSBNE   R9, R2, #0                      @ loop wraparound logic
        ADDNE   R2, R6, R2
        ADDNE   PC, LR, #(ARM_OP_LEN*2)
        LDMFD   SP!, {R4, R9, R12}
        B       C_mixing_end_and_stop_channel   @ R6 == 0 (always)

C_fixed_mixing_loop_or_end:
        LDR     R2, [SP, #ARG_LOOP_LENGTH+0x8]
        MOVS    R6, R2                          @ copy it to R6 and check whether loop is disabled
        LDRNE   R3, [SP, #ARG_LOOP_START_POS+0x8]
        BXNE    LR                              @ if it loops return to mixing function, if it doesn't go on end mixing

        LDMFD   SP!, {R4, R9}

C_mixing_end_and_stop_channel:
        STRB    R6, [R4]                        @ update channel flag with chn halt
        B       C_mixing_epilogue

/* These are used for the fixed freq mixer */
fixed_mixing_code_resource:
    MOVS    R6, R10, LSL#24
    MOVS    R6, R6, ASR#24
    MOVS    R6, R10, LSL#16
    MOVS    R6, R6, ASR#24
    MOVS    R6, R10, LSL#8
    MOVS    R6, R6, ASR#24
    MOVS    R6, R10, ASR#24
    LDMIA   R3!, {R10}                          @ load chunk of samples
    MOVS    R6, R10, LSL#24
    MOVS    R6, R6, ASR#24
    MOVS    R6, R10, LSL#16
    MOVS    R6, R6, ASR#24
    MOVS    R6, R10, LSL#8
    MOVS    R6, R6, ASR#24
    LDMFD   SP!, {R4, R9, R12}

C_setup_fixed_freq_mixing:
        STMFD   SP!, {R4, R9}

C_fixed_mixing_length_check:
        MOV     LR, R2                          @ sample countdown
        CMP     R2, R8
        MOVGT   LR, R8                          @ min(buffer_size, sample_countdown)
        SUB     LR, LR, #1
        MOVS    LR, LR, LSR#2
        BEQ     C_fixed_mixing_process_rest  @ <= 3 samples to process
        
        SUB     R8, R8, LR, LSL#2               @ subtract the amount of samples we need to process from the buffer length
        SUB     R2, R2, LR, LSL#2               @ subtract the amount of samples we need to process from the remaining samples
        ADR     R1, fixed_mixing_instructions
        ADR     R0, fixed_mixing_code_resource
        MOV     R9, R3, LSL#30
        ADD     R0, R0, R9, LSR#27              @ alignment * 8 + resource offset = new resource offset
        LDMIA   R0!, {R6, R7, R9, R10}          @ load and write instructions
        STMIA   R1, {R6, R7}
        ADD     R1, R1, #0xC
        STMIA   R1, {R9, R10}
        ADD     R1, R1, #0xC
        LDMIA   R0, {R6, R7, R9, R10}
        STMIA   R1, {R6, R7}
        ADD     R1, R1, #0xC
        STMIA   R1, {R9, R10}
        LDMIA   R3!, {R10}                      @ load 4 samples from ROM

C_fixed_mixing_loop:
            LDMIA    R5, {R0, R1, R7, R9}       @ load 4 samples from hq buffer

fixed_mixing_instructions:
            NOP
            NOP
            MLANE   R0, R11, R6, R0             @ add new sample if neccessary
            NOP
            NOP
            MLANE   R1, R11, R6, R1
            NOP
            NOP
            MLANE   R7, R11, R6, R7
            NOP
            NOP
            MLANE   R9, R11, R6, R9
            STMIA   R5!, {R0, R1, R7, R9}       @ write samples to the mixing buffer
            SUBS    LR, LR, #1
            BNE     C_fixed_mixing_loop

        SUB     R3, R3, #4                      @ we'll need to load this block again, so rewind a bit

C_fixed_mixing_process_rest:
        MOV     R1, #4                          @ repeat the loop #4 times to completley get rid of alignment errors

C_fixed_mixing_unaligned_loop:
            LDR     R0, [R5]
            LDRSB   R6, [R3], #1
            MLA     R0, R11, R6, R0
            STR     R0, [R5], #4
            SUBS    R2, R2, #1
            BLEQ    C_fixed_mixing_loop_or_end
            SUBS    R1, R1, #1
            BGT     C_fixed_mixing_unaligned_loop

        SUBS    R8, R8, #4
        BGT     C_fixed_mixing_length_check     @ repeat the mixing procedure until the buffer is filled

        LDMFD   SP!, {R4, R9}

C_mixing_end_store:
        STR     R2, [R4, #CHN_SAMPLE_COUNTDOWN]
        STR     R3, [R4, #CHN_POSITION_ABS]            

C_mixing_epilogue:
        ADR     R0, (C_end_channel_state_loop+1)
        BX      R0

    .thumb

C_end_channel_state_loop:
        LDR     R0, [SP, #ARG_REMAIN_CHN]
        SUB     R0, #1
        BLE     C_main_mixer_return

        ADD     R4, #0x40
        B       C_channel_state_loop

C_main_mixer_return:
        ADR     R0, C_downsampler
        BX      R0

    .arm
    .align  2

C_downsampler:
    LDR     R10, hq_buffer
    LDR     R9, [SP, #ARG_BUFFER_POS]
    LDR     R8, hq_buffer_length
    MOV     R11, #0xFF

.if ENABLE_CLIPPING==1

    MOV     R12, #0xFFFFFFFF
    MOV     R12, R12, LSL#14
    MOV     R7, #0x630

C_downsampler_loop:
        LDRSH   R2, [R10], #2
        LDRSH   R0, [R10], #2
        LDRSH   R3, [R10], #2
        LDRSH   R1, [R10], #2
        
        CMP     R0, #0x4000
        MOVGE   R0, #0x3F80
        CMP     R0, #-0x4000
        MOVLT   R0, R12
        
        CMP     R1, #0x4000
        MOVGE   R1, #0x3F80
        CMP     R1, #-0x4000
        MOVLT   R1, R12
        
        CMP     R2, #0x4000
        MOVGE   R2, #0x3F80
        CMP     R2, #-0x4000
        MOVLT   R2, R12
        
        CMP     R3, #0x4000
        MOVGE   R3, #0x3F80
        CMP     R3, #-0x4000
        MOVLT   R3, R12
        
        AND     R0, R11, R0, ASR#7
        AND     R1, R11, R1, ASR#7
        AND     R2, R11, R2, ASR#7
        AND     R3, R11, R3, ASR#7
        
        ORR     R2, R2, R3, LSL#8
        ORR     R0, R0, R1, LSL#8
        
        STRH    R2, [R9, R7]
        STRH    R0, [R9], #2
        
        SUBS    R8, #2
        BGT     C_downsampler_loop
        
.else
C_downsampler_loop:
        LDRH    R4, [R10], #2
        LDRH    R0, [R10], #2
        LDRH    R5, [R10], #2
        LDRH    R1, [R10], #2
        LDRH    R6, [R10], #2
        LDRH    R2, [R10], #2
        LDRH    R7, [R10], #2
        LDRH    R3, [R10], #2
        
        AND     R0, R11, R0, LSR#7
        AND     R1, R11, R1, LSR#7
        AND     R2, R11, R2, LSR#7
        AND     R3, R11, R3, LSR#7
        AND     R4, R11, R4, LSR#7
        AND     R5, R11, R5, LSR#7
        AND     R6, R11, R6, LSR#7
        AND     R7, R11, R7, LSR#7
        
        ORR     R4, R4, R5, LSL#8
        ORR     R4, R4, R6, LSL#16
        ORR     R4, R4, R7, LSL#24
        
        ORR     R0, R0, R1, LSL#8
        ORR     R0, R0, R2, LSL#16
        ORR     R0, R0, R3, LSL#24
        
        STR     R4, [R9, #0x630]
        STR     R0, [R9], #4
        
        SUBS    R8, #4
        BGT     C_downsampler_loop
.endif

    ADR     R0, (C_downsampler_return+1)
    BX      R0

    .thumb

C_downsampler_return:
    LDR     R0, [SP, #ARG_PCM_STRUCT]
    LDR     R3, mixer_finished_status           @ this is used to indicate the interrupt handler the rendering was finished properly
    STR     R3, [R0]
    ADD     SP, SP, #0x1C
    POP     {R0-R7}
    MOV     R8, R0
    MOV     R9, R1
    MOV     R10, R2
    MOV     R11, R3
    POP     {R3}
    BX      R3

    .align  2

mixer_finished_status:
    .word    0x68736D53

    .arm
    .align  2

C_setup_synth:
        CMP     R12, #0
        BNE     C_check_synth_saw

        /* modulating pulse wave */
        LDRB    R6, [R3, #SYNTH_WIDTH_CHANGE_1]
        ADD     R2, R2, R6, LSL#24
        LDRB    R6, [R3, #SYNTH_WIDTH_CHANGE_2]
        ADDS    R6, R2, R6, LSL#24
        MVNMI   R6, R6
        MOV     R10, R6, LSR#8
        LDRB    R1, [R3, #SYNTH_MOD_AMOUNT]
        LDRB    R0, [R3, #SYNTH_BASE_WAVE_DUTY]
        MOV     R0, R0, LSL#24
        MLA     R6, R10, R1, R0                 @ calculate the final duty cycle with the offset, and intensity * rotating duty cycle amount
        STMFD   SP!, {R2, R3, R9, R12}

C_synth_pulse_loop:
            LDMIA   R5, {R0-R3, R9, R10, R12, LR} @ load 8 samples
            CMP     R7, R6                      @ Block #1
            ADDLO   R0, R0, R11, LSL#6
            SUBHS   R0, R0, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #2
            ADDLO   R1, R1, R11, LSL#6
            SUBHS   R1, R1, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #3
            ADDLO   R2, R2, R11, LSL#6
            SUBHS   R2, R2, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #4
            ADDLO   R3, R3, R11, LSL#6
            SUBHS   R3, R3, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #5
            ADDLO   R9, R9, R11, LSL#6
            SUBHS   R9, R9, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #6
            ADDLO   R10, R10, R11, LSL#6
            SUBHS   R10, R10, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #7
            ADDLO   R12, R12, R11, LSL#6
            SUBHS   R12, R12, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            CMP     R7, R6                      @ Block #8
            ADDLO   LR, LR, R11, LSL#6
            SUBHS   LR, LR, R11, LSL#6
            ADDS    R7, R7, R4, LSL#3
            
            STMIA   R5!, {R0-R3, R9, R10, R12, LR} @ write 8 samples
            SUBS    R8, R8, #8
            BGT     C_synth_pulse_loop

        LDMFD   SP!, {R2, R3, R9, R12}
        B       C_end_mixing

C_check_synth_saw:
        /*
         * This is actually not a true saw wave
         * but looks pretty similar
         * (has a jump in the middle of the wave)
         */
        SUBS    R12, R12, #1
        BNE     C_synth_triangle

        MOV     R6, #0x300
        MOV     R11, R11, LSR#1
        BIC     R11, R11, #0xFF00
        MOV     R12, #0x70

C_synth_saw_loop:

            LDMIA   R5, {R0, R1, R10, LR}       @ load 4 samples from memory
            ADDS    R7, R7, R4, LSL#3           @ Block #1 (some oscillator type code)
            RSB     R9, R12, R7, LSR#24
            MOV     R6, R7, LSL#1
            SUB     R9, R9, R6, LSR#27
            ADDS    R2, R9, R2, ASR#1
            MLANE   R0, R11, R2, R0
            
            ADDS    R7, R7, R4, LSL#3           @ Block #2
            RSB     R9, R12, R7, LSR#24
            MOV     R6, R7, LSL#1
            SUB     R9, R9, R6, LSR#27
            ADDS    R2, R9, R2, ASR#1
            MLANE   R1, R11, R2, R1
            
            ADDS    R7, R7, R4, LSL#3           @ Block #3
            RSB     R9, R12, R7, LSR#24
            MOV     R6, R7, LSL#1
            SUB     R9, R9, R6, LSR#27
            ADDS    R2, R9, R2, ASR#1
            MLANE   R10, R11, R2, R10
            
            ADDS    R7, R7, R4, LSL#3           @ Block #4
            RSB     R9, R12, R7, LSR#24
            MOV     R6, R7, LSL#1
            SUB     R9, R9, R6, LSR#27
            ADDS    R2, R9, R2, ASR#1
            MLANE   LR, R11, R2, LR
            
            STMIA   R5!, {R0, R1, R10, LR}
            SUBS    R8, R8, #4
            BGT     C_synth_saw_loop

        B       C_end_mixing

C_synth_triangle:
        MOV     R6, #0x80
        MOV     R12, #0x180

C_synth_triangle_loop:
            LDMIA   R5, {R0, R1, R10, LR}       @ load samples from work buffer
            ADDS    R7, R7, R4, LSL#3           @ Block #1
            RSBPL   R9, R6, R7, ASR#23
            SUBMI   R9, R12, R7, LSR#23
            MLA     R0, R11, R9, R0
            
            ADDS    R7, R7, R4, LSL#3           @ Block #2
            RSBPL   R9, R6, R7, ASR#23
            SUBMI   R9, R12, R7, LSR#23
            MLA     R1, R11, R9, R1
            
            ADDS    R7, R7, R4, LSL#3           @ Block #3
            RSBPL   R9, R6, R7, ASR#23
            SUBMI   R9, R12, R7, LSR#23
            MLA     R10, R11, R9, R10
            
            ADDS    R7, R7, R4, LSL#3           @ Block #4
            RSBPL   R9, R6, R7, ASR#23
            SUBMI   R9, R12, R7, LSR#23
            MLA     LR, R11, R9, LR
            
            STMIA   R5!, {R0, R1, R10, LR}
            SUBS    R8, R8, #4                  @ subtract #4 from the remainging samples
            BGT     C_synth_triangle_loop

        B       C_end_mixing

    .if ENABLE_DECOMPRESSION==1
C_setup_special_mixing:
        LDR     R6, [R4, #CHN_WAVE_OFFSET]
        LDRB    R0, [R4]
        TST     R0, #FLAG_CHN_COMP
        BNE     C_setup_special_mixing_freq     @ skip the setup procedure if it's running in compressed mode already

        ORR     R0, #FLAG_CHN_COMP
        STRB    R0, [R4]
        LDRB    R0, [R4, #CHN_MODE]
        TST     R0, #MODE_REVERSE
        BEQ     C_check_compression             @ reversed mode not enabled?

        LDR     R1, [R6, #WAVE_LENGTH]          @ calculate seek position for reverse playback
        ADD     R1, R1, R6, LSL#1               @ sorry, I don't actually understand that piece of code myself
        ADD     R1, R1, #0x20
        SUB     R3, R1, R3
        STR     R3, [R4, #CHN_POSITION_ABS]

C_check_compression:
        LDRH    R0, [R6]
        CMP     R0, #0
        BEQ     C_setup_special_mixing_freq
        
        SUB     R3, R3, R6
        SUB     R3, R3, #0x10
        STR     R3, [R4, #CHN_POSITION_ABS]

C_setup_special_mixing_freq:
        LDR     R0, [R6, #WAVE_LOOP_START]
        STR     R0, [SP, #ARG_LOOP_START_POS]

        STMFD   SP!, {R4, R9, R12}

        MOVS    R11, R11, LSR#1
        ADC     R11, R11, #0x8000
        BIC     R11, R11, #0xFF00
        
        LDR     R7, [R4, #CHN_FINE_POSITION]
        LDR     R1, [R4, #CHN_FREQUENCY]
        LDRB    R0, [R4, #CHN_MODE]
        TST     R0, #MODE_FIXED_FREQ
        MOVNE   R1, #0x800000
        MULEQ   R1, R12, R1                     @ default rate factor * frequency = sample steps
        
        ADD     R5, R5, R8, LSL#2               @ set the buffer pointer to the end of the channel, same as slow mixing mode
        
        LDRH    R0, [R6]
        CMP     R0, #0
        BEQ     C_uncompressed_reverse_mixing_check
        
        MOV     R0, #0xFF000000                 @ --> invalid channel mod
        STR     R0, [R4, #CHN_BLOCK_COUNT]
        LDRB    R0, [R4, #CHN_MODE]
        TST     R0, #MODE_REVERSE
        BNE     C_setup_compressed_reverse_mixing  @ check again of reverse mixing is enabled

        /* forward compressed mixing */
        BL      F_bdpcm_decoder
        MOV     R6, R12
        ADD     R3, R3, #1
        BL      F_bdpcm_decoder
        SUB     R12, R12, R6

        @***** MIXING LOOP REGISTER USAGE ***********@
        @ R0:    Sample to modify from buffer
        @ R1:    sample steps        (MOVED FROM R4)
        @ R2:    remaining samples before loop/end
        @ R3:    sample position
        @ R4:    channel pointer
        @ R5:    pointer to the end of buffer
        @ R6:    Base sample
        @ R7:    fine position
        @ R8:    remaining samples for current buffer
        @ R9:    interpolated sample
        @ R10:   not used
        @ R11:   volume
        @ R12:   Delta Sample
        @ LR:    not used
        @********************************************@

C_compressed_mixing_loop:
            MUL     R9, R7, R12                 @ check slow mixing for details, same procedure here
            MOV     R9, R9, ASR#22
            ADDS    R9, R9, R6, LSL#1
            LDRNE   R0, [R5, -R8, LSL#2]
            MLANE   R0, R11, R9, R0
            STRNE   R0, [R5, -R8, LSL#2]
            ADD     R7, R7, R1                  @ ### changed from R4 to R1
            MOVS    R9, R7, LSR#23
            BEQ     C_compressed_mixing_skip_load

            SUBS    R2, R2, R7, LSR#23
            BLLE    C_mixing_loop_or_end
            SUBS    R9, R9, #1
            ADDEQ   R6, R12, R6
            BEQ     C_compressed_mixing_skip_base_load

            ADD     R3, R3, R9                  @ equivalent to LDRNESB R6, [R3, R9]!
            BL      F_bdpcm_decoder
            MOV     R6, R12

C_compressed_mixing_skip_base_load:
            ADD     R3, R3, #1                  @ equivalent to LDRSB R12, [R3, #1]!
            BL      F_bdpcm_decoder
            SUB     R12, R12, R6
            BIC     R7, R7, #0x3F800000

C_compressed_mixing_skip_load:
            SUBS    R8, R8, #1
            BGT     C_compressed_mixing_loop

        B       C_end_mixing

C_setup_compressed_reverse_mixing:
        SUB     R3, R3, #1
        BL      F_bdpcm_decoder
        MOV     R6, R12
        SUB     R3, R3, #1
        BL      F_bdpcm_decoder
        SUB     R12, R12, R6

C_compressed_reverse_mixing_loop:
            MUL     R9, R7, R12
            MOV     R9, R9, ASR#22
            ADDS    R9, R9, R6, LSL#1
            LDRNE   R0, [R5, -R8, LSL#2]
            MLANE   R0, R11, R9, R0
            STRNE   R0, [R5, -R8, LSL#2]
            ADD     R7, R7, R1                  @ ### changed from R4 to R1
            MOVS    R9, R7, LSR#23
            BEQ     C_compressed_reverse_mixing_skip_load

            SUBS    R2, R2, R7, LSR#23
            BLLE    C_mixing_loop_or_end
            SUBS    R9, R9, #1
            ADDEQ   R6, R12, R6
            BEQ     C_compressed_reverse_mixing_skip_base_load

            SUB     R3, R3, R9
            BL      F_bdpcm_decoder
            MOV     R6, R12

C_compressed_reverse_mixing_skip_base_load:
            SUB     R3, R3, #1
            BL      F_bdpcm_decoder
            SUB     R12, R12, R6
            BIC     R7, R7, #0x3F800000

C_compressed_reverse_mixing_skip_load:
            SUBS    R8, R8, #1
            BGT     C_compressed_reverse_mixing_loop

        ADD     R3, R3, #3
        B       C_end_mixing

C_uncompressed_reverse_mixing_check:
        LDRB    R0, [R4, #1]
        TST     R0, #MODE_REVERSE               @ check if reverse mode is even enabled (consistency)
        BEQ     C_end_mixing
        
        LDRSB   R6, [R3, #-1]!
        LDRSB   R12, [R3, #-1]
        SUB     R12, R12, R6

C_uncompressed_reverse_mixing_loop:
            MUL     R9, R7, R12
            MOV     R9, R9, ASR#22
            ADDS    R9, R9, R6, LSL#1
            LDRNE   R0, [R5, -R8, LSL#2]
            MLANE   R0, R11, R9, R0
            STRNE   R0, [R5, -R8, LSL#2]
            ADD     R7, R7, R1                  @ ### changed from R4 to R1
            MOVS    R9, R7, LSR#23
            BEQ     C_uncompressed_reverse_mixing_load_skip
            
            SUBS    R2, R2, R7, LSR#23
            BLLE    C_mixing_loop_or_end
            
            MOVS    R9, R9
            ADDEQ   R6, R12, R6
            LDRNESB R6, [R3, -R9]!
            LDRSB   R12, [R3, #-1]
            SUB     R12, R12, R6
            BIC     R7, R7, #0x3F800000

C_uncompressed_reverse_mixing_load_skip:
            SUBS    R8, R8, #1
            BGT     C_uncompressed_reverse_mixing_loop

        ADD     R3, R3, #2
        B       C_end_mixing 

/*
 * This is the main BDPCM Decoder
 * It decodes and caches a block of PCM data
 * and returns them in R12
 */
F_bdpcm_decoder:

    STMFD   SP!, {R0, R2, R5-R7, LR}
    MOV     R0, R3, LSR#6                       @ clip off everything but the block offset, each block is 0x40 samples long
    LDR     R12, [R4, #CHN_BLOCK_COUNT]
    CMP     R0, R12
    BEQ     C_bdpcm_decoder_return              @ block already decoded -> skip
    
    STR     R0, [R4, #CHN_BLOCK_COUNT]
    MOV     R12, #0x21                          @ 1 Block = 0x21 Bytes, 0x40 decoded samples
    MUL     R2, R12, R0
    LDR     R12, [R4, #CHN_WAVE_OFFSET]
    ADD     R2, R2, R12                         @ calc block ROM position
    ADD     R2, R2, #0x10
    LDR     R5, decoder_buffer
    ADR     R6, delta_lookup_table
    MOV     R7, #0x40                           @ 1 block  = 0x40 samples
    LDRB    LR, [R2], #1
    STRB    LR, [R5], #1
    LDRB    R12, [R2], #1
    B       C_bdpcm_decoder_lsb

C_bdpcm_decoder_msb:
        LDRB    R12, [R2], #1
        MOV     R0, R12, LSR#4
        LDRSB   R0, [R6, R0]
        ADD     LR, LR, R0
        STRB    LR, [R5], #1

C_bdpcm_decoder_lsb:
        AND     R0, R12, #0xF
        LDRSB   R0, [R6, R0]
        ADD     LR, LR, R0
        STRB    LR, [R5], #1
        SUBS    R7, R7, #2 
        BGT     C_bdpcm_decoder_msb

C_bdpcm_decoder_return:
    LDR     R5, decoder_buffer
    AND     R0, R3, #0x3F
    LDRSB   R12, [R5, R0]
    LDMFD   SP!, {R0, R2, R5-R7, PC}

    .align  2

decoder_buffer:
    .word    decoder_buffer_target

delta_lookup_table:
    .byte    0x0, 0x1, 0x4, 0x9, 0x10, 0x19, 0x24, 0x31, 0xC0, 0xCF, 0xDC, 0xE7, 0xF0, 0xF7, 0xFC, 0xFF

.endif  /* ENABLE_DECOMPRESSION*/

main_mixer_end:
    .end