amy/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-11 23:41:01 -05:00
Code Issues 1 Projects Releases Packages Wiki Activity Actions
winamp/Src/external_dependencies/openmpt-trunk/include/lame/mpglib/interface.c
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

718 lines
20 KiB
C
Vendored
Raw Blame History

/*
* 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);
}
Reference in a new issue View git blame Copy permalink