X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_track.cc;h=46aff98122db5735884493edde4a04867d6ef885;hb=3c7dea43af9d9e5b2563aee81ac5253fb2ee7858;hp=a82c109cbaa1ad216ed89d117a6561232e980d84;hpb=15cee60021eada542b2dae0fafbb3150fcaa5010;p=ardour.git diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc index a82c109cba..46aff98122 100644 --- a/libs/ardour/audio_track.cc +++ b/libs/ardour/audio_track.cc @@ -19,7 +19,6 @@ #include -#include "pbd/boost_debug.h" #include "pbd/enumwriter.h" #include "pbd/error.h" @@ -27,180 +26,128 @@ #include "ardour/amp.h" #include "ardour/audio_buffer.h" -#include "ardour/audio_diskstream.h" #include "ardour/audio_track.h" #include "ardour/audioplaylist.h" +#include "ardour/boost_debug.h" #include "ardour/buffer_set.h" #include "ardour/delivery.h" +#include "ardour/disk_reader.h" +#include "ardour/disk_writer.h" #include "ardour/meter.h" +#include "ardour/monitor_control.h" #include "ardour/playlist_factory.h" #include "ardour/processor.h" +#include "ardour/profile.h" #include "ardour/region.h" #include "ardour/region_factory.h" #include "ardour/session.h" #include "ardour/session_playlists.h" #include "ardour/source.h" +#include "ardour/types_convert.h" #include "ardour/utils.h" -#include "i18n.h" +#include "pbd/i18n.h" using namespace std; using namespace ARDOUR; using namespace PBD; -AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode) - : Track (sess, name, flag, mode) +AudioTrack::AudioTrack (Session& sess, string name, TrackMode mode) + : Track (sess, name, PresentationInfo::AudioTrack, mode) { } AudioTrack::~AudioTrack () { + if (_freeze_record.playlist && !_session.deletion_in_progress()) { + _freeze_record.playlist->release(); + } } -boost::shared_ptr -AudioTrack::create_diskstream () +MonitorState +AudioTrack::get_auto_monitoring_state () const { - AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0); + /* 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. + */ - if (_flags & Auditioner) { - dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden); + 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: sept 30 2017: Above is not the case: punch-in/out location is + * global session playhead position. + * When this method is called from process_output_buffers() we need + * to use delay-compensated route's process-position. + * + * NB. Disk reader/writer may also be offset by a same amount of time. + * + * Also keep in mind that _session.transport_rolling() is false during + * pre-roll but the disk already produces output. + * + * TODO: FIXME + */ + + if (_session.config.get_punch_in() || _session.config.get_punch_out()) { + session_rec = _session.actively_recording (); } else { - dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable); - } - - if (_mode == Destructive) { - dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive); - } else if (_mode == NonLayered){ - dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered); + session_rec = _session.get_record_enabled(); } - return boost::shared_ptr (new AudioDiskstream (_session, name(), dflags)); -} - -void -AudioTrack::set_diskstream (boost::shared_ptr ds) -{ - Track::set_diskstream (ds); + if (track_rec) { - _diskstream->set_track (this); - _diskstream->set_destructive (_mode == Destructive); - _diskstream->set_non_layered (_mode == NonLayered); - - if (audio_diskstream()->deprecated_io_node) { - - if (!IO::connecting_legal) { - IO::ConnectingLegal.connect_same_thread (*this, boost::bind (&AudioTrack::deprecated_use_diskstream_connections, this)); + if (!session_rec && roll && auto_input) { + return MonitoringDisk; } else { - deprecated_use_diskstream_connections (); + return software_monitor ? MonitoringInput : MonitoringSilence; } - } - - _diskstream->set_record_enabled (false); - _diskstream->request_input_monitoring (false); - - DiskstreamChanged (); /* EMIT SIGNAL */ -} - -boost::shared_ptr -AudioTrack::audio_diskstream() const -{ - return boost::dynamic_pointer_cast(_diskstream); -} - -int -AudioTrack::set_mode (TrackMode m) -{ - if (m != _mode) { - - if (_diskstream->set_destructive (m == Destructive)) { - return -1; - } - - _diskstream->set_non_layered (m == NonLayered); - _mode = m; - - TrackModeChanged (); /* EMIT SIGNAL */ - } - - return 0; -} - -bool -AudioTrack::can_use_mode (TrackMode m, bool& bounce_required) -{ - switch (m) { - case NonLayered: - case Normal: - bounce_required = false; - return true; - - case Destructive: - default: - return _diskstream->can_become_destructive (bounce_required); - } -} -int -AudioTrack::deprecated_use_diskstream_connections () -{ - boost::shared_ptr diskstream = audio_diskstream(); - - if (diskstream->deprecated_io_node == 0) { - return 0; - } - - const XMLProperty* prop; - XMLNode& node (*diskstream->deprecated_io_node); - - /* don't do this more than once. */ - - diskstream->deprecated_io_node = 0; + } else { - if ((prop = node.property ("gain")) != 0) { - _amp->set_gain (atof (prop->value().c_str()), this); - } + if (tape_machine_mode) { - if ((prop = node.property ("input-connection")) != 0) { - boost::shared_ptr c = _session.bundle_by_name (prop->value()); + return MonitoringDisk; - if (c == 0) { - error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), prop->value(), _name) << endmsg; + } else { - if ((c = _session.bundle_by_name (_("in 1"))) == 0) { - error << _("No input bundles available as a replacement") - << endmsg; - return -1; + if (!roll && auto_input) { + return software_monitor ? MonitoringInput : MonitoringSilence; } else { - info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), prop->value()) - << endmsg; + return MonitoringDisk; } - } - - _input->connect_ports_to_bundle (c, true, this); - } else if ((prop = node.property ("inputs")) != 0) { - if (_input->set_ports (prop->value())) { - error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg; - return -1; } } - return 0; + abort(); /* NOTREACHED */ + return MonitoringSilence; } int AudioTrack::set_state (const XMLNode& node, int version) { - const XMLProperty *prop; + if (!node.get_property (X_("mode"), _mode)) { + _mode = Normal; + } - if (Track::set_state (node, version)) { + if (Profile->get_trx() && _mode == Destructive) { + /* Tracks does not support destructive tracks and trying to + handle it as a normal track would be wrong. + */ + error << string_compose (_("%1: this session uses destructive tracks, which are not supported"), PROGRAM_NAME) << endmsg; return -1; } - if ((prop = node.property (X_("mode"))) != 0) { - _mode = TrackMode (string_2_enum (prop->value(), _mode)); - } else { - _mode = Normal; + if (Track::set_state (node, version)) { + return -1; } pending_state = const_cast (&node); @@ -215,23 +162,21 @@ AudioTrack::set_state (const XMLNode& node, int version) } XMLNode& -AudioTrack::state (bool full_state) +AudioTrack::state (bool save_template) { - XMLNode& root (Track::state(full_state)); + XMLNode& root (Track::state (save_template)); XMLNode* freeze_node; - char buf[64]; if (_freeze_record.playlist) { XMLNode* inode; freeze_node = new XMLNode (X_("freeze-info")); - freeze_node->add_property ("playlist", _freeze_record.playlist->name()); - freeze_node->add_property ("state", enum_2_string (_freeze_record.state)); + freeze_node->set_property ("playlist", _freeze_record.playlist->name()); + freeze_node->set_property ("state", _freeze_record.state); for (vector::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) { inode = new XMLNode (X_("processor")); - (*i)->id.print (buf, sizeof (buf)); - inode->add_property (X_("id"), buf); + inode->set_property (X_ ("id"), (*i)->id.to_s ()); inode->add_child_copy ((*i)->state); freeze_node->add_child_nocopy (*inode); @@ -240,7 +185,7 @@ AudioTrack::state (bool full_state) root.add_child_nocopy (*freeze_node); } - root.add_property (X_("mode"), enum_2_string (_mode)); + root.set_property (X_("mode"), _mode); return root; } @@ -249,8 +194,7 @@ void AudioTrack::set_state_part_two () { XMLNode* fnode; - XMLProperty* prop; - LocaleGuard lg (X_("POSIX")); + XMLProperty const * prop; /* This is called after all session state has been restored but before have been made ports and connections are established. @@ -273,6 +217,7 @@ AudioTrack::set_state_part_two () boost::shared_ptr pl = _session.playlists->by_name (prop->value()); if (pl) { _freeze_record.playlist = boost::dynamic_pointer_cast (pl); + _freeze_record.playlist->use(); } else { _freeze_record.playlist.reset (); _freeze_record.state = NoFreeze; @@ -280,9 +225,7 @@ AudioTrack::set_state_part_two () } } - if ((prop = fnode->property (X_("state"))) != 0) { - _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state)); - } + fnode->get_property (X_("state"), _freeze_record.state); XMLNodeConstIterator citer; XMLNodeList clist = fnode->children(); @@ -304,97 +247,20 @@ AudioTrack::set_state_part_two () } } -/** @param need_butler to be set to true if this track now needs the butler, otherwise it can be left alone - * or set to false. - */ int -AudioTrack::roll (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()) { - boost::shared_ptr diskstream = audio_diskstream(); - framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes); - if (can_internal_playback_seek(llabs(playback_distance))) { - /* TODO should declick */ - internal_playback_seek(playback_distance); - } - return 0; - } - - framepos_t transport_frame; - boost::shared_ptr diskstream = audio_diskstream(); - - if (n_outputs().n_total() == 0 && _processors.empty()) { - return 0; - } - - if (!_active) { - silence (nframes); - if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) { - _meter->reset(); - } - return 0; - } - - transport_frame = _session.transport_frame(); - - int dret; - framecnt_t playback_distance; - - if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) { - - /* need to do this so that the diskstream sets its - playback distance to zero, thus causing diskstream::commit - to do nothing. - */ - - BufferSet bufs; /* empty set, no matter - nothing will happen */ - - dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false); - need_butler = diskstream->commit (playback_distance); - return dret; - } - - _silent = false; - _amp->apply_gain_automation(false); - - BufferSet& bufs = _session.get_route_buffers (n_process_buffers ()); - - fill_buffers_with_input (bufs, _input, nframes); - - if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) { - _meter->run (bufs, start_frame, end_frame, nframes, true); - } - - 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; -} - -int -AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, - boost::shared_ptr endpoint, bool include_endpoint, bool for_export) +AudioTrack::export_stuff (BufferSet& buffers, samplepos_t start, samplecnt_t nframes, + boost::shared_ptr endpoint, bool include_endpoint, bool for_export, bool for_freeze) { boost::scoped_array gain_buffer (new gain_t[nframes]); boost::scoped_array mix_buffer (new Sample[nframes]); - boost::shared_ptr diskstream = audio_diskstream(); Glib::Threads::RWLock::ReaderLock rlock (_processor_lock); - boost::shared_ptr apl = boost::dynamic_pointer_cast(diskstream->playlist()); + boost::shared_ptr apl = boost::dynamic_pointer_cast(playlist()); assert(apl); assert(buffers.count().n_audio() >= 1); - assert ((framecnt_t) buffers.get_audio(0).capacity() >= nframes); + assert ((samplecnt_t) buffers.get_audio(0).capacity() >= nframes); if (apl->read (buffers.get_audio(0).data(), mix_buffer.get(), gain_buffer.get(), start, nframes) != nframes) { return -1; @@ -405,7 +271,7 @@ AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nfram BufferSet::audio_iterator bi = buffers.audio_begin(); ++bi; for ( ; bi != buffers.audio_end(); ++bi, ++n) { - if (n < diskstream->n_channels().n_audio()) { + if (n < _disk_reader->output_streams().n_audio()) { if (apl->read (bi->data(), mix_buffer.get(), gain_buffer.get(), start, nframes, n) != nframes) { return -1; } @@ -416,38 +282,7 @@ AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nfram } } - // If no processing is required, there's no need to go any further. - - if (!endpoint && !include_endpoint) { - return 0; - } - - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - - if (!include_endpoint && (*i) == endpoint) { - break; - } - - /* if we're not exporting, stop processing if we come across a routing processor. - */ - - if (!for_export && (*i)->does_routing()) { - break; - } - - /* even for export, don't run any processor that does routing. - - oh, and don't bother with the peak meter either. - */ - - if (!(*i)->does_routing() && !boost::dynamic_pointer_cast(*i)) { - (*i)->run (buffers, start, start+nframes, nframes, true); - } - - if ((*i) == endpoint) { - break; - } - } + bounce_process (buffers, start, nframes, endpoint, include_endpoint, for_export, for_freeze); return 0; } @@ -486,12 +321,12 @@ AudioTrack::bounceable (boost::shared_ptr endpoint, bool include_endp /* does the output from the last considered processor match the * input to this one? */ - + if (naudio != (*r)->input_streams().n_audio()) { return false; } - /* we're including the endpoint - if we just hit it, + /* we're including the endpoint - if we just hit it, then stop. */ @@ -499,7 +334,7 @@ AudioTrack::bounceable (boost::shared_ptr endpoint, bool include_endp return true; } - /* save outputs of this processor to test against inputs + /* save outputs of this processor to test against inputs of the next one. */ @@ -512,15 +347,15 @@ AudioTrack::bounceable (boost::shared_ptr endpoint, bool include_endp boost::shared_ptr AudioTrack::bounce (InterThreadInfo& itt) { - return bounce_range (_session.current_start_frame(), _session.current_end_frame(), itt, main_outs(), false); + return bounce_range (_session.current_start_sample(), _session.current_end_sample(), itt, main_outs(), false); } boost::shared_ptr -AudioTrack::bounce_range (framepos_t start, framepos_t end, InterThreadInfo& itt, +AudioTrack::bounce_range (samplepos_t start, samplepos_t end, InterThreadInfo& itt, boost::shared_ptr endpoint, bool include_endpoint) { vector > srcs; - return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false); + return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false, false); } void @@ -531,9 +366,8 @@ AudioTrack::freeze_me (InterThreadInfo& itt) boost::shared_ptr new_playlist; string dir; string region_name; - boost::shared_ptr diskstream = audio_diskstream(); - if ((_freeze_record.playlist = boost::dynamic_pointer_cast(diskstream->playlist())) == 0) { + if ((_freeze_record.playlist = boost::dynamic_pointer_cast(playlist())) == 0) { return; } @@ -563,8 +397,8 @@ AudioTrack::freeze_me (InterThreadInfo& itt) boost::shared_ptr res; - if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt, - main_outs(), false, false)) == 0) { + if ((res = _session.write_one_track (*this, _session.current_start_sample(), _session.current_end_sample(), + true, srcs, itt, main_outs(), false, false, true)) == 0) { return; } @@ -575,7 +409,10 @@ AudioTrack::freeze_me (InterThreadInfo& itt) for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) { - if (!(*r)->does_routing() && !boost::dynamic_pointer_cast(*r)) { + if ((*r)->does_routing() && (*r)->active()) { + break; + } + if (!boost::dynamic_pointer_cast(*r)) { FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), (*r)); @@ -583,11 +420,12 @@ AudioTrack::freeze_me (InterThreadInfo& itt) _freeze_record.processor_info.push_back (frii); - /* now deactivate the processor */ - - (*r)->deactivate (); + /* now deactivate the processor, */ + if (!boost::dynamic_pointer_cast(*r)) { + (*r)->deactivate (); + } } - + _session.set_dirty (); } } @@ -610,17 +448,20 @@ AudioTrack::freeze_me (InterThreadInfo& itt) boost::shared_ptr region (RegionFactory::create (srcs, plist, false)); new_playlist->set_orig_track_id (id()); - new_playlist->add_region (region, _session.current_start_frame()); + new_playlist->add_region (region, _session.current_start_sample()); new_playlist->set_frozen (true); region->set_locked (true); - diskstream->use_playlist (boost::dynamic_pointer_cast(new_playlist)); - diskstream->set_record_enabled (false); + use_playlist (DataType::AUDIO, boost::dynamic_pointer_cast(new_playlist)); + _disk_writer->set_record_enabled (false); + + _freeze_record.playlist->use(); // prevent deletion /* reset stuff that has already been accounted for in the freeze process */ - set_gain (1.0, this); - _amp->gain_control()->set_automation_state (Off); + gain_control()->set_value (GAIN_COEFF_UNITY, Controllable::NoGroup); + gain_control()->set_automation_state (Off); + /* XXX need to use _main_outs _panner->set_automation_state (Off); */ _freeze_record.state = Frozen; @@ -631,7 +472,8 @@ void AudioTrack::unfreeze () { if (_freeze_record.playlist) { - audio_diskstream()->use_playlist (_freeze_record.playlist); + _freeze_record.playlist->release(); + use_playlist (DataType::AUDIO, _freeze_record.playlist); { Glib::Threads::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc @@ -656,13 +498,6 @@ AudioTrack::unfreeze () boost::shared_ptr AudioTrack::write_source (uint32_t n) { - boost::shared_ptr ds = boost::dynamic_pointer_cast (_diskstream); - assert (ds); - return ds->write_source (n); -} - -boost::shared_ptr -AudioTrack::diskstream_factory (XMLNode const & node) -{ - return boost::shared_ptr (new AudioDiskstream (_session, node)); + assert (_disk_writer); + return _disk_writer->audio_write_source (n); }