Logo Search packages:      
Sourcecode: libjlayer-java version File versions  Download package

LayerIDecoder.java

/*
 * 11/19/04       1.0 moved to LGPL.
 * 
 * 12/12/99       Initial version. Adapted from javalayer.java
 *                      and Subband*.java. mdm@techie.com
 *
 * 02/28/99       Initial version : javalayer.java by E.B
 *-----------------------------------------------------------------------
 *   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;

/**
 * Implements decoding of MPEG Audio Layer I frames. 
 */
00030 class LayerIDecoder implements FrameDecoder
{
      protected Bitstream                 stream;
    protected Header                      header;
    protected SynthesisFilter             filter1, filter2;
    protected Obuffer                     buffer;
    protected int                               which_channels;
      protected int                             mode;
      
      protected int                             num_subbands;
      protected Subband[]                       subbands;
      protected Crc16                     crc   = null;     // new Crc16[1] to enable CRC checking.
      
      public LayerIDecoder()
      {
            crc = new Crc16();
      }
      
      public void create(Bitstream stream0, Header header0,
            SynthesisFilter filtera, SynthesisFilter filterb,
            Obuffer buffer0, int which_ch0)
      {           
            stream         = stream0;
            header         = header0;
            filter1        = filtera;
            filter2        = filterb;
            buffer         = buffer0;
            which_channels = which_ch0;
              
      }
      
      
      
00063       public void decodeFrame()
      {
            
            num_subbands = header.number_of_subbands();
            subbands = new Subband[32];
            mode = header.mode();
            
            createSubbands();
            
            readAllocation();
            readScaleFactorSelection();
            
          if ((crc != null) || header.checksum_ok())
            {
                  readScaleFactors();
                  
                  readSampleData();             
            }

      }

      protected void createSubbands()
      {           
            int i;
            if (mode == Header.SINGLE_CHANNEL)
              for (i = 0; i < num_subbands; ++i)
                subbands[i] = new SubbandLayer1(i);
            else if (mode == Header.JOINT_STEREO)
            {
              for (i = 0; i < header.intensity_stereo_bound(); ++i)
                subbands[i] = new SubbandLayer1Stereo(i);
              for (; i < num_subbands; ++i)
                subbands[i] = new SubbandLayer1IntensityStereo(i);
            }
            else
            {
              for (i = 0; i < num_subbands; ++i)
                subbands[i] = new SubbandLayer1Stereo(i);
          }       
      }
      
      protected void readAllocation()
      {
            // start to read audio data:
          for (int i = 0; i < num_subbands; ++i)
            subbands[i].read_allocation(stream, header, crc);
            
      }

      protected void readScaleFactorSelection()
      {
            // scale factor selection not present for layer I. 
      }
      
      protected void readScaleFactors()
      {
            for (int i = 0; i < num_subbands; ++i)
              subbands[i].read_scalefactor(stream, header);             
      }
      
      protected void readSampleData()
      {
            boolean read_ready = false;
            boolean write_ready = false;
            int mode = header.mode();
            int i;
            do
            {
              for (i = 0; i < num_subbands; ++i)
                  read_ready = subbands[i].read_sampledata(stream);
              do
              {
                  for (i = 0; i < num_subbands; ++i)
                        write_ready = subbands[i].put_next_sample(which_channels,filter1, filter2);

                  filter1.calculate_pcm_samples(buffer);
                  if ((which_channels == OutputChannels.BOTH_CHANNELS) && (mode != Header.SINGLE_CHANNEL))
                  filter2.calculate_pcm_samples(buffer);
              } while (!write_ready);
            } while (!read_ready);
            
      }

      /**
       * Abstract base class for subband classes of layer I and II
       */
00149       static abstract class Subband
      {
       /*
        *  Changes from version 1.1 to 1.2:
        *    - array size increased by one, although a scalefactor with index 63
        *      is illegal (to prevent segmentation faults)
        */
        // Scalefactors for layer I and II, Annex 3-B.1 in ISO/IEC DIS 11172:
        public static final float scalefactors[] =
        {
        2.00000000000000f, 1.58740105196820f, 1.25992104989487f, 1.00000000000000f,
        0.79370052598410f, 0.62996052494744f, 0.50000000000000f, 0.39685026299205f,
        0.31498026247372f, 0.25000000000000f, 0.19842513149602f, 0.15749013123686f,
        0.12500000000000f, 0.09921256574801f, 0.07874506561843f, 0.06250000000000f,
        0.04960628287401f, 0.03937253280921f, 0.03125000000000f, 0.02480314143700f,
        0.01968626640461f, 0.01562500000000f, 0.01240157071850f, 0.00984313320230f,
        0.00781250000000f, 0.00620078535925f, 0.00492156660115f, 0.00390625000000f,
        0.00310039267963f, 0.00246078330058f, 0.00195312500000f, 0.00155019633981f,
        0.00123039165029f, 0.00097656250000f, 0.00077509816991f, 0.00061519582514f,
        0.00048828125000f, 0.00038754908495f, 0.00030759791257f, 0.00024414062500f,
        0.00019377454248f, 0.00015379895629f, 0.00012207031250f, 0.00009688727124f,
        0.00007689947814f, 0.00006103515625f, 0.00004844363562f, 0.00003844973907f,
        0.00003051757813f, 0.00002422181781f, 0.00001922486954f, 0.00001525878906f,
        0.00001211090890f, 0.00000961243477f, 0.00000762939453f, 0.00000605545445f,
        0.00000480621738f, 0.00000381469727f, 0.00000302772723f, 0.00000240310869f,
        0.00000190734863f, 0.00000151386361f, 0.00000120155435f, 0.00000000000000f /* illegal scalefactor */
        };

        public abstract void read_allocation (Bitstream stream, Header header, Crc16 crc);
        public abstract void read_scalefactor (Bitstream stream, Header header);
        public abstract boolean read_sampledata (Bitstream stream);
        public abstract boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2);
      };
      
      /**
       * Class for layer I subbands in single channel mode.
       * Used for single channel mode
       * and in derived class for intensity stereo mode
       */
00188       static class SubbandLayer1 extends Subband
      {

        // Factors and offsets for sample requantization
        public static final float table_factor[] = {
         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),
        (1.0f/16.0f) * (32.0f/31.0f), (1.0f/32.0f) * (64.0f/63.0f), (1.0f/64.0f) * (128.0f/127.0f),
        (1.0f/128.0f) * (256.0f/255.0f), (1.0f/256.0f) * (512.0f/511.0f),
        (1.0f/512.0f) * (1024.0f/1023.0f), (1.0f/1024.0f) * (2048.0f/2047.0f),
        (1.0f/2048.0f) * (4096.0f/4095.0f), (1.0f/4096.0f) * (8192.0f/8191.0f),
        (1.0f/8192.0f) * (16384.0f/16383.0f), (1.0f/16384.0f) * (32768.0f/32767.0f)
        };

        public static final float table_offset[] = {
         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),
        ((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),
        ((1.0f/128.0f)-1.0f) * (256.0f/255.0f), ((1.0f/256.0f)-1.0f) * (512.0f/511.0f),
        ((1.0f/512.0f)-1.0f) * (1024.0f/1023.0f), ((1.0f/1024.0f)-1.0f) * (2048.0f/2047.0f),
        ((1.0f/2048.0f)-1.0f) * (4096.0f/4095.0f), ((1.0f/4096.0f)-1.0f) * (8192.0f/8191.0f),
        ((1.0f/8192.0f)-1.0f) * (16384.0f/16383.0f), ((1.0f/16384.0f)-1.0f) * (32768.0f/32767.0f)
        };

        protected int                subbandnumber;
        protected int                samplenumber;
        protected int                allocation;
        protected float        scalefactor;
        protected int          samplelength;
        protected float              sample;
        protected float              factor, offset;

        /**
         * Construtor.
         */
00221         public SubbandLayer1(int subbandnumber)
        {
          this.subbandnumber = subbandnumber;
          samplenumber = 0;  
        }
        
        /**
         *
         */
        public void read_allocation(Bitstream stream, Header header, Crc16 crc)
        {
          if ((allocation = stream.get_bits (4)) == 15) ;
            //     cerr << "WARNING: stream contains an illegal allocation!\n";
            // MPEG-stream is corrupted!
            if (crc != null)
                  crc.add_bits (allocation, 4);
            if (allocation != 0)
          {
             samplelength = allocation + 1;
             factor = table_factor[allocation];
           offset = table_offset[allocation];
          }
        }

        /**
         *
         */
        public void read_scalefactor(Bitstream stream, Header header)
        {
          if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
        }

        /**
         *
         */
        public boolean read_sampledata(Bitstream stream)
        {
          if (allocation != 0)
          {
               sample = (float) (stream.get_bits(samplelength));
          }
          if (++samplenumber == 12)
          {
               samplenumber = 0;
               return true;
          }
          return false;  
        }

        /**
         *
         */
        public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
        {
          if ((allocation !=0) && (channels != OutputChannels.RIGHT_CHANNEL))
          {
               float scaled_sample = (sample * factor + offset) * scalefactor;
               filter1.input_sample (scaled_sample, subbandnumber);
          }
          return true;
        }
      };
      
      /**
       * Class for layer I subbands in joint stereo mode.
       */
00287       static class SubbandLayer1IntensityStereo extends SubbandLayer1
      {
        protected float             channel2_scalefactor;

        /**
         * Constructor
         */
00294         public SubbandLayer1IntensityStereo(int subbandnumber)
        {
            super(subbandnumber);  
        }

        /**
         *
         */
        public void read_allocation(Bitstream stream, Header header, Crc16 crc)
        {
          super.read_allocation (stream, header, crc);
        }
        
        /**
         *
         */
        public void read_scalefactor (Bitstream stream, Header header)
        {
          if (allocation != 0)
          {
              scalefactor = scalefactors[stream.get_bits(6)];
              channel2_scalefactor = scalefactors[stream.get_bits(6)];
          }
        }

        /**
         *
         */
        public boolean read_sampledata(Bitstream stream)
        {
             return super.read_sampledata (stream);
        }
        
        /**
         *
         */
        public boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2)
        {
          if (allocation !=0 )
          {
            sample = sample * factor + offset;        // requantization
              if (channels == OutputChannels.BOTH_CHANNELS)
            {
                  float sample1 = sample * scalefactor,
                  sample2 = sample * channel2_scalefactor;
                  filter1.input_sample(sample1, subbandnumber);
                  filter2.input_sample(sample2, subbandnumber);
              }
              else if (channels == OutputChannels.LEFT_CHANNEL)
              {
                  float sample1 = sample * scalefactor;
                  filter1.input_sample(sample1, subbandnumber);
              }
              else
              {
                  float sample2 = sample * channel2_scalefactor;
                  filter1.input_sample(sample2, subbandnumber);
              }
          }
          return true;
        }
      };
      
      /**
       * Class for layer I subbands in stereo mode.
       */
00360       static class SubbandLayer1Stereo extends SubbandLayer1
      {
        protected int         channel2_allocation;
        protected float       channel2_scalefactor;
        protected int         channel2_samplelength;
        protected float       channel2_sample;
        protected float             channel2_factor, channel2_offset;


        /**
         * Constructor
         */
00372         public SubbandLayer1Stereo(int subbandnumber)
        {
          super(subbandnumber);
        }
        
        /**
         *
         */
        public void read_allocation (Bitstream stream, Header header, Crc16 crc)
        {
             allocation = stream.get_bits(4);
           channel2_allocation = stream.get_bits(4);
           if (crc != null)
           {
               crc.add_bits (allocation, 4);
             crc.add_bits (channel2_allocation, 4);
           }
           if (allocation != 0)
           {
                samplelength = allocation + 1;
              factor = table_factor[allocation];
              offset = table_offset[allocation];
           }
           if (channel2_allocation != 0)
           {
              channel2_samplelength = channel2_allocation + 1;
                channel2_factor = table_factor[channel2_allocation];
                channel2_offset = table_offset[channel2_allocation];
           }
        }
        
        /**
         *
         */
        public void read_scalefactor(Bitstream stream, Header header)
        {
          if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
          if (channel2_allocation != 0) channel2_scalefactor = scalefactors[stream.get_bits(6)];
        }

        /**
         *
         */
        public boolean read_sampledata (Bitstream stream)
        {
           boolean returnvalue = super.read_sampledata(stream);
           if (channel2_allocation != 0)
           {
                channel2_sample = (float) (stream.get_bits(channel2_samplelength));
            }
          return(returnvalue);
        }
        
        /**
         *
         */
        public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
        {
           super.put_next_sample (channels, filter1, filter2);
           if ((channel2_allocation != 0) && (channels != OutputChannels.LEFT_CHANNEL))
           {
                float sample2 = (channel2_sample * channel2_factor + channel2_offset) *
                                channel2_scalefactor;
                if (channels == OutputChannels.BOTH_CHANNELS)
                     filter2.input_sample (sample2, subbandnumber);
                else
                     filter1.input_sample (sample2, subbandnumber);
           }
           return true;
        }
      };
      
}

Generated by  Doxygen 1.6.0   Back to index