719 lines
20 KiB
C
719 lines
20 KiB
C
/*
|
|
* 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);
|
|
}
|