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