mirror of
https://git.zelz.net/catfoolyou/Project164.git
synced 2025-12-16 08:37:40 +00:00
250 errors
This commit is contained in:
catfoolyou
778
src/lwjgl/java/javazoom/jl/decoder/Header.java
Normal file
778
src/lwjgl/java/javazoom/jl/decoder/Header.java
Normal file
@@ -0,0 +1,778 @@
|
||||
/*
|
||||
* 11/19/04 : 1.0 moved to LGPL.
|
||||
* VBRI header support added, E.B javalayer@javazoom.net
|
||||
*
|
||||
* 12/04/03 : VBR (XING) header support added, E.B javalayer@javazoom.net
|
||||
*
|
||||
* 02/13/99 : Java Conversion by JavaZOOM , E.B javalayer@javazoom.net
|
||||
*
|
||||
* Declarations for MPEG header class
|
||||
* A few layer III, MPEG-2 LSF, and seeking modifications made by Jeff Tsay.
|
||||
* Last modified : 04/19/97
|
||||
*
|
||||
* @(#) header.h 1.7, last edit: 6/15/94 16:55:33
|
||||
* @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
|
||||
* @(#) Berlin University of Technology
|
||||
*-----------------------------------------------------------------------
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU Library General Public License as published
|
||||
* by the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU Library General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Library General Public
|
||||
* License along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*----------------------------------------------------------------------
|
||||
*/
|
||||
package javazoom.jl.decoder;
|
||||
|
||||
/**
|
||||
* Class for extracting information from a frame header.
|
||||
*/
|
||||
public final class Header
|
||||
{
|
||||
public static final int[][] frequencies =
|
||||
{{22050, 24000, 16000, 1},
|
||||
{44100, 48000, 32000, 1},
|
||||
{11025, 12000, 8000, 1}}; // SZD: MPEG25
|
||||
|
||||
/**
|
||||
* Constant for MPEG-2 LSF version
|
||||
*/
|
||||
public static final int MPEG2_LSF = 0;
|
||||
public static final int MPEG25_LSF = 2; // SZD
|
||||
|
||||
/**
|
||||
* Constant for MPEG-1 version
|
||||
*/
|
||||
public static final int MPEG1 = 1;
|
||||
|
||||
public static final int STEREO = 0;
|
||||
public static final int JOINT_STEREO = 1;
|
||||
public static final int DUAL_CHANNEL = 2;
|
||||
public static final int SINGLE_CHANNEL = 3;
|
||||
public static final int FOURTYFOUR_POINT_ONE = 0;
|
||||
public static final int FOURTYEIGHT=1;
|
||||
public static final int THIRTYTWO=2;
|
||||
|
||||
private int h_layer, h_protection_bit, h_bitrate_index,
|
||||
h_padding_bit, h_mode_extension;
|
||||
private int h_version;
|
||||
private int h_mode;
|
||||
private int h_sample_frequency;
|
||||
private int h_number_of_subbands, h_intensity_stereo_bound;
|
||||
private boolean h_copyright, h_original;
|
||||
// VBR support added by E.B
|
||||
private double[] h_vbr_time_per_frame = {-1, 384, 1152, 1152};
|
||||
private boolean h_vbr;
|
||||
private int h_vbr_frames;
|
||||
private int h_vbr_scale;
|
||||
private int h_vbr_bytes;
|
||||
private byte[] h_vbr_toc;
|
||||
|
||||
private byte syncmode = Bitstream.INITIAL_SYNC;
|
||||
private Crc16 crc;
|
||||
|
||||
public short checksum;
|
||||
public int framesize;
|
||||
public int nSlots;
|
||||
|
||||
private int _headerstring = -1; // E.B
|
||||
|
||||
Header()
|
||||
{
|
||||
}
|
||||
public String toString()
|
||||
{
|
||||
StringBuilder buffer = new StringBuilder(200);
|
||||
buffer.append("Layer ");
|
||||
buffer.append(layer_string());
|
||||
buffer.append(" frame ");
|
||||
buffer.append(mode_string());
|
||||
buffer.append(' ');
|
||||
buffer.append(version_string());
|
||||
if (!checksums())
|
||||
buffer.append(" no");
|
||||
buffer.append(" checksums");
|
||||
buffer.append(' ');
|
||||
buffer.append(sample_frequency_string());
|
||||
buffer.append(',');
|
||||
buffer.append(' ');
|
||||
buffer.append(bitrate_string());
|
||||
|
||||
String s = buffer.toString();
|
||||
return s;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read a 32-bit header from the bitstream.
|
||||
*/
|
||||
void read_header(Bitstream stream, Crc16[] crcp) throws BitstreamException
|
||||
{
|
||||
int headerstring;
|
||||
int channel_bitrate;
|
||||
boolean sync = false;
|
||||
do
|
||||
{
|
||||
headerstring = stream.syncHeader(syncmode);
|
||||
_headerstring = headerstring; // E.B
|
||||
if (syncmode == Bitstream.INITIAL_SYNC)
|
||||
{
|
||||
h_version = ((headerstring >>> 19) & 1);
|
||||
if (((headerstring >>> 20) & 1) == 0) // SZD: MPEG2.5 detection
|
||||
if (h_version == MPEG2_LSF)
|
||||
h_version = MPEG25_LSF;
|
||||
else
|
||||
throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
|
||||
if ((h_sample_frequency = ((headerstring >>> 10) & 3)) == 3)
|
||||
{
|
||||
throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
|
||||
}
|
||||
}
|
||||
h_layer = 4 - (headerstring >>> 17) & 3;
|
||||
h_protection_bit = (headerstring >>> 16) & 1;
|
||||
h_bitrate_index = (headerstring >>> 12) & 0xF;
|
||||
h_padding_bit = (headerstring >>> 9) & 1;
|
||||
h_mode = ((headerstring >>> 6) & 3);
|
||||
h_mode_extension = (headerstring >>> 4) & 3;
|
||||
if (h_mode == JOINT_STEREO)
|
||||
h_intensity_stereo_bound = (h_mode_extension << 2) + 4;
|
||||
else
|
||||
h_intensity_stereo_bound = 0; // should never be used
|
||||
if (((headerstring >>> 3) & 1) == 1)
|
||||
h_copyright = true;
|
||||
if (((headerstring >>> 2) & 1) == 1)
|
||||
h_original = true;
|
||||
// calculate number of subbands:
|
||||
if (h_layer == 1)
|
||||
h_number_of_subbands = 32;
|
||||
else
|
||||
{
|
||||
channel_bitrate = h_bitrate_index;
|
||||
// calculate bitrate per channel:
|
||||
if (h_mode != SINGLE_CHANNEL)
|
||||
if (channel_bitrate == 4)
|
||||
channel_bitrate = 1;
|
||||
else
|
||||
channel_bitrate -= 4;
|
||||
if ((channel_bitrate == 1) || (channel_bitrate == 2))
|
||||
if (h_sample_frequency == THIRTYTWO)
|
||||
h_number_of_subbands = 12;
|
||||
else
|
||||
h_number_of_subbands = 8;
|
||||
else if ((h_sample_frequency == FOURTYEIGHT) || ((channel_bitrate >= 3) && (channel_bitrate <= 5)))
|
||||
h_number_of_subbands = 27;
|
||||
else
|
||||
h_number_of_subbands = 30;
|
||||
}
|
||||
if (h_intensity_stereo_bound > h_number_of_subbands)
|
||||
h_intensity_stereo_bound = h_number_of_subbands;
|
||||
// calculate framesize and nSlots
|
||||
calculate_framesize();
|
||||
// read framedata:
|
||||
int framesizeloaded = stream.read_frame_data(framesize);
|
||||
if ((framesize >=0) && (framesizeloaded != framesize))
|
||||
{
|
||||
// Data loaded does not match to expected framesize,
|
||||
// it might be an ID3v1 TAG. (Fix 11/17/04).
|
||||
throw stream.newBitstreamException(Bitstream.INVALIDFRAME);
|
||||
}
|
||||
if (stream.isSyncCurrentPosition(syncmode))
|
||||
{
|
||||
if (syncmode == Bitstream.INITIAL_SYNC)
|
||||
{
|
||||
syncmode = Bitstream.STRICT_SYNC;
|
||||
stream.set_syncword(headerstring & 0xFFF80CC0);
|
||||
}
|
||||
sync = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
stream.unreadFrame();
|
||||
}
|
||||
}
|
||||
while (!sync);
|
||||
stream.parse_frame();
|
||||
if (h_protection_bit == 0)
|
||||
{
|
||||
// frame contains a crc checksum
|
||||
checksum = (short) stream.get_bits(16);
|
||||
if (crc == null)
|
||||
crc = new Crc16();
|
||||
crc.add_bits(headerstring, 16);
|
||||
crcp[0] = crc;
|
||||
}
|
||||
else
|
||||
crcp[0] = null;
|
||||
if (h_sample_frequency == FOURTYFOUR_POINT_ONE)
|
||||
{
|
||||
/*
|
||||
if (offset == null)
|
||||
{
|
||||
int max = max_number_of_frames(stream);
|
||||
offset = new int[max];
|
||||
for(int i=0; i<max; i++) offset[i] = 0;
|
||||
}
|
||||
// E.B : Investigate more
|
||||
int cf = stream.current_frame();
|
||||
int lf = stream.last_frame();
|
||||
if ((cf > 0) && (cf == lf))
|
||||
{
|
||||
offset[cf] = offset[cf-1] + h_padding_bit;
|
||||
}
|
||||
else
|
||||
{
|
||||
offset[0] = h_padding_bit;
|
||||
}
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse frame to extract optional VBR frame.
|
||||
*
|
||||
* @param firstframe
|
||||
* @author E.B (javalayer@javazoom.net)
|
||||
*/
|
||||
void parseVBR(byte[] firstframe) throws BitstreamException
|
||||
{
|
||||
// Trying Xing header.
|
||||
String xing = "Xing";
|
||||
byte tmp[] = new byte[4];
|
||||
int offset = 0;
|
||||
// Compute "Xing" offset depending on MPEG version and channels.
|
||||
if (h_version == MPEG1)
|
||||
{
|
||||
if (h_mode == SINGLE_CHANNEL) offset=21-4;
|
||||
else offset=36-4;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (h_mode == SINGLE_CHANNEL) offset=13-4;
|
||||
else offset = 21-4;
|
||||
}
|
||||
try
|
||||
{
|
||||
System.arraycopy(firstframe, offset, tmp, 0, 4);
|
||||
// Is "Xing" ?
|
||||
if (xing.equals(new String(tmp)))
|
||||
{
|
||||
//Yes.
|
||||
h_vbr = true;
|
||||
h_vbr_frames = -1;
|
||||
h_vbr_bytes = -1;
|
||||
h_vbr_scale = -1;
|
||||
h_vbr_toc = new byte[100];
|
||||
|
||||
int length = 4;
|
||||
// Read flags.
|
||||
byte flags[] = new byte[4];
|
||||
System.arraycopy(firstframe, offset + length, flags, 0, flags.length);
|
||||
length += flags.length;
|
||||
// Read number of frames (if available).
|
||||
if ((flags[3] & (byte) (1 << 0)) != 0)
|
||||
{
|
||||
System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
|
||||
h_vbr_frames = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
|
||||
length += 4;
|
||||
}
|
||||
// Read size (if available).
|
||||
if ((flags[3] & (byte) (1 << 1)) != 0)
|
||||
{
|
||||
System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
|
||||
h_vbr_bytes = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
|
||||
length += 4;
|
||||
}
|
||||
// Read TOC (if available).
|
||||
if ((flags[3] & (byte) (1 << 2)) != 0)
|
||||
{
|
||||
System.arraycopy(firstframe, offset + length, h_vbr_toc, 0, h_vbr_toc.length);
|
||||
length += h_vbr_toc.length;
|
||||
}
|
||||
// Read scale (if available).
|
||||
if ((flags[3] & (byte) (1 << 3)) != 0)
|
||||
{
|
||||
System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
|
||||
h_vbr_scale = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
|
||||
length += 4;
|
||||
}
|
||||
//System.out.println("VBR:"+xing+" Frames:"+ h_vbr_frames +" Size:"+h_vbr_bytes);
|
||||
}
|
||||
}
|
||||
catch (ArrayIndexOutOfBoundsException e)
|
||||
{
|
||||
throw new BitstreamException("XingVBRHeader Corrupted",e);
|
||||
}
|
||||
|
||||
// Trying VBRI header.
|
||||
String vbri = "VBRI";
|
||||
offset = 36-4;
|
||||
try
|
||||
{
|
||||
System.arraycopy(firstframe, offset, tmp, 0, 4);
|
||||
// Is "VBRI" ?
|
||||
if (vbri.equals(new String(tmp)))
|
||||
{
|
||||
//Yes.
|
||||
h_vbr = true;
|
||||
h_vbr_frames = -1;
|
||||
h_vbr_bytes = -1;
|
||||
h_vbr_scale = -1;
|
||||
h_vbr_toc = new byte[100];
|
||||
// Bytes.
|
||||
int length = 4 + 6;
|
||||
System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
|
||||
h_vbr_bytes = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
|
||||
length += 4;
|
||||
// Frames.
|
||||
System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
|
||||
h_vbr_frames = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
|
||||
length += 4;
|
||||
//System.out.println("VBR:"+vbri+" Frames:"+ h_vbr_frames +" Size:"+h_vbr_bytes);
|
||||
// TOC
|
||||
// TODO
|
||||
}
|
||||
}
|
||||
catch (ArrayIndexOutOfBoundsException e)
|
||||
{
|
||||
throw new BitstreamException("VBRIVBRHeader Corrupted",e);
|
||||
}
|
||||
}
|
||||
|
||||
// Functions to query header contents:
|
||||
/**
|
||||
* Returns version.
|
||||
*/
|
||||
public int version() { return h_version; }
|
||||
|
||||
/**
|
||||
* Returns Layer ID.
|
||||
*/
|
||||
public int layer() { return h_layer; }
|
||||
|
||||
/**
|
||||
* Returns bitrate index.
|
||||
*/
|
||||
public int bitrate_index() { return h_bitrate_index; }
|
||||
|
||||
/**
|
||||
* Returns Sample Frequency.
|
||||
*/
|
||||
public int sample_frequency() { return h_sample_frequency; }
|
||||
|
||||
/**
|
||||
* Returns Frequency.
|
||||
*/
|
||||
public int frequency() {return frequencies[h_version][h_sample_frequency];}
|
||||
|
||||
/**
|
||||
* Returns Mode.
|
||||
*/
|
||||
public int mode() { return h_mode; }
|
||||
|
||||
/**
|
||||
* Returns Protection bit.
|
||||
*/
|
||||
public boolean checksums()
|
||||
{
|
||||
if (h_protection_bit == 0) return true;
|
||||
else return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns Copyright.
|
||||
*/
|
||||
public boolean copyright() { return h_copyright; }
|
||||
|
||||
/**
|
||||
* Returns Original.
|
||||
*/
|
||||
public boolean original() { return h_original; }
|
||||
|
||||
/**
|
||||
* Return VBR.
|
||||
*
|
||||
* @return true if VBR header is found
|
||||
*/
|
||||
public boolean vbr() { return h_vbr; }
|
||||
|
||||
/**
|
||||
* Return VBR scale.
|
||||
*
|
||||
* @return scale of -1 if not available
|
||||
*/
|
||||
public int vbr_scale() { return h_vbr_scale; }
|
||||
|
||||
/**
|
||||
* Return VBR TOC.
|
||||
*
|
||||
* @return vbr toc ot null if not available
|
||||
*/
|
||||
public byte[] vbr_toc() { return h_vbr_toc; }
|
||||
|
||||
/**
|
||||
* Returns Checksum flag.
|
||||
* Compares computed checksum with stream checksum.
|
||||
*/
|
||||
public boolean checksum_ok () { return (checksum == crc.checksum()); }
|
||||
|
||||
// Seeking and layer III stuff
|
||||
/**
|
||||
* Returns Layer III Padding bit.
|
||||
*/
|
||||
public boolean padding()
|
||||
{
|
||||
if (h_padding_bit == 0) return false;
|
||||
else return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns Slots.
|
||||
*/
|
||||
public int slots() { return nSlots; }
|
||||
|
||||
/**
|
||||
* Returns Mode Extension.
|
||||
*/
|
||||
public int mode_extension() { return h_mode_extension; }
|
||||
|
||||
// E.B -> private to public
|
||||
public static final int bitrates[][][] = {
|
||||
{{0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
|
||||
112000, 128000, 144000, 160000, 176000, 192000 ,224000, 256000, 0},
|
||||
{0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
|
||||
56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0},
|
||||
{0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
|
||||
56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0}},
|
||||
|
||||
{{0 /*free format*/, 32000, 64000, 96000, 128000, 160000, 192000,
|
||||
224000, 256000, 288000, 320000, 352000, 384000, 416000, 448000, 0},
|
||||
{0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
|
||||
112000, 128000, 160000, 192000, 224000, 256000, 320000, 384000, 0},
|
||||
{0 /*free format*/, 32000, 40000, 48000, 56000, 64000, 80000,
|
||||
96000, 112000, 128000, 160000, 192000, 224000, 256000, 320000, 0}},
|
||||
// SZD: MPEG2.5
|
||||
{{0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
|
||||
112000, 128000, 144000, 160000, 176000, 192000 ,224000, 256000, 0},
|
||||
{0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
|
||||
56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0},
|
||||
{0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
|
||||
56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0}},
|
||||
|
||||
};
|
||||
|
||||
// E.B -> private to public
|
||||
/**
|
||||
* Calculate Frame size.
|
||||
*
|
||||
* Calculates framesize in bytes excluding header size.
|
||||
*/
|
||||
public int calculate_framesize()
|
||||
{
|
||||
|
||||
if (h_layer == 1)
|
||||
{
|
||||
framesize = (12 * bitrates[h_version][0][h_bitrate_index]) /
|
||||
frequencies[h_version][h_sample_frequency];
|
||||
if (h_padding_bit != 0 ) framesize++;
|
||||
framesize <<= 2; // one slot is 4 bytes long
|
||||
nSlots = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
framesize = (144 * bitrates[h_version][h_layer - 1][h_bitrate_index]) /
|
||||
frequencies[h_version][h_sample_frequency];
|
||||
if (h_version == MPEG2_LSF || h_version == MPEG25_LSF) framesize >>= 1; // SZD
|
||||
if (h_padding_bit != 0) framesize++;
|
||||
// Layer III slots
|
||||
if (h_layer == 3)
|
||||
{
|
||||
if (h_version == MPEG1)
|
||||
{
|
||||
nSlots = framesize - ((h_mode == SINGLE_CHANNEL) ? 17 : 32) // side info size
|
||||
- ((h_protection_bit!=0) ? 0 : 2) // CRC size
|
||||
- 4; // header size
|
||||
}
|
||||
else
|
||||
{ // MPEG-2 LSF, SZD: MPEG-2.5 LSF
|
||||
nSlots = framesize - ((h_mode == SINGLE_CHANNEL) ? 9 : 17) // side info size
|
||||
- ((h_protection_bit!=0) ? 0 : 2) // CRC size
|
||||
- 4; // header size
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
nSlots = 0;
|
||||
}
|
||||
}
|
||||
framesize -= 4; // subtract header size
|
||||
return framesize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the maximum number of frames in the stream.
|
||||
*
|
||||
* @param streamsize
|
||||
* @return number of frames
|
||||
*/
|
||||
public int max_number_of_frames(int streamsize) // E.B
|
||||
{
|
||||
if (h_vbr == true) return h_vbr_frames;
|
||||
else
|
||||
{
|
||||
if ((framesize + 4 - h_padding_bit) == 0) return 0;
|
||||
else return(streamsize / (framesize + 4 - h_padding_bit));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the maximum number of frames in the stream.
|
||||
*
|
||||
* @param streamsize
|
||||
* @return number of frames
|
||||
*/
|
||||
public int min_number_of_frames(int streamsize) // E.B
|
||||
{
|
||||
if (h_vbr == true) return h_vbr_frames;
|
||||
else
|
||||
{
|
||||
if ((framesize + 5 - h_padding_bit) == 0) return 0;
|
||||
else return(streamsize / (framesize + 5 - h_padding_bit));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns ms/frame.
|
||||
*
|
||||
* @return milliseconds per frame
|
||||
*/
|
||||
public float ms_per_frame() // E.B
|
||||
{
|
||||
if (h_vbr == true)
|
||||
{
|
||||
double tpf = h_vbr_time_per_frame[layer()] / frequency();
|
||||
if ((h_version == MPEG2_LSF) || (h_version == MPEG25_LSF)) tpf /= 2;
|
||||
return ((float) (tpf * 1000));
|
||||
}
|
||||
else
|
||||
{
|
||||
float ms_per_frame_array[][] = {{8.707483f, 8.0f, 12.0f},
|
||||
{26.12245f, 24.0f, 36.0f},
|
||||
{26.12245f, 24.0f, 36.0f}};
|
||||
return(ms_per_frame_array[h_layer-1][h_sample_frequency]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns total ms.
|
||||
*
|
||||
* @param streamsize
|
||||
* @return total milliseconds
|
||||
*/
|
||||
public float total_ms(int streamsize) // E.B
|
||||
{
|
||||
return(max_number_of_frames(streamsize) * ms_per_frame());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns synchronized header.
|
||||
*/
|
||||
public int getSyncHeader() // E.B
|
||||
{
|
||||
return _headerstring;
|
||||
}
|
||||
|
||||
// functions which return header informations as strings:
|
||||
/**
|
||||
* Return Layer version.
|
||||
*/
|
||||
public String layer_string()
|
||||
{
|
||||
switch (h_layer)
|
||||
{
|
||||
case 1:
|
||||
return "I";
|
||||
case 2:
|
||||
return "II";
|
||||
case 3:
|
||||
return "III";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// E.B -> private to public
|
||||
public static final String bitrate_str[][][] = {
|
||||
{{"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
|
||||
"80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s",
|
||||
"160 kbit/s", "176 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s",
|
||||
"forbidden"},
|
||||
{"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
|
||||
"40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
|
||||
"96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
|
||||
"forbidden"},
|
||||
{"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
|
||||
"40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
|
||||
"96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
|
||||
"forbidden"}},
|
||||
|
||||
{{"free format", "32 kbit/s", "64 kbit/s", "96 kbit/s", "128 kbit/s",
|
||||
"160 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s", "288 kbit/s",
|
||||
"320 kbit/s", "352 kbit/s", "384 kbit/s", "416 kbit/s", "448 kbit/s",
|
||||
"forbidden"},
|
||||
{"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
|
||||
"80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "160 kbit/s",
|
||||
"192 kbit/s", "224 kbit/s", "256 kbit/s", "320 kbit/s", "384 kbit/s",
|
||||
"forbidden"},
|
||||
{"free format", "32 kbit/s", "40 kbit/s", "48 kbit/s", "56 kbit/s",
|
||||
"64 kbit/s", "80 kbit/s" , "96 kbit/s", "112 kbit/s", "128 kbit/s",
|
||||
"160 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s", "320 kbit/s",
|
||||
"forbidden"}},
|
||||
// SZD: MPEG2.5
|
||||
{{"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
|
||||
"80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s",
|
||||
"160 kbit/s", "176 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s",
|
||||
"forbidden"},
|
||||
{"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
|
||||
"40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
|
||||
"96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
|
||||
"forbidden"},
|
||||
{"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
|
||||
"40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
|
||||
"96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
|
||||
"forbidden"}},
|
||||
};
|
||||
|
||||
/**
|
||||
* Return Bitrate.
|
||||
*
|
||||
* @return bitrate in bps
|
||||
*/
|
||||
public String bitrate_string()
|
||||
{
|
||||
if (h_vbr == true)
|
||||
{
|
||||
return Integer.toString(bitrate()/1000)+" kb/s";
|
||||
}
|
||||
else return bitrate_str[h_version][h_layer - 1][h_bitrate_index];
|
||||
}
|
||||
|
||||
/**
|
||||
* Return Bitrate.
|
||||
*
|
||||
* @return bitrate in bps and average bitrate for VBR header
|
||||
*/
|
||||
public int bitrate()
|
||||
{
|
||||
if (h_vbr == true)
|
||||
{
|
||||
return ((int) ((h_vbr_bytes * 8) / (ms_per_frame() * h_vbr_frames)))*1000;
|
||||
}
|
||||
else return bitrates[h_version][h_layer - 1][h_bitrate_index];
|
||||
}
|
||||
|
||||
/**
|
||||
* Return Instant Bitrate.
|
||||
* Bitrate for VBR is not constant.
|
||||
*
|
||||
* @return bitrate in bps
|
||||
*/
|
||||
public int bitrate_instant()
|
||||
{
|
||||
return bitrates[h_version][h_layer - 1][h_bitrate_index];
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns Frequency
|
||||
*
|
||||
* @return frequency string in kHz
|
||||
*/
|
||||
public String sample_frequency_string()
|
||||
{
|
||||
switch (h_sample_frequency)
|
||||
{
|
||||
case THIRTYTWO:
|
||||
if (h_version == MPEG1)
|
||||
return "32 kHz";
|
||||
else if (h_version == MPEG2_LSF)
|
||||
return "16 kHz";
|
||||
else // SZD
|
||||
return "8 kHz";
|
||||
case FOURTYFOUR_POINT_ONE:
|
||||
if (h_version == MPEG1)
|
||||
return "44.1 kHz";
|
||||
else if (h_version == MPEG2_LSF)
|
||||
return "22.05 kHz";
|
||||
else // SZD
|
||||
return "11.025 kHz";
|
||||
case FOURTYEIGHT:
|
||||
if (h_version == MPEG1)
|
||||
return "48 kHz";
|
||||
else if (h_version == MPEG2_LSF)
|
||||
return "24 kHz";
|
||||
else // SZD
|
||||
return "12 kHz";
|
||||
}
|
||||
return(null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns Mode.
|
||||
*/
|
||||
public String mode_string()
|
||||
{
|
||||
switch (h_mode)
|
||||
{
|
||||
case STEREO:
|
||||
return "Stereo";
|
||||
case JOINT_STEREO:
|
||||
return "Joint stereo";
|
||||
case DUAL_CHANNEL:
|
||||
return "Dual channel";
|
||||
case SINGLE_CHANNEL:
|
||||
return "Single channel";
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns Version.
|
||||
*
|
||||
* @return MPEG-1 or MPEG-2 LSF or MPEG-2.5 LSF
|
||||
*/
|
||||
public String version_string()
|
||||
{
|
||||
switch (h_version)
|
||||
{
|
||||
case MPEG1:
|
||||
return "MPEG-1";
|
||||
case MPEG2_LSF:
|
||||
return "MPEG-2 LSF";
|
||||
case MPEG25_LSF: // SZD
|
||||
return "MPEG-2.5 LSF";
|
||||
}
|
||||
return(null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the number of subbands in the current frame.
|
||||
*
|
||||
* @return number of subbands
|
||||
*/
|
||||
public int number_of_subbands() {return h_number_of_subbands;}
|
||||
|
||||
/**
|
||||
* Returns Intensity Stereo.
|
||||
* (Layer II joint stereo only).
|
||||
* Returns the number of subbands which are in stereo mode,
|
||||
* subbands above that limit are in intensity stereo mode.
|
||||
*
|
||||
* @return intensity
|
||||
*/
|
||||
public int intensity_stereo_bound() {return h_intensity_stereo_bound;}
|
||||
}
|
||||
Reference in New Issue
Block a user