Robust/src/Tests/ssJava/mp3decoder/Header.java

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