X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=gtk2_ardour%2Fstrip_silence_dialog.cc;h=2fb4b5923f9cd122a96f321fed20f6f03a52467a;hb=159b8face74f8ba8da5e1e4225aed0c384ac9dc2;hp=0403d4d188a49ea989a7c889610575273c19a9fd;hpb=9213e9c9094468ce21be378ea017b0da1405bf03;p=ardour.git diff --git a/gtk2_ardour/strip_silence_dialog.cc b/gtk2_ardour/strip_silence_dialog.cc index 0403d4d188..2fb4b5923f 100644 --- a/gtk2_ardour/strip_silence_dialog.cc +++ b/gtk2_ardour/strip_silence_dialog.cc @@ -22,475 +22,272 @@ #include #include #include -#include "ardour/audioregion.h" -#include "ardour/audiosource.h" +#include "ardour/audioregion.h" #include "ardour/dB.h" #include "ardour_ui.h" -#include "ardour/session.h" +#include "audio_clock.h" #include "gui_thread.h" #include "strip_silence_dialog.h" #include "canvas_impl.h" +#include "region_view.h" +#include "simpleline.h" #include "waveview.h" #include "simplerect.h" #include "rgb_macros.h" #include "i18n.h" +#include "logmeter.h" using namespace ARDOUR; using namespace std; using namespace ArdourCanvas; -Glib::StaticMutex StripSilenceDialog::run_lock; -Glib::Cond* StripSilenceDialog::thread_waiting = 0; -Glib::Cond* StripSilenceDialog::thread_run = 0; -bool StripSilenceDialog::thread_should_exit = false; -InterThreadInfo StripSilenceDialog::itt; -StripSilenceDialog* StripSilenceDialog::current = 0; - /** Construct Strip silence dialog box */ -StripSilenceDialog::StripSilenceDialog (Session* s, std::list > const & regions) +StripSilenceDialog::StripSilenceDialog (Session* s, list const & v) : ArdourDialog (_("Strip Silence")) - , _minimum_length (X_("silence duration"), true, "SilenceDurationClock", true, false, true, false) - , _fade_length (X_("silence duration"), true, "SilenceDurationClock", true, false, true, false) - , _wave_width (640) - , _wave_height (64) - , restart_queued (false) + , ProgressReporter () + , _minimum_length (new AudioClock (X_("silence duration"), true, "", true, false, true, false)) + , _fade_length (new AudioClock (X_("silence duration"), true, "", true, false, true, false)) , _peaks_ready_connection (0) + , _destroying (false) { set_session (s); - if (thread_waiting == 0) { - thread_waiting = new Glib::Cond; - thread_run = new Glib::Cond; + for (list::const_iterator r = v.begin(); r != v.end(); ++r) { + views.push_back (ViewInterval (*r)); } - - for (std::list >::const_iterator i = regions.begin(); i != regions.end(); ++i) { - - Wave w; - w.region = *i; - _waves.push_back (w); - - } Gtk::HBox* hbox = Gtk::manage (new Gtk::HBox); - hbox->set_spacing (16); - Gtk::Table* table = Gtk::manage (new Gtk::Table (4, 3)); - table->set_spacings (4); + Gtk::Table* table = Gtk::manage (new Gtk::Table (3, 3)); + table->set_spacings (6); - Gtk::Label* l = Gtk::manage (new Gtk::Label (_("Threshold:"))); - l->set_alignment (1, 0.5); - - hbox->pack_start (*l, false, false); - hbox->pack_start (_threshold, true, true); + int n = 0; + + table->attach (*Gtk::manage (new Gtk::Label (_("Threshold"), 1, 0.5)), 0, 1, n, n + 1, Gtk::FILL); + table->attach (_threshold, 1, 2, n, n + 1, Gtk::FILL); + table->attach (*Gtk::manage (new Gtk::Label (_("dbFS"))), 2, 3, n, n + 1, Gtk::FILL); + ++n; _threshold.set_digits (1); _threshold.set_increments (1, 10); _threshold.set_range (-120, 0); _threshold.set_value (-60); + _threshold.set_activates_default (); - l = Gtk::manage (new Gtk::Label (_("dBFS"))); - l->set_alignment (0, 0.5); - - hbox->pack_start (*l, false, false); - - l = Gtk::manage (new Gtk::Label (_("Minimum length:"))); - l->set_alignment (1, 0.5); + table->attach (*Gtk::manage (new Gtk::Label (_("Minimum length"), 1, 0.5)), 0, 1, n, n + 1, Gtk::FILL); + table->attach (*_minimum_length, 1, 2, n, n + 1, Gtk::FILL); + ++n; - hbox->pack_start (*l, false, false); - hbox->pack_start (_minimum_length, true, true); + _minimum_length->set_session (s); + _minimum_length->set_mode (AudioClock::Frames); + _minimum_length->set (1000, true); - _minimum_length.set_session (s); - _minimum_length.set_mode (AudioClock::Frames); - _minimum_length.set (1000, true); + table->attach (*Gtk::manage (new Gtk::Label (_("Fade length"), 1, 0.5)), 0, 1, n, n + 1, Gtk::FILL); + table->attach (*_fade_length, 1, 2, n, n + 1, Gtk::FILL); + ++n; - l = Gtk::manage (new Gtk::Label (_("Fade length:"))); - l->set_alignment (1, 0.5); + _fade_length->set_session (s); + _fade_length->set_mode (AudioClock::Frames); + _fade_length->set (64, true); - hbox->pack_start (*l, false, false); - hbox->pack_start (_fade_length, true, true); - - _fade_length.set_session (s); - _fade_length.set_mode (AudioClock::Frames); - _fade_length.set (64, true); - - _segment_count_label.set_text (_("Silent segments: none")); + hbox->pack_start (*table); get_vbox()->pack_start (*hbox, false, false); - add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL); add_button (Gtk::Stock::APPLY, Gtk::RESPONSE_OK); + set_default_response (Gtk::RESPONSE_OK); - _canvas = new CanvasAA (); - _canvas->signal_size_allocate().connect (sigc::mem_fun (*this, &StripSilenceDialog::canvas_allocation)); - _canvas->set_size_request (_wave_width, _wave_height * _waves.size ()); - - get_vbox()->pack_start (*_canvas, true, true); - get_vbox()->pack_start (_segment_count_label, false, false); + get_vbox()->pack_start (_progress_bar, true, true, 12); show_all (); - _threshold.get_adjustment()->signal_value_changed().connect (sigc::mem_fun (*this, &StripSilenceDialog::maybe_start_silence_detection)); - _minimum_length.ValueChanged.connect (sigc::mem_fun (*this, &StripSilenceDialog::maybe_start_silence_detection)); + _threshold.get_adjustment()->signal_value_changed().connect (sigc::mem_fun (*this, &StripSilenceDialog::threshold_changed)); + _minimum_length->ValueChanged.connect (sigc::mem_fun (*this, &StripSilenceDialog::restart_thread)); - create_waves (); update_silence_rects (); + update_threshold_line (); + + /* Create a thread which runs while the dialogue is open to compute the silence regions */ + Completed.connect (_completed_connection, MISSING_INVALIDATOR, boost::bind (&StripSilenceDialog::update, this), gui_context ()); + _thread_should_finish = false; + pthread_create (&_thread, 0, StripSilenceDialog::_detection_thread_work, this); } StripSilenceDialog::~StripSilenceDialog () { - for (std::list::iterator i = _waves.begin(); i != _waves.end(); ++i) { - delete i->view; - for (std::list::iterator j = i->silence_rects.begin(); j != i->silence_rects.end(); ++j) { - delete *j; - } - } + _destroying = true; - delete _peaks_ready_connection; + /* Terminate our thread */ - delete _canvas; -} + _lock.lock (); + _interthread_info.cancel = true; + _thread_should_finish = true; + _lock.unlock (); -void -StripSilenceDialog::create_waves () -{ - int n = 0; + _run_cond.signal (); + pthread_join (_thread, 0); - delete _peaks_ready_connection; - _peaks_ready_connection = 0; - - for (std::list::iterator i = _waves.begin(); i != _waves.end(); ++i) { - if (i->region->audio_source(0)->peaks_ready (boost::bind (&StripSilenceDialog::peaks_ready, this), &_peaks_ready_connection, gui_context())) { - i->view = new WaveView (*(_canvas->root())); - i->view->property_data_src() = static_cast(i->region.get()); - i->view->property_cache() = WaveView::create_cache (); - i->view->property_cache_updater() = true; - i->view->property_channel() = 0; - i->view->property_length_function() = (void *) region_length_from_c; - i->view->property_sourcefile_length_function() = (void *) sourcefile_length_from_c; - i->view->property_peak_function() = (void *) region_read_peaks_from_c; - i->view->property_x() = 0; - i->view->property_y() = n * _wave_height; - i->view->property_height() = _wave_height; - i->view->property_samples_per_unit() = i->samples_per_unit; - i->view->property_region_start() = i->region->start(); - i->view->property_wave_color() = ARDOUR_UI::config()->canvasvar_WaveForm.get(); - i->view->property_fill_color() = ARDOUR_UI::config()->canvasvar_WaveFormFill.get(); - } + delete _minimum_length; + delete _fade_length; - ++n; - } -} - -void -StripSilenceDialog::peaks_ready () -{ delete _peaks_ready_connection; - _peaks_ready_connection = 0; - create_waves (); } void -StripSilenceDialog::canvas_allocation (Gtk::Allocation& alloc) +StripSilenceDialog::silences (AudioIntervalMap& m) { - int n = 0; - - _canvas->set_scroll_region (0.0, 0.0, alloc.get_width(), alloc.get_height()); - _wave_width = alloc.get_width (); - _wave_height = alloc.get_height (); - - for (std::list::iterator i = _waves.begin(); i != _waves.end(); ++i, ++n) { - i->samples_per_unit = ((double) i->region->length() / _wave_width); - - if (i->view) { - i->view->property_y() = n * _wave_height; - i->view->property_samples_per_unit() = i->samples_per_unit; - i->view->property_height() = _wave_height; - } - } - - redraw_silence_rects (); + for (list::iterator v = views.begin(); v != views.end(); ++v) { + pair,AudioIntervalResult> newpair (v->view->region(), v->intervals); + m.insert (newpair); + } } void -StripSilenceDialog::redraw_silence_rects () +StripSilenceDialog::drop_rects () { - int n = 0; - - for (std::list::iterator i = _waves.begin(); i != _waves.end(); ++i) { - - std::list >::const_iterator j; - std::list::iterator r; - - for (j = i->silence.begin(), r = i->silence_rects.begin(); - j != i->silence.end() && r != i->silence_rects.end(); ++j, ++r) { - (*r)->property_x1() = j->first / i->samples_per_unit; - (*r)->property_x2() = j->second / i->samples_per_unit; - (*r)->property_y1() = n * _wave_height; - (*r)->property_y2() = (n + 1) * _wave_height; - (*r)->property_outline_pixels() = 0; - (*r)->property_fill_color_rgba() = RGBA_TO_UINT (128, 128, 128, 128); - } - - ++n; + for (list::iterator v = views.begin(); v != views.end(); ++v) { + v->view->drop_silent_frames (); } } void -StripSilenceDialog::update_silence_rects () +StripSilenceDialog::update_threshold_line () { +#if 0 int n = 0; - uint32_t max_segments = 0; - uint32_t sc; - for (std::list::iterator i = _waves.begin(); i != _waves.end(); ++i) { - for (std::list::iterator j = i->silence_rects.begin(); j != i->silence_rects.end(); ++j) { - delete *j; - } - - i->silence_rects.clear (); - sc = 0; + /* Don't need to lock here as we're not reading the _waves silence details */ - for (std::list >::const_iterator j = i->silence.begin(); j != i->silence.end(); ++j) { + for (list::iterator i = _waves.begin(); i != _waves.end(); ++i) { + (*i)->threshold_line->property_x1() = 0; + (*i)->threshold_line->property_x2() = _wave_width; - SimpleRect* r = new SimpleRect (*(_canvas->root())); - r->property_x1() = j->first / i->samples_per_unit; - r->property_x2() = j->second / i->samples_per_unit; - r->property_y1() = n * _wave_height; - r->property_y2() = (n + 1) * _wave_height; - r->property_outline_pixels() = 0; - r->property_fill_color_rgba() = RGBA_TO_UINT (128, 128, 128, 128); - i->silence_rects.push_back (r); - sc++; - } + double const y = alt_log_meter (_threshold.get_value()); - max_segments = max (max_segments, sc); - ++n; + (*i)->threshold_line->property_y1() = (n + 1 - y) * _wave_height; + (*i)->threshold_line->property_y2() = (n + 1 - y) * _wave_height; } - if (min_audible > 0) { - float ms, ma; - char* aunits; - char* sunits; - - ma = (float) min_audible/_session->frame_rate(); - ms = (float) min_silence/_session->frame_rate(); - - if (min_audible > _session->frame_rate()) { - aunits = _("secs"); - ma /= 1000.0; - } else { - aunits = _("msecs"); - } - - if (min_silence > _session->frame_rate()) { - sunits = _("secs"); - ms /= 1000.0; - } else { - sunits = _("msecs"); - } - - _segment_count_label.set_text (string_compose (_("Silent segments: %1\nShortest silence %2 %3 Shortest audible %4 %5"), - max_segments, ms, sunits, ma, aunits)); - } else { - _segment_count_label.set_text (_("Full silence")); - } + ++n; +#endif } -bool -StripSilenceDialog::_detection_done (void* arg) +void +StripSilenceDialog::update () { - StripSilenceDialog* ssd = (StripSilenceDialog*) arg; - return ssd->detection_done (); + update_threshold_line (); + update_silence_rects (); } -bool -StripSilenceDialog::detection_done () +void +StripSilenceDialog::update_silence_rects () { - get_window()->set_cursor (Gdk::Cursor (Gdk::LEFT_PTR)); - update_silence_rects (); - return false; + /* Lock so that we don't contend with the detection thread for access to the silence regions */ + Glib::Threads::Mutex::Lock lm (_lock); + double const y = _threshold.get_value(); + + for (list::iterator v = views.begin(); v != views.end(); ++v) { + v->view->set_silent_frames (v->intervals, y); + } } -void* +void * StripSilenceDialog::_detection_thread_work (void* arg) { - StripSilenceDialog* ssd = (StripSilenceDialog*) arg; - return ssd->detection_thread_work (); + StripSilenceDialog* d = reinterpret_cast (arg); + return d->detection_thread_work (); } -void* +/** Body of our silence detection thread */ +void * StripSilenceDialog::detection_thread_work () { ARDOUR_UI::instance()->register_thread ("gui", pthread_self(), "silence", 32); - - while (1) { - - run_lock.lock (); - thread_waiting->signal (); - thread_run->wait (run_lock); - - if (thread_should_exit) { - thread_waiting->signal (); - run_lock.unlock (); - break; - } - - if (current) { - StripSilenceDialog* ssd = current; - run_lock.unlock (); - - for (std::list::iterator i = ssd->_waves.begin(); i != ssd->_waves.end(); ++i) { - i->silence = i->region->find_silence (dB_to_coefficient (ssd->threshold ()), ssd->minimum_length (), ssd->itt); - ssd->update_stats (i->silence); - } - - if (!ssd->itt.cancel) { - g_idle_add ((gboolean (*)(void*)) StripSilenceDialog::_detection_done, ssd); - } - } else { - run_lock.unlock (); - } - - } - - return 0; -} - -void -StripSilenceDialog::maybe_start_silence_detection () -{ - if (!restart_queued) { - restart_queued = true; - Glib::signal_idle().connect (sigc::mem_fun (*this, &StripSilenceDialog::start_silence_detection)); - } -} - -bool -StripSilenceDialog::start_silence_detection () -{ - Glib::Mutex::Lock lm (run_lock); - restart_queued = false; - if (!itt.thread) { + /* Hold this lock when we are doing work */ + _lock.lock (); - itt.done = false; - itt.cancel = false; - itt.progress = 0.0; - current = this; + while (1) { + for (list::iterator i = views.begin(); i != views.end(); ++i) { + boost::shared_ptr ar = boost::dynamic_pointer_cast ((*i).view->region()); - pthread_create (&itt.thread, 0, StripSilenceDialog::_detection_thread_work, this); - /* wait for it to get started */ - thread_waiting->wait (run_lock); - - } else { - - /* stop whatever the thread is doing */ - - itt.cancel = 1; - current = 0; - - while (!itt.done) { - thread_run->signal (); - thread_waiting->wait (run_lock); - } - } + if (ar) { + i->intervals = ar->find_silence (dB_to_coefficient (threshold ()), minimum_length (), _interthread_info); + } + if (_interthread_info.cancel) { + break; + } + } - itt.cancel = false; - itt.done = false; - itt.progress = 0.0; - current = this; - - /* and start it up (again) */ - - thread_run->signal (); + if (!_interthread_info.cancel) { + Completed (); /* EMIT SIGNAL */ + } - /* change cursor */ + /* Our work is done; sleep until there is more to do. + * The lock is released while we are waiting. + */ + _run_cond.wait (_lock); - get_window()->set_cursor (Gdk::Cursor (Gdk::WATCH)); + if (_thread_should_finish) { + _lock.unlock (); + return 0; + } + } - /* don't call again until needed */ - - return false; + return 0; } void -StripSilenceDialog::stop_thread () +StripSilenceDialog::restart_thread () { - Glib::Mutex::Lock lm (run_lock); + if (_destroying) { + /* I don't know how this happens, but it seems to be possible for this + method to be called after our destructor has finished executing. + If this happens, bad things follow; _lock cannot be locked and + Ardour hangs. So if we are destroying, just bail early. + */ + return; + } + + /* Cancel any current run */ + _interthread_info.cancel = true; - itt.cancel = true; - thread_should_exit = true; - thread_run->signal (); - thread_waiting->wait (run_lock); - itt.thread = 0; + /* Block until the thread waits() */ + _lock.lock (); + /* Reset the flag */ + _interthread_info.cancel = false; + _lock.unlock (); + + /* And re-awake the thread */ + _run_cond.signal (); } void -StripSilenceDialog::update_stats (const SilenceResult& res) +StripSilenceDialog::threshold_changed () { - if (res.empty()) { - return; - } - - max_silence = 0; - min_silence = max_frames; - max_audible = 0; - min_audible = max_frames; - - SilenceResult::const_iterator cur; - - cur = res.begin(); - - framepos_t start = 0; - framepos_t end; - bool in_silence; - - if (cur->first == 0) { - /* initial segment, starting at zero, is silent */ - end = cur->second; - in_silence = true; - } else { - /* initial segment, starting at zero, is audible */ - end = cur->first; - in_silence = false; - } - - while (cur != res.end()) { - - framecnt_t interval_duration; - - interval_duration = end - start; - - if (in_silence) { - - max_silence = max (max_silence, interval_duration); - min_silence = min (min_silence, interval_duration); - } else { - - max_audible = max (max_audible, interval_duration); - min_audible = min (min_audible, interval_duration); - } - - start = end; - ++cur; - end = cur->first; - in_silence = !in_silence; - } + update_threshold_line (); + restart_thread (); } -nframes_t +framecnt_t StripSilenceDialog::minimum_length () const { - return _minimum_length.current_duration (_waves.front().region->position()); + return _minimum_length->current_duration (views.front().view->region()->position()); } -nframes_t +framecnt_t StripSilenceDialog::fade_length () const { - return _minimum_length.current_duration (_waves.front().region->position()); + return _fade_length->current_duration (views.front().view->region()->position()); +} + +void +StripSilenceDialog::update_progress_gui (float p) +{ + _progress_bar.set_fraction (p); }