/*

 * interface.c

 *

 * Copyright (C) 1999-2012 The L.A.M.E. project

 *

 * Initially written by Michael Hipp, see also AUTHORS and README.

 *  

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/* $Id: interface.c,v 1.69 2017/09/06 15:07:30 robert Exp $ */

#ifdef HAVE_CONFIG_H

# include <config.h>

#endif

#include <stdlib.h>

#include <stdio.h>

#include "common.h"

#include "interface.h"

#include "tabinit.h"

#include "layer3.h"

#include "lame.h"

#include "machine.h"

#include "VbrTag.h"

#include "decode_i386.h"

#include "layer1.h"

#include "layer2.h"

#ifdef WITH_DMALLOC

#include <dmalloc.h>

#endif

extern void lame_report_def(const char* format, va_list args);

/* #define HIP_DEBUG */

int

InitMP3(PMPSTR mp)

{

    hip_init_tables_layer1();

    hip_init_tables_layer2();

    hip_init_tables_layer3();

    if (mp) {

        memset(mp, 0, sizeof(MPSTR));

        mp->framesize = 0;

        mp->num_frames = 0;

        mp->enc_delay = -1;

        mp->enc_padding = -1;

        mp->vbr_header = 0;

        mp->header_parsed = 0;

        mp->side_parsed = 0;

        mp->data_parsed = 0;

        mp->free_format = 0;

        mp->old_free_format = 0;

        mp->ssize = 0;

        mp->dsize = 0;

        mp->fsizeold = -1;

        mp->bsize = 0;

        mp->head = mp->tail = NULL;

        mp->fr.single = -1;

        mp->bsnum = 0;

        mp->wordpointer = mp->bsspace[mp->bsnum] + 512;

        mp->bitindex = 0;

        mp->synth_bo = 1;

        mp->sync_bitstream = 1;

        mp->report_dbg = &lame_report_def;

        mp->report_err = &lame_report_def;

        mp->report_msg = &lame_report_def;

    }

    make_decode_tables(32767);

    return 1;

}

void

ExitMP3(PMPSTR mp)

{

    if (mp) {

        struct buf *b, *bn;

        b = mp->tail;

        while (b) {

            free(b->pnt);

            bn = b->next;

            free(b);

            b = bn;

        }

    }

}

static struct buf *

addbuf(PMPSTR mp, unsigned char *buf, int size)

{

    struct buf *nbuf;

    nbuf = (struct buf *) malloc(sizeof(struct buf));

    if (!nbuf) {

        lame_report_fnc(mp->report_err, "hip: addbuf() Out of memory!\n");

        return NULL;

    }

    nbuf->pnt = (unsigned char *) malloc((size_t) size);

    if (!nbuf->pnt) {

        free(nbuf);

        return NULL;

    }

    nbuf->size = size;

    memcpy(nbuf->pnt, buf, (size_t) size);

    nbuf->next = NULL;

    nbuf->prev = mp->head;

    nbuf->pos = 0;

    if (!mp->tail) {

        mp->tail = nbuf;

    }

    else {

        mp->head->next = nbuf;

    }

    mp->head = nbuf;

    mp->bsize += size;

    return nbuf;

}

void

remove_buf(PMPSTR mp)

{

    struct buf *buf = mp->tail;

    mp->tail = buf->next;

    if (mp->tail)

        mp->tail->prev = NULL;

    else {

        mp->tail = mp->head = NULL;

    }

    free(buf->pnt);

    free(buf);

}

static int

read_buf_byte(PMPSTR mp)

{

    unsigned int b;

    int     pos;

    pos = mp->tail->pos;

    while (pos >= mp->tail->size) {

        remove_buf(mp);

        if (!mp->tail) {

            lame_report_fnc(mp->report_err, "hip: Fatal error! tried to read past mp buffer\n");

            exit(1);

        }

        pos = mp->tail->pos;

    }

    b = mp->tail->pnt[pos];

    mp->bsize--;

    mp->tail->pos++;

    return b;

}

static void

read_head(PMPSTR mp)

{

    unsigned long head;

    head = read_buf_byte(mp);

    head <<= 8;

    head |= read_buf_byte(mp);

    head <<= 8;

    head |= read_buf_byte(mp);

    head <<= 8;

    head |= read_buf_byte(mp);

    mp->header = head;

}

static void

copy_mp(PMPSTR mp, int size, unsigned char *ptr)

{

    int     len = 0;

    while (len < size && mp->tail) {

        int     nlen;

        int     blen = mp->tail->size - mp->tail->pos;

        if ((size - len) <= blen) {

            nlen = size - len;

        }

        else {

            nlen = blen;

        }

        memcpy(ptr + len, mp->tail->pnt + mp->tail->pos, (size_t) nlen);

        len += nlen;

        mp->tail->pos += nlen;

        mp->bsize -= nlen;

        if (mp->tail->pos == mp->tail->size) {

            remove_buf(mp);

        }

    }

}

/* number of bytes needed by GetVbrTag to parse header */

#define XING_HEADER_SIZE 194

/*

traverse mp data structure without changing it

(just like sync_buffer)

pull out Xing bytes

call vbr header check code from LAME

if we find a header, parse it and also compute the VBR header size

if no header, do nothing.

bytes = number of bytes before MPEG header.  skip this many bytes

before starting to read

return value: number of bytes in VBR header, including syncword

*/

static int

check_vbr_header(PMPSTR mp, int bytes)

{

    int     i, pos;

    struct buf *buf = mp->tail;

    unsigned char xing[XING_HEADER_SIZE];

    VBRTAGDATA pTagData;

    pos = buf->pos;

    /* skip to valid header */

    for (i = 0; i < bytes; ++i) {

        while (pos >= buf->size) {

            buf = buf->next;

            if (!buf)

                return -1; /* fatal error */

            pos = buf->pos;

        }

        ++pos;

    }

    /* now read header */

    for (i = 0; i < XING_HEADER_SIZE; ++i) {

        while (pos >= buf->size) {

            buf = buf->next;

            if (!buf)

                return -1; /* fatal error */

            pos = buf->pos;

        }

        xing[i] = buf->pnt[pos];

        ++pos;

    }

    /* check first bytes for Xing header */

    mp->vbr_header = GetVbrTag(&pTagData, xing);

    if (mp->vbr_header) {

        mp->num_frames = pTagData.frames;

        mp->enc_delay = pTagData.enc_delay;

        mp->enc_padding = pTagData.enc_padding;

        /* lame_report_fnc(mp->report_msg,"hip: delays: %i %i \n",mp->enc_delay,mp->enc_padding); */

        /* lame_report_fnc(mp->report_msg,"hip: Xing VBR header dectected.  MP3 file has %i frames\n", pTagData.frames); */

        if (pTagData.headersize < 1)

            return 1;

        return pTagData.headersize;

    }

    return 0;

}

static int

sync_buffer(PMPSTR mp, int free_match)

{

    /* traverse mp structure without modifying pointers, looking

     * for a frame valid header.

     * if free_format, valid header must also have the same

     * samplerate.   

     * return number of bytes in mp, before the header

     * return -1 if header is not found

     */

    unsigned int b[4] = { 0, 0, 0, 0 };

    int     i, h, pos;

    struct buf *buf = mp->tail;

    if (!buf)

        return -1;

    pos = buf->pos;

    for (i = 0; i < mp->bsize; i++) {

        /* get 4 bytes */

        b[0] = b[1];

        b[1] = b[2];

        b[2] = b[3];

        while (pos >= buf->size) {

            buf = buf->next;

            if (!buf) {

                return -1;

                /* not enough data to read 4 bytes */

            }

            pos = buf->pos;

        }

        b[3] = buf->pnt[pos];

        ++pos;

        if (i >= 3) {

            struct frame *fr = &mp->fr;

            unsigned long head;

            head = b[0];

            head <<= 8;

            head |= b[1];

            head <<= 8;

            head |= b[2];

            head <<= 8;

            head |= b[3];

            h = head_check(head, fr->lay);

            if (h && free_match) {

                /* just to be even more thorough, match the sample rate */

                int     mode, stereo, sampling_frequency, mpeg25, lsf;

                if (head & (1 << 20)) {

                    lsf = (head & (1 << 19)) ? 0x0 : 0x1;

                    mpeg25 = 0;

                }

                else {

                    lsf = 1;

                    mpeg25 = 1;

                }

                mode = ((head >> 6) & 0x3);

                stereo = (mode == MPG_MD_MONO) ? 1 : 2;

                if (mpeg25)

                    sampling_frequency = 6 + ((head >> 10) & 0x3);

                else

                    sampling_frequency = ((head >> 10) & 0x3) + (lsf * 3);

                h = ((stereo == fr->stereo) && (lsf == fr->lsf) && (mpeg25 == fr->mpeg25) &&

                     (sampling_frequency == fr->sampling_frequency));

            }

            if (h) {

                return i - 3;

            }

        }

    }

    return -1;

}

void

decode_reset(PMPSTR mp)

{

#if 0

    remove_buf(mp);

    /* start looking for next frame */

    /* mp->fsizeold = mp->framesize; */

    mp->fsizeold = -1;

    mp->old_free_format = mp->free_format;

    mp->framesize = 0;

    mp->header_parsed = 0;

    mp->side_parsed = 0;

    mp->data_parsed = 0;

    mp->sync_bitstream = 1; /* TODO check if this is right */

#else

    InitMP3(mp);        /* Less error prone to just to reinitialise. */

#endif

}

int

audiodata_precedesframes(PMPSTR mp)

{

    if (mp->fr.lay == 3)

        return layer3_audiodata_precedesframes(mp);

    else

        return 0;       /* For Layer 1 & 2 the audio data starts at the frame that describes it, so no audio data precedes. */

}

static int

decodeMP3_clipchoice(PMPSTR mp, unsigned char *in, int isize, char *out, int *done,

                     int (*synth_1to1_mono_ptr) (PMPSTR, real *, unsigned char *, int *),

                     int (*synth_1to1_ptr) (PMPSTR, real *, int, unsigned char *, int *))

{

    int     i, iret, bits, bytes;

    if (in && isize && addbuf(mp, in, isize) == NULL)

        return MP3_ERR;

    /* First decode header */

    if (!mp->header_parsed) {

        if (mp->fsizeold == -1 || mp->sync_bitstream) {

            int     vbrbytes;

            mp->sync_bitstream = 0;

            /* This is the very first call.   sync with anything */

            /* bytes= number of bytes before header */

            bytes = sync_buffer(mp, 0);

            /* now look for Xing VBR header */

            if (mp->bsize >= bytes + XING_HEADER_SIZE) {

                /* vbrbytes = number of bytes in entire vbr header */

                vbrbytes = check_vbr_header(mp, bytes);

            }

            else {

                /* not enough data to look for Xing header */

#ifdef HIP_DEBUG

                lame_report_fnc(mp->report_dbg, "hip: not enough data to look for Xing header\n");

#endif

                return MP3_NEED_MORE;

            }

            if (mp->vbr_header) {

                /* do we have enough data to parse entire Xing header? */

                if (bytes + vbrbytes > mp->bsize) {

                    /* lame_report_fnc(mp->report_err,"hip: not enough data to parse entire Xing header\n"); */

                    return MP3_NEED_MORE;

                }

                /* read in Xing header.  Buffer data in case it

                 * is used by a non zero main_data_begin for the next

                 * frame, but otherwise dont decode Xing header */

#ifdef HIP_DEBUG

                lame_report_fnc(mp->report_dbg, "hip: found xing header, skipping %i bytes\n", vbrbytes + bytes);

#endif

                for (i = 0; i < vbrbytes + bytes; ++i)

                    read_buf_byte(mp);

                /* now we need to find another syncword */

                /* just return and make user send in more data */

                return MP3_NEED_MORE;

            }

        }

        else {

            /* match channels, samplerate, etc, when syncing */

            bytes = sync_buffer(mp, 1);

        }

        /* buffer now synchronized */

        if (bytes < 0) {

            /* lame_report_fnc(mp->report_err,"hip: need more bytes %d\n", bytes); */

            return MP3_NEED_MORE;

        }

        if (bytes > 0) {

            /* there were some extra bytes in front of header.

             * bitstream problem, but we are now resynced 

             * should try to buffer previous data in case new

             * frame has nonzero main_data_begin, but we need

             * to make sure we do not overflow buffer

             */

            int     size;

            if (mp->fsizeold != -1) {

                lame_report_fnc(mp->report_err, "hip: bitstream problem, resyncing skipping %d bytes...\n", bytes);

            }

            mp->old_free_format = 0;

#if 1

            /* FIXME: correct ??? */

            mp->sync_bitstream = 1;

#endif

            /* skip some bytes, buffer the rest */

            size = (int) (mp->wordpointer - (mp->bsspace[mp->bsnum] + 512));

            if (size > MAXFRAMESIZE) {

                /* wordpointer buffer is trashed.  probably cant recover, but try anyway */

                lame_report_fnc(mp->report_err, "hip: wordpointer trashed.  size=%i (%i)  bytes=%i \n",

                        size, MAXFRAMESIZE, bytes);

                size = 0;

                mp->wordpointer = mp->bsspace[mp->bsnum] + 512;

            }

            /* buffer contains 'size' data right now 

               we want to add 'bytes' worth of data, but do not 

               exceed MAXFRAMESIZE, so we through away 'i' bytes */

            i = (size + bytes) - MAXFRAMESIZE;

            for (; i > 0; --i) {

                --bytes;

                read_buf_byte(mp);

            }

            copy_mp(mp, bytes, mp->wordpointer);

            mp->fsizeold += bytes;

        }

        read_head(mp);

        if (!decode_header(mp, &mp->fr, mp->header))

            return MP3_ERR;

        mp->header_parsed = 1;

        mp->framesize = mp->fr.framesize;

        mp->free_format = (mp->framesize == 0);

        if (mp->fr.lsf)

            mp->ssize = (mp->fr.stereo == 1) ? 9 : 17;

        else

            mp->ssize = (mp->fr.stereo == 1) ? 17 : 32;

        if (mp->fr.error_protection)

            mp->ssize += 2;

        mp->bsnum = 1 - mp->bsnum; /* toggle buffer */

        mp->wordpointer = mp->bsspace[mp->bsnum] + 512;

        mp->bitindex = 0;

        /* for very first header, never parse rest of data */

        if (mp->fsizeold == -1) {

#ifdef HIP_DEBUG

            lame_report_fnc(mp->report_dbg, "hip: not parsing the rest of the data of the first header\n");

#endif

            return MP3_NEED_MORE;

        }

    }                   /* end of header parsing block */

    /* now decode side information */

    if (!mp->side_parsed) {

        /* Layer 3 only */

        if (mp->fr.lay == 3) {

            if (mp->bsize < mp->ssize)

                return MP3_NEED_MORE;

            copy_mp(mp, mp->ssize, mp->wordpointer);

            if (mp->fr.error_protection)

                getbits(mp, 16);

            bits = decode_layer3_sideinfo(mp);

            /* bits = actual number of bits needed to parse this frame */

            /* can be negative, if all bits needed are in the reservoir */

            if (bits < 0)

                bits = 0;

            /* read just as many bytes as necessary before decoding */

            mp->dsize = (bits + 7) / 8;

            if (!mp->free_format) {

                /* do not read more than framsize data */

                int framesize = mp->fr.framesize - mp->ssize;

                if (mp->dsize > framesize) {

                    lame_report_fnc(mp->report_err,

                            "hip: error audio data exceeds framesize by %d bytes\n", 

                            mp->dsize - framesize);

                    mp->dsize = framesize;

                }

            }

#ifdef HIP_DEBUG

            lame_report_fnc(mp->report_dbg,

                    "hip: %d bits needed to parse layer III frame, number of bytes to read before decoding dsize = %d\n",

                    bits, mp->dsize);

#endif

            /* this will force mpglib to read entire frame before decoding */

            /* mp->dsize= mp->framesize - mp->ssize; */

        }

        else {

            /* Layers 1 and 2 */

            /* check if there is enough input data */

            if (mp->fr.framesize > mp->bsize)

                return MP3_NEED_MORE;

            /* takes care that the right amount of data is copied into wordpointer */

            mp->dsize = mp->fr.framesize;

            mp->ssize = 0;

        }

        mp->side_parsed = 1;

    }

    /* now decode main data */

    iret = MP3_NEED_MORE;

    if (!mp->data_parsed) {

        if (mp->dsize > mp->bsize) {

            return MP3_NEED_MORE;

        }

        copy_mp(mp, mp->dsize, mp->wordpointer);

        *done = 0;

        /*do_layer3(&mp->fr,(unsigned char *) out,done); */

        switch (mp->fr.lay) {

        case 1:

            if (mp->fr.error_protection)

                getbits(mp, 16);

            if (decode_layer1_frame(mp, (unsigned char *) out, done) < 0)

                return MP3_ERR;

            break;

        case 2:

            if (mp->fr.error_protection)

                getbits(mp, 16);

            decode_layer2_frame(mp, (unsigned char *) out, done);

            break;

        case 3:

            decode_layer3_frame(mp, (unsigned char *) out, done, synth_1to1_mono_ptr, synth_1to1_ptr);

            break;

        default:

            lame_report_fnc(mp->report_err, "hip: invalid layer %d\n", mp->fr.lay);

        }

        mp->wordpointer = mp->bsspace[mp->bsnum] + 512 + mp->ssize + mp->dsize;

        mp->data_parsed = 1;

        iret = MP3_OK;

    }

    /* remaining bits are ancillary data, or reservoir for next frame 

     * If free format, scan stream looking for next frame to determine

     * mp->framesize */

    if (mp->free_format) {

        if (mp->old_free_format) {

            /* free format.  bitrate must not vary */

            mp->framesize = mp->fsizeold_nopadding + (mp->fr.padding);

        }

        else {

            bytes = sync_buffer(mp, 1);

            if (bytes < 0)

                return iret;

            mp->framesize = bytes + mp->ssize + mp->dsize;

            mp->fsizeold_nopadding = mp->framesize - mp->fr.padding;

#if 0

               lame_report_fnc(mp->report_dbg,"hip: freeformat bitstream:  estimated bitrate=%ikbs  \n",

               8*(4+mp->framesize)*freqs[mp->fr.sampling_frequency]/

               (1000*576*(2-mp->fr.lsf)));

#endif

        }

    }

    /* buffer the ancillary data and reservoir for next frame */

    bytes = mp->framesize - (mp->ssize + mp->dsize);

    if (bytes > mp->bsize) {

        return iret;

    }

    if (bytes > 0) {

        int     size;

#if 1

        /* FIXME: while loop OK ??? */

        while (bytes > 512) {

            read_buf_byte(mp);

            bytes--;

            mp->framesize--;

        }

#endif

        copy_mp(mp, bytes, mp->wordpointer);

        mp->wordpointer += bytes;

        size = (int) (mp->wordpointer - (mp->bsspace[mp->bsnum] + 512));

        if (size > MAXFRAMESIZE) {

            lame_report_fnc(mp->report_err, "hip: fatal error.  MAXFRAMESIZE not large enough.\n");

        }

    }

    /* the above frame is completely parsed.  start looking for next frame */

    mp->fsizeold = mp->framesize;

    mp->old_free_format = mp->free_format;

    mp->framesize = 0;

    mp->header_parsed = 0;

    mp->side_parsed = 0;

    mp->data_parsed = 0;

    return iret;

}

int

decodeMP3(PMPSTR mp, unsigned char *in, int isize, char *out, int osize, int *done)

{

    if (osize < 4608) {

        lame_report_fnc(mp->report_err, "hip: Insufficient memory for decoding buffer %d\n", osize);

        return MP3_ERR;

    }

    /* passing pointers to the functions which clip the samples */

    return decodeMP3_clipchoice(mp, in, isize, out, done, synth_1to1_mono, synth_1to1);

}

int

decodeMP3_unclipped(PMPSTR mp, unsigned char *in, int isize, char *out, int osize, int *done)

{

    /* we forbid input with more than 1152 samples per channel for output in unclipped mode */

    if (osize < (int) (1152 * 2 * sizeof(real))) {

        lame_report_fnc(mp->report_err, "hip: out space too small for unclipped mode\n");

        return MP3_ERR;

    }

    /* passing pointers to the functions which don't clip the samples */

    return decodeMP3_clipchoice(mp, in, isize, out, done, synth_1to1_mono_unclipped,

                                synth_1to1_unclipped);

}