2 Copyright (C) 2000-2006 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.
31 #include "pbd/error.h"
32 #include "pbd/xml++.h"
33 #include "pbd/memento_command.h"
34 #include "pbd/enumwriter.h"
35 #include "pbd/stateful_diff_command.h"
37 #include "ardour/analyser.h"
38 #include "ardour/audio_buffer.h"
39 #include "ardour/audio_diskstream.h"
40 #include "ardour/audio_port.h"
41 #include "ardour/audioengine.h"
42 #include "ardour/audiofilesource.h"
43 #include "ardour/audioplaylist.h"
44 #include "ardour/audioregion.h"
45 #include "ardour/butler.h"
46 #include "ardour/debug.h"
47 #include "ardour/io.h"
48 #include "ardour/playlist_factory.h"
49 #include "ardour/region_factory.h"
50 #include "ardour/session.h"
51 #include "ardour/session_playlists.h"
52 #include "ardour/source_factory.h"
53 #include "ardour/track.h"
54 #include "ardour/types.h"
55 #include "ardour/utils.h"
61 using namespace ARDOUR;
64 size_t AudioDiskstream::_working_buffers_size = 0;
65 Sample* AudioDiskstream::_mixdown_buffer = 0;
66 gain_t* AudioDiskstream::_gain_buffer = 0;
68 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
69 : Diskstream(sess, name, flag)
70 , channels (new ChannelList)
72 /* prevent any write sources from being created */
79 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
80 : Diskstream(sess, node)
81 , channels (new ChannelList)
86 if (set_state (node, Stateful::loading_state_version)) {
88 throw failed_constructor();
94 use_destructive_playlist ();
99 AudioDiskstream::init ()
101 /* there are no channels at this point, so these
102 two calls just get speed_buffer_size and wrap_buffer
103 size setup without duplicating their code.
106 set_block_size (_session.get_block_size());
107 allocate_temporary_buffers ();
110 AudioDiskstream::~AudioDiskstream ()
112 DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
115 RCUWriter<ChannelList> writer (channels);
116 boost::shared_ptr<ChannelList> c = writer.get_copy();
118 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
129 AudioDiskstream::allocate_working_buffers()
131 assert(disk_io_frames() > 0);
133 _working_buffers_size = disk_io_frames();
134 _mixdown_buffer = new Sample[_working_buffers_size];
135 _gain_buffer = new gain_t[_working_buffers_size];
139 AudioDiskstream::free_working_buffers()
141 delete [] _mixdown_buffer;
142 delete [] _gain_buffer;
143 _working_buffers_size = 0;
149 AudioDiskstream::non_realtime_input_change ()
151 bool need_write_sources = false;
154 Glib::Threads::Mutex::Lock lm (state_lock);
156 if (input_change_pending.type == IOChange::NoChange) {
160 boost::shared_ptr<ChannelList> cr = channels.reader();
161 if (!cr->empty() && !cr->front()->write_source) {
162 need_write_sources = true;
165 if (input_change_pending.type == IOChange::ConfigurationChanged) {
166 RCUWriter<ChannelList> writer (channels);
167 boost::shared_ptr<ChannelList> c = writer.get_copy();
169 _n_channels.set(DataType::AUDIO, c->size());
171 if (_io->n_ports().n_audio() > _n_channels.n_audio()) {
172 add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
173 } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
174 remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
177 need_write_sources = true;
180 if (input_change_pending.type & IOChange::ConnectionsChanged) {
181 get_input_sources ();
182 set_capture_offset ();
183 set_align_style_from_io ();
186 input_change_pending = IOChange::NoChange;
188 /* implicit unlock */
191 if (need_write_sources) {
192 reset_write_sources (false);
195 /* now refill channel buffers */
197 if (speed() != 1.0f || speed() != -1.0f) {
198 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
200 seek (_session.transport_frame());
205 AudioDiskstream::non_realtime_locate (framepos_t location)
207 /* now refill channel buffers */
209 if (speed() != 1.0f || speed() != -1.0f) {
210 seek ((framepos_t) (location * (double) speed()));
217 AudioDiskstream::get_input_sources ()
219 boost::shared_ptr<ChannelList> c = channels.reader();
222 ChannelList::iterator chan;
223 uint32_t ni = _io->n_ports().n_audio();
224 vector<string> connections;
226 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
228 connections.clear ();
230 if (_io->nth (n)->get_connections (connections) == 0) {
231 if (!(*chan)->source.name.empty()) {
232 // _source->disable_metering ();
234 (*chan)->source.name = string();
236 (*chan)->source.name = connections[0];
242 AudioDiskstream::find_and_use_playlist (const string& name)
244 boost::shared_ptr<AudioPlaylist> playlist;
246 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) == 0) {
247 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
251 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
255 return use_playlist (playlist);
259 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
261 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
263 Diskstream::use_playlist(playlist);
269 AudioDiskstream::use_new_playlist ()
272 boost::shared_ptr<AudioPlaylist> playlist;
274 if (!in_set_state && destructive()) {
279 newname = Playlist::bump_name (_playlist->name(), _session);
281 newname = Playlist::bump_name (_name, _session);
284 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
286 return use_playlist (playlist);
294 AudioDiskstream::use_copy_playlist ()
296 assert(audio_playlist());
302 if (_playlist == 0) {
303 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
308 boost::shared_ptr<AudioPlaylist> playlist;
310 newname = Playlist::bump_name (_playlist->name(), _session);
312 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
313 return use_playlist (playlist);
320 AudioDiskstream::setup_destructive_playlist ()
323 boost::shared_ptr<ChannelList> c = channels.reader();
325 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
326 srcs.push_back ((*chan)->write_source);
329 /* a single full-sized region */
331 assert (!srcs.empty ());
334 plist.add (Properties::name, _name.val());
335 plist.add (Properties::start, 0);
336 plist.add (Properties::length, max_framepos - (max_framepos - srcs.front()->natural_position()));
338 boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
339 _playlist->add_region (region, srcs.front()->natural_position());
343 AudioDiskstream::use_destructive_playlist ()
345 /* this is called from the XML-based constructor or ::set_destructive. when called,
346 we already have a playlist and a region, but we need to
347 set up our sources for write. we use the sources associated
348 with the (presumed single, full-extent) region.
351 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
354 reset_write_sources (false, true);
358 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
361 throw failed_constructor();
364 /* be sure to stretch the region out to the maximum length */
366 region->set_length (max_framepos - region->position());
369 ChannelList::iterator chan;
370 boost::shared_ptr<ChannelList> c = channels.reader();
372 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
373 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
374 assert((*chan)->write_source);
375 (*chan)->write_source->set_allow_remove_if_empty (false);
377 /* this might be false if we switched modes, so force it */
379 (*chan)->write_source->set_destructive (true);
382 /* the source list will never be reset for a destructive track */
386 AudioDiskstream::prepare_record_status(framepos_t capture_start_frame)
388 if (recordable() && destructive()) {
389 boost::shared_ptr<ChannelList> c = channels.reader();
390 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
392 RingBufferNPT<CaptureTransition>::rw_vector transitions;
393 (*chan)->capture_transition_buf->get_write_vector (&transitions);
395 if (transitions.len[0] > 0) {
396 transitions.buf[0]->type = CaptureStart;
397 transitions.buf[0]->capture_val = capture_start_frame;
398 (*chan)->capture_transition_buf->increment_write_ptr(1);
401 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
409 /** Do some record stuff [not described in this comment!]
412 * - Setup playback_distance with the nframes, or nframes adjusted
413 * for current varispeed, if appropriate.
414 * - Setup current_playback_buffer in each ChannelInfo to point to data
415 * that someone can read playback_distance worth of data from.
418 AudioDiskstream::process (BufferSet& bufs, framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance, bool need_disk_signal)
421 boost::shared_ptr<ChannelList> c = channels.reader();
422 ChannelList::iterator chan;
423 framecnt_t rec_offset = 0;
424 framecnt_t rec_nframes = 0;
425 bool collect_playback = false;
426 bool can_record = _session.actively_recording ();
428 playback_distance = 0;
430 if (!_io || !_io->active()) {
434 check_record_status (transport_frame, can_record);
440 Glib::Threads::Mutex::Lock sm (state_lock, Glib::Threads::TRY_LOCK);
446 adjust_capture_position = 0;
448 for (chan = c->begin(); chan != c->end(); ++chan) {
449 (*chan)->current_capture_buffer = 0;
450 (*chan)->current_playback_buffer = 0;
453 // Safeguard against situations where process() goes haywire when autopunching
454 // and last_recordable_frame < first_recordable_frame
456 if (last_recordable_frame < first_recordable_frame) {
457 last_recordable_frame = max_framepos;
460 if (record_enabled()) {
462 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
463 // XXX should this be transport_frame + nframes - 1 ? coverage() expects its parameter ranges to include their end points
464 // XXX also, first_recordable_frame & last_recordable_frame may both be == max_framepos: coverage() will return OverlapNone in that case. Is thak OK?
465 calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
467 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: this time record %2 of %3 frames, offset %4\n", _name, rec_nframes, nframes, rec_offset));
469 if (rec_nframes && !was_recording) {
470 capture_captured = 0;
471 was_recording = true;
475 if (can_record && !_last_capture_sources.empty()) {
476 _last_capture_sources.clear ();
481 uint32_t limit = _io->n_ports ().n_audio();
483 /* one or more ports could already have been removed from _io, but our
484 channel setup hasn't yet been updated. prevent us from trying to
485 use channels that correspond to missing ports. note that the
486 process callback (from which this is called) is always atomic
487 with respect to port removal/addition.
490 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
492 ChannelInfo* chaninfo (*chan);
494 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
496 if (rec_nframes <= (framecnt_t) chaninfo->capture_vector.len[0]) {
498 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
500 /* note: grab the entire port buffer, but only copy what we were supposed to
501 for recording, and use rec_offset
504 boost::shared_ptr<AudioPort> const ap = _io->audio (n);
506 assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());
508 Sample *buf = bufs.get_audio (n).data(rec_offset);
509 memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes);
513 framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
515 if (rec_nframes > total) {
516 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
517 DEBUG_THREAD_SELF, name(), rec_nframes, total));
522 boost::shared_ptr<AudioPort> const ap = _io->audio (n);
525 Sample *buf = bufs.get_audio (n).data(rec_offset);
526 framecnt_t first = chaninfo->capture_vector.len[0];
528 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
529 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
530 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
531 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
533 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
547 /* data will be written to disk */
549 if (rec_nframes == nframes && rec_offset == 0) {
551 for (chan = c->begin(); chan != c->end(); ++chan) {
552 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
555 playback_distance = nframes;
560 /* we can't use the capture buffer as the playback buffer, because
561 we recorded only a part of the current process' cycle data
565 collect_playback = true;
568 adjust_capture_position = rec_nframes;
570 } else if (can_record && record_enabled()) {
572 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
574 for (chan = c->begin(); chan != c->end(); ++chan) {
575 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
578 playback_distance = nframes;
582 collect_playback = true;
585 if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) {
587 /* we're doing playback */
589 framecnt_t necessary_samples;
591 /* no varispeed playback if we're recording, because the output .... TBD */
593 if (rec_nframes == 0 && _actual_speed != 1.0f) {
594 necessary_samples = (framecnt_t) ceil ((nframes * fabs (_actual_speed))) + 2;
596 necessary_samples = nframes;
599 for (chan = c->begin(); chan != c->end(); ++chan) {
600 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
605 /* Setup current_playback_buffer in each ChannelInfo to point to data that someone
606 can read necessary_samples (== nframes at a transport speed of 1) worth of data
610 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
612 ChannelInfo* chaninfo (*chan);
614 if (necessary_samples <= (framecnt_t) chaninfo->playback_vector.len[0]) {
615 /* There are enough samples in the first part of the ringbuffer */
616 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
619 framecnt_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
621 if (necessary_samples > total) {
622 cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
623 cerr << "underrun for " << _name << endl;
624 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 underrun in %2, rec_nframes = %3 total space = %4\n",
625 DEBUG_THREAD_SELF, name(), rec_nframes, total));
631 /* We have enough samples, but not in one lump. Coalesce the two parts
632 into one in playback_wrap_buffer in our ChannelInfo, and specify that
633 as our current_playback_buffer.
636 assert(wrap_buffer_size >= necessary_samples);
638 /* Copy buf[0] from playback_buf */
639 memcpy ((char *) chaninfo->playback_wrap_buffer,
640 chaninfo->playback_vector.buf[0],
641 chaninfo->playback_vector.len[0] * sizeof (Sample));
643 /* Copy buf[1] from playback_buf */
644 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
645 chaninfo->playback_vector.buf[1],
646 (necessary_samples - chaninfo->playback_vector.len[0])
649 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
654 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
656 interpolation.set_speed (_target_speed);
659 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
660 ChannelInfo* chaninfo (*chan);
662 playback_distance = interpolation.interpolate (
663 channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
665 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
669 playback_distance = nframes;
672 _speed = _target_speed;
675 if (need_disk_signal) {
677 /* copy data over to buffer set */
679 size_t n_buffers = bufs.count().n_audio();
680 size_t n_chans = c->size();
681 gain_t scaling = 1.0f;
683 if (n_chans > n_buffers) {
684 scaling = ((float) n_buffers)/n_chans;
687 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
689 AudioBuffer& buf (bufs.get_audio (n%n_buffers));
690 ChannelInfo* chaninfo (*chan);
693 if (scaling != 1.0f) {
694 buf.read_from_with_gain (chaninfo->current_playback_buffer, nframes, scaling);
696 buf.read_from (chaninfo->current_playback_buffer, nframes);
699 if (scaling != 1.0f) {
700 buf.accumulate_with_gain_from (chaninfo->current_playback_buffer, nframes, scaling);
702 buf.accumulate_from (chaninfo->current_playback_buffer, nframes);
707 /* leave the MIDI count alone */
708 ChanCount cnt (DataType::AUDIO, n_chans);
709 cnt.set (DataType::MIDI, bufs.count().n_midi());
710 bufs.set_count (cnt);
712 /* extra buffers will already be silent, so leave them alone */
719 AudioDiskstream::calculate_playback_distance (pframes_t nframes)
721 frameoffset_t playback_distance = nframes;
723 if (record_enabled()) {
724 playback_distance = nframes;
725 } else if (_actual_speed != 1.0f && _actual_speed != -1.0f) {
726 interpolation.set_speed (_target_speed);
727 boost::shared_ptr<ChannelList> c = channels.reader();
729 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++channel) {
730 playback_distance = interpolation.interpolate (channel, nframes, NULL, NULL);
733 playback_distance = nframes;
736 if (_actual_speed < 0.0) {
737 return -playback_distance;
739 return playback_distance;
743 /** Update various things including playback_sample, read pointer on each channel's playback_buf
744 * and write pointer on each channel's capture_buf. Also wout whether the butler is needed.
745 * @return true if the butler is required.
748 AudioDiskstream::commit (framecnt_t playback_distance)
750 bool need_butler = false;
752 if (!_io || !_io->active()) {
756 if (_actual_speed < 0.0) {
757 playback_sample -= playback_distance;
759 playback_sample += playback_distance;
762 boost::shared_ptr<ChannelList> c = channels.reader();
763 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
765 (*chan)->playback_buf->increment_read_ptr (playback_distance);
767 if (adjust_capture_position) {
768 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
772 if (adjust_capture_position != 0) {
773 capture_captured += adjust_capture_position;
774 adjust_capture_position = 0;
782 if (_io && _io->active()) {
783 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
788 if (_io && _io->active()) {
789 need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_io_chunk_frames)
790 || ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
792 need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
800 AudioDiskstream::set_pending_overwrite (bool yn)
802 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
804 _pending_overwrite = yn;
806 overwrite_frame = playback_sample;
808 boost::shared_ptr<ChannelList> c = channels.reader ();
810 overwrite_offset = c->front()->playback_buf->get_read_ptr();
815 AudioDiskstream::overwrite_existing_buffers ()
817 boost::shared_ptr<ChannelList> c = channels.reader();
819 _pending_overwrite = false;
823 Sample* mixdown_buffer;
826 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
828 overwrite_queued = false;
830 /* assume all are the same size */
831 framecnt_t size = c->front()->playback_buf->bufsize();
833 mixdown_buffer = new Sample[size];
834 gain_buffer = new float[size];
836 /* reduce size so that we can fill the buffer correctly (ringbuffers
837 can only handle size-1, otherwise they appear to be empty)
844 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
846 start = overwrite_frame;
847 framecnt_t cnt = size;
849 /* to fill the buffer without resetting the playback sample, we need to
850 do it one or two chunks (normally two).
852 |----------------------------------------------------------------------|
856 |<- second chunk->||<----------------- first chunk ------------------>|
860 framecnt_t to_read = size - overwrite_offset;
862 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, n, reversed)) {
863 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
864 id(), size, playback_sample) << endmsg;
872 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, start, cnt, n, reversed)) {
873 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
874 id(), size, playback_sample) << endmsg;
883 _pending_overwrite = false;
884 delete [] gain_buffer;
885 delete [] mixdown_buffer;
890 AudioDiskstream::seek (framepos_t frame, bool complete_refill)
894 ChannelList::iterator chan;
895 boost::shared_ptr<ChannelList> c = channels.reader();
897 Glib::Threads::Mutex::Lock lm (state_lock);
899 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
900 (*chan)->playback_buf->reset ();
901 (*chan)->capture_buf->reset ();
904 /* can't rec-enable in destructive mode if transport is before start */
906 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
907 disengage_record_enable ();
910 playback_sample = frame;
913 if (complete_refill) {
914 while ((ret = do_refill_with_alloc ()) > 0) ;
916 ret = do_refill_with_alloc ();
923 AudioDiskstream::can_internal_playback_seek (framecnt_t distance)
925 ChannelList::iterator chan;
926 boost::shared_ptr<ChannelList> c = channels.reader();
928 for (chan = c->begin(); chan != c->end(); ++chan) {
929 if ((*chan)->playback_buf->read_space() < (size_t) distance) {
937 AudioDiskstream::internal_playback_seek (framecnt_t distance)
939 ChannelList::iterator chan;
940 boost::shared_ptr<ChannelList> c = channels.reader();
942 for (chan = c->begin(); chan != c->end(); ++chan) {
943 (*chan)->playback_buf->increment_read_ptr (llabs(distance));
946 if (first_recordable_frame < max_framepos) {
947 first_recordable_frame += distance;
949 playback_sample += distance;
954 /** Read some data for 1 channel from our playlist into a buffer.
955 * @param buf Buffer to write to.
956 * @param start Session frame to start reading from; updated to where we end up
958 * @param cnt Count of samples to read.
959 * @param reversed true if we are running backwards, otherwise false.
962 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
963 framepos_t& start, framecnt_t cnt,
964 int channel, bool reversed)
966 framecnt_t this_read = 0;
968 framepos_t loop_end = 0;
969 framepos_t loop_start = 0;
970 framecnt_t offset = 0;
973 /* XXX we don't currently play loops in reverse. not sure why */
977 framecnt_t loop_length = 0;
979 /* Make the use of a Location atomic for this read operation.
981 Note: Locations don't get deleted, so all we care about
982 when I say "atomic" is that we are always pointing to
983 the same one and using a start/length values obtained
987 if ((loc = loop_location) != 0) {
988 loop_start = loc->start();
989 loop_end = loc->end();
990 loop_length = loop_end - loop_start;
993 /* if we are looping, ensure that the first frame we read is at the correct
994 position within the loop.
997 if (loc && start >= loop_end) {
998 start = loop_start + ((start - loop_start) % loop_length);
1006 /* We need this while loop in case we hit a loop boundary, in which case our read from
1007 the playlist must be split into more than one section.
1012 /* take any loop into account. we can't read past the end of the loop. */
1014 if (loc && (loop_end - start < cnt)) {
1015 this_read = loop_end - start;
1022 if (this_read == 0) {
1026 this_read = min(cnt,this_read);
1028 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1029 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), id(), this_read,
1036 swap_by_ptr (buf, buf + this_read - 1);
1040 /* if we read to the end of the loop, go back to the beginning */
1050 offset += this_read;
1057 AudioDiskstream::do_refill_with_alloc ()
1059 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1060 float* gain_buf = new float[disk_io_chunk_frames];
1062 int ret = _do_refill(mix_buf, gain_buf);
1070 /** Get some more data from disk and put it in our channels' playback_bufs,
1071 * if there is suitable space in them.
1074 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1078 RingBufferNPT<Sample>::rw_vector vector;
1079 bool const reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1080 framecnt_t total_space;
1081 framecnt_t zero_fill;
1083 ChannelList::iterator i;
1084 boost::shared_ptr<ChannelList> c = channels.reader();
1091 assert(mixdown_buffer);
1092 assert(gain_buffer);
1099 c->front()->playback_buf->get_write_vector (&vector);
1101 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1102 /* nowhere to write to */
1106 /* if there are 2+ chunks of disk i/o possible for
1107 this track, let the caller know so that it can arrange
1108 for us to be called again, ASAP.
1111 if (total_space >= (_slaved ? 3 : 2) * disk_io_chunk_frames) {
1115 /* if we're running close to normal speed and there isn't enough
1116 space to do disk_io_chunk_frames of I/O, then don't bother.
1118 at higher speeds, just do it because the sync between butler
1119 and audio thread may not be good enough.
1121 Note: it is a design assumption that disk_io_chunk_frames is smaller
1122 than the playback buffer size, so this check should never trip when
1123 the playback buffer is empty.
1126 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1130 /* when slaved, don't try to get too close to the read pointer. this
1131 leaves space for the buffer reversal to have something useful to
1135 if (_slaved && total_space < (framecnt_t) (c->front()->playback_buf->bufsize() / 2)) {
1139 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1141 total_space = min (disk_io_chunk_frames, total_space);
1145 if (file_frame == 0) {
1147 /* at start: nothing to do but fill with silence */
1149 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1151 ChannelInfo* chan (*i);
1152 chan->playback_buf->get_write_vector (&vector);
1153 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1154 if (vector.len[1]) {
1155 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1157 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1162 if (file_frame < total_space) {
1164 /* too close to the start: read what we can,
1165 and then zero fill the rest
1168 zero_fill = total_space - file_frame;
1169 total_space = file_frame;
1178 if (file_frame == max_framepos) {
1180 /* at end: nothing to do but fill with silence */
1182 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1184 ChannelInfo* chan (*i);
1185 chan->playback_buf->get_write_vector (&vector);
1186 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1187 if (vector.len[1]) {
1188 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1190 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1195 if (file_frame > max_framepos - total_space) {
1197 /* to close to the end: read what we can, and zero fill the rest */
1199 zero_fill = total_space - (max_framepos - file_frame);
1200 total_space = max_framepos - file_frame;
1207 framepos_t file_frame_tmp = 0;
1209 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1211 ChannelInfo* chan (*i);
1214 framecnt_t len1, len2;
1216 chan->playback_buf->get_write_vector (&vector);
1218 if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) {
1220 /* we're not going to fill the first chunk, so certainly do not bother with the
1221 other part. it won't be connected with the part we do fill, as in:
1223 .... => writable space
1224 ++++ => readable space
1225 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1227 |......|+++++++++++++|...............................|
1232 So, just pretend that the buf1 part isn't there.
1242 file_frame_tmp = file_frame;
1244 buf1 = vector.buf[0];
1245 len1 = vector.len[0];
1246 buf2 = vector.buf[1];
1247 len2 = vector.len[1];
1249 to_read = min (ts, len1);
1250 to_read = min (to_read, disk_io_chunk_frames);
1252 assert (to_read >= 0);
1256 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1261 chan->playback_buf->increment_write_ptr (to_read);
1265 to_read = min (ts, len2);
1269 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1270 so read some or all of vector.len[1] as well.
1273 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1278 chan->playback_buf->increment_write_ptr (to_read);
1282 /* XXX: do something */
1287 file_frame = file_frame_tmp;
1288 assert (file_frame >= 0);
1295 /** Flush pending data to disk.
1297 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1298 * of data to disk. it will never write more than that. If it writes that
1299 * much and there is more than that waiting to be written, it will return 1,
1300 * otherwise 0 on success or -1 on failure.
1302 * If there is less than disk_io_chunk_frames to be written, no data will be
1303 * written at all unless @a force_flush is true.
1306 AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
1310 RingBufferNPT<Sample>::rw_vector vector;
1311 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1314 transvec.buf[0] = 0;
1315 transvec.buf[1] = 0;
1319 boost::shared_ptr<ChannelList> c = channels.reader();
1320 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1322 (*chan)->capture_buf->get_read_vector (&vector);
1324 total = vector.len[0] + vector.len[1];
1326 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1330 /* if there are 2+ chunks of disk i/o possible for
1331 this track, let the caller know so that it can arrange
1332 for us to be called again, ASAP.
1334 if we are forcing a flush, then if there is* any* extra
1335 work, let the caller know.
1337 if we are no longer recording and there is any extra work,
1338 let the caller know too.
1341 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1345 to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
1347 // check the transition buffer when recording destructive
1348 // important that we get this after the capture buf
1350 if (destructive()) {
1351 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1352 size_t transcount = transvec.len[0] + transvec.len[1];
1355 for (ti=0; ti < transcount; ++ti) {
1356 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1358 if (captrans.type == CaptureStart) {
1359 // by definition, the first data we got above represents the given capture pos
1361 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1362 (*chan)->curr_capture_cnt = 0;
1364 } else if (captrans.type == CaptureEnd) {
1366 // capture end, the capture_val represents total frames in capture
1368 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1370 // shorten to make the write a perfect fit
1371 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1373 if (nto_write < to_write) {
1374 ret = 1; // should we?
1376 to_write = nto_write;
1378 (*chan)->write_source->mark_capture_end ();
1380 // increment past this transition, but go no further
1385 // actually ends just beyond this chunk, so force more work
1393 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1397 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1398 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1402 (*chan)->capture_buf->increment_read_ptr (to_write);
1403 (*chan)->curr_capture_cnt += to_write;
1405 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1407 /* we wrote all of vector.len[0] but it wasn't an entire
1408 disk_io_chunk_frames of data, so arrange for some part
1409 of vector.len[1] to be flushed to disk as well.
1412 to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1414 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 additional write of %2\n", name(), to_write));
1416 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1417 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1421 (*chan)->capture_buf->increment_read_ptr (to_write);
1422 (*chan)->curr_capture_cnt += to_write;
1431 AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1433 uint32_t buffer_position;
1434 bool more_work = true;
1436 boost::shared_ptr<AudioRegion> region;
1437 framecnt_t total_capture;
1439 SourceList::iterator src;
1440 ChannelList::iterator chan;
1441 vector<CaptureInfo*>::iterator ci;
1442 boost::shared_ptr<ChannelList> c = channels.reader();
1444 bool mark_write_completed = false;
1448 /* butler is already stopped, but there may be work to do
1449 to flush remaining data to disk.
1452 while (more_work && !err) {
1453 switch (do_flush (TransportContext, true)) {
1460 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1465 /* XXX is there anything we can do if err != 0 ? */
1466 Glib::Threads::Mutex::Lock lm (capture_info_lock);
1468 if (capture_info.empty()) {
1472 if (abort_capture) {
1474 if (destructive()) {
1478 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1480 if ((*chan)->write_source) {
1482 (*chan)->write_source->mark_for_remove ();
1483 (*chan)->write_source->drop_references ();
1484 (*chan)->write_source.reset ();
1487 /* new source set up in "out" below */
1493 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1494 total_capture += (*ci)->frames;
1497 /* figure out the name for this take */
1499 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1501 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1505 s->update_header (capture_info.front()->start, when, twhen);
1506 s->set_captured_for (_name.val());
1507 s->mark_immutable ();
1509 if (Config->get_auto_analyse_audio()) {
1510 Analyser::queue_source_for_analysis (s, true);
1515 /* destructive tracks have a single, never changing region */
1517 if (destructive()) {
1519 /* send a signal that any UI can pick up to do the right thing. there is
1520 a small problem here in that a UI may need the peak data to be ready
1521 for the data that was recorded and this isn't interlocked with that
1522 process. this problem is deferred to the UI.
1525 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1529 string whole_file_region_name;
1530 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1532 /* Register a new region with the Session that
1533 describes the entire source. Do this first
1534 so that any sub-regions will obviously be
1535 children of this one (later!)
1541 plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1542 plist.add (Properties::length, total_capture);
1543 plist.add (Properties::name, whole_file_region_name);
1544 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1545 rx->set_automatic (true);
1546 rx->set_whole_file (true);
1548 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1549 region->special_set_position (capture_info.front()->start);
1553 catch (failed_constructor& err) {
1554 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1558 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1560 _playlist->clear_changes ();
1561 _playlist->set_capture_insertion_in_progress (true);
1562 _playlist->freeze ();
1564 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1568 RegionFactory::region_name (region_name, whole_file_region_name, false);
1570 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1571 _name, (*ci)->start, (*ci)->frames, region_name));
1577 plist.add (Properties::start, buffer_position);
1578 plist.add (Properties::length, (*ci)->frames);
1579 plist.add (Properties::name, region_name);
1581 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1582 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1585 catch (failed_constructor& err) {
1586 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1587 continue; /* XXX is this OK? */
1590 i_am_the_modifier++;
1592 _playlist->add_region (region, (*ci)->start, 1, non_layered());
1593 _playlist->set_layer (region, DBL_MAX);
1594 i_am_the_modifier--;
1596 buffer_position += (*ci)->frames;
1600 _playlist->set_capture_insertion_in_progress (false);
1601 _session.add_command (new StatefulDiffCommand (_playlist));
1604 mark_write_completed = true;
1607 reset_write_sources (mark_write_completed);
1611 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1615 capture_info.clear ();
1616 capture_start_frame = 0;
1620 AudioDiskstream::transport_looped (framepos_t transport_frame)
1622 if (was_recording) {
1623 // all we need to do is finish this capture, with modified capture length
1624 boost::shared_ptr<ChannelList> c = channels.reader();
1626 // adjust the capture length knowing that the data will be recorded to disk
1627 // only necessary after the first loop where we're recording
1628 if (capture_info.size() == 0) {
1629 capture_captured += _capture_offset;
1631 if (_alignment_style == ExistingMaterial) {
1632 capture_captured += _session.worst_output_latency();
1634 capture_captured += _roll_delay;
1640 // the next region will start recording via the normal mechanism
1641 // we'll set the start position to the current transport pos
1642 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1643 capture_start_frame = transport_frame;
1644 first_recordable_frame = transport_frame; // mild lie
1645 last_recordable_frame = max_framepos;
1646 was_recording = true;
1648 if (recordable() && destructive()) {
1649 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1651 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1652 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1654 if (transvec.len[0] > 0) {
1655 transvec.buf[0]->type = CaptureStart;
1656 transvec.buf[0]->capture_val = capture_start_frame;
1657 (*chan)->capture_transition_buf->increment_write_ptr(1);
1661 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1671 AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
1673 was_recording = false;
1674 first_recordable_frame = max_framepos;
1675 last_recordable_frame = max_framepos;
1677 if (capture_captured == 0) {
1681 if (recordable() && destructive()) {
1682 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1684 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1685 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1687 if (transvec.len[0] > 0) {
1688 transvec.buf[0]->type = CaptureEnd;
1689 transvec.buf[0]->capture_val = capture_captured;
1690 (*chan)->capture_transition_buf->increment_write_ptr(1);
1694 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1700 CaptureInfo* ci = new CaptureInfo;
1702 ci->start = capture_start_frame;
1703 ci->frames = capture_captured;
1705 /* XXX theoretical race condition here. Need atomic exchange ?
1706 However, the circumstances when this is called right
1707 now (either on record-disable or transport_stopped)
1708 mean that no actual race exists. I think ...
1709 We now have a capture_info_lock, but it is only to be used
1710 to synchronize in the transport_stop and the capture info
1711 accessors, so that invalidation will not occur (both non-realtime).
1714 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->frames));
1716 capture_info.push_back (ci);
1717 capture_captured = 0;
1719 /* now we've finished a capture, reset first_recordable_frame for next time */
1720 first_recordable_frame = max_framepos;
1724 AudioDiskstream::set_record_enabled (bool yn)
1726 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1730 /* can't rec-enable in destructive mode if transport is before start */
1732 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1736 /* yes, i know that this not proof against race conditions, but its
1737 good enough. i think.
1740 if (record_enabled() != yn) {
1742 engage_record_enable ();
1744 disengage_record_enable ();
1747 RecordEnableChanged (); /* EMIT SIGNAL */
1752 AudioDiskstream::prep_record_enable ()
1754 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1758 /* can't rec-enable in destructive mode if transport is before start */
1760 if (destructive() && _session.transport_frame() < _session.current_start_frame()) {
1764 bool rolling = _session.transport_speed() != 0.0f;
1765 boost::shared_ptr<ChannelList> c = channels.reader();
1767 capturing_sources.clear ();
1769 if (Config->get_monitoring_model() == HardwareMonitoring) {
1771 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1772 (*chan)->source.request_input_monitoring (!(_session.config.get_auto_input() && rolling));
1773 capturing_sources.push_back ((*chan)->write_source);
1774 Source::Lock lock((*chan)->write_source->mutex());
1775 (*chan)->write_source->mark_streaming_write_started (lock);
1779 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1780 capturing_sources.push_back ((*chan)->write_source);
1781 Source::Lock lock((*chan)->write_source->mutex());
1782 (*chan)->write_source->mark_streaming_write_started (lock);
1790 AudioDiskstream::prep_record_disable ()
1792 boost::shared_ptr<ChannelList> c = channels.reader();
1793 if (Config->get_monitoring_model() == HardwareMonitoring) {
1794 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1795 (*chan)->source.request_input_monitoring (false);
1798 capturing_sources.clear ();
1804 AudioDiskstream::get_state ()
1806 XMLNode& node (Diskstream::get_state());
1808 LocaleGuard lg (X_("POSIX"));
1810 boost::shared_ptr<ChannelList> c = channels.reader();
1811 snprintf (buf, sizeof(buf), "%u", (unsigned int) c->size());
1812 node.add_property ("channels", buf);
1814 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1816 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1817 XMLNode* cs_grandchild;
1819 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1820 cs_grandchild = new XMLNode (X_("file"));
1821 cs_grandchild->add_property (X_("path"), (*i)->path());
1822 cs_child->add_child_nocopy (*cs_grandchild);
1825 /* store the location where capture will start */
1829 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1830 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1832 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1835 cs_child->add_property (X_("at"), buf);
1836 node.add_child_nocopy (*cs_child);
1843 AudioDiskstream::set_state (const XMLNode& node, int version)
1845 const XMLProperty* prop;
1846 XMLNodeList nlist = node.children();
1847 XMLNodeIterator niter;
1848 uint32_t nchans = 1;
1849 XMLNode* capture_pending_node = 0;
1850 LocaleGuard lg (X_("POSIX"));
1852 /* prevent write sources from being created */
1854 in_set_state = true;
1856 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1857 if ((*niter)->name() == IO::state_node_name) {
1858 deprecated_io_node = new XMLNode (**niter);
1861 if ((*niter)->name() == X_("CapturingSources")) {
1862 capture_pending_node = *niter;
1866 if (Diskstream::set_state (node, version)) {
1870 if ((prop = node.property ("channels")) != 0) {
1871 nchans = atoi (prop->value().c_str());
1874 // create necessary extra channels
1875 // we are always constructed with one and we always need one
1877 _n_channels.set(DataType::AUDIO, channels.reader()->size());
1879 if (nchans > _n_channels.n_audio()) {
1881 add_channel (nchans - _n_channels.n_audio());
1882 IO::PortCountChanged(_n_channels);
1884 } else if (nchans < _n_channels.n_audio()) {
1886 remove_channel (_n_channels.n_audio() - nchans);
1891 if (!destructive() && capture_pending_node) {
1892 /* destructive streams have one and only one source per channel,
1893 and so they never end up in pending capture in any useful
1896 use_pending_capture_data (*capture_pending_node);
1899 in_set_state = false;
1901 /* make sure this is clear before we do anything else */
1903 capturing_sources.clear ();
1905 /* write sources are handled when we handle the input set
1906 up of the IO that owns this DS (::non_realtime_input_change())
1913 AudioDiskstream::use_new_write_source (uint32_t n)
1915 boost::shared_ptr<ChannelList> c = channels.reader();
1917 if (!recordable()) {
1921 if (n >= c->size()) {
1922 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1926 ChannelInfo* chan = (*c)[n];
1929 if ((chan->write_source = _session.create_audio_source_for_session (
1930 n_channels().n_audio(), write_source_name(), n, destructive())) == 0) {
1931 throw failed_constructor();
1935 catch (failed_constructor &err) {
1936 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1937 chan->write_source.reset ();
1941 /* do not remove destructive files even if they are empty */
1943 chan->write_source->set_allow_remove_if_empty (!destructive());
1949 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1951 ChannelList::iterator chan;
1952 boost::shared_ptr<ChannelList> c = channels.reader();
1955 if (!_session.writable() || !recordable()) {
1959 capturing_sources.clear ();
1961 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1963 if (!destructive()) {
1965 if ((*chan)->write_source) {
1967 if (mark_write_complete) {
1968 Source::Lock lock((*chan)->write_source->mutex());
1969 (*chan)->write_source->mark_streaming_write_completed (lock);
1970 (*chan)->write_source->done_with_peakfile_writes ();
1973 if ((*chan)->write_source->removable()) {
1974 (*chan)->write_source->mark_for_remove ();
1975 (*chan)->write_source->drop_references ();
1978 (*chan)->write_source.reset ();
1981 use_new_write_source (n);
1983 if (record_enabled()) {
1984 capturing_sources.push_back ((*chan)->write_source);
1989 if ((*chan)->write_source == 0) {
1990 use_new_write_source (n);
1995 if (destructive() && !c->empty ()) {
1997 /* we now have all our write sources set up, so create the
1998 playlist's single region.
2001 if (_playlist->empty()) {
2002 setup_destructive_playlist ();
2008 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
2010 if (_session.get_block_size() > speed_buffer_size) {
2011 speed_buffer_size = _session.get_block_size();
2012 boost::shared_ptr<ChannelList> c = channels.reader();
2014 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2015 if ((*chan)->speed_buffer)
2016 delete [] (*chan)->speed_buffer;
2017 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2020 allocate_temporary_buffers ();
2024 AudioDiskstream::allocate_temporary_buffers ()
2026 /* make sure the wrap buffer is at least large enough to deal
2027 with the speeds up to 1.2, to allow for micro-variation
2028 when slaving to MTC, Timecode etc.
2031 double const sp = max (fabsf (_actual_speed), 1.2f);
2032 framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * sp) + 2;
2034 if (required_wrap_size > wrap_buffer_size) {
2036 boost::shared_ptr<ChannelList> c = channels.reader();
2038 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2039 if ((*chan)->playback_wrap_buffer) {
2040 delete [] (*chan)->playback_wrap_buffer;
2042 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2043 if ((*chan)->capture_wrap_buffer) {
2044 delete [] (*chan)->capture_wrap_buffer;
2046 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2049 wrap_buffer_size = required_wrap_size;
2054 AudioDiskstream::request_input_monitoring (bool yn)
2056 boost::shared_ptr<ChannelList> c = channels.reader();
2058 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2059 (*chan)->source.request_input_monitoring (yn);
2064 AudioDiskstream::set_align_style_from_io ()
2066 bool have_physical = false;
2068 if (_alignment_choice != Automatic) {
2076 get_input_sources ();
2078 boost::shared_ptr<ChannelList> c = channels.reader();
2080 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2081 if ((*chan)->source.is_physical ()) {
2082 have_physical = true;
2087 if (have_physical) {
2088 set_align_style (ExistingMaterial);
2090 set_align_style (CaptureTime);
2095 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2097 while (how_many--) {
2098 c->push_back (new ChannelInfo(
2099 _session.butler()->audio_diskstream_playback_buffer_size(),
2100 _session.butler()->audio_diskstream_capture_buffer_size(),
2101 speed_buffer_size, wrap_buffer_size));
2102 interpolation.add_channel_to (
2103 _session.butler()->audio_diskstream_playback_buffer_size(),
2107 _n_channels.set(DataType::AUDIO, c->size());
2113 AudioDiskstream::add_channel (uint32_t how_many)
2115 RCUWriter<ChannelList> writer (channels);
2116 boost::shared_ptr<ChannelList> c = writer.get_copy();
2118 return add_channel_to (c, how_many);
2122 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2124 while (how_many-- && !c->empty()) {
2127 interpolation.remove_channel_from ();
2130 _n_channels.set(DataType::AUDIO, c->size());
2136 AudioDiskstream::remove_channel (uint32_t how_many)
2138 RCUWriter<ChannelList> writer (channels);
2139 boost::shared_ptr<ChannelList> c = writer.get_copy();
2141 return remove_channel_from (c, how_many);
2145 AudioDiskstream::playback_buffer_load () const
2147 boost::shared_ptr<ChannelList> c = channels.reader();
2153 return (float) ((double) c->front()->playback_buf->read_space()/
2154 (double) c->front()->playback_buf->bufsize());
2158 AudioDiskstream::capture_buffer_load () const
2160 boost::shared_ptr<ChannelList> c = channels.reader();
2166 return (float) ((double) c->front()->capture_buf->write_space()/
2167 (double) c->front()->capture_buf->bufsize());
2171 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2173 const XMLProperty* prop;
2174 XMLNodeList nlist = node.children();
2175 XMLNodeIterator niter;
2176 boost::shared_ptr<AudioFileSource> fs;
2177 boost::shared_ptr<AudioFileSource> first_fs;
2178 SourceList pending_sources;
2179 framepos_t position;
2181 if ((prop = node.property (X_("at"))) == 0) {
2185 if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2189 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2190 if ((*niter)->name() == X_("file")) {
2192 if ((prop = (*niter)->property (X_("path"))) == 0) {
2196 // This protects sessions from errant CapturingSources in stored sessions
2198 if (stat (prop->value().c_str(), &sbuf)) {
2202 /* XXX as of June 2014, we always record to mono
2203 files. Since this Source is being created as part of
2204 crash recovery, we know that we need the first
2205 channel (the final argument to the SourceFactory
2206 call below). If we ever support non-mono files for
2207 capture, this will need rethinking.
2211 fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createForRecovery (DataType::AUDIO, _session, prop->value(), 0));
2214 catch (failed_constructor& err) {
2215 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2216 _name, prop->value())
2221 pending_sources.push_back (fs);
2223 if (first_fs == 0) {
2227 fs->set_captured_for (_name.val());
2231 if (pending_sources.size() == 0) {
2232 /* nothing can be done */
2236 if (pending_sources.size() != _n_channels.n_audio()) {
2237 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2244 boost::shared_ptr<AudioRegion> wf_region;
2245 boost::shared_ptr<AudioRegion> region;
2247 /* First create the whole file region */
2251 plist.add (Properties::start, 0);
2252 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2253 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2255 wf_region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2257 wf_region->set_automatic (true);
2258 wf_region->set_whole_file (true);
2259 wf_region->special_set_position (position);
2261 /* Now create a region that isn't the whole file for adding to
2264 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2266 _playlist->add_region (region, position);
2269 catch (failed_constructor& err) {
2270 error << string_compose (
2271 _("%1: cannot create whole-file region from pending capture sources"),
2282 AudioDiskstream::set_non_layered (bool yn)
2284 if (yn != non_layered()) {
2287 _flags = Flag (_flags | NonLayered);
2289 _flags = Flag (_flags & ~NonLayered);
2297 AudioDiskstream::set_destructive (bool yn)
2299 if (yn != destructive()) {
2302 bool bounce_ignored;
2303 /* requestor should already have checked this and
2304 bounced if necessary and desired
2306 if (!can_become_destructive (bounce_ignored)) {
2309 _flags = Flag (_flags | Destructive);
2310 use_destructive_playlist ();
2312 _flags = Flag (_flags & ~Destructive);
2313 reset_write_sources (true, true);
2321 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2324 requires_bounce = false;
2328 /* is there only one region ? */
2330 if (_playlist->n_regions() != 1) {
2331 requires_bounce = true;
2335 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2337 requires_bounce = false;
2341 /* do the source(s) for the region cover the session start position ? */
2343 if (first->position() != _session.current_start_frame()) {
2344 if (first->start() > _session.current_start_frame()) {
2345 requires_bounce = true;
2350 /* is the source used by only 1 playlist ? */
2352 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2356 if (_session.playlists->source_use_count (afirst->source()) > 1) {
2357 requires_bounce = true;
2361 requires_bounce = false;
2366 AudioDiskstream::adjust_playback_buffering ()
2368 boost::shared_ptr<ChannelList> c = channels.reader();
2370 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2371 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2376 AudioDiskstream::adjust_capture_buffering ()
2378 boost::shared_ptr<ChannelList> c = channels.reader();
2380 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2381 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2386 AudioDiskstream::ChannelSource::is_physical () const
2392 return AudioEngine::instance()->port_is_physical (name);
2396 AudioDiskstream::ChannelSource::request_input_monitoring (bool yn) const
2402 return AudioEngine::instance()->request_input_monitoring (name, yn);
2405 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2407 current_capture_buffer = 0;
2408 current_playback_buffer = 0;
2409 curr_capture_cnt = 0;
2411 speed_buffer = new Sample[speed_size];
2412 playback_wrap_buffer = new Sample[wrap_size];
2413 capture_wrap_buffer = new Sample[wrap_size];
2415 playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2416 capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2417 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2419 /* touch the ringbuffer buffers, which will cause
2420 them to be mapped into locked physical RAM if
2421 we're running with mlockall(). this doesn't do
2425 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2426 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2427 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2431 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2433 delete playback_buf;
2434 playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2435 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2439 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2443 capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2444 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2447 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2449 write_source.reset ();
2451 delete [] speed_buffer;
2454 delete [] playback_wrap_buffer;
2455 playback_wrap_buffer = 0;
2457 delete [] capture_wrap_buffer;
2458 capture_wrap_buffer = 0;
2460 delete playback_buf;
2466 delete capture_transition_buf;
2467 capture_transition_buf = 0;
2472 AudioDiskstream::set_name (string const & name)
2474 if (_name == name) {
2477 Diskstream::set_name (name);
2479 /* get a new write source so that its name reflects the new diskstream name */
2481 boost::shared_ptr<ChannelList> c = channels.reader();
2482 ChannelList::iterator i;
2485 for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2486 use_new_write_source (n);
2493 AudioDiskstream::set_write_source_name (const std::string& str) {
2494 if (_write_source_name == str) {
2498 Diskstream::set_write_source_name (str);
2500 if (_write_source_name == name()) {
2503 boost::shared_ptr<ChannelList> c = channels.reader();
2504 ChannelList::iterator i;
2507 for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2508 use_new_write_source (n);