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
 700   @RETURNLOC("THIS,Header.FS")
 701   public String bitrate_string() {
 702     @LOC("THIS,Header.T") String kbs = " kb/s";
 703     if (h_vbr == true) {
 704       return Integer.toString(bitrate() / 1000) + kbs;
 705     } else {
 706       return bitrate_str[h_version][h_layer - 1][h_bitrate_index];
 707     }
 708   }
 709
 710   /**
 711    * Return Bitrate.
 712    *
 713    * @return bitrate in bps and average bitrate for VBR header
 714    */
 715   @RETURNLOC("THIS,Header.FS")
 716   public int bitrate() {
 717     if (h_vbr == true) {
 718       return ((int) ((h_vbr_bytes * 8) / (ms_per_frame() * h_vbr_frames))) * 1000;
 719     } else {
 720       return bitrates[h_version][h_layer - 1][h_bitrate_index];
 721     }
 722   }
 723
 724   /**
 725    * Return Instant Bitrate. Bitrate for VBR is not constant.
 726    *
 727    * @return bitrate in bps
 728    */
 729   public int bitrate_instant() {
 730     return bitrates[h_version][h_layer - 1][h_bitrate_index];
 731   }
 732
 733   /**
 734    * Returns Frequency
 735    *
 736    * @return frequency string in kHz
 737    */
 738   @RETURNLOC("THIS,Header.FS")
 739   public String sample_frequency_string() {
 740     switch (h_sample_frequency) {
 741     case THIRTYTWO:
 742       if (h_version == MPEG1)
 743         return "32 kHz";
 744       else if (h_version == MPEG2_LSF)
 745         return "16 kHz";
 746       else
 747         // SZD
 748         return "8 kHz";
 749     case FOURTYFOUR_POINT_ONE:
 750       if (h_version == MPEG1)
 751         return "44.1 kHz";
 752       else if (h_version == MPEG2_LSF)
 753         return "22.05 kHz";
 754       else
 755         // SZD
 756         return "11.025 kHz";
 757     case FOURTYEIGHT:
 758       if (h_version == MPEG1)
 759         return "48 kHz";
 760       else if (h_version == MPEG2_LSF)
 761         return "24 kHz";
 762       else
 763         // SZD
 764         return "12 kHz";
 765     }
 766     return (null);
 767   }
 768
 769   /**
 770    * Returns Mode.
 771    */
 772   @RETURNLOC("THIS,Header.H")
 773   public String mode_string() {
 774     switch (h_mode) {
 775     case STEREO:
 776       return "Stereo";
 777     case JOINT_STEREO:
 778       return "Joint stereo";
 779     case DUAL_CHANNEL:
 780       return "Dual channel";
 781     case SINGLE_CHANNEL:
 782       return "Single channel";
 783     }
 784     return null;
 785   }
 786
 787   /**
 788    * Returns Version.
 789    *
 790    * @return MPEG-1 or MPEG-2 LSF or MPEG-2.5 LSF
 791    */
 792   @RETURNLOC("THIS,Header.HV")
 793   public String version_string() {
 794     switch (h_version) {
 795     case MPEG1:
 796       return "MPEG-1";
 797     case MPEG2_LSF:
 798       return "MPEG-2 LSF";
 799     case MPEG25_LSF: // SZD
 800       return "MPEG-2.5 LSF";
 801     }
 802     return (null);
 803   }
 804
 805   /**
 806    * Returns the number of subbands in the current frame.
 807    *
 808    * @return number of subbands
 809    */
 810   public int number_of_subbands() {
 811     return h_number_of_subbands;
 812   }
 813
 814   /**
 815    * Returns Intensity Stereo. (Layer II joint stereo only). Returns the number
 816    * of subbands which are in stereo mode, subbands above that limit are in
 817    * intensity stereo mode.
 818    *
 819    * @return intensity
 820    */
 821   public int intensity_stereo_bound() {
 822     return h_intensity_stereo_bound;
 823   }
 824
 825   public void setSideInfoBuf(SideInfoBuffer sib) {
 826     this.sib = sib;
 827   }
 828
 829   public void setBitReserve(BitReserve br) {
 830     this.br = br;
 831   }
 832
 833   @RETURNLOC("THIS,Header.T")
 834   public SideInfoBuffer getSideInfoBuffer() {
 835     return sib;
 836   }
 837
 838   @RETURNLOC("THIS,Header.T")
 839   public BitReserve getBitReserve() {
 840     return br;
 841   }
 842
 843 }