« back to all changes in this revision
Viewing changes to mpglib/interface.c
- browse files at revision 10
- compare with another revision
- download diff
- download tarball
- view history from revision 10
- Committer: Bazaar Package Importer
- Author(s): Reinhard Tartler
- Date: 2010-07-30 09:34:43 UTC
- mfrom: (1.1.4 upstream)
- Revision ID: james.westby@ubuntu.com-20100730093443-behxbw12v5vljwu2
Tags: 3.98.4-0ubuntu1
* New upstream Release
* Switch to source Format 3.0 (quilt)
* Remove debian/patches/03-buffer-too-small.patch, merged upstream
* Refreshed patches
* Tighten build depends on debhelper und quilt
* Bump standards version
* Remove outdated config.guess and config.sub during build
* Switch to source Format 3.0 (quilt)
* Remove debian/patches/03-buffer-too-small.patch, merged upstream
* Refreshed patches
* Tighten build depends on debhelper und quilt
* Bump standards version
* Remove outdated config.guess and config.sub during build
- files added:
- .pc
- .pc/01-debian-directory.patch
- .pc/02-dynamic-frontends.patch
- .pc/02-dynamic-frontends.patch/frontend
- .pc/04-exec-stac.patch
- .pc/04-exec-stac.patch/libmp3lame
- .pc/04-exec-stac.patch/libmp3lame/i386
- .pc/05-armel-no-finite-math-only.patch
- debian/source
- files removed:
- ChangeLog.header
- test
- files modified:
- ACM/ACM.cpp
added
removed
mpglib/interface.c
1
/* $Id: interface.c,v 1.52 2008/06/25 08:20:15 robert Exp $ */
1
/*
2
* interface.c
3
*
4
* Copyright (C) 1999-2010 The L.A.M.E. project
5
*
6
* Initially written by Michael Hipp, see also AUTHORS and README.
7
*
8
* This library is free software; you can redistribute it and/or
9
* modify it under the terms of the GNU Library General Public
10
* License as published by the Free Software Foundation; either
11
* version 2 of the License, or (at your option) any later version.
12
*
13
* This library is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
* Library General Public License for more details.
17
*
18
* You should have received a copy of the GNU Library General Public
19
* License along with this library; if not, write to the
20
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21
* Boston, MA 02111-1307, USA.
22
*/
23
/* $Id: interface.c,v 1.52.2.4 2010/03/22 14:17:14 robert Exp $ */
2
24
3
25
#ifdef HAVE_CONFIG_H
4
26
# include <config.h>
23
45
#include <dmalloc.h>
24
46
#endif
25
47
26
27
int InitMP3( PMPSTR mp)
28
{
29
memset(mp,0,sizeof(MPSTR));
30
31
mp->framesize = 0;
32
mp->num_frames = 0;
33
mp->enc_delay = -1;
34
mp->enc_padding = -1;
35
mp->vbr_header=0;
36
mp->header_parsed=0;
37
mp->side_parsed=0;
38
mp->data_parsed=0;
39
mp->free_format=0;
40
mp->old_free_format=0;
41
mp->ssize = 0;
42
mp->dsize=0;
43
mp->fsizeold = -1;
44
mp->bsize = 0;
45
mp->head = mp->tail = NULL;
46
mp->fr.single = -1;
47
mp->bsnum = 0;
48
mp->wordpointer = mp->bsspace[mp->bsnum] + 512;
49
mp->bitindex = 0;
50
mp->synth_bo = 1;
51
mp->sync_bitstream = 1;
52
53
make_decode_tables(32767);
54
55
init_layer3(SBLIMIT);
56
57
init_layer2();
58
59
return 1;
60
}
61
62
void ExitMP3( PMPSTR mp)
63
{
64
struct buf *b,*bn;
65
66
b = mp->tail;
67
while(b) {
68
free(b->pnt);
69
bn = b->next;
70
free(b);
71
b = bn;
72
}
73
}
74
75
static struct buf *addbuf( PMPSTR mp, unsigned char *buf,int size)
76
{
77
struct buf *nbuf;
78
79
nbuf = (struct buf*) malloc( sizeof(struct buf) );
80
if(!nbuf) {
81
fprintf(stderr,"Out of memory!\n");
82
return NULL;
83
}
84
nbuf->pnt = (unsigned char*) malloc((size_t)size);
85
if(!nbuf->pnt) {
86
free(nbuf);
87
return NULL;
88
}
89
nbuf->size = size;
90
memcpy(nbuf->pnt,buf,(size_t)size);
91
nbuf->next = NULL;
92
nbuf->prev = mp->head;
93
nbuf->pos = 0;
94
95
if(!mp->tail) {
96
mp->tail = nbuf;
97
}
98
else {
99
mp->head->next = nbuf;
100
}
101
102
mp->head = nbuf;
103
mp->bsize += size;
104
105
return nbuf;
106
}
107
108
void remove_buf(PMPSTR mp)
109
{
110
struct buf *buf = mp->tail;
111
112
mp->tail = buf->next;
113
if(mp->tail)
114
mp->tail->prev = NULL;
115
else {
116
mp->tail = mp->head = NULL;
117
}
118
119
free(buf->pnt);
120
free(buf);
121
122
}
123
124
static int read_buf_byte(PMPSTR mp)
125
{
126
unsigned int b;
127
128
int pos;
129
130
48
/* #define HIP_DEBUG */
49
50
int
51
InitMP3(PMPSTR mp)
52
{
53
memset(mp, 0, sizeof(MPSTR));
54
55
mp->framesize = 0;
56
mp->num_frames = 0;
57
mp->enc_delay = -1;
58
mp->enc_padding = -1;
59
mp->vbr_header = 0;
60
mp->header_parsed = 0;
61
mp->side_parsed = 0;
62
mp->data_parsed = 0;
63
mp->free_format = 0;
64
mp->old_free_format = 0;
65
mp->ssize = 0;
66
mp->dsize = 0;
67
mp->fsizeold = -1;
68
mp->bsize = 0;
69
mp->head = mp->tail = NULL;
70
mp->fr.single = -1;
71
mp->bsnum = 0;
72
mp->wordpointer = mp->bsspace[mp->bsnum] + 512;
73
mp->bitindex = 0;
74
mp->synth_bo = 1;
75
mp->sync_bitstream = 1;
76
77
make_decode_tables(32767);
78
79
init_layer3(SBLIMIT);
80
81
init_layer2();
82
83
return 1;
84
}
85
86
void
87
ExitMP3(PMPSTR mp)
88
{
89
struct buf *b, *bn;
90
91
b = mp->tail;
92
while (b) {
93
free(b->pnt);
94
bn = b->next;
95
free(b);
96
b = bn;
97
}
98
}
99
100
static struct buf *
101
addbuf(PMPSTR mp, unsigned char *buf, int size)
102
{
103
struct buf *nbuf;
104
105
nbuf = (struct buf *) malloc(sizeof(struct buf));
106
if (!nbuf) {
107
fprintf(stderr, "hip: addbuf() Out of memory!\n");
108
return NULL;
109
}
110
nbuf->pnt = (unsigned char *) malloc((size_t) size);
111
if (!nbuf->pnt) {
112
free(nbuf);
113
return NULL;
114
}
115
nbuf->size = size;
116
memcpy(nbuf->pnt, buf, (size_t) size);
117
nbuf->next = NULL;
118
nbuf->prev = mp->head;
119
nbuf->pos = 0;
120
121
if (!mp->tail) {
122
mp->tail = nbuf;
123
}
124
else {
125
mp->head->next = nbuf;
126
}
127
128
mp->head = nbuf;
129
mp->bsize += size;
130
131
return nbuf;
132
}
133
134
void
135
remove_buf(PMPSTR mp)
136
{
137
struct buf *buf = mp->tail;
138
139
mp->tail = buf->next;
140
if (mp->tail)
141
mp->tail->prev = NULL;
142
else {
143
mp->tail = mp->head = NULL;
144
}
145
146
free(buf->pnt);
147
free(buf);
148
149
}
150
151
static int
152
read_buf_byte(PMPSTR mp)
153
{
154
unsigned int b;
155
156
int pos;
157
158
159
pos = mp->tail->pos;
160
while (pos >= mp->tail->size) {
161
remove_buf(mp);
162
if (!mp->tail) {
163
fprintf(stderr, "hip: Fatal error! tried to read past mp buffer\n");
164
exit(1);
165
}
131
166
pos = mp->tail->pos;
132
while(pos >= mp->tail->size) {
133
remove_buf(mp);
134
if(!mp->tail) {
135
fprintf(stderr,"Fatal error! tried to read past mp buffer\n");
136
exit(1);
137
}
138
pos = mp->tail->pos;
139
}
140
141
b = mp->tail->pnt[pos];
142
mp->bsize--;
143
mp->tail->pos++;
144
145
146
return b;
147
}
148
149
150
151
static void read_head(PMPSTR mp)
152
{
153
unsigned long head;
154
155
head = read_buf_byte(mp);
156
head <<= 8;
157
head |= read_buf_byte(mp);
158
head <<= 8;
159
head |= read_buf_byte(mp);
160
head <<= 8;
161
head |= read_buf_byte(mp);
162
163
mp->header = head;
164
}
165
166
167
168
169
170
171
static void
172
copy_mp(PMPSTR mp,int size,unsigned char *ptr)
173
{
174
int len = 0;
175
176
while(len < size && mp->tail) {
177
int nlen;
178
int blen = mp->tail->size - mp->tail->pos;
179
if( (size - len) <= blen) {
180
nlen = size-len;
181
}
182
else {
183
nlen = blen;
184
}
185
memcpy(ptr+len,mp->tail->pnt+mp->tail->pos,(size_t)nlen);
186
len += nlen;
187
mp->tail->pos += nlen;
188
mp->bsize -= nlen;
189
if(mp->tail->pos == mp->tail->size) {
190
remove_buf(mp);
191
}
192
}
167
}
168
169
b = mp->tail->pnt[pos];
170
mp->bsize--;
171
mp->tail->pos++;
172
173
174
return b;
175
}
176
177
178
179
static void
180
read_head(PMPSTR mp)
181
{
182
unsigned long head;
183
184
head = read_buf_byte(mp);
185
head <<= 8;
186
head |= read_buf_byte(mp);
187
head <<= 8;
188
head |= read_buf_byte(mp);
189
head <<= 8;
190
head |= read_buf_byte(mp);
191
192
mp->header = head;
193
}
194
195
196
197
198
static void
199
copy_mp(PMPSTR mp, int size, unsigned char *ptr)
200
{
201
int len = 0;
202
203
while (len < size && mp->tail) {
204
int nlen;
205
int blen = mp->tail->size - mp->tail->pos;
206
if ((size - len) <= blen) {
207
nlen = size - len;
208
}
209
else {
210
nlen = blen;
211
}
212
memcpy(ptr + len, mp->tail->pnt + mp->tail->pos, (size_t) nlen);
213
len += nlen;
214
mp->tail->pos += nlen;
215
mp->bsize -= nlen;
216
if (mp->tail->pos == mp->tail->size) {
217
remove_buf(mp);
218
}
219
}
193
220
}
194
221
195
222
/* number of bytes needed by GetVbrTag to parse header */
196
223
#define XING_HEADER_SIZE 194
197
224
198
/* traverse mp data structure without changing it */
199
/* (just like sync_buffer) */
200
/* pull out Xing bytes */
201
/* call vbr header check code from LAME */
202
/* if we find a header, parse it and also compute the VBR header size */
203
/* if no header, do nothing. */
204
/* */
205
/* bytes = number of bytes before MPEG header. skip this many bytes */
206
/* before starting to read */
207
/* return value: number of bytes in VBR header, including syncword */
225
/*
226
traverse mp data structure without changing it
227
(just like sync_buffer)
228
pull out Xing bytes
229
call vbr header check code from LAME
230
if we find a header, parse it and also compute the VBR header size
231
if no header, do nothing.
232
233
bytes = number of bytes before MPEG header. skip this many bytes
234
before starting to read
235
return value: number of bytes in VBR header, including syncword
236
*/
208
237
static int
209
check_vbr_header(PMPSTR mp,int bytes)
238
check_vbr_header(PMPSTR mp, int bytes)
210
239
{
211
int i,pos;
212
struct buf *buf=mp->tail;
213
unsigned char xing[XING_HEADER_SIZE];
214
VBRTAGDATA pTagData;
215
216
pos = buf->pos;
217
/* skip to valid header */
218
for (i=0; i<bytes; ++i) {
219
while(pos >= buf->size) {
220
buf = buf->next;
221
pos = buf->pos;
222
if(!buf) return -1; /* fatal error */
223
}
224
++pos;
225
}
226
/* now read header */
227
for (i=0; i<XING_HEADER_SIZE; ++i) {
228
while(pos >= buf->size) {
229
buf = buf->next;
230
if(!buf) return -1; /* fatal error */
231
pos = buf->pos;
232
}
233
xing[i] = buf->pnt[pos];
234
++pos;
235
}
236
237
/* check first bytes for Xing header */
238
mp->vbr_header = GetVbrTag(&pTagData,xing);
239
if (mp->vbr_header) {
240
mp->num_frames=pTagData.frames;
241
mp->enc_delay=pTagData.enc_delay;
242
mp->enc_padding=pTagData.enc_padding;
243
244
/*fprintf(stderr,"\rmpglib: delays: %i %i \n",mp->enc_delay,mp->enc_padding); */
245
/* fprintf(stderr,"\rmpglib: Xing VBR header dectected. MP3 file has %i frames\n", pTagData.frames); */
246
if ( pTagData.headersize < 1 ) return 1;
247
return pTagData.headersize;
248
}
249
return 0;
240
int i, pos;
241
struct buf *buf = mp->tail;
242
unsigned char xing[XING_HEADER_SIZE];
243
VBRTAGDATA pTagData;
244
245
pos = buf->pos;
246
/* skip to valid header */
247
for (i = 0; i < bytes; ++i) {
248
while (pos >= buf->size) {
249
buf = buf->next;
250
if (!buf)
251
return -1; /* fatal error */
252
pos = buf->pos;
253
}
254
++pos;
255
}
256
/* now read header */
257
for (i = 0; i < XING_HEADER_SIZE; ++i) {
258
while (pos >= buf->size) {
259
buf = buf->next;
260
if (!buf)
261
return -1; /* fatal error */
262
pos = buf->pos;
263
}
264
xing[i] = buf->pnt[pos];
265
++pos;
266
}
267
268
/* check first bytes for Xing header */
269
mp->vbr_header = GetVbrTag(&pTagData, xing);
270
if (mp->vbr_header) {
271
mp->num_frames = pTagData.frames;
272
mp->enc_delay = pTagData.enc_delay;
273
mp->enc_padding = pTagData.enc_padding;
274
275
/* fprintf(stderr,"hip: delays: %i %i \n",mp->enc_delay,mp->enc_padding); */
276
/* fprintf(stderr,"hip: Xing VBR header dectected. MP3 file has %i frames\n", pTagData.frames); */
277
if (pTagData.headersize < 1)
278
return 1;
279
return pTagData.headersize;
280
}
281
return 0;
250
282
}
251
283
252
284
253
285
254
286
255
287
256
257
258
288
static int
259
sync_buffer(PMPSTR mp,int free_match)
289
sync_buffer(PMPSTR mp, int free_match)
260
290
{
261
/* traverse mp structure without modifing pointers, looking
262
* for a frame valid header.
263
* if free_format, valid header must also have the same
264
* samplerate.
265
* return number of bytes in mp, before the header
266
* return -1 if header is not found
267
*/
268
unsigned int b[4]={0,0,0,0};
269
int i,h,pos;
270
struct buf *buf=mp->tail;
271
if (!buf) return -1;
272
273
pos = buf->pos;
274
for (i=0; i<mp->bsize; i++) {
275
/* get 4 bytes */
276
277
b[0]=b[1]; b[1]=b[2]; b[2]=b[3];
278
while(pos >= buf->size) {
279
buf = buf->next;
280
pos = buf->pos;
281
if(!buf) {
291
/* traverse mp structure without modifying pointers, looking
292
* for a frame valid header.
293
* if free_format, valid header must also have the same
294
* samplerate.
295
* return number of bytes in mp, before the header
296
* return -1 if header is not found
297
*/
298
unsigned int b[4] = { 0, 0, 0, 0 };
299
int i, h, pos;
300
struct buf *buf = mp->tail;
301
if (!buf)
282
302
return -1;
283
/* not enough data to read 4 bytes */
284
}
285
}
286
b[3] = buf->pnt[pos];
287
++pos;
288
289
if (i>=3) {
290
struct frame *fr = &mp->fr;
291
unsigned long head;
292
293
head = b[0];
294
head <<= 8;
295
head |= b[1];
296
head <<= 8;
297
head |= b[2];
298
head <<= 8;
299
head |= b[3];
300
h = head_check(head,fr->lay);
301
302
if (h && free_match) {
303
/* just to be even more thorough, match the sample rate */
304
int mode,stereo,sampling_frequency,mpeg25,lsf;
305
306
if( head & (1<<20) ) {
307
lsf = (head & (1<<19)) ? 0x0 : 0x1;
308
mpeg25 = 0;
309
}
310
else {
311
lsf = 1;
312
mpeg25 = 1;
313
}
314
315
mode = ((head>>6)&0x3);
316
stereo = (mode == MPG_MD_MONO) ? 1 : 2;
317
318
if(mpeg25)
319
sampling_frequency = 6 + ((head>>10)&0x3);
320
else
321
sampling_frequency = ((head>>10)&0x3) + (lsf*3);
322
h = ((stereo==fr->stereo) && (lsf==fr->lsf) && (mpeg25==fr->mpeg25) &&
323
(sampling_frequency == fr->sampling_frequency));
324
}
325
326
if (h) {
327
return i-3;
328
}
329
}
330
}
331
return -1;
332
}
333
334
335
303
304
pos = buf->pos;
305
for (i = 0; i < mp->bsize; i++) {
306
/* get 4 bytes */
307
308
b[0] = b[1];
309
b[1] = b[2];
310
b[2] = b[3];
311
while (pos >= buf->size) {
312
buf = buf->next;
313
pos = buf->pos;
314
if (!buf) {
315
return -1;
316
/* not enough data to read 4 bytes */
317
}
318
}
319
b[3] = buf->pnt[pos];
320
++pos;
321
322
if (i >= 3) {
323
struct frame *fr = &mp->fr;
324
unsigned long head;
325
326
head = b[0];
327
head <<= 8;
328
head |= b[1];
329
head <<= 8;
330
head |= b[2];
331
head <<= 8;
332
head |= b[3];
333
h = head_check(head, fr->lay);
334
335
if (h && free_match) {
336
/* just to be even more thorough, match the sample rate */
337
int mode, stereo, sampling_frequency, mpeg25, lsf;
338
339
if (head & (1 << 20)) {
340
lsf = (head & (1 << 19)) ? 0x0 : 0x1;
341
mpeg25 = 0;
342
}
343
else {
344
lsf = 1;
345
mpeg25 = 1;
346
}
347
348
mode = ((head >> 6) & 0x3);
349
stereo = (mode == MPG_MD_MONO) ? 1 : 2;
350
351
if (mpeg25)
352
sampling_frequency = 6 + ((head >> 10) & 0x3);
353
else
354
sampling_frequency = ((head >> 10) & 0x3) + (lsf * 3);
355
h = ((stereo == fr->stereo) && (lsf == fr->lsf) && (mpeg25 == fr->mpeg25) &&
356
(sampling_frequency == fr->sampling_frequency));
357
}
358
359
if (h) {
360
return i - 3;
361
}
362
}
363
}
364
return -1;
365
}
366
367
368
void
369
decode_reset(PMPSTR mp)
370
{
371
#if 0
372
remove_buf(mp);
373
/* start looking for next frame */
374
/* mp->fsizeold = mp->framesize; */
375
mp->fsizeold = -1;
376
mp->old_free_format = mp->free_format;
377
mp->framesize = 0;
378
mp->header_parsed = 0;
379
mp->side_parsed = 0;
380
mp->data_parsed = 0;
381
mp->sync_bitstream = 1; /* TODO check if this is right */
382
#else
383
InitMP3(mp); /* Less error prone to just to reinitialise. */
384
#endif
385
}
386
387
int
388
audiodata_precedesframes(PMPSTR mp)
389
{
390
if (mp->fr.lay == 3)
391
return layer3_audiodata_precedesframes(mp);
392
else
393
return 0; /* For Layer 1 & 2 the audio data starts at the frame that describes it, so no audio data precedes. */
394
}
336
395
337
396
static int
338
decodeMP3_clipchoice( PMPSTR mp,unsigned char *in,int isize,char *out,int *done,
339
int (*synth_1to1_mono_ptr)(PMPSTR,real *,unsigned char *,int *),
340
int (*synth_1to1_ptr)(PMPSTR,real *,int,unsigned char *, int *) )
397
decodeMP3_clipchoice(PMPSTR mp, unsigned char *in, int isize, char *out, int *done,
398
int (*synth_1to1_mono_ptr) (PMPSTR, real *, unsigned char *, int *),
399
int (*synth_1to1_ptr) (PMPSTR, real *, int, unsigned char *, int *))
341
400
{
342
int i,iret,bits,bytes;
343
344
if (in && isize && addbuf(mp,in,isize) == NULL)
345
return MP3_ERR;
346
347
/* First decode header */
348
if(!mp->header_parsed) {
349
350
if (mp->fsizeold==-1 || mp->sync_bitstream) {
351
int vbrbytes;
352
mp->sync_bitstream=0;
353
354
/* This is the very first call. sync with anything */
355
/* bytes= number of bytes before header */
356
bytes=sync_buffer(mp,0);
357
358
/* now look for Xing VBR header */
359
if (mp->bsize >= bytes+XING_HEADER_SIZE ) {
360
/* vbrbytes = number of bytes in entire vbr header */
361
vbrbytes=check_vbr_header(mp,bytes);
362
} else {
363
/* not enough data to look for Xing header */
364
return MP3_NEED_MORE;
365
}
366
367
if (mp->vbr_header) {
368
/* do we have enough data to parse entire Xing header? */
369
if (bytes+vbrbytes > mp->bsize) return MP3_NEED_MORE;
370
371
/* read in Xing header. Buffer data in case it
372
* is used by a non zero main_data_begin for the next
373
* frame, but otherwise dont decode Xing header */
374
/*fprintf(stderr,"found xing header, skipping %i bytes\n",vbrbytes+bytes);*/
375
for (i=0; i<vbrbytes+bytes; ++i) read_buf_byte(mp);
376
/* now we need to find another syncword */
377
/* just return and make user send in more data */
378
return MP3_NEED_MORE;
379
}
380
}else{
381
/* match channels, samplerate, etc, when syncing */
382
bytes=sync_buffer(mp,1);
383
}
384
385
if (bytes<0) return MP3_NEED_MORE;
386
if (bytes>0) {
387
/* there were some extra bytes in front of header.
388
* bitstream problem, but we are now resynced
389
* should try to buffer previous data in case new
390
* frame has nonzero main_data_begin, but we need
391
* to make sure we do not overflow buffer
392
*/
393
int size;
394
fprintf(stderr,"bitstream problem: resyncing...\n");
395
mp->old_free_format=0;
396
mp->sync_bitstream=1;
397
398
/* skip some bytes, buffer the rest */
399
size = (int) (mp->wordpointer - (mp->bsspace[mp->bsnum]+512));
400
401
if (size > MAXFRAMESIZE) {
402
/* wordpointer buffer is trashed. probably cant recover, but try anyway */
403
fprintf(stderr,"mpglib: wordpointer trashed. size=%i (%i) bytes=%i \n",
404
size,MAXFRAMESIZE,bytes);
405
size=0;
406
mp->wordpointer = mp->bsspace[mp->bsnum]+512;
407
}
408
409
/* buffer contains 'size' data right now
410
we want to add 'bytes' worth of data, but do not
411
exceed MAXFRAMESIZE, so we through away 'i' bytes */
412
i = (size+bytes)-MAXFRAMESIZE;
413
for (; i>0; --i) {
414
--bytes;
401
int i, iret, bits, bytes;
402
403
if (in && isize && addbuf(mp, in, isize) == NULL)
404
return MP3_ERR;
405
406
/* First decode header */
407
if (!mp->header_parsed) {
408
409
if (mp->fsizeold == -1 || mp->sync_bitstream) {
410
int vbrbytes;
411
mp->sync_bitstream = 0;
412
413
/* This is the very first call. sync with anything */
414
/* bytes= number of bytes before header */
415
bytes = sync_buffer(mp, 0);
416
417
/* now look for Xing VBR header */
418
if (mp->bsize >= bytes + XING_HEADER_SIZE) {
419
/* vbrbytes = number of bytes in entire vbr header */
420
vbrbytes = check_vbr_header(mp, bytes);
421
}
422
else {
423
/* not enough data to look for Xing header */
424
#ifdef HIP_DEBUG
425
fprintf(stderr, "hip: not enough data to look for Xing header\n");
426
#endif
427
return MP3_NEED_MORE;
428
}
429
430
if (mp->vbr_header) {
431
/* do we have enough data to parse entire Xing header? */
432
if (bytes + vbrbytes > mp->bsize) {
433
/* fprintf(stderr,"hip: not enough data to parse entire Xing header\n"); */
434
return MP3_NEED_MORE;
435
}
436
437
/* read in Xing header. Buffer data in case it
438
* is used by a non zero main_data_begin for the next
439
* frame, but otherwise dont decode Xing header */
440
#ifdef HIP_DEBUG
441
fprintf(stderr, "hip: found xing header, skipping %i bytes\n", vbrbytes + bytes);
442
#endif
443
for (i = 0; i < vbrbytes + bytes; ++i)
415
444
read_buf_byte(mp);
416
}
417
418
copy_mp(mp,bytes,mp->wordpointer);
419
mp->fsizeold += bytes;
420
}
421
422
read_head(mp);
423
decode_header(&mp->fr,mp->header);
424
mp->header_parsed=1;
425
mp->framesize = mp->fr.framesize;
426
mp->free_format = (mp->framesize==0);
427
428
if(mp->fr.lsf)
429
mp->ssize = (mp->fr.stereo == 1) ? 9 : 17;
430
else
431
mp->ssize = (mp->fr.stereo == 1) ? 17 : 32;
432
if (mp->fr.error_protection)
433
mp->ssize += 2;
434
435
mp->bsnum = 1-mp->bsnum; /* toggle buffer */
436
mp->wordpointer = mp->bsspace[mp->bsnum] + 512;
437
mp->bitindex = 0;
438
439
/* for very first header, never parse rest of data */
440
if (mp->fsizeold==-1)
441
return MP3_NEED_MORE;
442
}
443
444
/* now decode side information */
445
if (!mp->side_parsed) {
446
447
/* Layer 3 only */
448
if (mp->fr.lay==3)
449
{
450
if (mp->bsize < mp->ssize)
451
return MP3_NEED_MORE;
452
453
copy_mp(mp,mp->ssize,mp->wordpointer);
454
455
if(mp->fr.error_protection)
456
getbits(mp,16);
457
bits=do_layer3_sideinfo(mp);
458
/* bits = actual number of bits needed to parse this frame */
459
/* can be negative, if all bits needed are in the reservoir */
460
if (bits<0) bits=0;
461
462
/* read just as many bytes as necessary before decoding */
463
mp->dsize = (bits+7)/8;
464
465
/* this will force mpglib to read entire frame before decoding */
466
/* mp->dsize= mp->framesize - mp->ssize;*/
467
468
}
469
470
else
471
{
472
/* Layers 1 and 2 */
473
474
/* check if there is enough input data */
475
if(mp->fr.framesize > mp->bsize)
476
return MP3_NEED_MORE;
477
478
/* takes care that the right amount of data is copied into wordpointer */
479
mp->dsize=mp->fr.framesize;
480
mp->ssize=0;
481
}
482
483
mp->side_parsed=1;
484
}
485
486
/* now decode main data */
487
iret=MP3_NEED_MORE;
488
if (!mp->data_parsed ) {
489
if(mp->dsize > mp->bsize) {
490
return MP3_NEED_MORE;
491
}
492
493
copy_mp(mp,mp->dsize,mp->wordpointer);
494
495
*done = 0;
496
497
/*do_layer3(&mp->fr,(unsigned char *) out,done); */
498
switch (mp->fr.lay)
499
{
500
case 1:
501
if(mp->fr.error_protection)
502
getbits(mp,16);
503
504
do_layer1(mp,(unsigned char *) out,done);
505
break;
506
507
case 2:
508
if(mp->fr.error_protection)
509
getbits(mp,16);
510
511
do_layer2(mp,(unsigned char *) out,done);
512
break;
513
514
case 3:
515
do_layer3(mp,(unsigned char *) out,done, synth_1to1_mono_ptr, synth_1to1_ptr);
516
break;
517
default:
518
fprintf(stderr,"invalid layer %d\n",mp->fr.lay);
519
}
520
521
mp->wordpointer = mp->bsspace[mp->bsnum] + 512 + mp->ssize + mp->dsize;
522
523
mp->data_parsed=1;
524
iret=MP3_OK;
525
}
526
527
528
/* remaining bits are ancillary data, or reservoir for next frame
529
* If free format, scan stream looking for next frame to determine
530
* mp->framesize */
531
if (mp->free_format) {
532
if (mp->old_free_format) {
445
/* now we need to find another syncword */
446
/* just return and make user send in more data */
447
448
return MP3_NEED_MORE;
449
}
450
}
451
else {
452
/* match channels, samplerate, etc, when syncing */
453
bytes = sync_buffer(mp, 1);
454
}
455
456
/* buffer now synchronized */
457
if (bytes < 0) {
458
/* fprintf(stderr,"hip: need more bytes %d\n", bytes); */
459
return MP3_NEED_MORE;
460
}
461
if (bytes > 0) {
462
/* there were some extra bytes in front of header.
463
* bitstream problem, but we are now resynced
464
* should try to buffer previous data in case new
465
* frame has nonzero main_data_begin, but we need
466
* to make sure we do not overflow buffer
467
*/
468
int size;
469
fprintf(stderr, "hip: bitstream problem, resyncing skipping %d bytes...\n", bytes);
470
mp->old_free_format = 0;
471
#if 1
472
/* FIXME: correct ??? */
473
mp->sync_bitstream = 1;
474
#endif
475
/* skip some bytes, buffer the rest */
476
size = (int) (mp->wordpointer - (mp->bsspace[mp->bsnum] + 512));
477
478
if (size > MAXFRAMESIZE) {
479
/* wordpointer buffer is trashed. probably cant recover, but try anyway */
480
fprintf(stderr, "hip: wordpointer trashed. size=%i (%i) bytes=%i \n",
481
size, MAXFRAMESIZE, bytes);
482
size = 0;
483
mp->wordpointer = mp->bsspace[mp->bsnum] + 512;
484
}
485
486
/* buffer contains 'size' data right now
487
we want to add 'bytes' worth of data, but do not
488
exceed MAXFRAMESIZE, so we through away 'i' bytes */
489
i = (size + bytes) - MAXFRAMESIZE;
490
for (; i > 0; --i) {
491
--bytes;
492
read_buf_byte(mp);
493
}
494
495
copy_mp(mp, bytes, mp->wordpointer);
496
mp->fsizeold += bytes;
497
}
498
499
read_head(mp);
500
decode_header(&mp->fr, mp->header);
501
mp->header_parsed = 1;
502
mp->framesize = mp->fr.framesize;
503
mp->free_format = (mp->framesize == 0);
504
505
if (mp->fr.lsf)
506
mp->ssize = (mp->fr.stereo == 1) ? 9 : 17;
507
else
508
mp->ssize = (mp->fr.stereo == 1) ? 17 : 32;
509
if (mp->fr.error_protection)
510
mp->ssize += 2;
511
512
mp->bsnum = 1 - mp->bsnum; /* toggle buffer */
513
mp->wordpointer = mp->bsspace[mp->bsnum] + 512;
514
mp->bitindex = 0;
515
516
/* for very first header, never parse rest of data */
517
if (mp->fsizeold == -1) {
518
#ifdef HIP_DEBUG
519
fprintf(stderr, "hip: not parsing the rest of the data of the first header\n");
520
#endif
521
return MP3_NEED_MORE;
522
}
523
} /* end of header parsing block */
524
525
/* now decode side information */
526
if (!mp->side_parsed) {
527
528
/* Layer 3 only */
529
if (mp->fr.lay == 3) {
530
if (mp->bsize < mp->ssize)
531
return MP3_NEED_MORE;
532
533
copy_mp(mp, mp->ssize, mp->wordpointer);
534
535
if (mp->fr.error_protection)
536
getbits(mp, 16);
537
bits = do_layer3_sideinfo(mp);
538
/* bits = actual number of bits needed to parse this frame */
539
/* can be negative, if all bits needed are in the reservoir */
540
if (bits < 0)
541
bits = 0;
542
543
/* read just as many bytes as necessary before decoding */
544
mp->dsize = (bits + 7) / 8;
545
546
#ifdef HIP_DEBUG
547
fprintf(stderr,
548
"hip: %d bits needed to parse layer III frame, number of bytes to read before decoding dsize = %d\n",
549
bits, mp->dsize);
550
#endif
551
552
/* this will force mpglib to read entire frame before decoding */
553
/* mp->dsize= mp->framesize - mp->ssize; */
554
555
}
556
else {
557
/* Layers 1 and 2 */
558
559
/* check if there is enough input data */
560
if (mp->fr.framesize > mp->bsize)
561
return MP3_NEED_MORE;
562
563
/* takes care that the right amount of data is copied into wordpointer */
564
mp->dsize = mp->fr.framesize;
565
mp->ssize = 0;
566
}
567
568
mp->side_parsed = 1;
569
}
570
571
/* now decode main data */
572
iret = MP3_NEED_MORE;
573
if (!mp->data_parsed) {
574
if (mp->dsize > mp->bsize) {
575
return MP3_NEED_MORE;
576
}
577
578
copy_mp(mp, mp->dsize, mp->wordpointer);
579
580
*done = 0;
581
582
/*do_layer3(&mp->fr,(unsigned char *) out,done); */
583
switch (mp->fr.lay) {
584
case 1:
585
if (mp->fr.error_protection)
586
getbits(mp, 16);
587
588
do_layer1(mp, (unsigned char *) out, done);
589
break;
590
591
case 2:
592
if (mp->fr.error_protection)
593
getbits(mp, 16);
594
595
do_layer2(mp, (unsigned char *) out, done);
596
break;
597
598
case 3:
599
do_layer3(mp, (unsigned char *) out, done, synth_1to1_mono_ptr, synth_1to1_ptr);
600
break;
601
default:
602
fprintf(stderr, "hip: invalid layer %d\n", mp->fr.lay);
603
}
604
605
mp->wordpointer = mp->bsspace[mp->bsnum] + 512 + mp->ssize + mp->dsize;
606
607
mp->data_parsed = 1;
608
iret = MP3_OK;
609
}
610
611
612
/* remaining bits are ancillary data, or reservoir for next frame
613
* If free format, scan stream looking for next frame to determine
614
* mp->framesize */
615
if (mp->free_format) {
616
if (mp->old_free_format) {
533
617
/* free format. bitrate must not vary */
534
mp->framesize=mp->fsizeold_nopadding + (mp->fr.padding);
535
}else{
536
bytes=sync_buffer(mp,1);
537
if (bytes<0) return iret;
538
mp->framesize = bytes + mp->ssize+mp->dsize;
539
mp->fsizeold_nopadding= mp->framesize - mp->fr.padding;
618
mp->framesize = mp->fsizeold_nopadding + (mp->fr.padding);
619
}
620
else {
621
bytes = sync_buffer(mp, 1);
622
if (bytes < 0)
623
return iret;
624
mp->framesize = bytes + mp->ssize + mp->dsize;
625
mp->fsizeold_nopadding = mp->framesize - mp->fr.padding;
540
626
/*
541
fprintf(stderr,"freeformat bitstream: estimated bitrate=%ikbs \n",
542
8*(4+mp->framesize)*freqs[mp->fr.sampling_frequency]/
543
(1000*576*(2-mp->fr.lsf)));
544
*/
545
}
546
}
547
548
/* buffer the ancillary data and reservoir for next frame */
549
bytes = mp->framesize-(mp->ssize+mp->dsize);
550
if (bytes > mp->bsize) {
551
return iret;
552
}
553
554
if (bytes>0) {
555
int size;
556
copy_mp(mp,bytes,mp->wordpointer);
557
mp->wordpointer += bytes;
558
559
size = (int) (mp->wordpointer - (mp->bsspace[mp->bsnum]+512));
560
if (size > MAXFRAMESIZE) {
561
fprintf(stderr,"fatal error. MAXFRAMESIZE not large enough.\n");
562
}
563
564
}
565
566
/* the above frame is completey parsed. start looking for next frame */
567
mp->fsizeold = mp->framesize;
568
mp->old_free_format = mp->free_format;
569
mp->framesize =0;
570
mp->header_parsed=0;
571
mp->side_parsed=0;
572
mp->data_parsed=0;
573
627
fprintf(stderr,"hip: freeformat bitstream: estimated bitrate=%ikbs \n",
628
8*(4+mp->framesize)*freqs[mp->fr.sampling_frequency]/
629
(1000*576*(2-mp->fr.lsf)));
630
*/
631
}
632
}
633
634
/* buffer the ancillary data and reservoir for next frame */
635
bytes = mp->framesize - (mp->ssize + mp->dsize);
636
if (bytes > mp->bsize) {
574
637
return iret;
575
}
576
577
int decodeMP3( PMPSTR mp,unsigned char *in,int isize,char *out,
578
int osize,int *done)
579
{
580
if(osize < 4608) {
581
fprintf(stderr,"To less out space\n");
582
return MP3_ERR;
583
}
584
585
/* passing pointers to the functions which clip the samples */
586
return decodeMP3_clipchoice(mp, in, isize, out, done, synth_1to1_mono, synth_1to1);
587
}
588
589
int decodeMP3_unclipped( PMPSTR mp,unsigned char *in,int isize,char *out,
590
int osize,int *done)
591
{
592
/* we forbid input with more than 1152 samples per channel for output in unclipped mode */
593
if(osize < (int)(1152 * 2 * sizeof(real)) ) {
594
fprintf(stderr,"To less out space\n");
595
return MP3_ERR;
596
}
597
598
/* passing pointers to the functions which don't clip the samples */
599
return decodeMP3_clipchoice(mp, in, isize, out, done, synth_1to1_mono_unclipped, synth_1to1_unclipped);
600
}
601
602
603
604
605
638
}
639
640
if (bytes > 0) {
641
int size;
642
#if 0
643
/* FIXME: while loop OK ??? */
644
while (bytes > 512) {
645
read_buf_byte(mp);
646
bytes--;
647
mp->framesize--;
648
}
649
#endif
650
copy_mp(mp, bytes, mp->wordpointer);
651
mp->wordpointer += bytes;
652
653
size = (int) (mp->wordpointer - (mp->bsspace[mp->bsnum] + 512));
654
if (size > MAXFRAMESIZE) {
655
fprintf(stderr, "hip: fatal error. MAXFRAMESIZE not large enough.\n");
656
}
657
658
}
659
660
/* the above frame is completely parsed. start looking for next frame */
661
mp->fsizeold = mp->framesize;
662
mp->old_free_format = mp->free_format;
663
mp->framesize = 0;
664
mp->header_parsed = 0;
665
mp->side_parsed = 0;
666
mp->data_parsed = 0;
667
668
return iret;
669
}
670
671
int
672
decodeMP3(PMPSTR mp, unsigned char *in, int isize, char *out, int osize, int *done)
673
{
674
if (osize < 4608) {
675
fprintf(stderr, "hip: Insufficient memory for decoding buffer %d\n", osize);
676
return MP3_ERR;
677
}
678
679
/* passing pointers to the functions which clip the samples */
680
return decodeMP3_clipchoice(mp, in, isize, out, done, synth_1to1_mono, synth_1to1);
681
}
682
683
int
684
decodeMP3_unclipped(PMPSTR mp, unsigned char *in, int isize, char *out, int osize, int *done)
685
{
686
/* we forbid input with more than 1152 samples per channel for output in unclipped mode */
687
if (osize < (int) (1152 * 2 * sizeof(real))) {
688
fprintf(stderr, "hip: out space too small for unclipped mode\n");
689
return MP3_ERR;
690
}
691
692
/* passing pointers to the functions which don't clip the samples */
693
return decodeMP3_clipchoice(mp, in, isize, out, done, synth_1to1_mono_unclipped,
694
synth_1to1_unclipped);
695
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1