// SPSA options
#define NUM_FILTER_COEFF 32
+#define NUM_SPSA_VALS (NUM_FILTER_COEFF + 2)
#define NUM_ITER 5000
#define A NUM_ITER/10 // approx
#define INITIAL_A 0.005 // A bit of trial and error...
#define GAMMA 0.166
#define ALPHA 1.0
-static float hysteresis_upper_limit = 3000.0 / 32768.0;
-static float hysteresis_lower_limit = -3000.0 / 32768.0;
+static float hysteresis_upper_limit = 0.1;
+static float hysteresis_lower_limit = -0.1;
static bool do_calibrate = true;
static bool output_cycles_plot = false;
static bool do_crop = false;
fprintf(stderr, " -a, --auto-level automatically adjust amplitude levels throughout the file\n");
fprintf(stderr, " -b, --auto-level-freq minimum frequency in Hertz of corrected level changes (default 200 Hz)\n");
fprintf(stderr, " -A, --output-leveled output leveled waveform to leveled.raw\n");
- fprintf(stderr, " -m, --min-level minimum estimated sound level (0..32768) for --auto-level\n");
+ fprintf(stderr, " -m, --min-level minimum estimated sound level (0..1) for --auto-level\n");
fprintf(stderr, " -s, --no-calibrate do not try to calibrate on sync pulse length\n");
fprintf(stderr, " -p, --plot-cycles output debugging info to cycles.plot\n");
- fprintf(stderr, " -l, --hysteresis-limit VAL change amplitude threshold for ignoring pulses (0..32768)\n");
+ fprintf(stderr, " -l, --hysteresis-limit U[:L] change amplitude threshold for ignoring pulses (-1..1)\n");
fprintf(stderr, " -f, --filter C1:C2:C3:... specify FIR filter (up to %d coefficients)\n", NUM_FILTER_COEFF);
fprintf(stderr, " -r, --rc-filter FREQ send signal through a highpass RC filter with given frequency (in Hertz)\n");
fprintf(stderr, " -F, --output-filtered output filtered waveform to filtered.raw\n");
break;
case 'm':
- min_level = atof(optarg) / 32768.0;
+ min_level = atof(optarg);
break;
case 's':
case 'l': {
const char *hyststr = strtok(optarg, ": ");
- hysteresis_upper_limit = atof(hyststr) / 32768.0;
+ hysteresis_upper_limit = atof(hyststr);
hyststr = strtok(NULL, ": ");
if (hyststr == NULL) {
hysteresis_lower_limit = -hysteresis_upper_limit;
} else {
- hysteresis_lower_limit = atof(hyststr) / 32768.0;
+ hysteresis_lower_limit = atof(hyststr);
}
break;
}
return filtered_pcm;
}
-std::vector<pulse> detect_pulses(const std::vector<float> &pcm, int sample_rate)
+std::vector<pulse> detect_pulses(const std::vector<float> &pcm, float hysteresis_upper_limit, float hysteresis_lower_limit, int sample_rate)
{
std::vector<pulse> pulses;
void spsa_train(const std::vector<float> &pcm, int sample_rate)
{
- float filter[NUM_FILTER_COEFF] = { 1.0f }; // The rest is filled with 0.
+ float vals[NUM_SPSA_VALS] = { hysteresis_upper_limit, hysteresis_lower_limit, 1.0f }; // The rest is filled with 0.
float start_c = INITIAL_C;
double best_badness = HUGE_VAL;
float c = start_c * pow(n, -GAMMA);
// find a random perturbation
- float p[NUM_FILTER_COEFF];
- float filter1[NUM_FILTER_COEFF], filter2[NUM_FILTER_COEFF];
- for (int i = 0; i < NUM_FILTER_COEFF; ++i) {
+ float p[NUM_SPSA_VALS];
+ float vals1[NUM_SPSA_VALS], vals2[NUM_SPSA_VALS];
+ for (int i = 0; i < NUM_SPSA_VALS; ++i) {
p[i] = (rand() % 2) ? 1.0 : -1.0;
- filter1[i] = std::max(std::min(filter[i] - c * p[i], 1.0f), -1.0f);
- filter2[i] = std::max(std::min(filter[i] + c * p[i], 1.0f), -1.0f);
+ vals1[i] = std::max(std::min(vals[i] - c * p[i], 1.0f), -1.0f);
+ vals2[i] = std::max(std::min(vals[i] + c * p[i], 1.0f), -1.0f);
}
- std::vector<pulse> pulses1 = detect_pulses(do_fir_filter(pcm, filter1), sample_rate);
- std::vector<pulse> pulses2 = detect_pulses(do_fir_filter(pcm, filter2), sample_rate);
+ std::vector<pulse> pulses1 = detect_pulses(do_fir_filter(pcm, vals1 + 2), vals1[0], vals1[1], sample_rate);
+ std::vector<pulse> pulses2 = detect_pulses(do_fir_filter(pcm, vals2 + 2), vals2[0], vals2[1], sample_rate);
float badness1 = eval_badness(pulses1, 1.0);
float badness2 = eval_badness(pulses2, 1.0);
// Find the gradient estimator
- float g[NUM_FILTER_COEFF];
- for (int i = 0; i < NUM_FILTER_COEFF; ++i) {
+ float g[NUM_SPSA_VALS];
+ for (int i = 0; i < NUM_SPSA_VALS; ++i) {
g[i] = (badness2 - badness1) / (2.0 * c * p[i]);
- filter[i] -= a * g[i];
- filter[i] = std::max(std::min(filter[i], 1.0f), -1.0f);
+ vals[i] -= a * g[i];
+ vals[i] = std::max(std::min(vals[i], 1.0f), -1.0f);
}
if (badness2 < badness1) {
std::swap(badness1, badness2);
- std::swap(filter1, filter2);
+ std::swap(vals1, vals2);
std::swap(pulses1, pulses2);
}
if (badness1 < best_badness) {
printf("\nNew best filter (badness=%f):", badness1);
for (int i = 0; i < NUM_FILTER_COEFF; ++i) {
- printf(" %.5f", filter1[i]);
+ printf(" %.5f", vals1[i + 2]);
}
+ printf(", hysteresis limits = %f %f\n", vals1[0], vals1[1]);
best_badness = badness1;
- printf("\n");
find_kmeans(pulses1, 1.0, train_snap_points);
exit(0);
}
- std::vector<pulse> pulses = detect_pulses(pcm, sample_rate);
+ std::vector<pulse> pulses = detect_pulses(pcm, hysteresis_upper_limit, hysteresis_lower_limit, sample_rate);
double calibration_factor = 1.0;
if (do_calibrate) {