vgmstream/src/decode.c

#include "vgmstream.h"
#include "decode.h"
#include "layout/layout.h"
#include "coding/coding.h"
#include "mixing.h"
#include "plugins.h"
#ifdef VGM_USE_MAIATRAC3PLUS
#include "at3plus_decoder.h"
#endif

/* custom codec handling, not exactly "decode" stuff but here to simplify adding new codecs */


void free_codec(VGMSTREAM* vgmstream) {

#ifdef VGM_USE_VORBIS
    if (vgmstream->coding_type == coding_OGG_VORBIS) {
        free_ogg_vorbis(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_VORBIS_custom) {
        free_vorbis_custom(vgmstream->codec_data);
    }
#endif

    if (vgmstream->coding_type == coding_CIRCUS_VQ) {
        free_circus_vq(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_RELIC) {
        free_relic(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_CRI_HCA) {
        free_hca(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_TAC) {
        free_tac(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_UBI_ADPCM) {
        free_ubi_adpcm(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_IMUSE) {
        free_imuse(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_COMPRESSWAVE) {
        free_compresswave(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_EA_MT) {
        free_ea_mt(vgmstream->codec_data, vgmstream->channels);
    }

#ifdef VGM_USE_FFMPEG
    if (vgmstream->coding_type == coding_FFmpeg) {
        free_ffmpeg(vgmstream->codec_data);
    }
#endif

#if defined(VGM_USE_MP4V2) && defined(VGM_USE_FDKAAC)
    if (vgmstream->coding_type == coding_MP4_AAC) {
        free_mp4_aac(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_MPEG
    if (vgmstream->coding_type == coding_MPEG_custom ||
        vgmstream->coding_type == coding_MPEG_ealayer3 ||
        vgmstream->coding_type == coding_MPEG_layer1 ||
        vgmstream->coding_type == coding_MPEG_layer2 ||
        vgmstream->coding_type == coding_MPEG_layer3) {
        free_mpeg(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_G7221
    if (vgmstream->coding_type == coding_G7221C) {
        free_g7221(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_G719
    if (vgmstream->coding_type == coding_G719) {
        free_g719(vgmstream->codec_data, vgmstream->channels);
    }
#endif

#ifdef VGM_USE_MAIATRAC3PLUS
    if (vgmstream->coding_type == coding_AT3plus) {
        free_at3plus(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_ATRAC9
    if (vgmstream->coding_type == coding_ATRAC9) {
        free_atrac9(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_CELT
    if (vgmstream->coding_type == coding_CELT_FSB) {
        free_celt_fsb(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_SPEEX
    if (vgmstream->coding_type == coding_SPEEX) {
        free_speex(vgmstream->codec_data);
    }
#endif

    if (vgmstream->coding_type == coding_ACM) {
        free_acm(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_NWA) {
        free_nwa(vgmstream->codec_data);
    }
}


void seek_codec(VGMSTREAM* vgmstream) {
    if (vgmstream->coding_type == coding_CIRCUS_VQ) {
        seek_circus_vq(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_RELIC) {
        seek_relic(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_CRI_HCA) {
        loop_hca(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_TAC) {
        seek_tac(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_UBI_ADPCM) {
        seek_ubi_adpcm(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_IMUSE) {
        seek_imuse(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_COMPRESSWAVE) {
        seek_compresswave(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_EA_MT) {
        seek_ea_mt(vgmstream, vgmstream->loop_current_sample);
    }

#ifdef VGM_USE_VORBIS
    if (vgmstream->coding_type == coding_OGG_VORBIS) {
        seek_ogg_vorbis(vgmstream->codec_data, vgmstream->loop_current_sample);
    }

    if (vgmstream->coding_type == coding_VORBIS_custom) {
        seek_vorbis_custom(vgmstream, vgmstream->loop_current_sample);
    }
#endif

#ifdef VGM_USE_FFMPEG
    if (vgmstream->coding_type == coding_FFmpeg) {
        seek_ffmpeg(vgmstream->codec_data, vgmstream->loop_current_sample);
    }
#endif

#if defined(VGM_USE_MP4V2) && defined(VGM_USE_FDKAAC)
    if (vgmstream->coding_type == coding_MP4_AAC) {
        seek_mp4_aac(vgmstream, vgmstream->loop_sample);
    }
#endif

#ifdef VGM_USE_MAIATRAC3PLUS
    if (vgmstream->coding_type == coding_AT3plus) {
        seek_at3plus(vgmstream, vgmstream->loop_current_sample);
    }
#endif

#ifdef VGM_USE_ATRAC9
    if (vgmstream->coding_type == coding_ATRAC9) {
        seek_atrac9(vgmstream, vgmstream->loop_current_sample);
    }
#endif

#ifdef VGM_USE_CELT
    if (vgmstream->coding_type == coding_CELT_FSB) {
        seek_celt_fsb(vgmstream, vgmstream->loop_current_sample);
    }
#endif

#ifdef VGM_USE_SPEEX
    if (vgmstream->coding_type == coding_SPEEX) {
        seek_speex(vgmstream, vgmstream->loop_current_sample);
    }
#endif

#ifdef VGM_USE_MPEG
    if (vgmstream->coding_type == coding_MPEG_custom ||
        vgmstream->coding_type == coding_MPEG_ealayer3 ||
        vgmstream->coding_type == coding_MPEG_layer1 ||
        vgmstream->coding_type == coding_MPEG_layer2 ||
        vgmstream->coding_type == coding_MPEG_layer3) {
        seek_mpeg(vgmstream, vgmstream->loop_current_sample);
    }
#endif

    if (vgmstream->coding_type == coding_NWA) {
        seek_nwa(vgmstream->codec_data, vgmstream->loop_current_sample);
    }
}


void reset_codec(VGMSTREAM* vgmstream) {

#ifdef VGM_USE_VORBIS
    if (vgmstream->coding_type == coding_OGG_VORBIS) {
        reset_ogg_vorbis(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_VORBIS_custom) {
        reset_vorbis_custom(vgmstream);
    }
#endif

    if (vgmstream->coding_type == coding_CIRCUS_VQ) {
        reset_circus_vq(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_RELIC) {
        reset_relic(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_CRI_HCA) {
        reset_hca(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_TAC) {
        reset_tac(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_UBI_ADPCM) {
        reset_ubi_adpcm(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_IMUSE) {
        reset_imuse(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_COMPRESSWAVE) {
        reset_compresswave(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_EA_MT) {
        reset_ea_mt(vgmstream);
    }

#if defined(VGM_USE_MP4V2) && defined(VGM_USE_FDKAAC)
    if (vgmstream->coding_type == coding_MP4_AAC) {
        reset_mp4_aac(vgmstream);
    }
#endif

#ifdef VGM_USE_MPEG
    if (vgmstream->coding_type == coding_MPEG_custom ||
        vgmstream->coding_type == coding_MPEG_ealayer3 ||
        vgmstream->coding_type == coding_MPEG_layer1 ||
        vgmstream->coding_type == coding_MPEG_layer2 ||
        vgmstream->coding_type == coding_MPEG_layer3) {
        reset_mpeg(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_G7221
    if (vgmstream->coding_type == coding_G7221C) {
        reset_g7221(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_G719
    if (vgmstream->coding_type == coding_G719) {
        reset_g719(vgmstream->codec_data, vgmstream->channels);
    }
#endif

#ifdef VGM_USE_MAIATRAC3PLUS
    if (vgmstream->coding_type == coding_AT3plus) {
        reset_at3plus(vgmstream);
    }
#endif

#ifdef VGM_USE_ATRAC9
    if (vgmstream->coding_type == coding_ATRAC9) {
        reset_atrac9(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_CELT
    if (vgmstream->coding_type == coding_CELT_FSB) {
        reset_celt_fsb(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_SPEEX
    if (vgmstream->coding_type == coding_SPEEX) {
        reset_speex(vgmstream->codec_data);
    }
#endif

#ifdef VGM_USE_FFMPEG
    if (vgmstream->coding_type == coding_FFmpeg) {
        reset_ffmpeg(vgmstream->codec_data);
    }
#endif

    if (vgmstream->coding_type == coding_ACM) {
        reset_acm(vgmstream->codec_data);
    }

    if (vgmstream->coding_type == coding_NWA) {
        reset_nwa(vgmstream->codec_data);
    }
}


/* Get the number of samples of a single frame (smallest self-contained sample group, 1/N channels) */
int get_vgmstream_samples_per_frame(VGMSTREAM* vgmstream) {
    /* Value returned here is the max (or less) that vgmstream will ask a decoder per
     * "decode_x" call. Decoders with variable samples per frame or internal discard
     * may return 0 here and handle arbitrary samples_to_do values internally
     * (or some internal sample buffer max too). */

    switch (vgmstream->coding_type) {
        case coding_SILENCE:
            return 0;

        case coding_CRI_ADX:
        case coding_CRI_ADX_fixed:
        case coding_CRI_ADX_exp:
        case coding_CRI_ADX_enc_8:
        case coding_CRI_ADX_enc_9:
            return (vgmstream->interleave_block_size - 2) * 2;

        case coding_NGC_DSP:
        case coding_NGC_DSP_subint:
            return 14;
        case coding_NGC_AFC:
        case coding_VADPCM:
            return 16;
        case coding_NGC_DTK:
            return 28;
        case coding_G721:
            return 1;

        case coding_PCM16LE:
        case coding_PCM16BE:
        case coding_PCM16_int:
        case coding_PCM8:
        case coding_PCM8_int:
        case coding_PCM8_U:
        case coding_PCM8_U_int:
        case coding_PCM8_SB:
        case coding_ULAW:
        case coding_ULAW_int:
        case coding_ALAW:
        case coding_PCMFLOAT:
        case coding_PCM24LE:
            return 1;
#ifdef VGM_USE_VORBIS
        case coding_OGG_VORBIS:
        case coding_VORBIS_custom:
#endif
#ifdef VGM_USE_MPEG
        case coding_MPEG_custom:
        case coding_MPEG_ealayer3:
        case coding_MPEG_layer1:
        case coding_MPEG_layer2:
        case coding_MPEG_layer3:
#endif
        case coding_SDX2:
        case coding_SDX2_int:
        case coding_CBD2:
        case coding_CBD2_int:
        case coding_ACM:
        case coding_DERF:
        case coding_WADY:
        case coding_NWA:
        case coding_SASSC:
        case coding_CIRCUS_ADPCM:
            return 1;

        case coding_IMA:
        case coding_DVI_IMA:
        case coding_SNDS_IMA:
        case coding_QD_IMA:
        case coding_UBI_IMA:
        case coding_UBI_SCE_IMA:
        case coding_OKI16:
        case coding_OKI4S:
        case coding_MTF_IMA:
            return 1;
        case coding_PCM4:
        case coding_PCM4_U:
        case coding_IMA_int:
        case coding_DVI_IMA_int:
        case coding_3DS_IMA:
        case coding_WV6_IMA:
        case coding_ALP_IMA:
        case coding_FFTA2_IMA:
        case coding_BLITZ_IMA:
        case coding_PCFX:
            return 2;
        case coding_XBOX_IMA:
        case coding_XBOX_IMA_mch:
        case coding_XBOX_IMA_int:
        case coding_FSB_IMA:
        case coding_WWISE_IMA:
        case coding_CD_IMA:
            return 64;
        case coding_APPLE_IMA4:
            return 64;
        case coding_MS_IMA:
        case coding_REF_IMA:
            return ((vgmstream->interleave_block_size - 0x04*vgmstream->channels) * 2 / vgmstream->channels) + 1;/* +1 from header sample */
        case coding_MS_IMA_mono:
            return ((vgmstream->frame_size - 0x04) * 2) + 1; /* +1 from header sample */
        case coding_RAD_IMA:
            return (vgmstream->interleave_block_size - 0x04*vgmstream->channels) * 2 / vgmstream->channels;
        case coding_NDS_IMA:
        case coding_DAT4_IMA:
            return (vgmstream->interleave_block_size - 0x04) * 2;
        case coding_AWC_IMA:
            return (0x800 - 0x04) * 2;
        case coding_RAD_IMA_mono:
            return 32;
        case coding_H4M_IMA:
            return 0; /* variable (block-controlled) */

        case coding_XA:
        case coding_XA_EA:
            return 28*8 / vgmstream->channels; /* 8 subframes per frame, mono/stereo */
        case coding_XA8:
            return 28*4 / vgmstream->channels; /* 4 subframes per frame, mono/stereo */
        case coding_PSX:
        case coding_PSX_badflags:
        case coding_HEVAG:
            return 28;
        case coding_PSX_cfg:
        case coding_PSX_pivotal:
            return (vgmstream->interleave_block_size - 0x01) * 2; /* size 0x01 header */

        case coding_EA_XA:
        case coding_EA_XA_int:
        case coding_EA_XA_V2:
        case coding_MAXIS_XA:
            return 28;
        case coding_EA_XAS_V0:
            return 32;
        case coding_EA_XAS_V1:
            return 128;

        case coding_MSADPCM:
            return (vgmstream->frame_size - 0x07*vgmstream->channels)*2 / vgmstream->channels + 2;
        case coding_MSADPCM_int:
        case coding_MSADPCM_ck:
            return (vgmstream->frame_size - 0x07)*2 + 2;
        case coding_WS: /* only works if output sample size is 8 bit, which always is for WS ADPCM */
            return vgmstream->ws_output_size;
        case coding_AICA:
        case coding_CP_YM:
            return 1;
        case coding_AICA_int:
            return 2;
        case coding_ASKA:
            return (vgmstream->frame_size - 0x04*vgmstream->channels) * 2 / vgmstream->channels;
        case coding_NXAP:
            return (0x40-0x04) * 2;
        case coding_NDS_PROCYON:
            return 30;
        case coding_L5_555:
            return 32;
        case coding_LSF:
            return 54;

#ifdef VGM_USE_G7221
        case coding_G7221C:
            return 32000/50; /* Siren7: 16000/50 */
#endif
#ifdef VGM_USE_G719
        case coding_G719:
            return 48000/50;
#endif
#ifdef VGM_USE_FFMPEG
        case coding_FFmpeg:
            return 0;
#endif
        case coding_MTAF:
            return 128*2;
        case coding_MTA2:
            return 128*2;
        case coding_MC3:
            return 10;
        case coding_FADPCM:
            return 256; /* (0x8c - 0xc) * 2 */
        case coding_ASF:
            return 32;  /* (0x11 - 0x1) * 2 */
        case coding_TANTALUS:
            return 30; /* (0x10 - 0x01) * 2 */
        case coding_DSA:
            return 14;  /* (0x08 - 0x1) * 2 */
        case coding_XMD:
            return (vgmstream->interleave_block_size - 0x06)*2 + 2;
        case coding_PTADPCM:
            return (vgmstream->interleave_block_size - 0x05)*2 + 2;
        case coding_UBI_ADPCM:
            return 0; /* varies per mode */
        case coding_IMUSE:
            return 0; /* varies per frame */
        case coding_COMPRESSWAVE:
            return 0; /* multiple of 2 */
        case coding_EA_MT:
            return 0; /* 432, but variable in looped files */
        case coding_CIRCUS_VQ:
            return 0;
        case coding_RELIC:
            return 0; /* 512 */
        case coding_CRI_HCA:
            return 0; /* 1024 - delay/padding (which can be bigger than 1024) */
        case coding_TAC:
            return 0; /* 1024 - delay/padding */
#if defined(VGM_USE_MP4V2) && defined(VGM_USE_FDKAAC)
        case coding_MP4_AAC:
            return ((mp4_aac_codec_data*)vgmstream->codec_data)->samples_per_frame;
#endif
#ifdef VGM_USE_MAIATRAC3PLUS
        case coding_AT3plus:
            return 2048 - ((maiatrac3plus_codec_data*)vgmstream->codec_data)->samples_discard;
#endif
#ifdef VGM_USE_ATRAC9
        case coding_ATRAC9:
            return 0; /* varies with config data, usually 256 or 1024 */
#endif
#ifdef VGM_USE_CELT
        case coding_CELT_FSB:
            return 0; /* 512? */
#endif
#ifdef VGM_USE_SPEEX
        case coding_SPEEX:
            return 0;
#endif
        default:
            return 0;
    }
}

/* Get the number of bytes of a single frame (smallest self-contained byte group, 1/N channels) */
int get_vgmstream_frame_size(VGMSTREAM* vgmstream) {
    switch (vgmstream->coding_type) {
        case coding_SILENCE:
            return 0;

        case coding_CRI_ADX:
        case coding_CRI_ADX_fixed:
        case coding_CRI_ADX_exp:
        case coding_CRI_ADX_enc_8:
        case coding_CRI_ADX_enc_9:
            return vgmstream->interleave_block_size;

        case coding_NGC_DSP:
            return 0x08;
        case coding_NGC_DSP_subint:
            return 0x08 * vgmstream->channels;
        case coding_NGC_AFC:
        case coding_VADPCM:
            return 0x09;
        case coding_NGC_DTK:
            return 0x20;
        case coding_G721:
            return 0;

        case coding_PCM16LE:
        case coding_PCM16BE:
        case coding_PCM16_int:
            return 0x02;
        case coding_PCM8:
        case coding_PCM8_int:
        case coding_PCM8_U:
        case coding_PCM8_U_int:
        case coding_PCM8_SB:
        case coding_ULAW:
        case coding_ULAW_int:
        case coding_ALAW:
            return 0x01;
        case coding_PCMFLOAT:
            return 0x04;
        case coding_PCM24LE:
            return 0x03;

        case coding_SDX2:
        case coding_SDX2_int:
        case coding_CBD2:
        case coding_CBD2_int:
        case coding_DERF:
        case coding_WADY:
        case coding_NWA:
        case coding_SASSC:
        case coding_CIRCUS_ADPCM:
            return 0x01;

        case coding_PCM4:
        case coding_PCM4_U:
        case coding_IMA:
        case coding_IMA_int:
        case coding_DVI_IMA:
        case coding_DVI_IMA_int:
        case coding_3DS_IMA:
        case coding_WV6_IMA:
        case coding_ALP_IMA:
        case coding_FFTA2_IMA:
        case coding_BLITZ_IMA:
        case coding_PCFX:
        case coding_OKI16:
        case coding_OKI4S:
        case coding_MTF_IMA:
            return 0x01;
        case coding_RAD_IMA:
        case coding_NDS_IMA:
        case coding_DAT4_IMA:
        case coding_REF_IMA:
            return vgmstream->interleave_block_size;
        case coding_MS_IMA:
        case coding_MS_IMA_mono:
            return vgmstream->frame_size;
        case coding_AWC_IMA:
            return 0x800;
        case coding_RAD_IMA_mono:
            return 0x14;
        case coding_SNDS_IMA:
        case coding_QD_IMA:
            return 0; //todo: 0x01?
        case coding_UBI_IMA: /* variable (PCM then IMA) */
            return 0;
        case coding_UBI_SCE_IMA:
            return 0;
        case coding_XBOX_IMA:
            //todo should be  0x48 when stereo, but blocked/interleave layout don't understand stereo codecs
            return 0x24; //vgmstream->channels==1 ? 0x24 : 0x48;
        case coding_XBOX_IMA_int:
        case coding_WWISE_IMA:
        case coding_CD_IMA:
            return 0x24;
        case coding_XBOX_IMA_mch:
        case coding_FSB_IMA:
            return 0x24 * vgmstream->channels;
        case coding_APPLE_IMA4:
            return 0x22;
        case coding_H4M_IMA:
            return 0x00; /* variable (block-controlled) */

        case coding_XA:
        case coding_XA_EA:
        case coding_XA8:
            return 0x80;
        case coding_PSX:
        case coding_PSX_badflags:
        case coding_HEVAG:
            return 0x10;
        case coding_PSX_cfg:
        case coding_PSX_pivotal:
            return vgmstream->interleave_block_size;

        case coding_EA_XA:
            return 0x1E;
        case coding_EA_XA_int:
            return 0x0F;
        case coding_MAXIS_XA:
            return 0x0F*vgmstream->channels;
        case coding_EA_XA_V2:
            return 0; /* variable (ADPCM frames of 0x0f or PCM frames of 0x3d) */
        case coding_EA_XAS_V0:
            return 0xF+0x02+0x02;
        case coding_EA_XAS_V1:
            return 0x4c*vgmstream->channels;

        case coding_MSADPCM:
        case coding_MSADPCM_int:
        case coding_MSADPCM_ck:
            return vgmstream->frame_size;
        case coding_WS:
            return vgmstream->current_block_size;
        case coding_AICA:
        case coding_AICA_int:
        case coding_CP_YM:
            return 0x01;
        case coding_ASKA:
            return vgmstream->frame_size;
        case coding_NXAP:
            return 0x40;
        case coding_NDS_PROCYON:
            return 0x10;
        case coding_L5_555:
            return 0x12;
        case coding_LSF:
            return 0x1C;

#ifdef VGM_USE_G7221
        case coding_G7221C:
#endif
#ifdef VGM_USE_G719
        case coding_G719:
#endif
#ifdef VGM_USE_MAIATRAC3PLUS
        case coding_AT3plus:
#endif
#ifdef VGM_USE_FFMPEG
        case coding_FFmpeg:
#endif
        case coding_MTAF:
            return vgmstream->interleave_block_size;
        case coding_MTA2:
            return 0x90;
        case coding_MC3:
            return 0x04;
        case coding_FADPCM:
            return 0x8c;
        case coding_ASF:
            return 0x11;
        case coding_TANTALUS:
            return 0x10;
        case coding_DSA:
            return 0x08;
        case coding_XMD:
            return vgmstream->interleave_block_size;
        case coding_PTADPCM:
            return vgmstream->interleave_block_size;
        /* UBI_ADPCM: varies per mode? */
        /* IMUSE: VBR */
        /* EA_MT: VBR, frames of bit counts or PCM frames */
        /* COMPRESSWAVE: VBR/huffman bits */
        /* ATRAC9: CBR around  0x100-200 */
        /* CELT FSB: varies, usually 0x80-100 */
        /* SPEEX: varies, usually 0x40-60 */
        /* TAC: VBR around ~0x200-300 */
        /* Vorbis, MPEG, ACM, etc: varies */
        default: /* (VBR or managed by decoder) */
            return 0;
    }
}

/* In NDS IMA the frame size is the block size, so the last one is short */
int get_vgmstream_samples_per_shortframe(VGMSTREAM* vgmstream) {
    switch (vgmstream->coding_type) {
        case coding_NDS_IMA:
            return (vgmstream->interleave_last_block_size-4)*2;
        default:
            return get_vgmstream_samples_per_frame(vgmstream);
    }
}

int get_vgmstream_shortframe_size(VGMSTREAM* vgmstream) {
    switch (vgmstream->coding_type) {
        case coding_NDS_IMA:
            return vgmstream->interleave_last_block_size;
        default:
            return get_vgmstream_frame_size(vgmstream);
    }
}

/* Decode samples into the buffer. Assume that we have written samples_written into the
 * buffer already, and we have samples_to_do consecutive samples ahead of us (won't call
 * more than one frame if configured above to do so).
 * Called by layouts since they handle samples written/to_do */
void decode_vgmstream(VGMSTREAM* vgmstream, int samples_written, int samples_to_do, sample_t* buffer) {
    int ch;

    buffer += samples_written * vgmstream->channels; /* passed externally to simplify I guess */

    switch (vgmstream->coding_type) {
        case coding_SILENCE:
            memset(buffer, 0, samples_to_do * vgmstream->channels * sizeof(sample_t));
            break;

        case coding_CRI_ADX:
        case coding_CRI_ADX_exp:
        case coding_CRI_ADX_fixed:
        case coding_CRI_ADX_enc_8:
        case coding_CRI_ADX_enc_9:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_adx(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->interleave_block_size, vgmstream->coding_type);
            }
            break;
        case coding_NGC_DSP:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ngc_dsp(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_NGC_DSP_subint:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ngc_dsp_subint(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch,
                        vgmstream->interleave_block_size);
            }
            break;

        case coding_PCM16LE:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm16le(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM16BE:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm16be(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM16_int:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm16_int(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->codec_endian);
            }
            break;
        case coding_PCM8:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm8(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM8_int:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm8_int(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM8_U:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm8_unsigned(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM8_U_int:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm8_unsigned_int(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM8_SB:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm8_sb(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCM4:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm4(vgmstream,&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_PCM4_U:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm4_unsigned(vgmstream, &vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;

        case coding_ULAW:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ulaw(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_ULAW_int:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ulaw_int(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_ALAW:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_alaw(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_PCMFLOAT:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcmfloat(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->codec_endian);
            }
            break;

        case coding_PCM24LE:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcm24le(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;

        case coding_NDS_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_nds_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_DAT4_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_dat4_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_XBOX_IMA:
        case coding_XBOX_IMA_int: {
            int is_stereo = (vgmstream->channels > 1 && vgmstream->coding_type == coding_XBOX_IMA);
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_xbox_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch, is_stereo);
            }
            break;
        }
        case coding_XBOX_IMA_mch:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_xbox_ima_mch(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_MS_IMA:
        case coding_MS_IMA_mono:
            //TODO: improve
            vgmstream->codec_config = (vgmstream->coding_type == coding_MS_IMA_mono) || vgmstream->channels == 1; /* mono mode */
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ms_ima(vgmstream,&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_RAD_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_rad_ima(vgmstream,&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_RAD_IMA_mono:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_rad_ima_mono(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_NGC_DTK:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ngc_dtk(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_G721:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_g721(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_NGC_AFC:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ngc_afc(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_VADPCM: {
            int order = vgmstream->codec_config;
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_vadpcm(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, order);
            }
            break;
        }
        case coding_PSX:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_psx(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        0, vgmstream->codec_config);
            }
            break;
        case coding_PSX_badflags:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_psx(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        1, vgmstream->codec_config);
            }
            break;
        case coding_PSX_cfg:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_psx_configurable(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->interleave_block_size, vgmstream->codec_config);
            }
            break;
        case coding_PSX_pivotal:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_psx_pivotal(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->interleave_block_size);
            }
            break;
        case coding_HEVAG:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_hevag(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_XA:
        case coding_XA_EA:
        case coding_XA8: {
            decode_xa(vgmstream, buffer, samples_to_do);
            break;
        }
        case coding_EA_XA:
        case coding_EA_XA_int: {
            int is_stereo = (vgmstream->channels > 1 && vgmstream->coding_type == coding_EA_XA);
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ea_xa(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch, is_stereo);
            }
            break;
        }
        case coding_EA_XA_V2:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ea_xa_v2(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_MAXIS_XA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_maxis_xa(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_EA_XAS_V0:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ea_xas_v0(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_EA_XAS_V1:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ea_xas_v1(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
#ifdef VGM_USE_VORBIS
        case coding_OGG_VORBIS:
            decode_ogg_vorbis(vgmstream->codec_data, buffer, samples_to_do, vgmstream->channels);
            break;

        case coding_VORBIS_custom:
            decode_vorbis_custom(vgmstream, buffer, samples_to_do, vgmstream->channels);
            break;
#endif
        case coding_CIRCUS_VQ:
            decode_circus_vq(vgmstream->codec_data, buffer, samples_to_do, vgmstream->channels);
            break;
        case coding_RELIC:
            decode_relic(&vgmstream->ch[0], vgmstream->codec_data, buffer, samples_to_do);
            break;
        case coding_CRI_HCA:
            decode_hca(vgmstream->codec_data, buffer, samples_to_do);
            break;
        case coding_TAC:
            decode_tac(vgmstream, buffer, samples_to_do);
            break;
#ifdef VGM_USE_FFMPEG
        case coding_FFmpeg:
            decode_ffmpeg(vgmstream, buffer, samples_to_do, vgmstream->channels);
            break;
#endif
#if defined(VGM_USE_MP4V2) && defined(VGM_USE_FDKAAC)
        case coding_MP4_AAC:
            decode_mp4_aac(vgmstream->codec_data, buffer, samples_to_do, vgmstream->channels);
            break;
#endif
        case coding_SDX2:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_sdx2(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_SDX2_int:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_sdx2_int(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_CBD2:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_cbd2(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_CBD2_int:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_cbd2_int(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_DERF:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_derf(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_WADY:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_wady(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_CIRCUS_ADPCM:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_circus_adpcm(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;

        case coding_IMA:
        case coding_IMA_int:
        case coding_DVI_IMA:
        case coding_DVI_IMA_int: {
            int is_stereo = (vgmstream->channels > 1 && vgmstream->coding_type == coding_IMA)
                    || (vgmstream->channels > 1 && vgmstream->coding_type == coding_DVI_IMA);
            int is_high_first = vgmstream->coding_type == coding_DVI_IMA
                    || vgmstream->coding_type == coding_DVI_IMA_int;
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_standard_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch,
                        is_stereo, is_high_first);
            }
            break;
        }
        case coding_MTF_IMA: {
            int is_stereo = (vgmstream->channels > 1);
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_mtf_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch, is_stereo);
            }
            break;
        }
        case coding_3DS_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_3ds_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_WV6_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_wv6_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_ALP_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_alp_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_FFTA2_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ffta2_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_BLITZ_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_blitz_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;

        case coding_APPLE_IMA4:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_apple_ima4(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_SNDS_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_snds_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_QD_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_otns_ima(vgmstream, &vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_FSB_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_fsb_ima(vgmstream, &vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_WWISE_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_wwise_ima(vgmstream,&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_REF_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ref_ima(vgmstream,&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_AWC_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_awc_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_UBI_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ubi_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_UBI_SCE_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ubi_sce_ima(&vgmstream->ch[ch], buffer+ch,
                    vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_H4M_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                uint16_t frame_format = (uint16_t)((vgmstream->codec_config >> 8) & 0xFFFF);

                decode_h4m_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch,
                        frame_format);
            }
            break;
        case coding_CD_IMA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_cd_ima(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;

        case coding_WS:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ws(vgmstream, ch, buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;

#ifdef VGM_USE_MPEG
        case coding_MPEG_custom:
        case coding_MPEG_ealayer3:
        case coding_MPEG_layer1:
        case coding_MPEG_layer2:
        case coding_MPEG_layer3:
            decode_mpeg(vgmstream, buffer, samples_to_do, vgmstream->channels);
            break;
#endif
#ifdef VGM_USE_G7221
        case coding_G7221C:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_g7221(vgmstream, buffer+ch, vgmstream->channels, samples_to_do, ch);
            }
            break;
#endif
#ifdef VGM_USE_G719
        case coding_G719:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_g719(vgmstream, buffer+ch, vgmstream->channels, samples_to_do, ch);
            }
            break;
#endif
#ifdef VGM_USE_MAIATRAC3PLUS
        case coding_AT3plus:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_at3plus(vgmstream, buffer+ch, vgmstream->channels, samples_to_do, ch);
            }
            break;
#endif
#ifdef VGM_USE_ATRAC9
        case coding_ATRAC9:
            decode_atrac9(vgmstream, buffer, samples_to_do, vgmstream->channels);
            break;
#endif
#ifdef VGM_USE_CELT
        case coding_CELT_FSB:
            decode_celt_fsb(vgmstream, buffer, samples_to_do, vgmstream->channels);
            break;
#endif
#ifdef VGM_USE_SPEEX
        case coding_SPEEX:
            decode_speex(vgmstream, buffer, samples_to_do);
            break;
#endif
        case coding_ACM:
            decode_acm(vgmstream->codec_data, buffer, samples_to_do, vgmstream->channels);
            break;
        case coding_NWA:
            decode_nwa(vgmstream->codec_data, buffer, samples_to_do);
            break;
        case coding_MSADPCM:
        case coding_MSADPCM_int:
            if (vgmstream->channels == 1 || vgmstream->coding_type == coding_MSADPCM_int) {
                for (ch = 0; ch < vgmstream->channels; ch++) {
                    decode_msadpcm_mono(vgmstream,buffer+ch,
                            vgmstream->channels,vgmstream->samples_into_block, samples_to_do, ch,
                            vgmstream->codec_config);
                }
            }
            else if (vgmstream->channels == 2) {
                decode_msadpcm_stereo(vgmstream, buffer, vgmstream->samples_into_block,samples_to_do);
            }
            break;
        case coding_MSADPCM_ck:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_msadpcm_ck(vgmstream, buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_AICA:
        case coding_AICA_int: {
            int is_stereo = (vgmstream->channels > 1 && vgmstream->coding_type == coding_AICA);
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_aica(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch,
                        is_stereo);
            }
            break;
        }
        case coding_CP_YM: {
            int is_stereo = (vgmstream->channels > 1);
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_cp_ym(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch,
                        is_stereo);
            }
            break;
        }
        case coding_ASKA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_aska(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch, vgmstream->frame_size);
            }
            break;
        case coding_NXAP:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_nxap(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_TGC:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_tgc(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_NDS_PROCYON:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_nds_procyon(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_L5_555:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_l5_555(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_SASSC:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_sassc(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_LSF:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_lsf(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_MTAF:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_mtaf(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_MTA2:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_mta2(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch, vgmstream->codec_config);
            }
            break;
        case coding_MC3:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_mc3(vgmstream, &vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;
        case coding_FADPCM:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_fadpcm(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels,vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_ASF:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_asf(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_TANTALUS:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_tantalus(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_DSA:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_dsa(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do);
            }
            break;
        case coding_XMD:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_xmd(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->interleave_block_size);
            }
            break;
        case coding_PTADPCM:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ptadpcm(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->interleave_block_size);
            }
            break;
        case coding_PCFX:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_pcfx(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do,
                        vgmstream->codec_config);
            }
            break;
        case coding_OKI16:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_oki16(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;

        case coding_OKI4S:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_oki4s(&vgmstream->ch[ch], buffer+ch,
                        vgmstream->channels, vgmstream->samples_into_block, samples_to_do, ch);
            }
            break;

        case coding_UBI_ADPCM:
            decode_ubi_adpcm(vgmstream, buffer, samples_to_do);
            break;

        case coding_IMUSE:
            decode_imuse(vgmstream, buffer, samples_to_do);
            break;

        case coding_COMPRESSWAVE:
            decode_compresswave(vgmstream->codec_data, buffer, samples_to_do);
            break;

        case coding_EA_MT:
            for (ch = 0; ch < vgmstream->channels; ch++) {
                decode_ea_mt(vgmstream, buffer+ch, vgmstream->channels, samples_to_do, ch);
            }
            break;
        default:
            break;
    }
}

/* Calculate number of consecutive samples we can decode. Takes into account hitting
 * a loop start or end, or going past a single frame. */
int get_vgmstream_samples_to_do(int samples_this_block, int samples_per_frame, VGMSTREAM* vgmstream) {
    int samples_to_do;
    int samples_left_this_block;

    samples_left_this_block = samples_this_block - vgmstream->samples_into_block;
    samples_to_do = samples_left_this_block; /* by default decodes all samples left */

    /* fun loopy crap, why did I think this would be any simpler? */
    if (vgmstream->loop_flag) {
        int samples_after_decode = vgmstream->current_sample + samples_left_this_block;

        /* are we going to hit the loop end during this block? */
        if (samples_after_decode > vgmstream->loop_end_sample) {
            /* only do samples up to loop end */
            samples_to_do = vgmstream->loop_end_sample - vgmstream->current_sample;
        }

        /* are we going to hit the loop start during this block? (first time only) */
        if (samples_after_decode > vgmstream->loop_start_sample && !vgmstream->hit_loop) {
            /* only do samples up to loop start */
            samples_to_do = vgmstream->loop_start_sample - vgmstream->current_sample;
        }
    }

    /* if it's a framed encoding don't do more than one frame */
    if (samples_per_frame > 1 && (vgmstream->samples_into_block % samples_per_frame) + samples_to_do > samples_per_frame)
        samples_to_do = samples_per_frame - (vgmstream->samples_into_block % samples_per_frame);

    return samples_to_do;
}

/* Detect loop start and save values, or detect loop end and restore (loop back).
 * Returns 1 if loop was done. */
int vgmstream_do_loop(VGMSTREAM* vgmstream) {
    /*if (!vgmstream->loop_flag) return 0;*/

    /* is this the loop end? = new loop, continue from loop_start_sample */
    if (vgmstream->current_sample == vgmstream->loop_end_sample) {

        /* disable looping if target count reached and continue normally
         * (only needed with the "play stream end after looping N times" option enabled) */
        vgmstream->loop_count++;
        if (vgmstream->loop_target && vgmstream->loop_target == vgmstream->loop_count) {
            vgmstream->loop_flag = 0; /* could be improved but works ok, will be restored on resets */
            return 0;
        }

        /* against everything I hold sacred, preserve adpcm history before looping for certain types */
        if (vgmstream->meta_type == meta_DSP_STD ||
            vgmstream->meta_type == meta_DSP_RS03 ||
            vgmstream->meta_type == meta_DSP_CSTR ||
            vgmstream->coding_type == coding_PSX ||
            vgmstream->coding_type == coding_PSX_badflags) {
            int ch;
            for (ch = 0; ch < vgmstream->channels; ch++) {
                vgmstream->loop_ch[ch].adpcm_history1_16 = vgmstream->ch[ch].adpcm_history1_16;
                vgmstream->loop_ch[ch].adpcm_history2_16 = vgmstream->ch[ch].adpcm_history2_16;
                vgmstream->loop_ch[ch].adpcm_history1_32 = vgmstream->ch[ch].adpcm_history1_32;
                vgmstream->loop_ch[ch].adpcm_history2_32 = vgmstream->ch[ch].adpcm_history2_32;
            }
        }

        //TODO: improve
        /* loop codecs that need special handling, usually:
         * - on hit_loop, current offset is copied to loop_ch[].offset
         * - some codecs will overwrite loop_ch[].offset with a custom value
         * - loop_ch[] is copied to ch[] (with custom value)
         * - then codec will use ch[]'s offset
         * regular codecs may use copied loop_ch[] offset without issue */
        seek_codec(vgmstream);

        /* restore! */
        memcpy(vgmstream->ch, vgmstream->loop_ch, sizeof(VGMSTREAMCHANNEL) * vgmstream->channels);
        vgmstream->current_sample = vgmstream->loop_current_sample;
        vgmstream->samples_into_block = vgmstream->loop_samples_into_block;
        vgmstream->current_block_size = vgmstream->loop_block_size;
        vgmstream->current_block_samples = vgmstream->loop_block_samples;
        vgmstream->current_block_offset = vgmstream->loop_block_offset;
        vgmstream->next_block_offset = vgmstream->loop_next_block_offset;
        //vgmstream->pstate = vgmstream->lstate; /* play state is applied over loops */

        /* loop layouts (after restore, in case layout needs state manipulations) */
        switch(vgmstream->layout_type) {
            case layout_segmented:
                loop_layout_segmented(vgmstream, vgmstream->loop_current_sample);
                break;
            case layout_layered:
                loop_layout_layered(vgmstream, vgmstream->loop_current_sample);
                break;
            default:
                break;
        }

        return 1; /* looped */
    }


    /* is this the loop start? save if we haven't saved yet (right when first loop starts) */
    if (!vgmstream->hit_loop && vgmstream->current_sample == vgmstream->loop_start_sample) {
        /* save! */
        memcpy(vgmstream->loop_ch, vgmstream->ch, sizeof(VGMSTREAMCHANNEL)*vgmstream->channels);
        vgmstream->loop_current_sample = vgmstream->current_sample;
        vgmstream->loop_samples_into_block = vgmstream->samples_into_block;
        vgmstream->loop_block_size = vgmstream->current_block_size;
        vgmstream->loop_block_samples = vgmstream->current_block_samples;
        vgmstream->loop_block_offset = vgmstream->current_block_offset;
        vgmstream->loop_next_block_offset = vgmstream->next_block_offset;
        //vgmstream->lstate = vgmstream->pstate; /* play state is applied over loops */

        vgmstream->hit_loop = 1; /* info that loop is now ready to use */
    }

    return 0; /* not looped */
}