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