MusicMaster 0.0.1.20101110

data/lib/MusicMaster/Common.rb

@@ -0,0 +1,197 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'fileutils'
+require 'rational'
+
+module MusicMaster
+
+  # Call WSK
+  #
+  # Parameters:
+  # * *iInputFile* (_String_): The input file
+  # * *iOutputFile* (_String_): The output file
+  # * *iAction* (_String_): The action
+  # * *iParams* (_String_): Action parameters [optional = '']
+  def self.wsk(iInputFile, iOutputFile, iAction, iParams = '')
+    logInfo ''
+    logInfo "========== Processing #{iInputFile} ==#{iAction}==> #{iOutputFile} | #{iParams} ..."
+    system("#{$MusicMasterConf[:WSKCmdLine]} --input \"#{iInputFile}\" --output \"#{iOutputFile}\" --action #{iAction} -- #{iParams}")
+    lErrorCode = $?.exitstatus
+    if (lErrorCode == 0)
+      logInfo "========== Processing #{iInputFile} ==#{iAction}==> #{iOutputFile} | #{iParams} ... OK"
+    else
+      logErr "========== Processing #{iInputFile} ==#{iAction}==> #{iOutputFile} | #{iParams} ... ERROR #{lErrorCode}"
+      raise RuntimeError, "Processing #{iInputFile} ==#{iAction}==> #{iOutputFile} | #{iParams} ... ERROR #{lErrorCode}"
+    end
+    logInfo ''
+  end
+
+  # Parse plugins
+  def self.parsePlugins
+    require 'rUtilAnts/Plugins'
+    RUtilAnts::Plugins::initializePlugins
+    lLibDir = File.expand_path(File.dirname(__FILE__))
+    parsePluginsFromDir('Processes', "#{lLibDir}/Processes", 'MusicMaster::Processes')
+  end
+
+  # Apply given record effects on a Wave file.
+  # It modifies the given Wave file.
+  # It saves original and intermediate Wave files before modifications.
+  #
+  # Parameters:
+  # * *iEffects* (<em>list<map<Symbol,Object>></em>): List of effects to apply
+  # * *iFileName* (_String_): File name to apply effects to
+  # * *iDir* (_String_): The directory where temporary files are stored
+  def self.applyProcesses(iEffects, iFileName, iDir)
+    lFileNameNoExt = File.basename(iFileName[0..-5])
+    iEffects.each_with_index do |iEffectInfo, iIdxEffect|
+      begin
+        accessPlugin('Processes', iEffectInfo[:Name]) do |ioActionPlugin|
+          # Save the file before using the plugin
+          lSave = true
+          lSaveFileName = "#{iDir}/#{lFileNameNoExt}.Before_#{iIdxEffect}_#{iEffectInfo[:Name]}.wav"
+          if (File.exists?(lSaveFileName))
+            puts "!!! File #{lSaveFileName} already exists. Overwrite and apply effect ? [y='yes']"
+            lSave = ($stdin.gets.chomp == 'y')
+          end
+          if (lSave)
+            logInfo "Saving file #{iFileName} to #{lSaveFileName} ..."
+            FileUtils::mv(iFileName, lSaveFileName)
+            logInfo "===== Apply Effect #{iEffectInfo[:Name]} to #{iFileName} ====="
+            ioActionPlugin.execute(lSaveFileName, iFileName, iDir, iEffectInfo.clone.delete_if{|iKey, iValue| next (iKey == :Name)})
+          end
+        end
+      rescue Exception
+        logErr "An error occurred while processing #{iFileName} with process #{iEffectInfo[:Name]}: #{$!}."
+        raise
+      end
+    end
+  end
+
+  # Read record configuration.
+  # Perform basic checks on it.
+  #
+  # Parameters:
+  # * *iConfFile* (_String_): Configuration file
+  # Return:
+  # * _Exception_: Error, or nil in case of success
+  # * <em>map<Symbol,Object></em>: The configuration
+  def self.readRecordConf(iConfFile)
+    rError = nil
+    rConf = nil
+
+    if (!File.exists?(iConfFile))
+      rError = RuntimeError.new("Missing configuration file: #{iConfFile}")
+    else
+      File.open(iConfFile, 'r') do |iFile|
+        rConf = eval(iFile.read)
+      end
+      # Check that all tracks are assigned somewhere, just once
+      lLstTracks = nil
+      if (rConf[:Patches] != nil)
+        lLstTracks = rConf[:Patches].keys.clone
+      else
+        lLstTracks = []
+      end
+      if (rConf[:Performs] != nil)
+        rConf[:Performs].each do |iLstPerform|
+          lLstTracks.concat(iLstPerform)
+        end
+      end
+      lAssignedTracks = {}
+      lLstTracks.each do |iIdxTrack|
+        if (lAssignedTracks.has_key?(iIdxTrack))
+          rError = RuntimeError.new("Track #{iIdxTrack} is recorded twice.")
+          break
+        else
+          lAssignedTracks[iIdxTrack] = nil
+        end
+      end
+      if (rError == nil)
+        if (rConf[:Patches] != nil)
+          rConf[:Patches].each do |iIdxTrack, iTrackConf|
+            if ((iTrackConf.has_key?(:VolCorrection)) and
+                (iTrackConf.has_key?(:VolCompareCuts)))
+              rError = RuntimeError.new("Patch track #{iIdxTrack} has both :VolCorrection and :VolCompareCuts values defined.")
+            elsif ((!iTrackConf.has_key?(:VolCorrection)) and
+                   (!iTrackConf.has_key?(:VolCompareCuts)))
+              rError = RuntimeError.new("Patch track #{iIdxTrack} has neither :VolCorrection nor :VolCompareCuts values defined.")
+            end
+          end
+        end
+        if (rError == nil)
+          lAssignedTracks.size.times do |iIdxTrack|
+            if (!lAssignedTracks.has_key?(iIdxTrack+1))
+              logWarn "Track #{iIdxTrack+1} is never recorded."
+            end
+          end
+        end
+      end
+    end
+
+    return rError, rConf
+  end
+
+  # Convert a Wave file to another
+  #
+  # Parameters:
+  # * *iSrcFile* (_String_): Source WAVE file
+  # * *iDstFile* (_String_): Destination WAVE file
+  # * *iParams* (<em>map<Symbol,Object></em>): The parameters:
+  # ** *:SampleRate* (_Integer_): The new sample rate in Hz
+  # ** *:BitDepth* (_Integer_): The new bit depth (only for Wave) [optional = nil]
+  # ** *:Dither* (_Boolean_): Do we apply dither (only for Wave) ? [optional = false]
+  # ** *:BitRate* (_Integer_): Bit rate in kbps (only for MP3) [optional = 320]
+  # ** *:FileFormat* (_Symbol_); File format. Here are the possible values: [optional = :Wave]
+  # *** *:Wave*: Uncompressed PCM Wave file
+  # *** *:MP3*: MP3 file
+  def self.src(iSrcFile, iDstFile, iParams)
+    if ((iParams[:FileFormat] != nil) and
+        (iParams[:FileFormat] == :MP3))
+      # MP3 conversion
+      lTranslatedParams = []
+      iParams.each do |iParam, iValue|
+        case iParam
+        when :SampleRate
+          lTranslatedParams << "Sample rate: #{iValue} Hz"
+        when :BitRate
+          lTranslatedParams << "Bit rate: #{iValue} kbps"
+        when :FileFormat
+          # Nothing to do
+        else
+          logErr "Unknown MP3 parameter: #{iParam} (value #{iValue.inspect}). Ignoring it."
+        end
+      end
+      puts "Convert file #{iSrcFile} into file #{iDstFile} in MP3 format with following parameters: #{lTranslatedParams.join(', ')}"
+      puts 'Press Enter when done.'
+      $stdin.gets
+    else
+      # Wave conversion
+      lTranslatedParams = [ '--profile standard', '--twopass' ]
+      iParams.each do |iParam, iValue|
+        case iParam
+        when :SampleRate
+          lTranslatedParams << "--rate #{iValue}"
+        when :BitDepth
+          lTranslatedParams << "--bits #{iValue}"
+        when :Dither
+          if (iValue == true)
+            lTranslatedParams << '--dither 4'
+          end
+        when :FileFormat
+          # Nothing to do
+        else
+          logErr "Unknown Wave parameter: #{iParam} (value #{iValue.inspect}). Ignoring it."
+        end
+      end
+      FileUtils::mkdir_p(File.dirname(iDstFile))
+      lCmd = "#{$MusicMasterConf[:SRCCmdLine]} #{lTranslatedParams.join(' ')} \"#{iSrcFile}\" \"#{iDstFile}\""
+      logInfo "=> #{lCmd}"
+      system(lCmd)
+    end
+  end
+
+end

data/lib/MusicMaster/ConfLoader.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.
+#++
+
+# This file is required by MusicMaster binaries to load the MusicMaster configuration.
+# This sets the $MusicMasterConf object that can then be accessed from anywhere.
+
+module MusicMaster
+
+  def self.loadConf
+    $MusicMasterConf = nil
+    lConfSource = nil
+    # 1. Find from the environment
+    lConfigFileName = ENV['MUSICMASTER_CONF_PATH']
+    if (lConfigFileName == nil)
+      # 2. Find from the MusicMaster directory
+      lConfigFileName = "#{File.dirname(__FILE__)}/musicmaster.conf.rb"
+      if (File.exists?(lConfigFileName))
+        lConfSource = 'MusicMaster package local libraries'
+      else
+        # 3. Find from the current directory
+        lConfigFileName = "musicmaster.conf.rb"
+        if (File.exists?(lConfigFileName))
+          lConfSource = 'current directory'
+        else
+          # 4. Failure
+        end
+      end
+    else
+      lConfSource = 'MUSICMASTER_CONF_PATH environment variable'
+    end
+
+    # Check the configuration
+    if (lConfSource == nil)
+      logErr "No MusicMaster configuration file could be found. You can set it by setting MUSICMASTER_CONF_PATH environment variable, or create a musicmaster.conf.rb file either in #{File.dirname(__FILE__)} or the current directory."
+    else
+      if (File.exists?(lConfigFileName))
+        File.open(lConfigFileName, 'r') do |iFile|
+          begin
+            $MusicMasterConf = eval(iFile.read)
+          rescue Exception
+            logErr "Invalid configuration file #{lConfigFileName} specified in #{lConfSource}: #{$!}"
+            $MusicMasterConf = nil
+          end
+        end
+      else
+        logErr "Missing file #{lConfigFileName}, specified in #{lConfSource}"
+      end
+    end
+
+  end
+
+end
+
+MusicMaster::loadConf

data/lib/MusicMaster/Processes/AddSilence.rb

@@ -0,0 +1,27 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module MusicMaster
+
+  module Processes
+
+    class AddSilence
+
+      # Execute the process
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): File name we want to apply effects to
+      # * *iOutputFileName* (_String_): File name to write
+      # * *iTempDir* (_String_): Temporary directory that can be used
+      # * *iParams* (<em>map<Symbol,Object></em>): Parameters
+      def execute(iInputFileName, iOutputFileName, iTempDir, iParams)
+        MusicMaster::wsk(iInputFileName, iOutputFileName, 'SilenceInserter', "--begin \"#{iParams[:Begin]}\" --end \"#{iParams[:End]}\"")
+      end
+
+    end
+
+  end
+
+end

data/lib/MusicMaster/Processes/ApplyVolumeFct.rb

@@ -0,0 +1,46 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'WSK/Common'
+
+module MusicMaster
+
+  module Processes
+
+    class ApplyVolumeFct
+
+      # Parameters of this process:
+      # * *:Function* (<em>map<Symbol,Object></em>): The function definition
+      # * *:Begin* (_String_): Position to apply volume transformation from. Can be specified as a sample number or a float seconds (ie. 12.3s).
+      # * *:End* (_String_): 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.
+      # * *:DBUnits* (_Boolean_): Are the units of the function in DB scale ? (else they are in a ratio scale).
+
+      include WSK::Common
+      
+      # Execute the process
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): File name we want to apply effects to
+      # * *iOutputFileName* (_String_): File name to write
+      # * *iTempDir* (_String_): Temporary directory that can be used
+      # * *iParams* (<em>map<Symbol,Object></em>): Parameters
+      def execute(iInputFileName, iOutputFileName, iTempDir, iParams)
+        # Create the file that will store the Function for WSK
+        lFunctionFile = "#{iTempDir}/#{File.basename(iInputFileName)[0..-5]}.fct.rb"
+        lFunction = WSK::Functions::Function.new
+        lFunction.set(iParams[:Function])
+        lFunction.writeToFile(lFunctionFile)
+        lStrUnitDB = '0'
+        if (iParams[:DBUnits])
+          lStrUnitDB = '1'
+        end
+        MusicMaster::wsk(iInputFileName, iOutputFileName, 'ApplyVolumeFct', "--function \"#{lFunctionFile}\" --begin \"#{iParams[:Begin]}\" --end \"#{iParams[:End]}\" --unitdb #{lStrUnitDB}")
+      end
+
+    end
+
+  end
+
+end

data/lib/MusicMaster/Processes/Compressor.rb

@@ -0,0 +1,246 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+require 'WSK/Common'
+
+module MusicMaster
+
+  module Processes
+
+    class Compressor
+      
+      # Parameters of this process:
+      # * *:DBUnits* (_Boolean_): Are units in DB format ? [optional = false]
+      # * *:Threshold* (_Float_): The threshold below which there is no compression (in DB if :DBUnit is true, else in a [0..1] scale)
+      # * *:Ratio* (_Float_): Compression ratio to apply above threshold.
+      # * *:AttackDuration* (_String_): The attack duration (either in seconds or in samples)
+      # * *:AttackDamping* (_String_): The attack damping value in the duration previously defined (in DB if :DBUnit is true, else in a [0..1] scale). The compressor will never attack more than :AttackDamping values during a duration of :AttackDuration.
+      # * *:AttackLookAhead* (_Boolean_): Is the attack to be forecast before it happens ?
+      # * *:ReleaseDuration* (_String_): The release duration (either in seconds or in samples)
+      # * *:ReleaseDamping* (_String_): The release damping value in the duration previously defined (in DB if :DBUnit is true, else in a [0..1] scale). The compressor will never release more than :ReleaseDamping values during a duration of :ReleaseDuration.
+      # * *:ReleaseLookAhead* (_Boolean_): Is the attack to be forecast before it happens ?
+      # * *:MinChangeDuration* (_String_): The minimal duration a change in volume should have (either in seconds or in samples)
+      # * *:RMSRatio* (_Float_): Ratio of RMS vs Peak level measurement used when profiling Wave files volumes. 0.0 = Use only Peak level. 1.0 = Use only RMS level. Other values in-between will produce a mix of both.
+
+      include WSK::Common
+
+      # -Infinity
+      MINUS_INFINITY = -1.0/0.0
+
+      # Execute the process
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): File name we want to apply effects to
+      # * *iOutputFileName* (_String_): File name to write
+      # * *iTempDir* (_String_): Temporary directory that can be used
+      # * *iParams* (<em>map<Symbol,Object></em>): Parameters
+      def execute(iInputFileName, iOutputFileName, iTempDir, iParams)
+        # Check parameters
+        lDBUnits = iParams[:DBUnits]
+        if (lDBUnits == nil)
+          lDBUnits = false
+        end
+        lParamsOK = true
+        if (lDBUnits)
+          # Threshold must be < 0
+          if (iParams[:Threshold] >= 0)
+            logErr "Threshold (#{iParams[:Threshold]}db) has to be < 0db"
+            lParamsOK = false
+          end
+        else
+          # Threshold must be < 1
+          if (iParams[:Threshold] >= 1)
+            logErr "Threshold (#{iParams[:Threshold]}) has to be < 1"
+            lParamsOK = false
+          end
+          # Threshold must be > 0
+          if (iParams[:Threshold] <= 0)
+            logErr "Threshold (#{iParams[:Threshold]}) has to be > 0"
+            lParamsOK = false
+          end
+        end
+        # Ratio must be > 1
+        if (iParams[:Ratio] <= 1)
+          logErr "Ratio (#{iParams[:Ratio]}) has to be > 1"
+          lParamsOK = false
+        end
+        if (lParamsOK)
+          # Get the volume profile of the Wave file
+          lTempVolProfileFile = "#{iTempDir}/#{File.basename(iInputFileName)[0..-5]}.ProfileFct.rb"
+          if (File.exists?(lTempVolProfileFile))
+            logWarn "File #{lTempVolProfileFile} already exists. Will not overwrite it."
+          else
+            lTempWaveFile = "#{iTempDir}/Dummy.wav"
+            # Get the volume profile
+            MusicMaster::wsk(iInputFileName, lTempWaveFile, 'VolumeProfile', "--function \"#{lTempVolProfileFile}\" --begin 0 --end -1 --interval \"#{$MusicMasterConf[:Compressor][:Interval]}\" --rmsratio #{iParams[:RMSRatio]}")
+            File::unlink(lTempWaveFile)
+          end
+
+          # Get the file header for various measures later
+          lHeader = nil
+          File.open(iInputFileName, 'rb') do |iFile|
+            lError, lHeader = readHeader(iFile)
+            if (lError != nil)
+              logErr "An error occurred while reading header: #{lError}"
+            end
+          end
+
+          # Create the Compressor's function based on the parameters
+          # Minimal value represented in DB.
+          # This value will be used to replace -Infinity
+          lMinimalDBValue = nil
+          lCompressorFunction = WSK::Functions::Function.new
+          lBDThreshold = Rational(iParams[:Threshold])
+          if (lDBUnits)
+            # The minimal DB value is the smallest ratio possible for RMS values of this file (1/2^(BPS-1)) converted in DB and minus 1 to not mix it with the ratio 1/2^(BPS-1)
+            lMinimalDBValue = lCompressorFunction.valueVal2db(Rational(1), Rational(2)**(lHeader.NbrBitsPerSample-1)) - 1
+            lCompressorFunction.set( {
+              :FunctionType => WSK::Functions::FCTTYPE_PIECEWISE_LINEAR,
+              :Points => [
+                [lMinimalDBValue, lMinimalDBValue],
+                [lBDThreshold, lBDThreshold],
+                [0, lBDThreshold - lBDThreshold/Rational(iParams[:Ratio]) ]
+              ]
+            } )
+          else
+            lCompressorFunction.set( {
+              :FunctionType => WSK::Functions::FCTTYPE_PIECEWISE_LINEAR,
+              :Points => [
+                [0, 0],
+                [lBDThreshold, lBDThreshold],
+                [1, lBDThreshold + (1-lBDThreshold)/Rational(iParams[:Ratio]) ]
+              ]
+            } )
+          end
+          logInfo "Compressor transfer function: #{lCompressorFunction.functionData[:Points].map{ |p| next [ sprintf('%.2f', p[0]), sprintf('%.2f', p[1]) ] }.inspect}"
+
+          # Compute the volume transformation function based on the profile function and the Compressor's parameters
+          lTempVolTransformFile = "#{iTempDir}/#{File.basename(iInputFileName)[0..-5]}.VolumeFct.rb"
+          if (File.exists?(lTempVolTransformFile))
+            logWarn "File #{lTempVolTransformFile} already exists. Will not overwrite it."
+          else
+            # Read the Profile function
+            logInfo 'Create volume profile function ...'
+            lProfileFunction = WSK::Functions::Function.new
+            lProfileFunction.readFromFile(lTempVolProfileFile)
+            if (lDBUnits)
+              # Convert the Profile function in DB units
+              lProfileFunction.convertToDB(Rational(1))
+              # Replace -Infinity with lMinimalDBValue
+              lProfileFunction.functionData[:Points].each do |ioPoint|
+                if (ioPoint[1] == MINUS_INFINITY)
+                  ioPoint[1] = lMinimalDBValue
+                end
+              end
+            end
+            
+            #dumpDebugFct(iInputFileName, lProfileFunction, 'ProfileDB', lDBUnits, iTempDir)
+
+            # Clone the profile function before applying the map
+            lNewProfileFunction = WSK::Functions::Function.new
+            lNewProfileFunction.set(lProfileFunction.functionData.clone)
+            
+            # Transform the Profile function with the Compressor function
+            logInfo 'Apply compressor transfer function ...'
+            lNewProfileFunction.applyMapFunction(lCompressorFunction)
+
+            #dumpDebugFct(iInputFileName, lNewProfileFunction, 'NewProfileDB', lDBUnits, iTempDir)
+
+            # The difference of the functions will give the volume transformation profile
+            logInfo 'Compute differing function ...'
+            lDiffProfileFunction = WSK::Functions::Function.new
+            lDiffProfileFunction.set(lNewProfileFunction.functionData.clone)
+            if (lDBUnits)
+              # The volume transformation will be a DB difference
+              lDiffProfileFunction.substractFunction(lProfileFunction)
+            else
+              # The volume transformation will be a ratio
+              lDiffProfileFunction.divideByFunction(lProfileFunction)
+            end
+
+            #dumpDebugFct(iInputFileName, lDiffProfileFunction, 'RawDiffProfileDB', lDBUnits, iTempDir)
+
+            # Apply damping for attack and release times
+            logInfo 'Damp differing function with attack and release ...'
+            lAttackDuration = Rational(readDuration(iParams[:AttackDuration], lHeader.SampleRate))
+            lAttackSlope = iParams[:AttackDamping].to_f.to_r/lAttackDuration
+            lReleaseDuration = Rational(readDuration(iParams[:ReleaseDuration], lHeader.SampleRate))
+            lReleaseSlope = iParams[:ReleaseDamping].to_f.to_r/lReleaseDuration
+            if (lDBUnits)
+              lAttackSlope = -lAttackSlope
+              lReleaseSlope = -lReleaseSlope
+            end
+            # Take care of look-aheads
+            if ((iParams[:AttackLookAhead] == true) or
+                (iParams[:ReleaseLookAhead] == true))
+              # Look-Aheads are implemented by applying damping on the reverted function
+              lDiffProfileFunction.invertAbscisses
+              if (iParams[:AttackLookAhead] == false)
+                lDiffProfileFunction.applyDamping(nil, -lReleaseSlope)
+              elsif (iParams[:ReleaseLookAhead] == false)
+                lDiffProfileFunction.applyDamping(lAttackSlope, nil)
+              else
+                lDiffProfileFunction.applyDamping(lAttackSlope, -lReleaseSlope)
+              end
+              lDiffProfileFunction.invertAbscisses
+            end
+            if (iParams[:AttackLookAhead] == true)
+              if (iParams[:ReleaseLookAhead] == false)
+                lDiffProfileFunction.applyDamping(lReleaseSlope, nil)
+              end
+            elsif (iParams[:ReleaseLookAhead] == true)
+              if (iParams[:AttackLookAhead] == false)
+                lDiffProfileFunction.applyDamping(nil, -lAttackSlope)
+              end
+            else
+              lDiffProfileFunction.applyDamping(lReleaseSlope, -lAttackSlope)
+            end
+            
+            #dumpDebugFct(iInputFileName, lDiffProfileFunction, 'DampedDiffProfileDB', lDBUnits, iTempDir)
+            
+            # Eliminate glitches in the function.
+            # This is done by deleting intermediate abscisses that are too close to each other
+
+            logInfo 'Smooth differing function ...'
+            lDiffProfileFunction.removeNoiseAbscisses(Rational(readDuration(iParams[:MinChangeDuration], lHeader.SampleRate)))
+
+            #dumpDebugFct(iInputFileName, lDiffProfileFunction, 'SmoothedDiffProfileDB', lDBUnits, iTempDir)
+
+            # Save the volume transformation file
+            lDiffProfileFunction.writeToFile(lTempVolTransformFile)
+          end
+
+          # Apply the volume transformation to the Wave file
+          lStrUnitDB = 0
+          if (lDBUnits)
+            lStrUnitDB = 1
+          end
+          MusicMaster::wsk(iInputFileName, iOutputFileName, 'ApplyVolumeFct', "--function \"#{lTempVolTransformFile}\" --begin 0 --end -1 --unitdb #{lStrUnitDB}")
+        end
+      end
+
+      # Dump a function into a Wave file.
+      # This is used for debugging purposes only.
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): Name of the input file
+      # * *iFunction* (<em>WSK::Functions::Function</em>): The function to dump
+      # * *iName* (_String_): Name given to this function
+      # * *iDBUnits* (_Boolean_): Is the function in DB units ?
+      # * *iTempDir* (_String_): Temporary directory to use
+      def dumpDebugFct(iInputFileName, iFunction, iName, iDBUnits, iTempDir)
+        lBaseFileName = File.basename(iInputFileName)[0..-5]
+        # Clone the function to round it first
+        lRoundedFunction = WSK::Functions::Function.new
+        lRoundedFunction.set(iFunction.functionData.clone)
+        lRoundedFunction.writeToFile("#{iTempDir}/_#{lBaseFileName}_#{iName}.fct.rb", :Floats => true)
+        MusicMaster::wsk(iInputFileName, "#{iTempDir}/_#{lBaseFileName}_#{iName}.wav", 'DrawFct', "--function \"#{iTempDir}/_#{lBaseFileName}_#{iName}.fct.rb\" --unitdb #{iDBUnits ? '1' : '0'}")
+      end
+      
+    end
+
+  end
+
+end

data/lib/MusicMaster/Processes/Custom.rb

@@ -0,0 +1,31 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module MusicMaster
+
+  module Processes
+
+    class Custom
+
+      # Execute the process
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): File name we want to apply effects to
+      # * *iOutputFileName* (_String_): File name to write
+      # * *iTempDir* (_String_): Temporary directory that can be used
+      # * *iParams* (<em>map<Symbol,Object></em>): Parameters
+      def execute(iInputFileName, iOutputFileName, iTempDir, iParams)
+        logInfo "Copying #{iInputFileName} => #{iOutputFileName} ..."
+        FileUtils::cp(iInputFileName, iOutputFileName)
+        puts "Apply custom process on file #{iOutputFileName}. Parameters: #{iParams.inspect}"
+        puts 'Press Enter when done ...'
+        $stdin.gets
+      end
+
+    end
+
+  end
+
+end

data/lib/MusicMaster/Processes/CutFirstSignal.rb

@@ -0,0 +1,27 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module MusicMaster
+
+  module Processes
+
+    class CutFirstSignal
+
+      # Execute the process
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): File name we want to apply effects to
+      # * *iOutputFileName* (_String_): File name to write
+      # * *iTempDir* (_String_): Temporary directory that can be used
+      # * *iParams* (<em>map<Symbol,Object></em>): Parameters
+      def execute(iInputFileName, iOutputFileName, iTempDir, iParams)
+        MusicMaster::wsk(iInputFileName, iOutputFileName, 'CutFirstSignal', "--silencethreshold 0 --noisefft none --silencemin \"#{$MusicMasterConf[:NoiseGate][:SilenceMin]}\"")
+      end
+
+    end
+
+  end
+
+end

data/lib/MusicMaster/Processes/GVerb.rb

@@ -0,0 +1,30 @@
+#--
+# Copyright (c) 2009-2010 Muriel Salvan (murielsalvan@users.sourceforge.net)
+# Licensed under the terms specified in LICENSE file. No warranty is provided.
+#++
+
+module MusicMaster
+
+  module Processes
+
+    class GVerb
+
+      # Execute the process
+      #
+      # Parameters:
+      # * *iInputFileName* (_String_): File name we want to apply effects to
+      # * *iOutputFileName* (_String_): File name to write
+      # * *iTempDir* (_String_): Temporary directory that can be used
+      # * *iParams* (<em>map<Symbol,Object></em>): Parameters
+      def execute(iInputFileName, iOutputFileName, iTempDir, iParams)
+        puts "===> Apply GVerb from Audacity to file #{iInputFileName} and write file #{iOutputFileName}"
+        puts "===> Parameters: #{iParams.inspect}"
+        puts 'Press Enter when done.'
+        $stdin.gets
+      end
+
+    end
+
+  end
+
+end