X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_track.cc;h=6de833aeb4f5b3332299782d2b627cdd49275d42;hb=9ef2a89ccde5656849ea13429186b80e580b6ab8;hp=07930c49e6884151a65db41685de287bdff79fd8;hpb=72f8544b2411c0bb9a8a46b2d27c5e94c2c0b803;p=ardour.git diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc index 07930c49e6..6de833aeb4 100644 --- a/libs/ardour/audio_track.cc +++ b/libs/ardour/audio_track.cc @@ -19,9 +19,9 @@ #include -#include "pbd/error.h" -#include "pbd/enumwriter.h" #include "pbd/boost_debug.h" +#include "pbd/enumwriter.h" +#include "pbd/error.h" #include "evoral/Curve.hpp" @@ -30,21 +30,18 @@ #include "ardour/audio_diskstream.h" #include "ardour/audio_track.h" #include "ardour/audioplaylist.h" -#include "ardour/audioregion.h" -#include "ardour/audiosource.h" #include "ardour/buffer_set.h" -#include "ardour/io_processor.h" -#include "ardour/panner.h" +#include "ardour/delivery.h" #include "ardour/meter.h" #include "ardour/playlist_factory.h" -#include "ardour/plugin_insert.h" #include "ardour/processor.h" +#include "ardour/region.h" #include "ardour/region_factory.h" -#include "ardour/route_group_specialized.h" #include "ardour/session.h" -#include "ardour/utils.h" #include "ardour/session_playlists.h" -#include "ardour/delivery.h" +#include "ardour/source.h" +#include "ardour/utils.h" + #include "i18n.h" using namespace std; @@ -60,12 +57,12 @@ AudioTrack::~AudioTrack () { } -void -AudioTrack::use_new_diskstream () +boost::shared_ptr +AudioTrack::create_diskstream () { AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0); - if (_flags & Hidden) { + if (_flags & Auditioner) { dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden); } else { dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable); @@ -77,19 +74,15 @@ AudioTrack::use_new_diskstream () dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered); } - AudioDiskstream* dsp (new AudioDiskstream (_session, name(), dflags)); - boost::shared_ptr ds (dsp); - - _session.add_diskstream (ds); - - set_diskstream (ds); + return boost::shared_ptr (new AudioDiskstream (_session, name(), dflags)); } void AudioTrack::set_diskstream (boost::shared_ptr ds) { - _diskstream = ds; - _diskstream->set_route (*this); + Track::set_diskstream (ds); + + _diskstream->set_track (this); _diskstream->set_destructive (_mode == Destructive); _diskstream->set_non_layered (_mode == NonLayered); @@ -103,7 +96,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 */ } @@ -183,7 +176,7 @@ AudioTrack::deprecated_use_diskstream_connections () } } - _input->connect_ports_to_bundle (c, this); + _input->connect_ports_to_bundle (c, true, this); } else if ((prop = node.property ("inputs")) != 0) { if (_input->set_ports (prop->value())) { @@ -197,20 +190,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; - 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) { @@ -219,20 +203,6 @@ AudioTrack::_set_state (const XMLNode& node, int version, bool call_base) _mode = Normal; } - XMLNodeList nlist; - XMLNodeConstIterator niter; - XMLNode *child; - - nlist = node.children(); - for (niter = nlist.begin(); niter != nlist.end(); ++niter){ - child = *niter; - - if (child->name() == X_("recenable")) { - _rec_enable_control->set_state (*child, version); - _session.add_controllable (_rec_enable_control); - } - } - pending_state = const_cast (&node); if (_session.state_of_the_state() & Session::Loading) { @@ -245,9 +215,9 @@ AudioTrack::_set_state (const XMLNode& node, int version, bool call_base) } XMLNode& -AudioTrack::state(bool full_state) +AudioTrack::state (bool full_state) { - XMLNode& root (Route::state(full_state)); + XMLNode& root (Track::state(full_state)); XMLNode* freeze_node; char buf[64]; @@ -270,26 +240,8 @@ AudioTrack::state(bool full_state) root.add_child_nocopy (*freeze_node); } - /* Alignment: act as a proxy for the diskstream */ - - XMLNode* align_node = new XMLNode (X_("Alignment")); - AlignStyle as = _diskstream->alignment_style (); - align_node->add_property (X_("style"), enum_2_string (as)); - root.add_child_nocopy (*align_node); - root.add_property (X_("mode"), enum_2_string (_mode)); - /* we don't return diskstream state because we don't - own the diskstream exclusively. control of the diskstream - state is ceded to the Session, even if we create the - diskstream. - */ - - _diskstream->id().print (buf, sizeof (buf)); - root.add_property ("diskstream-id", buf); - - root.add_child_nocopy (_rec_enable_control->get_state()); - return root; } @@ -350,227 +302,98 @@ AudioTrack::set_state_part_two () _freeze_record.processor_info.push_back (frii); } } - - /* Alignment: act as a proxy for the diskstream */ - - if ((fnode = find_named_node (*pending_state, X_("Alignment"))) != 0) { - - if ((prop = fnode->property (X_("style"))) != 0) { - - /* fix for older sessions from before EnumWriter */ - - string pstr; - - if (prop->value() == "capture") { - pstr = "CaptureTime"; - } else if (prop->value() == "existing") { - pstr = "ExistingMaterial"; - } else { - pstr = prop->value(); - } - - AlignStyle as = AlignStyle (string_2_enum (pstr, as)); - _diskstream->set_persistent_align_style (as); - } - } - return; } +/** @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 (nframes_t nframes, sframes_t start_frame, sframes_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) { - int dret; - Sample* b; - Sample* tmpb; - nframes_t transport_frame; - boost::shared_ptr diskstream = audio_diskstream(); - - { - Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); - if (lm.locked()) { - // automation snapshot can also be called from the non-rt context - // and it uses the redirect list, so we take the lock out here - automation_snapshot (start_frame, false); - } + Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK); + + if (!lm.locked()) { + 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); + 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. */ - return diskstream->process (transport_frame, 0, can_record, rec_monitors_input, need_butler); - } - _silent = false; - _amp->apply_gain_automation(false); + BufferSet bufs; /* empty set, no matter - nothing will happen */ - if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input, need_butler)) != 0) { - silence (nframes); + dret = diskstream->process (bufs, transport_frame, 0, playback_distance, false); + need_butler = diskstream->commit (playback_distance); return dret; } - /* special condition applies */ - - if (_meter_point == MeterInput) { - _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) - */ - - passthru (start_frame, end_frame, nframes, false); - - } else if ((b = diskstream->playback_buffer(0)) != 0) { - - /* - XXX is it true that the earlier test on n_outputs() - means that we can avoid checking it again here? i think - so, because changing the i/o configuration of an IO - requires holding the AudioEngine lock, which we hold - while in the process() tree. - */ - - - /* copy the diskstream data to all output buffers */ - - size_t limit = input_streams ().n_audio(); - BufferSet& bufs = _session.get_scratch_buffers (); - const size_t blimit = bufs.count().n_audio(); - - uint32_t n; - uint32_t i; - - if (limit > blimit) { - - /* example case: auditioner configured for stereo output, - but loaded with an 8 channel file. there are only - 2 passthrough buffers, but n_process_buffers() will - return 8. - - arbitrary decision: map all channels in the diskstream - to the outputs available. - */ - - float scaling = limit/blimit; - - for (i = 0, n = 1; i < blimit; ++i, ++n) { - - /* first time through just copy a channel into - the output buffer. - */ - - Sample* bb = bufs.get_audio (i).data(); - - for (nframes_t xx = 0; xx < nframes; ++xx) { - bb[xx] = b[xx] * scaling; - } - - if (n < diskstream->n_channels().n_audio()) { - tmpb = diskstream->playback_buffer(n); - if (tmpb!=0) { - b = tmpb; - } - } - } - - for (;i < limit; ++i, ++n) { - - /* for all remaining channels, sum with existing - data in the output buffers - */ - - bufs.get_audio (i%blimit).accumulate_with_gain_from (b, nframes, 0, scaling); - - if (n < diskstream->n_channels().n_audio()) { - tmpb = diskstream->playback_buffer(n); - if (tmpb!=0) { - b = tmpb; - } - } - - } - - limit = blimit; - - } else { - for (i = 0, n = 1; i < limit; ++i, ++n) { - memcpy (bufs.get_audio (i).data(), b, sizeof (Sample) * nframes); - if (n < diskstream->n_channels().n_audio()) { - tmpb = diskstream->playback_buffer(n); - if (tmpb!=0) { - b = tmpb; - } - } - } - - /* try to leave any MIDI buffers alone */ - - ChanCount chn; - chn.set_audio (limit); - chn.set_midi (_input->n_ports().n_midi()); - bufs.set_count (chn); - } - - /* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */ + _silent = false; + _amp->apply_gain_automation(false); - if (!diskstream->record_enabled() && _session.transport_rolling()) { -#ifdef XXX_MOVE_THIS_TO_AMP - Glib::Mutex::Lock am (data().control_lock(), Glib::TRY_LOCK); + BufferSet& bufs = _session.get_route_buffers (n_process_buffers ()); - if (am.locked() && gain_control()->automation_playback()) { - _amp->apply_gain_automation( - gain_control()->list()->curve().rt_safe_get_vector ( - start_frame, end_frame, _session.gain_automation_buffer(), nframes)); - } -#endif - } - - process_output_buffers (bufs, start_frame, end_frame, nframes, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick); + 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); + } - } else { - /* problem with the diskstream; just be quiet for a bit */ + 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, sframes_t start, nframes_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 float[nframes]); + boost::scoped_array mix_buffer (new Sample[nframes]); boost::shared_ptr diskstream = audio_diskstream(); - Glib::RWLock::ReaderLock rlock (_processor_lock); + Glib::Threads::RWLock::ReaderLock rlock (_processor_lock); boost::shared_ptr apl = boost::dynamic_pointer_cast(diskstream->playlist()); - assert(apl); - assert(buffers.get_audio(0).capacity() >= nframes); + assert(apl); + assert(buffers.count().n_audio() >= 1); + assert ((framecnt_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; } - assert(buffers.count().n_audio() >= 1); uint32_t n=1; Sample* b = buffers.get_audio(0).data(); BufferSet::audio_iterator bi = buffers.audio_begin(); @@ -581,47 +404,117 @@ AudioTrack::export_stuff (BufferSet& buffers, sframes_t start, nframes_t nframes return -1; } b = bi->data(); - } - else { + } else { /* duplicate last across remaining buffers */ memcpy (bi->data(), b, sizeof (Sample) * nframes); } } // 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. - */ - 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); + + if (!include_endpoint && (*i) == endpoint) { + break; + } + + /* if we're not exporting, stop processing if we come across a routing processor. + */ - if (processor && (!delivery || !Delivery::role_requires_output_ports (delivery->role()))) { - processor->run (buffers, start, start+nframes, nframes, true); + 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::Threads::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 (nframes_t start, nframes_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 @@ -664,39 +557,37 @@ 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; } _freeze_record.processor_info.clear (); { - Glib::RWLock::ReaderLock lm (_processor_lock); + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); 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() && !boost::dynamic_pointer_cast(*r)) { - 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 (); } } new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false); - _freeze_record.gain = _amp->gain(); - _freeze_record.gain_automation_state = _amp->gain_control()->automation_state(); /* XXX need main outs automation state _freeze_record.pan_automation_state = _mainpanner->automation_state(); */ region_name = new_playlist_name; @@ -704,7 +595,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); @@ -712,7 +603,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); @@ -737,7 +628,7 @@ AudioTrack::unfreeze () audio_diskstream()->use_playlist (_freeze_record.playlist); { - Glib::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc + Glib::Threads::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) { for (vector::iterator ii = _freeze_record.processor_info.begin(); ii != _freeze_record.processor_info.end(); ++ii) { if ((*ii)->id == (*i)->id()) { @@ -749,8 +640,6 @@ AudioTrack::unfreeze () } _freeze_record.playlist.reset (); - set_gain (_freeze_record.gain, this); - _amp->gain_control()->set_automation_state (_freeze_record.gain_automation_state); /* XXX need to use _main_outs _panner->set_automation_state (_freeze_record.pan_automation_state); */ } @@ -758,3 +647,16 @@ AudioTrack::unfreeze () FreezeChange (); /* EMIT SIGNAL */ } +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)); +}