X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_track.cc;h=b548b3a4448953ccf091a1474015f30b6c0b6f19;hb=f07ca6397f5699e4dc4ec1e360f9e263d8a0d9ad;hp=080538a34ee1c04df988f61c2a30817f81536eda;hpb=3356957afae11607f8fb8996ca22028ffd5fde2d;p=ardour.git diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc index 080538a34e..b548b3a444 100644 --- a/libs/ardour/audio_track.cc +++ b/libs/ardour/audio_track.cc @@ -38,6 +38,7 @@ #include "ardour/meter.h" #include "ardour/playlist_factory.h" #include "ardour/plugin_insert.h" +#include "ardour/port_insert.h" #include "ardour/processor.h" #include "ardour/region_factory.h" #include "ardour/route_group_specialized.h" @@ -61,8 +62,8 @@ AudioTrack::~AudioTrack () { } -void -AudioTrack::use_new_diskstream () +boost::shared_ptr +AudioTrack::create_diskstream () { AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0); @@ -78,13 +79,7 @@ AudioTrack::use_new_diskstream () dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered); } - AudioDiskstream* dsp (new AudioDiskstream (_session, name(), dflags)); - boost::shared_ptr ds (dsp); - - ds->do_refill_with_alloc (); - ds->set_block_size (_session.get_block_size ()); - - set_diskstream (ds); + return boost::shared_ptr (new AudioDiskstream (_session, name(), dflags)); } void @@ -106,7 +101,7 @@ AudioTrack::set_diskstream (boost::shared_ptr ds) } _diskstream->set_record_enabled (false); - _diskstream->monitor_input (false); + _diskstream->request_jack_monitors_input (false); DiskstreamChanged (); /* EMIT SIGNAL */ } @@ -200,21 +195,11 @@ AudioTrack::deprecated_use_diskstream_connections () int AudioTrack::set_state (const XMLNode& node, int version) -{ - return _set_state (node, version, true); -} - -int -AudioTrack::_set_state (const XMLNode& node, int version, bool call_base) { const XMLProperty *prop; - XMLNodeConstIterator iter; - XMLNode *child; - if (call_base) { - if (Route::_set_state (node, version, call_base)) { - return -1; - } + if (Track::set_state (node, version)) { + return -1; } if ((prop = node.property (X_("mode"))) != 0) { @@ -223,32 +208,6 @@ AudioTrack::_set_state (const XMLNode& node, int version, bool call_base) _mode = Normal; } - if (version >= 3000) { - if ((child = find_named_node (node, X_("Diskstream"))) != 0) { - boost::shared_ptr ds (new AudioDiskstream (_session, *child)); - ds->do_refill_with_alloc (); - set_diskstream (ds); - } - } - - /* set rec-enable control *AFTER* setting up diskstream, because it may want to operate - on the diskstream as it sets its own state - */ - - XMLNodeList nlist; - XMLNodeConstIterator niter; - - nlist = node.children(); - for (niter = nlist.begin(); niter != nlist.end(); ++niter){ - child = *niter; - - if (child->name() == Controllable::xml_node_name && (prop = child->property ("name")) != 0) { - if (prop->value() == X_("recenable")) { - _rec_enable_control->set_state (*child, version); - } - } - } - pending_state = const_cast (&node); if (_session.state_of_the_state() & Session::Loading) { @@ -263,7 +222,7 @@ AudioTrack::_set_state (const XMLNode& node, int version, bool call_base) XMLNode& AudioTrack::state (bool full_state) { - XMLNode& root (Route::state(full_state)); + XMLNode& root (Track::state(full_state)); XMLNode* freeze_node; char buf[64]; @@ -287,8 +246,6 @@ AudioTrack::state (bool full_state) } root.add_property (X_("mode"), enum_2_string (_mode)); - root.add_child_nocopy (_rec_enable_control->get_state()); - root.add_child_nocopy (_diskstream->get_state ()); return root; } @@ -352,21 +309,23 @@ 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 can_record, bool rec_monitors_input, bool& need_butler) +AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler) { Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); + if (!lm.locked()) { return 0; } - int dret; Sample* b; Sample* tmpb; framepos_t transport_frame; boost::shared_ptr diskstream = audio_diskstream(); - + automation_snapshot (start_frame, false); if (n_outputs().n_total() == 0 && _processors.empty()) { @@ -380,19 +339,26 @@ AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_fram 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. */ - return diskstream->process (transport_frame, 0, can_record, rec_monitors_input, need_butler); + + dret = diskstream->process (transport_frame, 0, playback_distance); + need_butler = diskstream->commit (playback_distance); + return dret; } _silent = false; _amp->apply_gain_automation(false); - if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input, need_butler)) != 0) { + if ((dret = diskstream->process (transport_frame, nframes, playback_distance)) != 0) { + need_butler = diskstream->commit (playback_distance); silence (nframes); return dret; } @@ -403,11 +369,7 @@ AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_fram _input->process_input (_meter, start_frame, end_frame, nframes); } - if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) { - - /* not actually recording, but we want to hear the input material anyway, - at least potentially (depending on monitoring options) - */ + if (monitoring_state() == MonitoringInput) { passthru (start_frame, end_frame, nframes, false); @@ -506,20 +468,23 @@ AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_fram process_output_buffers ( bufs, start_frame, end_frame, nframes, - (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, - (!diskstream->record_enabled() && _session.transport_rolling())); + (!diskstream->record_enabled() && _session.transport_rolling()) + ); } else { /* problem with the diskstream; just be quiet for a bit */ silence (nframes); } + need_butler = diskstream->commit (playback_distance); + return 0; } int -AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, bool enable_processing) +AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, + boost::shared_ptr endpoint, bool include_endpoint, bool for_export) { boost::scoped_array gain_buffer (new gain_t[nframes]); boost::scoped_array mix_buffer (new Sample[nframes]); @@ -554,41 +519,110 @@ 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 (!enable_processing) { + + if (!endpoint && !include_endpoint) { return 0; } - /* note: only run processors during export. other layers in the machinery - will already have checked that there are no external port processors. - Also, don't run deliveries that write to real output ports, and don't - run meters. - */ - for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { - boost::shared_ptr processor = boost::dynamic_pointer_cast (*i); - boost::shared_ptr delivery = boost::dynamic_pointer_cast (*i); - boost::shared_ptr meter = boost::dynamic_pointer_cast (*i); + + if (!include_endpoint && (*i) == endpoint) { + break; + } - if (processor && (!delivery || !Delivery::role_requires_output_ports (delivery->role())) && !meter) { - processor->run (buffers, start, start+nframes, nframes, true); + /* 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; } } return 0; } +bool +AudioTrack::bounceable (boost::shared_ptr endpoint, bool include_endpoint) const +{ + if (!endpoint && !include_endpoint) { + /* no processing - just read from the playlist and create new + files: always possible. + */ + return true; + } + + Glib::RWLock::ReaderLock lm (_processor_lock); + uint32_t naudio = n_inputs().n_audio(); + + for (ProcessorList::const_iterator r = _processors.begin(); r != _processors.end(); ++r) { + + /* if we're not including the endpoint, potentially stop + right here before we test matching i/o valences. + */ + + if (!include_endpoint && (*r) == endpoint) { + return true; + } + + /* ignore any processors that do routing, because we will not + * use them during a bounce/freeze/export operation. + */ + + if ((*r)->does_routing()) { + continue; + } + + /* 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, + then stop. + */ + + if ((*r) == endpoint) { + return true; + } + + /* save outputs of this processor to test against inputs + of the next one. + */ + + naudio = (*r)->output_streams().n_audio(); + } + + return true; +} + boost::shared_ptr AudioTrack::bounce (InterThreadInfo& itt) { - vector > srcs; - return _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), false, srcs, itt); + return bounce_range (_session.current_start_frame(), _session.current_end_frame(), itt, main_outs(), false); } boost::shared_ptr -AudioTrack::bounce_range (framepos_t start, framepos_t end, InterThreadInfo& itt, bool enable_processing) +AudioTrack::bounce_range (framepos_t start, framepos_t end, InterThreadInfo& itt, + boost::shared_ptr endpoint, bool include_endpoint) { vector > srcs; - return _session.write_one_track (*this, start, end, false, srcs, itt, enable_processing); + return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false); } void @@ -631,7 +665,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)) == 0) { + if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt, + main_outs(), false, false)) == 0) { return; } @@ -642,21 +677,20 @@ AudioTrack::freeze_me (InterThreadInfo& itt) for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) { - boost::shared_ptr processor; - - if ((processor = boost::dynamic_pointer_cast(*r)) != 0) { + if (!(*r)->does_routing()) { - FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), processor); + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), (*r)); - frii->id = processor->id(); + frii->id = (*r)->id(); _freeze_record.processor_info.push_back (frii); /* now deactivate the processor */ - processor->deactivate (); - _session.set_dirty (); + (*r)->deactivate (); } + + _session.set_dirty (); } } @@ -669,7 +703,7 @@ AudioTrack::freeze_me (InterThreadInfo& itt) /* create a new region from all filesources, keep it private */ PropertyList plist; - + plist.add (Properties::start, 0); plist.add (Properties::length, srcs[0]->length(srcs[0]->timeline_position())); plist.add (Properties::name, region_name); @@ -677,7 +711,7 @@ AudioTrack::freeze_me (InterThreadInfo& itt) boost::shared_ptr region (RegionFactory::create (srcs, plist, false)); - new_playlist->set_orig_diskstream_id (_diskstream->id()); + new_playlist->set_orig_track_id (id()); new_playlist->add_region (region, _session.current_start_frame()); new_playlist->set_frozen (true); region->set_locked (true); @@ -729,8 +763,8 @@ AudioTrack::write_source (uint32_t n) return ds->write_source (n); } -bool -AudioTrack::bounceable () const +boost::shared_ptr +AudioTrack::diskstream_factory (XMLNode const & node) { - return n_inputs().n_audio() >= n_outputs().n_audio(); + return boost::shared_ptr (new AudioDiskstream (_session, node)); }