When training, K-means to find the more-or-less ideal buckets. Not actually used...

[c64tapwav] / decode.cpp

diff --git a/decode.cpp b/decode.cpp
index ab242d0be5845f7145e0b40ca75c5a646207ca25..7d5fe4338f5f38586d9ec428d273d3fb34fa2115 100644 (file)
--- a/decode.cpp
+++ b/decode.cpp
@@ -42,6 +42,12 @@ static bool output_leveled = false;
 static std::vector<float> train_snap_points;
 static bool do_train = false;
 
+// The minimum estimated sound level (for do_auto_level) at any given point.
+// If you decrease this, you'll be able to amplify really silent signals
+// by more, but you'll also increase the level of silent (ie. noise-only) segments,
+// possibly caused misdetected pulses in these segments.
+static float min_level = 0.05f;
+
 // between [x,x+1]
 double find_zerocrossing(const std::vector<float> &pcm, int x)
 {
@@ -164,6 +170,7 @@ void output_tap(const std::vector<pulse>& pulses, double calibration_factor)
 
 static struct option long_options[] = {
        {"auto-level",       0,                 0, 'a' },
+       {"output-leveled",   0,                 0, 'A' },
        {"no-calibrate",     0,                 0, 's' },
        {"plot-cycles",      0,                 0, 'p' },
        {"hysteresis-limit", required_argument, 0, 'l' },
@@ -181,6 +188,7 @@ void help()
        fprintf(stderr, "\n");
        fprintf(stderr, "  -a, --auto-level             automatically adjust amplitude levels throughout the file\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, "  -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");
@@ -198,7 +206,7 @@ void parse_options(int argc, char **argv)
 {
        for ( ;; ) {
                int option_index = 0;
-               int c = getopt_long(argc, argv, "aAspl:f:Fc:t:qh", long_options, &option_index);
+               int c = getopt_long(argc, argv, "aAm:spl:f:Fc:t:qh", long_options, &option_index);
                if (c == -1)
                        break;
 
@@ -211,6 +219,10 @@ void parse_options(int argc, char **argv)
                        output_leveled = true;
                        break;
 
+               case 'm':
+                       min_level = atof(optarg) / 32768.0;
+                       break;
+
                case 's':
                        do_calibrate = false;
                        break;
@@ -368,24 +380,80 @@ void output_cycle_plot(const std::vector<pulse> &pulses, double calibration_fact
        fclose(fp);
 }
 
+std::pair<int, double> find_closest_point(double x, const std::vector<float> &points)
+{
+       int best_point = 0;
+       double best_dist = (x - points[0]) * (x - points[0]);
+       for (unsigned j = 1; j < train_snap_points.size(); ++j) {
+               double dist = (x - points[j]) * (x - points[j]);
+               if (dist < best_dist) {
+                       best_point = j;
+                       best_dist = dist;
+               }
+       }
+       return std::make_pair(best_point, best_dist);
+}
+
 float eval_badness(const std::vector<pulse>& pulses, double calibration_factor)
 {
        double sum_badness = 0.0;
        for (unsigned i = 0; i < pulses.size(); ++i) {
                double cycles = pulses[i].len * calibration_factor * C64_FREQUENCY;
                if (cycles > 2000.0) cycles = 2000.0;  // Don't make pauses arbitrarily bad.
-               double badness = (cycles - train_snap_points[0]) * (cycles - train_snap_points[0]);
-               for (unsigned j = 1; j < train_snap_points.size(); ++j) {
-                       badness = std::min(badness, (cycles - train_snap_points[j]) * (cycles - train_snap_points[j]));
-               }
-               sum_badness += badness;
+               std::pair<int, double> selected_point_and_sq_dist = find_closest_point(cycles, train_snap_points);
+               sum_badness += selected_point_and_sq_dist.second;
        }
        return sqrt(sum_badness / (pulses.size() - 1));
 }
 
-void spsa_train(std::vector<float> &pcm, int sample_rate)
+void find_kmeans(const std::vector<pulse> &pulses, double calibration_factor, const std::vector<float> &initial_centers)
+{
+       std::vector<float> last_centers = initial_centers;
+       std::vector<float> sums;
+       std::vector<float> num;
+       sums.resize(initial_centers.size());
+       num.resize(initial_centers.size());
+       for ( ;; ) {
+               for (unsigned i = 0; i < initial_centers.size(); ++i) {
+                       sums[i] = 0.0f;
+                       num[i] = 0;
+               }
+               for (unsigned i = 0; i < pulses.size(); ++i) {
+                       double cycles = pulses[i].len * calibration_factor * C64_FREQUENCY;
+                       // Ignore heavy outliers, which are almost always long pauses.
+                       if (cycles > 2000.0) {
+                               continue;
+                       }
+                       std::pair<int, double> selected_point_and_sq_dist = find_closest_point(cycles, last_centers);
+                       int p = selected_point_and_sq_dist.first;
+                       sums[p] += cycles;
+                       ++num[p];
+               }
+               bool any_moved = false;
+               for (unsigned i = 0; i < initial_centers.size(); ++i) {
+                       if (num[i] == 0) {
+                               printf("K-means broke down, can't output new reference training points\n");
+                               return;
+                       }
+                       float new_center = sums[i] / num[i];
+                       if (fabs(new_center - last_centers[i]) > 1e-3) {
+                               any_moved = true;
+                       }
+                       last_centers[i] = new_center;
+               }
+               if (!any_moved) {
+                       break;
+               }
+       }
+       printf("New reference training points:");
+       for (unsigned i = 0; i < last_centers.size(); ++i) {
+               printf(" %.3f", last_centers[i]);
+       }
+       printf("\n");
+}
+
+void spsa_train(const std::vector<float> &pcm, int sample_rate)
 {
-       // Train!
        float filter[NUM_FILTER_COEFF] = { 1.0f };  // The rest is filled with 0.
 
        float start_c = INITIAL_C;
@@ -429,6 +497,8 @@ void spsa_train(std::vector<float> &pcm, int sample_rate)
                        best_badness = badness1;
                        printf("\n");
 
+                       find_kmeans(pulses1, 1.0, train_snap_points);
+
                        if (output_cycles_plot) {
                                output_cycle_plot(pulses1, 1.0);
                        }
@@ -458,7 +528,7 @@ int main(int argc, char **argv)
        }
 
        if (do_auto_level) {
-               pcm = level_samples(pcm, sample_rate);
+               pcm = level_samples(pcm, min_level, sample_rate);
                if (output_leveled) {
                        FILE *fp = fopen("leveled.raw", "wb");
                        fwrite(pcm.data(), pcm.size() * sizeof(pcm[0]), 1, fp);