gtk2_ardour/rhythm_ferret.cc

   1 #include <gtkmm/stock.h>
   2 #include <gtkmm2ext/utils.h>
   3
   4 #include "pbd/memento_command.h"
   5 #include "pbd/convert.h"
   6
   7 #include "ardour/transient_detector.h"
   8 #include "ardour/onset_detector.h"
   9 #include "ardour/audiosource.h"
  10 #include "ardour/audioregion.h"
  11 #include "ardour/playlist.h"
  12 #include "ardour/region_factory.h"
  13 #include "ardour/session.h"
  14
  15 #include "rhythm_ferret.h"
  16 #include "audio_region_view.h"
  17 #include "public_editor.h"
  18 #include "utils.h"
  19 #include "time_axis_view.h"
  20
  21 #include "i18n.h"
  22
  23 using namespace std;
  24 using namespace Gtk;
  25 using namespace Gdk;
  26 using namespace PBD;
  27 using namespace ARDOUR;
  28
  29 /* order of these must match the AnalysisMode enums
  30    in rhythm_ferret.h
  31 */
  32 static const gchar * _analysis_mode_strings[] = {
  33         N_("Percussive Onset"),
  34         N_("Note Onset"),
  35         0
  36 };
  37
  38 static const gchar * _onset_function_strings[] = {
  39         N_("Energy Based"),
  40         N_("Spectral Difference"),
  41         N_("High-Frequency Content"),
  42         N_("Complex Domain"),
  43         N_("Phase Deviation"),
  44         N_("Kullback-Liebler"),
  45         N_("Modified Kullback-Liebler"),
  46         0
  47 };
  48
  49 static const gchar * _operation_strings[] = {
  50         N_("Split region"),
  51         N_("Set tempo map"),
  52         N_("Conform region"),
  53         0
  54 };
  55
  56 RhythmFerret::RhythmFerret (PublicEditor& e)
  57         : ArdourDialog (_("Rhythm Ferret"))
  58         , editor (e)
  59         , detection_threshold_adjustment (3, 0, 20, 1, 4)
  60         , detection_threshold_scale (detection_threshold_adjustment)
  61         , sensitivity_adjustment (40, 0, 100, 1, 10)
  62         , sensitivity_scale (sensitivity_adjustment)
  63         , analyze_button (_("Analyze"))
  64         , peak_picker_threshold_adjustment (0.3, 0.0, 1.0, 0.01, 0.1)
  65         , peak_picker_threshold_scale (peak_picker_threshold_adjustment)
  66         , silence_threshold_adjustment (-90.0, -120.0, 0.0, 1, 10)
  67         , silence_threshold_scale (silence_threshold_adjustment)
  68         , trigger_gap_adjustment (3, 0, 100, 1, 10)
  69         , trigger_gap_spinner (trigger_gap_adjustment)
  70         , action_button (Stock::APPLY)
  71 {
  72         operation_strings = I18N (_operation_strings);
  73         Gtkmm2ext::set_popdown_strings (operation_selector, operation_strings);
  74         operation_selector.set_active (0);
  75
  76         analysis_mode_strings = I18N (_analysis_mode_strings);
  77         Gtkmm2ext::set_popdown_strings (analysis_mode_selector, analysis_mode_strings);
  78         analysis_mode_selector.set_active_text (analysis_mode_strings.front());
  79         analysis_mode_selector.signal_changed().connect (sigc::mem_fun (*this, &RhythmFerret::analysis_mode_changed));
  80
  81         onset_function_strings = I18N (_onset_function_strings);
  82         Gtkmm2ext::set_popdown_strings (onset_detection_function_selector, onset_function_strings);
  83         /* Onset plugin uses complex domain as default function
  84            XXX there should be a non-hacky way to set this
  85          */
  86         onset_detection_function_selector.set_active_text (onset_function_strings[3]);
  87
  88         Table* t = manage (new Table (7, 3));
  89         t->set_spacings (12);
  90
  91         int n = 0;
  92
  93         t->attach (*manage (new Label (_("Mode"), 1, 0.5)), 0, 1, n, n + 1, FILL);
  94         t->attach (analysis_mode_selector, 1, 2, n, n + 1, FILL);
  95         ++n;
  96
  97         t->attach (*manage (new Label (_("Detection function"), 1, 0.5)), 0, 1, n, n + 1, FILL);
  98         t->attach (onset_detection_function_selector, 1, 2, n, n + 1, FILL);
  99         ++n;
 100
 101         t->attach (*manage (new Label (_("Trigger gap"), 1, 0.5)), 0, 1, n, n + 1, FILL);
 102         t->attach (trigger_gap_spinner, 1, 2, n, n + 1, FILL);
 103         t->attach (*manage (new Label (_("ms"))), 2, 3, n, n + 1, FILL);
 104         ++n;
 105
 106         t->attach (*manage (new Label (_("Threshold"), 1, 0.5)), 0, 1, n, n + 1, FILL);
 107         t->attach (detection_threshold_scale, 1, 2, n, n + 1, FILL);
 108         t->attach (*manage (new Label (_("dB"))), 2, 3, n, n + 1, FILL);
 109         ++n;
 110
 111         t->attach (*manage (new Label (_("Peak threshold"), 1, 0.5)), 0, 1, n, n + 1, FILL);
 112         t->attach (peak_picker_threshold_scale, 1, 2, n, n + 1, FILL);
 113         t->attach (*manage (new Label (_("dB"))), 2, 3, n, n + 1, FILL);
 114         ++n;
 115
 116         t->attach (*manage (new Label (_("Silence threshold"), 1, 0.5)), 0, 1, n, n + 1, FILL);
 117         t->attach (silence_threshold_scale, 1, 2, n, n + 1, FILL);
 118         t->attach (*manage (new Label (_("dB"))), 2, 3, n, n + 1, FILL);
 119         ++n;
 120
 121         t->attach (*manage (new Label (_("Sensitivity"), 1, 0.5)), 0, 1, n, n + 1, FILL);
 122         t->attach (sensitivity_scale, 1, 2, n, n + 1, FILL);
 123         ++n;
 124
 125         t->attach (*manage (new Label (_("Operation"), 1, 0.5)), 0, 1, n, n + 1, FILL);
 126         t->attach (operation_selector, 1, 2, n, n + 1, FILL);
 127         ++n;
 128
 129         analyze_button.signal_clicked().connect (sigc::mem_fun (*this, &RhythmFerret::run_analysis));
 130         action_button.signal_clicked().connect (sigc::mem_fun (*this, &RhythmFerret::do_action));
 131
 132         get_vbox()->set_border_width (6);
 133         get_vbox()->set_spacing (6);
 134         get_vbox()->pack_start (*t);
 135
 136         add_action_widget (analyze_button, 1);
 137         add_action_widget (action_button, 0);
 138
 139         show_all ();
 140         analysis_mode_changed ();
 141 }
 142
 143 void
 144 RhythmFerret::analysis_mode_changed ()
 145 {
 146         bool const perc = get_analysis_mode() == PercussionOnset;
 147
 148         detection_threshold_scale.set_sensitive (perc);
 149         sensitivity_scale.set_sensitive (perc);
 150         onset_detection_function_selector.set_sensitive (!perc);
 151         peak_picker_threshold_scale.set_sensitive (!perc);
 152         silence_threshold_scale.set_sensitive (!perc);
 153 }
 154
 155 RhythmFerret::AnalysisMode
 156 RhythmFerret::get_analysis_mode () const
 157 {
 158         string str = analysis_mode_selector.get_active_text ();
 159
 160         if (str == analysis_mode_strings[(int) NoteOnset]) {
 161                 return NoteOnset;
 162         }
 163
 164         return PercussionOnset;
 165 }
 166
 167 RhythmFerret::Action
 168 RhythmFerret::get_action () const
 169 {
 170         if (operation_selector.get_active_row_number() == 1) {
 171                 return DefineTempoMap;
 172         } else if (operation_selector.get_active_row_number() == 2) {
 173                 return ConformRegion;
 174         }
 175
 176         return SplitRegion;
 177 }
 178
 179 void
 180 RhythmFerret::run_analysis ()
 181 {
 182         if (!_session) {
 183                 return;
 184         }
 185
 186         RegionSelection& regions (editor.get_selection().regions);
 187
 188         current_results.clear ();
 189
 190         if (regions.empty()) {
 191                 return;
 192         }
 193
 194         for (RegionSelection::iterator i = regions.begin(); i != regions.end(); ++i) {
 195
 196                 boost::shared_ptr<Readable> rd = boost::static_pointer_cast<AudioRegion> ((*i)->region());
 197
 198                 switch (get_analysis_mode()) {
 199                 case PercussionOnset:
 200                         run_percussion_onset_analysis (rd, (*i)->region()->position(), current_results);
 201                         break;
 202                 case NoteOnset:
 203                         run_note_onset_analysis (rd, (*i)->region()->position(), current_results);
 204                         break;
 205                 default:
 206                         break;
 207                 }
 208
 209         }
 210
 211         for (RegionSelection::iterator i = regions.begin(); i != regions.end(); ++i) {
 212                 (*i)->get_time_axis_view().show_feature_lines (current_results);
 213         }
 214
 215 }
 216
 217 int
 218 RhythmFerret::run_percussion_onset_analysis (boost::shared_ptr<Readable> readable, nframes64_t offset, AnalysisFeatureList& results)
 219 {
 220         TransientDetector t (_session->frame_rate());
 221
 222         for (uint32_t i = 0; i < readable->n_channels(); ++i) {
 223
 224                 AnalysisFeatureList these_results;
 225
 226                 t.reset ();
 227                 t.set_threshold (detection_threshold_adjustment.get_value());
 228                 t.set_sensitivity (sensitivity_adjustment.get_value());
 229
 230                 if (t.run ("", readable.get(), i, these_results)) {
 231                         continue;
 232                 }
 233
 234                 /* translate all transients to give absolute position */
 235
 236                 for (AnalysisFeatureList::iterator x = these_results.begin(); x != these_results.end(); ++x) {
 237                         (*x) += offset;
 238                 }
 239
 240                 /* merge */
 241
 242                 results.insert (results.end(), these_results.begin(), these_results.end());
 243                 these_results.clear ();
 244         }
 245
 246         if (!results.empty()) {
 247                 TransientDetector::cleanup_transients (results, _session->frame_rate(), trigger_gap_adjustment.get_value());
 248         }
 249
 250         return 0;
 251 }
 252
 253 int
 254 RhythmFerret::get_note_onset_function ()
 255 {
 256         string txt = onset_detection_function_selector.get_active_text();
 257
 258         for (int n = 0; _onset_function_strings[n]; ++n) {
 259                 /* compare translated versions */
 260                 if (txt == onset_function_strings[n]) {
 261                         return n;
 262                 }
 263         }
 264         fatal << string_compose (_("programming error: %1 (%2)"), X_("illegal note onset function string"), txt)
 265               << endmsg;
 266         /*NOTREACHED*/
 267         return -1;
 268 }
 269
 270 int
 271 RhythmFerret::run_note_onset_analysis (boost::shared_ptr<Readable> readable, nframes64_t offset, AnalysisFeatureList& results)
 272 {
 273         try {
 274                 OnsetDetector t (_session->frame_rate());
 275
 276                 for (uint32_t i = 0; i < readable->n_channels(); ++i) {
 277
 278                         AnalysisFeatureList these_results;
 279
 280                         t.reset ();
 281
 282                         t.set_function (get_note_onset_function());
 283                         t.set_silence_threshold (silence_threshold_adjustment.get_value());
 284                         t.set_peak_threshold (peak_picker_threshold_adjustment.get_value());
 285
 286                         if (t.run ("", readable.get(), i, these_results)) {
 287                                 continue;
 288                         }
 289
 290                         /* translate all transients to give absolute position */
 291
 292                         for (AnalysisFeatureList::iterator x = these_results.begin(); x != these_results.end(); ++x) {
 293                                 (*x) += offset;
 294                         }
 295
 296                         /* merge */
 297
 298                         results.insert (results.end(), these_results.begin(), these_results.end());
 299                         these_results.clear ();
 300                 }
 301
 302         } catch (failed_constructor& err) {
 303                 error << "Could not load note onset detection plugin" << endmsg;
 304                 return -1;
 305         }
 306
 307         if (!results.empty()) {
 308                 OnsetDetector::cleanup_onsets (results, _session->frame_rate(), trigger_gap_adjustment.get_value());
 309         }
 310
 311         return 0;
 312 }
 313
 314 void
 315 RhythmFerret::do_action ()
 316 {
 317         if (!_session || current_results.empty()) {
 318                 return;
 319         }
 320
 321         switch (get_action()) {
 322         case SplitRegion:
 323                 do_split_action ();
 324                 break;
 325
 326         default:
 327                 break;
 328         }
 329 }
 330
 331 void
 332 RhythmFerret::do_split_action ()
 333 {
 334         /* this can/will change the current selection, so work with a copy */
 335
 336         RegionSelection& regions (editor.get_selection().regions);
 337
 338         if (regions.empty()) {
 339                 return;
 340         }
 341
 342         _session->begin_reversible_command (_("split regions (rhythm ferret)"));
 343
 344         for (RegionSelection::iterator i = regions.begin(); i != regions.end(); ) {
 345
 346                 RegionSelection::iterator tmp;
 347
 348                 tmp = i;
 349                 ++tmp;
 350
 351                 (*i)->get_time_axis_view().hide_feature_lines ();
 352
 353                 editor.split_region_at_points ((*i)->region(), current_results, false);
 354
 355                 /* i is invalid at this point */
 356
 357                 i = tmp;
 358         }
 359
 360         _session->commit_reversible_command ();
 361 }
 362
 363 void
 364 RhythmFerret::set_session (Session* s)
 365 {
 366         ArdourDialog::set_session (s);
 367         current_results.clear ();
 368 }
 369
 370 static void hide_time_axis_features (TimeAxisView& tav)
 371 {
 372         tav.hide_feature_lines ();
 373 }
 374
 375 void
 376 RhythmFerret::on_hide ()
 377 {
 378         editor.foreach_time_axis_view (sigc::ptr_fun (hide_time_axis_features));
 379         ArdourDialog::on_hide ();
 380 }
 381