#include <stdlib.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdio.h>

/* tri-Ace PS2 DCT-style codec.
 *
 * Adapted from Nisto's decoder w/ VU1 emulation:
 * - https://github.com/Nisto/pk3dec
 * Info:
 * - https://psi-rockin.github.io/ps2tek/
 * - https://github.com/PCSX2/pcsx2/blob/master/pcsx2/VUops.cpp
 *
 * Codec has no apparent name, but most functions mention "St" (stream?) and "Sac" (sound audio
 * compression?) and main lib is called "Sac" (Sac.cpp/Sac.dsm), also set in a "Csd" ELF. Looks inspired
 * by MPEG (much simplified) with bits from other codecs (per-file codebook and 1024 samples).
 *
 * Original decoder is mainly implemented in the PS2's VU1, a coprocessor specialized in vector/SIMD
 * and parallel instructions. As VU1 works with many 128 bit registers (typically x4 floats) algorithm
 * was tailored to do multiple ops at once. This code tries to simplify it into standard C to a point,
 * but keeps this vector style in main decoding to ease porting (since tables are made with SIMD in
 * mind it would need some transposing around) and for PS2 float simulation.
 *
 * Codec returns float samples then converted to PCM16. Output samples are +-1 vs Nisto's/PCSX2's
 * results, due to various quirks:
 * - simplified PS2 float handling (PS2 VU floats don't map 1:1 to PC IEEE floats), can be re-enabled (slow)
 * - various heisenbugs (PC 80b register floats <> 32b memory floats conversions, see transform()).
 *
 * Files are divided into blocks (size 0x4E000). At file start is a simple header and huffman codebook
 * then N VBR frames (of size around 0x200~300) containing huffman codes of spectral data. A frame has
 * codes for 2 channels, decoded separatedly (first all L then all R), then handle joint stereo.
 * Channel spectrum coefs are processeed, then MDCT(?) + window overlap to get final samples. When a
 * "block end frame" is found, handler must get next block and resume decoding (blocks may be pre/post
 * padded, for looping porposes). Game reads a couple of blocks at once though.
 */

/**********************************************************************************/
/* DEFINITIONS                                                                    */
/**********************************************************************************/
#include "tac_decoder_lib_data.h"
#include "tac_decoder_lib_ops.h"
#include "tac_decoder_lib.h"

//#define TAC_MAX_FRAME_SIZE  0x300 /* typically around ~0x1d0, observed max is ~0x2e2 */
#define TAC_CODED_BANDS     27
#define TAC_CODED_COEFS     32
#define TAC_TOTAL_POINTS    32 /* not sure about this term */
#define TAC_SCALE_TABLE_MAX_INDEX 511


struct tac_handle_t {
    /* base header */
    tac_header_t header;

    /* general state */
    int data_start;     /* first frame after huffman tables, within first block */
    int frame_offset;   /* current position within block */
    int frame_number;   /* frames must be sequential */

    /* decoding huffman tree state */
    int16_t huff_table_1[257]; /* init once */
    int16_t huff_table_2[TAC_CHANNELS][32]; /* saved between (some) frames */
    int16_t huff_table_3[258]; /* init once */
    uint8_t huff_table_4[16383]; /* init once */

    int16_t codes[TAC_CHANNELS][TAC_FRAME_SAMPLES];

    /* decoding vector state */
    REG_VF spectrum[TAC_CHANNELS][TAC_FRAME_SAMPLES / 4]; /* temp huffman-to-coefs */
    REG_VF wave[TAC_CHANNELS][TAC_FRAME_SAMPLES / 4]; /* final samples, in vector form */
    REG_VF hist[TAC_CHANNELS][TAC_FRAME_SAMPLES / 4]; /* saved between frames */
};


/**********************************************************************************/
/* MAIN DECODE                                                                    */
/**********************************************************************************/

/* similar to MP3's alias reduction step with pre-made SIMD tables:
 *  lo_out.M = (lo_in.M * AT[0x0+j].N) - (AT[0xF-j].M * lo_hi.N)
 *  hi_out.N = (lo_hi.N * AT[0x7-j].M) + (AT[0x8+j].N * lo_in.M) */
static void unpack_antialias(REG_VF* spectrum) {
    const REG_VF* AT = ANTIALIASING_TABLE;
    int i;
    int pos_lo = 0x7;
    int pos_hi = 0x8;

    for (i = 0; i < TAC_CODED_BANDS; i++) {
        for (int j = 0; j < 4; j++) {
            REG_VF lo_in, hi_in, lo_out, hi_out;

            LOAD (_xyzw, &lo_in, spectrum, pos_lo - j);
            LOAD (_xyzw, &hi_in, spectrum, pos_hi + j);

            MULx (____w, &lo_out, &lo_in,     &AT[0x0+j]);
            MSUBx(____w, &lo_out, &AT[0xF-j], &hi_in);
            MULw (_x___, &hi_out, &hi_in,     &AT[0x7-j]);
            MADDw(_x___, &hi_out, &AT[0x8+j], &lo_in);

            MULy (___z_, &lo_out, &lo_in,     &AT[0x0+j]);
            MSUBy(___z_, &lo_out, &AT[0xF-j], &hi_in);
            MULz (__y__, &hi_out, &hi_in,     &AT[0x7-j]);
            MADDz(__y__, &hi_out, &AT[0x8+j], &lo_in);

            MULz (__y__, &lo_out, &lo_in,     &AT[0x0+j]);
            MSUBz(__y__, &lo_out, &AT[0xF-j], &hi_in);
            MULy (___z_, &hi_out, &hi_in,     &AT[0x7-j]);
            MADDy(___z_, &hi_out, &AT[0x8+j], &lo_in);

            MULw (_x___, &lo_out, &lo_in,  &AT[0x0+j]);
            MSUBw(_x___, &lo_out, &AT[0xF-j], &hi_in);
            MULx (____w, &hi_out, &hi_in,  &AT[0x7-j]);
            MADDx(____w, &hi_out, &AT[0x8+j], &lo_in);

            STORE(_xyzw, spectrum, &lo_out, pos_lo - j);
            STORE(_xyzw, spectrum, &hi_out, pos_hi + j);
        }

        pos_lo += 0x8;
        pos_hi += 0x8;
    }
}


static inline int16_t clamp_s16(int16_t value, int16_t min, int16_t max) {
    if (value < min)
        return min;
    else if (value > max)
        return max;
    else
        return value;
}


/* converts 4 huffman codes to 4 spectrums coefs */
//SUB_1188 (Pass1_Start?)
static void unpack_code4(REG_VF* spectrum, const REG_VF* spc1, const REG_VF* spc2, const REG_VF* code, const REG_VF* idx, int out_pos) {
    const REG_VF* ST = SCALE_TABLE;
    REG_VF tbc1, tbc2, out;

    /* copy table coefs .N, unless huffman code was 0 */
    if (code->f.x != 0) {
        MOVEx(_x___, &tbc1, &ST[idx->i.x + 0]);
        MOVEx(_x___, &tbc2, &ST[idx->i.x + 1]);
    } else {
        MOVEx(_x___, &tbc1, &VECTOR_ZERO);
        MOVEx(_x___, &tbc2, &VECTOR_ZERO);
    }

    if (code->f.y != 0) {
        MOVEx(__y__, &tbc1, &ST[idx->i.y + 0]);
        MOVEx(__y__, &tbc2, &ST[idx->i.y + 1]);
    } else {
        MOVEx(__y__, &tbc1, &VECTOR_ZERO);
        MOVEx(__y__, &tbc2, &VECTOR_ZERO);
    }

    if (code->f.z != 0) {
        MOVEx(___z_, &tbc1, &ST[idx->i.z + 0]);
        MOVEx(___z_, &tbc2, &ST[idx->i.z + 1]);
    } else {
        MOVEx(___z_, &tbc1, &VECTOR_ZERO);
        MOVEx(___z_, &tbc2, &VECTOR_ZERO);
    }

    if (code->f.w != 0) {
        MOVEx(____w, &tbc1, &ST[idx->i.w + 0]);
        MOVEx(____w, &tbc2, &ST[idx->i.w + 1]);
    } else {
        MOVEx(____w, &tbc1, &VECTOR_ZERO);
        MOVEx(____w, &tbc2, &VECTOR_ZERO);
    }

    /* out = [signed] (scp1/scp2) * (tbc2 - tbc1) + tbc1 */
    DIV  (_xyzw, &out, spc1, spc2);
    SUB  (_xyzw, &tbc2, &tbc2, &tbc1);
    MUL  (_xyzw, &out, &out, &tbc2);
    ADD  (_xyzw, &out, &out, &tbc1);
    SIGN (_xyzw, &out, code);

    STORE(_xyzw, spectrum, &out, out_pos);
}


/* Unpacks huffman codes in one band into 32 spectrum coefs, using selected scales for that band. */
// SUB_C88
static void unpack_band(REG_VF* spectrum, const int16_t* codes, int band_pos, int* code_pos, int out_pos) {
    const REG_VF* ST = SCALE_TABLE;
    int i;
    int16_t base_index = codes[0]; /* table index, max ~35 */
    int16_t band_index = codes[band_pos]; /* table too */
    REG_VF scale;

    /* bad values should be caught by CRC check but for completeness */
    base_index = clamp_s16(base_index, 0, TAC_SCALE_TABLE_MAX_INDEX);
    band_index = clamp_s16(band_index, 0, TAC_SCALE_TABLE_MAX_INDEX-128);


    /* index zero = band is not coded and all of its coefs are 0 */
    if (band_index == 0) {
        for (i = 0; i < (TAC_CODED_COEFS / 4); i++) {
            STORE(_xyzw, spectrum, &VECTOR_ZERO, out_pos+i);
        }
        return;
    }

    /* put final band scale at .y */
    MULy (__y__, &scale, &ST[128 + band_index], &ST[base_index]);

    /* unpack coefs */
    for (i = 0; i < 8; i++) {
        REG_VF code, idx, tm01, tm02, tm03;
        REG_VF spc1, spc2;

        COPY (_xyzw, &code, &codes[(*code_pos)]);
        (*code_pos) += 4;

        /* scale coef then round down to int to get table indexes (!!!) */
        ABS  (_xyzw, &tm01, &code);
        MULy (_xyzw, &tm01, &tm01, &scale);
        FMUL (_xyzw, &tm02, &tm01, 512.0); /* 512 = SCALE_TABLE max */
        ADD  (_xyzw, &tm03, &tm02, &VECTOR_ONE);

        FTOI0(_xyzw, &idx, &tm02); /* keep idx as int for later (probably could use (int)f.N too) */
        ITOF0(_xyzw, &tm02, &idx);
        FMULf(_xyzw, &tm02, 0.00195313);

        FTOI0(_xyzw, &tm03, &tm03);
        ITOF0(_xyzw, &tm03, &tm03);
        FMULf(_xyzw, &tm03, 0.00195313);

        SUB  (_xyzw, &spc1, &tm01, &tm02);
        SUB  (_xyzw, &spc2, &tm03, &tm02);

        /* Also just in case. In rare cases index may access 511+1 but table takes this into account */
        idx.i.x = clamp_s16(idx.i.x, 0, TAC_SCALE_TABLE_MAX_INDEX);
        idx.i.y = clamp_s16(idx.i.y, 0, TAC_SCALE_TABLE_MAX_INDEX);
        idx.i.z = clamp_s16(idx.i.z, 0, TAC_SCALE_TABLE_MAX_INDEX);
        idx.i.w = clamp_s16(idx.i.w, 0, TAC_SCALE_TABLE_MAX_INDEX);

        unpack_code4(spectrum, &spc1, &spc2, &code, &idx, out_pos + i);
    }
}

/* Unpacks channel's huffman codes to spectrum coefs. Also done in the VU1 (uses VIFcode UNPACK V4-16
 * to copy 16b huffman codes to VU1 memory as 32b first) but it's simplified a bit here. */
// SUB_6E0
static void unpack_channel(REG_VF* spectrum, const int16_t* codes) {
    int i;

    /* Huffman codes has 1 base scale + 27 bands scales + N coefs (up to 27*32).
     * Not all bands store codes so an index is needed, after scales */
    int code_pos = TAC_CODED_BANDS + 1;
    int out_pos = 0x00;

    /* unpack bands */
    for (i = 1; i < TAC_CODED_BANDS + 1; i++) {
        unpack_band(spectrum, codes, i, &code_pos, out_pos);
        out_pos += (TAC_CODED_COEFS / 4); /* 8 vectors of 4 coefs, per band */
    }

    /* memset rest up to max (27*32/4)..(32*32/4) */
    for (i = 0xD8; i < 0x100; i++) {
       STORE (_xyzw, spectrum, &VECTOR_ZERO, i);
    }

    /* tweak spectrum */
    unpack_antialias(spectrum);
}


/* in GCC this function seems to cause heisenbugs, copy x4 below to get original results */
static void transform_dot_product(REG_VF* mac, const REG_VF* spectrum, const REG_VF* TT, int pos_i, int pos_t) {
    MUL  (_xyzw, mac, &spectrum[pos_i+0], &TT[pos_t+0]); /* resets mac */
    MADD (_xyzw, mac, &spectrum[pos_i+1], &TT[pos_t+1]);
    MADD (_xyzw, mac, &spectrum[pos_i+2], &TT[pos_t+2]);
    MADD (_xyzw, mac, &spectrum[pos_i+3], &TT[pos_t+3]);
    MADD (_xyzw, mac, &spectrum[pos_i+4], &TT[pos_t+4]);
    MADD (_xyzw, mac, &spectrum[pos_i+5], &TT[pos_t+5]);
    MADD (_xyzw, mac, &spectrum[pos_i+6], &TT[pos_t+6]);
    MADD (_xyzw, mac, &spectrum[pos_i+7], &TT[pos_t+7]);
}

/* take spectrum coefs and, ahem, transform somehow, possibly using a SIMD'd DCT table. */
//SUB_1410 (Idct_Start?)
static void transform(REG_VF* wave, const REG_VF* spectrum) {
    const REG_VF* TT = TRANSFORM_TABLE;
    int i, j;

    int pos_t = 0;
    int pos_o = 0;

    for (i = 0; i < TAC_TOTAL_POINTS; i++) {
        int pos_i = 0;
        REG_VF mac, ror, out;

        for (j = 0; j < 8; j++) {
            transform_dot_product(&mac, spectrum, TT, pos_i, pos_t);
            pos_i += 8;
            MR32 (_xyzw, &ror, &mac);
            ADD  (_x_z_, &ror, &ror, &mac);
            ADDz (_x___, &out, &ror, &ror);

            transform_dot_product(&mac, spectrum, TT, pos_i, pos_t);
            pos_i += 8;
            MR32 (_xyzw, &ror, &mac);
            ADD  (__y_w, &ror, &ror, &mac);
            ADDw (__y__, &out, &ror, &ror);

            transform_dot_product(&mac, spectrum, TT, pos_i, pos_t);
            pos_i += 8;
            MR32 (_xyzw, &ror, &mac);
            ADD  (_x_z_, &ror, &ror, &mac);
            ADDx (___z_, &out, &ror, &ror);

            transform_dot_product(&mac, spectrum, TT, pos_i, pos_t);
            pos_i += 8;
            MR32 (_xyzw, &ror, &mac);
            ADD  (__y_w, &ror, &ror, &mac);
            ADDy (____w, &out, &ror, &ror);

            FMULf(_xyzw, &out, 0.25);
            STORE(_xyzw, wave, &out, pos_o++);
        }

        pos_t += 0x08;
    }
}


/* process and apply window/overlap. Similar to MP3's synth granule function. */
//SUB_1690 (Pass3_Start?)
static void process(REG_VF* wave, REG_VF* hist) {
    const REG_VF* ST = SYNTH_TABLE;
    int i, j;

    int pos_o = 0;
    int pos_w = 0;
    int pos_h;
    int pos_r = 0x200; /* rolls down to 0, becoming 0x10 steps (0x00, 0xF0, 0xE0, ..., 0x00, 0xF0, ...) */

    for (i = 0; i < TAC_TOTAL_POINTS; i++) {
        REG_VF zero, neg1;
        /* Sorry... hopefully compiler optimizes. Probably could be simplified with some rearranging below */
        REG_VF tm00, tm01, tm02, tm03, tm04, tm05, tm06, tm07,
               tm10, tm11, tm12, tm13, tm14, tm15, tm16, tm17,
               tm20, tm21, tm22, tm23, tm24, tm25, tm26, tm27,
               tm30, tm31, tm32, tm33, tm34;
        /* tmp calcs, meant to be used nearby */
        REG_VF tmpZ;
        /* output temps, could STORE as calc'd (like VU1) but thought would be easier to read at the end */
        REG_VF out0, out1, out2, out3, out4, out5, out6, out7,
               out8, out9, outA, outB, outC, outD, outE, outF;

        pos_h = pos_r & 0xFF;
        pos_r = pos_r - 0x10;

        LOAD (_xyzw, &tm00, wave, pos_w+0);
        LOAD (_xyzw, &tm01, wave, pos_w+1);
        LOAD (_xyzw, &tm02, wave, pos_w+2);
        LOAD (_xyzw, &tm03, wave, pos_w+3);
        LOAD (_xyzw, &tm04, wave, pos_w+4);
        LOAD (_xyzw, &tm05, wave, pos_w+5);
        LOAD (_xyzw, &tm06, wave, pos_w+6);
        LOAD (_xyzw, &tm07, wave, pos_w+7);
        pos_w += 8;

        MOVE (_xyzw, &zero, &VECTOR_ZERO);  /* always 0, used for copying */
        MOVE (_xyzw, &neg1, &VECTOR_M_ONE);  /* always -1, used for negating */


        /* WTF is going on here? Yeah, no clue. Probably some multi-step FFT/DCT twiddle thing.
         * Remember all those separate ops are left as-is to allow PS2 float simulation (disabled though).
         * Tried cleaning up some more but... */
        ADDw (_x___, &tm10, &tm01, &tm00);
        ADDx (____w, &tm10, &tm01, &tm02);
        ADDx (____w, &tm11, &tm02, &tm03);
        ADDw (_x___, &tm12, &tm04, &tm03);
        ADDw (_x___, &tm13, &tm05, &tm04);
        ADDx (____w, &tm13, &tm05, &tm06);
        ADDx (____w, &tm12, &tm06, &tm07);
        ADDx (__y__, &tm11, &zero, &tm10);
        ADDw (___z_, &tm11, &zero, &tm10);
        ADDx (__y__, &tm12, &zero, &tm13);
        ADDw (___z_, &tm12, &zero, &tm13);
        ADDw (_x___, &tm14, &tm00, &tm07);
        SUBw (_x___, &tm15, &tm00, &tm07);
        ADDz (___z_, &tm16, &tm11, &tm12);
        ADDx (___z_, &tm17, &zero, &tm14);
        ADDx (____w, &tm16, &zero, &tm15);
        SUBz (___z_, &tm10, &tm11, &tm12);
        ADDz (_x___, &tm16, &tm12, &tm17);
        MULx (___z_, &tm13, &tm10, &ST[0x4]);
        ADDz (_x___, &tm17, &tm16, &tm16);
        ADDz (__y__, &tm16, &zero, &tm13);
        SUBx (___z_, &tm17, &tm17, &tm12);
        ADDy (____w, &tm14, &tm11, &tm12);
        ADDw (__y__, &tm17, &tm16, &tm16);
        SUBy (____w, &tm17, &tm16, &tm16);
        SUBz (_x___, &tm20, &tm16, &tm16);
        ADDw (__y__, &tm16, &tm11, &tm11);
        ADDw (___z_, &tm16, &zero, &tm14);
        ADDy (____w, &tm16, &tm12, &tm12);
        ADDw (__y__, &tm10, &tm11, &tm12);
        SUBw (__y__, &tm13, &tm11, &tm12);
        ADDw (__y__, &tm21, &tm11, &tm12);
        SUBw (__y__, &tm14, &tm16, &tm16);

        ADDy (___z_, &tm22, &tm16, &tm10);
        ADDy (____w, &tm22, &zero, &tm13);
        SUBz (__y__, &tm21, &tm21, &tm16);
        MULx (__y__, &tm16, &tm14, &ST[0x4]);
        ADDz (_x___, &tm23, &tm17, &tm22);
        ADDx (_x___, &tm24, &zero, &tm20);
        MULx (__y__, &tm21, &tm21, &ST[0x4]);
        ADDy (____w, &tm10, &tm22, &tm16);
        SUBy (____w, &tm14, &tm22, &tm16);
        SUBz (_x___, &tm25, &tm17, &tm22);
        ADDy (___z_, &tm23, &tm17, &tm21);
        MULw (_x___, &tm21, &ST[0x2], &tm10);
        MULx (____w, &tm14, &tm14, &ST[0x6]);

        ADDz (___z_, &tm20, &zero, &tm23);
        ADDx (__y__, &tm23, &tm17, &tm21);
        ADDw (___z_, &tm21, &zero, &tm14);
        ADDy (____w, &tm20, &zero, &tm23);
        ADDz (____w, &tm23, &tm17, &tm21);
        SUBz (____w, &tm25, &tm17, &tm21);
        SUBy (___z_, &tm24, &tm17, &tm21);
        SUBx (__y__, &tm25, &tm17, &tm21);
        ADDw (__y__, &tm20, &zero, &tm23);
        ADDw (__y__, &tm24, &zero, &tm25);
        ADDz (___z_, &tm25, &zero, &tm24);
        ADDy (____w, &tm24, &zero, &tm25);
        ADDz (__y__, &tm10, &tm00, &tm00);
        ADDz (__y__, &tm13, &tm03, &tm03);
        ADDz (__y__, &tm11, &tm01, &tm01);
        ADDy (___z_, &tm11, &tm02, &tm02);
        ADDy (_x___, &tm11, &zero, &tm10);
        ADDy (____w, &tm11, &zero, &tm13);
        ADDz (__y__, &tm10, &tm04, &tm04);
        ADDz (__y__, &tm13, &tm07, &tm07);
        ADDz (__y__, &tm12, &tm05, &tm05);
        ADDy (___z_, &tm12, &tm06, &tm06);
        ADDy (_x___, &tm12, &zero, &tm10);
        ADDy (____w, &tm12, &zero, &tm13);
        ADDz (__y__, &tm26, &tm11, &tm11);
        ADDz (__y__, &tm15, &tm12, &tm12);
        ADDx (____w, &tm14, &tm11, &tm12);
        ADDw (_x___, &tm27, &tm11, &tm12);
        SUBw (_x___, &tm10, &tm11, &tm12);
        ADDy (____w, &tm26, &zero, &tm15);
        ADDw (___z_, &tm26, &zero, &tm14);
        ADDy (_x___, &tm16, &tm11, &tm11);
        ADDx (____w, &tm16, &zero, &tm10);
        ADDw (__y__, &tm22, &tm26, &tm26);
        ADDz (_x___, &tm22, &tm27, &tm26);
        SUBw (__y__, &tm16, &tm26, &tm26);
        SUBz (_x___, &tm14, &tm27, &tm26);
        ADDw (___z_, &tm15, &tm11, &tm11);
        ADDy (_x___, &tm17, &tm22, &tm22);
        MULx (__y__, &tm16, &tm16, &ST[0x4]);
        ADDx (___z_, &tm17, &zero, &tm14);

        ADDy (_x___, &tm10, &tm12, &tm12);
        ADDw (__y__, &tm17, &tm16, &tm16);
        SUBy (____w, &tm17, &tm16, &tm16);
        ADDz (____w, &tm16, &tm12, &tm12);
        ADDx (___z_, &tm16, &zero, &tm10);
        ADDz (__y__, &tm16, &zero, &tm15);
        ADDx (_x___, &tm30, &tm23, &tm17);
        FMULf(_x___, &tm30, -1.0);
        MOVE (_x___, &outC, &tm30);
        ADDw (_x___, &tm27, &tm16, &tm16);
        ADDz (__y__, &tm27, &tm16, &tm16);
        SUBw (_x___, &tm13, &tm16, &tm16);
        ADDy (_x___, &tm14, &tm16, &tm16);
        ADDz (____w, &tm27, &tm16, &tm16);
        ADDx (____w, &tm22, &zero, &tm13);
        ADDx (___z_, &tm27, &zero, &tm14);
        SUBy (_x___, &tm13, &tm27, &tm27);
        SUBw (___z_, &tm15, &tm27, &tm27);
        MULx (_x___, &tm13, &tm13, &ST[0x4]);
        MULx (___z_, &tm15, &tm15, &ST[0x4]);
        ADDx (__y__, &tm21, &zero, &tm13);
        ADDz (____w, &tm27, &zero, &tm15);
        ADDw (____w, &tm14, &tm22, &tm27);
        SUBw (____w, &tm13, &tm22, &tm27);
        MULx (____w, &tm14, &tm14, &ST[0x2]);
        MULx (____w, &tm13, &tm13, &ST[0x6]);
        ADDw (_x___, &tm21, &zero, &tm14);
        ADDw (___z_, &tm21, &zero, &tm13);

        ADDx (__y__, &tmpZ, &tm17, &tm21);
        ADDy (___z_, &tmpZ, &tm17, &tm21);
        ADDz (____w, &tmpZ, &tm17, &tm21);
        SUBy (_x___, &tmpZ, &tm22, &tm22);
        MULx (__y__, &tm10, &tmpZ, &ST[0x1]);
        MULx (___z_, &tm10, &tmpZ, &ST[0x2]);
        MULx (____w, &tm10, &tmpZ, &ST[0x3]);
        MULx (_x___, &tm10, &tmpZ, &ST[0x4]);

        SUBx (_x___, &tm23, &tm23, &tm17); /* .x not used after this */
        MULx (_x___, &out0, &tm23, &ST[0x4]);

        SUBy (__y__, &tm23, &tm23, &tm10);
        SUBz (___z_, &tm23, &tm23, &tm10);
        SUBw (____w, &tm23, &tm23, &tm10);
        ADDw (__y__, &tm20, &tm20, &tm10);
        ADDz (___z_, &tm20, &tm20, &tm10);
        ADDy (____w, &tm20, &tm20, &tm10);
        ADDx (_x___, &tm20, &tm20, &tm10);
        SUBx (_x___, &tm24, &tm24, &tm10);

        SUBx (__y__, &tmpZ, &tm17, &tm21);
        SUBy (___z_, &tmpZ, &tm17, &tm21);
        SUBz (____w, &tmpZ, &tm17, &tm21);
        MULx (__y__, &tm10, &tmpZ, &ST[0x7]);
        MULx (___z_, &tm10, &tmpZ, &ST[0x6]);
        MULx (____w, &tm10, &tmpZ, &ST[0x5]);

        SUBw (__y__, &tm24, &tm24, &tm10);
        SUBz (___z_, &tm24, &tm24, &tm10);
        SUBy (____w, &tm24, &tm24, &tm10);

        ADDy (__y__, &tm25, &tm25, &tm10);
        ADDz (___z_, &tm25, &tm25, &tm10);
        ADDw (____w, &tm25, &tm25, &tm10);

        ADDy (_x___, &tm00, &tm00, &tm00);
        FMULf(_x___, &tm00, -1.0);
        ADDw (___z_, &tm10, &tm00, &tm00);
        ADDy (_x___, &tm10, &tm01, &tm01);
        FMULf(_x___, &tm10, -1.0);
        ADDz (____w, &tm00, &tm01, &tm01);
        ADDz (__y__, &tm00, &zero, &tm10);
        ADDy (_x___, &tm01, &tm02, &tm02);
        FMULf(_x___, &tm01, -1.0);
        ADDw (___z_, &tm10, &tm02, &tm02);
        ADDy (_x___, &tm13, &tm03, &tm03);
        FMULf(_x___, &tm13, -1.0);
        ADDx (___z_, &tm00, &zero, &tm10);
        ADDz (__y__, &tm01, &zero, &tm10);
        ADDz (____w, &tm01, &tm03, &tm03);
        ADDy (_x___, &tm02, &tm04, &tm04);
        FMULf(_x___, &tm02, -1.0);
        ADDw (___z_, &tm10, &tm04, &tm04);
        ADDx (___z_, &tm01, &zero, &tm13);
        ADDy (_x___, &tm13, &tm05, &tm05);
        FMULf(_x___, &tm13, -1.0);
        ADDz (__y__, &tm02, &zero, &tm10);
        ADDz (____w, &tm02, &tm05, &tm05);
        ADDy (_x___, &tm03, &tm06, &tm06);
        FMULf(_x___, &tm03, -1.0);
        ADDw (___z_, &tm10, &tm06, &tm06);
        ADDy (_x___, &tm14, &tm07, &tm07);
        FMULf(_x___, &tm14, -1.0);
        ADDx (___z_, &tm02, &zero, &tm13);
        ADDz (__y__, &tm03, &zero, &tm10);
        ADDz (____w, &tm03, &tm07, &tm07);

        ADDx (___z_, &tm03, &zero, &tm14);
        ADDz (__y__, &tm11, &tm00, &tm00);
        ADDx (____w, &tm10, &tm00, &tm01);
        ADDz (__y__, &tm10, &tm01, &tm01);
        ADDw (_x___, &tm12, &tm02, &tm01);
        ADDz (__y__, &tm12, &tm02, &tm02);
        ADDw (___z_, &tm11, &zero, &tm10);
        ADDy (____w, &tm11, &zero, &tm10);
        ADDx (____w, &tm10, &tm02, &tm03);
        ADDz (__y__, &tm10, &tm03, &tm03);
        ADDy (__y__, &tm13, &tm11, &tm12);
        ADDw (__y__, &tm26, &tm11, &tm11);
        ADDw (___z_, &tm12, &zero, &tm10);
        ADDy (____w, &tm12, &zero, &tm10);
        SUBw (__y__, &tm13, &tm13, &tm11);
        ADDy (____w, &tm10, &tm11, &tm12);
        ADDy (____w, &tm26, &tm12, &tm12);
        SUBz (___z_, &tm14, &tm11, &tm12);
        SUBw (__y__, &tm13, &tm13, &tm12);
        ADDw (___z_, &tm26, &zero, &tm10);
        ADDw (__y__, &tm10, &tm26, &tm26);
        MULx (__y__, &tm10, &tm10, &ST[0x4]);
        ADDz (__y__, &tm21, &zero, &tm14);
        ADDy (_x___, &tm31, &zero, &tm13);
        SUBw (__y__, &tm13, &tm26, &tm26);
        MULx (__y__, &tm13, &tm13, &ST[0x4]);

        ADDy (___z_, &tm21, &zero, &tm10);
        ADDy (___z_, &tm17, &zero, &tm13);
        ADDz (___z_, &tm10, &tm21, &tm26);
        SUBz (___z_, &tm13, &tm21, &tm26);
        ADDz (___z_, &tm30, &tm11, &tm12);
        MULx (___z_, &tm10, &tm10, &ST[0x2]);
        MULx (___z_, &tm13, &tm13, &ST[0x6]);
        MULx (___z_, &tm30, &tm30, &ST[0x4]);
        ADDz (__y__, &tm17, &zero, &tm10);
        ADDz (____w, &tm17, &zero, &tm13);
        ADDz (____w, &tm22, &zero, &tm30);
        SUBx (____w, &tm10, &tm22, &tm12);
        ADDw (_x___, &tm21, &tm12, &tm22);

        ADDw (___z_, &tm21, &zero, &tm10);
        ADDx (__y__, &tm32, &tm17, &tm21);
        ADDy (___z_, &tm32, &tm17, &tm21);
        FMUL (_x___, &tm33, &tm31, -1.0);
        ADDz (____w, &tm32, &tm17, &tm21);
        FMUL (__y__, &tm10, &tm32, -1.0);
        FMUL (___z_, &tm33, &tm32, -1.0);
        SUBz (____w, &tm14, &tm17, &tm21);
        FMUL (____w, &tm13, &tm32, -1.0);
        ADDy (____w, &tm33, &zero, &tm10);
        SUBy (___z_, &tm31, &tm17, &tm21);
        ADDw (__y__, &tm31, &zero, &tm14);
        ADDw (__y__, &tm33, &zero, &tm13);
        SUBx (__y__, &tm13, &tm17, &tm21);
        FMUL (___z_, &tm34, &tm31, -1.0);
        FMUL (__y__, &tm10, &tm31, -1.0);
        ADDy (____w, &tm31, &zero, &tm13);
        ADDy (____w, &tm34, &zero, &tm10);
        FMUL (____w, &tm10, &tm31, -1.0);
        ADDw (__y__, &tm34, &zero, &tm10);
        ADDy (_x___, &tm11, &tm00, &tm00);
        ADDw (___z_, &tm10, &tm00, &tm00);
        ADDy (_x___, &tm13, &tm01, &tm01);
        ADDz (____w, &tm11, &tm01, &tm01);
        ADDy (_x___, &tm12, &tm02, &tm02);
        ADDz (__y__, &tm11, &zero, &tm10);
        ADDx (___z_, &tm11, &zero, &tm13);
        ADDw (___z_, &tm10, &tm02, &tm02);
        ADDy (_x___, &tm13, &tm03, &tm03);
        ADDz (____w, &tm12, &tm03, &tm03);

        ADDz (__y__, &tm12, &zero, &tm10);
        ADDx (___z_, &tm12, &zero, &tm13);
        SUBy (_x___, &tm34, &tm11, &tm11);
        SUBw (___z_, &tm10, &tm11, &tm11);
        SUBy (_x___, &tm13, &tm12, &tm12);
        SUBw (___z_, &tm14, &tm12, &tm12);
        ADDz (__y__, &tm15, &tm12, &tm12);
        ADDz (_x___, &tm34, &tm34, &tm10);
        ADDx (____w, &tm10, &tm11, &tm12);
        ADDz (_x___, &tm13, &tm13, &tm14);
        ADDy (____w, &tm16, &zero, &tm15);
        ADDz (__y__, &tm16, &tm11, &tm11);
        ADDw (___z_, &tm16, &zero, &tm10);
        ADDx (_x___, &tm34, &tm34, &tm13);
        ADDz (____w, &tm26, &tm12, &tm12);
        ADDy (_x___, &tm14, &tm12, &tm12);
        ADDw (___z_, &tm15, &tm11, &tm11);
        ADDy (_x___, &tm26, &tm11, &tm11);
        ADDx (___z_, &tm26, &zero, &tm14);
        ADDz (__y__, &tm26, &zero, &tm15);
        ADDw (___z_, &tm13, &tm26, &tm26);
        ADDy (_x___, &tm27, &tm26, &tm26);
        ADDz (__y__, &tm10, &tm26, &tm26);
        ADDz (__y__, &tm27, &zero, &tm13);
        ADDy (____w, &tm27, &zero, &tm10);
        ADDy (_x___, &tm10, &tm27, &tm27);
        SUBy (_x___, &tm14, &tm27, &tm27);
        ADDy (____w, &tm22, &tm16, &tm16);
        SUBw (__y__, &tm21, &tm16, &tm16);
        MULx (_x___, &tm10, &tm10, &ST[0x4]);
        MULx (_x___, &tm14, &tm14, &ST[0x4]);
        MULx (____w, &tm22, &tm22, &ST[0x4]);
        ADDx (___z_, &tm21, &zero, &tm10);
        ADDx (___z_, &tm17, &zero, &tm14);
        SUBz (____w, &tm30, &tm22, &tm16);
        ADDw (___z_, &tm10, &tm21, &tm27);
        SUBw (___z_, &tm14, &tm21, &tm27);
        ADDz (____w, &tmpZ, &tm22, &tm16);
        ADDw (_x___, &tm21, &zero, &tmpZ);
        ADDw (___z_, &tm21, &zero, &tm30);
        MULx (___z_, &tm10, &tm10, &ST[0x2]);
        MULx (___z_, &tm14, &tm14, &ST[0x6]);
        ADDz (__y__, &tm17, &zero, &tm10);
        ADDz (____w, &tm17, &zero, &tm14);
        SUBy (_x___, &tm30, &tm26, &tm26);
        ADDx (__y__, &tm10, &tm17, &tm21);
        ADDy (___z_, &tm10, &tm17, &tm21);
        ADDz (____w, &tm10, &tm17, &tm21);
        ADDz (_x___, &tm30, &tm30, &tm26);
        MULx (__y__, &tm10, &tm10, &ST[0x1]);
        MULx (___z_, &tm10, &tm10, &ST[0x2]);
        MULx (____w, &tm10, &tm10, &ST[0x3]);
        SUBw (_x___, &tm30, &tm30, &tm26);
        MULx (_x___, &tm30, &tm30, &ST[0x4]);

        ADDy (__y__, &tmpZ, &tm32, &tm10);
        ADDz (___z_, &tmpZ, &tm32, &tm10);
        ADDw (____w, &tmpZ, &tm32, &tm10);
        MULz (__y__, &tm32, &tmpZ, &ST[0x0]);
        MULx (___z_, &tm32, &tmpZ, &ST[0x1]);
        MULz (____w, &tm32, &tmpZ, &ST[0x1]);
        MOVE (_x___, &tm32, &zero);

        ADDy (____w, &tm33, &tm33, &tm10);
        ADDz (___z_, &tm33, &tm33, &tm10);
        ADDw (__y__, &tm33, &tm33, &tm10);
        ADDx (_x___, &tm33, &tm33, &tm30);
        MULx (_x___, &tm33, &tm33, &ST[0x6]);

        SUBz (____w, &tmpZ, &tm17, &tm21);
        SUBy (___z_, &tmpZ, &tm17, &tm21);
        SUBx (__y__, &tmpZ, &tm17, &tm21);
        MULx (____w, &tm10, &tmpZ, &ST[0x5]);
        MULx (___z_, &tm10, &tmpZ, &ST[0x6]);
        MULx (__y__, &tm10, &tmpZ, &ST[0x7]);

        ADDx (_x___, &tmpZ, &tm31, &tm30);
        ADDw (__y__, &tmpZ, &tm31, &tm10);
        ADDz (___z_, &tmpZ, &tm31, &tm10);
        ADDy (____w, &tmpZ, &tm31, &tm10);
        MULx (_x___, &tm31, &tmpZ, &ST[0x2]);
        MULz (__y__, &tm31, &tmpZ, &ST[0x2]);
        MULx (___z_, &tm31, &tmpZ, &ST[0x3]);
        MULz (____w, &tm31, &tmpZ, &ST[0x3]);

        ADDy (__y__, &tmpZ, &tm23, &tm32);
        ADDz (___z_, &tmpZ, &tm23, &tm32);
        ADDw (____w, &tmpZ, &tm23, &tm32);
        ADDx (_x___, &tmpZ, &tm24, &tm31);
        MULy (__y__, &out0, &tmpZ, &ST[0x4]);
        MULz (___z_, &out0, &tmpZ, &ST[0x4]);
        MULw (____w, &out0, &tmpZ, &ST[0x4]);
        MULx (_x___, &out1, &tmpZ, &ST[0x5]);
        MULy (____w, &out7, &neg1, &out0);
        MULz (___z_, &out7, &neg1, &out0);
        MULw (__y__, &out7, &neg1, &out0);
        MULx (_x___, &out7, &neg1, &out1);

        SUBy (__y__, &tmpZ, &tm32, &tm23);
        SUBz (___z_, &tmpZ, &tm32, &tm23);
        SUBw (____w, &tmpZ, &tm32, &tm23);
        SUBx (_x___, &tmpZ, &tm31, &tm24);
        MULy (____w, &outF, &ST[0x3], &tmpZ);
        MULz (___z_, &outF, &ST[0x3], &tmpZ);
        MULw (__y__, &outF, &ST[0x3], &tmpZ);
        MULx (_x___, &outF, &ST[0x3], &tmpZ);
        ADDw (__y__, &out8, &zero, &outF);
        ADDz (___z_, &out8, &zero, &outF);
        ADDy (____w, &out8, &zero, &outF);
        ADDx (_x___, &out9, &zero, &outF);

        ADDw (____w, &tmpZ, &tm34, &tm10);
        ADDz (___z_, &tmpZ, &tm34, &tm10);
        ADDy (__y__, &tmpZ, &tm34, &tm10);
        MULz (__y__, &tm34, &tmpZ, &ST[0x4]);
        MULx (___z_, &tm34, &tmpZ, &ST[0x5]);
        MULz (____w, &tm34, &tmpZ, &ST[0x5]);
        MULx (_x___, &tm34, &tm34, &ST[0x4]);

        ADDy (__y__, &tmpZ, &tm24, &tm31);
        ADDz (___z_, &tmpZ, &tm24, &tm31);
        ADDw (____w, &tmpZ, &tm24, &tm31);
        ADDx (_x___, &tmpZ, &tm25, &tm34);
        MULy (__y__, &out1, &tmpZ, &ST[0x5]);
        MULz (___z_, &out1, &tmpZ, &ST[0x5]);
        MULw (____w, &out1, &tmpZ, &ST[0x5]);
        MULx (_x___, &out2, &tmpZ, &ST[0x6]);
        MULy (____w, &out6, &neg1, &out1);
        MULz (___z_, &out6, &neg1, &out1);
        MULw (__y__, &out6, &neg1, &out1);
        MULx (_x___, &out6, &neg1, &out2);

        SUBy (__y__, &tmpZ, &tm31, &tm24);
        SUBz (___z_, &tmpZ, &tm31, &tm24);
        SUBw (____w, &tmpZ, &tm31, &tm24);
        SUBx (_x___, &tmpZ, &tm34, &tm25);
        MULw (__y__, &outE, &ST[0x2], &tmpZ);
        MULz (___z_, &outE, &ST[0x2], &tmpZ);
        MULy (____w, &outE, &ST[0x2], &tmpZ);
        MULx (_x___, &outE, &ST[0x2], &tmpZ);
        ADDw (__y__, &out9, &zero, &outE);
        ADDz (___z_, &out9, &zero, &outE);
        ADDy (____w, &out9, &zero, &outE);
        ADDx (_x___, &outA, &zero, &outE);

        ADDy (__y__, &tmpZ, &tm25, &tm34);
        ADDz (___z_, &tmpZ, &tm25, &tm34);
        ADDw (____w, &tmpZ, &tm25, &tm34);
        ADDx (_x___, &tmpZ, &tm20, &tm33);
        MULy (__y__, &out2, &tmpZ, &ST[0x6]);
        MULz (___z_, &out2, &tmpZ, &ST[0x6]);
        MULw (____w, &out2, &tmpZ, &ST[0x6]);
        MULx (_x___, &out3, &tmpZ, &ST[0x7]);
        MULy (____w, &out5, &neg1, &out2);
        MULz (___z_, &out5, &neg1, &out2);
        MULw (__y__, &out5, &neg1, &out2);
        MULx (_x___, &out5, &neg1, &out3);

        SUBy (__y__, &tmpZ, &tm34, &tm25);
        SUBz (___z_, &tmpZ, &tm34, &tm25);
        SUBw (____w, &tmpZ, &tm34, &tm25);
        SUBx (_x___, &tmpZ, &tm33, &tm20);
        MULw (__y__, &outD, &ST[0x1], &tmpZ);
        MULz (___z_, &outD, &ST[0x1], &tmpZ);
        MULy (____w, &outD, &ST[0x1], &tmpZ);
        MULx (_x___, &outD, &ST[0x1], &tmpZ);
        ADDw (__y__, &outA, &zero, &outD);
        ADDz (___z_, &outA, &zero, &outD);
        ADDy (____w, &outA, &zero, &outD);
        ADDx (_x___, &outB, &zero, &outD);

        MULz (__y__, &tm33, &tm33, &ST[0x6]);
        MULx (___z_, &tm33, &tm33, &ST[0x7]);
        MULz (____w, &tm33, &tm33, &ST[0x7]);

        ADDy (__y__, &tmpZ, &tm20, &tm33);
        ADDz (___z_, &tmpZ, &tm20, &tm33);
        ADDw (____w, &tmpZ, &tm20, &tm33);
        MULw (____w, &out3, &tmpZ, &ST[0x7]);
        MULz (___z_, &out3, &tmpZ, &ST[0x7]);
        MULy (__y__, &out3, &tmpZ, &ST[0x7]);
        MULw (__y__, &out4, &neg1, &out3);
        MULz (___z_, &out4, &neg1, &out3);
        MULy (____w, &out4, &neg1, &out3);
        MOVE (_x___, &out4, &zero);

        SUBy (__y__, &tmpZ, &tm33, &tm20);
        SUBz (___z_, &tmpZ, &tm33, &tm20);
        SUBw (____w, &tmpZ, &tm33, &tm20);
        MULw (__y__, &outC, &ST[0x0], &tmpZ);
        MULz (___z_, &outC, &ST[0x0], &tmpZ);
        MULy (____w, &outC, &ST[0x0], &tmpZ);
        ADDw (__y__, &outB, &zero, &outC);
        ADDz (___z_, &outB, &zero, &outC);
        ADDy (____w, &outB, &zero, &outC);
        MULx (_x___, &out8, &neg1, &out0);

        /* current output */
        STORE(_xyzw, hist, &out0, pos_h + 0x0);
        STORE(_xyzw, hist, &out1, pos_h + 0x1);
        STORE(_xyzw, hist, &out2, pos_h + 0x2);
        STORE(_xyzw, hist, &out3, pos_h + 0x3);
        STORE(_xyzw, hist, &out4, pos_h + 0x4);
        STORE(_xyzw, hist, &out5, pos_h + 0x5);
        STORE(_xyzw, hist, &out6, pos_h + 0x6);
        STORE(_xyzw, hist, &out7, pos_h + 0x7);
        STORE(_xyzw, hist, &out8, pos_h + 0x8);
        STORE(_xyzw, hist, &out9, pos_h + 0x9);
        STORE(_xyzw, hist, &outA, pos_h + 0xA);
        STORE(_xyzw, hist, &outB, pos_h + 0xB);
        STORE(_xyzw, hist, &outC, pos_h + 0xC);
        STORE(_xyzw, hist, &outD, pos_h + 0xD);
        STORE(_xyzw, hist, &outE, pos_h + 0xE);
        STORE(_xyzw, hist, &outF, pos_h + 0xF);

        /* hist/window overlap and update final wave */
        for (j = 0; j < 8; j++) {
            const REG_VF* WT = WINDOW_TABLE;
            REG_VF out, rnd;

            MUL  (_xyzw, &out, &hist[(pos_h + 0x00) & 0xFF], &WT[0x00+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x18) & 0xFF], &WT[0x08+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x20) & 0xFF], &WT[0x10+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x38) & 0xFF], &WT[0x18+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x40) & 0xFF], &WT[0x20+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x58) & 0xFF], &WT[0x28+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x60) & 0xFF], &WT[0x30+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x78) & 0xFF], &WT[0x38+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x80) & 0xFF], &WT[0x40+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0x98) & 0xFF], &WT[0x48+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0xA0) & 0xFF], &WT[0x50+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0xB8) & 0xFF], &WT[0x58+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0xC0) & 0xFF], &WT[0x60+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0xD8) & 0xFF], &WT[0x68+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0xE0) & 0xFF], &WT[0x70+j]);
            MADD (_xyzw, &out, &hist[(pos_h + 0xF8) & 0xFF], &WT[0x78+j]);

            pos_h++;

            /* base volume and +-0.5 to final sample (+-32767.0) */
            MUL  (_xyzw, &out, &out, &VECTOR_VOLUME);

            MOVE (_xyzw, &rnd, &VECTOR_ROUND);
            SIGN (_xyzw, &rnd, &out);
            ADD  (_xyzw, &out, &out, &rnd);

            STORE(_xyzw, wave, &out, pos_o++);
        }
    }
}


///////////////////////////////////////////////////////////////////////////////

/* main decoding in the VU1 coprocessor */
static void decode_vu1(tac_handle_t* h) {
    int ch;

    for (ch = 0; ch < TAC_CHANNELS; ch++) {
        unpack_channel(h->spectrum[ch], h->codes[ch]);

        transform(h->wave[ch], h->spectrum[ch]);

        process(h->wave[ch], h->hist[ch]);
    }

    /* Decoded data is originally stored in VUMem1 as clamped ints, though final step
     * seems may be done done externally (StMakeFinalOut/StFlushWriteBuffer) */
}

/* Create final output samples */
// StMakeFinalOut
static void finalize_output(tac_handle_t* h) {
    int i;

    /* original code copies + clamps to PCM buffer here instead of modifying wave,
     * but we do it later to potentially allow float output. It also sets total output:
     * - type 1 (at loop frame): start_sample = loop_discard, frame_samples = 1024 - loop_discard
     * - type 2 (at last frame): start_sample = 0, frame_samples = frame_last + 1
     * - other: start_sample = 0, frame_samples = 1024
     * (only copies or does joint stereo from start_sample) */

    if (h->header.joint_stereo) {
        REG_VF* wave_l = h->wave[0];
        REG_VF* wave_r = h->wave[1];

        /* Combine joint stereo channels that encode diffs in L/R ("MS stereo"). In pseudo-mono files R has */
        /* all samples as 0 (R only saves 28 huffman codes, signalling no coefs per 1+27 bands) */
        for (i = 0; i < TAC_TOTAL_POINTS * 8; i++) {
            REG_VF samples_l, samples_r;

            ADD  (_xyzw, &samples_l, &wave_l[i], &wave_r[i]); /* L = L + R */
            SUB  (_xyzw, &samples_r, &wave_l[i], &wave_r[i]); /* R = L - R */
            MOVE (_xyzw, &wave_l[i], &samples_l);
            MOVE (_xyzw, &wave_r[i], &samples_r);
        }
    }
}

/* read huffman codes for all channels (max per channel 27*32 = 864 + 27 + 1 = 892) */
static int read_codes(tac_handle_t* h, const uint8_t* ptr, uint16_t huff_flag, uint32_t huff_cfg) {
    int huff_count = 0;
    int ch;
    uint32_t unkA = 0;
    uint32_t unkB = huff_cfg;
    uint32_t unkC = 0;
    uint32_t unkD = 0xFFFFFFFF;

    for (ch = 0; ch < TAC_CHANNELS; ch++) {
        int huff_done = 0;
        int huff_todo = 28;
        int16_t huff_val = 0;

        for (; huff_done < huff_todo; huff_done++) {
            unkD = unkD >> 14;
            unkA = h->huff_table_4[(unkB - unkC) / unkD];
            unkC += h->huff_table_3[unkA] * unkD;
            unkD *= h->huff_table_1[unkA];

            while (0xFFFFFF >= (unkC ^ (unkC + unkD))) {
                unkB = (unkB << 8) | (*ptr++);
                unkD = (unkD << 8);
                unkC = (unkC << 8);
            }

            while (0xFFFF >= unkD) {
                unkD = (((~unkC) + 1) & 0xFFFF) << 8;
                unkB = (unkB << 8) | (*ptr++);
                unkC = (unkC << 8);
            }

            if (unkA >= 0xFE) {
                uint32_t unkT;
                unkT = unkA == 0xFE;
                unkD = unkD >> (unkT ? 8 : 13);
                unkA = (unkB - unkC) / unkD;
                unkC = unkC + (unkA * unkD);
                if (unkT)
                    unkA += 0xFE;

                while (0xFFFFFF >= (unkC ^ (unkC + unkD))) {
                    unkB = (unkB << 8) | (*ptr++);
                    unkD = (unkD << 8);
                    unkC = (unkC << 8);
                }

                while (0xFFFF >= unkD) {
                    unkD = (((~unkC) + 1) & 0xFFFF) << 8;
                    unkB = (unkB << 8) | (*ptr++);
                    unkC = (unkC << 8);
                }
            }

            if (unkA & 1) {
                huff_val = -((((int16_t)unkA) + 1) / 2);
            } else {
                huff_val = unkA / 2;
            }

            if (huff_done < 28) {
                if (huff_flag) {
                    huff_val += h->huff_table_2[ch][huff_done];
                }

                h->huff_table_2[ch][huff_done] = huff_val;

                if (huff_done != 0 && (huff_val << 16) != 0) {
                    huff_todo += 32;
                }
            }

            h->codes[ch][huff_done] = huff_val;
        }

        huff_count += huff_done;
    }

    return huff_count;
}


/* CRC-16/GENIBUS implementation */
/* https://reveng.sourceforge.io/crc-catalogue/16.htm#crc.cat.crc-16-genibus */

#define CRC16_INIT     0xFFFF
#define CRC16_POLY     0x1021
#define CRC16_XOR_OUT  0xFFFF

static uint16_t crc16(const uint8_t* data, int length) {
    uint16_t i, crc = CRC16_INIT;

    while (length--) {
        for (crc ^= *data++ << 8, i = 0; i < 8; i++) {
            crc = (crc & 0x8000) ? crc << 1 ^ CRC16_POLY : crc << 1;
        }
    }

    return crc ^ CRC16_XOR_OUT;
}

/* ************************************************************************* */
/* SETUP                                                                     */
/* ************************************************************************* */

static uint32_t get_u32be(const uint8_t* mem) {
    return (mem[0] << 24) | (mem[1] << 16) | (mem[2] << 8) | mem[3];
}

static uint32_t get_u32le(const uint8_t* mem) {
    return (mem[3] << 24) | (mem[2] << 16) | (mem[1] << 8) | mem[0];
}

static uint16_t get_u16le(const uint8_t* mem) {
    return (mem[1] << 8) | mem[0];
}

static int init_header(tac_header_t* header, const uint8_t* buf) {
    header->huffman_offset  = get_u32le(buf+0x00);
    header->unknown         = get_u32le(buf+0x04);
    header->loop_frame      = get_u16le(buf+0x08);
    header->loop_discard    = get_u16le(buf+0x0A);
    header->frame_count     = get_u16le(buf+0x0C);
    header->frame_last      = get_u16le(buf+0x0E);
    header->loop_offset     = get_u32le(buf+0x10);
    header->file_size       = get_u32le(buf+0x14);
    header->joint_stereo    = get_u32le(buf+0x18);
    header->empty           = get_u32le(buf+0x1c);

    /* huffman table offset should make sense */
    if (header->huffman_offset < 0x20 || header->huffman_offset > TAC_BLOCK_SIZE)
        return TAC_PROCESS_HEADER_ERROR;
    /* header size ia block-aligned (but actual size can be smaller, ex. VP 00000715) */
    if (header->file_size % TAC_BLOCK_SIZE != 0)
        return TAC_PROCESS_HEADER_ERROR;
    /* loop_discard over max makes game crash, while frame_last seems to ignore it */
    if (header->loop_discard > TAC_FRAME_SAMPLES || header->frame_last + 1 > TAC_FRAME_SAMPLES)
        return TAC_PROCESS_HEADER_ERROR;
    /* looping makes sense */
    if (header->loop_frame > header->frame_count || header->loop_offset > header->file_size)
        return TAC_PROCESS_HEADER_ERROR;
    /* just in case */
    if ((header->joint_stereo != 0 && header->joint_stereo != 1) || header->empty != 0)
        return TAC_PROCESS_HEADER_ERROR;

    return TAC_PROCESS_OK;
}


/* AKA RangeDecodeInit (Csd module) */
static int init_huffman(tac_handle_t* h, const uint8_t* buf) {
    uint8_t idx = 0;
    int offset = 0;
    int i, j;

    /* initialize huff_table_1 with values from header */
    for (i = 0; i < 256; i++) {
        int16_t n = buf[offset++];

        if (n & 0x80) {
            n &= 0x7F;
            n |= buf[offset++] << 7;
        }

        h->huff_table_1[i] = n;
    }

    /* zero-initialize huff_table_2 */
    for (i = 0; i < TAC_CHANNELS; i++) {
        for (j = 0; j < 32; j++) {
            h->huff_table_2[i][j] = 0;
        }
    }

    /* initialize huff_table_3 */
    h->huff_table_1[256] = 1;
    h->huff_table_3[0] = 0;
    for (i = 1, j = 0; i < 258; i++, j++) {
        h->huff_table_3[i] = h->huff_table_3[j] + h->huff_table_1[j];
    }

    /* initialize huff_table_4 */
    for (idx = 0; !h->huff_table_1[idx]; idx++) {
        ;
    }

    for (i = 0; i < 16383; i++) {
        if (i >= h->huff_table_3[idx+1]) {
            while (!h->huff_table_1[++idx]) {
                ;
            }
        }
        h->huff_table_4[i] = idx;
    }

    return offset;
}

/* ************************************************************************* */
/* API                                                                       */
/* ************************************************************************* */

tac_handle_t* tac_init(const uint8_t* buf, int buf_size) {
    tac_handle_t* handle = NULL;

    /* assumes 1 block */
    if (buf_size < TAC_BLOCK_SIZE)
        goto fail;

    handle = malloc(sizeof(tac_handle_t));
    if (!handle) goto fail;

    {
        int res, pos;

        res = init_header(&handle->header, buf);
        if (res != TAC_PROCESS_OK) goto fail;

        pos = init_huffman(handle, &buf[handle->header.huffman_offset]);
        if (pos <= 0) goto fail;

        handle->data_start = handle->header.huffman_offset + pos;
        if (handle->data_start > TAC_BLOCK_SIZE)
            goto fail;
    }

    tac_reset(handle);

    return handle;
fail:
    tac_free(handle);
    return NULL;
}

const tac_header_t* tac_get_header(tac_handle_t* handle) {
    if (!handle)
        return NULL;
    return &handle->header;
}

void tac_free(tac_handle_t* handle) {
    if (!handle)
        return;
    free(handle);
}

void tac_reset(tac_handle_t* handle) {
    if (!handle)
        return;

    handle->frame_offset = handle->data_start;
    handle->frame_number = 1;

    memset(handle->hist, 0, sizeof(REG_VF) * TAC_CHANNELS * (TAC_FRAME_SAMPLES / 4));
    memset(handle->huff_table_2, 0, sizeof(int16_t) * TAC_CHANNELS * 32);
}


int tac_decode_frame(tac_handle_t* handle, const uint8_t* block) {
    int pos = handle->frame_offset;

    if (handle->frame_number > handle->header.frame_count)
        return TAC_PROCESS_DONE;

    if (pos + 0x04 > TAC_BLOCK_SIZE)
        return TAC_PROCESS_ERROR_SIZE;

    /* new block marker (may be right at block's end) */
    if (get_u32le(block + pos) == 0xFFFFFFFF) {
        handle->frame_offset = 0; /* start at the beginning of next block */
        return TAC_PROCESS_NEXT_BLOCK;
    }

    if (pos + 0x0C > TAC_BLOCK_SIZE)
        return TAC_PROCESS_ERROR_SIZE;


    /* read new frame */
    {
        const uint8_t* buf = &block[pos]; /* current frame */
        uint16_t frame_crc  = get_u16le(buf + 0x00); /* checksum of data starting at 0x04 */
        uint16_t huff_flag  = get_u16le(buf + 0x02) >> 15; /* 0 every 64th frame, 1 for others */
        uint16_t frame_size = get_u16le(buf + 0x02) & 0x7FFF; /* not including base header (0x08) */
        uint16_t frame_id   = get_u16le(buf + 0x04); /* current number */
        uint16_t huff_count = get_u16le(buf + 0x06); /* huffman decoded length */

        uint32_t huff_cfg   = get_u32be(buf + 0x08); /* huffman table setup */
        uint16_t crc_calc, huff_read;

        if (frame_id != handle->frame_number)
            return TAC_PROCESS_ERROR_ID;

        if (pos + 0x08 + frame_size > TAC_BLOCK_SIZE)
            return TAC_PROCESS_ERROR_SIZE;

        /* from tests seems CRC errors cause current frame to be skipped, so change values before validations */
        handle->frame_number++;
        handle->frame_offset += 0x08 + frame_size;

        crc_calc = crc16(buf + 0x04, 0x04 + frame_size);
        if (frame_crc != crc_calc)
            return TAC_PROCESS_ERROR_CRC;

        /* extract huffman frame codes */
        huff_read = read_codes(handle, buf + 0x0C, huff_flag, huff_cfg);
        if (huff_read != huff_count)
            return TAC_PROCESS_ERROR_HUFFMAN;

        /* main decode */
        decode_vu1(handle);

        /* post process */
        finalize_output(handle);
    }

    /* current frame decoded and samples can be requested */
    return TAC_PROCESS_OK;
}


static inline int16_t clamp16f(float sample) {
    if (sample > 32767.0)
        return 32767;
    else if (sample < -32768.0)
        return -32768;
    return (int16_t)sample;
}

void tac_get_samples_pcm16(tac_handle_t* handle, int16_t* dst) {
    int ch, i;
    int chs = TAC_CHANNELS;

    for (ch = 0; ch < chs; ch++) {
        int s = 0;
        for (i = 0; i < TAC_FRAME_SAMPLES / 4; i++) {
            dst[(s+0)*chs + ch] = clamp16f(handle->wave[ch][i].f.x);
            dst[(s+1)*chs + ch] = clamp16f(handle->wave[ch][i].f.y);
            dst[(s+2)*chs + ch] = clamp16f(handle->wave[ch][i].f.z);
            dst[(s+3)*chs + ch] = clamp16f(handle->wave[ch][i].f.w);
            s += 4;
        }
    }
}


void tac_set_loop(tac_handle_t* handle) {
    handle->frame_number = handle->header.loop_frame;
    handle->frame_offset = 0;
}
