Class: WSK::Actions::Analyze

Inherits:
Object
  • Object
show all
Includes:
Common
Defined in:
lib/WSK/Actions/Analyze.rb

Instance Method Summary collapse

Methods included from Common

#accessInputWaveFile, #accessOutputWaveFile, #getWaveFileAccesses, #parsePlugins, #readDuration, #readFFTProfile, #readThresholds, #val2db

Instance Method Details

#execute(iInputData, oOutputData) ⇒ Object

Execute

Parameters

  • iInputData (WSK::Model::InputData): The input data

  • oOutputData (Object): The output data to fill

Return

  • Exception: An error, or nil if success



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/WSK/Actions/Analyze.rb', line 33

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

#get_nbr_samples(iInputData) ⇒ Object

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 (WSK::Model::InputData): The input data

Return

  • Integer: The number of samples to be written



22
23
24
 
# File 'lib/WSK/Actions/Analyze.rb', line 22

def get_nbr_samples(iInputData)
  return 0
end