X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_track.cc;h=14870cb72dc18b2649bd78c814dcb5bd1e10e296;hb=0938a42440cc82ce8d0cb064840c258c863714ab;hp=151b434c6ba62c2c1d2e83d512bf13325777505c;hpb=d7bd270aa10b3a8669223debe4c1b572ae876e2b;p=ardour.git diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc index 151b434c6b..14870cb72d 100644 --- a/libs/ardour/audio_track.cc +++ b/libs/ardour/audio_track.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002 Paul Davis + Copyright (C) 2002 Paul Davis This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,28 +17,35 @@ */ -#include -#include -#include - -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include + +#include "pbd/error.h" +#include "pbd/enumwriter.h" +#include "pbd/boost_debug.h" + +#include "evoral/Curve.hpp" + +#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/audioregion.h" +#include "ardour/audiosource.h" +#include "ardour/buffer_set.h" +#include "ardour/io_processor.h" +#include "ardour/panner.h" +#include "ardour/meter.h" +#include "ardour/playlist_factory.h" +#include "ardour/plugin_insert.h" +#include "ardour/processor.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/meter.h" #include "i18n.h" using namespace std; @@ -47,6 +54,15 @@ using namespace PBD; AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode) : Track (sess, name, flag, mode) +{ +} + +AudioTrack::~AudioTrack () +{ +} + +void +AudioTrack::use_new_diskstream () { AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0); @@ -56,25 +72,49 @@ AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable); } - if (mode == Destructive) { + if (_mode == Destructive) { dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive); + } else if (_mode == NonLayered){ + dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered); } - boost::shared_ptr ds (new AudioDiskstream (_session, name, dflags)); - - _session.add_diskstream (ds); + AudioDiskstream* dsp (new AudioDiskstream (_session, name(), dflags)); + boost::shared_ptr ds (dsp); - set_diskstream (boost::dynamic_pointer_cast (ds), this); + ds->do_refill_with_alloc (); + ds->set_block_size (_session.get_block_size ()); + + set_diskstream (ds); } -AudioTrack::AudioTrack (Session& sess, const XMLNode& node) - : Track (sess, node) +void +AudioTrack::set_diskstream (boost::shared_ptr ds) { - _set_state (node, false); + Track::set_diskstream (ds); + + _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)); + } else { + deprecated_use_diskstream_connections (); + } + } + + _diskstream->set_record_enabled (false); + _diskstream->monitor_input (false); + + DiskstreamChanged (); /* EMIT SIGNAL */ } -AudioTrack::~AudioTrack () +boost::shared_ptr +AudioTrack::audio_diskstream() const { + return boost::dynamic_pointer_cast(_diskstream); } int @@ -86,8 +126,9 @@ AudioTrack::set_mode (TrackMode m) return -1; } + _diskstream->set_non_layered (m == NonLayered); _mode = m; - + TrackModeChanged (); /* EMIT SIGNAL */ } @@ -98,10 +139,11 @@ 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); @@ -124,117 +166,53 @@ AudioTrack::deprecated_use_diskstream_connections () diskstream->deprecated_io_node = 0; - set_input_minimum (ChanCount::ZERO); - set_input_maximum (ChanCount::INFINITE); - set_output_minimum (ChanCount::ZERO); - set_output_maximum (ChanCount::INFINITE); - if ((prop = node.property ("gain")) != 0) { - set_gain (atof (prop->value().c_str()), this); - _gain = _desired_gain; + _amp->set_gain (atof (prop->value().c_str()), this); } if ((prop = node.property ("input-connection")) != 0) { - Bundle* c = _session.bundle_by_name (prop->value()); - + boost::shared_ptr c = _session.bundle_by_name (prop->value()); + if (c == 0) { - error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), prop->value(), _name) << endmsg; - + error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), prop->value(), _name) << endmsg; + if ((c = _session.bundle_by_name (_("in 1"))) == 0) { - error << _("No input bundles available as a replacement") + error << _("No input bundles available as a replacement") << endmsg; return -1; } else { - info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), prop->value()) + info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), prop->value()) << endmsg; } } - use_input_bundle(*c, this); + _input->connect_ports_to_bundle (c, this); } else if ((prop = node.property ("inputs")) != 0) { - if (set_inputs (prop->value())) { - error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg; + if (_input->set_ports (prop->value())) { + error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg; return -1; } } - - return 0; -} - -int -AudioTrack::set_diskstream (boost::shared_ptr ds, void *src) -{ - _diskstream = ds; - _diskstream->set_io (*this); - _diskstream->set_destructive (_mode == Destructive); - - if (audio_diskstream()->deprecated_io_node) { - - if (!connecting_legal) { - ConnectingLegal.connect (mem_fun (*this, &AudioTrack::deprecated_use_diskstream_connections)); - } else { - deprecated_use_diskstream_connections (); - } - } - - _diskstream->set_record_enabled (false); - _diskstream->monitor_input (false); - - ic_connection.disconnect(); - ic_connection = input_changed.connect (mem_fun (*_diskstream, &Diskstream::handle_input_change)); - - DiskstreamChanged (); /* EMIT SIGNAL */ return 0; -} - -int -AudioTrack::use_diskstream (string name) -{ - boost::shared_ptr dstream; - - if ((dstream = boost::dynamic_pointer_cast(_session.diskstream_by_name (name))) == 0) { - error << string_compose(_("AudioTrack: audio diskstream \"%1\" not known by session"), name) << endmsg; - return -1; - } - - return set_diskstream (dstream, this); -} - -int -AudioTrack::use_diskstream (const PBD::ID& id) -{ - boost::shared_ptr dstream; - - if ((dstream = boost::dynamic_pointer_cast (_session.diskstream_by_id (id))) == 0) { - error << string_compose(_("AudioTrack: audio diskstream \"%1\" not known by session"), id) << endmsg; - return -1; - } - - return set_diskstream (dstream, this); -} - -boost::shared_ptr -AudioTrack::audio_diskstream() const -{ - return boost::dynamic_pointer_cast(_diskstream); } int -AudioTrack::set_state (const XMLNode& node) +AudioTrack::set_state (const XMLNode& node, int version) { - return _set_state (node, true); + return _set_state (node, version, true); } int -AudioTrack::_set_state (const XMLNode& node, bool call_base) +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, call_base)) { + if (Route::_set_state (node, version, call_base)) { return -1; } } @@ -245,53 +223,45 @@ AudioTrack::_set_state (const XMLNode& node, bool call_base) _mode = Normal; } - if ((prop = node.property ("diskstream-id")) == 0) { - - /* some old sessions use the diskstream name rather than the ID */ - - if ((prop = node.property ("diskstream")) == 0) { - fatal << _("programming error: AudioTrack given state without diskstream!") << endmsg; - /*NOTREACHED*/ - return -1; - } - - if (use_diskstream (prop->value())) { - return -1; - } - - } else { - - PBD::ID id (prop->value()); - - if (use_diskstream (id)) { - return -1; + 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; - 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); - _session.add_controllable (&_rec_enable_control); + 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); - _session.StateReady.connect (mem_fun (*this, &AudioTrack::set_state_part_two)); + if (_session.state_of_the_state() & Session::Loading) { + _session.StateReady.connect_same_thread (*this, boost::bind (&AudioTrack::set_state_part_two, this)); + } else { + set_state_part_two (); + } return 0; } -XMLNode& -AudioTrack::state(bool full_state) +XMLNode& +AudioTrack::state (bool full_state) { XMLNode& root (Route::state(full_state)); XMLNode* freeze_node; @@ -304,37 +274,21 @@ AudioTrack::state(bool full_state) freeze_node->add_property ("playlist", _freeze_record.playlist->name()); freeze_node->add_property ("state", enum_2_string (_freeze_record.state)); - for (vector::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) { - inode = new XMLNode (X_("insert")); + 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->add_child_copy ((*i)->state); - + freeze_node->add_child_nocopy (*inode); } 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()); + root.add_child_nocopy (_rec_enable_control->get_state()); + root.add_child_nocopy (_diskstream->get_state ()); return root; } @@ -356,17 +310,15 @@ AudioTrack::set_state_part_two () if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) { - - _freeze_record.have_mementos = false; _freeze_record.state = Frozen; - - for (vector::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) { + + for (vector::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) { delete *i; } - _freeze_record.insert_info.clear (); - + _freeze_record.processor_info.clear (); + if ((prop = fnode->property (X_("playlist"))) != 0) { - boost::shared_ptr pl = _session.playlist_by_name (prop->value()); + boost::shared_ptr pl = _session.playlists->by_name (prop->value()); if (pl) { _freeze_record.playlist = boost::dynamic_pointer_cast (pl); } else { @@ -375,197 +327,89 @@ AudioTrack::set_state_part_two () return; } } - + if ((prop = fnode->property (X_("state"))) != 0) { _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state)); } - + XMLNodeConstIterator citer; XMLNodeList clist = fnode->children(); - + for (citer = clist.begin(); citer != clist.end(); ++citer) { - if ((*citer)->name() != X_("insert")) { + if ((*citer)->name() != X_("processor")) { continue; } - + if ((prop = (*citer)->property (X_("id"))) == 0) { continue; } - - FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo (*((*citer)->children().front()), - boost::shared_ptr()); - frii->id = prop->value (); - _freeze_record.insert_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); + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()), + boost::shared_ptr()); + frii->id = prop->value (); + _freeze_record.processor_info.push_back (frii); } } - return; -} +} -int -AudioTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, - bool session_state_changing, bool can_record, bool rec_monitors_input) +int +AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, + bool can_record, bool& need_butler) { - if (n_outputs().n_total() == 0) { + Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK); + if (!lm.locked()) { return 0; } - if (!_active) { - silence (nframes, offset); - return 0; - } - - if (session_state_changing) { - - /* XXX is this safe to do against transport state changes? */ - - passthru_silence (start_frame, end_frame, nframes, offset, 0, false); - return 0; - } - - audio_diskstream()->check_record_status (start_frame, nframes, can_record); - - bool send_silence; - - if (_have_internal_generator) { - /* since the instrument has no input streams, - there is no reason to send any signal - into the route. - */ - send_silence = true; - } else { - - if (Config->get_auto_input()) { - if (Config->get_monitoring_model() == SoftwareMonitoring) { - send_silence = false; - } else { - send_silence = true; - } - } else { - if (_diskstream->record_enabled()) { - if (Config->get_monitoring_model() == SoftwareMonitoring) { - send_silence = false; - } else { - send_silence = true; - } - } else { - send_silence = true; - } - } - } - - apply_gain_automation = false; - - if (send_silence) { - - /* if we're sending silence, but we want the meters to show levels for the signal, - meter right here. - */ - - if (_have_internal_generator) { - passthru_silence (start_frame, end_frame, nframes, offset, 0, true); - } else { - if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); - } - passthru_silence (start_frame, end_frame, nframes, offset, 0, false); - } - - } else { - - /* we're sending signal, but we may still want to meter the input. - */ - - passthru (start_frame, end_frame, nframes, offset, 0, (_meter_point == MeterInput)); - } - - return 0; -} - -int -AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick, - bool can_record, bool rec_monitors_input) -{ int dret; Sample* b; Sample* tmpb; - nframes_t transport_frame; + framepos_t transport_frame; boost::shared_ptr diskstream = audio_diskstream(); - - { - Glib::RWLock::ReaderLock lm (insert_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); - } - } - - if (n_outputs().n_total() == 0 && _inserts.empty()) { + automation_snapshot (start_frame, false); + + if (n_outputs().n_total() == 0 && _processors.empty()) { return 0; } if (!_active) { - silence (nframes, offset); + silence (nframes); return 0; } transport_frame = _session.transport_frame(); - if ((nframes = check_initial_delay (nframes, offset, transport_frame)) == 0) { + 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, 0, can_record, rec_monitors_input); - } + return diskstream->process (transport_frame, 0, can_record, need_butler); + } _silent = false; - apply_gain_automation = false; - - if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) { - - silence (nframes, offset); + _amp->apply_gain_automation(false); + if ((dret = diskstream->process (transport_frame, nframes, can_record, need_butler)) != 0) { + silence (nframes); return dret; } /* special condition applies */ - + if (_meter_point == MeterInput) { - just_meter_input (start_frame, end_frame, nframes, offset); + _input->process_input (_meter, start_frame, end_frame, nframes); } - if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) { + 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, offset, 0, true); + passthru (start_frame, end_frame, nframes, false); } else if ((b = diskstream->playback_buffer(0)) != 0) { @@ -577,185 +421,178 @@ AudioTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, while in the process() tree. */ - + /* copy the diskstream data to all output buffers */ - - const size_t limit = n_process_buffers().n_audio(); - BufferSet& bufs = _session.get_scratch_buffers (n_process_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; - 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; + 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 (pframes_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; + } } } - } - /* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */ + 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; + } + } - if (!diskstream->record_enabled() && _session.transport_rolling()) { - Glib::Mutex::Lock am (_automation_lock, Glib::TRY_LOCK); - - if (am.locked() && gain_automation().automation_playback()) { - apply_gain_automation = gain_automation().curve().rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes); } - } - process_output_buffers (bufs, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput)); - - } else { - /* problem with the diskstream; just be quiet for a bit */ - silence (nframes, offset); - } + limit = blimit; - return 0; -} + } 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; + } + } + } -int -AudioTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, - bool can_record, bool rec_monitors_input) -{ - if (n_outputs().n_total() == 0 && _inserts.empty()) { - return 0; - } + /* try to leave any MIDI buffers alone */ - if (!_active) { - silence (nframes, offset); - return 0; - } + ChanCount chn; + chn.set_audio (limit); + chn.set_midi (_input->n_ports().n_midi()); + bufs.set_count (chn); + } + + /* final argument: don't waste time with automation if we're recording or we've just stopped (yes it can happen) */ - _silent = true; - apply_gain_automation = false; + 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())); - silence (nframes, offset); + } else { + /* problem with the diskstream; just be quiet for a bit */ + silence (nframes); + } - return audio_diskstream()->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input); + return 0; } int -AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes) +AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, bool enable_processing) { - gain_t gain_automation[nframes]; - gain_t gain_buffer[nframes]; - float mix_buffer[nframes]; - InsertList::iterator i; - bool post_fader_work = false; - gain_t this_gain = _gain; + boost::scoped_array gain_buffer (new gain_t[nframes]); + boost::scoped_array mix_buffer (new Sample[nframes]); boost::shared_ptr diskstream = audio_diskstream(); - - Glib::RWLock::ReaderLock rlock (insert_lock); + + Glib::RWLock::ReaderLock rlock (_processor_lock); boost::shared_ptr apl = boost::dynamic_pointer_cast(diskstream->playlist()); + assert(apl); + assert(buffers.count().n_audio() >= 1); + assert ((framecnt_t) buffers.get_audio(0).capacity() >= nframes); - if (apl->read (buffers.get_audio(nframes).data(), - mix_buffer, gain_buffer, start, nframes) != 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(); ++bi; for ( ; bi != buffers.audio_end(); ++bi, ++n) { if (n < diskstream->n_channels().n_audio()) { - if (apl->read (bi->data(), mix_buffer, gain_buffer, start, nframes, n) != nframes) { + if (apl->read (bi->data(), mix_buffer.get(), gain_buffer.get(), start, nframes, n) != nframes) { return -1; } b = bi->data(); - } - else { + } else { /* duplicate last across remaining buffers */ - memcpy (bi->data(), b, sizeof (Sample) * nframes); + memcpy (bi->data(), b, sizeof (Sample) * nframes); } } - - /* note: only run inserts during export. other layers in the machinery - will already have checked that there are no external port inserts. - */ - - for (i = _inserts.begin(); i != _inserts.end(); ++i) { - boost::shared_ptr insert; - - if ((insert = boost::dynamic_pointer_cast(*i)) != 0) { - switch (insert->placement()) { - case PreFader: - insert->run (buffers, start, start+nframes, nframes, 0); - break; - case PostFader: - post_fader_work = true; - break; - } - } + // If no processing is required, there's no need to go any further. + if (!enable_processing) { + return 0; } - - if (IO::gain_automation().automation_state() == Play) { - - IO::gain_automation().curve().get_vector (start, start + nframes, gain_automation, nframes); - for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) { - Sample *b = bi->data(); - for (nframes_t n = 0; n < nframes; ++n) { - b[n] *= gain_automation[n]; - } - } + /* 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. + */ - } else { + 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); - for (BufferSet::audio_iterator bi = buffers.audio_begin(); bi != buffers.audio_end(); ++bi) { - Sample *b = bi->data(); - for (nframes_t n = 0; n < nframes; ++n) { - b[n] *= this_gain; - } + if (processor && (!delivery || !Delivery::role_requires_output_ports (delivery->role())) && !meter) { + processor->run (buffers, start, start+nframes, nframes, true); } } - if (post_fader_work) { - - for (i = _inserts.begin(); i != _inserts.end(); ++i) { - boost::shared_ptr insert; - - if ((insert = boost::dynamic_pointer_cast(*i)) != 0) { - switch ((*i)->placement()) { - case PreFader: - break; - case PostFader: - insert->run (buffers, start, start+nframes, nframes, 0); - break; - } - } - } - } - return 0; } -void +boost::shared_ptr AudioTrack::bounce (InterThreadInfo& itt) { vector > srcs; - _session.write_one_audio_track (*this, 0, _session.current_end_frame(), false, srcs, itt); - itt.done = true; + return _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), false, srcs, itt); } - -void -AudioTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt) +boost::shared_ptr +AudioTrack::bounce_range (framepos_t start, framepos_t end, InterThreadInfo& itt, bool enable_processing) { vector > srcs; - _session.write_one_audio_track (*this, start, end, false, srcs, itt); - itt.done = true; + return _session.write_one_track (*this, start, end, false, srcs, itt, enable_processing); } void -AudioTrack::freeze (InterThreadInfo& itt) +AudioTrack::freeze_me (InterThreadInfo& itt) { vector > srcs; string new_playlist_name; @@ -763,7 +600,7 @@ AudioTrack::freeze (InterThreadInfo& itt) string dir; string region_name; boost::shared_ptr diskstream = audio_diskstream(); - + if ((_freeze_record.playlist = boost::dynamic_pointer_cast(diskstream->playlist())) == 0) { return; } @@ -771,68 +608,76 @@ AudioTrack::freeze (InterThreadInfo& itt) uint32_t n = 1; while (n < (UINT_MAX-1)) { - + string candidate; - + candidate = string_compose ("%1", _freeze_record.playlist->name(), n); - if (_session.playlist_by_name (candidate) == 0) { + if (_session.playlists->by_name (candidate) == 0) { new_playlist_name = candidate; break; } ++n; - } + } if (n == (UINT_MAX-1)) { error << string_compose (X_("There are too many frozen versions of playlist \"%1\"" - " to create another one"), _freeze_record.playlist->name()) + " to create another one"), _freeze_record.playlist->name()) << endmsg; return; } - if (_session.write_one_audio_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt)) { + boost::shared_ptr res; + + if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt)) == 0) { return; } - _freeze_record.insert_info.clear (); - _freeze_record.have_mementos = true; + _freeze_record.processor_info.clear (); { - Glib::RWLock::ReaderLock lm (insert_lock); - - for (InsertList::iterator r = _inserts.begin(); r != _inserts.end(); ++r) { - - boost::shared_ptr insert; - - if ((insert = boost::dynamic_pointer_cast(*r)) != 0) { - - FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo ((*r)->get_state(), insert); - - frii->id = insert->id(); - - _freeze_record.insert_info.push_back (frii); - - /* now deactivate the insert */ - - insert->set_active (false); + Glib::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) { + + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), processor); + + frii->id = processor->id(); + + _freeze_record.processor_info.push_back (frii); + + /* now deactivate the processor */ + + processor->deactivate (); _session.set_dirty (); } } } new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false); + + /* XXX need main outs automation state _freeze_record.pan_automation_state = _mainpanner->automation_state(); */ + region_name = new_playlist_name; /* create a new region from all filesources, keep it private */ - boost::shared_ptr region (RegionFactory::create (srcs, 0, srcs[0]->length(), - region_name, 0, - (Region::Flag) (Region::WholeFile|Region::DefaultFlags), - false)); + PropertyList plist; + + plist.add (Properties::start, 0); + plist.add (Properties::length, srcs[0]->length(srcs[0]->timeline_position())); + plist.add (Properties::name, region_name); + plist.add (Properties::whole_file, true); - new_playlist->set_orig_diskstream_id (diskstream->id()); + boost::shared_ptr region (RegionFactory::create (srcs, plist, false)); + + new_playlist->set_orig_diskstream_id (_diskstream->id()); new_playlist->add_region (region, _session.current_start_frame()); new_playlist->set_frozen (true); region->set_locked (true); @@ -840,6 +685,12 @@ AudioTrack::freeze (InterThreadInfo& itt) diskstream->use_playlist (boost::dynamic_pointer_cast(new_playlist)); diskstream->set_record_enabled (false); + /* reset stuff that has already been accounted for in the freeze process */ + + set_gain (1.0, this); + _amp->gain_control()->set_automation_state (Off); + /* XXX need to use _main_outs _panner->set_automation_state (Off); */ + _freeze_record.state = Frozen; FreezeChange(); /* EMIT SIGNAL */ } @@ -850,29 +701,36 @@ AudioTrack::unfreeze () if (_freeze_record.playlist) { audio_diskstream()->use_playlist (_freeze_record.playlist); - if (_freeze_record.have_mementos) { - - for (vector::iterator i = _freeze_record.insert_info.begin(); i != _freeze_record.insert_info.end(); ++i) { - (*i)->memento (); - } - - } else { - - Glib::RWLock::ReaderLock lm (insert_lock); // should this be a write lock? jlc - for (InsertList::iterator i = _inserts.begin(); i != _inserts.end(); ++i) { - for (vector::iterator ii = _freeze_record.insert_info.begin(); ii != _freeze_record.insert_info.end(); ++ii) { + { + Glib::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()) { - (*i)->set_state (((*ii)->state)); + (*i)->set_state (((*ii)->state), Stateful::current_state_version); break; } } } } - + _freeze_record.playlist.reset (); + /* XXX need to use _main_outs _panner->set_automation_state (_freeze_record.pan_automation_state); */ } _freeze_record.state = UnFrozen; 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); +} + +bool +AudioTrack::bounceable () const +{ + return n_inputs().n_audio() >= n_outputs().n_audio(); +}