X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Faudio_track.cc;h=bc2f0d9feba60c79aa43a6a34d873f278581d482;hb=118816dfe393cc671d29352c3ed4741b4f261088;hp=b3727937e221ff32d55e5b43062255e81fc21fe2;hpb=50a3102b9b533d7f8786d220f8df67421b9227c8;p=ardour.git diff --git a/libs/ardour/audio_track.cc b/libs/ardour/audio_track.cc index b3727937e2..bc2f0d9feb 100644 --- a/libs/ardour/audio_track.cc +++ b/libs/ardour/audio_track.cc @@ -15,25 +15,30 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ -#include + #include #include #include +#include +#include + #include #include #include -#include +#include #include #include +#include #include -#include +#include +#include #include +#include #include #include - +#include #include "i18n.h" using namespace std; @@ -41,9 +46,7 @@ using namespace ARDOUR; using namespace PBD; AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode) - : Route (sess, name, 1, -1, -1, -1, flag), - _diskstream (0), - _rec_enable_control (*this) + : Track (sess, name, flag, mode) { AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0); @@ -57,52 +60,74 @@ AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive); } - AudioDiskstream* ds = new AudioDiskstream (_session, name, dflags); + boost::shared_ptr ds (new AudioDiskstream (_session, name, dflags)); - _declickable = true; - _freeze_record.state = NoFreeze; - _saved_meter_point = _meter_point; - _mode = mode; + _session.add_diskstream (ds); - set_diskstream (*ds, this); + set_diskstream (boost::dynamic_pointer_cast (ds), this); } AudioTrack::AudioTrack (Session& sess, const XMLNode& node) - : Route (sess, "to be renamed", 0, 0, -1, -1), - _diskstream (0), - _rec_enable_control (*this) + : Track (sess, node) { - _freeze_record.state = NoFreeze; - set_state (node); - _declickable = true; - _saved_meter_point = _meter_point; + _set_state (node, false); } AudioTrack::~AudioTrack () { - if (_diskstream) { - _diskstream->unref(); +} + +int +AudioTrack::set_mode (TrackMode m) +{ + if (m != _mode) { + + if (_diskstream->set_destructive (m == Destructive)) { + return -1; + } + + _mode = m; + + TrackModeChanged (); /* EMIT SIGNAL */ + } + + return 0; +} + +bool +AudioTrack::can_use_mode (TrackMode m, bool& bounce_required) +{ + switch (m) { + case Normal: + bounce_required = false; + return true; + + case Destructive: + default: + return _diskstream->can_become_destructive (bounce_required); } } int AudioTrack::deprecated_use_diskstream_connections () { - if (_diskstream->deprecated_io_node == 0) { + boost::shared_ptr diskstream = audio_diskstream(); + + if (diskstream->deprecated_io_node == 0) { return 0; } const XMLProperty* prop; - XMLNode& node (*_diskstream->deprecated_io_node); + XMLNode& node (*diskstream->deprecated_io_node); /* don't do this more than once. */ - _diskstream->deprecated_io_node = 0; + diskstream->deprecated_io_node = 0; - set_input_minimum (-1); - set_input_maximum (-1); - set_output_minimum (-1); - set_output_maximum (-1); + 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); @@ -110,22 +135,22 @@ AudioTrack::deprecated_use_diskstream_connections () } if ((prop = node.property ("input-connection")) != 0) { - Connection* c = _session.connection_by_name (prop->value()); + boost::shared_ptr c = _session.bundle_by_name (prop->value()); if (c == 0) { - error << string_compose(_("Unknown connection \"%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.connection_by_name (_("in 1"))) == 0) { - error << _("No input connections available as a replacement") + if ((c = _session.bundle_by_name (_("in 1"))) == 0) { + error << _("No input bundles available as a replacement") << endmsg; return -1; } else { - info << string_compose (_("Connection %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_connection (*c, this); + connect_input_ports_to_bundle (c, this); } else if ((prop = node.property ("inputs")) != 0) { if (set_inputs (prop->value())) { @@ -138,17 +163,13 @@ AudioTrack::deprecated_use_diskstream_connections () } int -AudioTrack::set_diskstream (AudioDiskstream& ds, void *src) +AudioTrack::set_diskstream (boost::shared_ptr ds, void *src) { - if (_diskstream) { - _diskstream->unref(); - } - - _diskstream = &ds.ref(); + _diskstream = ds; _diskstream->set_io (*this); _diskstream->set_destructive (_mode == Destructive); - if (_diskstream->deprecated_io_node) { + if (audio_diskstream()->deprecated_io_node) { if (!connecting_legal) { ConnectingLegal.connect (mem_fun (*this, &AudioTrack::deprecated_use_diskstream_connections)); @@ -157,13 +178,13 @@ AudioTrack::set_diskstream (AudioDiskstream& ds, void *src) } } - _diskstream->set_record_enabled (false, this); + _diskstream->set_record_enabled (false); _diskstream->monitor_input (false); ic_connection.disconnect(); - ic_connection = input_changed.connect (mem_fun (*_diskstream, &AudioDiskstream::handle_input_change)); + ic_connection = input_changed.connect (mem_fun (*_diskstream, &Diskstream::handle_input_change)); - diskstream_changed (src); /* EMIT SIGNAL */ + DiskstreamChanged (); /* EMIT SIGNAL */ return 0; } @@ -171,89 +192,55 @@ AudioTrack::set_diskstream (AudioDiskstream& ds, void *src) int AudioTrack::use_diskstream (string name) { - AudioDiskstream *dstream; + boost::shared_ptr dstream; - if ((dstream = dynamic_cast(_session.diskstream_by_name (name))) == 0) { - error << string_compose(_("AudioTrack: audio diskstream \"%1\" not known by session"), name) << endmsg; + 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); + return set_diskstream (dstream, this); } int AudioTrack::use_diskstream (const PBD::ID& id) { - AudioDiskstream *dstream; + boost::shared_ptr dstream; - if ((dstream = dynamic_cast(_session.diskstream_by_id (id))) == 0) { + 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); -} - -bool -AudioTrack::record_enabled () const -{ - return _diskstream->record_enabled (); + return set_diskstream (dstream, this); } -void -AudioTrack::set_record_enable (bool yn, void *src) +boost::shared_ptr +AudioTrack::audio_diskstream() const { - if (_freeze_record.state == Frozen) { - return; - } - - if (_mix_group && src != _mix_group && _mix_group->is_active()) { - _mix_group->apply (&AudioTrack::set_record_enable, yn, _mix_group); - return; - } - - /* keep track of the meter point as it was before we rec-enabled */ - - if (!_diskstream->record_enabled()) { - _saved_meter_point = _meter_point; - } - - _diskstream->set_record_enabled (yn, src); - - if (_diskstream->record_enabled()) { - set_meter_point (MeterInput, this); - } else { - set_meter_point (_saved_meter_point, this); - } - - _rec_enable_control.Changed (); + return boost::dynamic_pointer_cast(_diskstream); } -void -AudioTrack::set_meter_point (MeterPoint p, void *src) +int +AudioTrack::set_state (const XMLNode& node) { - Route::set_meter_point (p, src); + return _set_state (node, true); } int -AudioTrack::set_state (const XMLNode& node) +AudioTrack::_set_state (const XMLNode& node, bool call_base) { const XMLProperty *prop; XMLNodeConstIterator iter; - if (Route::set_state (node)) { - return -1; + if (call_base) { + if (Route::_set_state (node, call_base)) { + return -1; + } } if ((prop = node.property (X_("mode"))) != 0) { - if (prop->value() == X_("normal")) { - _mode = Normal; - } else if (prop->value() == X_("destructive")) { - _mode = Destructive; - } else { - warning << string_compose ("unknown audio track mode \"%1\" seen and ignored", prop->value()) << endmsg; - _mode = Normal; - } + _mode = TrackMode (string_2_enum (prop->value(), _mode)); } else { _mode = Normal; } @@ -290,12 +277,9 @@ AudioTrack::set_state (const XMLNode& node) for (niter = nlist.begin(); niter != nlist.end(); ++niter){ child = *niter; - if (child->name() == X_("remote_control")) { - if ((prop = child->property (X_("id"))) != 0) { - int32_t x; - sscanf (prop->value().c_str(), "%d", &x); - set_remote_control_id (x); - } + if (child->name() == X_("recenable")) { + _rec_enable_control->set_state (*child); + _session.add_controllable (_rec_enable_control); } } @@ -306,18 +290,6 @@ AudioTrack::set_state (const XMLNode& node) return 0; } -XMLNode& -AudioTrack::get_template () -{ - return state (false); -} - -XMLNode& -AudioTrack::get_state () -{ - return state (true); -} - XMLNode& AudioTrack::state(bool full_state) { @@ -330,12 +302,11 @@ AudioTrack::state(bool full_state) freeze_node = new XMLNode (X_("freeze-info")); freeze_node->add_property ("playlist", _freeze_record.playlist->name()); - snprintf (buf, sizeof (buf), "%d", (int) _freeze_record.state); - freeze_node->add_property ("state", buf); + 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")); - (*i)->id.print (buf); + 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); @@ -348,30 +319,11 @@ AudioTrack::state(bool full_state) /* Alignment: act as a proxy for the diskstream */ XMLNode* align_node = new XMLNode (X_("alignment")); - switch (_diskstream->alignment_style()) { - case ExistingMaterial: - snprintf (buf, sizeof (buf), X_("existing")); - break; - case CaptureTime: - snprintf (buf, sizeof (buf), X_("capture")); - break; - } - align_node->add_property (X_("style"), buf); + AlignStyle as = _diskstream->alignment_style (); + align_node->add_property (X_("style"), enum_2_string (as)); root.add_child_nocopy (*align_node); - XMLNode* remote_control_node = new XMLNode (X_("remote_control")); - snprintf (buf, sizeof (buf), "%d", _remote_control_id); - remote_control_node->add_property (X_("id"), buf); - root.add_child_nocopy (*remote_control_node); - - switch (_mode) { - case Normal: - root.add_property (X_("mode"), X_("normal")); - break; - case Destructive: - root.add_property (X_("mode"), X_("destructive")); - break; - } + 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 @@ -379,9 +331,11 @@ AudioTrack::state(bool full_state) diskstream. */ - _diskstream->id().print (buf); + _diskstream->id().print (buf, sizeof (buf)); root.add_property ("diskstream-id", buf); + root.add_child_nocopy (_rec_enable_control->get_state()); + return root; } @@ -406,31 +360,31 @@ AudioTrack::set_state_part_two () _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) { - Playlist* pl = _session.playlist_by_name (prop->value()); + boost::shared_ptr pl = _session.playlist_by_name (prop->value()); if (pl) { - _freeze_record.playlist = dynamic_cast (pl); + _freeze_record.playlist = boost::dynamic_pointer_cast (pl); } else { - _freeze_record.playlist = 0; + _freeze_record.playlist.reset (); _freeze_record.state = NoFreeze; return; } } if ((prop = fnode->property (X_("state"))) != 0) { - _freeze_record.state = (FreezeState) atoi (prop->value().c_str()); + _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; } @@ -438,10 +392,10 @@ AudioTrack::set_state_part_two () continue; } - FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo (*((*citer)->children().front())); - frii->insert = 0; + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()), + boost::shared_ptr()); frii->id = prop->value (); - _freeze_record.insert_info.push_back (frii); + _freeze_record.processor_info.push_back (frii); } } @@ -450,34 +404,31 @@ AudioTrack::set_state_part_two () if ((fnode = find_named_node (*pending_state, X_("alignment"))) != 0) { if ((prop = fnode->property (X_("style"))) != 0) { - if (prop->value() == "existing") { - _diskstream->set_persistent_align_style (ExistingMaterial); - } else if (prop->value() == "capture") { - _diskstream->set_persistent_align_style (CaptureTime); + + /* 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; } -uint32_t -AudioTrack::n_process_buffers () -{ - return max ((uint32_t) _diskstream->n_channels(), redirect_max_outs); -} - -void -AudioTrack::passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter) -{ - uint32_t nbufs = n_process_buffers (); - process_output_buffers (_session.get_silent_buffers (nbufs), nbufs, start_frame, end_frame, nframes, offset, true, declick, meter); -} - int -AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, +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) { - if (n_outputs() == 0) { + if (n_outputs().n_total() == 0) { return 0; } @@ -494,7 +445,7 @@ AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nf return 0; } - _diskstream->check_record_status (start_frame, nframes, can_record); + audio_diskstream()->check_record_status (start_frame, nframes, can_record); bool send_silence; @@ -506,15 +457,15 @@ AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nf send_silence = true; } else { - if (_session.get_auto_input()) { - if (Config->get_use_sw_monitoring()) { + 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_use_sw_monitoring()) { + if (Config->get_monitoring_model() == SoftwareMonitoring) { send_silence = false; } else { send_silence = true; @@ -554,24 +505,26 @@ AudioTrack::no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nf } int -AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, int declick, +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; - jack_nframes_t transport_frame; - + nframes_t transport_frame; + boost::shared_ptr diskstream = audio_diskstream(); + { - Glib::RWLock::ReaderLock lm (redirect_lock, Glib::TRY_LOCK); + 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); } } + - if (n_outputs() == 0 && _redirects.empty()) { + if (n_outputs().n_total() == 0 && _processors.empty()) { return 0; } @@ -587,13 +540,13 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram 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, 0, can_record, rec_monitors_input); } _silent = false; apply_gain_automation = false; - if ((dret = _diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) { + if ((dret = diskstream->process (transport_frame, nframes, offset, can_record, rec_monitors_input)) != 0) { silence (nframes, offset); @@ -606,7 +559,7 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram just_meter_input (start_frame, end_frame, nframes, offset); } - if (_diskstream->record_enabled() && !can_record && !_session.get_auto_input()) { + if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) { /* not actually recording, but we want to hear the input material anyway, at least potentially (depending on monitoring options) @@ -614,7 +567,7 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram passthru (start_frame, end_frame, nframes, offset, 0, true); - } else if ((b = _diskstream->playback_buffer(0)) != 0) { + } else if ((b = diskstream->playback_buffer(0)) != 0) { /* XXX is it true that the earlier test on n_outputs() @@ -627,17 +580,16 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram /* copy the diskstream data to all output buffers */ - vector& bufs = _session.get_passthru_buffers (); - uint32_t limit = n_process_buffers (); + const size_t limit = n_process_buffers().n_audio(); + BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers()); uint32_t n; uint32_t i; - for (i = 0, n = 1; i < limit; ++i, ++n) { - memcpy (bufs[i], b, sizeof (Sample) * nframes); - if (n < _diskstream->n_channels()) { - tmpb = _diskstream->playback_buffer(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; } @@ -646,15 +598,15 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram /* don't waste time with automation if we're recording or we've just stopped (yes it can happen) */ - if (!_diskstream->record_enabled() && _session.transport_rolling()) { - Glib::Mutex::Lock am (automation_lock, Glib::TRY_LOCK); + if (!diskstream->record_enabled() && _session.transport_rolling()) { + Glib::Mutex::Lock am (_automation_lock, Glib::TRY_LOCK); - if (am.locked() && gain_automation_playback()) { - apply_gain_automation = _gain_automation_curve.rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes); + if (am.locked() && gain_control()->list()->automation_playback()) { + apply_gain_automation = gain_control()->list()->curve().rt_safe_get_vector (start_frame, end_frame, _session.gain_automation_buffer(), nframes); } } - process_output_buffers (bufs, limit, start_frame, end_frame, nframes, offset, (!_session.get_record_enabled() || !_session.get_do_not_record_plugins()), declick, (_meter_point != MeterInput)); + 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 */ @@ -665,10 +617,10 @@ AudioTrack::roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nfram } int -AudioTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, jack_nframes_t offset, +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() == 0 && _redirects.empty()) { + if (n_outputs().n_total() == 0 && _processors.empty()) { return 0; } @@ -682,90 +634,61 @@ AudioTrack::silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jac silence (nframes, offset); - return _diskstream->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input); -} - -void -AudioTrack::toggle_monitor_input () -{ - for (vector::iterator i = _inputs.begin(); i != _inputs.end(); ++i) { - (*i)->request_monitor_input(!(*i)->monitoring_input()); - } + return audio_diskstream()->process (_session.transport_frame() + offset, nframes, offset, can_record, rec_monitors_input); } int -AudioTrack::set_name (string str, void *src) -{ - int ret; - - if (record_enabled() && _session.actively_recording()) { - /* this messes things up if done while recording */ - return -1; - } - - if (_diskstream->set_name (str, src)) { - return -1; - } - - /* save state so that the statefile fully reflects any filename changes */ - - if ((ret = IO::set_name (str, src)) == 0) { - _session.save_state (""); - } - return ret; -} - -int -AudioTrack::export_stuff (vector& buffers, char * workbuf, uint32_t nbufs, jack_nframes_t start, jack_nframes_t nframes) +AudioTrack::export_stuff (BufferSet& buffers, nframes_t start, nframes_t nframes) { gain_t gain_automation[nframes]; gain_t gain_buffer[nframes]; float mix_buffer[nframes]; - RedirectList::iterator i; + ProcessorList::iterator i; bool post_fader_work = false; gain_t this_gain = _gain; - vector::iterator bi; - Sample * b; + boost::shared_ptr diskstream = audio_diskstream(); - Glib::RWLock::ReaderLock rlock (redirect_lock); + Glib::RWLock::ReaderLock rlock (_processor_lock); - // FIXME - AudioPlaylist* const apl = dynamic_cast(_diskstream->playlist()); + boost::shared_ptr apl = boost::dynamic_pointer_cast(diskstream->playlist()); assert(apl); - if (apl->read (buffers[0], mix_buffer, gain_buffer, workbuf, start, nframes) != nframes) { + assert(buffers.get_audio(0).capacity() >= nframes); + + if (apl->read (buffers.get_audio(0).data(), mix_buffer, gain_buffer, start, nframes) != nframes) { return -1; } + assert(buffers.count().n_audio() >= 1); uint32_t n=1; - bi = buffers.begin(); - b = buffers[0]; + Sample* b = buffers.get_audio(0).data(); + BufferSet::audio_iterator bi = buffers.audio_begin(); ++bi; - for (; bi != buffers.end(); ++bi, ++n) { - if (n < _diskstream->n_channels()) { - if (apl->read ((*bi), mix_buffer, gain_buffer, workbuf, start, nframes, n) != nframes) { + 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) { return -1; } - b = (*bi); + b = bi->data(); } else { /* duplicate last across remaining buffers */ - memcpy ((*bi), 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. + /* note: only run processors during export. other layers in the machinery + will already have checked that there are no external port processors. */ - for (i = _redirects.begin(); i != _redirects.end(); ++i) { - Insert *insert; + for (i = _processors.begin(); i != _processors.end(); ++i) { + boost::shared_ptr processor; - if ((insert = dynamic_cast(*i)) != 0) { - switch (insert->placement()) { + if ((processor = boost::dynamic_pointer_cast(*i)) != 0) { + switch (processor->placement()) { case PreFader: - insert->run (buffers, nbufs, nframes, 0); + processor->run_in_place (buffers, start, start+nframes, nframes, 0); break; case PostFader: post_fader_work = true; @@ -774,22 +697,22 @@ AudioTrack::export_stuff (vector& buffers, char * workbuf, uint32_t nbu } } - if (_gain_automation_curve.automation_state() == Play) { + if (gain_control()->list()->automation_state() == Play) { - _gain_automation_curve.get_vector (start, start + nframes, gain_automation, nframes); + gain_control()->list()->curve().get_vector (start, start + nframes, gain_automation, nframes); - for (bi = buffers.begin(); bi != buffers.end(); ++bi) { - Sample *b = *bi; - for (jack_nframes_t n = 0; n < nframes; ++n) { + 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]; } } } else { - for (bi = buffers.begin(); bi != buffers.end(); ++bi) { - Sample *b = *bi; - for (jack_nframes_t n = 0; n < nframes; ++n) { + 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; } } @@ -797,15 +720,15 @@ AudioTrack::export_stuff (vector& buffers, char * workbuf, uint32_t nbu if (post_fader_work) { - for (i = _redirects.begin(); i != _redirects.end(); ++i) { - PluginInsert *insert; + for (i = _processors.begin(); i != _processors.end(); ++i) { + boost::shared_ptr processor; - if ((insert = dynamic_cast(*i)) != 0) { + if ((processor = boost::dynamic_pointer_cast(*i)) != 0) { switch ((*i)->placement()) { case PreFader: break; case PostFader: - insert->run (buffers, nbufs, nframes, 0); + processor->run_in_place (buffers, start, start+nframes, nframes, 0); break; } } @@ -815,56 +738,34 @@ AudioTrack::export_stuff (vector& buffers, char * workbuf, uint32_t nbu return 0; } -void -AudioTrack::set_latency_delay (jack_nframes_t longest_session_latency) -{ - Route::set_latency_delay (longest_session_latency); - _diskstream->set_roll_delay (_roll_delay); -} - -jack_nframes_t -AudioTrack::update_total_latency () -{ - _own_latency = 0; - - for (RedirectList::iterator i = _redirects.begin(); i != _redirects.end(); ++i) { - if ((*i)->active ()) { - _own_latency += (*i)->latency (); - } - } - - set_port_latency (_own_latency); - - return _own_latency; -} - void AudioTrack::bounce (InterThreadInfo& itt) { - vector srcs; + vector > srcs; _session.write_one_audio_track (*this, 0, _session.current_end_frame(), false, srcs, itt); + itt.done = true; } void -AudioTrack::bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo& itt) +AudioTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt) { - vector srcs; + vector > srcs; _session.write_one_audio_track (*this, start, end, false, srcs, itt); + itt.done = true; } void AudioTrack::freeze (InterThreadInfo& itt) { - Insert* insert; - vector srcs; + vector > srcs; string new_playlist_name; - Playlist* new_playlist; + boost::shared_ptr new_playlist; string dir; - AudioRegion* region; string region_name; + boost::shared_ptr diskstream = audio_diskstream(); - if ((_freeze_record.playlist = dynamic_cast(_diskstream->playlist())) == 0) { + if ((_freeze_record.playlist = boost::dynamic_pointer_cast(diskstream->playlist())) == 0) { return; } @@ -886,58 +787,59 @@ AudioTrack::freeze (InterThreadInfo& itt) } if (n == (UINT_MAX-1)) { - error << string_compose (X_("There Are too many frozen versions of playlist \"%1\"" + error << string_compose (X_("There are too many frozen versions of playlist \"%1\"" " to create another one"), _freeze_record.playlist->name()) << endmsg; return; } - if (_session.write_one_audio_track (*this, 0, _session.current_end_frame(), true, srcs, itt)) { + if (_session.write_one_audio_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt)) { return; } - _freeze_record.insert_info.clear (); + _freeze_record.processor_info.clear (); _freeze_record.have_mementos = true; { - Glib::RWLock::ReaderLock lm (redirect_lock); + Glib::RWLock::ReaderLock lm (_processor_lock); - for (RedirectList::iterator r = _redirects.begin(); r != _redirects.end(); ++r) { + for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) { - if ((insert = dynamic_cast(*r)) != 0) { - - FreezeRecordInsertInfo* frii = new FreezeRecordInsertInfo ((*r)->get_state()); + boost::shared_ptr processor; + + if ((processor = boost::dynamic_pointer_cast(*r)) != 0) { - frii->insert = insert; - frii->id = insert->id(); - frii->memento = (*r)->get_memento(); + FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), processor); - _freeze_record.insert_info.push_back (frii); + frii->id = processor->id(); + + _freeze_record.processor_info.push_back (frii); - /* now deactivate the insert */ + /* now deactivate the processor */ - insert->set_active (false, this); + processor->set_active (false); + _session.set_dirty (); } } } - new_playlist = new AudioPlaylist (_session, new_playlist_name, false); + new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false); region_name = new_playlist_name; /* create a new region from all filesources, keep it private */ - region = new AudioRegion (srcs, 0, srcs[0]->length(), - region_name, 0, - (AudioRegion::Flag) (AudioRegion::WholeFile|AudioRegion::DefaultFlags), - false); + boost::shared_ptr region (RegionFactory::create (srcs, 0, srcs[0]->length(), + region_name, 0, + (Region::Flag) (Region::WholeFile|Region::DefaultFlags), + false)); - new_playlist->set_orig_diskstream_id (_diskstream->id()); - new_playlist->add_region (*region, 0); + 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); - _diskstream->use_playlist (dynamic_cast(new_playlist)); - _diskstream->set_record_enabled (false, this); + diskstream->use_playlist (boost::dynamic_pointer_cast(new_playlist)); + diskstream->set_record_enabled (false); _freeze_record.state = Frozen; FreezeChange(); /* EMIT SIGNAL */ @@ -947,19 +849,19 @@ void AudioTrack::unfreeze () { if (_freeze_record.playlist) { - _diskstream->use_playlist (_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) { + for (vector::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) { (*i)->memento (); } } else { - Glib::RWLock::ReaderLock lm (redirect_lock); // should this be a write lock? jlc - for (RedirectList::iterator i = _redirects.begin(); i != _redirects.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)); break; @@ -968,53 +870,10 @@ AudioTrack::unfreeze () } } - _freeze_record.playlist = 0; + _freeze_record.playlist.reset (); } _freeze_record.state = UnFrozen; FreezeChange (); /* EMIT SIGNAL */ } -AudioTrack::FreezeRecord::~FreezeRecord () -{ - for (vector::iterator i = insert_info.begin(); i != insert_info.end(); ++i) { - delete *i; - } -} - -AudioTrack::FreezeState -AudioTrack::freeze_state() const -{ - return _freeze_record.state; -} - -AudioTrack::RecEnableControllable::RecEnableControllable (AudioTrack& s) - : track (s) -{ -} - -void -AudioTrack::RecEnableControllable::set_value (float val) -{ - bool bval = ((val >= 0.5f) ? true: false); - track.set_record_enable (bval, this); -} - -float -AudioTrack::RecEnableControllable::get_value (void) const -{ - if (track.record_enabled()) { return 1.0f; } - return 0.0f; -} - -void -AudioTrack::set_mode (TrackMode m) -{ - if (_diskstream) { - if (_mode != m) { - _mode = m; - _diskstream->set_destructive (m == Destructive); - ModeChanged(); - } - } -}