X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Ftrack.cc;h=4f22892b5ab2594549ed6eb1788ef0980589dc87;hb=097176696b055b91fcc4298965c9042a4cc71f47;hp=41769ae471f0cbd189d027b37d179a5de8f819af;hpb=53e6f13852f1cc831002cce9dc84d07e7e526515;p=ardour.git diff --git a/libs/ardour/track.cc b/libs/ardour/track.cc index 41769ae471..4f22892b5a 100644 --- a/libs/ardour/track.cc +++ b/libs/ardour/track.cc @@ -19,6 +19,9 @@ #include "ardour/amp.h" #include "ardour/audioengine.h" +#include "ardour/audiofilesource.h" +#include "ardour/audioplaylist.h" +#include "ardour/audioregion.h" #include "ardour/debug.h" #include "ardour/delivery.h" #include "ardour/disk_reader.h" @@ -26,17 +29,21 @@ #include "ardour/event_type_map.h" #include "ardour/io_processor.h" #include "ardour/meter.h" +#include "ardour/midi_playlist.h" +#include "ardour/midi_region.h" #include "ardour/monitor_control.h" #include "ardour/playlist.h" #include "ardour/playlist_factory.h" #include "ardour/port.h" #include "ardour/processor.h" #include "ardour/profile.h" +#include "ardour/region_factory.h" #include "ardour/record_enable_control.h" #include "ardour/record_safe_control.h" #include "ardour/route_group_specialized.h" #include "ardour/session.h" #include "ardour/session_playlists.h" +#include "ardour/smf_source.h" #include "ardour/track.h" #include "ardour/types_convert.h" #include "ardour/utils.h" @@ -49,48 +56,56 @@ using namespace PBD; Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type) : Route (sess, name, flag, default_type) - , _saved_meter_point (_meter_point) - , _mode (mode) + , _saved_meter_point (_meter_point) + , _mode (mode) + , _alignment_choice (Automatic) { _freeze_record.state = NoFreeze; - _declickable = true; } Track::~Track () { DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name)); + + if (_disk_reader) { + _disk_reader->set_route (boost::shared_ptr()); + _disk_reader.reset (); + } + + if (_disk_writer) { + _disk_writer->set_route (boost::shared_ptr()); + _disk_writer.reset (); + } } int Track::init () { - if (Route::init ()) { - return -1; - } - - DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable; + if (Route::init ()) { + return -1; + } - if (_mode == Destructive && !Profile->get_trx()) { - dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive); - } else if (_mode == NonLayered){ - dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered); - } + DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable; - _disk_reader.reset (new DiskReader (_session, name(), dflags)); + if (_mode == Destructive && !Profile->get_trx()) { + dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive); + } - _disk_reader->set_block_size (_session.get_block_size ()); - _disk_reader->set_route (shared_from_this()); + _disk_reader.reset (new DiskReader (_session, name(), dflags)); + _disk_reader->set_block_size (_session.get_block_size ()); + _disk_reader->set_route (boost::dynamic_pointer_cast (shared_from_this())); + _disk_reader->set_owner (this); - _disk_writer.reset (new DiskWriter (_session, name(), dflags)); - _disk_writer->set_block_size (_session.get_block_size ()); - _disk_writer->set_route (shared_from_this()); + _disk_writer.reset (new DiskWriter (_session, name(), dflags)); + _disk_writer->set_block_size (_session.get_block_size ()); + _disk_writer->set_route (boost::dynamic_pointer_cast (shared_from_this())); + _disk_writer->set_owner (this); - use_new_playlist (); + set_align_choice_from_io (); - add_processor (_disk_writer, PreFader); - add_processor (_disk_reader, PreFader); + use_new_playlist (data_type()); - boost::shared_ptr rp (boost::dynamic_pointer_cast (shared_from_this())); + boost::shared_ptr rp (boost::dynamic_pointer_cast (shared_from_this())); boost::shared_ptr rt = boost::dynamic_pointer_cast (rp); _record_enable_control.reset (new RecordEnableControl (_session, EventTypeMap::instance().to_symbol (RecEnableAutomation), *this)); @@ -104,30 +119,34 @@ Track::init () _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1)); - _monitoring_control->Changed.connect_same_thread (*this, boost::bind (&Track::monitoring_changed, this, _1, _2)); - _record_safe_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_safe_changed, this, _1, _2)); - _record_enable_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_enable_changed, this, _1, _2)); + _monitoring_control->Changed.connect_same_thread (*this, boost::bind (&Track::monitoring_changed, this, _1, _2)); + _record_safe_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_safe_changed, this, _1, _2)); + _record_enable_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_enable_changed, this, _1, _2)); + + _input->changed.connect_same_thread (*this, boost::bind (&Track::input_changed, this)); - return 0; + return 0; } -XMLNode& -Track::get_state () +void +Track::input_changed () { - return state (true); + if (_disk_writer && _alignment_choice == Automatic) { + set_align_choice_from_io (); + } } XMLNode& -Track::state (bool full) +Track::state (bool save_template) { - XMLNode& root (Route::state (full)); + XMLNode& root (Route::state (save_template)); if (_playlists[DataType::AUDIO]) { - root.add_property (X_("audio-playlist"), _playlists[DataType::AUDIO]->id().to_s()); + root.set_property (X_("audio-playlist"), _playlists[DataType::AUDIO]->id().to_s()); } if (_playlists[DataType::MIDI]) { - root.add_property (X_("midi-playlist"), _playlists[DataType::MIDI]->id().to_s()); + root.set_property (X_("midi-playlist"), _playlists[DataType::MIDI]->id().to_s()); } root.add_child_nocopy (_monitoring_control->get_state ()); @@ -135,6 +154,7 @@ Track::state (bool full) root.add_child_nocopy (_record_enable_control->get_state ()); root.set_property (X_("saved-meter-point"), _saved_meter_point); + root.set_property (X_("alignment-choice"), _alignment_choice); return root; } @@ -146,21 +166,41 @@ Track::set_state (const XMLNode& node, int version) return -1; } - XMLNode* child; - XMLProperty const * prop; + if (version >= 3000 && version < 6000) { + if (XMLNode* ds_node = find_named_node (node, "Diskstream")) { + std::string name; + if (ds_node->get_property ("name", name)) { - if (version >= 3000 && version < 4000) { - if ((child = find_named_node (node, X_("Diskstream"))) != 0) { - /* XXX DISK ... setup reader/writer from XML */ + ds_node->set_property ("active", true); + + _disk_writer->set_state (*ds_node, version); + _disk_reader->set_state (*ds_node, version); + + AlignChoice ac; + if (ds_node->get_property (X_("capture-alignment"), ac)) { + set_align_choice (ac, true); + } + + if (boost::shared_ptr pl = boost::dynamic_pointer_cast (_session.playlists->by_name (name))) { + use_playlist (DataType::AUDIO, pl); + } + + if (boost::shared_ptr pl = boost::dynamic_pointer_cast (_session.playlists->by_name (name))) { + use_playlist (DataType::MIDI, pl); + } + } } } - if ((prop = node.property (X_("audio-playlist")))) { - find_and_use_playlist (DataType::AUDIO, PBD::ID (prop->value())); + XMLNode* child; + std::string playlist_id; + + if (node.get_property (X_("audio-playlist"), playlist_id)) { + find_and_use_playlist (DataType::AUDIO, PBD::ID (playlist_id)); } - if ((prop = node.property (X_("midi-playlist")))) { - find_and_use_playlist (DataType::MIDI, PBD::ID (prop->value())); + if (node.get_property (X_("midi-playlist"), playlist_id)) { + find_and_use_playlist (DataType::MIDI, PBD::ID (playlist_id)); } XMLNodeList nlist = node.children(); @@ -187,13 +227,14 @@ Track::set_state (const XMLNode& node, int version) _saved_meter_point = _meter_point; } - return 0; -} -XMLNode& -Track::get_template () -{ - return state (false); + AlignChoice ac; + + if (node.get_property (X_("alignment-choice"), ac)) { + set_align_choice (ac, true); + } + + return 0; } Track::FreezeRecord::~FreezeRecord () @@ -209,6 +250,12 @@ Track::freeze_state() const return _freeze_record.state; } +bool +Track::declick_in_progress () const +{ + return _disk_reader->declick_in_progress (); +} + bool Track::can_record() { @@ -342,6 +389,7 @@ Track::set_name (const string& str) _disk_writer->set_write_source_name (diskstream_name); boost::shared_ptr me = boost::dynamic_pointer_cast (shared_from_this ()); + if (_playlists[data_type()]->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) { /* Only rename the diskstream (and therefore the playlist) if a) the playlist has never had a region added to it and @@ -358,6 +406,12 @@ Track::set_name (const string& str) _disk_writer->set_name (str); } + for (uint32_t n = 0; n < DataType::num_types; ++n) { + if (_playlists[n]) { + _playlists[n]->set_name (str); + } + } + /* save state so that the statefile fully reflects any filename changes */ if ((ret = Route::set_name (str)) == 0) { @@ -367,181 +421,6 @@ Track::set_name (const string& str) return ret; } -void -Track::set_latency_compensation (framecnt_t longest_session_latency) -{ - Route::set_latency_compensation (longest_session_latency); - _disk_reader->set_roll_delay (_roll_delay); -} - -int -Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing) -{ - Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); - - if (!lm.locked()) { - return 0; - } - - bool can_record = _session.actively_recording (); - - /* no outputs? nothing to do ... what happens if we have sends etc. ? */ - - if (n_outputs().n_total() == 0 && !ARDOUR::Profile->get_mixbus()) { - //Note: Mixbus has its own output mechanism, so we should operate even if no explicit outputs are assigned - return 0; - } - - /* not active ... do the minimum possible by just outputting silence */ - - if (!_active) { - silence (nframes); - if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled())) { - _meter->reset(); - } - return 0; - } - - if (session_state_changing) { - if (_session.transport_speed() != 0.0f) { - /* we're rolling but some state is changing (e.g. our - disk reader contents) so we cannot use them. Be - silent till this is over. Don't declick. - - XXX note the absurdity of ::no_roll() being called when we ARE rolling! - */ - passthru_silence (start_frame, end_frame, nframes, 0); - return 0; - } - /* we're really not rolling, so we're either delivery silence or actually - monitoring, both of which are safe to do while session_state_changing is true. - */ - } - - _disk_writer->check_record_status (start_frame, can_record); - - bool be_silent; - - MonitorState const s = monitoring_state (); - /* we are not rolling, so be silent even if we are monitoring disk, as there - will be no disk data coming in. - */ - switch (s) { - case MonitoringSilence: - be_silent = true; - break; - case MonitoringDisk: - be_silent = true; - break; - case MonitoringInput: - be_silent = false; - break; - default: - be_silent = false; - break; - } - - //if we have an internal generator, let it play regardless of monitoring state - if (_have_internal_generator) { - be_silent = false; - } - - _amp->apply_gain_automation (false); - - /* if have_internal_generator, or .. */ - - if (be_silent) { - - if (_meter_point == MeterInput) { - /* still need input monitoring and metering */ - - bool const track_rec = _disk_writer->record_enabled (); - bool const auto_input = _session.config.get_auto_input (); - bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; - bool const tape_machine_mode = Config->get_tape_machine_mode (); - bool no_meter = false; - - /* this needs a proper K-map - * and should be separated into a function similar to monitoring_state() - * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc - * - * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf - */ - if (!auto_input && !track_rec) { - no_meter=true; - } - else if (tape_machine_mode && !track_rec && auto_input) { - no_meter=true; - } - else if (!software_monitor && tape_machine_mode && !track_rec) { - no_meter=true; - } - else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) { - no_meter=true; - } - - if (no_meter) { - BufferSet& bufs (_session.get_silent_buffers (n_process_buffers())); - _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true); - _input->process_input (boost::shared_ptr(), start_frame, end_frame, speed(), nframes); - } else { - _input->process_input (_meter, start_frame, end_frame, speed(), nframes); - } - } - - passthru_silence (start_frame, end_frame, nframes, 0); - - } else { - - BufferSet& bufs = _session.get_route_buffers (n_process_buffers()); - - fill_buffers_with_input (bufs, _input, nframes); - - if (_meter_point == MeterInput) { - _meter->run (bufs, start_frame, end_frame, 1.0 /*speed()*/, nframes, true); - } - - passthru (bufs, start_frame, end_frame, nframes, false); - } - - flush_processor_buffers_locked (nframes); - - return 0; -} - -int -Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler) -{ - Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); - if (!lm.locked()) { - // XXX DISK reader needs to seek ahead the correct distance ?? OR DOES IT ? - //framecnt_t playback_distance = _disk_reader->calculate_playback_distance(nframes); - //if (can_internal_playback_seek(playback_distance)) { - // internal_playback_seek(playback_distance); - //} - return 0; - } - - if (n_outputs().n_total() == 0 && _processors.empty()) { - return 0; - } - - if (!_active) { - silence (nframes); - return 0; - } - - _silent = true; - _amp->apply_gain_automation(false); - - silence (nframes); - flush_processor_buffers_locked (nframes); - - //BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true)); - // XXXX DISKWRITER/READER ADVANCE, SET need_butler - return 0; -} - boost::shared_ptr Track::playlist () { @@ -576,12 +455,6 @@ Track::last_capture_sources () return _disk_writer->last_capture_sources (); } -void -Track::set_capture_offset () -{ - _disk_writer->set_capture_offset (); -} - std::string Track::steal_write_source_name() { @@ -625,7 +498,7 @@ Track::set_pending_overwrite (bool o) } int -Track::seek (framepos_t p, bool complete_refill) +Track::seek (samplepos_t p, bool complete_refill) { if (_disk_reader->seek (p, complete_refill)) { return -1; @@ -633,42 +506,22 @@ Track::seek (framepos_t p, bool complete_refill) return _disk_writer->seek (p, complete_refill); } -bool -Track::hidden () const -{ - return _disk_writer->hidden () || _disk_reader->hidden(); -} - int -Track::can_internal_playback_seek (framecnt_t p) +Track::can_internal_playback_seek (samplecnt_t p) { return _disk_reader->can_internal_playback_seek (p); } int -Track::internal_playback_seek (framecnt_t p) +Track::internal_playback_seek (samplecnt_t p) { return _disk_reader->internal_playback_seek (p); } void -Track::non_realtime_locate (framepos_t p) +Track::non_realtime_locate (samplepos_t p) { Route::non_realtime_locate (p); - - if (!hidden()) { - /* don't waste i/o cycles and butler calls - for hidden (secret) tracks - */ - _disk_reader->non_realtime_locate (p); - _disk_writer->non_realtime_locate (p); - } -} - -void -Track::non_realtime_set_speed () -{ - _disk_reader->non_realtime_set_speed (); } int @@ -677,36 +530,18 @@ Track::overwrite_existing_buffers () return _disk_reader->overwrite_existing_buffers (); } -framecnt_t -Track::get_captured_frames (uint32_t n) const -{ - return _disk_writer->get_captured_frames (n); -} - -int -Track::set_loop (Location* l) +samplecnt_t +Track::get_captured_samples (uint32_t n) const { - if (_disk_reader->set_loop (l)) { - return -1; - } - return _disk_writer->set_loop (l); + return _disk_writer->get_captured_samples (n); } void -Track::transport_looped (framepos_t p) +Track::transport_looped (samplepos_t p) { return _disk_writer->transport_looped (p); } -bool -Track::realtime_set_speed (double s, bool g) -{ - if (_disk_reader->realtime_set_speed (s, g)) { - return -1; - } - return _disk_writer->realtime_set_speed (s, g); -} - void Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g) { @@ -719,18 +554,6 @@ Track::pending_overwrite () const return _disk_reader->pending_overwrite (); } -double -Track::speed () const -{ - return _disk_reader->speed (); -} - -void -Track::prepare_to_stop (framepos_t t, framepos_t a) -{ - _disk_writer->prepare_to_stop (t, a); -} - void Track::set_slaved (bool s) { @@ -741,13 +564,13 @@ Track::set_slaved (bool s) ChanCount Track::n_channels () { - return _disk_reader->output_streams(); // XXX DISK + return _disk_reader->output_streams(); } -framepos_t -Track::get_capture_start_frame (uint32_t n) const +samplepos_t +Track::get_capture_start_sample (uint32_t n) const { - return _disk_writer->get_capture_start_frame (n); + return _disk_writer->get_capture_start_sample (n); } AlignStyle @@ -759,16 +582,16 @@ Track::alignment_style () const AlignChoice Track::alignment_choice () const { - return _disk_writer->alignment_choice (); + return _alignment_choice; } -framepos_t +samplepos_t Track::current_capture_start () const { return _disk_writer->current_capture_start (); } -framepos_t +samplepos_t Track::current_capture_end () const { return _disk_writer->current_capture_end (); @@ -812,6 +635,9 @@ Track::use_playlist (DataType dt, boost::shared_ptr p) _playlists[dt] = p; } + _session.set_dirty (); + PlaylistChanged (); /* EMIT SIGNAL */ + return ret; } @@ -840,10 +666,10 @@ Track::use_copy_playlist () } int -Track::use_new_playlist () +Track::use_new_playlist (DataType dt) { string newname; - boost::shared_ptr playlist = _playlists[data_type()]; + boost::shared_ptr playlist = _playlists[dt]; if (playlist) { newname = Playlist::bump_name (playlist->name(), _session); @@ -851,25 +677,88 @@ Track::use_new_playlist () newname = Playlist::bump_name (_name, _session); } - playlist = PlaylistFactory::create (data_type(), _session, newname, hidden()); + playlist = PlaylistFactory::create (dt, _session, newname, is_private_route()); if (!playlist) { return -1; } - return use_playlist (data_type(), playlist); + return use_playlist (dt, playlist); +} + +void +Track::set_align_choice (AlignChoice ac, bool force) +{ + _alignment_choice = ac; + switch (ac) { + case Automatic: + set_align_choice_from_io (); + break; + case UseCaptureTime: + _disk_writer->set_align_style (CaptureTime, force); + break; + case UseExistingMaterial: + _disk_writer->set_align_style (ExistingMaterial, force); + break; + } } void Track::set_align_style (AlignStyle s, bool force) { - // XXX DISK + _disk_writer->set_align_style (s, force); } void -Track::set_align_choice (AlignChoice s, bool force) +Track::set_align_choice_from_io () { - // XXX DISK + bool have_physical = false; + + if (_input) { + uint32_t n = 0; + vector connections; + boost::shared_ptr p; + + while (true) { + + p = _input->nth (n++); + + if (!p) { + break; + } + + if (p->get_connections (connections) != 0) { + if (AudioEngine::instance()->port_is_physical (connections[0])) { + have_physical = true; + break; + } + } + + connections.clear (); + } + } + +#ifdef MIXBUS + // compensate for latency when bouncing from master or mixbus. + // we need to use "ExistingMaterial" to pick up the master bus' latency + // see also Route::direct_feeds_according_to_reality + IOVector ios; + ios.push_back (_input); + if (_session.master_out() && ios.fed_by (_session.master_out()->output())) { + have_physical = true; + } + for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) { + if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) { + have_physical = true; + } + } +#endif + + if (have_physical) { + _disk_writer->set_align_style (ExistingMaterial); + } else { + _disk_writer->set_align_style (CaptureTime); + } } void @@ -896,222 +785,292 @@ Track::adjust_capture_buffering () } } -#ifdef USE_TRACKS_CODE_FEATURES +void +Track::monitoring_changed (bool, Controllable::GroupControlDisposition) +{ + for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { + (*i)->monitoring_changed (); + } +} -/* This is the Tracks version of Track::monitoring_state(). - * - * Ardour developers: try to flag or fix issues if parts of the libardour API - * change in ways that invalidate this - */ +MeterState +Track::metering_state () const +{ + bool rv; + if (_session.transport_rolling ()) { + // audio_track.cc || midi_track.cc roll() runs meter IFF: + rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled()); + } else { + // track no_roll() always metering if + rv = _meter_point == MeterInput; + } + return rv ? MeteringInput : MeteringRoute; +} -MonitorState -Track::monitoring_state () const +bool +Track::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure) { - /* Explicit requests */ + if (Route::set_processor_state (node, prop, new_order, must_configure)) { + return true; + } - if (_monitoring & MonitorInput) { - return MonitoringInput; + cerr << name() << " looking for state for track procs, DR = " << _disk_reader << endl; + + if (prop->value() == "diskreader") { + if (_disk_reader) { + _disk_reader->set_state (node, Stateful::current_state_version); + new_order.push_back (_disk_reader); + return true; + } + } else if (prop->value() == "diskwriter") { + if (_disk_writer) { + _disk_writer->set_state (node, Stateful::current_state_version); + new_order.push_back (_disk_writer); + return true; + } } - if (_monitoring & MonitorDisk) { - return MonitoringDisk; + error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg; + return false; +} + +void +Track::use_captured_sources (SourceList& srcs, CaptureInfos const & capture_info) +{ + if (srcs.empty()) { + return; } - /* This is an implementation of the truth table in doc/monitor_modes.pdf; - I don't think it's ever going to be too pretty too look at. - */ + boost::shared_ptr afs = boost::dynamic_pointer_cast (srcs.front()); + boost::shared_ptr mfs = boost::dynamic_pointer_cast (srcs.front()); - // GZ: NOT USED IN TRACKS - //bool const auto_input = _session.config.get_auto_input (); - //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; - //bool const tape_machine_mode = Config->get_tape_machine_mode (); + if (afs) { + use_captured_audio_sources (srcs, capture_info); + } - bool const roll = _session.transport_rolling (); - bool const track_rec = _diskstream->record_enabled (); - bool session_rec = _session.actively_recording (); + if (mfs) { + use_captured_midi_sources (srcs, capture_info); + } +} - if (track_rec) { +void +Track::use_captured_midi_sources (SourceList& srcs, CaptureInfos const & capture_info) +{ + if (srcs.empty() || data_type() != DataType::MIDI) { + return; + } - if (!session_rec && roll) { - return MonitoringDisk; - } else { - return MonitoringInput; - } + boost::shared_ptr mfs = boost::dynamic_pointer_cast (srcs.front()); + boost::shared_ptr pl = _playlists[DataType::MIDI]; + boost::shared_ptr midi_region; + CaptureInfos::const_iterator ci; - } else { + if (!mfs || !pl) { + return; + } - if (roll) { - return MonitoringDisk; - } + samplecnt_t total_capture = 0; + + for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) { + total_capture += (*ci)->samples; } - return MonitoringSilence; -} + /* we will want to be able to keep (over)writing the source + but we don't want it to be removable. this also differs + from the audio situation, where the source at this point + must be considered immutable. luckily, we can rely on + MidiSource::mark_streaming_write_completed() to have + already done the necessary work for that. + */ -#else + string whole_file_region_name; + whole_file_region_name = region_name_from_path (mfs->name(), true); -/* This is the Ardour/Mixbus version of Track::monitoring_state(). - * - * Tracks developers: do NOT modify this method under any circumstances. - */ + /* Register a new region with the Session that + describes the entire source. Do this first + so that any sub-regions will obviously be + children of this one (later!) + */ -MonitorState -Track::monitoring_state () const -{ - /* Explicit requests */ - MonitorChoice m (_monitoring_control->monitoring_choice()); + try { + PropertyList plist; - if (m & MonitorInput) { - return MonitoringInput; - } + plist.add (Properties::name, whole_file_region_name); + plist.add (Properties::whole_file, true); + plist.add (Properties::automatic, true); + plist.add (Properties::start, 0); + plist.add (Properties::length, total_capture); + plist.add (Properties::layer, 0); + + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); - if (m & MonitorDisk) { - return MonitoringDisk; + midi_region = boost::dynamic_pointer_cast (rx); + midi_region->special_set_position (capture_info.front()->start); } - switch (_session.config.get_session_monitoring ()) { - case MonitorDisk: - return MonitoringDisk; - break; - case MonitorInput: - return MonitoringInput; - break; - default: - break; + catch (failed_constructor& err) { + error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg; + /* XXX what now? */ } - /* This is an implementation of the truth table in doc/monitor_modes.pdf; - I don't think it's ever going to be too pretty too look at. - */ + pl->clear_changes (); + pl->freeze (); - bool const roll = _session.transport_rolling (); - bool const track_rec = _disk_writer->record_enabled (); - bool const auto_input = _session.config.get_auto_input (); - bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring; - bool const tape_machine_mode = Config->get_tape_machine_mode (); - bool session_rec; - - /* I suspect that just use actively_recording() is good enough all the - * time, but just to keep the semantics the same as they were before - * sept 26th 2012, we differentiate between the cases where punch is - * enabled and those where it is not. - * - * rg: I suspect this is not the case: monitoring may differ - */ - - if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) { - session_rec = _session.actively_recording (); - } else { - session_rec = _session.get_record_enabled(); + /* Session sample time of the initial capture in this pass, which is where the source starts */ + samplepos_t initial_capture = 0; + if (!capture_info.empty()) { + initial_capture = capture_info.front()->start; } - if (track_rec) { + BeatsSamplesConverter converter (_session.tempo_map(), capture_info.front()->start); + const samplepos_t preroll_off = _session.preroll_record_trim_len (); - if (!session_rec && roll && auto_input) { - return MonitoringDisk; - } else { - return software_monitor ? MonitoringInput : MonitoringSilence; - } + for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) { - } else { + string region_name; - if (tape_machine_mode) { + RegionFactory::region_name (region_name, mfs->name(), false); - return MonitoringDisk; + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n", + _name, (*ci)->start, (*ci)->samples, region_name)); - } else { - if (!roll && auto_input) { - return software_monitor ? MonitoringInput : MonitoringSilence; - } else { - return MonitoringDisk; + // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->samples << " add a region\n"; + + try { + PropertyList plist; + + /* start of this region is the offset between the start of its capture and the start of the whole pass */ + plist.add (Properties::start, (*ci)->start - initial_capture); + plist.add (Properties::length, (*ci)->samples); + plist.add (Properties::length_beats, converter.from((*ci)->samples).to_double()); + plist.add (Properties::name, region_name); + + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + midi_region = boost::dynamic_pointer_cast (rx); + if (preroll_off > 0) { + midi_region->trim_front ((*ci)->start - initial_capture + preroll_off); } + } + catch (failed_constructor& err) { + error << _("MidiDiskstream: could not create region for captured midi!") << endmsg; + continue; /* XXX is this OK? */ } + + cerr << "add new region, len = " << (*ci)->samples << " @ " << (*ci)->start << endl; + + pl->add_region (midi_region, (*ci)->start + preroll_off, 1, _session.config.get_layered_record_mode ()); } - abort(); /* NOTREACHED */ - return MonitoringSilence; + pl->thaw (); + _session.add_command (new StatefulDiffCommand (pl)); } -#endif - void -Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick) +Track::use_captured_audio_sources (SourceList& srcs, CaptureInfos const & capture_info) { - /* never declick if there is an internal generator - we just want it to - keep generating sound without interruption. + if (srcs.empty() || data_type() != DataType::AUDIO) { + return; + } - ditto if we are monitoring inputs. - */ + boost::shared_ptr afs = boost::dynamic_pointer_cast (srcs.front()); + boost::shared_ptr pl = _playlists[DataType::AUDIO]; + boost::shared_ptr region; - if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) { - return; - } + if (!afs || !pl) { + return; + } + + /* destructive tracks have a single, never changing region */ + + if (destructive()) { + + /* send a signal that any UI can pick up to do the right thing. there is + a small problem here in that a UI may need the peak data to be ready + for the data that was recorded and this isn't interlocked with that + process. this problem is deferred to the UI. + */ - if (!declick) { - declick = _pending_declick; + pl->LayeringChanged(); // XXX this may not get the UI to do the right thing + return; } - if (declick != 0) { - Amp::declick (bufs, nframes, declick); + string whole_file_region_name; + whole_file_region_name = region_name_from_path (afs->name(), true); + + /* Register a new region with the Session that + describes the entire source. Do this first + so that any sub-regions will obviously be + children of this one (later!) + */ + + try { + PropertyList plist; + + plist.add (Properties::start, afs->last_capture_start_sample()); + plist.add (Properties::length, afs->length(0)); + plist.add (Properties::name, whole_file_region_name); + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + rx->set_automatic (true); + rx->set_whole_file (true); + + region = boost::dynamic_pointer_cast (rx); + region->special_set_position (afs->natural_position()); } -} -framecnt_t -Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame) -{ - if (_roll_delay > nframes) { - _roll_delay -= nframes; - silence_unlocked (nframes); - /* transport frame is not legal for caller to use */ - return 0; + catch (failed_constructor& err) { + error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg; + /* XXX what now? */ + } - } else if (_roll_delay > 0) { + pl->clear_changes (); + pl->set_capture_insertion_in_progress (true); + pl->freeze (); - nframes -= _roll_delay; - silence_unlocked (_roll_delay); - transport_frame += _roll_delay; + const samplepos_t preroll_off = _session.preroll_record_trim_len (); + samplecnt_t buffer_position = afs->last_capture_start_sample (); + CaptureInfos::const_iterator ci; - /* shuffle all the port buffers for things that lead "out" of this Route - to reflect that we just wrote _roll_delay frames of silence. - */ + for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) { + + string region_name; + + RegionFactory::region_name (region_name, whole_file_region_name, false); + + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n", + _name, (*ci)->start, (*ci)->samples, region_name, buffer_position)); + + try { - Glib::Threads::RWLock::ReaderLock lm (_processor_lock); - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - boost::shared_ptr iop = boost::dynamic_pointer_cast (*i); - if (iop) { - iop->increment_port_buffer_offset (_roll_delay); + PropertyList plist; + + plist.add (Properties::start, buffer_position); + plist.add (Properties::length, (*ci)->samples); + plist.add (Properties::name, region_name); + + boost::shared_ptr rx (RegionFactory::create (srcs, plist)); + region = boost::dynamic_pointer_cast (rx); + if (preroll_off > 0) { + region->trim_front (buffer_position + preroll_off); } } - _output->increment_port_buffer_offset (_roll_delay); - _roll_delay = 0; + catch (failed_constructor& err) { + error << _("AudioDiskstream: could not create region for captured audio!") << endmsg; + continue; /* XXX is this OK? */ + } + + pl->add_region (region, (*ci)->start + preroll_off, 1, _session.config.get_layered_record_mode()); + pl->set_layer (region, DBL_MAX); + buffer_position += (*ci)->samples; } - return nframes; + pl->thaw (); + pl->set_capture_insertion_in_progress (false); + _session.add_command (new StatefulDiffCommand (pl)); } -void -Track::monitoring_changed (bool, Controllable::GroupControlDisposition) -{ - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - (*i)->monitoring_changed (); - } -} -MeterState -Track::metering_state () const -{ - bool rv; - if (_session.transport_rolling ()) { - // audio_track.cc || midi_track.cc roll() runs meter IFF: - rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled()); - } else { - // track no_roll() always metering if - rv = _meter_point == MeterInput; - } - return rv ? MeteringInput : MeteringRoute; -}