WaveSwissKnife 0.2.0.20120302

data/lib/WSK/Actions/GenSawtooth.rb

@@ -0,0 +1,57 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module Actions
+
+    class GenSawtooth
+
+      # 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 get_nbr_samples(iInputData)
+        return iInputData.Header.SampleRate
+      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)
+        # Compute values used to create sawtooth
+        lMaxValue = 2**(iInputData.Header.NbrBitsPerSample-1)-1
+        lMinValue = -2**(iInputData.Header.NbrBitsPerSample-1)
+        lMiddleSample = iInputData.Header.SampleRate/2
+        # Create buffer
+        lBuffer = []
+        iInputData.Header.SampleRate.times do |iIdxSample|
+          iInputData.Header.NbrChannels.times do |iIdxChannel|
+            if (iIdxSample < lMiddleSample)
+              lBuffer << (iIdxSample*lMaxValue)/lMiddleSample
+            else
+              lBuffer << lMinValue+(lMiddleSample-iIdxSample)*lMinValue/(iInputData.Header.SampleRate-lMiddleSample)
+            end
+          end
+        end
+        # Write buffer
+        oOutputData.pushBuffer(lBuffer)
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,20 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :Frequency => [
+      '--frequency <Frequency>', Integer,
+      '<Frequency>: Frequency of the sine wave (in Hz)',
+      'Specify the frequency of the generated sine wave.'
+    ],
+    :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/GenSine.rb

@@ -0,0 +1,73 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module Actions
+
+    class GenSine
+
+      # 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 get_nbr_samples(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)
+        # Compute values used to create sawtooth
+        lMaxValue = 2**(iInputData.Header.NbrBitsPerSample-1)-1
+        # Compute the number of complete periods to put in the samples we want
+        lNbrSamplesPeriod = iInputData.Header.SampleRate/@Frequency
+        lNbrPeriods = @NbrSamples/lNbrSamplesPeriod
+        lBuffer = nil
+        if (lNbrPeriods > 0)
+          # Generate a buffer with a omplete period in it
+          lBuffer = []
+          lNbrSamplesPeriod.times do |iIdx|
+            lBuffer.concat( [(Math.sin((2*Math::PI*iIdx)/lNbrSamplesPeriod)*lMaxValue).round] * iInputData.Header.NbrChannels )
+          end
+          # Write them
+          lNbrPeriods.times do |iIdx|
+            oOutputData.pushBuffer(lBuffer)
+          end
+        end
+        lRemainingSamples = @NbrSamples % lNbrSamplesPeriod
+        if (lRemainingSamples > 0)
+          # Add the remaining part of the buffer
+          if (lBuffer == nil)
+            # Generate a part of the buffer
+            lBuffer = []
+            lRemainingSamples.times do |iIdx|
+              lBuffer.concat( [(Math.sin((2*Math::PI*iIdx)/lNbrSamplesPeriod)*lMaxValue).round] * iInputData.Header.NbrChannels )
+            end
+            # Write it
+            oOutputData.pushBuffer(lBuffer)
+          else
+            # Write a part of the already generated buffer
+            oOutputData.pushBuffer(lBuffer[0..iInputData.Header.NbrChannels*lRemainingSamples-1])
+          end
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/Identity.rb

@@ -0,0 +1,43 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module Actions
+
+    class Identity
+
+      # 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 get_nbr_samples(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)
+        iInputData.each_raw_buffer do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+          oOutputData.pushRawBuffer(iInputRawBuffer)
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,15 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :MixFiles => [
+      '--files <FilesList>', String,
+      '<FilesList>: List of files to mix with the input file, with floating coefficients, separated with | (example: File1.wav|2|File2.wav|1.4|File3.wav|-1)',
+      'Specify the list of files to mix along with their coefficient. The input file has the coefficient 1. The coefficient can be negative to invert the file while mixing.'
+    ]
+  }
+}

data/lib/WSK/Actions/Mix.rb

@@ -0,0 +1,149 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module Actions
+
+    class Mix
+
+      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 get_nbr_samples(iInputData)
+        @NbrSamples = iInputData.NbrSamples
+        
+        # Decode the files list
+        # list< [ String, Float ] >
+        @LstFiles = []
+        lLstParams = @MixFiles.split('|')
+        if (lLstParams.size % 2 != 0)
+          raise RuntimeError, 'Invalid mix parameters. Example: File1.wav|1|File2.wav|0.4'
+        else
+          (lLstParams.size/2).times do |iIdxFile|
+            lFileName = lLstParams[iIdxFile*2]
+            lCoeff = lLstParams[iIdxFile*2+1].to_f
+            if (lCoeff == 0)
+              log_warn "File #{lFileName} has a null coefficient. It won't be part of the mix."
+            else
+              # Check if the file exists
+              if (File.exists?(lFileName))
+                # Check the file's header
+                lError = accessInputWaveFile(lFileName) do |iInputHeader2, iInputData2|
+                  rSubError = nil
+                  # Check that headers are the same
+                  if (iInputHeader2 != iInputData.Header)
+                    rSubError = RuntimeError.new("Mismatch headers with file #{lFileName}: First input file: #{iInputData.Header.inspect} Mix file: #{iInputHeader2.inspect}")
+                  end
+                  # OK, keep this file
+                  @LstFiles << [ lFileName, lCoeff ]
+                  if (iInputData2.NbrSamples > @NbrSamples)
+                    @NbrSamples = iInputData2.NbrSamples
+                  end
+                  next rSubError
+                end
+                if (lError != nil)
+                  raise lError
+                end
+              else
+                raise RuntimeError, "Missing file: #{lFileName}"
+              end
+            end
+          end
+        end
+        
+        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)
+        rError = nil
+        
+        # Store the list of opened files, and initialize it with the input data (first file)
+        # list< [ IO, InputData, Coeff, Buffer, NbrSamplesInBuffer ] >
+        lLstOpenedFiles = [ [ nil, iInputData, 1.0, nil, nil ] ]
+        @LstFiles.each do |iFileInfo|
+          iFileName, iCoeff = iFileInfo
+          lFileHandle = File.open(iFileName, 'rb')
+          rError, lHeader, lInputData = getWaveFileAccesses(lFileHandle)
+          if (rError == nil)
+            lLstOpenedFiles << [ lFileHandle, lInputData, iCoeff, nil, nil ]
+          else
+            break
+          end
+        end
+        if (rError == nil)
+          require 'WSK/ArithmUtils/ArithmUtils'
+          lArithmUtils = WSK::ArithmUtils::ArithmUtils.new
+          # Loop until we meet the maximal number of samples
+          # !!! We assume that buffers have the same size when read
+          # Initialize buffers
+          lLstOpenedFiles.each do |ioFileInfo|
+            lFileHandle, lInputData, lCoeff, lBuffer = ioFileInfo
+            lInputData.each_raw_buffer do |iRawBuffer, iNbrSamples, iNbrChannels|
+              break
+            end
+            lRawBuffer, lNbrSamples, lNbrChannels2 = lInputData.get_current_raw_buffer
+            ioFileInfo[3] = lRawBuffer
+            ioFileInfo[4] = lNbrSamples
+          end
+          # Sort the list based on the number of samples of each file.
+          # This is a prerequisite of the C function mixing.
+          lLstOpenedFiles.sort! do |iOF1, iOF2|
+            next (iOF2[1].NbrSamples <=> iOF1[1].NbrSamples)
+          end
+          lLstRemainingOpenedFiles = lLstOpenedFiles.clone
+          lNbrSamplesProcessed = 0
+          while (!lLstRemainingOpenedFiles.empty?)
+            # Mix all buffers
+            lMixRawBuffer, lNbrSamplesWritten = lArithmUtils.mixBuffers(lLstRemainingOpenedFiles, iInputData.Header.NbrBitsPerSample, iInputData.Header.NbrChannels)
+            # Remove the ones that don't have data anymore
+            lLstRemainingOpenedFiles.delete_if do |ioFileInfo|
+              lFileHandle, lInputData, lCoeff, lRawBuffer = ioFileInfo
+              rToBeDeleted = false
+              # Set the next buffer of this file
+              if (lNbrSamplesProcessed + lNbrSamplesWritten >= lInputData.NbrSamples)
+                # Close the handle if it is not the main input
+                if (lFileHandle != nil)
+                  lFileHandle.close
+                end
+                rToBeDeleted = true
+              else
+                # Read next Buffer
+                lInputData.each_raw_buffer(lNbrSamplesProcessed + lNbrSamplesWritten) do |iRawBuffer, iNbrSamples, iNbrChannels|
+                  break
+                end
+                lRawBuffer, lNbrSamples, lNbrChannels2 = lInputData.get_current_raw_buffer
+                ioFileInfo[3] = lRawBuffer
+                ioFileInfo[4] = lNbrSamples
+              end
+              next rToBeDeleted
+            end
+            oOutputData.pushRawBuffer(lMixRawBuffer)
+            lNbrSamplesProcessed += lNbrSamplesWritten
+          end
+        end
+        
+        return rError
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,15 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :Coeff => [
+      '--coeff <Coeff>', String,
+      '<Coeff>: Coefficient to apply in the form X/Y (ie. 4/3) or in db (ie. -3db)',
+      'Specify the multiplying coefficient'
+    ]
+  }
+}

data/lib/WSK/Actions/Multiply.rb

@@ -0,0 +1,73 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module Actions
+
+    class Multiply
+
+      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 get_nbr_samples(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)
+        rError = nil
+
+        lCoeff = nil
+        lMatch = @Coeff.match(/^(.*)db$/)
+        if (lMatch == nil)
+          lMatch = @Coeff.match(/^(\d*)\/(\d*)$/)
+          if (lMatch == nil)
+            log_err "Incorrect coefficient: #{@Coeff} is not in the form X/Y or in the form Xdb"
+            rError = RuntimeError.new("Incorrect coefficient: #{@Coeff} is not in the form X/Y or in the form Xdb")
+          else
+            lNum, lDenom = lMatch[1..2].map { |iStrValue| iStrValue.to_i }
+            lCoeff = Rational(lNum, lDenom)
+          end
+        else
+          lCoeff = 2**(lMatch[1].to_f/6)
+        end
+
+        if (rError == nil)
+          lMaxValue = 2**(iInputData.Header.NbrBitsPerSample-1) - 1
+          lMinValue = -2**(iInputData.Header.NbrBitsPerSample-1)
+          lFunction = {
+            :FunctionType => WSK::Functions::FCTTYPE_PIECEWISE_LINEAR,
+            :MinValue => lMinValue,
+            :MaxValue => lMaxValue,
+            :Points => {
+              lMinValue => (lMinValue*lCoeff).to_i,
+              lMaxValue => (lMaxValue*lCoeff).to_i
+            }
+          }
+          apply_map_functions(iInputData, oOutputData, [lFunction]*iInputData.Header.NbrChannels)
+        end
+
+        return rError
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,35 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# 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'
+    ],
+    :Attack => [
+      '--attack <AttackDuration>', String,
+      '<AttackDuration>: Attack duration in samples or in float seconds (ie. 234 or 25.3s).',
+      'Specify the attack duration after the silence. This will fadein the noise before the non-silent part.'
+    ],
+    :Release => [
+      '--release <ReleaseDuration>', String,
+      '<ReleaseDuration>: Release duration in samples or in float seconds (ie. 234 or 25.3s).',
+      'Specify the release duration before the silence. This will fadeout the noise after the non-silent part.'
+    ],
+    :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.'
+    ],
+    :NoiseFFTFileName => [
+      '--noisefft <FFTFile>', String,
+      '<FFTFile>: File containing the FFT profile of the reference noise.',
+      'This is used to compare potential noise profile with the real noise profile.'
+    ]
+  }
+}

data/lib/WSK/Actions/NoiseGate.rb

@@ -0,0 +1,129 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module WSK
+
+  module Actions
+
+    class NoiseGate
+
+      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 get_nbr_samples(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)
+        lSilenceThresholds = readThresholds(@SilenceThreshold, iInputData.Header.NbrChannels)
+        lAttackDuration = readDuration(@Attack, iInputData.Header.SampleRate)
+        lReleaseDuration = readDuration(@Release, iInputData.Header.SampleRate)
+        lSilenceDuration = readDuration(@SilenceMin, iInputData.Header.SampleRate)
+        lNoiseFFTMaxDistance, lNoiseFFTProfile = readFFTProfile(@NoiseFFTFileName)
+        # Create a map of the non silent parts
+        # list< [ Integer,                 Integer ] >
+        # list< [ IdxBeginNonSilentSample, IdxEndNonSilentSample ] >
+        lNonSilentParts = []
+        lIdxSample = 0
+        while (lIdxSample != nil)
+          lIdxNextSilence, lSilenceLength, lIdxNextBeyondThresholds = getNextSilentSample(iInputData, lIdxSample, lSilenceThresholds, lSilenceDuration, lNoiseFFTProfile, lNoiseFFTMaxDistance, false)
+          if (lIdxNextSilence == nil)
+            lNonSilentParts << [lIdxSample, iInputData.NbrSamples-1]
+          else
+            lNonSilentParts << [lIdxSample, lIdxNextSilence-1]
+          end
+          lIdxSample = lIdxNextBeyondThresholds
+        end
+        lStrNonSilentParts = lNonSilentParts.map { |iNonSilentInfo| "[#{iNonSilentInfo[0]/iInputData.Header.SampleRate}s - #{iNonSilentInfo[1]/iInputData.Header.SampleRate}s]" }
+        log_info "#{lNonSilentParts.size} non silent parts: #{lStrNonSilentParts[0..9].join(', ')}"
+        lStrDbgNonSilentParts = lNonSilentParts.map { |iNonSilentInfo| "[#{iNonSilentInfo[0]} - #{iNonSilentInfo[1]}]" }
+        log_debug "#{lNonSilentParts.size} non silent parts: #{lStrDbgNonSilentParts[0..9].join(', ')}"
+        # Now we write the non-silent parts, spaced with nulled parts, with fadeins and fadeouts around.
+        lNextSampleToWrite = 0
+        lNonSilentParts.each do |iNonSilentInfo|
+          iIdxBegin, iIdxEnd = iNonSilentInfo
+          # Compute the fadein buffer
+          lIdxBeginFadeIn = iIdxBegin - lAttackDuration
+          if (lIdxBeginFadeIn < 0)
+            lIdxBeginFadeIn = 0
+          end
+          # Write a blank buffer if needed
+          if (lIdxBeginFadeIn > lNextSampleToWrite)
+            log_debug "Write #{lIdxBeginFadeIn - lNextSampleToWrite} samples of silence"
+            oOutputData.pushRawBuffer("\000" * (((lIdxBeginFadeIn - lNextSampleToWrite)*iInputData.Header.NbrChannels*iInputData.Header.NbrBitsPerSample)/8))
+          end
+          lFadeInSize = iIdxBegin-lIdxBeginFadeIn
+          if (lFadeInSize > 0)
+            lBuffer = []
+            lIdxFadeSample = 0
+            iInputData.each(lIdxBeginFadeIn) do |iChannelValues|
+              if (lIdxFadeSample == lFadeInSize)
+                break
+              end
+              lBuffer.concat(iChannelValues.map { |iValue| (iValue*lIdxFadeSample)/lFadeInSize })
+              lIdxFadeSample += 1
+            end
+            log_debug "Write #{lBuffer.size/iInputData.Header.NbrChannels} samples of fadein."
+            oOutputData.pushBuffer(lBuffer)
+          else
+            log_debug 'Ignore empty fadein.'
+          end
+          # Write the file
+          log_debug "Write #{iIdxEnd-iIdxBegin+1} samples of audio."
+          iInputData.each_raw_buffer(iIdxBegin, iIdxEnd) do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+            oOutputData.pushRawBuffer(iInputRawBuffer)
+          end
+          # Write the fadeout buffer
+          lIdxEndFadeOut = iIdxEnd + lReleaseDuration
+          if (lIdxEndFadeOut >= iInputData.NbrSamples)
+            lIdxEndFadeOut = iInputData.NbrSamples - 1
+          end
+          lFadeOutSize = lIdxEndFadeOut-iIdxEnd
+          if (lFadeOutSize > 0)
+            lBuffer = []
+            lIdxFadeSample = 0
+            iInputData.each(iIdxEnd+1) do |iChannelValues|
+              if (lIdxFadeSample == lFadeOutSize)
+                break
+              end
+              lBuffer.concat(iChannelValues.map { |iValue| (iValue*(lFadeOutSize-lIdxFadeSample))/lFadeOutSize })
+              lIdxFadeSample += 1
+            end
+            log_debug "Write #{lBuffer.size/iInputData.Header.NbrChannels} samples of fadeout."
+            oOutputData.pushBuffer(lBuffer)
+          else
+            log_debug 'Ignore empty fadeout.'
+          end
+          lNextSampleToWrite = lIdxEndFadeOut + 1
+        end
+        # If there is remaining silence, write it
+        if (lNextSampleToWrite < iInputData.NbrSamples)
+          log_debug "Write #{iInputData.NbrSamples - lNextSampleToWrite} samples of last silence"
+          oOutputData.pushRawBuffer("\000" * (((iInputData.NbrSamples - lNextSampleToWrite)*iInputData.Header.NbrChannels*iInputData.Header.NbrBitsPerSample)/8))
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,20 @@
+#--
+# Copyright (c) 2009 - 2012 Muriel Salvan (muriel@x-aeon.com)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+{
+  :OutputInterface => 'DirectStream',
+  :Options => {
+    :BeginSilenceLength => [
+      '--begin <SilenceLength>', String,
+      '<SilenceLength>: Length of silence to insert in samples or in float seconds (ie. 234 or 25.3s)',
+      'Specify the number of samples to insert at the beginning of the audio data'
+    ],
+    :EndSilenceLength => [
+      '--end <SilenceLength>', String,
+      '<SilenceLength>: Length of silence to insert in samples or in float seconds (ie. 234 or 25.3s)',
+      'Specify the number of samples to insert at the end of the audio data'
+    ]
+  }
+}