2 * 11/19/04 1.0 moved to LGPL.
4 * 11/17/04 Uncomplete frames discarded. E.B, javalayer@javazoom.net
6 * 12/05/03 ID3v2 tag returned. E.B, javalayer@javazoom.net
8 * 12/12/99 Based on Ibitstream. Exceptions thrown on errors,
9 * Temporary removed seek functionality. mdm@techie.com
11 * 02/12/99 : Java Conversion by E.B , javalayer@javazoom.net
13 * 04/14/97 : Added function prototypes for new syncing and seeking
14 * mechanisms. Also made this file portable. Changes made by Jeff Tsay
16 * @(#) ibitstream.h 1.5, last edit: 6/15/94 16:55:34
17 * @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
18 * @(#) Berlin University of Technology
19 *-----------------------------------------------------------------------
20 * This program is free software; you can redistribute it and/or modify
21 * it under the terms of the GNU Library General Public License as published
22 * by the Free Software Foundation; either version 2 of the License, or
23 * (at your option) any later version.
25 * This program is distributed in the hope that it will be useful,
26 * but WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 * GNU Library General Public License for more details.
30 * You should have received a copy of the GNU Library General Public
31 * License along with this program; if not, write to the Free Software
32 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 *----------------------------------------------------------------------
37 * The <code>Bistream</code> class is responsible for parsing an MPEG audio
40 * <b>REVIEW:</b> much of the parsing currently occurs in the various decoders.
41 * This should be moved into this class and associated inner classes.
43 @LATTICE("FB<F,FF<F,WP<BI,FF*,WP*,BI*")
44 @METHODDEFAULT("OUT<THIS,THIS<VAR,VAR<IN,VAR*,THISLOC=THIS,GLOBALLOC=IN")
45 public final class Bitstream implements BitstreamErrors {
47 * Synchronization control constant for the initial synchronization to the
51 static byte INITIAL_SYNC = 0;
54 * Synchronization control constant for non-initial frame synchronizations.
58 static byte STRICT_SYNC = 1;
60 // max. 1730 bytes per frame: 144 * 384kbit/s / 32000 Hz + 2 Bytes CRC
62 * Maximum size of the frame buffer.
65 private static final int BUFFER_INT_SIZE = 433;
68 * The frame buffer that holds the data for the current frame.
71 private final int[] framebuffer = new int[BUFFER_INT_SIZE];
74 * Number of valid bytes in the frame buffer.
77 private int framesize;
80 * The bytes read from the stream.
83 private byte[] frame_bytes = new byte[BUFFER_INT_SIZE * 4];
86 * Index into <code>framebuffer</code> where the next bits are retrieved.
89 private int wordpointer;
92 * Number (0-31, from MSB to LSB) of next bit for get_bits()
98 * The current specified syncword
101 private int syncword;
104 * Audio header position in stream.
107 private int header_pos = 0;
113 private boolean single_ch_mode;
114 // private int current_frame_number;
115 // private int last_frame_number;
118 private final int bitmask[] = {
120 0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
121 0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, 0x00001FFF, 0x00003FFF,
122 0x00007FFF, 0x0000FFFF, 0x0001FFFF };
125 private final PushbackInputStream source;
128 private final Header header = new Header();
131 private final byte syncbuf[] = new byte[4];
134 private Crc16[] crc = new Crc16[1];
137 private byte[] rawid3v2 = null;
140 private boolean firstframe = true;
143 * Construct a IBitstream that reads data from a given InputStream.
146 * The InputStream to read from.
148 public Bitstream(InputStream in) {
150 throw new NullPointerException("in");
151 in = new BufferedInputStream(in);
154 // source = new PushbackInputStream(in, 1024);
155 source = new PushbackInputStream(in, BUFFER_INT_SIZE * 4);
158 // current_frame_number = -1;
159 // last_frame_number = -1;
163 * Return position of the first audio header.
165 * @return size of ID3v2 tag frames.
167 public int header_pos() {
178 private void loadID3v2(InputStream in) {
181 // Read ID3v2 header (10 bytes).
183 size = readID3v2Header(in);
185 } catch (IOException e) {
188 // Unread ID3v2 header (10 bytes).
190 } catch (IOException e) {
196 rawid3v2 = new byte[size];
197 in.read(rawid3v2, 0, rawid3v2.length);
199 } catch (IOException e) {
204 * Parse ID3v2 tag header to find out size of ID3v2 frames.
208 * @return size of ID3v2 frames + header
209 * @throws IOException
212 private int readID3v2Header(InputStream in) throws IOException {
213 byte[] id3header = new byte[4];
215 in.read(id3header, 0, 3);
217 if ((id3header[0] == 'I') && (id3header[1] == 'D') && (id3header[2] == '3')) {
218 in.read(id3header, 0, 3);
219 int majorVersion = id3header[0];
220 int revision = id3header[1];
221 in.read(id3header, 0, 4);
223 (int) (id3header[0] << 21) + (id3header[1] << 14) + (id3header[2] << 7) + (id3header[3]);
229 * Return raw ID3v2 frames + header.
231 * @return ID3v2 InputStream or null if ID3v2 frames are not available.
233 public InputStream getRawID3v2() {
234 if (rawid3v2 == null)
237 ByteArrayInputStream bain = new ByteArrayInputStream(rawid3v2);
243 * Close the Bitstream.
245 * @throws BitstreamException
247 public void close() throws BitstreamException {
250 } catch (IOException ex) {
251 throw newBitstreamException(STREAM_ERROR, ex);
256 * Reads and parses the next frame from the input source.
258 * @return the Header describing details of the frame read, or null if the end
259 * of the stream has been reached.
261 public Header readFrame() throws BitstreamException {
262 Header result = null;
264 result = readNextFrame();
265 // E.B, Parse VBR (if any) first frame.
266 if (firstframe == true) {
267 result.parseVBR(frame_bytes);
270 } catch (BitstreamException ex) {
271 if ((ex.getErrorCode() == INVALIDFRAME)) {
272 // Try to skip this frame.
273 // System.out.println("INVALIDFRAME");
276 result = readNextFrame();
277 } catch (BitstreamException e) {
278 if ((e.getErrorCode() != STREAM_EOF)) {
279 // wrap original exception so stack trace is maintained.
280 throw newBitstreamException(e.getErrorCode(), e);
283 } else if ((ex.getErrorCode() != STREAM_EOF)) {
284 // wrap original exception so stack trace is maintained.
285 throw newBitstreamException(ex.getErrorCode(), ex);
292 * Read next MP3 frame.
294 * @return MP3 frame header.
295 * @throws BitstreamException
297 private Header readNextFrame() throws BitstreamException {
298 if (framesize == -1) {
305 * Read next MP3 frame.
307 * @throws BitstreamException
309 private void nextFrame() throws BitstreamException {
310 // entire frame is read by the header class.
311 header.read_header(this, crc);
315 * Unreads the bytes read from the frame.
317 * @throws BitstreamException
319 // REVIEW: add new error codes for this.
320 public void unreadFrame() throws BitstreamException {
321 if (wordpointer == -1 && bitindex == -1 && (framesize > 0)) {
323 source.unread(frame_bytes, 0, framesize);
324 } catch (IOException ex) {
325 throw newBitstreamException(STREAM_ERROR);
333 public void closeFrame() {
340 * Determines if the next 4 bytes of the stream represent a frame header.
342 public boolean isSyncCurrentPosition(int syncmode) throws BitstreamException {
343 int read = readBytes(syncbuf, 0, 4);
345 ((syncbuf[0] << 24) & 0xFF000000) | ((syncbuf[1] << 16) & 0x00FF0000)
346 | ((syncbuf[2] << 8) & 0x0000FF00) | ((syncbuf[3] << 0) & 0x000000FF);
349 source.unread(syncbuf, 0, read);
350 } catch (IOException ex) {
353 boolean sync = false;
359 sync = isSyncMark(headerstring, syncmode, syncword);
366 // REVIEW: this class should provide inner classes to
367 // parse the frame contents. Eventually, readBits will
369 public int readBits(int n) {
373 public int readCheckedBits(int n) {
374 // REVIEW: implement CRC check.
378 protected BitstreamException newBitstreamException(int errorcode) {
379 return new BitstreamException(errorcode, null);
382 protected BitstreamException newBitstreamException(int errorcode, Throwable throwable) {
383 return new BitstreamException(errorcode, throwable);
387 * Get next 32 bits from bitstream. They are stored in the headerstring.
388 * syncmod allows Synchro flag ID The returned value is False at the end of
392 int syncHeader(byte syncmode) throws BitstreamException {
395 // read additional 2 bytes
396 int bytesRead = readBytes(syncbuf, 0, 3);
399 throw newBitstreamException(STREAM_EOF, null);
402 ((syncbuf[0] << 16) & 0x00FF0000) | ((syncbuf[1] << 8) & 0x0000FF00)
403 | ((syncbuf[2] << 0) & 0x000000FF);
408 if (readBytes(syncbuf, 3, 1) != 1)
409 throw newBitstreamException(STREAM_EOF, null);
411 headerstring |= (syncbuf[3] & 0x000000FF);
413 sync = isSyncMark(headerstring, syncmode, syncword);
416 // current_frame_number++;
417 // if (last_frame_number < current_frame_number) last_frame_number =
418 // current_frame_number;
423 public boolean isSyncMark(int headerstring, int syncmode, int word) {
424 boolean sync = false;
426 if (syncmode == INITIAL_SYNC) {
427 // sync = ((headerstring & 0xFFF00000) == 0xFFF00000);
428 sync = ((headerstring & 0xFFE00000) == 0xFFE00000); // SZD: MPEG 2.5
431 ((headerstring & 0xFFF80C00) == word)
432 && (((headerstring & 0x000000C0) == 0x000000C0) == single_ch_mode);
435 // filter out invalid sample rate
437 sync = (((headerstring >>> 10) & 3) != 3);
438 // filter out invalid layer
440 sync = (((headerstring >>> 17) & 3) != 0);
441 // filter out invalid version
443 sync = (((headerstring >>> 19) & 3) != 1);
449 * Reads the data for the next frame. The frame is not parsed until parse
452 int read_frame_data(int bytesize) throws BitstreamException {
454 numread = readFully(frame_bytes, 0, bytesize);
455 framesize = bytesize;
462 * Parses the data previously read with read_frame_data().
464 @LATTICE("GLOBAL<B,B<BNUM,BNUM<K,K<BYTE,BYTE<THIS,B*,K*,THISLOC=THIS,GLOBALLOC=GLOBAL")
465 void parse_frame() throws BitstreamException {
466 // Convert Bytes read to int
468 @LOC("BYTE") byte[] byteread = frame_bytes;
469 @LOC("BYTE") int bytesize = framesize;
471 // Check ID3v1 TAG (True only if last frame).
472 // for (int t=0;t<(byteread.length)-2;t++)
474 // if ((byteread[t]=='T') && (byteread[t+1]=='A') && (byteread[t+2]=='G'))
476 // System.out.println("ID3v1 detected at offset "+t);
477 // throw newBitstreamException(INVALIDFRAME, null);
481 for (@LOC("K") int k = 0; k < bytesize; k = k + 4) {
482 @LOC("BYTE") int convert = 0;
483 @LOC("BNUM") byte b0 = 0;
484 @LOC("BNUM") byte b1 = 0;
485 @LOC("BNUM") byte b2 = 0;
486 @LOC("BNUM") byte b3 = 0;
488 if (k + 1 < bytesize)
489 b1 = byteread[k + 1];
490 if (k + 2 < bytesize)
491 b2 = byteread[k + 2];
492 if (k + 3 < bytesize)
493 b3 = byteread[k + 3];
495 ((b0 << 24) & 0xFF000000) | ((b1 << 16) & 0x00FF0000) | ((b2 << 8) & 0x0000FF00)
503 * Read bits from buffer into the lower bits of an unsigned int. The LSB
504 * contains the latest read bit of the stream. (1 <= number_of_bits <= 16)
506 @LATTICE("OUT<RL,RL<THIS,THIS<IN,OUT*,THISLOC=THIS,RETURNLOC=OUT")
507 public int get_bits(@LOC("IN") int number_of_bits) {
509 @LOC("OUT") int returnvalue = 0;
510 @LOC("THIS,Bitstream.BI") int sum = bitindex + number_of_bits;
513 // There is a problem here, wordpointer could be -1 ?!
519 // all bits contained in *wordpointer
520 returnvalue = (framebuffer[wordpointer] >>> (32 - sum)) & bitmask[number_of_bits];
521 // returnvalue = (wordpointer[0] >> (32 - sum)) & bitmask[number_of_bits];
522 if ((bitindex += number_of_bits) == 32) {
524 wordpointer++; // added by me!
529 // E.B : Check that ?
530 // ((short[])&returnvalue)[0] = ((short[])wordpointer + 1)[0];
531 // wordpointer++; // Added by me!
532 // ((short[])&returnvalue + 1)[0] = ((short[])wordpointer)[0];
533 @LOC("RL") int Right = (framebuffer[wordpointer] & 0x0000FFFF);
535 @LOC("RL") int Left = (framebuffer[wordpointer] & 0xFFFF0000);
536 returnvalue = ((Right << 16) & 0xFFFF0000) | ((Left >>> 16) & 0x0000FFFF);
538 returnvalue >>>= 48 - sum; // returnvalue >>= 16 - (number_of_bits - (32 -
540 returnvalue &= bitmask[number_of_bits];
546 * Set the word we want to sync the header to. In Big-Endian byte order
548 void set_syncword(@LOC("IN") int syncword0) {
549 syncword = syncword0 & 0xFFFFFF3F;
550 single_ch_mode = ((syncword0 & 0x000000C0) == 0x000000C0);
554 * Reads the exact number of bytes from the source input stream into a byte
558 * The byte array to read the specified number of bytes into.
560 * The index in the array where the first byte read should be stored.
562 * the number of bytes to read.
564 * @exception BitstreamException
565 * is thrown if the specified number of bytes could not be read
568 @LATTICE("OUT<VAR,VAR<THIS,THIS<IN,IN*,VAR*,THISLOC=THIS")
570 private int readFully(@LOC("OUT") byte[] b, @LOC("IN") int offs, @LOC("IN") int len)
571 throws BitstreamException {
572 @LOC("VAR") int nRead = 0;
575 @LOC("IN") int bytesread = source.read(b, offs, len);
576 if (bytesread == -1) {
581 // throw newBitstreamException(UNEXPECTED_EOF, new EOFException());
583 nRead = nRead + bytesread;
587 } catch (IOException ex) {
588 throw newBitstreamException(STREAM_ERROR, ex);
594 * Simlar to readFully, but doesn't throw exception when EOF is reached.
596 @LATTICE("OUT<VAR,VAR<THIS,THIS<IN,IN*,VAR*,THISLOC=THIS")
598 private int readBytes(@LOC("OUT") byte[] b, @LOC("IN") int offs, @LOC("IN") int len)
599 throws BitstreamException {
600 @LOC("VAR") int totalBytesRead = 0;
603 @LOC("IN") int bytesread = source.read(b, offs, len);
604 if (bytesread == -1) {
607 totalBytesRead += bytesread;
611 } catch (IOException ex) {
612 throw newBitstreamException(STREAM_ERROR, ex);
614 return totalBytesRead;