2 Copyright (C) 2002 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #include <boost/scoped_array.hpp>
22 #include "pbd/error.h"
23 #include "pbd/enumwriter.h"
24 #include "pbd/boost_debug.h"
26 #include "evoral/Curve.hpp"
28 #include "ardour/amp.h"
29 #include "ardour/audio_buffer.h"
30 #include "ardour/audio_diskstream.h"
31 #include "ardour/audio_track.h"
32 #include "ardour/audioplaylist.h"
33 #include "ardour/audioregion.h"
34 #include "ardour/audiosource.h"
35 #include "ardour/buffer_set.h"
36 #include "ardour/io_processor.h"
37 #include "ardour/panner.h"
38 #include "ardour/meter.h"
39 #include "ardour/playlist_factory.h"
40 #include "ardour/plugin_insert.h"
41 #include "ardour/processor.h"
42 #include "ardour/region_factory.h"
43 #include "ardour/route_group_specialized.h"
44 #include "ardour/session.h"
45 #include "ardour/utils.h"
46 #include "ardour/session_playlists.h"
47 #include "ardour/delivery.h"
48 #include "ardour/meter.h"
52 using namespace ARDOUR;
55 AudioTrack::AudioTrack (Session& sess, string name, Route::Flag flag, TrackMode mode)
56 : Track (sess, name, flag, mode)
60 AudioTrack::~AudioTrack ()
64 boost::shared_ptr<Diskstream>
65 AudioTrack::create_diskstream ()
67 AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
69 if (_flags & Hidden) {
70 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden);
72 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable);
75 if (_mode == Destructive) {
76 dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive);
77 } else if (_mode == NonLayered){
78 dflags = AudioDiskstream::Flag(dflags | AudioDiskstream::NonLayered);
81 return boost::shared_ptr<AudioDiskstream> (new AudioDiskstream (_session, name(), dflags));
85 AudioTrack::set_diskstream (boost::shared_ptr<Diskstream> ds)
87 Track::set_diskstream (ds);
89 _diskstream->set_track (this);
90 _diskstream->set_destructive (_mode == Destructive);
91 _diskstream->set_non_layered (_mode == NonLayered);
93 if (audio_diskstream()->deprecated_io_node) {
95 if (!IO::connecting_legal) {
96 IO::ConnectingLegal.connect_same_thread (*this, boost::bind (&AudioTrack::deprecated_use_diskstream_connections, this));
98 deprecated_use_diskstream_connections ();
102 _diskstream->set_record_enabled (false);
103 _diskstream->request_jack_monitors_input (false);
105 DiskstreamChanged (); /* EMIT SIGNAL */
108 boost::shared_ptr<AudioDiskstream>
109 AudioTrack::audio_diskstream() const
111 return boost::dynamic_pointer_cast<AudioDiskstream>(_diskstream);
115 AudioTrack::set_mode (TrackMode m)
119 if (_diskstream->set_destructive (m == Destructive)) {
123 _diskstream->set_non_layered (m == NonLayered);
126 TrackModeChanged (); /* EMIT SIGNAL */
133 AudioTrack::can_use_mode (TrackMode m, bool& bounce_required)
138 bounce_required = false;
143 return _diskstream->can_become_destructive (bounce_required);
148 AudioTrack::deprecated_use_diskstream_connections ()
150 boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
152 if (diskstream->deprecated_io_node == 0) {
156 const XMLProperty* prop;
157 XMLNode& node (*diskstream->deprecated_io_node);
159 /* don't do this more than once. */
161 diskstream->deprecated_io_node = 0;
163 if ((prop = node.property ("gain")) != 0) {
164 _amp->set_gain (atof (prop->value().c_str()), this);
167 if ((prop = node.property ("input-connection")) != 0) {
168 boost::shared_ptr<Bundle> c = _session.bundle_by_name (prop->value());
171 error << string_compose(_("Unknown bundle \"%1\" listed for input of %2"), prop->value(), _name) << endmsg;
173 if ((c = _session.bundle_by_name (_("in 1"))) == 0) {
174 error << _("No input bundles available as a replacement")
178 info << string_compose (_("Bundle %1 was not available - \"in 1\" used instead"), prop->value())
183 _input->connect_ports_to_bundle (c, this);
185 } else if ((prop = node.property ("inputs")) != 0) {
186 if (_input->set_ports (prop->value())) {
187 error << string_compose(_("improper input channel list in XML node (%1)"), prop->value()) << endmsg;
196 AudioTrack::set_state (const XMLNode& node, int version)
198 const XMLProperty *prop;
200 if (Track::set_state (node, version)) {
204 if ((prop = node.property (X_("mode"))) != 0) {
205 _mode = TrackMode (string_2_enum (prop->value(), _mode));
210 pending_state = const_cast<XMLNode*> (&node);
212 if (_session.state_of_the_state() & Session::Loading) {
213 _session.StateReady.connect_same_thread (*this, boost::bind (&AudioTrack::set_state_part_two, this));
215 set_state_part_two ();
222 AudioTrack::state (bool full_state)
224 XMLNode& root (Track::state(full_state));
225 XMLNode* freeze_node;
228 if (_freeze_record.playlist) {
231 freeze_node = new XMLNode (X_("freeze-info"));
232 freeze_node->add_property ("playlist", _freeze_record.playlist->name());
233 freeze_node->add_property ("state", enum_2_string (_freeze_record.state));
235 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
236 inode = new XMLNode (X_("processor"));
237 (*i)->id.print (buf, sizeof (buf));
238 inode->add_property (X_("id"), buf);
239 inode->add_child_copy ((*i)->state);
241 freeze_node->add_child_nocopy (*inode);
244 root.add_child_nocopy (*freeze_node);
247 root.add_property (X_("mode"), enum_2_string (_mode));
253 AudioTrack::set_state_part_two ()
257 LocaleGuard lg (X_("POSIX"));
259 /* This is called after all session state has been restored but before
260 have been made ports and connections are established.
263 if (pending_state == 0) {
267 if ((fnode = find_named_node (*pending_state, X_("freeze-info"))) != 0) {
269 _freeze_record.state = Frozen;
271 for (vector<FreezeRecordProcessorInfo*>::iterator i = _freeze_record.processor_info.begin(); i != _freeze_record.processor_info.end(); ++i) {
274 _freeze_record.processor_info.clear ();
276 if ((prop = fnode->property (X_("playlist"))) != 0) {
277 boost::shared_ptr<Playlist> pl = _session.playlists->by_name (prop->value());
279 _freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist> (pl);
281 _freeze_record.playlist.reset ();
282 _freeze_record.state = NoFreeze;
287 if ((prop = fnode->property (X_("state"))) != 0) {
288 _freeze_record.state = FreezeState (string_2_enum (prop->value(), _freeze_record.state));
291 XMLNodeConstIterator citer;
292 XMLNodeList clist = fnode->children();
294 for (citer = clist.begin(); citer != clist.end(); ++citer) {
295 if ((*citer)->name() != X_("processor")) {
299 if ((prop = (*citer)->property (X_("id"))) == 0) {
303 FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo (*((*citer)->children().front()),
304 boost::shared_ptr<Processor>());
305 frii->id = prop->value ();
306 _freeze_record.processor_info.push_back (frii);
312 AudioTrack::roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame, int declick, bool& need_butler)
314 Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
322 framepos_t transport_frame;
323 boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
325 automation_snapshot (start_frame, false);
327 if (n_outputs().n_total() == 0 && _processors.empty()) {
336 transport_frame = _session.transport_frame();
339 framecnt_t playback_distance;
341 if ((nframes = check_initial_delay (nframes, transport_frame)) == 0) {
343 /* need to do this so that the diskstream sets its
344 playback distance to zero, thus causing diskstream::commit
348 dret = diskstream->process (transport_frame, 0, playback_distance);
349 need_butler = diskstream->commit (playback_distance);
354 _amp->apply_gain_automation(false);
356 if ((dret = diskstream->process (transport_frame, nframes, playback_distance)) != 0) {
357 need_butler = diskstream->commit (playback_distance);
362 /* special condition applies */
364 if (_meter_point == MeterInput) {
365 _input->process_input (_meter, start_frame, end_frame, nframes);
368 if (monitoring_state() == MonitoringInput) {
370 passthru (start_frame, end_frame, nframes, false);
372 } else if ((b = diskstream->playback_buffer(0)) != 0) {
375 XXX is it true that the earlier test on n_outputs()
376 means that we can avoid checking it again here? i think
377 so, because changing the i/o configuration of an IO
378 requires holding the AudioEngine lock, which we hold
379 while in the process() tree.
383 /* copy the diskstream data to all output buffers */
385 size_t limit = input_streams ().n_audio();
386 BufferSet& bufs = _session.get_scratch_buffers ();
387 const size_t blimit = bufs.count().n_audio();
392 if (limit > blimit) {
394 /* example case: auditioner configured for stereo output,
395 but loaded with an 8 channel file. there are only
396 2 passthrough buffers, but n_process_buffers() will
399 arbitrary decision: map all channels in the diskstream
400 to the outputs available.
403 float scaling = limit/blimit;
405 for (i = 0, n = 1; i < blimit; ++i, ++n) {
407 /* first time through just copy a channel into
411 Sample* bb = bufs.get_audio (i).data();
413 for (pframes_t xx = 0; xx < nframes; ++xx) {
414 bb[xx] = b[xx] * scaling;
417 if (n < diskstream->n_channels().n_audio()) {
418 tmpb = diskstream->playback_buffer(n);
425 for (;i < limit; ++i, ++n) {
427 /* for all remaining channels, sum with existing
428 data in the output buffers
431 bufs.get_audio (i%blimit).accumulate_with_gain_from (b, nframes, 0, scaling);
433 if (n < diskstream->n_channels().n_audio()) {
434 tmpb = diskstream->playback_buffer(n);
445 for (i = 0, n = 1; i < limit; ++i, ++n) {
446 memcpy (bufs.get_audio (i).data(), b, sizeof (Sample) * nframes);
447 if (n < diskstream->n_channels().n_audio()) {
448 tmpb = diskstream->playback_buffer(n);
455 /* try to leave any MIDI buffers alone */
458 chn.set_audio (limit);
459 chn.set_midi (_input->n_ports().n_midi());
460 bufs.set_count (chn);
463 /* final argument: don't waste time with automation if we're recording or we've just stopped (yes it can happen) */
465 process_output_buffers (
466 bufs, start_frame, end_frame, nframes,
468 (!diskstream->record_enabled() && _session.transport_rolling())
472 /* problem with the diskstream; just be quiet for a bit */
476 need_butler = diskstream->commit (playback_distance);
482 AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes, bool enable_processing)
484 boost::scoped_array<gain_t> gain_buffer (new gain_t[nframes]);
485 boost::scoped_array<Sample> mix_buffer (new Sample[nframes]);
486 boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
488 Glib::RWLock::ReaderLock rlock (_processor_lock);
490 boost::shared_ptr<AudioPlaylist> apl = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist());
493 assert(buffers.count().n_audio() >= 1);
494 assert ((framecnt_t) buffers.get_audio(0).capacity() >= nframes);
496 if (apl->read (buffers.get_audio(0).data(), mix_buffer.get(), gain_buffer.get(), start, nframes) != nframes) {
501 Sample* b = buffers.get_audio(0).data();
502 BufferSet::audio_iterator bi = buffers.audio_begin();
504 for ( ; bi != buffers.audio_end(); ++bi, ++n) {
505 if (n < diskstream->n_channels().n_audio()) {
506 if (apl->read (bi->data(), mix_buffer.get(), gain_buffer.get(), start, nframes, n) != nframes) {
511 /* duplicate last across remaining buffers */
512 memcpy (bi->data(), b, sizeof (Sample) * nframes);
516 // If no processing is required, there's no need to go any further.
517 if (!enable_processing) {
521 /* note: only run processors during export. other layers in the machinery
522 will already have checked that there are no external port processors.
523 Also, don't run deliveries that write to real output ports, and don't
527 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
528 boost::shared_ptr<Processor> processor = boost::dynamic_pointer_cast<Processor> (*i);
529 boost::shared_ptr<Delivery> delivery = boost::dynamic_pointer_cast<Delivery> (*i);
530 boost::shared_ptr<PeakMeter> meter = boost::dynamic_pointer_cast<PeakMeter> (*i);
532 if (processor && (!delivery || !Delivery::role_requires_output_ports (delivery->role())) && !meter) {
533 processor->run (buffers, start, start+nframes, nframes, true);
540 boost::shared_ptr<Region>
541 AudioTrack::bounce (InterThreadInfo& itt)
543 vector<boost::shared_ptr<Source> > srcs;
544 return _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), false, srcs, itt);
547 boost::shared_ptr<Region>
548 AudioTrack::bounce_range (framepos_t start, framepos_t end, InterThreadInfo& itt, bool enable_processing)
550 vector<boost::shared_ptr<Source> > srcs;
551 return _session.write_one_track (*this, start, end, false, srcs, itt, enable_processing);
555 AudioTrack::freeze_me (InterThreadInfo& itt)
557 vector<boost::shared_ptr<Source> > srcs;
558 string new_playlist_name;
559 boost::shared_ptr<Playlist> new_playlist;
562 boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
564 if ((_freeze_record.playlist = boost::dynamic_pointer_cast<AudioPlaylist>(diskstream->playlist())) == 0) {
570 while (n < (UINT_MAX-1)) {
574 candidate = string_compose ("<F%2>%1", _freeze_record.playlist->name(), n);
576 if (_session.playlists->by_name (candidate) == 0) {
577 new_playlist_name = candidate;
585 if (n == (UINT_MAX-1)) {
586 error << string_compose (X_("There are too many frozen versions of playlist \"%1\""
587 " to create another one"), _freeze_record.playlist->name())
592 boost::shared_ptr<Region> res;
594 if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt)) == 0) {
598 _freeze_record.processor_info.clear ();
601 Glib::RWLock::ReaderLock lm (_processor_lock);
603 for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
605 boost::shared_ptr<Processor> processor;
607 if ((processor = boost::dynamic_pointer_cast<Processor>(*r)) != 0) {
609 FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), processor);
611 frii->id = processor->id();
613 _freeze_record.processor_info.push_back (frii);
615 /* now deactivate the processor */
617 processor->deactivate ();
618 _session.set_dirty ();
623 new_playlist = PlaylistFactory::create (DataType::AUDIO, _session, new_playlist_name, false);
625 /* XXX need main outs automation state _freeze_record.pan_automation_state = _mainpanner->automation_state(); */
627 region_name = new_playlist_name;
629 /* create a new region from all filesources, keep it private */
633 plist.add (Properties::start, 0);
634 plist.add (Properties::length, srcs[0]->length(srcs[0]->timeline_position()));
635 plist.add (Properties::name, region_name);
636 plist.add (Properties::whole_file, true);
638 boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist, false));
640 new_playlist->set_orig_track_id (id());
641 new_playlist->add_region (region, _session.current_start_frame());
642 new_playlist->set_frozen (true);
643 region->set_locked (true);
645 diskstream->use_playlist (boost::dynamic_pointer_cast<AudioPlaylist>(new_playlist));
646 diskstream->set_record_enabled (false);
648 /* reset stuff that has already been accounted for in the freeze process */
650 set_gain (1.0, this);
651 _amp->gain_control()->set_automation_state (Off);
652 /* XXX need to use _main_outs _panner->set_automation_state (Off); */
654 _freeze_record.state = Frozen;
655 FreezeChange(); /* EMIT SIGNAL */
659 AudioTrack::unfreeze ()
661 if (_freeze_record.playlist) {
662 audio_diskstream()->use_playlist (_freeze_record.playlist);
665 Glib::RWLock::ReaderLock lm (_processor_lock); // should this be a write lock? jlc
666 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
667 for (vector<FreezeRecordProcessorInfo*>::iterator ii = _freeze_record.processor_info.begin(); ii != _freeze_record.processor_info.end(); ++ii) {
668 if ((*ii)->id == (*i)->id()) {
669 (*i)->set_state (((*ii)->state), Stateful::current_state_version);
676 _freeze_record.playlist.reset ();
677 /* XXX need to use _main_outs _panner->set_automation_state (_freeze_record.pan_automation_state); */
680 _freeze_record.state = UnFrozen;
681 FreezeChange (); /* EMIT SIGNAL */
684 boost::shared_ptr<AudioFileSource>
685 AudioTrack::write_source (uint32_t n)
687 boost::shared_ptr<AudioDiskstream> ds = boost::dynamic_pointer_cast<AudioDiskstream> (_diskstream);
689 return ds->write_source (n);
693 AudioTrack::bounceable () const
695 return n_inputs().n_audio() >= n_outputs().n_audio();
698 boost::shared_ptr<Diskstream>
699 AudioTrack::diskstream_factory (XMLNode const & node)
701 return boost::shared_ptr<Diskstream> (new AudioDiskstream (_session, node));