| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| * use this file except in compliance with the License. You may obtain a copy of |
| * the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| /* This test accepts a collection of N speech waveforms collected as |
| part of N recognition attempts. The waveforms are ordered by |
| increasing presentation level. The test determines the extent to |
| which the peak amplitudes in the waveforms track the change in |
| presentation level. Failure to track the presentation level within |
| some reasonable margin is an indication of clipping or of automatic |
| gain control in the signal path. |
| |
| The speech stimuli that are used for this test should simply be |
| replications of exactly the same speech signal presented at |
| different levels. It is expected that all recognition attempts on |
| this signal result in correct recognition. A warning, but not a |
| hard failure, should be issued if any of the attempts fail. The |
| hard failure criterion for this test should be only based on the |
| amplitude linearity tracking. */ |
| |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <math.h> |
| |
| /* Keep a record of the top N absolute values found using a slow |
| bubble-sort. This is OK, since the use of this program is not time |
| critical, and N is usually small. Note that the argument n = N-1. */ |
| static void bubbleUp(int* store, int n, short val) { |
| if (val < store[n]) |
| return; |
| for (int i = 0; i <= n; ++i) { |
| if (val >= store[i]) { |
| for (int j = n; j > i ; j--) |
| store[j] = store[j-1]; |
| store[i] = val; |
| return; |
| } |
| } |
| } |
| |
| /* Make two measurements on the signal of length numSamples sampled at |
| sampleRate in pcm: the RMS of the highest amplitude 30ms segment |
| (returned in peakRms), and the RMS of the top 50 peak absolute |
| values found (returned in peakAverage). If the signal is too |
| short to make reasonable measurements, the function returns 0, else |
| it returns 1. */ |
| static int peakLevels(short* pcm, int numSamples, float sampleRate, |
| float* peakAverage, float* peakRms) { |
| float rmsFrameSize = 0.03; |
| float rmsFrameStep = 0.01; |
| int frameStep = int(0.5 + (sampleRate * rmsFrameStep)); |
| int frameSize = int(0.5 + (sampleRate * rmsFrameSize)); |
| int numFrames = 1 + ((numSamples - frameSize) / frameStep); |
| |
| if (numFrames < 10) { |
| return 0; // failure for too short signal |
| } |
| |
| // Peak RMS calculation |
| double maxEnergy = 0.0; |
| for (int frame = 0; frame < numFrames; ++frame) { |
| double energy = 0.0; |
| int limit = (frame * frameStep) + frameSize; |
| for (int i = frame * frameStep; i < limit; ++i) { |
| double s = pcm[i]; |
| energy += s * s; |
| } |
| if (energy > maxEnergy) { |
| maxEnergy = energy; |
| } |
| } |
| *peakRms = sqrt(maxEnergy / frameSize); |
| |
| // Find the absolute highest topN peaks in the signal and compute |
| // the RMS of their values. |
| int topN = 50; // The number of highest peaks over which to average. |
| int topM = topN - 1; |
| int* maxVal = new int[topN]; |
| for (int i = 0; i < topN; ++i) { |
| maxVal[i] = 0; |
| } |
| for (int i = 0; i < numSamples; ++i) { |
| if (pcm[i] >= 0) { |
| bubbleUp(maxVal, topM, pcm[i]); |
| } else { |
| bubbleUp(maxVal, topM, -pcm[i]); |
| } |
| } |
| float sum = 0.0; |
| // The RMS is taken bacause we want the values of the highest peaks |
| // to dominate. |
| for (int i = 0; i < topN; ++i) { |
| float fval = maxVal[i]; |
| sum += (fval * fval); |
| } |
| delete [] maxVal; |
| *peakAverage = sqrt(sum/topN); |
| return 1; // success |
| } |
| |
| /* There are numSignals int16 signals in pcms. sampleCounts is an |
| integer array of length numSignals containing their respective |
| lengths in samples. They are all sampled at sampleRate. The pcms |
| are ordered by increasing stimulus level. The level steps between |
| successive stimuli were of size dbStepSize dB. The signal with |
| index referenceStim (0 <= referenceStim < numSignals) should be in |
| an amplitude range that is reasonably certain to be linear (e.g. at |
| normal speaking levels). The maximum deviation in linearity found |
| (in dB) is returned in maxDeviation. The function returns 1 if |
| the measurements could be made, or a negative number that |
| indicates the error, as follows: |
| -1 The input signals or sample counts are missing. |
| -2 The number of input signals is < 2. |
| -3 The specified sample rate is <= 4000.0 |
| -4 The dB step size for the increase in stimulus level is <= 0.0 |
| -5 The specified reverence stimulus number is out of range. |
| -6 One or more of the stimuli is too short in duration. */ |
| int linearityTest(short** pcms, int* sampleCounts, int numSignals, |
| float sampleRate, float dbStepSize, int referenceStim, |
| float* maxDeviation) { |
| if (!(pcms && sampleCounts)) { |
| return -1; // Input signals or sample counts are missing |
| } |
| if (numSignals < 2) { |
| return -2; // the number of input signals must be >= 2; |
| } |
| if (sampleRate <= 4000.0) { |
| return -3; // The sample rate must be > 4000 Hz. |
| } |
| if (dbStepSize <= 0.0) { |
| return -4; // The dB step size must be > 0.0 |
| } |
| if (!((referenceStim >= 0) && (referenceStim < numSignals))) { |
| return -5; // (0 <= referenceStim < numSignals) must be true |
| } |
| float* peakAverage = new float[numSignals]; |
| float* peakRms = new float[numSignals]; |
| for (int sig = 0; sig < numSignals; ++sig) { |
| if (!peakLevels(pcms[sig], sampleCounts[sig], |
| sampleRate, peakAverage + sig, peakRms + sig)) { |
| return -6; // failure because a signal is too short. |
| } |
| } |
| float peakAverageRef = peakAverage[referenceStim]; |
| float peakRmsRef = peakRms[referenceStim]; |
| float maxDev = 0.0; |
| for (int i = 0; i < numSignals; ++i) { |
| float dbAverage = 20.0 * log10(peakAverage[i]/peakAverageRef); |
| float dbRms = 20.0 * log10(peakRms[i]/peakRmsRef); |
| float reference = dbStepSize * (i - referenceStim); |
| float average_level = 0.5 * (dbAverage + dbRms); |
| float dev = fabs(average_level - reference); |
| // fprintf(stderr,"dbAverage:%f dbRms:%f reference:%f dev:%f\n", |
| // dbAverage, dbRms, reference, dev); |
| if (dev > maxDev) |
| maxDev = dev; |
| } |
| *maxDeviation = maxDev; |
| return 1; |
| } |
