WaveSwissKnife 0.0.1.20101110-x86-cygwin

data/lib/WSK/Model/InputData.rb

@@ -0,0 +1,193 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'WSK/Model/RawReader.rb'
+require 'WSK/Model/WaveReader.rb'
+
+module WSK
+
+  module Model
+
+    class InputData
+
+      # Number of samples in the data
+      #   Integer
+      attr_reader :NbrSamples
+
+      # Header of the input data
+      #   WSK::Model::Header
+      attr_reader :Header
+
+      # Constructor
+      #
+      # Parameters:
+      # * *iFile* (_IO_): The file descriptor. Don't use it externally as long as it is used by this class.
+      # * *iHeader* (<em>WSK::Model::Header</em>): Corresponding file header
+      def initialize(iFile, iHeader)
+        @File, @Header = iFile, iHeader
+        @NbrSamples = nil
+      end
+
+      # Check that data seems coherent, and initialize the cursor
+      #
+      # Return:
+      # * _Exception_: Error, or nil in case of success
+      def initCursor
+        rError = nil
+
+        # Size of a sample
+        # Integer
+        lSampleSize = (@Header.NbrChannels*@Header.NbrBitsPerSample)/8
+        # Read the size of the data
+        rError, lDataSize = RIFFReader.new(@File).setFilePos('data')
+        if (rError == nil)
+          # Check that the data size is coherent
+          if (lDataSize % lSampleSize == 0)
+            @NbrSamples = lDataSize / lSampleSize
+            @RawReader = RawReader.new(@File, @File.pos, lSampleSize, @NbrSamples)
+            @WaveReader = WaveReader.new(@RawReader, @Header)
+            logDebug "Number of samples: #{@NbrSamples}"
+          else
+            rError = RuntimeError.new("Data size (#{lDataSize} should be a multiple of #{lSampleSize} according to header.")
+          end
+        end
+
+        return rError
+      end
+
+      # Iterate through the samples
+      #
+      # Parameters:
+      # * *iIdxBeginSample* (_Integer_): Index of the first sample to begin with [optional = 0]
+      # * *CodeBlock*: The code called for each iteration:
+      # ** *iInputSampleData* (<em>list<Integer></em>): The list of values (1 per channel)
+      def each(iIdxBeginSample = 0)
+        eachBuffer(iIdxBeginSample) do |iBuffer, iNbrSamples|
+          iBuffer.size.times do |iIdxSample|
+            yield(iBuffer[iIdxSample*@Header.NbrChannels..(iIdxSample+1)*@Header.NbrChannels-1])
+          end
+        end
+      end
+
+      # Iterate through the buffers. This is far more efficient than iterating over samples.
+      #
+      # Parameters:
+      # * *iIdxBeginSample* (_Integer_): Index of the first sample to begin with [optional = 0]
+      # * *CodeBlock*: The code called for each iteration:
+      # ** *iInputBuffer* (<em>list<Integer></em>): The list of channel values
+      # ** *iNbrSamples* (_Integer_): The number of samples in this buffer
+      # ** *iNbrChannels* (_Integer_): The number of channels in this buffer
+      def eachBuffer(iIdxBeginSample = 0)
+        @WaveReader.eachBuffer(iIdxBeginSample) do |iBuffer, iNbrSamples|
+          yield(iBuffer, iNbrSamples, @Header.NbrChannels)
+        end
+      end
+
+      # Get the current buffer.
+      # !!! This must be called only if the buffer was previously initialized (call getSampleSata to do so).
+      #
+      # Return:
+      # * <em>list<Integer></em>: The list of channel values
+      # * _Integer_: The number of samples in this buffer
+      # * _Integer_: The number of channels in this buffer
+      def getCurrentBuffer
+        rBuffer, lIdxStartSample, lIdxEndSample = @WaveReader.getCurrentBuffer
+
+        return rBuffer, lIdxEndSample-lIdxStartSample+1, @Header.NbrChannels
+      end
+
+      # Get the current raw buffer.
+      # !!! This must be called only if the buffer was previously initialized (call eachRawBuffer to do so).
+      #
+      # Return:
+      # * _String_: The raw buffer
+      # * _Integer_: The number of samples in this buffer
+      # * _Integer_: The number of channels in this buffer
+      def getCurrentRawBuffer
+        rBuffer, lIdxStartSample, lIdxEndSample = @RawReader.getCurrentBuffer
+
+        return rBuffer, lIdxEndSample-lIdxStartSample+1, @Header.NbrChannels
+      end
+
+      # Iterate through the buffers in the reverse order. This is far more efficient than iterating over samples.
+      #
+      # Parameters:
+      # * *iIdxEndSample* (_Integer_): Index of the first sample to begin with [optional = @NbrSamples-1]
+      # * *CodeBlock*: The code called for each iteration:
+      # ** *iInputBuffer* (<em>list<Integer></em>): The list of channel values
+      # ** *iNbrSamples* (_Integer_): The number of samples in this buffer
+      # ** *iNbrChannels* (_Integer_): The number of channels in this buffer
+      def eachReverseBuffer(iIdxEndSample = @NbrSamples-1)
+        @WaveReader.eachReverseBuffer(0, iIdxEndSample) do |iBuffer, iNbrSamples|
+          yield(iBuffer, iNbrSamples, @Header.NbrChannels)
+        end
+      end
+
+      # Iterate through the buffers in raw mode (strings read directly without unpacking).
+      # This is far more efficient than iterating over samples or unpacked buffers.
+      #
+      # Parameters:
+      # * *iIdxBeginSample* (_Integer_): Index of the first sample to begin with [optional = 0]
+      # * *iIdxLastSample* (_Integer_): Index of the last sample to end with [optional = @NbrSamples-1]
+      # * *iOptions* (<em>map<Symbol,Object></em>): Additional options. See CachedBufferReader for documentation. [optional = {}]
+      # * *CodeBlock*: The code called for each iteration:
+      # ** *iInputRawBuffer* (_String_): The raw buffer
+      # ** *iNbrSamples* (_Integer_): The number of samples in this buffer
+      # ** *iNbrChannels* (_Integer_): The number of channels in this buffer
+      def eachRawBuffer(iIdxBeginSample = 0, iIdxLastSample = @NbrSamples-1, iOptions = {})
+        @RawReader.eachBuffer(iIdxBeginSample, iIdxLastSample, iOptions) do |iBuffer, iNbrSamples|
+          yield(iBuffer, iNbrSamples, @Header.NbrChannels)
+        end
+      end
+
+      # Iterate through the buffers in the reverse order in raw mode (strings read directly without unpacking).
+      # This is far more efficient than iterating over samples or unpacked buffers.
+      #
+      # Parameters:
+      # * *iIdxBeginSample* (_Integer_): Index of the first sample to begin with [optional = 0]
+      # * *iIdxLastSample* (_Integer_): Index of the last sample to end with [optional = @NbrSamples-1]
+      # * *iOptions* (<em>map<Symbol,Object></em>): Additional options. See CachedBufferReader for documentation. [optional = {}]
+      # * *CodeBlock*: The code called for each iteration:
+      # ** *iInputRawBuffer* (_String_): The raw buffer
+      # ** *iNbrSamples* (_Integer_): The number of samples in this buffer
+      # ** *iNbrChannels* (_Integer_): The number of channels in this buffer
+      def eachReverseRawBuffer(iIdxBeginSample = 0, iIdxLastSample = @NbrSamples-1, iOptions = {})
+        @RawReader.eachReverseBuffer(iIdxBeginSample, iIdxLastSample, iOptions) do |iBuffer, iNbrSamples|
+          yield(iBuffer, iNbrSamples, @Header.NbrChannels)
+        end
+      end
+
+      # Get a sample's data
+      #
+      # Parameters:
+      # * *iIdxSample* (_Integer_): Index of the sample to retrieve
+      # * *iOptions* (<em>map<Symbol,Object></em>): Additional options [optional = {}]
+      # ** *:ReverseBuffer* (_Boolean_): Do we load the previous buffer containing this sample if needed ? [optional = false]
+      # Return:
+      # * <em>list<Integer></em>: The list of values (1 per channel), or nil in case of error
+      def getSampleData(iIdxSample, iOptions = {})
+        rSampleData = nil
+
+        lReverseBuffer = (iOptions[:ReverseBuffer] != nil) ? iOptions[:ReverseBuffer] : false
+        if (lReverseBuffer)
+          @WaveReader.eachReverseBuffer(0, iIdxSample) do |iBuffer, iNbrSamples|
+            rSampleData = iBuffer[-@Header.NbrChannels..-1]
+            break
+          end
+        else
+          @WaveReader.eachBuffer(iIdxSample) do |iBuffer, iNbrSamples|
+            rSampleData = iBuffer[0..@Header.NbrChannels-1]
+            break
+          end
+        end
+
+        return rSampleData
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Model/RawReader.rb

@@ -0,0 +1,78 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'WSK/Model/CachedBufferReader'
+
+module WSK
+
+  module Model
+
+    # Implement a RAW file reader using cached buffer reader.
+    # Buffers returned are of type String.
+    class RawReader < CachedBufferReader
+
+      # Buffer size.
+      # It is expressed in bytes.
+      #   Integer
+      BUFFER_SIZE = 8388608
+
+      # Constructor
+      #
+      # Parameters:
+      # * *iFile* (_IO_): The file descriptor. Don't use it externally as long as it is used by this class.
+      # * *iFirstSampleFilePos* (_Integer_): Position in the file of the first sample
+      # * *iSampleSize* (_Integer_): Size of a single sample to read
+      # * *iNbrSamples* (_Integer_): Total number of samples
+      def initialize(iFile, iFirstSampleFilePos, iSampleSize, iNbrSamples)
+        @File, @FirstSampleFilePos, @SampleSize, @NbrSamples = iFile, iFirstSampleFilePos, iSampleSize, iNbrSamples
+        super()
+      end
+
+      # Get the number of samples read per buffer
+      #
+      # Return:
+      # * _Integer_: Nnumber of samples in 1 buffer
+      def getNbrSamplesPerBuffer
+        return BUFFER_SIZE/@SampleSize
+      end
+
+      # Get the total number of samples
+      #
+      # Return:
+      # * _Integer_: Total number of samples
+      def getNbrSamples
+        return @NbrSamples
+      end
+
+      # Read a buffer
+      #
+      # Parameters:
+      # * *iIdxStartSample* (_Integer_): Index of the first sample to begin with
+      # * *iIdxEndSample* (_Integer_): Index of the last sample to end with
+      # Return:
+      # * _Object_: The corresponding buffer
+      def readBuffer(iIdxStartSample, iIdxEndSample)
+        @File.seek(@FirstSampleFilePos + iIdxStartSample*@SampleSize)
+        logDebug "Raw read samples [#{iIdxStartSample} - #{iIdxEndSample}]"
+        return @File.read((iIdxEndSample-iIdxStartSample+1)*@SampleSize)
+      end
+
+      # Extract a sub-buffer for the given index range
+      #
+      # Parameters:
+      # * *iBuffer* (_Object_): The buffer to extract from
+      # * *iIdxStartSample* (_Integer_): Index of the first sample to begin with
+      # * *iIdxEndSample* (_Integer_): Index of the last sample to end with
+      # Return:
+      # * _Object_: The sub buffer
+      def extractSubBuffer(iBuffer, iIdxStartSample, iIdxEndSample)
+        return iBuffer[iIdxStartSample*@SampleSize..(iIdxEndSample+1)*@SampleSize-1]
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Model/WaveReader.rb

@@ -0,0 +1,91 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'WSK/Model/CachedBufferReader'
+
+module WSK
+
+  module Model
+
+    # Implement a Wave file reader using a raw buffer reader.
+    # Buffers returned are of type list<Integer>.
+    class WaveReader < CachedBufferReader
+
+      # Number of channel samples per buffer.
+      #   Integer
+      NBR_CHANNEL_SAMPLES_PER_BUFFER = 2097152
+
+      # Constructor
+      #
+      # Parameters:
+      # * *iRawReader* (_CachedBufferReader_): The reader that provides raw data
+      # * *iHeader* (<em>WSK::Model::Header</em>): Corresponding file header
+      def initialize(iRawReader, iHeader)
+        @RawReader, @Header = iRawReader, iHeader
+        super()
+      end
+
+      # Get the number of samples read per buffer
+      #
+      # Return:
+      # * _Integer_: Nnumber of samples in 1 buffer
+      def getNbrSamplesPerBuffer
+        return NBR_CHANNEL_SAMPLES_PER_BUFFER/@Header.NbrChannels
+      end
+
+      # Get the total number of samples
+      #
+      # Return:
+      # * _Integer_: Total number of samples
+      def getNbrSamples
+        return @RawReader.getNbrSamples
+      end
+
+      # Read a buffer
+      #
+      # Parameters:
+      # * *iIdxStartSample* (_Integer_): Index of the first sample to begin with
+      # * *iIdxEndSample* (_Integer_): Index of the last sample to end with
+      # Return:
+      # * _Object_: The corresponding buffer
+      def readBuffer(iIdxStartSample, iIdxEndSample)
+        lRawBuffer = nil
+        lNbrSamplesToRead = iIdxEndSample - iIdxStartSample + 1
+        @RawReader.eachBuffer(iIdxStartSample, iIdxEndSample) do |iBuffer, iNbrSamples|
+          if (lRawBuffer == nil)
+            if (lNbrSamplesToRead == iNbrSamples)
+              # We have the buffer directly. No copy.
+              lRawBuffer = iBuffer
+            else
+              # We will need to concatenate other buffers. Clone it.
+              lRawBuffer = iBuffer.clone
+            end
+          else
+            # Concatenate
+            lRawBuffer.concat(iBuffer)
+          end
+        end
+        logDebug "Decode samples [#{iIdxStartSample} - #{iIdxEndSample}]"
+        
+        return @Header.getDecodedSamples(lRawBuffer, lNbrSamplesToRead)
+      end
+
+      # Extract a sub-buffer for the given index range
+      #
+      # Parameters:
+      # * *iBuffer* (_Object_): The buffer to extract from
+      # * *iIdxStartSample* (_Integer_): Index of the first sample to begin with
+      # * *iIdxEndSample* (_Integer_): Index of the last sample to end with
+      # Return:
+      # * _Object_: The sub buffer
+      def extractSubBuffer(iBuffer, iIdxStartSample, iIdxEndSample)
+        return iBuffer[iIdxStartSample*@Header.NbrChannels..(iIdxEndSample+1)*@Header.NbrChannels-1]
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/OutputInterfaces/DirectStream.rb

@@ -0,0 +1,146 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module OutputInterfaces
+
+    class DirectStream
+
+      # Here we define the buffer size.
+      # The buffer will be used to store contiguous audio data in RAM.
+      # Each OutputData object will never use more than this size.
+      # It is expressed in bytes.
+      #   Integer
+      BUFFER_SIZE = 2097152
+
+      # Initialize the plugin
+      #
+      # Parameters:
+      # * *oFile* (_IO_): The file descriptor. Don't use it externally as long as it is used by this class.
+      # * *iHeader* (<em>WSK::Model::Header</em>): Corresponding file header
+      # * *iNbrOutputDataSamples* (_Integer_): The number of output data samples
+      # Return:
+      # * _Exception_: An error, or nil in case of success
+      def initInterface(oFile, iHeader, iNbrOutputDataSamples)
+        rError = nil
+
+        @File, @Header, @NbrSamples = oFile, iHeader, iNbrOutputDataSamples
+        @NbrSamplesWritten = 0
+        # Size of a sample
+        # Integer
+        @SampleSize = (@Header.NbrChannels*@Header.NbrBitsPerSample)/8
+        # Compute the number of samples to store in the buffer
+        @NbrSamplesPerBuffer = BUFFER_SIZE/@SampleSize
+        # The position of the last written sample in the buffer
+        # Integer
+        @IdxCurrentBufferSample = 0
+        # The buffer itself, list of channels values
+        # list< Integer >
+        @Buffer = []
+
+        return rError
+      end
+
+      # Finalize writing
+      #
+      # Return:
+      # * _Integer_: The number of samples written
+      def finalize
+        if (!@Buffer.empty?)
+          flushBuffer
+        end
+
+        return @NbrSamplesWritten
+      end
+
+      # Add a sample data
+      #
+      # Parameters:
+      # * *iSampleData* (<em>list<Integer></em>): The list of channel values for this sample
+      def pushSample(iSampleData)
+        # Write data in the buffer
+        @Buffer += iSampleData
+        @IdxCurrentBufferSample += 1
+        if (@IdxCurrentBufferSample == @NbrSamplesPerBuffer)
+          # We have to flush the buffer
+          flushBuffer
+        end
+      end
+
+      # Add a buffer
+      #
+      # Parameters:
+      # * *iBuffer* (<em>list<Integer></em>): The list of channel values for this buffer
+      def pushBuffer(iBuffer)
+        # Write data in the current buffer
+        @Buffer += iBuffer
+        @IdxCurrentBufferSample += iBuffer.size/@Header.NbrChannels
+        if (@IdxCurrentBufferSample >= @NbrSamplesPerBuffer)
+          # We have to flush the buffer
+          flushBuffer
+        end
+      end
+
+      # Add a raw buffer
+      #
+      # Parameters:
+      # * *iRawBuffer* (_String_): The raw buffer
+      def pushRawBuffer(iRawBuffer)
+        # First, flush eventually remaining buffer to encode
+        if (!@Buffer.empty?)
+          flushBuffer
+        end
+        # Then write our raw buffer
+        @File.write(iRawBuffer)
+        updateProgress(iRawBuffer.size/@SampleSize)
+      end
+
+      # Loop on a range of samples split into buffers
+      #
+      # Parameters:
+      # * *iIdxBeginSample* (_Integer_): The beginning sample
+      # * *iIdxEndSample* (_Integer_): The ending sample
+      # * _CodeBlock_: The code called for each buffer:
+      # ** *iIdxBeginBufferSample* (_Integer_): The beginning of this buffer's sample
+      # ** *iIdxEndBufferSample* (_Integer_): The ending of this buffer's sample
+      def eachBuffer(iIdxBeginSample, iIdxEndSample)
+        lIdxBeginBufferSample = iIdxBeginSample
+        while (lIdxBeginBufferSample <= iIdxEndSample)
+          lIdxEndBufferSample = lIdxBeginBufferSample + @NbrSamplesPerBuffer - 1
+          if (lIdxEndBufferSample > iIdxEndSample)
+            lIdxEndBufferSample = iIdxEndSample
+          end
+          yield(lIdxBeginBufferSample, lIdxEndBufferSample)
+          lIdxBeginBufferSample = lIdxEndBufferSample + 1
+        end
+      end
+
+      private
+
+      # Write the buffer to the disk
+      def flushBuffer
+        # Write it
+        @File.write(@Header.getEncodedString(@Buffer))
+        updateProgress(@Buffer.size/@Header.NbrChannels)
+        @IdxCurrentBufferSample = 0
+        @Buffer = []
+      end
+
+      # Add a samples' number to the progression
+      #
+      # Parameters:
+      # * *iNbrSamples* (_Integer_): Number of samples
+      def updateProgress(iNbrSamples)
+        @NbrSamplesWritten += iNbrSamples
+        $stdout.write("[#{(@NbrSamplesWritten*100)/@NbrSamples}%]\015")
+        $stdout.flush
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/RIFFReader.rb

@@ -0,0 +1,60 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  # Class reading RIFF files
+  class RIFFReader
+
+    # Constructor
+    #
+    # Parameters:
+    # * *iFile* (_IO_): File to read
+    def initialize(iFile)
+      @File = iFile
+    end
+
+    # Position the file on the data associated to a given RIFF name
+    #
+    # Parameters:
+    # * *iRIFFName* (_String_): The RIFF name
+    # Return:
+    # * _Exception_: An error, or nil in case of success
+    # * _Integer_: The RIFF chunk size
+    def setFilePos(iRIFFName)
+      rError = nil
+      rSize = nil
+
+      # Loop through the names until we find ours
+      @File.seek(12)
+      lRIFFName, rSize = @File.read(8).unpack('a4V')
+      lCurrentPos = 20
+      while (lRIFFName != nil)
+        if (lRIFFName == iRIFFName)
+          # We are positioned correctly
+          lRIFFName = nil
+          logDebug "Found RIFF chunk #{iRIFFName} of size #{rSize}"
+        else
+          logDebug "Skip RIFF chunk #{lRIFFName} of size #{rSize}"
+          # Go to the next chunk
+          @File.seek(lCurrentPos + rSize)
+          lData = @File.read(8)
+          lCurrentPos += rSize + 8
+          if (lData == nil)
+            # End of the file
+            rError = RuntimeError.new("End of file met: no RIFF #{iRIFFName} chunk found.")
+            lRIFFName = nil
+          else
+            lRIFFName, rSize = lData.unpack('a4V')
+          end
+        end
+      end
+
+      return rError, rSize
+    end
+
+  end
+
+end