2 * 09/26/08 throw exception on subbband alloc error: Christopher G. Jennings (cjennings@acm.org)
4 * 11/19/04 1.0 moved to LGPL.
6 * 12/12/99 Initial version. Adapted from javalayer.java
7 * and Subband*.java. mdm@techie.com
9 * 02/28/99 Initial version : javalayer.java by E.B
10 *-----------------------------------------------------------------------
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU Library General Public License as published
13 * by the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU Library General Public License for more details.
21 * You should have received a copy of the GNU Library General Public
22 * License along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *----------------------------------------------------------------------
29 * Implements decoding of MPEG Audio Layer I frames.
31 class LayerIDecoder implements FrameDecoder
33 protected Bitstream stream;
34 protected Header header;
35 protected SynthesisFilter filter1, filter2;
36 protected Obuffer buffer;
37 protected int which_channels;
40 protected int num_subbands;
41 protected Subband[] subbands;
42 protected Crc16 crc = null; // new Crc16[1] to enable CRC checking.
44 public LayerIDecoder()
49 public void create(Bitstream stream0, Header header0,
50 SynthesisFilter filtera, SynthesisFilter filterb,
51 Obuffer buffer0, int which_ch0)
58 which_channels = which_ch0;
62 public void decodeFrame() throws DecoderException
65 num_subbands = header.number_of_subbands();
66 subbands = new Subband[32];
72 readScaleFactorSelection();
74 if ((crc != null) || header.checksum_ok())
83 protected void createSubbands()
86 if (mode == Header.SINGLE_CHANNEL)
87 for (i = 0; i < num_subbands; ++i)
88 subbands[i] = new SubbandLayer1(i);
89 else if (mode == Header.JOINT_STEREO)
91 for (i = 0; i < header.intensity_stereo_bound(); ++i)
92 subbands[i] = new SubbandLayer1Stereo(i);
93 for (; i < num_subbands; ++i)
94 subbands[i] = new SubbandLayer1IntensityStereo(i);
98 for (i = 0; i < num_subbands; ++i)
99 subbands[i] = new SubbandLayer1Stereo(i);
103 protected void readAllocation() throws DecoderException
105 // start to read audio data:
106 for (int i = 0; i < num_subbands; ++i)
107 subbands[i].read_allocation(stream, header, crc);
111 protected void readScaleFactorSelection()
113 // scale factor selection not present for layer I.
116 protected void readScaleFactors()
118 for (int i = 0; i < num_subbands; ++i)
119 subbands[i].read_scalefactor(stream, header);
122 protected void readSampleData()
124 boolean read_ready = false;
125 boolean write_ready = false;
126 int mode = header.mode();
130 for (i = 0; i < num_subbands; ++i)
131 read_ready = subbands[i].read_sampledata(stream);
134 for (i = 0; i < num_subbands; ++i)
135 write_ready = subbands[i].put_next_sample(which_channels,filter1, filter2);
137 filter1.calculate_pcm_samples(buffer);
138 if ((which_channels == OutputChannels.BOTH_CHANNELS) && (mode != Header.SINGLE_CHANNEL))
139 filter2.calculate_pcm_samples(buffer);
140 } while (!write_ready);
141 } while (!read_ready);
146 * Abstract base class for subband classes of layer I and II
148 static abstract class Subband
151 * Changes from version 1.1 to 1.2:
152 * - array size increased by one, although a scalefactor with index 63
153 * is illegal (to prevent segmentation faults)
155 // Scalefactors for layer I and II, Annex 3-B.1 in ISO/IEC DIS 11172:
156 public static final float scalefactors[] =
158 2.00000000000000f, 1.58740105196820f, 1.25992104989487f, 1.00000000000000f,
159 0.79370052598410f, 0.62996052494744f, 0.50000000000000f, 0.39685026299205f,
160 0.31498026247372f, 0.25000000000000f, 0.19842513149602f, 0.15749013123686f,
161 0.12500000000000f, 0.09921256574801f, 0.07874506561843f, 0.06250000000000f,
162 0.04960628287401f, 0.03937253280921f, 0.03125000000000f, 0.02480314143700f,
163 0.01968626640461f, 0.01562500000000f, 0.01240157071850f, 0.00984313320230f,
164 0.00781250000000f, 0.00620078535925f, 0.00492156660115f, 0.00390625000000f,
165 0.00310039267963f, 0.00246078330058f, 0.00195312500000f, 0.00155019633981f,
166 0.00123039165029f, 0.00097656250000f, 0.00077509816991f, 0.00061519582514f,
167 0.00048828125000f, 0.00038754908495f, 0.00030759791257f, 0.00024414062500f,
168 0.00019377454248f, 0.00015379895629f, 0.00012207031250f, 0.00009688727124f,
169 0.00007689947814f, 0.00006103515625f, 0.00004844363562f, 0.00003844973907f,
170 0.00003051757813f, 0.00002422181781f, 0.00001922486954f, 0.00001525878906f,
171 0.00001211090890f, 0.00000961243477f, 0.00000762939453f, 0.00000605545445f,
172 0.00000480621738f, 0.00000381469727f, 0.00000302772723f, 0.00000240310869f,
173 0.00000190734863f, 0.00000151386361f, 0.00000120155435f, 0.00000000000000f /* illegal scalefactor */
176 public abstract void read_allocation (Bitstream stream, Header header, Crc16 crc) throws DecoderException;
177 public abstract void read_scalefactor (Bitstream stream, Header header);
178 public abstract boolean read_sampledata (Bitstream stream);
179 public abstract boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2);
183 * Class for layer I subbands in single channel mode.
184 * Used for single channel mode
185 * and in derived class for intensity stereo mode
187 static class SubbandLayer1 extends Subband
190 // Factors and offsets for sample requantization
191 public static final float table_factor[] = {
192 0.0f, (1.0f/2.0f) * (4.0f/3.0f), (1.0f/4.0f) * (8.0f/7.0f), (1.0f/8.0f) * (16.0f/15.0f),
193 (1.0f/16.0f) * (32.0f/31.0f), (1.0f/32.0f) * (64.0f/63.0f), (1.0f/64.0f) * (128.0f/127.0f),
194 (1.0f/128.0f) * (256.0f/255.0f), (1.0f/256.0f) * (512.0f/511.0f),
195 (1.0f/512.0f) * (1024.0f/1023.0f), (1.0f/1024.0f) * (2048.0f/2047.0f),
196 (1.0f/2048.0f) * (4096.0f/4095.0f), (1.0f/4096.0f) * (8192.0f/8191.0f),
197 (1.0f/8192.0f) * (16384.0f/16383.0f), (1.0f/16384.0f) * (32768.0f/32767.0f)
200 public static final float table_offset[] = {
201 0.0f, ((1.0f/2.0f)-1.0f) * (4.0f/3.0f), ((1.0f/4.0f)-1.0f) * (8.0f/7.0f), ((1.0f/8.0f)-1.0f) * (16.0f/15.0f),
202 ((1.0f/16.0f)-1.0f) * (32.0f/31.0f), ((1.0f/32.0f)-1.0f) * (64.0f/63.0f), ((1.0f/64.0f)-1.0f) * (128.0f/127.0f),
203 ((1.0f/128.0f)-1.0f) * (256.0f/255.0f), ((1.0f/256.0f)-1.0f) * (512.0f/511.0f),
204 ((1.0f/512.0f)-1.0f) * (1024.0f/1023.0f), ((1.0f/1024.0f)-1.0f) * (2048.0f/2047.0f),
205 ((1.0f/2048.0f)-1.0f) * (4096.0f/4095.0f), ((1.0f/4096.0f)-1.0f) * (8192.0f/8191.0f),
206 ((1.0f/8192.0f)-1.0f) * (16384.0f/16383.0f), ((1.0f/16384.0f)-1.0f) * (32768.0f/32767.0f)
209 protected int subbandnumber;
210 protected int samplenumber;
211 protected int allocation;
212 protected float scalefactor;
213 protected int samplelength;
214 protected float sample;
215 protected float factor, offset;
220 public SubbandLayer1(int subbandnumber)
222 this.subbandnumber = subbandnumber;
229 public void read_allocation(Bitstream stream, Header header, Crc16 crc) throws DecoderException
231 if ((allocation = stream.get_bits (4)) == 15)
233 // CGJ: catch this condition and throw appropriate exception
234 throw new DecoderException(DecoderErrors.ILLEGAL_SUBBAND_ALLOCATION, null);
235 // cerr << "WARNING: stream contains an illegal allocation!\n";
236 // MPEG-stream is corrupted!
239 if (crc != null) crc.add_bits (allocation, 4);
242 samplelength = allocation + 1;
243 factor = table_factor[allocation];
244 offset = table_offset[allocation];
251 public void read_scalefactor(Bitstream stream, Header header)
253 if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
259 public boolean read_sampledata(Bitstream stream)
263 sample = (float) (stream.get_bits(samplelength));
265 if (++samplenumber == 12)
276 public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
278 if ((allocation !=0) && (channels != OutputChannels.RIGHT_CHANNEL))
280 float scaled_sample = (sample * factor + offset) * scalefactor;
281 filter1.input_sample (scaled_sample, subbandnumber);
288 * Class for layer I subbands in joint stereo mode.
290 static class SubbandLayer1IntensityStereo extends SubbandLayer1
292 protected float channel2_scalefactor;
297 public SubbandLayer1IntensityStereo(int subbandnumber)
299 super(subbandnumber);
305 public void read_allocation(Bitstream stream, Header header, Crc16 crc) throws DecoderException
307 super.read_allocation (stream, header, crc);
313 public void read_scalefactor (Bitstream stream, Header header)
317 scalefactor = scalefactors[stream.get_bits(6)];
318 channel2_scalefactor = scalefactors[stream.get_bits(6)];
325 public boolean read_sampledata(Bitstream stream)
327 return super.read_sampledata (stream);
333 public boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2)
337 sample = sample * factor + offset; // requantization
338 if (channels == OutputChannels.BOTH_CHANNELS)
340 float sample1 = sample * scalefactor,
341 sample2 = sample * channel2_scalefactor;
342 filter1.input_sample(sample1, subbandnumber);
343 filter2.input_sample(sample2, subbandnumber);
345 else if (channels == OutputChannels.LEFT_CHANNEL)
347 float sample1 = sample * scalefactor;
348 filter1.input_sample(sample1, subbandnumber);
352 float sample2 = sample * channel2_scalefactor;
353 filter1.input_sample(sample2, subbandnumber);
361 * Class for layer I subbands in stereo mode.
363 static class SubbandLayer1Stereo extends SubbandLayer1
365 protected int channel2_allocation;
366 protected float channel2_scalefactor;
367 protected int channel2_samplelength;
368 protected float channel2_sample;
369 protected float channel2_factor, channel2_offset;
375 public SubbandLayer1Stereo(int subbandnumber)
377 super(subbandnumber);
383 public void read_allocation (Bitstream stream, Header header, Crc16 crc) throws DecoderException
385 allocation = stream.get_bits(4);
386 channel2_allocation = stream.get_bits(4);
389 crc.add_bits (allocation, 4);
390 crc.add_bits (channel2_allocation, 4);
394 samplelength = allocation + 1;
395 factor = table_factor[allocation];
396 offset = table_offset[allocation];
398 if (channel2_allocation != 0)
400 channel2_samplelength = channel2_allocation + 1;
401 channel2_factor = table_factor[channel2_allocation];
402 channel2_offset = table_offset[channel2_allocation];
409 public void read_scalefactor(Bitstream stream, Header header)
411 if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
412 if (channel2_allocation != 0) channel2_scalefactor = scalefactors[stream.get_bits(6)];
418 public boolean read_sampledata (Bitstream stream)
420 boolean returnvalue = super.read_sampledata(stream);
421 if (channel2_allocation != 0)
423 channel2_sample = (float) (stream.get_bits(channel2_samplelength));
431 public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
433 super.put_next_sample (channels, filter1, filter2);
434 if ((channel2_allocation != 0) && (channels != OutputChannels.LEFT_CHANNEL))
436 float sample2 = (channel2_sample * channel2_factor + channel2_offset) *
437 channel2_scalefactor;
438 if (channels == OutputChannels.BOTH_CHANNELS)
439 filter2.input_sample (sample2, subbandnumber);
441 filter1.input_sample (sample2, subbandnumber);