|
Packit |
229ac0 |
/*
|
|
Packit |
229ac0 |
* Copyright (C) 2013-2015 Intel Corporation
|
|
Packit |
229ac0 |
*
|
|
Packit |
229ac0 |
* This program is free software; you can redistribute it and/or modify
|
|
Packit |
229ac0 |
* it under the terms of the GNU General Public License as published by
|
|
Packit |
229ac0 |
* the Free Software Foundation; either version 2 of the License, or
|
|
Packit |
229ac0 |
* (at your option) any later version.
|
|
Packit |
229ac0 |
*
|
|
Packit |
229ac0 |
* This program is distributed in the hope that it will be useful,
|
|
Packit |
229ac0 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
Packit |
229ac0 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
Packit |
229ac0 |
* GNU General Public License for more details.
|
|
Packit |
229ac0 |
*
|
|
Packit |
229ac0 |
*/
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
#include <stdio.h>
|
|
Packit |
229ac0 |
#include <stdlib.h>
|
|
Packit |
229ac0 |
#include <errno.h>
|
|
Packit |
229ac0 |
#include <stdbool.h>
|
|
Packit |
229ac0 |
#include <stdint.h>
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
#include <math.h>
|
|
Packit |
229ac0 |
#include <fftw3.h>
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
#include "aconfig.h"
|
|
Packit |
229ac0 |
#include "gettext.h"
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
#include "common.h"
|
|
Packit |
229ac0 |
#include "bat-signal.h"
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
static void check_amplitude(struct bat *bat, float *buf)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
float sum, average, amplitude;
|
|
Packit |
229ac0 |
int i, percent;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate average value */
|
|
Packit |
229ac0 |
for (i = 0, sum = 0.0, average = 0.0; i < bat->frames; i++)
|
|
Packit |
229ac0 |
sum += buf[i];
|
|
Packit |
229ac0 |
average = sum / bat->frames;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate peak-to-average amplitude */
|
|
Packit |
229ac0 |
for (i = 0, sum = 0.0; i < bat->frames; i++)
|
|
Packit |
229ac0 |
sum += fabsf(buf[i] - average);
|
|
Packit |
229ac0 |
amplitude = sum / bat->frames * M_PI / 2.0;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate amplitude percentage against full range */
|
|
Packit |
229ac0 |
percent = amplitude * 100 / ((1 << ((bat->sample_size << 3) - 1)) - 1);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
fprintf(bat->log, _("Amplitude: %.1f; Percentage: [%d]\n"),
|
|
Packit |
229ac0 |
amplitude, percent);
|
|
Packit |
229ac0 |
if (percent < 0)
|
|
Packit |
229ac0 |
fprintf(bat->err, _("ERROR: Amplitude can't be negative!\n"));
|
|
Packit |
229ac0 |
else if (percent < 1)
|
|
Packit |
229ac0 |
fprintf(bat->err, _("WARNING: Signal too weak!\n"));
|
|
Packit |
229ac0 |
else if (percent > 100)
|
|
Packit |
229ac0 |
fprintf(bat->err, _("WARNING: Signal overflow!\n"));
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/**
|
|
Packit |
229ac0 |
*
|
|
Packit |
229ac0 |
* @return 0 if peak detected at right frequency,
|
|
Packit |
229ac0 |
* 1 if peak detected somewhere else
|
|
Packit |
229ac0 |
* 2 if DC detected
|
|
Packit |
229ac0 |
*/
|
|
Packit |
229ac0 |
int check_peak(struct bat *bat, struct analyze *a, int end, int peak, float hz,
|
|
Packit |
229ac0 |
float mean, float p, int channel, int start)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
int err;
|
|
Packit |
229ac0 |
float hz_peak = (float) (peak) * hz;
|
|
Packit |
229ac0 |
float delta_rate = DELTA_RATE * bat->target_freq[channel];
|
|
Packit |
229ac0 |
float delta_HZ = DELTA_HZ;
|
|
Packit |
229ac0 |
float tolerance = (delta_rate > delta_HZ) ? delta_rate : delta_HZ;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
fprintf(bat->log, _("Detected peak at %2.2f Hz of %2.2f dB\n"), hz_peak,
|
|
Packit |
229ac0 |
10.0 * log10f(a->mag[peak] / mean));
|
|
Packit |
229ac0 |
fprintf(bat->log, _(" Total %3.1f dB from %2.2f to %2.2f Hz\n"),
|
|
Packit |
229ac0 |
10.0 * log10f(p / mean), start * hz, end * hz);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
if (hz_peak < DC_THRESHOLD) {
|
|
Packit |
229ac0 |
fprintf(bat->err, _(" WARNING: Found low peak %2.2f Hz,"),
|
|
Packit |
229ac0 |
hz_peak);
|
|
Packit |
229ac0 |
fprintf(bat->err, _(" very close to DC\n"));
|
|
Packit |
229ac0 |
err = FOUND_DC;
|
|
Packit |
229ac0 |
} else if (hz_peak < bat->target_freq[channel] - tolerance) {
|
|
Packit |
229ac0 |
fprintf(bat->err, _(" FAIL: Peak freq too low %2.2f Hz\n"),
|
|
Packit |
229ac0 |
hz_peak);
|
|
Packit |
229ac0 |
err = FOUND_WRONG_PEAK;
|
|
Packit |
229ac0 |
} else if (hz_peak > bat->target_freq[channel] + tolerance) {
|
|
Packit |
229ac0 |
fprintf(bat->err, _(" FAIL: Peak freq too high %2.2f Hz\n"),
|
|
Packit |
229ac0 |
hz_peak);
|
|
Packit |
229ac0 |
err = FOUND_WRONG_PEAK;
|
|
Packit |
229ac0 |
} else {
|
|
Packit |
229ac0 |
fprintf(bat->log, _(" PASS: Peak detected"));
|
|
Packit |
229ac0 |
fprintf(bat->log, _(" at target frequency\n"));
|
|
Packit |
229ac0 |
err = 0;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/**
|
|
Packit |
229ac0 |
* Search for main frequencies in fft results and compare it to target
|
|
Packit |
229ac0 |
*/
|
|
Packit |
229ac0 |
static int check(struct bat *bat, struct analyze *a, int channel)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
float hz = 1.0 / ((float) bat->frames / (float) bat->rate);
|
|
Packit |
229ac0 |
float mean = 0.0, t, sigma = 0.0, p = 0.0;
|
|
Packit |
229ac0 |
int i, start = -1, end = -1, peak = 0, signals = 0;
|
|
Packit |
229ac0 |
int err = 0, N = bat->frames / 2;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate mean */
|
|
Packit |
229ac0 |
for (i = 0; i < N; i++)
|
|
Packit |
229ac0 |
mean += a->mag[i];
|
|
Packit |
229ac0 |
mean /= (float) N;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate standard deviation */
|
|
Packit |
229ac0 |
for (i = 0; i < N; i++) {
|
|
Packit |
229ac0 |
t = a->mag[i] - mean;
|
|
Packit |
229ac0 |
t *= t;
|
|
Packit |
229ac0 |
sigma += t;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
sigma /= (float) N;
|
|
Packit |
229ac0 |
sigma = sqrtf(sigma);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* clip any data less than k sigma + mean */
|
|
Packit |
229ac0 |
for (i = 0; i < N; i++) {
|
|
Packit |
229ac0 |
if (a->mag[i] > mean + bat->sigma_k * sigma) {
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* find peak start points */
|
|
Packit |
229ac0 |
if (start == -1) {
|
|
Packit |
229ac0 |
start = peak = end = i;
|
|
Packit |
229ac0 |
signals++;
|
|
Packit |
229ac0 |
} else {
|
|
Packit |
229ac0 |
if (a->mag[i] > a->mag[peak])
|
|
Packit |
229ac0 |
peak = i;
|
|
Packit |
229ac0 |
end = i;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
p += a->mag[i];
|
|
Packit |
229ac0 |
} else if (start != -1) {
|
|
Packit |
229ac0 |
/* Check if peak is as expected */
|
|
Packit |
229ac0 |
err |= check_peak(bat, a, end, peak, hz, mean,
|
|
Packit |
229ac0 |
p, channel, start);
|
|
Packit |
229ac0 |
end = start = -1;
|
|
Packit |
229ac0 |
if (signals == MAX_PEAKS)
|
|
Packit |
229ac0 |
break;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
if (signals == 0)
|
|
Packit |
229ac0 |
err = -ENOPEAK; /* No peak detected */
|
|
Packit |
229ac0 |
else if ((err == FOUND_DC) && (signals == 1))
|
|
Packit |
229ac0 |
err = -EONLYDC; /* Only DC detected */
|
|
Packit |
229ac0 |
else if ((err & FOUND_WRONG_PEAK) == FOUND_WRONG_PEAK)
|
|
Packit |
229ac0 |
err = -EBADPEAK; /* Bad peak detected */
|
|
Packit |
229ac0 |
else
|
|
Packit |
229ac0 |
err = 0; /* Correct peak detected */
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
fprintf(bat->log, _("Detected at least %d signal(s) in total\n"),
|
|
Packit |
229ac0 |
signals);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
static void calc_magnitude(struct bat *bat, struct analyze *a, int N)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
float r2, i2;
|
|
Packit |
229ac0 |
int i;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
for (i = 1; i < N / 2; i++) {
|
|
Packit |
229ac0 |
r2 = a->out[i] * a->out[i];
|
|
Packit |
229ac0 |
i2 = a->out[N - i] * a->out[N - i];
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
a->mag[i] = sqrtf(r2 + i2);
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
a->mag[0] = 0.0;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
static int find_and_check_harmonics(struct bat *bat, struct analyze *a,
|
|
Packit |
229ac0 |
int channel)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
fftwf_plan p;
|
|
Packit |
229ac0 |
int err = -ENOMEM, N = bat->frames;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* Allocate FFT buffers */
|
|
Packit |
229ac0 |
a->in = (float *) fftwf_malloc(sizeof(float) * bat->frames);
|
|
Packit |
229ac0 |
if (a->in == NULL)
|
|
Packit |
229ac0 |
goto out1;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
a->out = (float *) fftwf_malloc(sizeof(float) * bat->frames);
|
|
Packit |
229ac0 |
if (a->out == NULL)
|
|
Packit |
229ac0 |
goto out2;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
a->mag = (float *) fftwf_malloc(sizeof(float) * bat->frames);
|
|
Packit |
229ac0 |
if (a->mag == NULL)
|
|
Packit |
229ac0 |
goto out3;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* create FFT plan */
|
|
Packit |
229ac0 |
p = fftwf_plan_r2r_1d(N, a->in, a->out, FFTW_R2HC,
|
|
Packit |
229ac0 |
FFTW_MEASURE | FFTW_PRESERVE_INPUT);
|
|
Packit |
229ac0 |
if (p == NULL)
|
|
Packit |
229ac0 |
goto out4;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* convert source PCM to floats */
|
|
Packit |
229ac0 |
bat->convert_sample_to_float(a->buf, a->in, bat->frames);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* check amplitude */
|
|
Packit |
229ac0 |
check_amplitude(bat, a->in);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* run FFT */
|
|
Packit |
229ac0 |
fftwf_execute(p);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* FFT out is real and imaginary numbers - calc magnitude for each */
|
|
Packit |
229ac0 |
calc_magnitude(bat, a, N);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* check data */
|
|
Packit |
229ac0 |
err = check(bat, a, channel);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
fftwf_destroy_plan(p);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
out4:
|
|
Packit |
229ac0 |
fftwf_free(a->mag);
|
|
Packit |
229ac0 |
out3:
|
|
Packit |
229ac0 |
fftwf_free(a->out);
|
|
Packit |
229ac0 |
out2:
|
|
Packit |
229ac0 |
fftwf_free(a->in);
|
|
Packit |
229ac0 |
out1:
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
static int calculate_noise_one_period(struct bat *bat,
|
|
Packit |
229ac0 |
struct noise_analyzer *na, float *src,
|
|
Packit |
229ac0 |
int length, int channel)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
int i, shift = 0;
|
|
Packit |
229ac0 |
float tmp, rms, gain, residual;
|
|
Packit |
229ac0 |
float a = 0.0, b = 1.0;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* step 1. phase compensation */
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
if (length < 2 * na->nsamples)
|
|
Packit |
229ac0 |
return -EINVAL;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* search for the beginning of a sine period */
|
|
Packit |
229ac0 |
for (i = 0, tmp = 0.0, shift = -1; i < na->nsamples; i++) {
|
|
Packit |
229ac0 |
/* find i where src[i] >= 0 && src[i+1] < 0 */
|
|
Packit |
229ac0 |
if (src[i] < 0.0)
|
|
Packit |
229ac0 |
continue;
|
|
Packit |
229ac0 |
if (src[i + 1] < 0.0) {
|
|
Packit |
229ac0 |
tmp = src[i] - src[i + 1];
|
|
Packit |
229ac0 |
a = src[i] / tmp;
|
|
Packit |
229ac0 |
b = -src[i + 1] / tmp;
|
|
Packit |
229ac0 |
shift = i;
|
|
Packit |
229ac0 |
break;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* didn't find the beginning of a sine period */
|
|
Packit |
229ac0 |
if (shift == -1)
|
|
Packit |
229ac0 |
return -EINVAL;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* shift sine waveform to source[0] = 0.0 */
|
|
Packit |
229ac0 |
for (i = 0; i < na->nsamples; i++)
|
|
Packit |
229ac0 |
na->source[i] = a * src[i + shift + 1] + b * src[i + shift];
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* step 2. gain compensation */
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate rms of signal amplitude */
|
|
Packit |
229ac0 |
for (i = 0, tmp = 0.0; i < na->nsamples; i++)
|
|
Packit |
229ac0 |
tmp += na->source[i] * na->source[i];
|
|
Packit |
229ac0 |
rms = sqrtf(tmp / na->nsamples);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
gain = na->rms_tgt / rms;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
for (i = 0; i < na->nsamples; i++)
|
|
Packit |
229ac0 |
na->source[i] *= gain;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* step 3. calculate snr in dB */
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
for (i = 0, tmp = 0.0, residual = 0.0; i < na->nsamples; i++) {
|
|
Packit |
229ac0 |
tmp = fabsf(na->target[i] - na->source[i]);
|
|
Packit |
229ac0 |
residual += tmp * tmp;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
tmp = na->rms_tgt / sqrtf(residual / na->nsamples);
|
|
Packit |
229ac0 |
na->snr_db = 20.0 * log10f(tmp);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
return 0;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
static int calculate_noise(struct bat *bat, float *src, int channel)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
int err = 0;
|
|
Packit |
229ac0 |
struct noise_analyzer na;
|
|
Packit |
229ac0 |
float freq = bat->target_freq[channel];
|
|
Packit |
229ac0 |
float tmp, sum_snr_pc, avg_snr_pc, avg_snr_db;
|
|
Packit |
229ac0 |
int offset, i, cnt_noise, cnt_clean;
|
|
Packit |
229ac0 |
/* num of samples in each sine period */
|
|
Packit |
229ac0 |
int nsamples = (int) ceilf(bat->rate / freq);
|
|
Packit |
229ac0 |
/* each section has 2 sine periods, the first one for locating
|
|
Packit |
229ac0 |
* and the second one for noise calculating */
|
|
Packit |
229ac0 |
int nsamples_per_section = nsamples * 2;
|
|
Packit |
229ac0 |
/* all sine periods will be calculated except the first one */
|
|
Packit |
229ac0 |
int nsection = bat->frames / nsamples - 1;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
fprintf(bat->log, _("samples per period: %d\n"), nsamples);
|
|
Packit |
229ac0 |
fprintf(bat->log, _("total sections to detect: %d\n"), nsection);
|
|
Packit |
229ac0 |
na.source = (float *)malloc(sizeof(float) * nsamples);
|
|
Packit |
229ac0 |
if (!na.source) {
|
|
Packit |
229ac0 |
err = -ENOMEM;
|
|
Packit |
229ac0 |
goto out1;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
na.target = (float *)malloc(sizeof(float) * nsamples);
|
|
Packit |
229ac0 |
if (!na.target) {
|
|
Packit |
229ac0 |
err = -ENOMEM;
|
|
Packit |
229ac0 |
goto out2;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* generate standard single-tone signal */
|
|
Packit |
229ac0 |
err = generate_sine_wave_raw_mono(bat, na.target, freq, nsamples);
|
|
Packit |
229ac0 |
if (err < 0)
|
|
Packit |
229ac0 |
goto out3;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
na.nsamples = nsamples;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate rms of standard signal */
|
|
Packit |
229ac0 |
for (i = 0, tmp = 0.0; i < nsamples; i++)
|
|
Packit |
229ac0 |
tmp += na.target[i] * na.target[i];
|
|
Packit |
229ac0 |
na.rms_tgt = sqrtf(tmp / nsamples);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* calculate average noise level */
|
|
Packit |
229ac0 |
sum_snr_pc = 0.0;
|
|
Packit |
229ac0 |
cnt_clean = cnt_noise = 0;
|
|
Packit |
229ac0 |
for (i = 0, offset = 0; i < nsection; i++) {
|
|
Packit |
229ac0 |
na.snr_db = SNR_DB_INVALID;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
err = calculate_noise_one_period(bat, &na, src + offset,
|
|
Packit |
229ac0 |
nsamples_per_section, channel);
|
|
Packit |
229ac0 |
if (err < 0)
|
|
Packit |
229ac0 |
goto out3;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
if (na.snr_db > bat->snr_thd_db) {
|
|
Packit |
229ac0 |
cnt_clean++;
|
|
Packit |
229ac0 |
sum_snr_pc += 100.0 / powf(10.0, na.snr_db / 20.0);
|
|
Packit |
229ac0 |
} else {
|
|
Packit |
229ac0 |
cnt_noise++;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
offset += nsamples;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
if (cnt_noise > 0) {
|
|
Packit |
229ac0 |
fprintf(bat->err, _("Noise detected at %d points.\n"),
|
|
Packit |
229ac0 |
cnt_noise);
|
|
Packit |
229ac0 |
err = -cnt_noise;
|
|
Packit |
229ac0 |
if (cnt_clean == 0)
|
|
Packit |
229ac0 |
goto out3;
|
|
Packit |
229ac0 |
} else {
|
|
Packit |
229ac0 |
fprintf(bat->log, _("No noise detected.\n"));
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
avg_snr_pc = sum_snr_pc / cnt_clean;
|
|
Packit |
229ac0 |
avg_snr_db = 20.0 * log10f(100.0 / avg_snr_pc);
|
|
Packit |
229ac0 |
fprintf(bat->log, _("Average SNR is %.2f dB (%.2f %%) at %d points.\n"),
|
|
Packit |
229ac0 |
avg_snr_db, avg_snr_pc, cnt_clean);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
out3:
|
|
Packit |
229ac0 |
free(na.target);
|
|
Packit |
229ac0 |
out2:
|
|
Packit |
229ac0 |
free(na.source);
|
|
Packit |
229ac0 |
out1:
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
static int find_and_check_noise(struct bat *bat, void *buf, int channel)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
int err = 0;
|
|
Packit |
229ac0 |
float *source;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
source = (float *)malloc(sizeof(float) * bat->frames);
|
|
Packit |
229ac0 |
if (!source)
|
|
Packit |
229ac0 |
return -ENOMEM;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* convert source PCM to floats */
|
|
Packit |
229ac0 |
bat->convert_sample_to_float(buf, source, bat->frames);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* adjust waveform and calculate noise */
|
|
Packit |
229ac0 |
err = calculate_noise(bat, source, channel);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
free(source);
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/**
|
|
Packit |
229ac0 |
* Convert interleaved samples from channels in samples from a single channel
|
|
Packit |
229ac0 |
*/
|
|
Packit |
229ac0 |
static int reorder_data(struct bat *bat)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
char *p, *new_bat_buf;
|
|
Packit |
229ac0 |
int ch, i, j;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
if (bat->channels == 1)
|
|
Packit |
229ac0 |
return 0; /* No need for reordering */
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
p = malloc(bat->frames * bat->frame_size);
|
|
Packit |
229ac0 |
new_bat_buf = p;
|
|
Packit |
229ac0 |
if (p == NULL)
|
|
Packit |
229ac0 |
return -ENOMEM;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
for (ch = 0; ch < bat->channels; ch++) {
|
|
Packit |
229ac0 |
for (j = 0; j < bat->frames; j++) {
|
|
Packit |
229ac0 |
for (i = 0; i < bat->sample_size; i++) {
|
|
Packit |
229ac0 |
*p++ = ((char *) (bat->buf))[j * bat->frame_size
|
|
Packit |
229ac0 |
+ ch * bat->sample_size + i];
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
free(bat->buf);
|
|
Packit |
229ac0 |
bat->buf = new_bat_buf;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
return 0;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* truncate sample frames for faster FFT analysis process */
|
|
Packit |
229ac0 |
static int truncate_frames(struct bat *bat)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
int shift = SHIFT_MAX;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
for (; shift > SHIFT_MIN; shift--)
|
|
Packit |
229ac0 |
if (bat->frames & (1 << shift)) {
|
|
Packit |
229ac0 |
bat->frames = 1 << shift;
|
|
Packit |
229ac0 |
return 0;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
return -EINVAL;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
int analyze_capture(struct bat *bat)
|
|
Packit |
229ac0 |
{
|
|
Packit |
229ac0 |
int err = 0;
|
|
Packit |
229ac0 |
size_t items;
|
|
Packit |
229ac0 |
int c;
|
|
Packit |
229ac0 |
struct analyze a;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
err = truncate_frames(bat);
|
|
Packit |
229ac0 |
if (err < 0) {
|
|
Packit |
229ac0 |
fprintf(bat->err, _("Invalid frame number for analysis: %d\n"),
|
|
Packit |
229ac0 |
bat->frames);
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
fprintf(bat->log, _("\nBAT analysis: signal has %d frames at %d Hz,"),
|
|
Packit |
229ac0 |
bat->frames, bat->rate);
|
|
Packit |
229ac0 |
fprintf(bat->log, _(" %d channels, %d bytes per sample.\n"),
|
|
Packit |
229ac0 |
bat->channels, bat->sample_size);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
bat->buf = malloc(bat->frames * bat->frame_size);
|
|
Packit |
229ac0 |
if (bat->buf == NULL)
|
|
Packit |
229ac0 |
return -ENOMEM;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
bat->fp = fopen(bat->capture.file, "rb");
|
|
Packit |
229ac0 |
err = -errno;
|
|
Packit |
229ac0 |
if (bat->fp == NULL) {
|
|
Packit |
229ac0 |
fprintf(bat->err, _("Cannot open file: %s %d\n"),
|
|
Packit |
229ac0 |
bat->capture.file, err);
|
|
Packit |
229ac0 |
goto exit1;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
/* Skip header */
|
|
Packit |
229ac0 |
err = read_wav_header(bat, bat->capture.file, bat->fp, true);
|
|
Packit |
229ac0 |
if (err != 0)
|
|
Packit |
229ac0 |
goto exit2;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
items = fread(bat->buf, bat->frame_size, bat->frames, bat->fp);
|
|
Packit |
229ac0 |
if (items != bat->frames) {
|
|
Packit |
229ac0 |
err = -EIO;
|
|
Packit |
229ac0 |
goto exit2;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
err = reorder_data(bat);
|
|
Packit |
229ac0 |
if (err != 0)
|
|
Packit |
229ac0 |
goto exit2;
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
for (c = 0; c < bat->channels; c++) {
|
|
Packit |
229ac0 |
fprintf(bat->log, _("\nChannel %i - "), c + 1);
|
|
Packit |
229ac0 |
fprintf(bat->log, _("Checking for target frequency %2.2f Hz\n"),
|
|
Packit |
229ac0 |
bat->target_freq[c]);
|
|
Packit |
229ac0 |
a.buf = bat->buf +
|
|
Packit |
229ac0 |
c * bat->frames * bat->frame_size
|
|
Packit |
229ac0 |
/ bat->channels;
|
|
Packit |
229ac0 |
if (!bat->standalone) {
|
|
Packit |
229ac0 |
err = find_and_check_harmonics(bat, &a, c);
|
|
Packit |
229ac0 |
if (err != 0)
|
|
Packit |
229ac0 |
goto exit2;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
if (snr_is_valid(bat->snr_thd_db)) {
|
|
Packit |
229ac0 |
fprintf(bat->log, _("\nChecking for SNR: "));
|
|
Packit |
229ac0 |
fprintf(bat->log, _("Threshold is %.2f dB (%.2f%%)\n"),
|
|
Packit |
229ac0 |
bat->snr_thd_db, 100.0
|
|
Packit |
229ac0 |
/ powf(10.0, bat->snr_thd_db / 20.0));
|
|
Packit |
229ac0 |
err = find_and_check_noise(bat, a.buf, c);
|
|
Packit |
229ac0 |
if (err != 0)
|
|
Packit |
229ac0 |
goto exit2;
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
}
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
exit2:
|
|
Packit |
229ac0 |
fclose(bat->fp);
|
|
Packit |
229ac0 |
exit1:
|
|
Packit |
229ac0 |
free(bat->buf);
|
|
Packit |
229ac0 |
|
|
Packit |
229ac0 |
return err;
|
|
Packit |
229ac0 |
}
|