WaveSwissKnife 0.0.1.20101110-x86-cygwin

data/lib/WSK/Actions/ConstantCompare.rb

@@ -0,0 +1,61 @@
+#--
+# 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 Actions
+
+    class ConstantCompare
+
+      include WSK::Common
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        return 0
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        if (iInputData.NbrSamples != @NbrSamples)
+          logErr "Input data has #{iInputData.NbrSamples} samples. It should be #{@NbrSamples}"
+        end
+        lRawSample = iInputData.Header.getEncodedString([@Value]*iInputData.Header.NbrChannels)
+        lCompareBuffer = nil
+        lNbrSamplesProcessed = 0
+        iInputData.eachRawBuffer do |iRawBuffer, iNbrSamples, iNbrChannels|
+          if ((lCompareBuffer == nil) or
+              (lCompareBuffer.size != iRawBuffer.size))
+            # Create the comparison buffer
+            lCompareBuffer = lRawSample*iNbrSamples
+          end
+          if (lCompareBuffer != iRawBuffer)
+            logErr "Differences found between samples #{lNbrSamplesProcessed} and #{lNbrSamplesProcessed+iNbrSamples-1}"
+          end
+          lNbrSamplesProcessed += iNbrSamples
+          $stdout.write("#{(lNbrSamplesProcessed*100)/iInputData.NbrSamples} %\015")
+          $stdout.flush
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/Cut.desc.rb

@@ -0,0 +1,20 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :BeginSample => [
+      '--begin <BeginSample>', String,
+      '<BeginSample>: Index of sample to begin with [default = 0]. Can be specified in float seconds (ie. 12.3s).',
+      'Specify the first sample to write'
+    ],
+    :EndSample => [
+      '--end <EndSample>', String,
+      '<EndSample>: Index of sample to end with [default = 256]. Can be specified in float seconds (ie. 12.3s).',
+      'Specify the last sample to write'
+    ]
+  }
+}

data/lib/WSK/Actions/Cut.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
+
+  module Actions
+
+    class Cut
+
+      include WSK::Common
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        @IdxBeginSample = readDuration(@BeginSample, iInputData.Header.SampleRate)
+        @IdxEndSample = readDuration(@EndSample, iInputData.Header.SampleRate)
+
+        return @IdxEndSample-@IdxBeginSample+1
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        lChannelsSampleSize = (iInputData.Header.NbrChannels*iInputData.Header.NbrBitsPerSample)/8
+        lIdxFirstSample = @IdxBeginSample
+        iInputData.eachRawBuffer(@IdxBeginSample) do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+          # If the end sample is in this buffer, write only up to it
+          if (@IdxEndSample < lIdxFirstSample + iNbrSamples - 1)
+            oOutputData.pushRawBuffer(iInputRawBuffer[0..(@IdxEndSample-lIdxFirstSample+1)*lChannelsSampleSize-1])
+          else
+            oOutputData.pushRawBuffer(iInputRawBuffer)
+          end
+          if (@IdxEndSample < lIdxFirstSample + iNbrSamples)
+            # Nothing left to write
+            break
+          end
+          lIdxFirstSample += iNbrSamples
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/CutFirstSignal.desc.rb

@@ -0,0 +1,25 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :SilenceThreshold => [
+      '--silencethreshold <SilenceThreshold>', String,
+      '<SilenceThreshold>: Threshold to use to identify silent parts [default = 0]. It is possible to specify several values, for each channel, sperated with | (ie. 34|35). It is also possible to specify a range instead of a threshold with , (ie. -128,126 or -128,126|-127,132)',
+      'Specify the silence threshold'
+    ],
+    :NoiseFFTFileName => [
+      '--noisefft <FFTFile>', String,
+      '<FFTFile>: File containing the FFT profile of the reference noise. Can be set to \'none\' if no file.',
+      'This is used to compare potential noise profile with the real noise profile.'
+    ],
+    :SilenceMin => [
+      '--silencemin <SilenceDuration>', String,
+      '<SilenceDuration>: Silence duration in samples or in float seconds (ie. 234 or 25.3s).',
+      'Specify the minimum duration a silent part must have to be interpreted as a silence.'
+    ],
+  }
+}

data/lib/WSK/Actions/CutFirstSignal.rb

@@ -0,0 +1,72 @@
+#--
+# 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 Actions
+
+    class CutFirstSignal
+
+      include WSK::Common
+      include WSK::FFT
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        @IdxStartSample = 0
+        lSilenceThresholds = readThresholds(@SilenceThreshold, iInputData.Header.NbrChannels)
+        # Find the first signal
+        lIdxSignalSample, lIdxNextAboveThresholds = getNextNonSilentSample(iInputData, 0, lSilenceThresholds, nil, nil, false)
+        if (lIdxSignalSample == nil)
+          logWarn 'No signal found. Keeping the whole file.'
+        else
+          lNoiseFFTMaxDistance, lNoiseFFTProfile = readFFTProfile(@NoiseFFTFileName)
+          lSilenceDuration = readDuration(@SilenceMin, iInputData.Header.SampleRate)
+          lIdxSilenceSample, lSilenceLength, lIdxNextAboveThresholds = getNextSilentSample(iInputData, lIdxSignalSample, lSilenceThresholds, lSilenceDuration, lNoiseFFTProfile, lNoiseFFTMaxDistance, false)
+          if (lIdxSilenceSample == nil)
+            logWarn "No silence found after the signal beginning at #{lIdxSignalSample}. Keeping the whole file."
+          elsif (lSilenceLength == nil)
+            # Find the silence length by parsing following data
+            lIdxNonSilentSample, lIdxNextAboveThresholds = getNextNonSilentSample(iInputData, lIdxSilenceSample+1, lSilenceThresholds, lNoiseFFTProfile, lNoiseFFTMaxDistance, false)
+            if (lIdxNonSilentSample == nil)
+              # The file should be empty
+              @IdxStartSample = iInputData.NbrSamples-1
+            else
+              @IdxStartSample = lIdxNonSilentSample
+            end
+          else
+            @IdxStartSample = lIdxSilenceSample + lSilenceLength
+          end
+        end
+
+        return iInputData.NbrSamples-@IdxStartSample
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        iInputData.eachRawBuffer(@IdxStartSample) do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+          oOutputData.pushRawBuffer(iInputRawBuffer)
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/DCShifter.desc.rb

@@ -0,0 +1,15 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :Offset => [
+      '--offset <DCOffset>', String,
+      '<DCOffset>: Offset to use for the shift [default = 0]. It is possible to specify several values, for each channel, sperated with | (ie. 34|35).',
+      'Specify the offset'
+    ]
+  }
+}

data/lib/WSK/Actions/DCShifter.rb

@@ -0,0 +1,67 @@
+#--
+# 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 Actions
+
+    class DCShifter
+
+      include WSK::Maps
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        return iInputData.NbrSamples
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        # The offset, per channel
+        # list< Integer >
+        lOffsets = nil
+        if (@Offset.split('|').size == 1)
+          lOffsets = [@Offset.to_i] * iInputData.Header.NbrChannels
+        else
+          lOffsets = @Offset.split('|').map { |iStrValue| iStrValue.to_i }
+        end
+        
+        # List of functions to apply, per channel
+        lMaxValue = 2**(iInputData.Header.NbrBitsPerSample-1) - 1
+        lMinValue = -2**(iInputData.Header.NbrBitsPerSample-1)
+        lFunctions = []
+        lOffsets.each do |iOffset|
+          lFunctions << {
+            :FunctionType => WSK::Functions::FCTTYPE_PIECEWISE_LINEAR,
+            :MinValue => lMinValue,
+            :MaxValue => lMaxValue,
+            :Points => {
+              lMinValue => lMinValue + iOffset,
+              lMaxValue => lMaxValue + iOffset
+            }
+          }
+        end
+        applyMapFunctions(iInputData, oOutputData, lFunctions)
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/DrawFct.desc.rb

@@ -0,0 +1,20 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :FctFileName => [
+      '--function <FunctionFileName>', String,
+      '<FunctionFileName>: File containing the function definition',
+      'Specify the function to draw'
+    ],
+    :UnitDB => [
+      '--unitdb <Switch>', Integer,
+      '<Switch>: 0 means that units used in the function are ratios. 1 means that units used in the functions are db.',
+      'Specify the unit used in the function'
+    ]
+  }
+}

data/lib/WSK/Actions/DrawFct.rb

@@ -0,0 +1,59 @@
+#--
+# 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 Actions
+
+    class DrawFct
+
+      include WSK::Common
+      include WSK::Functions
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        @Function = WSK::Functions::Function.new
+        @Function.readFromFile(@FctFileName)
+        lMinX, lMinY, lMaxX, lMaxY = @Function.getBounds
+        @NbrSamplesOut = lMaxX.to_i-lMinX.to_i+1
+
+        return @NbrSamplesOut
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        rError = nil
+
+        # Then draw it
+        lMaxY = @Function.getBounds[3]
+        if (@UnitDB == 1)
+          lMaxY = (2**(lMaxY.to_f/6)).to_r
+        end
+        lMedianValue = ((2**(iInputData.Header.NbrBitsPerSample-1)-1)/lMaxY).to_i
+        logInfo "Draw function with maximal ratio #{lMaxY.to_f}, using median value #{lMedianValue}"
+        # Take the median value as a fraction of the maximal value
+        @Function.draw(iInputData, oOutputData, 0, @NbrSamplesOut-1, (@UnitDB == 1), lMedianValue)
+
+        return rError
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/FFT.rb

@@ -0,0 +1,104 @@
+#--
+# 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 Actions
+
+    class FFT
+
+      include WSK::Common
+      include WSK::FFT
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        return 0
+      end
+      
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+
+        # 1. Create the whole FFT profile
+        logInfo 'Creating FFT profile ...'
+        # Object that will create the FFT
+        lFFTComputing = FFTComputing.new(false, iInputData.Header)
+        # Parse the data
+        lIdxSample = 0
+        iInputData.eachRawBuffer do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+          lFFTComputing.completeFFT(iInputRawBuffer, iNbrSamples)
+          lIdxSample += iNbrSamples
+          $stdout.write("#{(lIdxSample*100)/iInputData.NbrSamples} %\015")
+          $stdout.flush
+        end
+        # Compute the result
+        require 'WSK/FFTUtils/FFTUtils'
+        lFFTUtils = FFTUtils::FFTUtils.new
+        lFFTProfile = lFFTComputing.getFFTProfile
+        lFFTReferenceProfile = lFFTUtils.createCFFTProfile(lFFTProfile)
+
+        # 2. Compute the distance obtained by comparing this profile with a normal file pass
+        logInfo 'Computing average distance ...'
+        lFFTComputing2 = FFTComputing.new(true, iInputData.Header)
+        lIdxSample = 0
+        lNbrTimes = 0
+        lSumDist = 0
+        while (lIdxSample < iInputData.NbrSamples)
+          # Compute the number of samples needed to have a valid FFT.
+          # Modify this number if it exceeds the range we have
+          lNbrSamplesFFTMax = iInputData.Header.SampleRate/FFTSAMPLE_FREQ
+          lIdxBeginFFTSample = lIdxSample
+          lIdxEndFFTSample = lIdxSample+lNbrSamplesFFTMax-1
+          if (lIdxEndFFTSample >= iInputData.NbrSamples)
+            lIdxEndFFTSample = iInputData.NbrSamples-1
+          end
+          lNbrSamplesFFT = lIdxEndFFTSample-lIdxBeginFFTSample+1
+          # Load an FFT buffer of this
+          lFFTBuffer = ''
+          iInputData.eachRawBuffer(lIdxBeginFFTSample, lIdxEndFFTSample, :NbrSamplesPrefetch => iInputData.NbrSamples-lIdxBeginFFTSample) do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+            lFFTBuffer.concat(iInputRawBuffer)
+          end
+          # Compute its FFT profile
+          lFFTComputing2.resetData
+          lFFTComputing2.completeFFT(lFFTBuffer, lNbrSamplesFFT)
+          lSumDist += lFFTUtils.distFFTProfiles(lFFTReferenceProfile, lFFTUtils.createCFFTProfile(lFFTComputing2.getFFTProfile), FFTDIST_MAX).abs
+          lNbrTimes += 1
+          lIdxSample = lIdxEndFFTSample+1
+          $stdout.write("#{(lIdxSample*100)/iInputData.NbrSamples} %\015")
+          $stdout.flush
+        end
+        lAverageDist = lSumDist/lNbrTimes
+        logDebug "Average distance with silence: #{lAverageDist}"
+
+        # Display results
+        (FREQINDEX_FIRST..FREQINDEX_LAST).each_with_index do |iIdx, iIdxFreq|
+          logDebug "[#{(440*(2**(iIdx/12.0))).round} Hz]: #{lFFTProfile[2][iIdxFreq].join(', ')}"
+        end
+
+        # Write the result in a file
+        File.open('fft.result', 'wb') do |oFile|
+          oFile.write(Marshal.dump([lAverageDist, lFFTProfile]))
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/GenAllValues.rb

@@ -0,0 +1,67 @@
+#--
+# 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 Actions
+
+    class GenAllValues
+
+      MAX_BUFFER_SAMPLES = 65536
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        @MaxValue = 2**(iInputData.Header.NbrBitsPerSample-1)-1
+        @MinValue = -2**(iInputData.Header.NbrBitsPerSample-1)
+
+        return @MaxValue-@MinValue+1
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        # Create buffer
+        lNbrBuffers = ((@MaxValue-@MinValue+1) / MAX_BUFFER_SAMPLES)+1
+        lSizeofLastBuffer = ((@MaxValue-@MinValue+1) % MAX_BUFFER_SAMPLES)
+        lIdxValue = @MinValue
+        logDebug "Will output #{@MaxValue-@MinValue+1} samples in #{lNbrBuffers} buffers."
+        lNbrBuffers.times do |iIdxBuffer|
+          lBuffer = []
+          lSamplesInBuffer = nil
+          if (iIdxBuffer == lNbrBuffers-1)
+            # The last one
+            lSamplesInBuffer = lSizeofLastBuffer
+          else
+            lSamplesInBuffer = MAX_BUFFER_SAMPLES
+          end
+          lSamplesInBuffer.times do |iIdxSampleBuffer|
+            iInputData.Header.NbrChannels.times do |iIdxChannel|
+              lBuffer << lIdxValue
+            end
+            lIdxValue += 1
+          end
+          oOutputData.pushBuffer(lBuffer)
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/GenConstant.desc.rb

@@ -0,0 +1,20 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :Value => [
+      '--value <Value>', Integer,
+      '<Value>: Constant value to write',
+      'Specify the value to write in the wave file.'
+    ],
+    :NbrSamples => [
+      '--nbrsamples <NbrSamples>', Integer,
+      '<NbrSamples>: Number of samples used to write this value',
+      'Specify the number of samples during the value will be written.'
+    ]
+  }
+}

data/lib/WSK/Actions/GenConstant.rb

@@ -0,0 +1,56 @@
+#--
+# 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 Actions
+
+    class GenConstant
+
+      MAX_BUFFER_SAMPLES = 65536
+
+      # Get the number of samples that will be written.
+      # This is called before execute, as it is needed to write the output file.
+      # It is possible to give a majoration: it will be padded with silence.
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # Return:
+      # * _Integer_: The number of samples to be written
+      def getNbrSamples(iInputData)
+        return @NbrSamples
+      end
+
+      # Execute
+      #
+      # Parameters:
+      # * *iInputData* (<em>WSK::Model::InputData</em>): The input data
+      # * *oOutputData* (_Object_): The output data to fill
+      # Return:
+      # * _Exception_: An error, or nil if success
+      def execute(iInputData, oOutputData)
+        lRawSample = iInputData.Header.getEncodedString([@Value]*iInputData.Header.NbrChannels)
+        # Write complete buffers
+        lNbrCompleteBuffers = @NbrSamples/MAX_BUFFER_SAMPLES
+        if (lNbrCompleteBuffers > 0)
+          lCompleteRawBuffer = lRawSample*MAX_BUFFER_SAMPLES
+          lNbrCompleteBuffers.times do |iIdx|
+            oOutputData.pushRawBuffer(lCompleteRawBuffer)
+          end
+        end
+        # Write last buffer
+        lLastBufferSize = @NbrSamples % MAX_BUFFER_SAMPLES
+        if (lLastBufferSize > 0)
+          oOutputData.pushRawBuffer(lRawSample*lLastBufferSize)
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end