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