JOCLoudness 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 233b016a7113d6d0d79533b247d6962922467c1a
+  data.tar.gz: 3aae6b46fdf8eb78b818b3318fd9a46562d5f9d1
+SHA512:
+  metadata.gz: afa516ea690e777fff9c5bef87bae79fddf1750022f5c4bc42135cbec06152d6784f510349bf6b9f54c6d3dbfeb92c959f15e6b87a6180338cf50f84d654822e
+  data.tar.gz: af9f65f0f1ae9df978eadf8acfb4aba34c2d9c1fcada4418a87df2624608c47e1f3c19491358a34e6625ecbe9d3828f557f561ce3cfe2a4f888e4e8e441b59dc

data/lib/JOCLoudness.rb

@@ -0,0 +1,4 @@
+#file: JOCLoudness.rb 
+require 'logger'
+require_relative './WavReader/wavfile'
+require_relative './Loudness/jocLoud.rb'

data/lib/Loudness/IIRFilter/IIRFilter.rb

@@ -0,0 +1,85 @@
+#file: IIRFilter.rb
+
+
+class IIRFilter
+  
+  # Ini obj
+  def initialize(order)
+    @OldSamples = nil
+    @ACoefs= nil
+    @BCoefs= nil
+    @Order = 0
+  
+    @Order = order 
+    
+    @OldSamples = Array.new(@Order) {0.0}
+        
+  end
+  
+  #Set filters coeficients
+  def SetCoefs (b, a)
+    if ((a.kind_of?(Array) == false) or (b.kind_of?(Array) == false))
+      raise 'Filter coeficinets must be an array'
+    end
+    if ((a.length != @Order + 1) or (b.length != @Order + 1))
+      raise "Incorrect number of coeficients. A filter of order #{@Order} must have #{@Order+1} coeficients"
+    end
+    
+    @ACoefs = a
+    @BCoefs = b
+     
+  end
+  
+  #Filter 1 sample
+  def FilterSample (sampleIn)
+    
+    nFilterCoefs = @Order + 1;
+    sx = sampleIn;
+    spx = 0.0;   
+    ox = 0.0;   
+    
+    #A coefs
+    nA = 0; 
+    while nA < nFilterCoefs do
+      if (nA == 0)
+        spx = sx.to_f;
+      else
+        spx = spx.to_f -  @ACoefs[nA].to_f * @OldSamples[nA - 1].to_f  #Spx - m_pACoefs[nA]*m_pOldSamples[nA-1];
+      end
+    
+      nA = nA + 1  
+    end       
+    
+    #B coefs
+    nB = 0;  
+    while nB < nFilterCoefs do
+      if (nB == 0)
+        ox = ox.to_f + @BCoefs[nB].to_f * spx.to_f   #Ox = Ox + m_pBCoefs[nB]*Spx;
+      else
+        ox = ox.to_f + @BCoefs[nB].to_f * @OldSamples[nB - 1].to_f   #Ox = Ox + m_pBCoefs[nB]*m_pOldSamples[nB-1];
+      end
+    
+      nB = nB + 1  
+    end       
+    
+    #Set Old samples
+    nS = @Order     
+    while nS > 0 do
+      if ((nS - 2) < 0)
+        @OldSamples[nS - 1] = spx.to_f
+      else
+        @OldSamples[nS - 1] = @OldSamples[nS - 2].to_f    
+      end       
+      
+      nS = nS - 1
+    end
+
+    return ox
+  end
+ 
+  #Show coefs
+  def Info
+    return "IIR Filter Order #{@Order}\nACoefs #{@ACoefs}\nBCoefs #{@BCoefs}\n"
+  end
+  
+end

data/lib/Loudness/JOCLoud.rb

@@ -0,0 +1,163 @@
+#file: jocLoud.rb
+require_relative './RlbFilter/RLBFilter.rb'
+require_relative './PreFilter/PREFilter.rb'
+require_relative './Mean/MeanFast.rb'
+
+class JOCLoud
+  
+  # Ini obj
+  def initialize    
+    @logger = nil
+    
+    @fs = 48000
+    @nchannels = 2
+    
+    @channelweights = [1.0, 1.0, 1.0, 1.41, 1.41, 0, 0, 0]
+    
+    @prefilters = nil
+    @rlbfilters = nil
+    
+    @meansqfiltersPlain = nil
+        
+    @calculatedLKFS = -Float::INFINITY
+    
+    @iscomputingLKFS = false
+  end
+
+  #Set logger
+  def Setlogger(logger)
+    @logger = logger
+  end
+
+  def ini(fs, nchannels)    
+  
+    @fs = fs
+    @nchannels = nchannels
+    
+    Log(Logger::INFO,"Starting ini fs: #{@fs}, Num. channels: #{@nchannels}")
+    
+    #Ini all components
+    @prefilters = Array.new
+    @rlbfilters = Array.new
+    @meansqfiltersPlain = Array.new
+    
+    nc = 0
+    while nc < @nchannels do
+      #Ini PRE filters (one per channel)
+      prefilter = PREFilter.new(@fs)
+      @prefilters.insert(-1, prefilter) #Insert at loast position
+      Log(Logger::INFO,"Channel #{@nc} PREFilter info: #{prefilter.Info}")  
+
+      #Ini RLB filters (one per channel)
+      rlbfilter = RLBFilter.new(@fs)
+      @rlbfilters.insert(-1, rlbfilter) #Insert at loast position
+      Log(Logger::INFO,"Channel #{@nc} RLB Filter info: #{rlbfilter.Info}")
+
+      #Plain mean (initializes in TOTAL mode)
+      mfast = MeanFast.new
+      @meansqfiltersPlain.insert(-1, mfast) #Insert at loast position
+      
+      nc = nc + 1
+    end
+    
+    @calculatedLKFS = -Float::INFINITY
+    
+    @iscomputingLKFS = false
+    
+    Log(Logger::DEBUG,"Endini")
+  end
+
+  def SetChannelWeigths(channelweights)
+
+    if (@iscomputingLKFS == true)
+      raise 'Ivalid state. You cannot change channelwheights during a loudness calculation'
+    end
+    
+    if (channelweights.kind_of?(Array) == false)
+      raise 'Channel wrights must be an array'
+    end
+    if (channelweights.length < @nchannels)
+      raise 'Channelweigts length must be equal or greater as number of channels'
+    end
+    
+    @channelweights = channelweights
+
+    Log(Logger::INFO,"Set new channel wheights: #{@channelweights}")
+  end
+  
+  def Addsample (dsample)
+    @iscomputingLKFS = true
+  
+    if (dsample.kind_of?(Array) == false)
+      raise 'dsample must be an array'
+    end
+    if (dsample.length < @nchannels)
+      raise 'dsample length must be equal or greater as number of channels'
+    end
+
+    nc = 0
+    while nc < @nchannels do
+      
+      presampled = @prefilters[nc].FilterSample(dsample[nc])
+      rlbsampled = @rlbfilters[nc].FilterSample(presampled)
+      @meansqfiltersPlain[nc].AddSample(rlbsampled)
+    
+      Log(Logger::DEBUG,"Enter sample #{dsample[nc]}, presample = #{presampled}, rlbsmample = #{rlbsampled}")
+      
+      nc = nc + 1
+    end
+  end
+  
+  def GetLoudnessLKFS
+    meanvals = Array.new
+    nc = 0
+    while nc < @nchannels do
+      mean = @meansqfiltersPlain[nc].GetMeanVal
+      meanvals.insert(-1, mean) #Insert at last position
+      
+      nc = nc + 1
+    end
+    
+    Log(Logger::DEBUG,"Enter GetLoudnessLKFS channel means: #{mean}, Channel Weights: #{@channelweights}")
+        
+    #Calc Loudness [LKFS]
+    nc = 0
+    dsum = 0.0
+    while nc < @nchannels do
+      dsum = dsum + @channelweights[nc].to_f * meanvals[nc].to_f
+            
+      nc = nc + 1
+    end
+   
+    @calculatedLKFS = -0.691 + 10.0 * Math.log10(dsum.to_f)
+   
+    Log(Logger::DEBUG,"All sum: #{dsum}, Channel Weights: #{@channelweights}")
+    
+    Log(Logger::INFO,"Loudness: #{@calculatedLKFS} LKFS")
+        
+    return @calculatedLKFS
+  end
+  
+private
+
+  def Log (type, message)
+  
+    if (@logger != nil)
+      if (type == Logger::FATAL)
+        @logger.fatal(message)
+      end
+      if (type == Logger::ERROR)
+        @logger.error(message)
+      end
+      if (type == Logger::WARN)
+        @logger.warn(message)
+      end
+      if (type == Logger::INFO)
+        @logger.info(message)
+      end
+      if (type == Logger::DEBUG)
+        @logger.debug(message)
+      end 
+    end     
+  end
+end 

data/lib/Loudness/Mean/MeanFast.rb

@@ -0,0 +1,123 @@
+#file: MeanFast.rb
+
+# define MeanFast
+class MeanFast
+  
+  module MEAN_MODE
+    MEAN_OVERLAPPED = 1
+    MEAN_TOTAL = 2
+  end
+  
+  # Ini obj
+  def initialize
+    @bIni = false
+    @mode = MEAN_MODE::MEAN_TOTAL
+
+    #Vars used in Overlapped mode
+    @lSamplesInInterval = 0
+    @lSamplesOverlapped = 0
+    @lGetMeanEveryXSamples = 0
+    @nSums = 0
+    @Sums  = 0
+    @lNumSamplesLoaded = 0
+    @nSumIndex = 0    
+    @queueMean = Array.new
+    
+    #Vars used in TOTAL mode
+    @lNumAcumulatedSamplesMean = 0
+    @dAccumulatedMean = 0.0
+    
+    #if @mode == MEAN_MODE::MEAN_TOTAL the fs, lMeanIntervalms, dOverlappingFactor does not take effect
+    Ini(@mode, 48000, 400, 0.75)
+  end
+  
+  def Ini(mode, fs, lMeanIntervalms, dOverlappingFactor)    
+    
+    if (@bIni == true)
+      raise 'ERROR bad state'
+    end
+    
+    if (fs <= 0) or (lMeanIntervalms <= 0) or (dOverlappingFactor <= 0.0) or (dOverlappingFactor >= 1.0)        
+      raise 'ERROR bad arguments'
+    end
+    
+    @mode = mode
+    
+    if (@mode == MEAN_MODE::MEAN_OVERLAPPED)
+      @lSamplesInInterval = Integer(fs.to_f * (lMeanIntervalms.to_f / 1000.0))
+      @lSamplesOverlapped = Integer(@lSamplesInInterval.to_f * dOverlappingFactor.to_f)
+      @lGetMeanEveryXSamples = @lSamplesInInterval - @lSamplesOverlapped;
+
+      if (@lGetMeanEveryXSamples <= 0)
+        raise 'ERROR calculating lGetMeanEveryXSamples (bad arguments)'
+      end
+      
+      @nSums = @lSamplesInInterval / @lGetMeanEveryXSamples; 
+      @Sums = Array.new(@nSums) {|i| i = 0}
+
+      @lNumSamplesLoaded = 0;
+      @nSumIndex = 0;  
+    else  
+      @lNumAcumulatedSamplesMean = 0;
+      @dAccumulatedMean = 0.0;
+    end
+
+    @bIni = true;
+  end
+  
+  def AddSample (dSample)
+    rc = false
+    
+    if (@mode == MEAN_MODE::MEAN_OVERLAPPED)
+      ni = 0     
+      while ni < @nSums do
+        @Sums[ni] = @Sums[ni].to_f + (dSample.to_f * dSample.to_f)
+        
+        ni = ni + 1
+      end 
+      
+      @lNumSamplesLoaded = @lNumSamplesLoaded + 1
+
+      if ((@lNumSamplesLoaded % @lGetMeanEveryXSamples) == 0)
+        dMean = @Sums[@nSumIndex].to_f / @lSamplesInInterval.to_f
+        
+        @queueMean.insert(-1, dMean) #Insert at loast position
+        
+        rc = true
+        @Sums[@nSumIndex] = 0.0
+
+        @nSumIndex = @nSumIndex + 1        
+        if (@nSumIndex >= @nSums)
+          @nSumIndex = 0
+        end
+      end
+      
+      if (@lNumSamplesLoaded >= @lSamplesInInterval)
+        @lNumSamplesLoaded = 0
+      end        
+    else
+      dAddVal = dSample.to_f * dSample.to_f
+
+      if (@lNumAcumulatedSamplesMean > 0)
+        dMul = @lNumAcumulatedSamplesMean.to_f / (@lNumAcumulatedSamplesMean + 1).to_f
+        @dAccumulatedMean = (@dAccumulatedMean.to_f * dMul.to_f) + dAddVal.to_f / (@lNumAcumulatedSamplesMean + 1).to_f
+      else
+        @dAccumulatedMean = dAddVal
+      end
+      @lNumAcumulatedSamplesMean = @lNumAcumulatedSamplesMean + 1
+
+      rc = true      
+    end
+    
+    return rc
+  end
+  
+  def GetMeanVal
+    if (@mode == MEAN_MODE::MEAN_OVERLAPPED)
+      raise 'ERROR function not valid in overlapped mean mode'
+    end
+    
+    return @dAccumulatedMean
+  end
+  
+end

data/lib/Loudness/PreFilter/PREFilter.rb

@@ -0,0 +1,58 @@
+#file: PREFilter.rb
+
+require_relative '../IIRFilter/IIRFilter.rb'
+
+# define PRE filter
+class PREFilter < IIRFilter
+  
+  # Ini obj
+  def initialize(fs)
+    super 2 
+    
+    SetFreqSampling(fs)
+  end
+
+  def SetFreqSampling (fs) 
+    @fs = fs
+    
+    #PRE FILTER - Order 2 = 3coefs
+    #Coefs Fs = 48KHz (ITU 1770 published coefs for fs = 48KHz)
+    mACoefs = [1.0, -1.69065929318241, 0.73248077421585]
+    mBCoefs = [1.53512485958697, -2.69169618940638, 1.19839281085285]
+
+    if (@fs != 48000)
+      #Parameters of second order HF shelvoing filter
+      nGdb = 4      #Gain in DB
+      dFc = 1650    #Center freq
+
+      mBCoefs , mACoefs = CalcCoefs fs, nGdb, dFc
+    end
+
+    SetCoefs mBCoefs,mACoefs
+  end 
+
+  def CalcCoefs (fs, nGdb, dFc)
+
+    dK = Math.tan( (Math::PI * dFc.to_f) / fs.to_f )    
+    dV0 = (10.0 ** (nGdb.to_f / 20.0))
+    dsqrt2 = (2 ** 0.5)
+    dDivider = (1.0 + dsqrt2.to_f * dK.to_f + (dK.to_f ** 2))
+
+    mACoefs = [0,0,0]
+    mACoefs[0] = 1.0;
+    mACoefs[1] = (2.0 * ((dK.to_f ** 2.0) - 1)) / dDivider.to_f;
+    mACoefs[2] = (1.0 - (dsqrt2.to_f * dK.to_f) + (dK.to_f ** 2.0)) / dDivider.to_f;
+
+    mBCoefs = [0,0,0]
+    mBCoefs[0] = (dV0.to_f + ((2.0 * dV0.to_f) ** 0.5) * dK.to_f + (dK.to_f ** 2.0)) / dDivider.to_f;
+    mBCoefs[1] = (2.0 * ((dK.to_f ** 2.0) - dV0.to_f)) / dDivider.to_f;
+    mBCoefs[2] = (dV0 - ((2.0 * dV0.to_f) ** 0.5) * dK.to_f + (dK.to_f ** 2.0)) / dDivider.to_f;
+
+    return mBCoefs, mACoefs
+  end
+  
+  #Show info 
+  def Info
+    return "PRE Filter--------\nFs = #{@fs} Hz\n#{super}\n------------------\n"
+  end
+end

data/lib/Loudness/RlbFilter/RLBFilter.rb

@@ -0,0 +1,56 @@
+#file: RLBFilter.rb
+
+require_relative '../IIRFilter/IIRFilter.rb'
+
+# define RLB filter
+class RLBFilter < IIRFilter
+  
+  # Ini obj
+  def initialize(fs)
+    super 2 
+    
+    SetFreqSampling(fs)
+  end
+
+  def SetFreqSampling (fs) 
+    @fs = fs
+    
+    #RLB FILTER - Order 2 = 3coefs
+    #Coefs Fs = 48KHz (ITU 1770 published coefs for fs = 48KHz)
+    mACoefs = [1.0, -1.99004745483398, 0.99007225036621]
+    mBCoefs = [1.0, -2.0, 1.0]
+
+    if (@fs != 48000)
+      #Parameters of second order HPF
+      dFc = 60 #Center freq
+
+      mBCoefs , mACoefs = CalcCoefs fs,dFc
+    end
+
+    SetCoefs mBCoefs,mACoefs
+  end 
+
+  def CalcCoefs (fs, dFc)
+    dK = Math.tan( (Math::PI * dFc.to_f) / fs.to_f )    
+    dsqrt2 = 2 ** 0.5
+    dDivider = (1.0 + dsqrt2.to_f * dK.to_f + (dK ** 2))
+    
+    #ACoefs
+    mACoefs = [0,0,0]
+    mACoefs[0] = 1.0;
+    mACoefs[1] = (2.0 * ((dK.to_f ** 2.0) - 1)) / dDivider.to_f;
+    mACoefs[2] = (1.0 - (dsqrt2.to_f * dK.to_f) + (dK.to_f ** 2.0))/dDivider.to_f;
+
+    mBCoefs = [0,0,0]
+    mBCoefs[0] = 1.0 / dDivider.to_f;
+    mBCoefs[1] = -2.0 / dDivider.to_f;
+    mBCoefs[2] = 1.0 / dDivider.to_f;
+  
+    return mBCoefs, mACoefs
+  end
+  
+  #Show info 
+  def Info
+    return "RLB Filter--------\nFs = #{@fs} Hz\n#{super}\n------------------\n"
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: JOCLoudness
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jordi Cenzano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bindata
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+description: This ruby native gem is able to load a wav file and calculate its LKFS
+  following the ITU-R BS.1770
+email: jordicenzano@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/JOCLoudness.rb
+- lib/Loudness/IIRFilter/IIRFilter.rb
+- lib/Loudness/JOCLoud.rb
+- lib/Loudness/Mean/MeanFast.rb
+- lib/Loudness/PreFilter/PREFilter.rb
+- lib/Loudness/RlbFilter/RLBFilter.rb
+homepage: http://rubygems.org/gems/JOCLoudness
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: It calculates the LKFS of a wav file
+test_files: []