#include "mpeg_decoder.h"

#ifdef VGM_USE_MPEG

/* init config and validate per type */
int mpeg_custom_setup_init_default(STREAMFILE* sf, off_t start_offset, mpeg_codec_data* data, coding_t* coding_type) {
    mpeg_frame_info info;


    /* get frame info at offset */
    if ( !mpeg_get_frame_info(sf, start_offset, &info))
        goto fail;
    switch(info.layer) {
        case 1: *coding_type = coding_MPEG_layer1; break;
        case 2: *coding_type = coding_MPEG_layer2; break;
        case 3: *coding_type = coding_MPEG_layer3; break;
        default: goto fail;
    }
    data->channels_per_frame = info.channels;
    data->samples_per_frame = info.frame_samples;
    data->bitrate_per_frame = info.bit_rate;
    data->sample_rate_per_frame = info.sample_rate;


    /* extra checks per type */
    switch(data->type) {
        case MPEG_XVAG:
            if (data->config.chunk_size <= 0 || data->config.interleave <= 0)
                goto fail; /* needs external fixed size */
            break;

        case MPEG_FSB:
            if (data->config.fsb_padding != 0
                    && data->config.fsb_padding != 2
                    && data->config.fsb_padding != 4
                    && data->config.fsb_padding != 16)
                goto fail; /* aligned to closest 0/2/4/16 bytes */

            /* get find interleave to stream offsets are set up externally */
            {
                int current_data_size = info.frame_size;
                int current_padding = 0;
                /* FSB padding for Layer III or multichannel Layer II */
                if ((info.layer == 3 && data->config.fsb_padding) || data->config.fsb_padding == 16) {
                    current_padding = (current_data_size % data->config.fsb_padding)
                            ? data->config.fsb_padding - (current_data_size % data->config.fsb_padding)
                            : 0;
                }

                data->config.interleave = current_data_size + current_padding; /* should be constant for all stream */
            }
            break;

        //todo simplify/unify XVAG/P3D/SCD/LYN and just feed arbitrary chunks to the decoder
        case MPEG_P3D:
        case MPEG_SCD:
            if (data->config.interleave <= 0)
                goto fail; /* needs external fixed size */
            break;

        case MPEG_LYN:
            if (data->config.interleave <= 0)
                goto fail; /* needs external fixed size */
            data->default_buffer_size = data->config.interleave;
            if (data->default_buffer_size < data->config.interleave_last)
                data->default_buffer_size = data->config.interleave_last;
            break;

        case MPEG_STANDARD:
        case MPEG_AHX:
        case MPEG_EA:
            if (info.channels != data->config.channels)
                goto fail; /* no multichannel expected */
            break;

        default:
            break;  /* nothing special needed */
    }


    //todo: test more: this improves the output, but seems formats aren't usually prepared
    // (and/or the num_samples includes all possible samples in file, so by discarding some it'll reach EOF)

    /* set encoder delay (samples to skip at the beginning of a stream) if needed, which varies with encoder used */
    switch(data->type) {
        //case MPEG_AHX: data->skip_samples = 480; break; /* observed default */
        //case MPEG_P3D: data->skip_samples = info.frame_samples; break; /* matches Radical ADPCM (PC) output */

        /* FSBs (with FMOD DLLs) don't seem to need it. Particularly a few games (all from Wayforward?)
         * contain audible garbage at the beginning, but it's actually there in-game too.
         * Games doing full loops also must not have delay (reuses mpeg state on loop) */
        case MPEG_FSB:
            data->skip_samples = 0; break;

        case MPEG_XVAG: /* set in header and needed for gapless looping */
            data->skip_samples = data->config.skip_samples; break;
        case MPEG_STANDARD:
            data->skip_samples = data->config.skip_samples; break;
        case MPEG_EA:
            /* typical MP2 decoder delay, verified vs sx.exe, also SCHl blocks header takes discard
             * samples into account (so block_samples+240*2+1 = total frame samples) */
            if (info.layer == 2) {
                data->skip_samples = 240*2 + 1;
            }
            /* MP3 probably uses 576 + 528+1 but no known games use it */
            break;
        default:
            break;
    }
    data->samples_to_discard = data->skip_samples;


    return 1;
fail:
    return 0;
}


/* writes data to the buffer and moves offsets */
int mpeg_custom_parse_frame_default(VGMSTREAMCHANNEL* stream, mpeg_codec_data* data, int num_stream) {
    mpeg_custom_stream *ms = data->streams[num_stream];
    mpeg_frame_info info;
    size_t current_data_size = 0;
    size_t current_padding = 0;
    size_t current_interleave_pre = 0; /* interleaved data size before current stream */
    size_t current_interleave_post = 0; /* interleaved data size after current stream */
    size_t current_interleave = 0; /* interleave in this block (usually this + pre + post = interleave*streams = block) */


    /* Get data size to give to the decoder, per stream. Usually 1 frame at a time,
     * but doesn't really need to be a full frame (decoder would request more data). */
    switch(data->type) {

        case MPEG_XVAG: /* frames of fixed size (though we could read frame info too) */
            current_interleave = data->config.interleave; /* big interleave */
            current_interleave_pre  = current_interleave*num_stream;
            current_interleave_post = current_interleave*(data->streams_size-1) - current_interleave_pre;

            current_data_size = data->config.chunk_size;
            break;

        case MPEG_FSB: /* frames with padding + interleave */
            current_interleave = data->config.interleave; /* constant for multi-stream FSbs (1 frame + padding) */
            current_interleave_pre  = current_interleave*num_stream;
            current_interleave_post = current_interleave*(data->streams_size-1) - current_interleave_pre;

            if (!mpeg_get_frame_info(stream->streamfile, stream->offset + current_interleave_pre, &info))
                goto fail;
            current_data_size = info.frame_size;

            /* get FSB padding for Layer III or multichannel Layer II (Layer I isn't supported by FMOD).
             * Padding sometimes contains garbage like the next frame header so we can't feed it to mpg123 or it gets confused. */
            if ((info.layer == 3 && data->config.fsb_padding) || data->config.fsb_padding == 16) {
                current_padding = (current_data_size % data->config.fsb_padding)
                        ? data->config.fsb_padding - (current_data_size % data->config.fsb_padding)
                        : 0;

                /* Rare Mafia II (PS3) bug (GP_0701_music multilang only): some frame paddings "4" are incorrect,
                 * calcs give 0xD0+0x00 but need 0xD0+0x04 (unlike all other fsbs, which never do that).
                 * FMOD tools decode fine, so they may be doing special detection too, since even
                 * re-encoding the same file and using the same FSB flags/modes won't trigger the bug. */
                if (info.layer == 3 && data->config.fsb_padding == 4 && current_data_size == 0xD0) {
                    uint32_t next_header;
                    off_t next_offset;

                    next_offset = stream->offset + current_data_size + current_padding;
                    if (current_interleave && ((next_offset - stream->channel_start_offset + current_interleave_pre + current_interleave_post) % current_interleave == 0)) {
                        next_offset += current_interleave_pre + current_interleave_post;
                    }

                    next_header = read_32bitBE(next_offset, stream->streamfile);
                    if ((next_header & 0xFFE00000) != 0xFFE00000) { /* doesn't land in a proper frame, fix sizes and hope */
                        VGM_LOG_ONCE("MPEG FSB: stream with wrong padding found\n");
                        current_padding = 0x04;
                    }
                }

            }

            VGM_ASSERT(data->streams_size > 1 && current_interleave != current_data_size+current_padding,
                    "MPEG FSB: %i streams with non-constant interleave found @ 0x%08x\n", data->streams_size, (uint32_t)stream->offset);
            break;

        case MPEG_P3D: /* fixed interleave, not frame-aligned (ie. blocks may end/start in part of a frame) */
        case MPEG_SCD:
            current_interleave = data->config.interleave;

            /* check if current interleave block is short */
            {
                off_t block_offset = stream->offset - stream->channel_start_offset;
                size_t next_block = data->streams_size*data->config.interleave;

                if (data->config.data_size && block_offset + next_block >= data->config.data_size)
                    current_interleave = (data->config.data_size % next_block) / data->streams_size; /* short_interleave*/
            }

            current_interleave_pre  = current_interleave*num_stream;
            current_interleave_post = current_interleave*(data->streams_size-1) - current_interleave_pre;

            current_data_size = current_interleave;
            break;

        case MPEG_LYN:
            /* after N interleaves last block is bigger */
            if (ms->current_size_count < data->config.max_chunks)
                current_interleave = data->config.interleave;
            else if (ms->current_size_count == data->config.max_chunks)
                current_interleave = data->config.interleave_last;
            else
                goto fail;

            current_interleave_pre  = current_interleave*num_stream;
            current_interleave_post = current_interleave*(data->streams_size-1) - current_interleave_pre;
            //VGM_LOG("o=%lx, %i: %x, %x, %x, %x\n", stream->offset, num_stream, ms->current_size_count, current_interleave, current_interleave_pre, current_interleave_post );

            current_data_size = current_interleave;
            ms->current_size_count++;
            break;

        default: /* standard frames (CBR or VBR) */
            if ( !mpeg_get_frame_info(stream->streamfile, stream->offset, &info) )
                goto fail;
            current_data_size = info.frame_size;
            break;
    }
    if (!current_data_size || current_data_size > ms->buffer_size) {
        VGM_LOG("MPEG: incorrect data_size 0x%x vs buffer 0x%x\n", current_data_size, ms->buffer_size);
        goto fail;
    }

    /* This assumes all streams' offsets start in the first stream, and advances
     * the 'full interleaved block' at once, ex:
     *  start at s0=0x00, s1=0x00, interleave=0x40 (block = 0x40*2=0x80)
     *  @0x00 read 0x40 of s0, skip 0x40 of s1 (block of 0x80 done) > new offset = 0x80
     *  @0x00 skip 0x40 of s0, read 0x40 of s1 (block of 0x80 done) > new offset = 0x800
     */

    /* read chunk (skipping other interleaves if needed) */
    ms->bytes_in_buffer = read_streamfile(ms->buffer,stream->offset + current_interleave_pre, current_data_size, stream->streamfile);


    /* update offsets and skip other streams */
    stream->offset += current_data_size + current_padding;

    /* skip rest of block (interleave per stream) once this stream's interleaved data is done, if defined */
    if (current_interleave && ((stream->offset - stream->channel_start_offset + current_interleave_pre + current_interleave_post) % current_interleave == 0)) {
        stream->offset += current_interleave_pre + current_interleave_post;
    }


    return 1;
fail:
    return 0;
}
#endif

//TODO: move to a better place

/*****************/
/* FRAME HELPERS */
/*****************/

/**
 * Gets info from a MPEG frame header at offset. Normally you would use mpg123_info but somehow
 * it's wrong at times (maybe because we use an ancient version) so here we do our thing.
 */
static int mpeg_get_frame_info_h(uint32_t header, mpeg_frame_info* info) {
    /* index tables */
    static const int versions[4] = { /* MPEG 2.5 */ 3, /* reserved */ -1,  /* MPEG 2 */ 2, /* MPEG 1 */ 1 };
    static const int layers[4] = { -1,3,2,1 };
    static const int bit_rates[5][16] = { /* [version index ][bit rate index] (0=free, -1=bad) */
            { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, -1 }, /* MPEG1 Layer I */
            { 0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384, -1 }, /* MPEG1 Layer II */
            { 0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, -1 }, /* MPEG1 Layer III */
            { 0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256, -1 }, /* MPEG2/2.5 Layer I */
            { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160, -1 }, /* MPEG2/2.5 Layer II/III */
    };
    static const int sample_rates[4][4] = { /* [version][sample rate index] */
            { 44100, 48000, 32000, -1}, /* MPEG1 */
            { 22050, 24000, 16000, -1}, /* MPEG2 */
            { 11025, 12000,  8000, -1}, /* MPEG2.5 */
    };
    static const int channels[4] = { 2,2,2, 1 }; /* [channel] */
    static const int frame_samples[3][3] = { /* [version][layer] */
            { 384, 1152, 1152 }, /* MPEG1 */
            { 384, 1152, 576  }, /* MPEG2 */
            { 384, 1152, 576  }  /* MPEG2.5 */
    };

    int idx, padding;


    memset(info, 0, sizeof(*info));

    if ((header >> 21) != 0x7FF) /* 31-21: sync */
        goto fail;

    info->version = versions[(header >> 19) & 0x3]; /* 20,19: version */
    if (info->version <= 0) goto fail;

    info->layer = layers[(header >> 17) & 0x3]; /* 18,17: layer */
    if (info->layer <= 0 || info->layer > 3) goto fail;

    //crc       = (header >> 16) & 0x1; /* 16: protected by crc? */

    idx = (info->version==1 ? info->layer-1 : (3 + (info->layer==1 ? 0 : 1)));
    info->bit_rate = bit_rates[idx][(header >> 12) & 0xf]; /* 15-12: bit rate */
    if (info->bit_rate <= 0) goto fail;

    info->sample_rate = sample_rates[info->version-1][(header >> 10) & 0x3]; /* 11-10: sampling rate */
    if (info->sample_rate <= 0) goto fail;

    padding     = (header >>  9) & 0x1; /* 9: padding? */
    //private   = (header >>  8) & 0x1; /* 8: private bit */

    info->channels = channels[(header >>  6) & 0x3]; /* 7,6: channel mode */

    //js_mode   = (header >>  4) & 0x3; /* 5,4: mode extension for joint stereo */
    //copyright = (header >>  3) & 0x1; /* 3: copyrighted */
    //original  = (header >>  2) & 0x1; /* 2: original */
    //emphasis  = (header >>  0) & 0x3; /* 1,0: emphasis */

    info->frame_samples = frame_samples[info->version-1][info->layer-1];

    /* calculate frame length (from hcs's fsb_mpeg) */
    switch (info->frame_samples) {
        case 384:  info->frame_size = (12l  * info->bit_rate * 1000l / info->sample_rate + padding) * 4; break; /* 384/32 = 12 */
        case 576:  info->frame_size = (72l  * info->bit_rate * 1000l / info->sample_rate + padding); break; /* 576/8 = 72 */
        case 1152: info->frame_size = (144l * info->bit_rate * 1000l / info->sample_rate + padding); break; /* 1152/8 = 144 */
        default: goto fail;
    }

    return 1;

fail:
    return 0;
}
int mpeg_get_frame_info(STREAMFILE* sf, off_t offset, mpeg_frame_info* info) {
    uint32_t header = read_u32be(offset, sf);
    return mpeg_get_frame_info_h(header, info);
}


uint32_t mpeg_get_tag_size(STREAMFILE* sf, uint32_t offset, uint32_t header) {
    if (!header)
        header = read_u32be(offset+0x00, sf);

    /* skip ID3v2 */
    if ((header & 0xFFFFFF00) == get_id32be("ID3\0")) {
        size_t frame_size = 0;
        uint8_t flags = read_u8(offset+0x05, sf);
        /* this is how it's officially read :/ */
        frame_size += read_u8(offset+0x06, sf) << 21;
        frame_size += read_u8(offset+0x07, sf) << 14;
        frame_size += read_u8(offset+0x08, sf) << 7;
        frame_size += read_u8(offset+0x09, sf) << 0;
        frame_size += 0x0a;
        if (flags & 0x10) /* footer? */
            frame_size += 0x0a;

        return frame_size;
        
    }

    /* skip ID3v1 */
    if ((header & 0xFFFFFF00) == get_id32be("TAG\0")) {
        ;VGM_LOG("MPEG: ID3v1 at %x\n", offset);
        return 0x80;
    }

    return 0;
}

size_t mpeg_get_samples(STREAMFILE* sf, off_t start_offset, size_t bytes) {
    off_t offset = start_offset;
    off_t max_offset = start_offset + bytes;
    int frames = 0, samples = 0, encoder_delay = 0, encoder_padding = 0;
    mpeg_frame_info info;

    if (!sf)
        return 0;

    if (max_offset > get_streamfile_size(sf))
        max_offset = get_streamfile_size(sf);

    /* MPEG may use VBR so must read all frames */
    while (offset < max_offset) {
        uint32_t header = read_u32be(offset+0x00, sf);
        size_t tag_size = mpeg_get_tag_size(sf, offset, header);
        if (tag_size) {
            offset += tag_size;
            continue;
        }

        /* regular frame (assumed) */
        if (!mpeg_get_frame_info_h(header, &info)) {
            VGM_LOG("MPEG: unknown frame at %lx\n", offset);
            break;
        }

        /* detect Xing header (disguised as a normal frame) */
        if (frames < 3) { /* should be first after tags */
            /* frame is empty so Xing goes after MPEG side info */
            off_t xing_offset;
            if (info.version == 1)
                xing_offset = (info.channels == 2 ? 0x20 : 0x11) + 0x04;
            else
                xing_offset = (info.channels == 2 ? 0x11 : 0x09) + 0x04;

            if (info.frame_size >= xing_offset + 0x78 &&
                read_u32be(offset + 0x04, sf) == 0 && /* empty frame */
                (read_u32be(offset + xing_offset, sf) == 0x58696E67 ||  /* "Xing" (mainly for VBR) */
                 read_u32be(offset + xing_offset, sf) == 0x496E666F)) { /* "Info" (mainly for CBR) */
                uint32_t flags = read_u32be(offset + xing_offset + 0x04, sf);

                if (flags & 1) {
                    uint32_t frame_count = read_u32be(offset + xing_offset + 0x08, sf);
                    samples = frame_count * info.frame_samples;
                }
                /* other flags indicate seek table and stuff */

                ;VGM_LOG("MPEG: found Xing header\n");

                /* vendor specific */
                if (info.frame_size > xing_offset + 0x78 + 0x24) {
                    uint32_t sub_id = read_u32be(offset + xing_offset + 0x78, sf);
                    if (sub_id == get_id32be("LAME") || /* LAME */
                        sub_id == get_id32be("Lavc")) { /* FFmpeg */
                        if (info.layer == 3) {
                            uint32_t delays = read_u32be(offset + xing_offset + 0x8C, sf);
                            encoder_delay   = ((delays >> 12) & 0xFFF);
                            encoder_padding =  ((delays >> 0) & 0xFFF);

                            encoder_delay += (528 + 1); /* implicit MDCT decoder delay (seen in LAME source) */
                            if (encoder_padding > 528 + 1)
                                encoder_padding -= (528 + 1);
                        }
                        else {
                            encoder_delay = 240 + 1;
                        }
                    }

                    /* replay gain and stuff */
                }

                /* there is also "iTunes" vendor with no apparent extra info, iTunes delays are in "iTunSMPB" ID3 tag */
                break; /* we got samples */
             }
        }

        //TODO: detect "VBRI" header (Fraunhofer encoder)
        // https://www.codeproject.com/Articles/8295/MPEG-Audio-Frame-Header#VBRIHeader

        /* could detect VBR/CBR but read frames to remove ID3 end tags */

        frames++;
        offset += info.frame_size;
        samples += info.frame_samples;
    }

    ;VGM_LOG("MPEG: samples=%i, ed=%i, ep=%i, end=%i\n", samples,encoder_delay,encoder_padding, samples - encoder_delay - encoder_padding);

    //todo return encoder delay
    samples = samples - encoder_delay - encoder_padding;
    return samples;
}


/* variation of the above, for clean streams = no ID3/VBR headers
 * (maybe should be fused in a single thing with config, API is kinda messy too) */
int32_t mpeg_get_samples_clean(STREAMFILE* sf, off_t start, size_t size, uint32_t* p_loop_start, uint32_t* p_loop_end, int is_vbr) {
    mpeg_frame_info info;
    off_t offset = start;
    int32_t num_samples = 0, loop_start = 0, loop_end = 0;

    if (!is_vbr) {
        /* CBR = quick calcs */
        if (!mpeg_get_frame_info(sf, offset, &info))
            goto fail;

        num_samples = size / info.frame_size * info.frame_samples;
        if (p_loop_start)
            loop_start = *p_loop_start / info.frame_size * info.frame_samples;
        if (p_loop_end)
            loop_end = *p_loop_end / info.frame_size * info.frame_samples;
    }
    else {
        /* VBR (or unknown) = count frames */
        while (offset < start + size) {
            if (!mpeg_get_frame_info(sf, offset, &info))
                goto fail;

            if (p_loop_start && *p_loop_start + start == offset)
                loop_start = num_samples;

            num_samples += info.frame_samples;
            offset += info.frame_size;

            if (p_loop_end && *p_loop_end + start == offset)
                loop_end = num_samples;
        }
    }


    if (p_loop_start)
        *p_loop_start = loop_start;
    if (p_loop_end)
        *p_loop_end = loop_end;

    return num_samples;
fail:
    VGM_LOG("MPEG: sample reader failed at %lx\n", offset);
    return 0;
}