/*
 * 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 v4lk.lwbd.decoders.processing.jlayer;

/**
 * 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() {
		StringBuffer buffer = new StringBuffer(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 optionnal 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;
	}
}
