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

WaveFile.java

/*
 * 11/19/04 1.0 moved to LGPL.
 * 02/23/99 JavaConversion by E.B
 * Don Cross, April 1993.
 * RIFF file format classes.
 * See Chapter 8 of "Multimedia Programmer's Reference" in
 * the Microsoft Windows SDK.
 *  
 *-----------------------------------------------------------------------
 *   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.converter;

/**
 * Class allowing WaveFormat Access
 */
00031 public class WaveFile extends RiffFile
{
    public static final int   MAX_WAVE_CHANNELS = 2;
    
      class WaveFormat_ChunkData
      {
         public short         wFormatTag = 0;       // Format category (PCM=1)
         public short         nChannels = 0;        // Number of channels (mono=1, stereo=2)
         public int           nSamplesPerSec = 0;   // Sampling rate [Hz]
         public int           nAvgBytesPerSec = 0;
         public short         nBlockAlign = 0;
         public short         nBitsPerSample = 0;
         
         public WaveFormat_ChunkData()
         {
            wFormatTag = 1;     // PCM
            Config(44100,(short)16,(short)1);
            }

         public void Config (int NewSamplingRate, short NewBitsPerSample, short NewNumChannels)
       {
              nSamplesPerSec  = NewSamplingRate;
              nChannels       = NewNumChannels;
              nBitsPerSample  = NewBitsPerSample;
              nAvgBytesPerSec = (nChannels * nSamplesPerSec * nBitsPerSample) / 8;
              nBlockAlign     = (short) ((nChannels * nBitsPerSample) / 8);
       }
   }


      class WaveFormat_Chunk
      {
            public RiffChunkHeader         header;
            public WaveFormat_ChunkData    data;

            public WaveFormat_Chunk()
            {
                header = new RiffChunkHeader();
                data = new WaveFormat_ChunkData();
                  header.ckID     =   FourCC("fmt ");
                  header.ckSize   =   16;
            }

            public int VerifyValidity()
            {
                boolean ret = header.ckID == FourCC("fmt ") &&

            (data.nChannels == 1 || data.nChannels == 2) &&

             data.nAvgBytesPerSec == ( data.nChannels *
                                       data.nSamplesPerSec *
                                       data.nBitsPerSample    ) / 8   &&

             data.nBlockAlign == ( data.nChannels *
                                   data.nBitsPerSample ) / 8;
            if (ret == true) return 1;
            else return 0;
            }
      }

      public class WaveFileSample
      {
            public short[]                      chan;
            
            public WaveFileSample()
            {chan = new short[WaveFile.MAX_WAVE_CHANNELS];}
      }

   private WaveFormat_Chunk          wave_format;
   private RiffChunkHeader           pcm_data;
   private long                      pcm_data_offset = 0;  // offset of 'pcm_data' in output file
   private int                       num_samples = 0;


   /**
    * Constructs a new WaveFile instance. 
      */
00108    public WaveFile()
   {
       pcm_data = new RiffChunkHeader();
       wave_format = new WaveFormat_Chunk();
         pcm_data.ckID = FourCC("data");
         pcm_data.ckSize = 0;
         num_samples = 0;
   }

   /**
    *
      *
   public int OpenForRead (String Filename)
   {
      // Verify filename parameter as best we can...
      if (Filename == null)
      {
            return DDC_INVALID_CALL;
      }
      int retcode = Open ( Filename, RFM_READ );
   
      if ( retcode == DDC_SUCCESS )
      {
            retcode = Expect ( "WAVE", 4 );
   
            if ( retcode == DDC_SUCCESS )
          {
                  retcode = Read(wave_format,24);
   
                  if ( retcode == DDC_SUCCESS && !wave_format.VerifyValidity() )
                {
                        // This isn't standard PCM, so we don't know what it is!
                        retcode = DDC_FILE_ERROR;
                }
   
                if ( retcode == DDC_SUCCESS )
                {
                    pcm_data_offset = CurrentFilePosition();
   
                    // Figure out number of samples from
                    // file size, current file position, and
                    // WAVE header.
                    retcode = Read (pcm_data, 8 );
                    num_samples = filelength(fileno(file)) - CurrentFilePosition();
                    num_samples /= NumChannels();
                    num_samples /= (BitsPerSample() / 8);
                }
          }
     }
     return retcode;
   }*/

   /**
    *
      */
00163    public int OpenForWrite (String Filename, int SamplingRate, short BitsPerSample, short NumChannels)
   {
      // Verify parameters...
      if ( (Filename==null) ||
            (BitsPerSample != 8 && BitsPerSample != 16) ||
            NumChannels < 1 || NumChannels > 2 )
      {
            return DDC_INVALID_CALL;
      }
   
      wave_format.data.Config ( SamplingRate, BitsPerSample, NumChannels );
   
      int retcode = Open ( Filename, RFM_WRITE );
   
      if ( retcode == DDC_SUCCESS )
      {
        byte [] theWave = {(byte)'W',(byte)'A',(byte)'V',(byte)'E'};
            retcode = Write ( theWave, 4 );
   
            if ( retcode == DDC_SUCCESS )
            {
            // Ecriture de wave_format
            retcode = Write (wave_format.header, 8);   
            retcode = Write (wave_format.data.wFormatTag, 2);
            retcode = Write (wave_format.data.nChannels, 2);
            retcode = Write (wave_format.data.nSamplesPerSec, 4);
            retcode = Write (wave_format.data.nAvgBytesPerSec, 4);
            retcode = Write (wave_format.data.nBlockAlign, 2);
            retcode = Write (wave_format.data.nBitsPerSample, 2);
            /* byte[] br = new byte[16];
              br[0] = (byte) ((wave_format.data.wFormatTag >> 8) & 0x00FF);
            br[1] = (byte) (wave_format.data.wFormatTag & 0x00FF);
        
            br[2] = (byte) ((wave_format.data.nChannels >> 8) & 0x00FF);
              br[3] = (byte) (wave_format.data.nChannels & 0x00FF);
        
              br[4] = (byte) ((wave_format.data.nSamplesPerSec >> 24)& 0x000000FF);
              br[5] = (byte) ((wave_format.data.nSamplesPerSec >> 16)& 0x000000FF);
              br[6] = (byte) ((wave_format.data.nSamplesPerSec >> 8)& 0x000000FF);
              br[7] = (byte) (wave_format.data.nSamplesPerSec & 0x000000FF);
        
              br[8] = (byte) ((wave_format.data.nAvgBytesPerSec>> 24)& 0x000000FF);
              br[9] = (byte) ((wave_format.data.nAvgBytesPerSec >> 16)& 0x000000FF);
              br[10] = (byte) ((wave_format.data.nAvgBytesPerSec >> 8)& 0x000000FF);
              br[11] = (byte) (wave_format.data.nAvgBytesPerSec & 0x000000FF);

              br[12] = (byte) ((wave_format.data.nBlockAlign >> 8) & 0x00FF);
              br[13] = (byte) (wave_format.data.nBlockAlign & 0x00FF);
        
              br[14] = (byte) ((wave_format.data.nBitsPerSample >> 8) & 0x00FF);
              br[15] = (byte) (wave_format.data.nBitsPerSample & 0x00FF);                 
                  retcode = Write (br, 16); */
                  
   
                  if ( retcode == DDC_SUCCESS )
                  {
                        pcm_data_offset = CurrentFilePosition();
                        retcode = Write ( pcm_data, 8 );
                  }
            }
      }
   
      return retcode;
   }

   /**
    *
      *
   public int ReadSample ( short[] Sample )
   {
   
   }*/
   
   /**
    *
      *
   public int WriteSample( short[] Sample )
   {
      int retcode = DDC_SUCCESS;
      switch ( wave_format.data.nChannels )
      {
            case 1:
               switch ( wave_format.data.nBitsPerSample )
               {
                    case 8:
                           pcm_data.ckSize += 1;
                           retcode = Write ( Sample, 1 );
                           break;
   
                    case 16:
                           pcm_data.ckSize += 2;
                           retcode = Write ( Sample, 2 );
                           break;
   
                    default:
                           retcode = DDC_INVALID_CALL;
               }
               break;
   
            case 2:
               switch ( wave_format.data.nBitsPerSample )
               {
                    case 8:
                           retcode = Write ( Sample, 1 );
                           if ( retcode == DDC_SUCCESS )
                           {
                              // &Sample[1]
                                retcode = Write (Sample, 1 );
                                if ( retcode == DDC_SUCCESS )
                                {
                                     pcm_data.ckSize += 2;
                                }
                           }
                           break;
   
                    case 16:
                           retcode = Write ( Sample, 2 );
                           if ( retcode == DDC_SUCCESS )
                           {
                      // &Sample[1]
                                retcode = Write (Sample, 2 );
                                if ( retcode == DDC_SUCCESS )
                                {
                                     pcm_data.ckSize += 4;
                                }
                           }
                           break;
   
                    default:
                           retcode = DDC_INVALID_CALL;
               }
               break;
   
            default:
               retcode = DDC_INVALID_CALL;
      }
   
        return retcode;
      }*/
      
      /**
       *
       *
   public int SeekToSample ( long SampleIndex )
   {
      if ( SampleIndex >= NumSamples() )
      {
          return DDC_INVALID_CALL;
      }
      int SampleSize = (BitsPerSample() + 7) / 8;
      int rc = Seek ( pcm_data_offset + 8 +
                                SampleSize * NumChannels() * SampleIndex );
        return rc;
   }*/

   /**
    * Write 16-bit audio
      */
00321    public int WriteData ( short[] data, int numData )
   {
        int extraBytes = numData * 2;
        pcm_data.ckSize += extraBytes;
        return super.Write ( data, extraBytes );
   }

   /**
    * Read 16-bit audio.
      *
   public int ReadData  (short[] data, int numData)
   {return super.Read ( data, numData * 2);} */

   /**
    * Write 8-bit audio.
      *
   public int WriteData ( byte[] data, int numData )
   {
        pcm_data.ckSize += numData;
        return super.Write ( data, numData );
   }*/

   /**
    * Read 8-bit audio.
      *
   public int ReadData ( byte[] data, int numData )
   {return super.Read ( data, numData );} */
   
   
   /**
    *
      *
   public int ReadSamples  (int num, int [] WaveFileSample)
   {
   
   }*/

   /**
    *
      *
   public int WriteMonoSample ( short[] SampleData )
   {
      switch ( wave_format.data.nBitsPerSample )
      {
            case 8:
               pcm_data.ckSize += 1;
               return Write ( SampleData, 1 );
   
            case 16:
               pcm_data.ckSize += 2;
               return Write ( SampleData, 2 );
      }
        return DDC_INVALID_CALL;
   }*/

   /**
    *
      *
   public int WriteStereoSample  ( short[] LeftSample, short[] RightSample )
   {
      int retcode = DDC_SUCCESS;
      switch ( wave_format.data.nBitsPerSample )
      {
            case 8:
               retcode = Write ( LeftSample, 1 );
               if ( retcode == DDC_SUCCESS )
               {
                    retcode = Write ( RightSample, 1 );
                    if ( retcode == DDC_SUCCESS )
                    {
                         pcm_data.ckSize += 2;
                    }
               }
               break;
   
            case 16:
               retcode = Write ( LeftSample, 2 );
               if ( retcode == DDC_SUCCESS )
               {
                    retcode = Write ( RightSample, 2 );
                    if ( retcode == DDC_SUCCESS )
                    {
                         pcm_data.ckSize += 4;
                    }
               }
               break;
   
            default:
               retcode = DDC_INVALID_CALL;
      }   
      return retcode;
   }*/
   
   /**
    *
      *
   public int ReadMonoSample ( short[] Sample )
   {
      int retcode = DDC_SUCCESS;
      switch ( wave_format.data.nBitsPerSample )
      {
            case 8:
               byte[] x = {0};
               retcode = Read ( x, 1 );
               Sample[0] = (short)(x[0]);
               break;
   
            case 16:
               retcode = Read ( Sample, 2 );
               break;
   
        default:
               retcode = DDC_INVALID_CALL;
      }
      return retcode;
   }*/

   /**
    *
      *
   public int ReadStereoSample ( short[] LeftSampleData, short[] RightSampleData )
   {
      int retcode = DDC_SUCCESS;
      byte[] x = new byte[2];
      short[] y = new short[2];
      switch ( wave_format.data.nBitsPerSample )
      {
            case 8:
               retcode = Read ( x, 2 );
               L[0] = (short) ( x[0] );
               R[0] = (short) ( x[1] );
               break;
   
          case 16:
               retcode = Read ( y, 4 );
               L[0] = (short) ( y[0] );
               R[0] = (short) ( y[1] );
               break;
   
          default:
               retcode = DDC_INVALID_CALL;
      }
       return retcode;
   }*/

   
   /**
    *
      */
00470    public int Close()
   {
      int rc = DDC_SUCCESS;
      
      if ( fmode == RFM_WRITE )
         rc = Backpatch ( pcm_data_offset, pcm_data, 8 );
      if ( rc == DDC_SUCCESS )
        rc = super.Close();
      return rc;
   }

   // [Hz]
   public int SamplingRate()
   {return wave_format.data.nSamplesPerSec;}

   public short BitsPerSample()
   {return wave_format.data.nBitsPerSample;}

   public short NumChannels()
   {return wave_format.data.nChannels;}

   public int NumSamples()
   {return num_samples;}

 
   /**
    * Open for write using another wave file's parameters...
      */
00498    public int OpenForWrite (String Filename, WaveFile OtherWave )
   {
      return OpenForWrite ( Filename,
                            OtherWave.SamplingRate(),
                            OtherWave.BitsPerSample(),
                            OtherWave.NumChannels() );
   }

   /**
    *
      */
00509    public long CurrentFilePosition()
   {
      return super.CurrentFilePosition();
   }

   /* public int FourCC(String ChunkName)
   {
      byte[] p = {0x20,0x20,0x20,0x20};
        ChunkName.getBytes(0,4,p,0);
        int ret = (((p[0] << 24)& 0xFF000000) | ((p[1] << 16)&0x00FF0000) | ((p[2] << 8)&0x0000FF00) | (p[3]&0x000000FF));
      return ret;
   }*/

}

Generated by  Doxygen 1.6.0   Back to index