2 Copyright (C) 2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 #include "pbd/error.h"
20 #include "ardour/amp.h"
21 #include "ardour/audioengine.h"
22 #include "ardour/audiofilesource.h"
23 #include "ardour/audioregion.h"
24 #include "ardour/debug.h"
25 #include "ardour/delivery.h"
26 #include "ardour/disk_reader.h"
27 #include "ardour/disk_writer.h"
28 #include "ardour/event_type_map.h"
29 #include "ardour/io_processor.h"
30 #include "ardour/meter.h"
31 #include "ardour/midi_region.h"
32 #include "ardour/monitor_control.h"
33 #include "ardour/playlist.h"
34 #include "ardour/playlist_factory.h"
35 #include "ardour/port.h"
36 #include "ardour/processor.h"
37 #include "ardour/profile.h"
38 #include "ardour/region_factory.h"
39 #include "ardour/record_enable_control.h"
40 #include "ardour/record_safe_control.h"
41 #include "ardour/route_group_specialized.h"
42 #include "ardour/session.h"
43 #include "ardour/session_playlists.h"
44 #include "ardour/smf_source.h"
45 #include "ardour/track.h"
46 #include "ardour/types_convert.h"
47 #include "ardour/utils.h"
52 using namespace ARDOUR;
55 Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type)
56 : Route (sess, name, flag, default_type)
57 , _saved_meter_point (_meter_point)
58 , _disk_io_point (DiskIOPreFader)
60 , _alignment_choice (Automatic)
62 _freeze_record.state = NoFreeze;
68 DEBUG_TRACE (DEBUG::Destruction, string_compose ("track %1 destructor\n", _name));
71 _disk_reader->set_route (boost::shared_ptr<Route>());
72 _disk_reader.reset ();
76 _disk_writer->set_route (boost::shared_ptr<Route>());
77 _disk_writer.reset ();
90 /* disk writer and reader processors will be added when Route calls
91 * add_processors_oh_children_of_mine ().
94 boost::shared_ptr<Route> rp (boost::dynamic_pointer_cast<Route> (shared_from_this()));
95 boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
97 _record_enable_control.reset (new RecordEnableControl (_session, EventTypeMap::instance().to_symbol (RecEnableAutomation), *this));
98 add_control (_record_enable_control);
100 _record_safe_control.reset (new RecordSafeControl (_session, EventTypeMap::instance().to_symbol (RecSafeAutomation), *this));
101 add_control (_record_safe_control);
103 _monitoring_control.reset (new MonitorControl (_session, EventTypeMap::instance().to_symbol (MonitoringAutomation), *this));
104 add_control (_monitoring_control);
106 _session.config.ParameterChanged.connect_same_thread (*this, boost::bind (&Track::parameter_changed, this, _1));
108 _monitoring_control->Changed.connect_same_thread (*this, boost::bind (&Track::monitoring_changed, this, _1, _2));
109 _record_safe_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_safe_changed, this, _1, _2));
110 _record_enable_control->Changed.connect_same_thread (*this, boost::bind (&Track::record_enable_changed, this, _1, _2));
112 _input->changed.connect_same_thread (*this, boost::bind (&Track::input_changed, this));
118 Track::add_processors_oh_children_of_mine ()
120 cerr << name() << " ::apocom(), create DW + DR\n";
122 DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable;
124 if (_mode == Destructive && !Profile->get_trx()) {
125 dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive);
126 } else if (_mode == NonLayered){
127 dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered);
130 _disk_reader.reset (new DiskReader (_session, name(), dflags));
131 _disk_reader->set_block_size (_session.get_block_size ());
132 _disk_reader->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
134 _disk_writer.reset (new DiskWriter (_session, name(), dflags));
135 _disk_writer->set_block_size (_session.get_block_size ());
136 _disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
140 Track::input_changed ()
142 if (_disk_writer && _alignment_choice == Automatic) {
143 set_align_choice_from_io ();
154 Track::state (bool full)
156 XMLNode& root (Route::state (full));
158 if (_playlists[DataType::AUDIO]) {
159 root.set_property (X_("audio-playlist"), _playlists[DataType::AUDIO]->id().to_s());
162 if (_playlists[DataType::MIDI]) {
163 root.set_property (X_("midi-playlist"), _playlists[DataType::MIDI]->id().to_s());
166 root.add_child_nocopy (_monitoring_control->get_state ());
167 root.add_child_nocopy (_record_safe_control->get_state ());
168 root.add_child_nocopy (_record_enable_control->get_state ());
170 root.set_property (X_("saved-meter-point"), _saved_meter_point);
171 root.set_property (X_("disk-io-point"), _disk_io_point);
172 root.set_property (X_("alignment-choice"), _alignment_choice);
178 Track::set_state (const XMLNode& node, int version)
180 if (Route::set_state (node, version)) {
186 if (version >= 3000 && version < 4000) {
187 if ((child = find_named_node (node, X_("Diskstream"))) != 0) {
188 /* XXX if we remember anything from stored DiskStream
189 state (older Ardour versions) that is needed by a
190 DiskReader or DiskWriter, we should cook up a new
191 XMLNode here, populate it with that information
192 (child nodes, properties, etc.) and then call
193 ::set_state() on the writer/reader.
195 But at present (June 2017), there's no such state.
200 std::string playlist_id;
202 if (node.get_property (X_("audio-playlist"), playlist_id)) {
203 find_and_use_playlist (DataType::AUDIO, PBD::ID (playlist_id));
206 if (node.get_property (X_("midi-playlist"), playlist_id)) {
207 find_and_use_playlist (DataType::MIDI, PBD::ID (playlist_id));
210 XMLNodeList nlist = node.children();
211 for (XMLNodeConstIterator niter = nlist.begin(); niter != nlist.end(); ++niter) {
214 if (child->name() == Controllable::xml_node_name) {
216 if (!child->get_property ("name", name)) {
220 if (name == _record_enable_control->name()) {
221 _record_enable_control->set_state (*child, version);
222 } else if (name == _record_safe_control->name()) {
223 _record_safe_control->set_state (*child, version);
224 } else if (name == _monitoring_control->name()) {
225 _monitoring_control->set_state (*child, version);
230 if (!node.get_property (X_("saved-meter-point"), _saved_meter_point)) {
231 _saved_meter_point = _meter_point;
234 if (!node.get_property (X_("saved-meter-point"), _disk_io_point)) {
235 _disk_io_point = DiskIOPreFader;
240 if (node.get_property (X_("alignment-choice"), ac)) {
241 set_align_choice (ac, true);
248 Track::get_template ()
250 return state (false);
253 Track::FreezeRecord::~FreezeRecord ()
255 for (vector<FreezeRecordProcessorInfo*>::iterator i = processor_info.begin(); i != processor_info.end(); ++i) {
261 Track::freeze_state() const
263 return _freeze_record.state;
269 bool will_record = true;
270 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end() && will_record; ++i) {
279 Track::prep_record_enabled (bool yn)
281 if (yn && _record_safe_control->get_value()) {
285 if (!can_be_record_enabled()) {
289 /* keep track of the meter point as it was before we rec-enabled */
290 if (!_disk_writer->record_enabled()) {
291 _saved_meter_point = _meter_point;
297 will_follow = _disk_writer->prep_record_enable ();
299 will_follow = _disk_writer->prep_record_disable ();
304 if (_meter_point != MeterCustom) {
305 set_meter_point (MeterInput);
308 set_meter_point (_saved_meter_point);
316 Track::record_enable_changed (bool, Controllable::GroupControlDisposition)
318 _disk_writer->set_record_enabled (_record_enable_control->get_value());
322 Track::record_safe_changed (bool, Controllable::GroupControlDisposition)
324 _disk_writer->set_record_safe (_record_safe_control->get_value());
328 Track::can_be_record_safe ()
330 return !_record_enable_control->get_value() && _disk_writer && _session.writable() && (_freeze_record.state != Frozen);
334 Track::can_be_record_enabled ()
336 return !_record_safe_control->get_value() && _disk_writer && !_disk_writer->record_safe() && _session.writable() && (_freeze_record.state != Frozen);
340 Track::parameter_changed (string const & p)
342 if (p == "track-name-number") {
343 resync_track_name ();
345 else if (p == "track-name-take") {
346 resync_track_name ();
348 else if (p == "take-name") {
349 if (_session.config.get_track_name_take()) {
350 resync_track_name ();
356 Track::resync_track_name ()
362 Track::set_name (const string& str)
370 if (_record_enable_control->get_value()) {
371 /* when re-arm'ed the file (named after the track) is already ready to rolll */
375 string diskstream_name = "";
376 if (_session.config.get_track_name_take () && !_session.config.get_take_name ().empty()) {
377 // Note: any text is fine, legalize_for_path() fixes this later
378 diskstream_name += _session.config.get_take_name ();
379 diskstream_name += "_";
381 const int64_t tracknumber = track_number();
382 if (tracknumber > 0 && _session.config.get_track_name_number()) {
383 char num[64], fmt[10];
384 snprintf(fmt, sizeof(fmt), "%%0%d" PRId64, _session.track_number_decimals());
385 snprintf(num, sizeof(num), fmt, tracknumber);
386 diskstream_name += num;
387 diskstream_name += "_";
389 diskstream_name += str;
391 if (diskstream_name == _diskstream_name) {
394 _diskstream_name = diskstream_name;
396 _disk_writer->set_write_source_name (diskstream_name);
398 boost::shared_ptr<Track> me = boost::dynamic_pointer_cast<Track> (shared_from_this ());
400 if (_playlists[data_type()]->all_regions_empty () && _session.playlists->playlists_for_track (me).size() == 1) {
401 /* Only rename the diskstream (and therefore the playlist) if
402 a) the playlist has never had a region added to it and
403 b) there is only one playlist for this track.
405 If (a) is not followed, people can get confused if, say,
406 they have notes about a playlist with a given name and then
407 it changes (see mantis #4759).
409 If (b) is not followed, we rename the current playlist and not
410 the other ones, which is a bit confusing (see mantis #4977).
412 _disk_reader->set_name (str);
413 _disk_writer->set_name (str);
416 for (uint32_t n = 0; n < DataType::num_types; ++n) {
418 _playlists[n]->set_name (str);
422 /* save state so that the statefile fully reflects any filename changes */
424 if ((ret = Route::set_name (str)) == 0) {
425 _session.save_state ("");
432 Track::set_latency_compensation (framecnt_t longest_session_latency)
434 Route::set_latency_compensation (longest_session_latency);
435 _disk_reader->set_roll_delay (_roll_delay);
439 Track::no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, bool session_state_changing)
441 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
447 bool can_record = _session.actively_recording ();
449 /* no outputs? nothing to do ... what happens if we have sends etc. ? */
451 if (n_outputs().n_total() == 0 && !ARDOUR::Profile->get_mixbus()) {
452 //Note: Mixbus has its own output mechanism, so we should operate even if no explicit outputs are assigned
456 /* not active ... do the minimum possible by just outputting silence */
460 if (_meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled())) {
466 if (session_state_changing) {
467 if (_session.transport_speed() != 0.0f) {
468 /* we're rolling but some state is changing (e.g. our
469 disk reader contents) so we cannot use them. Be
470 silent till this is over. Don't declick.
472 XXX note the absurdity of ::no_roll() being called when we ARE rolling!
474 passthru_silence (start_frame, end_frame, nframes, 0);
477 /* we're really not rolling, so we're either delivery silence or actually
478 monitoring, both of which are safe to do while session_state_changing is true.
482 _disk_writer->check_record_status (start_frame, can_record);
486 MonitorState const s = monitoring_state ();
487 /* we are not rolling, so be silent even if we are monitoring disk, as there
488 will be no disk data coming in.
491 case MonitoringSilence:
497 case MonitoringInput:
505 //if we have an internal generator, let it play regardless of monitoring state
506 if (_have_internal_generator) {
510 _amp->apply_gain_automation (false);
512 /* if have_internal_generator, or .. */
516 if (_meter_point == MeterInput) {
517 /* still need input monitoring and metering */
519 bool const track_rec = _disk_writer->record_enabled ();
520 bool const auto_input = _session.config.get_auto_input ();
521 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
522 bool const tape_machine_mode = Config->get_tape_machine_mode ();
523 bool no_meter = false;
525 /* this needs a proper K-map
526 * and should be separated into a function similar to monitoring_state()
527 * that also handles roll() states in audio_track.cc, midi_track.cc and route.cc
529 * see http://www.oofus.co.uk/ardour/Ardour3MonitorModesV3.pdf
531 if (!auto_input && !track_rec) {
534 else if (tape_machine_mode && !track_rec && auto_input) {
537 else if (!software_monitor && tape_machine_mode && !track_rec) {
540 else if (!software_monitor && !tape_machine_mode && !track_rec && !auto_input) {
545 BufferSet& bufs (_session.get_silent_buffers (n_process_buffers()));
546 _meter->run (bufs, start_frame, end_frame, 1.0, nframes, true);
547 _input->process_input (boost::shared_ptr<Processor>(), start_frame, end_frame, _session.transport_speed(), nframes);
549 _input->process_input (_meter, start_frame, end_frame, _session.transport_speed(), nframes);
553 passthru_silence (start_frame, end_frame, nframes, 0);
557 BufferSet& bufs = _session.get_route_buffers (n_process_buffers());
559 fill_buffers_with_input (bufs, _input, nframes);
561 if (_meter_point == MeterInput) {
562 _meter->run (bufs, start_frame, end_frame, _session.transport_speed(), nframes, true);
565 passthru (bufs, start_frame, end_frame, nframes, false);
568 flush_processor_buffers_locked (nframes);
574 Track::silent_roll (pframes_t nframes, framepos_t /*start_frame*/, framepos_t /*end_frame*/, bool& need_butler)
576 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
578 // XXX DISK reader needs to seek ahead the correct distance ?? OR DOES IT ?
579 //framecnt_t playback_distance = _disk_reader->calculate_playback_distance(nframes);
580 //if (can_internal_playback_seek(playback_distance)) {
581 // internal_playback_seek(playback_distance);
586 if (n_outputs().n_total() == 0 && _processors.empty()) {
596 _amp->apply_gain_automation(false);
599 flush_processor_buffers_locked (nframes);
601 //BufferSet& bufs (_session.get_route_buffers (n_process_buffers(), true));
602 // XXXX DISKWRITER/READER ADVANCE, SET need_butler
606 boost::shared_ptr<Playlist>
609 return _playlists[data_type()];
613 Track::request_input_monitoring (bool m)
615 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
616 AudioEngine::instance()->request_input_monitoring ((*i)->name(), m);
621 Track::ensure_input_monitoring (bool m)
623 for (PortSet::iterator i = _input->ports().begin(); i != _input->ports().end(); ++i) {
624 AudioEngine::instance()->ensure_input_monitoring ((*i)->name(), m);
629 Track::destructive () const
631 return _disk_writer->destructive ();
634 list<boost::shared_ptr<Source> > &
635 Track::last_capture_sources ()
637 return _disk_writer->last_capture_sources ();
641 Track::update_latency_information ()
643 Glib::Threads::RWLock::ReaderLock lr (_processor_lock);
644 framecnt_t chain_latency = _input->latency ();
646 for (ProcessorList::iterator p = _processors.begin(); p != _processors.end(); ++p) {
647 (*p)->set_input_latency (chain_latency);
648 chain_latency += (*p)->signal_latency ();
653 Track::steal_write_source_name()
655 return _disk_writer->steal_write_source_name ();
659 Track::reset_write_sources (bool r, bool force)
661 _disk_writer->reset_write_sources (r, force);
665 Track::playback_buffer_load () const
667 return _disk_reader->buffer_load ();
671 Track::capture_buffer_load () const
673 return _disk_writer->buffer_load ();
679 return _disk_reader->do_refill ();
683 Track::do_flush (RunContext c, bool force)
685 return _disk_writer->do_flush (c, force);
689 Track::set_pending_overwrite (bool o)
691 _disk_reader->set_pending_overwrite (o);
695 Track::seek (framepos_t p, bool complete_refill)
697 if (_disk_reader->seek (p, complete_refill)) {
700 return _disk_writer->seek (p, complete_refill);
704 Track::hidden () const
706 return _disk_writer->hidden () || _disk_reader->hidden();
710 Track::can_internal_playback_seek (framecnt_t p)
712 return _disk_reader->can_internal_playback_seek (p);
716 Track::internal_playback_seek (framecnt_t p)
718 return _disk_reader->internal_playback_seek (p);
722 Track::non_realtime_locate (framepos_t p)
724 Route::non_realtime_locate (p);
727 /* don't waste i/o cycles and butler calls
728 for hidden (secret) tracks
730 _disk_reader->non_realtime_locate (p);
731 _disk_writer->non_realtime_locate (p);
736 Track::non_realtime_speed_change ()
738 _disk_reader->non_realtime_speed_change ();
742 Track::overwrite_existing_buffers ()
744 return _disk_reader->overwrite_existing_buffers ();
748 Track::get_captured_frames (uint32_t n) const
750 return _disk_writer->get_captured_frames (n);
754 Track::set_loop (Location* l)
756 if (_disk_reader->set_loop (l)) {
759 return _disk_writer->set_loop (l);
763 Track::transport_looped (framepos_t p)
765 return _disk_writer->transport_looped (p);
769 Track::realtime_speed_change ()
771 if (_disk_reader->realtime_speed_change ()) {
774 return _disk_writer->realtime_speed_change ();
778 Track::realtime_handle_transport_stopped ()
780 Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
786 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
787 (*i)->realtime_handle_transport_stopped ();
792 Track::transport_stopped_wallclock (struct tm & n, time_t t, bool g)
794 _disk_writer->transport_stopped_wallclock (n, t, g);
798 Track::pending_overwrite () const
800 return _disk_reader->pending_overwrite ();
804 Track::prepare_to_stop (framepos_t t, framepos_t a)
806 _disk_writer->prepare_to_stop (t, a);
810 Track::set_slaved (bool s)
812 _disk_reader->set_slaved (s);
813 _disk_writer->set_slaved (s);
819 return _disk_reader->output_streams();
823 Track::get_capture_start_frame (uint32_t n) const
825 return _disk_writer->get_capture_start_frame (n);
829 Track::alignment_style () const
831 return _disk_writer->alignment_style ();
835 Track::alignment_choice () const
837 return _disk_writer->alignment_choice ();
841 Track::current_capture_start () const
843 return _disk_writer->current_capture_start ();
847 Track::current_capture_end () const
849 return _disk_writer->current_capture_end ();
853 Track::playlist_modified ()
855 _disk_reader->playlist_modified ();
859 Track::find_and_use_playlist (DataType dt, PBD::ID const & id)
861 boost::shared_ptr<Playlist> playlist;
863 if ((playlist = _session.playlists->by_id (id)) == 0) {
868 error << string_compose(_("DiskIOProcessor: \"%1\" isn't an playlist"), id.to_s()) << endmsg;
872 return use_playlist (dt, playlist);
876 Track::use_playlist (DataType dt, boost::shared_ptr<Playlist> p)
880 if ((ret = _disk_reader->use_playlist (dt, p)) == 0) {
881 if ((ret = _disk_writer->use_playlist (dt, p)) == 0) {
882 p->set_orig_track_id (id());
894 Track::use_copy_playlist ()
896 assert (_playlists[data_type()]);
898 if (_playlists[data_type()] == 0) {
899 error << string_compose(_("DiskIOProcessor %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
904 boost::shared_ptr<Playlist> playlist;
906 newname = Playlist::bump_name (_playlists[data_type()]->name(), _session);
908 if ((playlist = PlaylistFactory::create (_playlists[data_type()], newname)) == 0) {
912 playlist->reset_shares();
914 return use_playlist (data_type(), playlist);
918 Track::use_new_playlist ()
921 boost::shared_ptr<Playlist> playlist = _playlists[data_type()];
924 newname = Playlist::bump_name (playlist->name(), _session);
926 newname = Playlist::bump_name (_name, _session);
929 playlist = PlaylistFactory::create (data_type(), _session, newname, hidden());
935 return use_playlist (data_type(), playlist);
939 Track::set_align_choice (AlignChoice ac, bool force)
943 _alignment_choice = Automatic;
944 set_align_choice_from_io ();
950 _disk_writer->set_align_choice (ac, force);
951 _alignment_choice = ac;
955 Track::set_align_style (AlignStyle s, bool force)
957 _disk_writer->set_align_style (s, force);
961 Track::set_align_choice_from_io ()
963 bool have_physical = false;
967 vector<string> connections;
968 boost::shared_ptr<Port> p;
972 p = _input->nth (n++);
978 if (p->get_connections (connections) != 0) {
979 if (AudioEngine::instance()->port_is_physical (connections[0])) {
980 have_physical = true;
985 connections.clear ();
990 // compensate for latency when bouncing from master or mixbus.
991 // we need to use "ExistingMaterial" to pick up the master bus' latency
992 // see also Route::direct_feeds_according_to_reality
994 ios.push_back (_input);
995 if (_session.master_out() && ios.fed_by (_session.master_out()->output())) {
996 have_physical = true;
998 for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) {
999 if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) {
1000 have_physical = true;
1005 if (have_physical) {
1006 _disk_writer->set_align_style (ExistingMaterial);
1008 _disk_writer->set_align_style (CaptureTime);
1013 Track::set_block_size (pframes_t n)
1015 Route::set_block_size (n);
1016 _disk_reader->set_block_size (n);
1017 _disk_writer->set_block_size (n);
1021 Track::adjust_playback_buffering ()
1024 _disk_reader->adjust_buffering ();
1029 Track::adjust_capture_buffering ()
1032 _disk_writer->adjust_buffering ();
1036 #ifdef USE_TRACKS_CODE_FEATURES
1038 /* This is the Tracks version of Track::monitoring_state().
1040 * Ardour developers: try to flag or fix issues if parts of the libardour API
1041 * change in ways that invalidate this
1045 Track::monitoring_state () const
1047 /* Explicit requests */
1049 if (_monitoring != MonitorInput) {
1050 return MonitoringInput;
1053 if (_monitoring & MonitorDisk) {
1054 return MonitoringDisk;
1057 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
1058 I don't think it's ever going to be too pretty too look at.
1061 // GZ: NOT USED IN TRACKS
1062 //bool const auto_input = _session.config.get_auto_input ();
1063 //bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
1064 //bool const tape_machine_mode = Config->get_tape_machine_mode ();
1066 bool const roll = _session.transport_rolling ();
1067 bool const track_rec = _diskstream->record_enabled ();
1068 bool session_rec = _session.actively_recording ();
1072 if (!session_rec && roll) {
1073 return MonitoringDisk;
1075 return MonitoringInput;
1081 return MonitoringDisk;
1085 return MonitoringSilence;
1090 /* This is the Ardour/Mixbus version of Track::monitoring_state().
1092 * Tracks developers: do NOT modify this method under any circumstances.
1096 Track::monitoring_state () const
1098 /* Explicit requests */
1099 MonitorChoice m (_monitoring_control->monitoring_choice());
1101 if (m != MonitorAuto) {
1103 MonitorState ms ((MonitorState) 0);
1105 if (m & MonitorInput) {
1106 ms = MonitoringInput;
1109 if (m & MonitorDisk) {
1110 ms = MonitorState (ms | MonitoringDisk);
1116 switch (_session.config.get_session_monitoring ()) {
1118 return MonitoringDisk;
1121 return MonitoringInput;
1127 /* This is an implementation of the truth table in doc/monitor_modes.pdf;
1128 I don't think it's ever going to be too pretty too look at.
1131 bool const roll = _session.transport_rolling ();
1132 bool const track_rec = _disk_writer->record_enabled ();
1133 bool const auto_input = _session.config.get_auto_input ();
1134 bool const software_monitor = Config->get_monitoring_model() == SoftwareMonitoring;
1135 bool const tape_machine_mode = Config->get_tape_machine_mode ();
1138 /* I suspect that just use actively_recording() is good enough all the
1139 * time, but just to keep the semantics the same as they were before
1140 * sept 26th 2012, we differentiate between the cases where punch is
1141 * enabled and those where it is not.
1143 * rg: I suspect this is not the case: monitoring may differ
1146 if (_session.config.get_punch_in() || _session.config.get_punch_out() || _session.preroll_record_punch_enabled ()) {
1147 session_rec = _session.actively_recording ();
1149 session_rec = _session.get_record_enabled();
1154 if (!session_rec && roll && auto_input) {
1155 return MonitoringDisk;
1157 return software_monitor ? MonitoringInput : MonitoringSilence;
1162 if (tape_machine_mode) {
1164 return MonitoringDisk;
1168 if (!roll && auto_input) {
1169 return software_monitor ? MonitoringInput : MonitoringSilence;
1171 return MonitoringDisk;
1177 abort(); /* NOTREACHED */
1178 return MonitoringSilence;
1184 Track::maybe_declick (BufferSet& bufs, framecnt_t nframes, int declick)
1186 /* never declick if there is an internal generator - we just want it to
1187 keep generating sound without interruption.
1189 ditto if we are monitoring inputs.
1192 if (_have_internal_generator || (_monitoring_control->monitoring_choice() == MonitorInput)) {
1197 declick = _pending_declick;
1201 Amp::declick (bufs, nframes, declick);
1206 Track::check_initial_delay (framecnt_t nframes, framepos_t& transport_frame)
1208 if (_roll_delay > nframes) {
1210 _roll_delay -= nframes;
1211 silence_unlocked (nframes);
1212 /* transport frame is not legal for caller to use */
1215 } else if (_roll_delay > 0) {
1217 nframes -= _roll_delay;
1218 silence_unlocked (_roll_delay);
1219 transport_frame += _roll_delay;
1221 /* shuffle all the port buffers for things that lead "out" of this Route
1222 to reflect that we just wrote _roll_delay frames of silence.
1225 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
1226 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1227 boost::shared_ptr<IOProcessor> iop = boost::dynamic_pointer_cast<IOProcessor> (*i);
1229 iop->increment_port_buffer_offset (_roll_delay);
1232 _output->increment_port_buffer_offset (_roll_delay);
1242 Track::monitoring_changed (bool, Controllable::GroupControlDisposition)
1244 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
1245 (*i)->monitoring_changed ();
1250 Track::metering_state () const
1253 if (_session.transport_rolling ()) {
1254 // audio_track.cc || midi_track.cc roll() runs meter IFF:
1255 rv = _meter_point == MeterInput && ((_monitoring_control->monitoring_choice() & MonitorInput) || _disk_writer->record_enabled());
1257 // track no_roll() always metering if
1258 rv = _meter_point == MeterInput;
1260 return rv ? MeteringInput : MeteringRoute;
1264 Track::set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure)
1266 if (Route::set_processor_state (node, prop, new_order, must_configure)) {
1270 if (prop->value() == "diskreader") {
1272 _disk_reader->set_state (node, Stateful::current_state_version);
1273 new_order.push_back (_disk_reader);
1276 } else if (prop->value() == "diskwriter") {
1278 _disk_writer->set_state (node, Stateful::current_state_version);
1279 new_order.push_back (_disk_writer);
1284 error << string_compose(_("unknown Processor type \"%1\"; ignored"), prop->value()) << endmsg;
1289 Track::use_captured_sources (SourceList& srcs, CaptureInfos const & capture_info)
1295 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (srcs.front());
1296 boost::shared_ptr<SMFSource> mfs = boost::dynamic_pointer_cast<SMFSource> (srcs.front());
1299 use_captured_audio_sources (srcs, capture_info);
1303 use_captured_midi_sources (srcs, capture_info);
1308 Track::use_captured_midi_sources (SourceList& srcs, CaptureInfos const & capture_info)
1310 if (srcs.empty() || data_type() != DataType::MIDI) {
1314 boost::shared_ptr<SMFSource> mfs = boost::dynamic_pointer_cast<SMFSource> (srcs.front());
1315 boost::shared_ptr<Playlist> pl = _playlists[DataType::MIDI];
1316 boost::shared_ptr<MidiRegion> midi_region;
1317 CaptureInfos::const_iterator ci;
1323 framecnt_t total_capture = 0;
1325 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1326 total_capture += (*ci)->frames;
1329 /* we will want to be able to keep (over)writing the source
1330 but we don't want it to be removable. this also differs
1331 from the audio situation, where the source at this point
1332 must be considered immutable. luckily, we can rely on
1333 MidiSource::mark_streaming_write_completed() to have
1334 already done the necessary work for that.
1337 string whole_file_region_name;
1338 whole_file_region_name = region_name_from_path (mfs->name(), true);
1340 /* Register a new region with the Session that
1341 describes the entire source. Do this first
1342 so that any sub-regions will obviously be
1343 children of this one (later!)
1349 plist.add (Properties::name, whole_file_region_name);
1350 plist.add (Properties::whole_file, true);
1351 plist.add (Properties::automatic, true);
1352 plist.add (Properties::start, 0);
1353 plist.add (Properties::length, total_capture);
1354 plist.add (Properties::layer, 0);
1356 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1358 midi_region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1359 midi_region->special_set_position (capture_info.front()->start);
1362 catch (failed_constructor& err) {
1363 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1367 pl->clear_changes ();
1370 /* Session frame time of the initial capture in this pass, which is where the source starts */
1371 framepos_t initial_capture = 0;
1372 if (!capture_info.empty()) {
1373 initial_capture = capture_info.front()->start;
1376 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
1377 const framepos_t preroll_off = _session.preroll_record_trim_len ();
1379 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1383 RegionFactory::region_name (region_name, mfs->name(), false);
1385 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1386 _name, (*ci)->start, (*ci)->frames, region_name));
1389 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1394 /* start of this region is the offset between the start of its capture and the start of the whole pass */
1395 plist.add (Properties::start, (*ci)->start - initial_capture);
1396 plist.add (Properties::length, (*ci)->frames);
1397 plist.add (Properties::length_beats, converter.from((*ci)->frames).to_double());
1398 plist.add (Properties::name, region_name);
1400 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1401 midi_region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1402 if (preroll_off > 0) {
1403 midi_region->trim_front ((*ci)->start - initial_capture + preroll_off);
1407 catch (failed_constructor& err) {
1408 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1409 continue; /* XXX is this OK? */
1412 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1414 pl->add_region (midi_region, (*ci)->start + preroll_off);
1418 _session.add_command (new StatefulDiffCommand (pl));
1422 Track::use_captured_audio_sources (SourceList& srcs, CaptureInfos const & capture_info)
1424 if (srcs.empty() || data_type() != DataType::AUDIO) {
1428 boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource> (srcs.front());
1429 boost::shared_ptr<Playlist> pl = _playlists[DataType::AUDIO];
1430 boost::shared_ptr<AudioRegion> region;
1436 /* destructive tracks have a single, never changing region */
1438 if (destructive()) {
1440 /* send a signal that any UI can pick up to do the right thing. there is
1441 a small problem here in that a UI may need the peak data to be ready
1442 for the data that was recorded and this isn't interlocked with that
1443 process. this problem is deferred to the UI.
1446 pl->LayeringChanged(); // XXX this may not get the UI to do the right thing
1450 string whole_file_region_name;
1451 whole_file_region_name = region_name_from_path (afs->name(), true);
1453 /* Register a new region with the Session that
1454 describes the entire source. Do this first
1455 so that any sub-regions will obviously be
1456 children of this one (later!)
1462 plist.add (Properties::start, afs->last_capture_start_frame());
1463 plist.add (Properties::length, afs->length(0));
1464 plist.add (Properties::name, whole_file_region_name);
1465 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1466 rx->set_automatic (true);
1467 rx->set_whole_file (true);
1469 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1470 region->special_set_position (afs->natural_position());
1474 catch (failed_constructor& err) {
1475 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1479 pl->clear_changes ();
1480 pl->set_capture_insertion_in_progress (true);
1483 const framepos_t preroll_off = _session.preroll_record_trim_len ();
1484 framecnt_t buffer_position = afs->last_capture_start_frame ();
1485 CaptureInfos::const_iterator ci;
1487 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1491 RegionFactory::region_name (region_name, whole_file_region_name, false);
1493 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n",
1494 _name, (*ci)->start, (*ci)->frames, region_name, buffer_position));
1500 plist.add (Properties::start, buffer_position);
1501 plist.add (Properties::length, (*ci)->frames);
1502 plist.add (Properties::name, region_name);
1504 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1505 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1506 if (preroll_off > 0) {
1507 region->trim_front (buffer_position + preroll_off);
1511 catch (failed_constructor& err) {
1512 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1513 continue; /* XXX is this OK? */
1516 pl->add_region (region, (*ci)->start + preroll_off, 1, _disk_writer->non_layered());
1517 pl->set_layer (region, DBL_MAX);
1519 buffer_position += (*ci)->frames;
1523 pl->set_capture_insertion_in_progress (false);
1524 _session.add_command (new StatefulDiffCommand (pl));
1528 __attribute__((annotate("realtime")))
1531 Track::setup_invisible_processors_oh_children_of_mine (ProcessorList& processors)
1533 ProcessorList::iterator insert_pos;
1535 switch (_disk_io_point) {
1536 case DiskIOPreFader:
1537 insert_pos = find (processors.begin(), processors.end(), _trim);
1538 if (insert_pos != processors.end()) {
1539 insert_pos = processors.insert (insert_pos, _disk_writer);
1540 processors.insert (insert_pos, _disk_reader);
1543 case DiskIOPostFader:
1544 insert_pos = find (processors.begin(), processors.end(), _main_outs);
1545 if (insert_pos != processors.end()) {
1546 insert_pos = processors.insert (insert_pos, _disk_writer);
1547 processors.insert (insert_pos, _disk_reader);
1555 Track::set_disk_io_position (DiskIOPoint diop)
1557 bool display = false;
1567 _disk_writer->set_display_to_user (display);
1568 _disk_reader->set_display_to_user (display);
1570 const bool changed = (diop != _disk_io_point);
1572 _disk_io_point = diop;
1575 Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
1576 configure_processors (0);