more changes to pass the flow-down rule
[IRC.git] / Robust / src / Tests / ssJava / mp3decoder / Header.java
1 /*
2  * 11/19/04 : 1.0 moved to LGPL.
3  *            VBRI header support added, E.B javalayer@javazoom.net
4  * 
5  * 12/04/03 : VBR (XING) header support added, E.B javalayer@javazoom.net
6  *
7  * 02/13/99 : Java Conversion by JavaZOOM , E.B javalayer@javazoom.net
8  *
9  * Declarations for MPEG header class
10  * A few layer III, MPEG-2 LSF, and seeking modifications made by Jeff Tsay.
11  * Last modified : 04/19/97
12  *
13  *  @(#) header.h 1.7, last edit: 6/15/94 16:55:33
14  *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
15  *  @(#) Berlin University of Technology
16  *-----------------------------------------------------------------------
17  *   This program is free software; you can redistribute it and/or modify
18  *   it under the terms of the GNU Library General Public License as published
19  *   by the Free Software Foundation; either version 2 of the License, or
20  *   (at your option) any later version.
21  *
22  *   This program is distributed in the hope that it will be useful,
23  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
24  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
25  *   GNU Library General Public License for more details.
26  *
27  *   You should have received a copy of the GNU Library General Public
28  *   License along with this program; if not, write to the Free Software
29  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
30  *----------------------------------------------------------------------
31  */
32
33 /**
34  * Class for extracting information from a frame header.
35  */
36 @LATTICE("HI<HNS,HNS<H,C<H,NS<FS,FS<H,FS<HV,H<SYNC,HV<SYNC,H<T,HV<T,SYNC*,HV*,FS*,HI*")
37 @METHODDEFAULT("THIS<IN,THISLOC=THIS,GLOBALLOC=THIS,RETURNLOC=THIS")
38 public final class Header {
39
40   public static final int[][] frequencies = { { 22050, 24000, 16000, 1 },
41       { 44100, 48000, 32000, 1 }, { 11025, 12000, 8000, 1 } }; // SZD: MPEG25
42
43   /**
44    * Constant for MPEG-2 LSF version
45    */
46   public static final int MPEG2_LSF = 0;
47   public static final int MPEG25_LSF = 2; // SZD
48
49   /**
50    * Constant for MPEG-1 version
51    */
52   public static final int MPEG1 = 1;
53
54   public static final int STEREO = 0;
55   public static final int JOINT_STEREO = 1;
56   public static final int DUAL_CHANNEL = 2;
57   public static final int SINGLE_CHANNEL = 3;
58   public static final int FOURTYFOUR_POINT_ONE = 0;
59   public static final int FOURTYEIGHT = 1;
60   public static final int THIRTYTWO = 2;
61
62   @LOC("H")
63   private int h_layer;
64   @LOC("H")
65   private int h_protection_bit;
66   @LOC("H")
67   private int h_bitrate_index;
68   @LOC("H")
69   private int h_padding_bit;
70   @LOC("H")
71   private int h_mode_extension;
72   @LOC("HV")
73   private int h_version;
74   @LOC("H")
75   private int h_mode;
76   @LOC("H")
77   private int h_sample_frequency;
78   @LOC("HNS")
79   private int h_number_of_subbands;
80   @LOC("HI")
81   private int h_intensity_stereo_bound;
82   @LOC("H")
83   private boolean h_copyright;
84   @LOC("H")
85   private boolean h_original;
86   // VBR support added by E.B
87   @LOC("T")
88   private double[] h_vbr_time_per_frame = { -1.0, 384.0, 1152.0, 1152.0 };
89   @LOC("T")
90   private boolean h_vbr;
91   @LOC("T")
92   private int h_vbr_frames;
93   @LOC("T")
94   private int h_vbr_scale;
95   @LOC("T")
96   private int h_vbr_bytes;
97   @LOC("T")
98   private byte[] h_vbr_toc;
99
100   @LOC("SYNC")
101   private byte syncmode = Bitstream.INITIAL_SYNC;
102   @LOC("C")
103   private Crc16 crc;
104
105   @LOC("C")
106   public short checksum;
107   @LOC("FS")
108   public int framesize;
109   @LOC("NS")
110   public int nSlots;
111
112   @LOC("T")
113   private int _headerstring = -1; // E.B
114
115   @LOC("T")
116   private SideInfoBuffer sib;
117   @LOC("T")
118   private BitReserve br;
119
120   Header() {
121   }
122
123   @LATTICE("OUT<BUF,BUF<THIS,THISLOC=THIS,RETURNLOC=OUT")
124   public String toString() {
125     @LOC("BUF") StringBuffer buffer = new StringBuffer(200);
126     buffer.append("Layer ");
127     buffer.append(layer_string());
128     buffer.append(" frame ");
129     buffer.append(mode_string());
130     buffer.append(' ');
131     buffer.append(version_string());
132     if (!checksums())
133       buffer.append(" no");
134     buffer.append(" checksums");
135     buffer.append(' ');
136     buffer.append(sample_frequency_string());
137     buffer.append(',');
138     buffer.append(' ');
139     buffer.append(bitrate_string());
140
141     @LOC("OUT") String s = buffer.toString();
142     return s;
143   }
144
145   /**
146    * Read a 32-bit header from the bitstream.
147    */
148   int read_header(Bitstream stream, Crc16[] crcp) throws BitstreamException {
149     int headerstring;
150     int channel_bitrate;
151     boolean sync = false;
152     do {
153       headerstring = stream.syncHeader(syncmode);
154       if (headerstring == -1) {
155         return -1;
156       }
157       _headerstring = headerstring; // E.B
158       if (syncmode == Bitstream.INITIAL_SYNC) {
159         h_version = ((headerstring >>> 19) & 1);
160         if (((headerstring >>> 20) & 1) == 0) // SZD: MPEG2.5 detection
161           if (h_version == MPEG2_LSF)
162             h_version = MPEG25_LSF;
163           else
164             throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
165         if ((h_sample_frequency = ((headerstring >>> 10) & 3)) == 3) {
166           throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
167         }
168       }
169       h_layer = 4 - (headerstring >>> 17) & 3;
170       h_protection_bit = (headerstring >>> 16) & 1;
171       h_bitrate_index = (headerstring >>> 12) & 0xF;
172       h_padding_bit = (headerstring >>> 9) & 1;
173       h_mode = ((headerstring >>> 6) & 3);
174       h_mode_extension = (headerstring >>> 4) & 3;
175       if (h_mode == JOINT_STEREO)
176         h_intensity_stereo_bound = (h_mode_extension << 2) + 4;
177       else
178         h_intensity_stereo_bound = 0; // should never be used
179       if (((headerstring >>> 3) & 1) == 1)
180         h_copyright = true;
181       if (((headerstring >>> 2) & 1) == 1)
182         h_original = true;
183       // calculate number of subbands:
184       if (h_layer == 1)
185         h_number_of_subbands = 32;
186       else {
187         channel_bitrate = h_bitrate_index;
188         // calculate bitrate per channel:
189         if (h_mode != SINGLE_CHANNEL)
190           if (channel_bitrate == 4)
191             channel_bitrate = 1;
192           else
193             channel_bitrate -= 4;
194         if ((channel_bitrate == 1) || (channel_bitrate == 2))
195           if (h_sample_frequency == THIRTYTWO)
196             h_number_of_subbands = 12;
197           else
198             h_number_of_subbands = 8;
199         else if ((h_sample_frequency == FOURTYEIGHT)
200             || ((channel_bitrate >= 3) && (channel_bitrate <= 5)))
201           h_number_of_subbands = 27;
202         else
203           h_number_of_subbands = 30;
204       }
205       if (h_intensity_stereo_bound > h_number_of_subbands)
206         h_intensity_stereo_bound = h_number_of_subbands;
207       // calculate framesize and nSlots
208       calculate_framesize();
209       // read framedata:
210       int framesizeloaded = stream.read_frame_data(framesize);
211       if ((framesize >= 0) && (framesizeloaded != framesize)) {
212         // Data loaded does not match to expected framesize,
213         // it might be an ID3v1 TAG. (Fix 11/17/04).
214         throw stream.newBitstreamException(Bitstream.INVALIDFRAME);
215       }
216       if (stream.isSyncCurrentPosition(syncmode)) {
217         if (syncmode == Bitstream.INITIAL_SYNC) {
218           syncmode = Bitstream.STRICT_SYNC;
219           stream.set_syncword(headerstring & 0xFFF80CC0);
220         }
221         sync = true;
222       } else {
223         stream.unreadFrame();
224       }
225     } while (!sync);
226     stream.parse_frame();
227     if (h_protection_bit == 0) {
228       // frame contains a crc checksum
229       checksum = (short) stream.get_bits(16);
230       if (crc == null)
231         crc = new Crc16();
232       crc.add_bits(headerstring, 16);
233       crcp[0] = crc;
234     } else
235       crcp[0] = null;
236     if (h_sample_frequency == FOURTYFOUR_POINT_ONE) {
237       /*
238        * if (offset == null) { int max = max_number_of_frames(stream); offset =
239        * new int[max]; for(int i=0; i<max; i++) offset[i] = 0; } // E.B :
240        * Investigate more int cf = stream.current_frame(); int lf =
241        * stream.last_frame(); if ((cf > 0) && (cf == lf)) { offset[cf] =
242        * offset[cf-1] + h_padding_bit; } else { offset[0] = h_padding_bit; }
243        */
244     }
245     return 0;
246   }
247
248   /**
249    * Parse frame to extract optionnal VBR frame.
250    * 
251    * @param firstframe
252    * @author E.B (javalayer@javazoom.net)
253    */
254   void parseVBR(byte[] firstframe) throws BitstreamException {
255     // Trying Xing header.
256     String xing = "Xing";
257     byte tmp[] = new byte[4];
258     int offset = 0;
259     // Compute "Xing" offset depending on MPEG version and channels.
260     if (h_version == MPEG1) {
261       if (h_mode == SINGLE_CHANNEL)
262         offset = 21 - 4;
263       else
264         offset = 36 - 4;
265     } else {
266       if (h_mode == SINGLE_CHANNEL)
267         offset = 13 - 4;
268       else
269         offset = 21 - 4;
270     }
271     try {
272       System.arraycopy(firstframe, offset, tmp, 0, 4);
273       // Is "Xing" ?
274       if (xing.equals(new String(tmp))) {
275         // Yes.
276         h_vbr = true;
277         h_vbr_frames = -1;
278         h_vbr_bytes = -1;
279         h_vbr_scale = -1;
280         h_vbr_toc = new byte[100];
281
282         int length = 4;
283         // Read flags.
284         byte flags[] = new byte[4];
285         System.arraycopy(firstframe, offset + length, flags, 0, flags.length);
286         length += flags.length;
287         // Read number of frames (if available).
288         if ((flags[3] & (byte) (1 << 0)) != 0) {
289           System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
290           h_vbr_frames =
291               (tmp[0] << 24) & 0xFF000000 | (tmp[1] << 16) & 0x00FF0000 | (tmp[2] << 8)
292                   & 0x0000FF00 | tmp[3] & 0x000000FF;
293           length += 4;
294         }
295         // Read size (if available).
296         if ((flags[3] & (byte) (1 << 1)) != 0) {
297           System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
298           h_vbr_bytes =
299               (tmp[0] << 24) & 0xFF000000 | (tmp[1] << 16) & 0x00FF0000 | (tmp[2] << 8)
300                   & 0x0000FF00 | tmp[3] & 0x000000FF;
301           length += 4;
302         }
303         // Read TOC (if available).
304         if ((flags[3] & (byte) (1 << 2)) != 0) {
305           System.arraycopy(firstframe, offset + length, h_vbr_toc, 0, h_vbr_toc.length);
306           length += h_vbr_toc.length;
307         }
308         // Read scale (if available).
309         if ((flags[3] & (byte) (1 << 3)) != 0) {
310           System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
311           h_vbr_scale =
312               (tmp[0] << 24) & 0xFF000000 | (tmp[1] << 16) & 0x00FF0000 | (tmp[2] << 8)
313                   & 0x0000FF00 | tmp[3] & 0x000000FF;
314           length += 4;
315         }
316         // System.out.println("VBR:"+xing+" Frames:"+ h_vbr_frames
317         // +" Size:"+h_vbr_bytes);
318       }
319     } catch (ArrayIndexOutOfBoundsException e) {
320       throw new BitstreamException("XingVBRHeader Corrupted", e);
321     }
322
323     // Trying VBRI header.
324     String vbri = "VBRI";
325     offset = 36 - 4;
326     try {
327       System.arraycopy(firstframe, offset, tmp, 0, 4);
328       // Is "VBRI" ?
329       if (vbri.equals(new String(tmp))) {
330         // Yes.
331         h_vbr = true;
332         h_vbr_frames = -1;
333         h_vbr_bytes = -1;
334         h_vbr_scale = -1;
335         h_vbr_toc = new byte[100];
336         // Bytes.
337         int length = 4 + 6;
338         System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
339         h_vbr_bytes =
340             (tmp[0] << 24) & 0xFF000000 | (tmp[1] << 16) & 0x00FF0000 | (tmp[2] << 8) & 0x0000FF00
341                 | tmp[3] & 0x000000FF;
342         length += 4;
343         // Frames.
344         System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
345         h_vbr_frames =
346             (tmp[0] << 24) & 0xFF000000 | (tmp[1] << 16) & 0x00FF0000 | (tmp[2] << 8) & 0x0000FF00
347                 | tmp[3] & 0x000000FF;
348         length += 4;
349         // System.out.println("VBR:"+vbri+" Frames:"+ h_vbr_frames
350         // +" Size:"+h_vbr_bytes);
351         // TOC
352         // TODO
353       }
354     } catch (ArrayIndexOutOfBoundsException e) {
355       throw new BitstreamException("VBRIVBRHeader Corrupted", e);
356     }
357   }
358
359   // Functions to query header contents:
360   /**
361    * Returns version.
362    */
363   @RETURNLOC("THIS,Header.HV")
364   public int version() {
365     return h_version;
366   }
367
368   /**
369    * Returns Layer ID.
370    */
371   @RETURNLOC("THIS,Header.H")
372   public int layer() {
373     return h_layer;
374   }
375
376   /**
377    * Returns bitrate index.
378    */
379   public int bitrate_index() {
380     return h_bitrate_index;
381   }
382
383   /**
384    * Returns Sample Frequency.
385    */
386   @RETURNLOC("THIS,Header.H")
387   public int sample_frequency() {
388     return h_sample_frequency;
389   }
390
391   /**
392    * Returns Frequency.
393    */
394   @RETURNLOC("THIS,Header.FS")
395   public int frequency() {
396     return frequencies[h_version][h_sample_frequency];
397   }
398
399   /**
400    * Returns Mode.
401    */
402   @RETURNLOC("THIS,Header.H")
403   public int mode() {
404     return h_mode;
405   }
406
407   /**
408    * Returns Protection bit.
409    */
410   @RETURNLOC("THIS,Header.H")
411   public boolean checksums() {
412     if (h_protection_bit == 0)
413       return true;
414     else
415       return false;
416   }
417
418   /**
419    * Returns Copyright.
420    */
421   public boolean copyright() {
422     return h_copyright;
423   }
424
425   /**
426    * Returns Original.
427    */
428   public boolean original() {
429     return h_original;
430   }
431
432   /**
433    * Return VBR.
434    * 
435    * @return true if VBR header is found
436    */
437   public boolean vbr() {
438     return h_vbr;
439   }
440
441   /**
442    * Return VBR scale.
443    * 
444    * @return scale of -1 if not available
445    */
446   public int vbr_scale() {
447     return h_vbr_scale;
448   }
449
450   /**
451    * Return VBR TOC.
452    * 
453    * @return vbr toc ot null if not available
454    */
455   public byte[] vbr_toc() {
456     return h_vbr_toc;
457   }
458
459   /**
460    * Returns Checksum flag. Compares computed checksum with stream checksum.
461    */
462   @RETURNLOC("OUT")
463   public boolean checksum_ok() {
464     return (checksum == crc.checksum());
465   }
466
467   // Seeking and layer III stuff
468   /**
469    * Returns Layer III Padding bit.
470    */
471   public boolean padding() {
472     if (h_padding_bit == 0)
473       return false;
474     else
475       return true;
476   }
477
478   /**
479    * Returns Slots.
480    */
481   @RETURNLOC("THIS,Header.NS")
482   public int slots() {
483     return nSlots;
484   }
485
486   /**
487    * Returns Mode Extension.
488    */
489   @RETURNLOC("THIS,Header.H")
490   public int mode_extension() {
491     return h_mode_extension;
492   }
493
494   // E.B -> private to public
495   public static final int bitrates[][][] = {
496       {
497           { 0 /* free format */, 32000, 48000, 56000, 64000, 80000, 96000, 112000, 128000, 144000,
498               160000, 176000, 192000, 224000, 256000, 0 },
499           { 0 /* free format */, 8000, 16000, 24000, 32000, 40000, 48000, 56000, 64000, 80000,
500               96000, 112000, 128000, 144000, 160000, 0 },
501           { 0 /* free format */, 8000, 16000, 24000, 32000, 40000, 48000, 56000, 64000, 80000,
502               96000, 112000, 128000, 144000, 160000, 0 } },
503
504       {
505           { 0 /* free format */, 32000, 64000, 96000, 128000, 160000, 192000, 224000, 256000,
506               288000, 320000, 352000, 384000, 416000, 448000, 0 },
507           { 0 /* free format */, 32000, 48000, 56000, 64000, 80000, 96000, 112000, 128000, 160000,
508               192000, 224000, 256000, 320000, 384000, 0 },
509           { 0 /* free format */, 32000, 40000, 48000, 56000, 64000, 80000, 96000, 112000, 128000,
510               160000, 192000, 224000, 256000, 320000, 0 } },
511       // SZD: MPEG2.5
512       {
513           { 0 /* free format */, 32000, 48000, 56000, 64000, 80000, 96000, 112000, 128000, 144000,
514               160000, 176000, 192000, 224000, 256000, 0 },
515           { 0 /* free format */, 8000, 16000, 24000, 32000, 40000, 48000, 56000, 64000, 80000,
516               96000, 112000, 128000, 144000, 160000, 0 },
517           { 0 /* free format */, 8000, 16000, 24000, 32000, 40000, 48000, 56000, 64000, 80000,
518               96000, 112000, 128000, 144000, 160000, 0 } },
519
520   };
521
522   // E.B -> private to public
523   /**
524    * Calculate Frame size. Calculates framesize in bytes excluding header size.
525    */
526   public int calculate_framesize() {
527
528     if (h_layer == 1) {
529       framesize =
530           (12 * bitrates[h_version][0][h_bitrate_index])
531               / frequencies[h_version][h_sample_frequency];
532       if (h_padding_bit != 0)
533         framesize++;
534       framesize <<= 2; // one slot is 4 bytes long
535       nSlots = 0;
536     } else {
537       framesize =
538           (144 * bitrates[h_version][h_layer - 1][h_bitrate_index])
539               / frequencies[h_version][h_sample_frequency];
540       if (h_version == MPEG2_LSF || h_version == MPEG25_LSF)
541         framesize >>= 1; // SZD
542       if (h_padding_bit != 0)
543         framesize++;
544       // Layer III slots
545       if (h_layer == 3) {
546         if (h_version == MPEG1) {
547           nSlots = framesize - ((h_mode == SINGLE_CHANNEL) ? 17 : 32) // side
548                                                                       // info
549                                                                       // size
550               - ((h_protection_bit != 0) ? 0 : 2) // CRC size
551               - 4; // header size
552         } else { // MPEG-2 LSF, SZD: MPEG-2.5 LSF
553           nSlots = framesize - ((h_mode == SINGLE_CHANNEL) ? 9 : 17) // side
554                                                                      // info
555                                                                      // size
556               - ((h_protection_bit != 0) ? 0 : 2) // CRC size
557               - 4; // header size
558         }
559       } else {
560         nSlots = 0;
561       }
562     }
563     framesize -= 4; // subtract header size
564     return framesize;
565   }
566
567   /**
568    * Returns the maximum number of frames in the stream.
569    * 
570    * @param streamsize
571    * @return number of frames
572    */
573   public int max_number_of_frames(int streamsize) // E.B
574   {
575     if (h_vbr == true)
576       return h_vbr_frames;
577     else {
578       if ((framesize + 4 - h_padding_bit) == 0)
579         return 0;
580       else
581         return (streamsize / (framesize + 4 - h_padding_bit));
582     }
583   }
584
585   /**
586    * Returns the maximum number of frames in the stream.
587    * 
588    * @param streamsize
589    * @return number of frames
590    */
591   public int min_number_of_frames(int streamsize) // E.B
592   {
593     if (h_vbr == true)
594       return h_vbr_frames;
595     else {
596       if ((framesize + 5 - h_padding_bit) == 0)
597         return 0;
598       else
599         return (streamsize / (framesize + 5 - h_padding_bit));
600     }
601   }
602
603   /**
604    * Returns ms/frame.
605    * 
606    * @return milliseconds per frame
607    */
608   @LATTICE("OUT<THIS,THISLOC=THIS,RETURNLOC=OUT")
609   public float ms_per_frame() // E.B
610   {
611     if (h_vbr == true) {
612       @LOC("OUT") double tpf = h_vbr_time_per_frame[layer()] / frequency();
613       if ((h_version == MPEG2_LSF) || (h_version == MPEG25_LSF))
614         tpf /= 2;
615       return ((float) (tpf * 1000));
616     } else {
617       @LOC("OUT") float ms_per_frame_array[][] =
618           { { 8.707483f, 8.0f, 12.0f }, { 26.12245f, 24.0f, 36.0f }, { 26.12245f, 24.0f, 36.0f } };
619       return (ms_per_frame_array[h_layer - 1][h_sample_frequency]);
620     }
621   }
622
623   /**
624    * Returns total ms.
625    * 
626    * @param streamsize
627    * @return total milliseconds
628    */
629   public float total_ms(int streamsize) // E.B
630   {
631     return (max_number_of_frames(streamsize) * ms_per_frame());
632   }
633
634   /**
635    * Returns synchronized header.
636    */
637   public int getSyncHeader() // E.B
638   {
639     return _headerstring;
640   }
641
642   // functions which return header informations as strings:
643   /**
644    * Return Layer version.
645    */
646   @RETURNLOC("THIS,Header.H")
647   public String layer_string() {
648     switch (h_layer) {
649     case 1:
650       return "I";
651     case 2:
652       return "II";
653     case 3:
654       return "III";
655     }
656     return null;
657   }
658
659   // E.B -> private to public
660   public static final String bitrate_str[][][] = {
661       {
662           { "free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
663               "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s", "176 kbit/s",
664               "192 kbit/s", "224 kbit/s", "256 kbit/s", "forbidden" },
665           { "free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s", "40 kbit/s",
666               "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s", "96 kbit/s", "112 kbit/s",
667               "128 kbit/s", "144 kbit/s", "160 kbit/s", "forbidden" },
668           { "free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s", "40 kbit/s",
669               "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s", "96 kbit/s", "112 kbit/s",
670               "128 kbit/s", "144 kbit/s", "160 kbit/s", "forbidden" } },
671
672       {
673           { "free format", "32 kbit/s", "64 kbit/s", "96 kbit/s", "128 kbit/s", "160 kbit/s",
674               "192 kbit/s", "224 kbit/s", "256 kbit/s", "288 kbit/s", "320 kbit/s", "352 kbit/s",
675               "384 kbit/s", "416 kbit/s", "448 kbit/s", "forbidden" },
676           { "free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
677               "96 kbit/s", "112 kbit/s", "128 kbit/s", "160 kbit/s", "192 kbit/s", "224 kbit/s",
678               "256 kbit/s", "320 kbit/s", "384 kbit/s", "forbidden" },
679           { "free format", "32 kbit/s", "40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
680               "80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "160 kbit/s", "192 kbit/s",
681               "224 kbit/s", "256 kbit/s", "320 kbit/s", "forbidden" } },
682       // SZD: MPEG2.5
683       {
684           { "free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
685               "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s", "176 kbit/s",
686               "192 kbit/s", "224 kbit/s", "256 kbit/s", "forbidden" },
687           { "free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s", "40 kbit/s",
688               "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s", "96 kbit/s", "112 kbit/s",
689               "128 kbit/s", "144 kbit/s", "160 kbit/s", "forbidden" },
690           { "free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s", "40 kbit/s",
691               "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s", "96 kbit/s", "112 kbit/s",
692               "128 kbit/s", "144 kbit/s", "160 kbit/s", "forbidden" } }, };
693
694   /**
695    * Return Bitrate.
696    * 
697    * @return bitrate in bps
698    */
699   @RETURNLOC("THIS,Header.FS")
700   public String bitrate_string() {
701     @LOC("THIS,Header.T") String kbs = " kb/s";
702     if (h_vbr == true) {
703       return Integer.toString(bitrate() / 1000) + kbs;
704     } else {
705       return bitrate_str[h_version][h_layer - 1][h_bitrate_index];
706     }
707   }
708
709   /**
710    * Return Bitrate.
711    * 
712    * @return bitrate in bps and average bitrate for VBR header
713    */
714   @RETURNLOC("THIS,Header.FS")
715   public int bitrate() {
716     if (h_vbr == true) {
717       return ((int) ((h_vbr_bytes * 8) / (ms_per_frame() * h_vbr_frames))) * 1000;
718     } else {
719       return bitrates[h_version][h_layer - 1][h_bitrate_index];
720     }
721   }
722
723   /**
724    * Return Instant Bitrate. Bitrate for VBR is not constant.
725    * 
726    * @return bitrate in bps
727    */
728   public int bitrate_instant() {
729     return bitrates[h_version][h_layer - 1][h_bitrate_index];
730   }
731
732   /**
733    * Returns Frequency
734    * 
735    * @return frequency string in kHz
736    */
737   @RETURNLOC("THIS,Header.FS")
738   public String sample_frequency_string() {
739     switch (h_sample_frequency) {
740     case THIRTYTWO:
741       if (h_version == MPEG1)
742         return "32 kHz";
743       else if (h_version == MPEG2_LSF)
744         return "16 kHz";
745       else
746         // SZD
747         return "8 kHz";
748     case FOURTYFOUR_POINT_ONE:
749       if (h_version == MPEG1)
750         return "44.1 kHz";
751       else if (h_version == MPEG2_LSF)
752         return "22.05 kHz";
753       else
754         // SZD
755         return "11.025 kHz";
756     case FOURTYEIGHT:
757       if (h_version == MPEG1)
758         return "48 kHz";
759       else if (h_version == MPEG2_LSF)
760         return "24 kHz";
761       else
762         // SZD
763         return "12 kHz";
764     }
765     return (null);
766   }
767
768   /**
769    * Returns Mode.
770    */
771   @RETURNLOC("THIS,Header.H")
772   public String mode_string() {
773     switch (h_mode) {
774     case STEREO:
775       return "Stereo";
776     case JOINT_STEREO:
777       return "Joint stereo";
778     case DUAL_CHANNEL:
779       return "Dual channel";
780     case SINGLE_CHANNEL:
781       return "Single channel";
782     }
783     return null;
784   }
785
786   /**
787    * Returns Version.
788    * 
789    * @return MPEG-1 or MPEG-2 LSF or MPEG-2.5 LSF
790    */
791   @RETURNLOC("THIS,Header.HV")
792   public String version_string() {
793     switch (h_version) {
794     case MPEG1:
795       return "MPEG-1";
796     case MPEG2_LSF:
797       return "MPEG-2 LSF";
798     case MPEG25_LSF: // SZD
799       return "MPEG-2.5 LSF";
800     }
801     return (null);
802   }
803
804   /**
805    * Returns the number of subbands in the current frame.
806    * 
807    * @return number of subbands
808    */
809   public int number_of_subbands() {
810     return h_number_of_subbands;
811   }
812
813   /**
814    * Returns Intensity Stereo. (Layer II joint stereo only). Returns the number
815    * of subbands which are in stereo mode, subbands above that limit are in
816    * intensity stereo mode.
817    * 
818    * @return intensity
819    */
820   public int intensity_stereo_bound() {
821     return h_intensity_stereo_bound;
822   }
823
824   public void setSideInfoBuf(SideInfoBuffer sib) {
825     this.sib = sib;
826   }
827
828   public void setBitReserve(BitReserve br) {
829     this.br = br;
830   }
831
832   @RETURNLOC("THIS,Header.T")
833   public SideInfoBuffer getSideInfoBuffer() {
834     return sib;
835   }
836
837   @RETURNLOC("THIS,Header.T")
838   public BitReserve getBitReserve() {
839     return br;
840   }
841
842 }