Merge branch 'pitch-detect'

* pitch-detect:
  LIB: minor performance optimization for pitch detection
  LIB: FFT: make test program initialization for new arrays faster
  GLUI: MorphWavSourceView: fix unused lambda capture warning
  GLUI: InstEditNote: cleanup pitch detection worker thread initialization
  LIB: cleanup variable names in pitch detection algorithm
  GLUI: InstEditNote: update comments for detect note related objects
  GLUI: InstEditNote: only start pitch detection timer if thread is active
  LIB: provide a reference to the original pitch detection paper
  LIB: use static / anon namespace for pitch detection helpers
  TESTS: .gitignore for testpitchdetect
  GLUI: InstEditNote: add "Cancel" button for pitch detection
  GLUI: NoteWidget: provide visual "blinking" feedback for pitch detection
  GLUI: avoid deep copy of Sample wav_data in pitch detection thread
  TESTS: testpitchdetect: add tests for WavData -> midi note pitch detection
  TESTS: testpitchdetect: add unit tests for pitch detect twm
  LIB: provide pitch detection twm function for unit tests
  GLUI: do nothing if pitch detection failed
  GLUI: fix crashes by better InstEditWindow Instrument ownership rules
  SRC: smenc: handle pitch detection error
  LIB: detect_pitch: return -1 if pitch detection fails
  GLUI: display progress bar during pitch detection
  LIB: report progress from pitch detection function
  GLUI: support pitch detection in instrument editor in background thread
  LIB: support stopping pitch detection before it is done (kill_function)
  LIB: cleanup pitch detection code a little bit
  LIB: make pitch detection work properly on multi channel input data
  SRC: smenc: add options to automatically detect fundamental freq / note
  TESTS: use pitch detection code from library
  LIB: add pitch detection code to library
  TESTS: testpitchdetect: optimize freq err -> midi note loop
  TESTS: testpitchdetect: fix out-of-bounds write due to bad FFT array
  TESTS: testpitchdetect: avoid full grid search (performance)
	This could possibly lead to suboptimal results, however for the test material
	used to validate the correctness of the algorithm, the results are still the
	very good.
  TESTS: testpitchdetect: simplify error computation, remove extra pow()
  TESTS: testpitchdetect: use fast vector sin (performance)
  TESTS: testpitchdetect: improve accuracy for some cases
	 - use finer grid for initial twm pitch estimate
	 - estimate note as double
	 - ignore outliers in additional note estimation pass
  TESTS: testpitchdetect: extend search range to 5kHz for fundamental
  TESTS: testpitchdetect: use all selected partials for error_m2p
  TESTS: testpitchdetect: use mag sum weighted frequency errors
  TESTS: testpitchdetect: only use stronger partials for pitch detection
  TESTS: testpitchdetect: fix error_p2m computation
  TESTS: testpitchdetect: automatically detect window size to use
  TESTS: testpitchdetect: try to find most likely midi note from freqs
  TESTS: testpitchdetect: improve golden section search performance
  TESTS: testpitchdetect: use golden section search
  TESTS: testpitchdetect: use local minimum + refinement to find best freq
  TESTS: testpitchdetect: implement basic two-way-mismatch pitch detection
  TESTS: testpitchdetect: started to implement pitch detection

Signed-off-by: Stefan Westerfeld <stefan@space.twc.de>

Author: swesterfeld

glui/sminsteditnote.hh

@@ -13,10 +13,81 @@
 #include "smscrollview.hh"
 #include "smsynthinterface.hh"
 #include "smsimplelines.hh"
+#include "smpitchdetect.hh"
+#include "smprogressbar.hh"
 
 namespace SpectMorph
 {
 
+class PitchDetectionThread : public SignalReceiver
+{
+  std::thread worker;
+  std::atomic<bool> done = false;
+  std::atomic<bool> killed = false;
+  std::atomic<double> progress = 0;
+  double midi_note = -1;
+  Sample::SharedP sample_shared; // keep Sample wav_data alive as long as needed
+  Sample *sample = nullptr;
+
+  void
+  on_samples_changed()
+  {
+    /* ui thread */
+    sample = nullptr;
+    killed = true;
+  }
+public:
+  PitchDetectionThread (Window *window, Instrument *instrument, Sample *sample) :
+    sample_shared (sample->shared()),
+    sample (sample)
+  {
+    /* ui thread */
+    connect (instrument->signal_samples_changed, this, &PitchDetectionThread::on_samples_changed);
+
+    worker = std::thread ([this]()
+      {
+        /* worker thread
+         *
+         * using sample_shared keeps a reference on the wav_data of the sample,
+         * which keeps alive the wav_data we're using for pitch detection even
+         * if the Instrument Sample is destroyed before we're done
+         */
+        midi_note = detect_pitch (sample_shared->wav_data(), [this] (double progress) { this->progress = progress; return killed.load(); });
+        done = true;
+      });
+  }
+  ~PitchDetectionThread()
+  {
+    /* ui thread */
+    killed = true;
+    worker.join();
+  }
+  int
+  result()
+  {
+    /* ui thread */
+    assert (is_done());
+    return lrint (midi_note);
+  }
+  double
+  timer_tick()
+  {
+    /* ui thread */
+    if (is_done())
+      {
+        if (sample && midi_note != -1) // midi_note is -1 if pitch detection failed
+          sample->set_midi_note (lrint (midi_note));
+      }
+    return progress.load();
+  }
+  bool
+  is_done() const
+  {
+    /* any thread */
+    return done.load();
+  }
+};
+
 class NoteWidget : public Widget
 {
   int first = 12;
@@ -49,6 +120,9 @@ class NoteWidget : public Widget
   int mouse_note = -1;
   int left_pressed_note = -1;
   int right_pressed_note = -1;
+  int pitch_detection_note = -1;
+  int pitch_detection_age = 0;
+  Timer *pitch_detection_note_timer = nullptr;
   Instrument     *instrument      = nullptr;
   SynthInterface *synth_interface = nullptr;
   std::vector<int> active_notes;
@@ -59,6 +133,8 @@ public:
     instrument (instrument),
     synth_interface (synth_interface)
   {
+    pitch_detection_note_timer = new Timer (this);
+    connect (pitch_detection_note_timer->signal_timeout, this, &NoteWidget::on_pitch_detection_timer);
     connect (instrument->signal_samples_changed, this, &NoteWidget::on_samples_changed);
   }
   void
@@ -126,7 +202,8 @@ public:
             for (auto note : active_notes)
               if (n == note)
                 note_playing = true;
-            if (n == mouse_note || note_playing)
+            bool display_pitch_detect = (n == pitch_detection_note && (pitch_detection_age % 2) == 0);
+            if (n == mouse_note || display_pitch_detect || note_playing)
               {
                 double xspace = width() / cols / 10;
                 double yspace = height() / rows / 10;
@@ -138,6 +215,12 @@ public:
                     fill_color  = ThemeColor::SLIDER;
                     text_color  = Color (0, 0, 0);
                   }
+                else if (display_pitch_detect)
+                  {
+                    frame_color = Color::null();
+                    fill_color  = ThemeColor::MENU_ITEM;
+                    text_color  = Color (0, 0, 0);
+                  }
                 else
                   {
                     frame_color = Color (0.8, 0.8, 0.8);
@@ -236,14 +319,36 @@ public:
         update();
       }
   }
+  void
+  set_pitch_detection_note (int note)
+  {
+    pitch_detection_age  = 0;
+    pitch_detection_note = note;
+    update();
+
+    pitch_detection_note_timer->start (300);
+  }
+  void
+  on_pitch_detection_timer()
+  {
+    pitch_detection_age++;
+    if (pitch_detection_age == 3)
+      pitch_detection_note_timer->stop();
+    update();
+  }
 };
 
 class InstEditNote : public Window
 {
   NoteWidget *note_widget = nullptr;
+  Timer *detect_note_timer = nullptr;
+  ProgressBar *detect_note_progress_bar = nullptr;
+  Button *detect_note_button = nullptr;
+  Button *detect_note_cancel_button = nullptr;
+  std::unique_ptr<PitchDetectionThread> pitch_detection_thread;
 public:
   InstEditNote (Window *window, Instrument *instrument, SynthInterface *synth_interface) :
-    Window (*window->event_loop(), "SpectMorph - Instrument Note", 13 * 40 + 2 * 8, 9 * 40 + 6 * 8, 0, false, window->native_window())
+    Window (*window->event_loop(), "SpectMorph - Instrument Note", 13 * 40 + 2 * 8, 9 * 40 + 8 * 8, 0, false, window->native_window())
   {
     set_close_callback ([this]() {
       signal_closed();
@@ -255,7 +360,7 @@ public:
 
     note_widget = new NoteWidget (this, instrument, synth_interface);
     FixedGrid grid;
-    grid.add_widget (note_widget, 1, 1, width() / 8 - 2, height() / 8 - 6);
+    grid.add_widget (note_widget, 1, 1, width() / 8 - 2, height() / 8 - 8);
 
     Label *left = new Label (this, "Left Click");
     Label *left_txt = new Label (this, "Play Reference");
@@ -273,19 +378,74 @@ public:
     Label *space_txt = new Label (this, "Play Selected Note");
     space->set_bold (true);
 
+    /*--- detect note: timer ---*/
+    detect_note_timer = new Timer (this);
+    connect (detect_note_timer->signal_timeout, [this] ()
+      {
+        if (pitch_detection_thread)
+          {
+            double progress = pitch_detection_thread->timer_tick();
+            detect_note_progress_bar->set_value (progress * 0.01);
+            if (pitch_detection_thread->is_done())
+              {
+                int note = pitch_detection_thread->result();
+                if (note >= 0)
+                  note_widget->set_pitch_detection_note (note);
+                pitch_detection_thread.reset();
+                detect_note_button->set_visible (true);
+                detect_note_progress_bar->set_visible (false);
+                detect_note_cancel_button->set_visible (false);
+              }
+          }
+        else
+          {
+            detect_note_timer->stop();
+          }
+      });
+
+    /*--- detect note: button ---*/
+    detect_note_button = new Button (this, "Detect Midi Note");
+    connect (detect_note_button->signal_clicked, [this, instrument]()
+      {
+        Sample *sample = instrument->sample (instrument->selected());
+        if (sample)
+          {
+            pitch_detection_thread = std::make_unique<PitchDetectionThread> (this, instrument, sample);
+            detect_note_timer->start (0);
+            detect_note_button->set_visible (false);
+            detect_note_progress_bar->set_visible (true);
+            detect_note_cancel_button->set_visible (true);
+          }
+      });
+    /*--- detect note: cancel button ---*/
+    detect_note_cancel_button = new Button (this, "Cancel");
+    connect (detect_note_cancel_button->signal_clicked, [this]()
+      {
+        pitch_detection_thread.reset();
+        detect_note_button->set_visible (true);
+        detect_note_progress_bar->set_visible (false);
+        detect_note_cancel_button->set_visible (false);
+      });
+    detect_note_cancel_button->set_visible (false);
+
+    /*--- detect note: progress ---*/
+    detect_note_progress_bar = new ProgressBar (this);
+    detect_note_progress_bar->set_visible (false);
+
     grid.dx = 4;
-    grid.dy = height() / 8 - 5;
+    grid.dy = height() / 8 - 7;
 
     double xw = 12;
-    grid.add_widget (dbl, 0, 2, xw, 3);
-    grid.add_widget (dbl_txt, xw, 2, 20, 3);
     grid.add_widget (space, 0, 0, xw, 3);
     grid.add_widget (space_txt, xw, 0, 20, 3);
+    grid.add_widget (detect_note_button, 0, 3, 25, 3);
+    grid.add_widget (detect_note_progress_bar, 0, 3, 16, 3);
+    grid.add_widget (detect_note_cancel_button, 17, 3, 8, 3);
 
     grid.dx = width() / 8 / 2;
-    grid.dy = height() / 8 - 5;
+    grid.dy = height() / 8 - 7;
 
-    grid.add_widget (new VLine (this, Color (0.6, 0.6, 0.6), 2), 0, 0, 1, 5);
+    grid.add_widget (new VLine (this, Color (0.6, 0.6, 0.6), 2), 0, 0, 1, 7);
 
     grid.dx += 4;
 
@@ -294,6 +454,8 @@ public:
     grid.add_widget (left_txt, xw, 0, 20, 3);
     grid.add_widget (right, 0, 2, xw, 3);
     grid.add_widget (right_txt, xw, 2, 20, 3);
+    grid.add_widget (dbl, 0, 4, xw, 3);
+    grid.add_widget (dbl_txt, xw, 4, 20, 3);
 
     show();
   }

glui/sminsteditwindow.cc

@@ -83,6 +83,12 @@ InstEditBackend::InstEditBackend (SynthInterface *synth_interface) :
   synth_interface (synth_interface),
   cache_group (InstEncCache::the()->create_group())
 {
+  synth_interface->synth_inst_edit_update (true, nullptr, nullptr);
+}
+
+InstEditBackend::~InstEditBackend()
+{
+  synth_interface->synth_inst_edit_update (false, nullptr, nullptr);
 }
 
 void
@@ -138,13 +144,13 @@ InstEditBackend::on_timer()
 
 // ---------------- InstEditWindow ----------------
 //
-InstEditWindow::InstEditWindow (EventLoop& event_loop, Instrument *edit_instrument, SynthInterface *synth_interface, Window *parent_window) :
+InstEditWindow::InstEditWindow (EventLoop& event_loop, const Instrument *edit_instrument, SynthInterface *synth_interface, Window *parent_window) :
   Window (event_loop, "SpectMorph - Instrument Editor", win_width, win_height, 0, false, parent_window ? parent_window->native_window() : 0),
   m_backend (synth_interface),
   synth_interface (synth_interface)
 {
   assert (edit_instrument != nullptr);
-  instrument = edit_instrument;
+  instrument = edit_instrument->clone();
 
   /* make a backup to be able to revert */
   ZipWriter writer;
@@ -411,6 +417,9 @@ InstEditWindow::~InstEditWindow()
       delete inst_edit_volume;
       inst_edit_volume = nullptr;
     }
+
+  assert (instrument);
+  delete instrument;
 }
 
 void
@@ -480,9 +489,6 @@ InstEditWindow::load_sample_convert_from_stereo (const WavData& wav_data, const
 void
 InstEditWindow::on_synth_notify_event (SynthNotifyEvent *notify_event)
 {
-  if (!instrument)
-    return;
-
   auto iev = dynamic_cast<InstEditVoiceEvent *> (notify_event);
   if (!iev)
     return;
@@ -556,9 +562,6 @@ InstEditWindow::on_synth_notify_event (SynthNotifyEvent *notify_event)
 void
 InstEditWindow::on_selected_sample_changed()
 {
-  if (!instrument) // during close we cannot access the instrument anymore
-    return;
-
   sample_combobox->clear();
   if (instrument->size() == 0)
     {
@@ -604,9 +607,6 @@ InstEditWindow::on_selected_sample_changed()
 void
 InstEditWindow::on_samples_changed()
 {
-  if (!instrument) // during close we cannot access the instrument anymore
-    return;
-
   on_selected_sample_changed();
   m_backend.update_instrument (instrument, reference);
 }
@@ -685,9 +685,6 @@ InstEditWindow::update_auto_checkboxes()
 void
 InstEditWindow::on_global_changed()
 {
-  if (!instrument) // during close we cannot access the instrument anymore
-    return;
-
   update_auto_checkboxes();
 
   name_line_edit->set_text (instrument->name());
@@ -1018,14 +1015,23 @@ InstEditWindow::set_playing (bool new_playing)
   play_button->set_icon (playing ? IconButton::STOP : IconButton::PLAY);
 }
 
-void
-InstEditWindow::clear_edit_instrument()
+/*
+ * Instrument ownership:
+ *   - in our constructor we make a deep copy of the instrument we want to edit
+ *     so we can modify it and use its signals without any interference
+ *   - in this function we return a deep copy of the edited instruments to
+ *     ensure that the caller can modify, keep or destroy the Instrument at any
+ *     time
+ *   - in our destructor, we delete our copy of the instrument
+ *
+ * This ensures that draw events or timer events that happen after the
+ * window has been closed (but before the InstEditWindow has been destroyed)
+ * can always access our own private version of the Instrument.
+ */
+std::unique_ptr<Instrument>
+InstEditWindow::get_modified_instrument()
 {
-  /* this is called if the window is closed: after the close event
-   * we should no longer access the instrument because it could be
-   * deleted already
-   */
-  instrument = nullptr;
+  return std::unique_ptr<Instrument> (instrument->clone());
 }
 
 void

glui/sminsteditwindow.hh

@@ -50,6 +50,7 @@ class InstEditBackend
 
 public:
   InstEditBackend (SynthInterface *synth_interface);
+  ~InstEditBackend();
 
   void update_instrument (const Instrument *instrument, const std::string& reference);
   bool have_builder();
@@ -123,10 +124,10 @@ public:
   static const int win_width = 744;
   static const int win_height = 560;
 
-  InstEditWindow (EventLoop& event_loop, Instrument *edit_instrument, SynthInterface *synth_interface, Window *parent_window = nullptr);
+  InstEditWindow (EventLoop& event_loop, const Instrument *edit_instrument, SynthInterface *synth_interface, Window *parent_window = nullptr);
   ~InstEditWindow();
 
-  void clear_edit_instrument();
+  std::unique_ptr<Instrument> get_modified_instrument();
 
   bool auto_select() const;
   void set_auto_select (bool auto_select);