X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fauditioner.cc;h=0c7ba0bc1c15b81c4c335ad2430df2a9d5c3485f;hb=e0ff70cf86c01c42f98faf8b0eaf1a8ccf867946;hp=7bf9f0542a3584f479a500f55e24a114d31a7d23;hpb=93c7aeba048f19df5abee5e4325ef8b0ef62c279;p=ardour.git diff --git a/libs/ardour/auditioner.cc b/libs/ardour/auditioner.cc index 7bf9f0542a..0c7ba0bc1c 100644 --- a/libs/ardour/auditioner.cc +++ b/libs/ardour/auditioner.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2001 Paul Davis + Copyright (C) 2001 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -15,22 +15,29 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ -#include - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include + +#include "pbd/error.h" + +#include "ardour/amp.h" +#include "ardour/audio_diskstream.h" +#include "ardour/audio_port.h" +#include "ardour/audioengine.h" +#include "ardour/audioplaylist.h" +#include "ardour/audioregion.h" +#include "ardour/auditioner.h" +#include "ardour/data_type.h" +#include "ardour/delivery.h" +#include "ardour/midi_diskstream.h" +#include "ardour/midi_region.h" +#include "ardour/plugin.h" +#include "ardour/plugin_insert.h" +#include "ardour/profile.h" +#include "ardour/region_factory.h" +#include "ardour/route.h" +#include "ardour/session.h" using namespace std; using namespace ARDOUR; @@ -39,139 +46,508 @@ using namespace PBD; #include "i18n.h" Auditioner::Auditioner (Session& s) - : AudioTrack (s, "auditioner", Route::Hidden) + : Track (s, "auditioner", PresentationInfo::Auditioner) + , current_frame (0) + , _auditioning (0) + , length (0) + , _seek_frame (-1) + , _seeking (false) + , _seek_complete (false) + , via_monitor (false) + , _midi_audition (false) + , _synth_added (false) + , _synth_changed (false) + , _queue_panic (false) + , _import_position (0) +{ +} + +int +Auditioner::init () +{ + if (Track::init ()) { + return -1; + } + + if (connect ()) { + return -1; + } + + _output->add_port ("", this, DataType::MIDI); + + lookup_synth(); + + _output->changed.connect_same_thread (*this, boost::bind (&Auditioner::output_changed, this, _1, _2)); + Config->ParameterChanged.connect_same_thread (*this, boost::bind (&Auditioner::config_changed, this, _1)); + + return 0; +} + +Auditioner::~Auditioner () +{ + if (asynth) { + asynth->drop_references (); + } + asynth.reset (); +} + +void +Auditioner::lookup_synth () +{ + string plugin_id = Config->get_midi_audition_synth_uri(); + asynth.reset (); + if (!plugin_id.empty()) { + boost::shared_ptr p; + p = find_plugin (_session, plugin_id, ARDOUR::LV2); + if (!p) { + p = find_plugin (_session, "https://community.ardour.org/node/7596", ARDOUR::LV2); + if (p) { + warning << _("Falling back to Reasonable Synth for Midi Audition") << endmsg; + } else { + warning << _("No synth for midi-audition found.") << endmsg; + Config->set_midi_audition_synth_uri(""); // Don't check again for Reasonable Synth (ie --no-lv2) + } + } + if (p) { + asynth = boost::shared_ptr (new PluginInsert (_session, p)); + } + } +} + +void +Auditioner::config_changed (std::string p) +{ + if (p == "midi-audition-synth-uri") { + _synth_changed = true; + } +} + +int +Auditioner::connect () { string left = Config->get_auditioner_output_left(); string right = Config->get_auditioner_output_right(); - - if ((left.length() == 0) && (right.length() == 0)) { - return; + + vector outputs; + _session.engine().get_physical_outputs (DataType::AUDIO, outputs); + + via_monitor = false; + + if (left.empty() || left == "default") { + if (_session.monitor_out()) { + left = _session.monitor_out()->input()->audio (0)->name(); + via_monitor = true; + } else { + if (outputs.size() > 0) { + left = outputs[0]; + } + } } - defer_pan_reset (); + if (right.empty() || right == "default") { + if (_session.monitor_out()) { + right = _session.monitor_out()->input()->audio (1)->name(); + via_monitor = true; + } else { + if (outputs.size() > 1) { + right = outputs[1]; + } + } + } + + _output->disconnect (this); + + if (left.empty() && right.empty()) { + if (_output->n_ports().n_audio() == 0) { + /* ports not set up, so must be during startup */ + warning << _("no outputs available for auditioner - manual connection required") << endmsg; + } + } else { + + if (_output->n_ports().n_audio() == 0) { + + /* create (and connect) new ports */ + + _main_outs->defer_pan_reset (); + + if (left.length()) { + _output->add_port (left, this, DataType::AUDIO); + } + + if (right.length()) { + _output->add_port (right, this, DataType::AUDIO); + } + + _main_outs->allow_pan_reset (); + _main_outs->reset_panner (); + + } else { + + /* reconnect existing ports */ + + boost::shared_ptr oleft (_output->nth (0)); + boost::shared_ptr oright (_output->nth (1)); + if (oleft) { + oleft->connect (left); + } + if (oright) { + oright->connect (right); + } + } - if (left.length()) { - add_output_port (left, this, DataType::AUDIO); } - if (right.length()) { - audio_diskstream()->add_channel(); - add_output_port (right, this, DataType::AUDIO); + return 0; +} + + +DataType +Auditioner::data_type () const { + if (_midi_audition) { + return DataType::MIDI; + } else { + return DataType::AUDIO; + } +} + +boost::shared_ptr +Auditioner::create_diskstream () { + + { + AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0); + dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden); + _diskstream_audio = boost::shared_ptr (new AudioDiskstream (_session, name(), dflags)); } - allow_pan_reset (); - - IO::output_changed.connect (mem_fun (*this, &Auditioner::output_changed)); + { + MidiDiskstream::Flag dflags = MidiDiskstream::Flag (0); + dflags = MidiDiskstream::Flag (dflags | MidiDiskstream::Hidden); + _diskstream_midi = boost::shared_ptr (new MidiDiskstream (_session, name(), dflags)); + _diskstream_midi->do_refill_with_alloc (); + _diskstream_midi->playlist()->set_orig_track_id (id()); + } - the_region.reset ((AudioRegion*) 0); - g_atomic_int_set (&_active, 0); + return _diskstream_audio; } -Auditioner::~Auditioner () +int +Auditioner::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) { + if (_midi_audition) { + return roll_midi(nframes, start_frame, end_frame, declick, need_butler); + } else { + return roll_audio(nframes, start_frame, end_frame, declick, need_butler); + } +} + +int +Auditioner::roll_midi (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) { + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { + return 0; + } + + assert(_active); + + framecnt_t playback_distance = nframes; + boost::shared_ptr diskstream = midi_diskstream(); + BufferSet& bufs = _session.get_route_buffers (n_process_buffers()); + MidiBuffer& mbuf (bufs.get_midi (0)); + _silent = false; + + ChanCount cnt (DataType::MIDI, 1); + cnt.set (DataType::AUDIO, bufs.count().n_audio()); + bufs.set_count (cnt); + + if (_queue_panic) { + _queue_panic = false; + for (uint8_t chn = 0; chn < 0xf; ++chn) { + uint8_t buf[3] = { ((uint8_t) (MIDI_CMD_CONTROL | chn)), ((uint8_t) MIDI_CTL_SUSTAIN), 0 }; + mbuf.push_back(0, 3, buf); + buf[1] = MIDI_CTL_ALL_NOTES_OFF; + mbuf.push_back(0, 3, buf); + buf[1] = MIDI_CTL_RESET_CONTROLLERS; + mbuf.push_back(0, 3, buf); + } + process_output_buffers (bufs, start_frame, start_frame+1, 1, false, false); + + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + boost::shared_ptr d = boost::dynamic_pointer_cast (*i); + if (d) { + d->flush_buffers (nframes); + } + } + } + + diskstream->get_playback (mbuf, nframes); + + process_output_buffers (bufs, start_frame, end_frame, nframes, + declick, (!diskstream->record_enabled() && !_session.transport_stopped())); + + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + boost::shared_ptr d = boost::dynamic_pointer_cast (*i); + if (d) { + d->flush_buffers (nframes); + } + } + + need_butler = diskstream->commit (playback_distance); + return 0; +} + + +int +Auditioner::roll_audio (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) { + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + if (!lm.locked()) { + return 0; + } + + assert(n_outputs().n_total() > 0); + assert(_active); + + int dret; + framecnt_t playback_distance; + framepos_t transport_frame = _session.transport_frame(); + boost::shared_ptr diskstream = audio_diskstream(); + BufferSet& bufs = _session.get_route_buffers (n_process_buffers ()); + + _silent = false; + _amp->apply_gain_automation(false); + + if ((dret = diskstream->process (bufs, transport_frame, nframes, playback_distance, (monitoring_state() == MonitoringDisk))) != 0) { + need_butler = diskstream->commit (playback_distance); + silence (nframes); + return dret; + } + + process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!diskstream->record_enabled() && _session.transport_rolling())); + need_butler = diskstream->commit (playback_distance); + return 0; +} + +void +Auditioner::set_diskstream (boost::shared_ptr ds) +{ + Track::set_diskstream (ds); + + _diskstream->set_track (this); + if (Profile->get_trx()) { + _diskstream->set_destructive (false); + } else { + _diskstream->set_destructive (_mode == Destructive); + } + _diskstream->set_non_layered (_mode == NonLayered); + _diskstream->set_record_enabled (false); + _diskstream->request_input_monitoring (false); + + DiskstreamChanged (); /* EMIT SIGNAL */ } AudioPlaylist& Auditioner::prepare_playlist () { + // used by CrossfadeEditor::audition() + + _midi_audition = false; + set_diskstream(_diskstream_audio); + if (_synth_added) { + remove_processor(asynth); + _synth_added = false; + } + // FIXME auditioner is still audio-only - AudioPlaylist* const apl = dynamic_cast(_diskstream->playlist()); + boost::shared_ptr apl = boost::dynamic_pointer_cast(_diskstream->playlist()); assert(apl); - apl->clear (false); + apl->clear (); return *apl; } void -Auditioner::audition_current_playlist () +Auditioner::audition_region (boost::shared_ptr region) { - if (g_atomic_int_get (&_active)) { + if (g_atomic_int_get (&_auditioning)) { /* don't go via session for this, because we are going to remain active. */ cancel_audition (); } - Glib::Mutex::Lock lm (lock); - _diskstream->seek (0); - length = _diskstream->playlist()->get_maximum_extent(); - current_frame = 0; + Glib::Threads::Mutex::Lock lm (lock); - /* force a panner reset now that we have all channels */ + if (boost::dynamic_pointer_cast(region) != 0) { - _panner->reset (n_outputs(), _diskstream->n_channels()); + _midi_audition = false; + set_diskstream(_diskstream_audio); + if (_synth_added) { + remove_processor(asynth); + _synth_added = false; + } + midi_region.reset(); + _import_position = 0; - g_atomic_int_set (&_active, 1); -} + /* copy it */ + the_region = boost::dynamic_pointer_cast (RegionFactory::create (region)); + the_region->set_position (0); -void -Auditioner::audition_region (boost::shared_ptr region) -{ - if (g_atomic_int_get (&_active)) { - /* don't go via session for this, because we are going - to remain active. - */ - cancel_audition (); - } + _diskstream->playlist()->drop_regions (); + _diskstream->playlist()->add_region (the_region, 0, 1); - if (boost::dynamic_pointer_cast(region) == 0) { - error << _("Auditioning of non-audio regions not yet supported") << endmsg; - return; - } + if (_diskstream->n_channels().n_audio() < the_region->n_channels()) { + audio_diskstream()->add_channel (the_region->n_channels() - _diskstream->n_channels().n_audio()); + } else if (_diskstream->n_channels().n_audio() > the_region->n_channels()) { + audio_diskstream()->remove_channel (_diskstream->n_channels().n_audio() - the_region->n_channels()); + } - Glib::Mutex::Lock lm (lock); + ProcessorStreams ps; + { + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); - /* copy it */ + if (configure_processors (&ps)) { + error << string_compose (_("Cannot setup auditioner processing flow for %1 channels"), + _diskstream->n_channels()) << endmsg; + return; + } + } - boost::shared_ptr the_region (boost::dynamic_pointer_cast (RegionFactory::create (region))); - the_region->set_position (0, this); + } else if (boost::dynamic_pointer_cast(region)) { + _midi_audition = true; + set_diskstream(_diskstream_midi); + the_region.reset(); + _import_position = region->position(); - _diskstream->playlist()->clear (false); - _diskstream->playlist()->add_region (the_region, 0, 1, false); + /* copy it */ + midi_region = (boost::dynamic_pointer_cast (RegionFactory::create (region))); + midi_region->set_position (_import_position); + + _diskstream->playlist()->drop_regions (); + _diskstream->playlist()->add_region (midi_region, _import_position, 1); + midi_diskstream()->reset_tracker(); + + ProcessorStreams ps; + + if (_synth_changed && _synth_added) { + remove_processor(asynth); + _synth_added = false; + } + if (_synth_changed && !_synth_added) { + _synth_added = false; + lookup_synth(); + } - while (_diskstream->n_channels() < the_region->n_channels()) { - audio_diskstream()->add_channel (); - } - while (_diskstream->n_channels() > the_region->n_channels()) { - audio_diskstream()->remove_channel (); + if (!_synth_added && asynth) { + int rv = add_processor (asynth, PreFader, &ps, true); + if (rv) { + error << _("Failed to load synth for MIDI-Audition.") << endmsg; + } else { + _synth_added = true; + } + } else { + _queue_panic = true; + } + + { + Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ()); + + if (configure_processors (&ps)) { + error << string_compose (_("Cannot setup auditioner processing flow for %1 channels"), + _diskstream->n_channels()) << endmsg; + return; + } + } + + } else { + error << _("Auditioning of regions other than Audio or Midi is not supported.") << endmsg; + return; } /* force a panner reset now that we have all channels */ + _main_outs->reset_panner(); + + _seek_frame = -1; + _seeking = false; + + int dir; + framecnt_t offset; - _panner->reset (n_outputs(), _diskstream->n_channels()); + if (_midi_audition) { + length = midi_region->length(); + offset = _import_position + midi_region->sync_offset (dir); + } else { + length = the_region->length(); + offset = the_region->sync_offset (dir); + } - length = the_region->length(); - _diskstream->seek (0); - current_frame = 0; - g_atomic_int_set (&_active, 1); + /* can't audition from a negative sync point */ + + if (dir < 0) { + offset = 0; + } + + _diskstream->seek (offset, true); + current_frame = offset; + + g_atomic_int_set (&_auditioning, 1); } int -Auditioner::play_audition (nframes_t nframes) +Auditioner::play_audition (framecnt_t nframes) { - bool need_butler; - nframes_t this_nframes; + bool need_butler = false; + framecnt_t this_nframes; int ret; - if (g_atomic_int_get (&_active) == 0) { - silence (nframes, 0); + if (g_atomic_int_get (&_auditioning) == 0) { + silence (nframes); return 0; } - this_nframes = min (nframes, length - current_frame); +#if 0 // TODO + if (_seeking && _seek_complete) { + // set FADE-IN + } else if (_seek_frame >= 0 && _seek_frame < length && !_seeking) { + // set FADE-OUT -- use/override amp? || use region-gain ? + } +#endif + + if (_seeking && _seek_complete) { + _seek_complete = false; + _seeking = false; + _seek_frame = -1; + if (_midi_audition && midi_diskstream()) { + midi_diskstream()->reset_tracker(); + } + } + + if(!_seeking) { + /* process audio */ + this_nframes = min (nframes, length - current_frame + _import_position); + + if ((ret = roll (this_nframes, current_frame, current_frame + nframes, false, need_butler)) != 0) { + silence (nframes); + return ret; + } + + current_frame += this_nframes; - _diskstream->prepare (); + } else { + silence (nframes); + } - if ((ret = roll (this_nframes, current_frame, current_frame + nframes, 0, false, false, false)) != 0) { - silence (nframes, 0); - return ret; + if (_seek_frame >= 0 && _seek_frame < length && !_seeking) { + _queue_panic = true; + _seek_complete = false; + _seeking = true; + need_butler = true; } - need_butler = _diskstream->commit (this_nframes); - current_frame += this_nframes; + if (!_seeking) { + AuditionProgress(current_frame - _import_position, length); /* emit */ + } - if (current_frame >= length) { + if (current_frame >= length + _import_position) { _session.cancel_audition (); return 0; } else { @@ -180,20 +556,75 @@ Auditioner::play_audition (nframes_t nframes) } void -Auditioner::output_changed (IOChange change, void* src) +Auditioner::output_changed (IOChange change, void* /*src*/) { - if (change & ConnectionsChanged) { - const char ** connections; - connections = output (0)->get_connections (); - if (connections) { - Config->set_auditioner_output_left (connections[0]); - free (connections); + if (change.type & IOChange::ConnectionsChanged) { + string phys; + vector connections; + vector outputs; + _session.engine().get_physical_outputs (DataType::AUDIO, outputs); + if (_output->nth (0)->get_connections (connections)) { + if (outputs.size() > 0) { + phys = outputs[0]; + } + if (phys != connections[0]) { + Config->set_auditioner_output_left (connections[0]); + } else { + Config->set_auditioner_output_left ("default"); + } + } else { + Config->set_auditioner_output_left (""); } - - connections = output (1)->get_connections (); - if (connections) { - Config->set_auditioner_output_right (connections[0]); - free (connections); + + connections.clear (); + + if (_output->nth (1)->get_connections (connections)) { + if (outputs.size() > 1) { + phys = outputs[1]; + } + if (phys != connections[0]) { + Config->set_auditioner_output_right (connections[0]); + } else { + Config->set_auditioner_output_right ("default"); + } + } else { + Config->set_auditioner_output_right (""); } } } + +ChanCount +Auditioner::input_streams () const +{ + /* auditioner never has any inputs - its channel configuration + depends solely on the region we are auditioning. + */ + + if (!_midi_audition && audio_diskstream()) { + return audio_diskstream()->n_channels(); + } + if (_midi_audition && midi_diskstream()) { + ChanCount cnt (DataType::MIDI, 1); + return cnt; + } + + return ChanCount (); +} + +MonitorState +Auditioner::monitoring_state () const +{ + return MonitoringDisk; +} + +boost::shared_ptr +Auditioner::audio_diskstream() const +{ + return boost::dynamic_pointer_cast (_diskstream); +} + +boost::shared_ptr +Auditioner::midi_diskstream() const +{ + return boost::dynamic_pointer_cast (_diskstream); +}