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