WaveSwissKnife 0.2.0.20120302

data/lib/WSK/Actions/Analyze.rb

@@ -0,0 +1,176 @@
+#--
+# 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 Analyze
+
+      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)
+        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)
+        lMaxValue = 2**(iInputData.Header.NbrBitsPerSample-1)-1
+        lMinValue = 2**(iInputData.Header.NbrBitsPerSample-1)
+
+        # Require C extension
+        require 'WSK/AnalyzeUtils/AnalyzeUtils'
+        lAnalyzeUtils = AnalyzeUtils::AnalyzeUtils.new
+        # Initialize computing arrays
+        lCMaxValues = lAnalyzeUtils.init64bitsArray(iInputData.Header.NbrChannels, 0);
+        lCMinValues = lAnalyzeUtils.init64bitsArray(iInputData.Header.NbrChannels, lMinValue);
+        lCSumValues = lAnalyzeUtils.init64bitsArray(iInputData.Header.NbrChannels, 0);
+        lCAbsSumValues = lAnalyzeUtils.init64bitsArray(iInputData.Header.NbrChannels, 0);
+        lCSquareSumValues = lAnalyzeUtils.init128bitsArray(iInputData.Header.NbrChannels);
+        # Gather data
+        lNbrSamplesProcessed = 0
+        iInputData.each_raw_buffer do |iRawBuffer, iNbrSamples, iNbrChannels|
+          lAnalyzeUtils.completeAnalyze(iRawBuffer, iInputData.Header.NbrBitsPerSample, iNbrSamples, iNbrChannels, lCMaxValues, lCMinValues, lCSumValues, lCAbsSumValues, lCSquareSumValues)
+          lNbrSamplesProcessed += iNbrSamples
+          $stdout.write("#{(lNbrSamplesProcessed*100)/iInputData.NbrSamples} %\015")
+          $stdout.flush
+        end
+        # Get the Ruby arrays from the C ones
+        lMaxValues = lAnalyzeUtils.getRuby64bitsArray(lCMaxValues, iInputData.Header.NbrChannels);
+        lMinValues = lAnalyzeUtils.getRuby64bitsArray(lCMinValues, iInputData.Header.NbrChannels);
+        lSumValues = lAnalyzeUtils.getRuby64bitsArray(lCSumValues, iInputData.Header.NbrChannels);
+        lAbsSumValues = lAnalyzeUtils.getRuby64bitsArray(lCAbsSumValues, iInputData.Header.NbrChannels);
+        lSquareSumValues = lAnalyzeUtils.getRuby128bitsArray(lCSquareSumValues, iInputData.Header.NbrChannels);
+        # Compute values in DB scale also
+        lDBMinValues = []
+        lMinValues.each do |iValue|
+          lDBMinValues << val2db(iValue, lMinValue)[0]
+        end
+        lDBMaxValues = []
+        lMaxValues.each do |iValue|
+          lDBMaxValues << val2db(iValue, lMaxValue)[0]
+        end
+        lMoyValues = []
+        lDBMoyValues = []
+        lSumValues.each do |iValue|
+          lMoyValue = Float(iValue)/Float(iInputData.NbrSamples)
+          lMoyValues << lMoyValue
+          lDBMoyValues << val2db(lMoyValue, lMinValue)[0]
+        end
+        lAbsMoyValues = []
+        lDBAbsMoyValues = []
+        lAbsSumValues.each do |iValue|
+          lAbsMoyValue = Float(iValue)/Float(iInputData.NbrSamples)
+          lAbsMoyValues << lAbsMoyValue
+          lDBAbsMoyValues << val2db(lAbsMoyValue, lMinValue)[0]
+        end
+        lAbsMaxValues = []
+        lDBAbsMaxValues = []
+        lMinValues.each_with_index do |iValue, iIdx|
+          lAbsMinValue = iValue.abs
+          lAbsMaxValue = lMaxValues[iIdx].abs
+          lAbsMax = nil
+          if (lAbsMinValue > lAbsMaxValue)
+            lAbsMax = lAbsMinValue
+          else
+            lAbsMax = lAbsMaxValue
+          end
+          lAbsMaxValues << lAbsMax
+          lDBAbsMaxValues << val2db(lAbsMax, lMinValue)[0]
+        end
+        lAbsMaxValue = lAbsMaxValues.sort[-1]
+        lAbsMaxValueDB, lAbsMaxValuePC = val2db(lAbsMaxValue, lMinValue)
+        lAbsMoyValue = 0
+        lAbsMoyValues.each do |iValue|
+          lAbsMoyValue += iValue
+        end
+        lAbsMoyValue /= lAbsMoyValues.size
+        lAbsMoyValueDB, lAbsMoyValuePC = val2db(lAbsMoyValue, lMinValue)
+        lRMSValues = []
+        lDBRMSValues = []
+        lSquareSumValues.each do |iValue|
+          lRMSValue = Math.sqrt(iValue/iInputData.NbrSamples).round
+          lRMSValues << lRMSValue
+          lDBRMSValues << val2db(lRMSValue, lMinValue)[0]
+        end
+        lResult = {
+          :MinValues => lMinValues,
+          :MaxValues => lMaxValues,
+          :MoyValues => lMoyValues,
+          :DBMinValues => lDBMinValues,
+          :DBMaxValues => lDBMaxValues,
+          :DBMoyValues => lDBMoyValues,
+          :AbsMaxValues => lAbsMaxValues,
+          :AbsMoyValues => lAbsMoyValues,
+          :DBAbsMaxValues => lDBAbsMaxValues,
+          :DBAbsMoyValues => lDBAbsMoyValues,
+          :SampleRate => iInputData.Header.SampleRate,
+          :SampleSize => iInputData.Header.NbrBitsPerSample,
+          :NbrChannels => iInputData.Header.NbrChannels,
+          :DataRate => ((iInputData.Header.NbrChannels*iInputData.Header.NbrBitsPerSample)/8)*iInputData.Header.SampleRate,
+          :NbrDataSamples => iInputData.NbrSamples,
+          :DataLength => Float(iInputData.NbrSamples)/Float(iInputData.Header.SampleRate),
+          :AbsMaxValue => lAbsMaxValue,
+          :DBAbsMaxValue => lAbsMaxValueDB,
+          :PCAbsMaxValue => lAbsMaxValuePC,
+          :AbsMoyValue => lAbsMoyValue,
+          :DBAbsMoyValue => lAbsMoyValueDB,
+          :PCAbsMoyValue => lAbsMoyValuePC,
+          :MaxPossibleValue => lMaxValue,
+          :MinPossibleValue => lMinValue,
+          :RMSValues => lRMSValues,
+          :DBRMSValues => lDBRMSValues
+        }
+        # Display
+        log_info "Min values: #{lResult[:MinValues].join(', ')}"
+        log_info "Min values (db): #{lResult[:DBMinValues].join(', ')}"
+        log_info "Max values: #{lResult[:MaxValues].join(', ')}"
+        log_info "Max values (db): #{lResult[:DBMaxValues].join(', ')}"
+        log_info "Moy values (DC offset): #{lResult[:MoyValues].join(', ')}"
+        log_info "Moy values (DC offset) (db): #{lResult[:DBMoyValues].join(', ')}"
+        log_info "RMS values: #{lResult[:RMSValues].join(', ')}"
+        log_info "RMS values (db): #{lResult[:DBRMSValues].join(', ')}"
+        log_info "Abs Max values: #{lResult[:AbsMaxValues].join(', ')}"
+        log_info "Abs Max values (db): #{lResult[:DBAbsMaxValues].join(', ')}"
+        log_info "Abs Moy values: #{lResult[:AbsMoyValues].join(', ')}"
+        log_info "Abs Moy values (db): #{lResult[:DBAbsMoyValues].join(', ')}"
+        log_info ''
+        log_info 'Header:'
+        log_info "Sample rate: #{lResult[:SampleRate]}"
+        log_info "Sample size (bits): #{lResult[:SampleSize]}"
+        log_info "Number of channels: #{lResult[:NbrChannels]}"
+        log_info "Data rate: #{lResult[:DataRate]} bytes/sec"
+        log_info ''
+        log_info 'Data:'
+        log_info "Number of data samples: #{lResult[:NbrDataSamples]} (#{lResult[:DataLength]} secs)"
+        log_info "Maximal absolute value: #{lResult[:AbsMaxValue]} (#{lResult[:DBAbsMaxValue]} db) (#{lResult[:PCAbsMaxValue]} %)"
+        log_info "Mean absolute value: #{lResult[:AbsMoyValue]} (#{lResult[:DBAbsMoyValue]} db) (#{lResult[:PCAbsMoyValue]} %)"
+        # Write a result file
+        File.open('analyze.result', 'wb') do |oFile|
+          oFile.write(Marshal.dump(lResult))
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/ApplyMap.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 => {
+    :MapFileName => [
+      '--transformmap <MapFileName>', String,
+      '<MapFileName>: Name of the map file corresponding to the transform',
+      'Specify the file to take the transformation from.'
+    ]
+  }
+}

data/lib/WSK/Actions/ApplyMap.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 ApplyMap
+
+      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)
+        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)
+        lTransformMap = nil
+        File.open(@MapFileName, 'rb') do |iFile|
+          lTransformMap = Marshal.load(iFile.read)
+        end
+        iInputData.each_buffer do |iBuffer, iNbrSamples, iNbrChannels|
+          lTransformedBuffer = iBuffer.map do |iValue|
+            if (lTransformMap[iValue] == nil)
+              log_warn "Unknown value from the transform map: #{iValue}. Keeping it."
+              next iValue
+            else
+              next lTransformMap[iValue]
+            end
+          end
+          oOutputData.pushBuffer(lTransformedBuffer)
+        end
+
+        return nil
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,30 @@
+#--
+# 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 => {
+    :FctFileName => [
+      '--function <FunctionFileName>', String,
+      '<FunctionFileName>: File containing the function definition',
+      'Specify the function to apply'
+    ],
+    :Begin => [
+      '--begin <BeginPos>', String,
+      '<BeginPos>: Position to apply volume transformation from. Can be specified as a sample number or a float seconds (ie. 12.3s).',
+      'Specify the first sample that will have the function applied'
+    ],
+    :End => [
+      '--end <EndPos>', String,
+      '<EndPos>: Position to apply volume transformation to. Can be specified as a sample number or a float seconds (ie. 12.3s). -1 means to the end of file.',
+      'Specify the last sample that will have the function applied'
+    ],
+    :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/ApplyVolumeFct.rb

@@ -0,0 +1,72 @@
+#--
+# 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 ApplyVolumeFct
+
+      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 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
+
+        lIdxBegin = readDuration(@Begin, iInputData.Header.SampleRate)
+        lIdxEnd = readDuration(@End, iInputData.Header.SampleRate)
+        if (lIdxEnd == -1)
+          lIdxEnd = iInputData.NbrSamples - 1
+        end
+        if (lIdxEnd >= iInputData.NbrSamples)
+          rError = RuntimeError.new("Transformation ends at #{lIdxEnd}, superceeding last sample (#{iInputData.NbrSamples-1})")
+        else
+          lFunction = WSK::Functions::Function.new
+          begin
+            lFunction.read_from_file(@FctFileName)
+          rescue Exception
+            rError = $!
+          end
+          if (rError == nil)
+            # First, write samples before
+            iInputData.each_raw_buffer(0, lIdxBegin-1) do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+              oOutputData.pushRawBuffer(iInputRawBuffer)
+            end
+            # Then apply volume transformation
+            lFunction.apply_on_volume(iInputData, oOutputData, lIdxBegin, lIdxEnd, (@UnitDB == 1))
+            # Last, write samples after
+            iInputData.each_raw_buffer(lIdxEnd+1) do |iInputRawBuffer, iNbrSamples, iNbrChannels|
+              oOutputData.pushRawBuffer(iInputRawBuffer)
+            end
+          end
+        end
+
+        return rError
+      end
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,25 @@
+#--
+# 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 => {
+    :InputFileName2 => [
+      '--inputfile2 <FileName>', String,
+      '<FileName>: Second file name to compare with.',
+      'Specify the file to compare with. The resulting file will be (inputfile - inputfile2)*Coefficient.'
+    ],
+    :Coeff => [
+      '--coeff <Coefficient>', Integer,
+      '<Coefficient>: Coefficient to multiply the differences [default = 1]',
+      'Specify the multiplying coefficient.'
+    ],
+    :GenMap => [
+      '--genmap <Switch>', Integer,
+      '<Switch>: 0 or 1, turning off or on the map generation [default = 0]',
+      'If 1, a file (named Output.map) will be created, storing the distortion for each encountered value.'
+    ]
+  }
+}

data/lib/WSK/Actions/Compare.rb

@@ -0,0 +1,238 @@
+#--
+# 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 Compare
+
+      include WSK::Common
+      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)
+        rNbrSamples = iInputData.NbrSamples
+
+        # Get the second input file
+        lError = accessInputWaveFile(@InputFileName2) do |iInputHeader2, iInputData2|
+          rSubError = nil
+          # First check that headers are the same
+          if (iInputHeader2 != iInputData.Header)
+            rSubError = RuntimeError.new("Mismatch headers: First input file: #{iInputData.Header.inspect} Second input file: #{iInputHeader2.inspect}")
+          end
+          # Then we will return the maximal samples
+          if (iInputData2.NbrSamples > iInputData.NbrSamples)
+            log_warn "Second file has more samples (#{iInputData2.NbrSamples} > #{iInputData.NbrSamples})."
+            rNbrSamples = iInputData2.NbrSamples
+          elsif (iInputData2.NbrSamples < iInputData.NbrSamples)
+            log_warn "Second file has less samples (#{iInputData2.NbrSamples} < #{iInputData.NbrSamples})."
+          else
+            log_info 'Files have the same number of samples.'
+          end
+          next rSubError
+        end
+        if (lError != nil)
+          raise lError
+        end
+        @TotalNbrSamples = rNbrSamples
+
+        return rNbrSamples
+      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)
+        @NbrBitsPerSample = iInputData.Header.NbrBitsPerSample
+        @NbrChannels = iInputData.Header.NbrChannels
+        if (@GenMap == 1)
+          # We want to generate the map
+          @DistortionMap = [nil]*(2**@NbrBitsPerSample)
+        else
+          @DistortionMap = nil
+        end
+        # Measure the cumulative errors
+        @CumulativeErrors = 0
+        @MaxValue = 2**(@NbrBitsPerSample-1)-1
+        @MinValue = -2**(@NbrBitsPerSample-1)
+        # Get the second input file
+        rError = accessInputWaveFile(@InputFileName2) do |iInputHeader2, iInputData2|
+          # Loop on both files.
+          # !!! We count on the same buffer size for both files.
+          require 'WSK/ArithmUtils/ArithmUtils'
+          @ArithmUtils = WSK::ArithmUtils::ArithmUtils.new
+          # Initialize buffers
+          lNbrSamplesProcessed = 0
+          iInputData.each_raw_buffer do |iRawBuffer, iNbrSamples, iNbrChannels|
+            break
+          end
+          lRawBuffer1, lNbrSamples1, lNbrChannels = iInputData.get_current_raw_buffer
+          iInputData2.each_raw_buffer do |iRawBuffer, iNbrSamples, iNbrChannels|
+            break
+          end
+          lRawBuffer2, lNbrSamples2, lNbrChannels = iInputData2.get_current_raw_buffer
+          while ((lRawBuffer1 != nil) or
+                 (lRawBuffer2 != nil))
+            if (lRawBuffer1 == nil)
+              oOutputData.pushRawBuffer(lRawBuffer2)
+              lNbrSamplesProcessed += lNbrSamples2
+              if (lNbrSamplesProcessed == @TotalNbrSamples)
+                lRawBuffer2 = nil
+              end
+            elsif (lRawBuffer2 == nil)
+              computeInverseMap
+              oOutputData.pushRawBuffer(@ArithmUtils.applyMap(@InverseMap, lRawBuffer1, @NbrBitsPerSample, lNbrSamples1))
+              lNbrSamplesProcessed += lNbrSamples1
+              if (lNbrSamplesProcessed == @TotalNbrSamples)
+                lRawBuffer1 = nil
+              end
+            elsif (lNbrSamples1 == lNbrSamples2)
+              lOutputBuffer, lCumulativeErrors = @ArithmUtils.compareBuffers(
+                lRawBuffer1,
+                lRawBuffer2,
+                @NbrBitsPerSample,
+                @NbrChannels,
+                lNbrSamples1,
+                @Coeff,
+                @DistortionMap
+              )
+              oOutputData.pushRawBuffer(lOutputBuffer)
+              @CumulativeErrors += lCumulativeErrors
+              lNbrSamplesProcessed += lNbrSamples1
+              if (lNbrSamplesProcessed == @TotalNbrSamples)
+                lRawBuffer1 = nil
+                lRawBuffer2 = nil
+              end
+            elsif (lNbrSamples1 > lNbrSamples2)
+              lOutputBuffer, lCumulativeErrors = @ArithmUtils.compareBuffers(
+                lRawBuffer1[0..lRawBuffer2.size-1],
+                lRawBuffer2,
+                @NbrBitsPerSample,
+                @NbrChannels,
+                lNbrSamples1,
+                @Coeff,
+                @DistortionMap
+              )
+              oOutputData.pushRawBuffer(lOutputBuffer)
+              @CumulativeErrors += lCumulativeErrors
+              # Write remaining buffer (-Buffer1)
+              computeInverseMap
+              oOutputData.pushRawBuffer(@ArithmUtils.applyMap(@InverseMap, lRawBuffer1[lRawBuffer2.size..-1], @NbrBitsPerSample, lNbrSamples2 - lNbrSamples1))
+              # Buffer2 is finished
+              lRawBuffer2 = nil
+              lNbrSamplesProcessed += lNbrSamples1
+            else
+              lOutputBuffer, lCumulativeErrors = @ArithmUtils.compareBuffers(
+                lRawBuffer1,
+                lRawBuffer2[0..lRawBuffer1.size-1],
+                @NbrBitsPerSample,
+                @NbrChannels,
+                lNbrSamples1,
+                @Coeff,
+                @DistortionMap
+              )
+              oOutputData.pushRawBuffer(lOutputBuffer)
+              @CumulativeErrors += lCumulativeErrors
+              # Write remaining buffer (Buffer2)
+              oOutputData.pushRawBuffer(lRawBuffer2[lRawBuffer1.size..-1])
+              # Buffer1 is finished
+              lRawBuffer1 = nil
+              lNbrSamplesProcessed += lNbrSamples2
+            end
+            # Read next buffers if they are not finished
+            if (lRawBuffer1 != nil)
+              iInputData.each_raw_buffer(lNbrSamplesProcessed) do |iRawBuffer, iNbrSamples, iNbrChannels|
+                break
+              end
+              lRawBuffer1, lNbrSamples1, lNbrChannels = iInputData.get_current_raw_buffer
+            end
+            if (lRawBuffer2 != nil)
+              iInputData2.each_raw_buffer(lNbrSamplesProcessed) do |iRawBuffer, iNbrSamples, iNbrChannels|
+                break
+              end
+              lRawBuffer2, lNbrSamples2, lNbrChannels = iInputData2.get_current_raw_buffer
+            end
+          end
+        end
+        if (@DistortionMap != nil)
+          # Write the distortion map
+          log_info 'Generate distortion map in distortion.diffmap'
+          File.open('distortion.diffmap', 'wb') do |oFile|
+            oFile.write(Marshal.dump(@DistortionMap))
+          end
+          log_info 'Generate invert map in invert.map'
+          # We want to spot the values that are missing, and the duplicate values
+          lInvertMap = [nil]*(2**@NbrBitsPerSample)
+          (@MinValue .. @MaxValue).each do |iValue|
+            if (@DistortionMap[iValue] == nil)
+              log_warn "Value #{iValue} was not part of the input file"
+            else
+              lRecordedValue = iValue + @DistortionMap[iValue]
+              if (lInvertMap[lRecordedValue] == nil)
+                lInvertMap[lRecordedValue] = iValue
+              else
+                if (iValue.abs < lInvertMap[lRecordedValue].abs)
+                  log_warn "Recorded value #{lRecordedValue} is used for both input values #{iValue} and #{lInvertMap[lRecordedValue]}. Setting it to #{iValue}."
+                  lInvertMap[lRecordedValue] = iValue
+                else
+                  log_warn "Recorded value #{lRecordedValue} is used for both input values #{iValue} and #{lInvertMap[lRecordedValue]}. Keeping it to #{lInvertMap[lRecordedValue]}."
+                end
+              end
+            end
+          end
+          (@MinValue .. @MaxValue).each do |iValue|
+            if (lInvertMap[iValue] == nil)
+              log_warn "Missing value that has never been recorded: #{iValue}"
+            end
+          end
+          File.open('invert.map', 'wb') do |oFile|
+            oFile.write(Marshal.dump(lInvertMap))
+          end
+        end
+        puts "Cumulative errors: #{@CumulativeErrors} (#{Float(@CumulativeErrors*100)/Float(iInputData.NbrSamples*(2**@NbrBitsPerSample))} %)"
+
+        return rError
+      end
+
+      private
+
+      # Compute the inverse map
+      def computeInverseMap
+        if (defined?(@InverseMap) == nil)
+          # Compute the function that will perform inversion
+          lMaxValue = 2**(@NbrBitsPerSample-1) - 1
+          lMinValue = -2**(@NbrBitsPerSample-1)
+          @InverseMap = @ArithmUtils.createMapFromFunctions(
+            @NbrBitsPerSample,
+            [ {
+              :FunctionType => WSK::Functions::FCTTYPE_PIECEWISE_LINEAR,
+              :MinValue => lMinValue,
+              :MaxValue => lMaxValue,
+              :Points => {
+                lMinValue => -lMinValue,
+                lMaxValue => -lMaxValue
+              }
+            } ] * @NbrChannels
+          )
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/WSK/Actions/ConstantCompare.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 => {
+    :Value => [
+      '--value <Value>', Integer,
+      '<Value>: Constant value to compare with',
+      'Specify the value to compare with.'
+    ],
+    :NbrSamples => [
+      '--nbrsamples <NbrSamples>', Integer,
+      '<NbrSamples>: Number of samples used to compare with',
+      'Specify the number of samples the file should have.'
+    ]
+  }
+}