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.
33 #include "pbd/error.h"
34 #include "pbd/xml++.h"
35 #include "pbd/memento_command.h"
36 #include "pbd/enumwriter.h"
37 #include "pbd/stateful_diff_command.h"
39 #include "ardour/analyser.h"
40 #include "ardour/ardour.h"
41 #include "ardour/audio_buffer.h"
42 #include "ardour/audio_diskstream.h"
43 #include "ardour/audio_port.h"
44 #include "ardour/audioengine.h"
45 #include "ardour/audiofilesource.h"
47 #include "ardour/audioplaylist.h"
48 #include "ardour/audioregion.h"
49 #include "ardour/butler.h"
50 #include "ardour/configuration.h"
51 #include "ardour/cycle_timer.h"
52 #include "ardour/debug.h"
53 #include "ardour/io.h"
54 #include "ardour/playlist_factory.h"
55 #include "ardour/region_factory.h"
56 #include "ardour/send.h"
57 #include "ardour/session.h"
58 #include "ardour/source_factory.h"
59 #include "ardour/track.h"
60 #include "ardour/utils.h"
61 #include "ardour/session_playlists.h"
62 #include "ardour/route.h"
68 using namespace ARDOUR;
71 size_t AudioDiskstream::_working_buffers_size = 0;
72 Sample* AudioDiskstream::_mixdown_buffer = 0;
73 gain_t* AudioDiskstream::_gain_buffer = 0;
75 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
76 : Diskstream(sess, name, flag)
77 , channels (new ChannelList)
79 /* prevent any write sources from being created */
86 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
87 : Diskstream(sess, node)
88 , channels (new ChannelList)
93 if (set_state (node, Stateful::loading_state_version)) {
95 throw failed_constructor();
101 use_destructive_playlist ();
106 AudioDiskstream::init ()
108 /* there are no channels at this point, so these
109 two calls just get speed_buffer_size and wrap_buffer
110 size setup without duplicating their code.
113 set_block_size (_session.get_block_size());
114 allocate_temporary_buffers ();
117 AudioDiskstream::~AudioDiskstream ()
119 DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
122 RCUWriter<ChannelList> writer (channels);
123 boost::shared_ptr<ChannelList> c = writer.get_copy();
125 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
136 AudioDiskstream::allocate_working_buffers()
138 assert(disk_io_frames() > 0);
140 _working_buffers_size = disk_io_frames();
141 _mixdown_buffer = new Sample[_working_buffers_size];
142 _gain_buffer = new gain_t[_working_buffers_size];
146 AudioDiskstream::free_working_buffers()
148 delete [] _mixdown_buffer;
149 delete [] _gain_buffer;
150 _working_buffers_size = 0;
156 AudioDiskstream::non_realtime_input_change ()
159 Glib::Mutex::Lock lm (state_lock);
161 if (input_change_pending.type == IOChange::NoChange) {
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());
178 if (input_change_pending.type & IOChange::ConnectionsChanged) {
179 get_input_sources ();
180 set_capture_offset ();
181 set_align_style_from_io ();
184 input_change_pending = IOChange::NoChange;
186 /* implicit unlock */
189 /* reset capture files */
191 reset_write_sources (false);
193 /* now refill channel buffers */
195 if (speed() != 1.0f || speed() != -1.0f) {
196 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
198 seek (_session.transport_frame());
203 AudioDiskstream::non_realtime_locate (framepos_t location)
205 /* now refill channel buffers */
207 if (speed() != 1.0f || speed() != -1.0f) {
208 seek ((framepos_t) (location * (double) speed()));
215 AudioDiskstream::get_input_sources ()
217 boost::shared_ptr<ChannelList> c = channels.reader();
220 ChannelList::iterator chan;
221 uint32_t ni = _io->n_ports().n_audio();
222 vector<string> connections;
224 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
226 connections.clear ();
228 if (_io->nth (n)->get_connections (connections) == 0) {
229 if (!(*chan)->source.name.empty()) {
230 // _source->disable_metering ();
232 (*chan)->source.name = string();
234 (*chan)->source.name = connections[0];
240 AudioDiskstream::find_and_use_playlist (const string& name)
242 boost::shared_ptr<AudioPlaylist> playlist;
244 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) == 0) {
245 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
249 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
253 return use_playlist (playlist);
257 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
259 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
261 Diskstream::use_playlist(playlist);
267 AudioDiskstream::use_new_playlist ()
270 boost::shared_ptr<AudioPlaylist> playlist;
272 if (!in_set_state && destructive()) {
277 newname = Playlist::bump_name (_playlist->name(), _session);
279 newname = Playlist::bump_name (_name, _session);
282 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
284 playlist->set_orig_diskstream_id (id());
285 return use_playlist (playlist);
293 AudioDiskstream::use_copy_playlist ()
295 assert(audio_playlist());
301 if (_playlist == 0) {
302 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
307 boost::shared_ptr<AudioPlaylist> playlist;
309 newname = Playlist::bump_name (_playlist->name(), _session);
311 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
312 playlist->set_orig_diskstream_id (id());
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 AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool& need_butler)
412 boost::shared_ptr<ChannelList> c = channels.reader();
413 ChannelList::iterator chan;
415 framecnt_t rec_offset = 0;
416 framecnt_t rec_nframes = 0;
417 bool collect_playback = false;
418 bool can_record = _session.actively_recording ();
420 playback_distance = 0;
422 if (!_io || !_io->active()) {
426 check_record_status (transport_frame, can_record);
432 Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
438 adjust_capture_position = 0;
440 for (chan = c->begin(); chan != c->end(); ++chan) {
441 (*chan)->current_capture_buffer = 0;
442 (*chan)->current_playback_buffer = 0;
445 // Safeguard against situations where process() goes haywire when autopunching
446 // and last_recordable_frame < first_recordable_frame
448 if (last_recordable_frame < first_recordable_frame) {
449 last_recordable_frame = max_framepos;
452 if (record_enabled()) {
454 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
455 calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
457 if (rec_nframes && !was_recording) {
458 capture_captured = 0;
459 was_recording = true;
463 if (can_record && !_last_capture_sources.empty()) {
464 _last_capture_sources.clear ();
469 uint32_t limit = _io->n_ports ().n_audio();
471 /* one or more ports could already have been removed from _io, but our
472 channel setup hasn't yet been updated. prevent us from trying to
473 use channels that correspond to missing ports. note that the
474 process callback (from which this is called) is always atomic
475 with respect to port removal/addition.
478 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
480 ChannelInfo* chaninfo (*chan);
482 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
484 if (rec_nframes <= (framecnt_t) chaninfo->capture_vector.len[0]) {
486 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
488 /* note: grab the entire port buffer, but only copy what we were supposed to
489 for recording, and use rec_offset
492 boost::shared_ptr<AudioPort> const ap = _io->audio (n);
494 assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());
496 Sample *buf = ap->get_audio_buffer (nframes).data (rec_offset);
497 memcpy (chaninfo->current_capture_buffer, buf, sizeof (Sample) * rec_nframes);
501 framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
503 if (rec_nframes > total) {
508 boost::shared_ptr<AudioPort> const ap = _io->audio (n);
511 Sample* buf = ap->get_audio_buffer(nframes).data (rec_offset);
512 framecnt_t first = chaninfo->capture_vector.len[0];
514 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
515 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
516 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
517 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
519 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
533 /* data will be written to disk */
535 if (rec_nframes == nframes && rec_offset == 0) {
537 for (chan = c->begin(); chan != c->end(); ++chan) {
538 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
541 playback_distance = nframes;
546 /* we can't use the capture buffer as the playback buffer, because
547 we recorded only a part of the current process' cycle data
551 collect_playback = true;
554 adjust_capture_position = rec_nframes;
556 } else if (can_record && record_enabled()) {
558 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
560 for (chan = c->begin(); chan != c->end(); ++chan) {
561 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
564 playback_distance = nframes;
568 collect_playback = true;
571 if ((_track->monitoring_state () & MonitoringDisk) || collect_playback) {
573 /* we're doing playback */
575 framecnt_t necessary_samples;
577 /* no varispeed playback if we're recording, because the output .... TBD */
579 if (rec_nframes == 0 && _actual_speed != 1.0f) {
580 necessary_samples = (framecnt_t) floor ((nframes * fabs (_actual_speed))) + 1;
582 necessary_samples = nframes;
585 for (chan = c->begin(); chan != c->end(); ++chan) {
586 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
591 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
593 ChannelInfo* chaninfo (*chan);
595 if (necessary_samples <= (framecnt_t) chaninfo->playback_vector.len[0]) {
597 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
600 framecnt_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
602 if (necessary_samples > total) {
603 cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
604 cerr << "underrun for " << _name << endl;
610 memcpy ((char *) chaninfo->playback_wrap_buffer,
611 chaninfo->playback_vector.buf[0],
612 chaninfo->playback_vector.len[0] * sizeof (Sample));
613 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
614 chaninfo->playback_vector.buf[1],
615 (necessary_samples - chaninfo->playback_vector.len[0])
618 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
623 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
624 process_varispeed_playback(nframes, c);
626 playback_distance = nframes;
629 _speed = _target_speed;
635 if (commit (nframes)) {
644 AudioDiskstream::process_varispeed_playback (pframes_t nframes, boost::shared_ptr<ChannelList> c)
646 ChannelList::iterator chan;
648 interpolation.set_speed (_target_speed);
651 for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
652 ChannelInfo* chaninfo (*chan);
654 playback_distance = interpolation.interpolate (
655 channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
657 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
662 AudioDiskstream::commit (framecnt_t /* nframes */)
664 bool need_butler = false;
666 if (!_io || !_io->active()) {
670 if (_actual_speed < 0.0) {
671 playback_sample -= playback_distance;
673 playback_sample += playback_distance;
676 boost::shared_ptr<ChannelList> c = channels.reader();
677 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
679 (*chan)->playback_buf->increment_read_ptr (playback_distance);
681 if (adjust_capture_position) {
682 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
686 if (adjust_capture_position != 0) {
687 capture_captured += adjust_capture_position;
688 adjust_capture_position = 0;
696 if (_io && _io->active()) {
697 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
702 if (_io && _io->active()) {
703 need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_io_chunk_frames)
704 || ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
706 need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
714 AudioDiskstream::set_pending_overwrite (bool yn)
716 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
718 _pending_overwrite = yn;
720 overwrite_frame = playback_sample;
722 boost::shared_ptr<ChannelList> c = channels.reader ();
724 overwrite_offset = c->front()->playback_buf->get_read_ptr();
729 AudioDiskstream::overwrite_existing_buffers ()
731 boost::shared_ptr<ChannelList> c = channels.reader();
733 _pending_overwrite = false;
737 Sample* mixdown_buffer;
740 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
742 overwrite_queued = false;
744 /* assume all are the same size */
745 framecnt_t size = c->front()->playback_buf->bufsize();
747 mixdown_buffer = new Sample[size];
748 gain_buffer = new float[size];
750 /* reduce size so that we can fill the buffer correctly (ringbuffers
751 can only handle size-1, otherwise they appear to be empty)
758 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
760 start = overwrite_frame;
761 framecnt_t cnt = size;
763 /* to fill the buffer without resetting the playback sample, we need to
764 do it one or two chunks (normally two).
766 |----------------------------------------------------------------------|
770 |<- second chunk->||<----------------- first chunk ------------------>|
774 framecnt_t to_read = size - overwrite_offset;
776 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, n, reversed)) {
777 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
778 id(), size, playback_sample) << endmsg;
786 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer, start, cnt, n, reversed)) {
787 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
788 id(), size, playback_sample) << endmsg;
797 _pending_overwrite = false;
798 delete [] gain_buffer;
799 delete [] mixdown_buffer;
804 AudioDiskstream::seek (framepos_t frame, bool complete_refill)
808 ChannelList::iterator chan;
809 boost::shared_ptr<ChannelList> c = channels.reader();
811 Glib::Mutex::Lock lm (state_lock);
813 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
814 (*chan)->playback_buf->reset ();
815 (*chan)->capture_buf->reset ();
818 /* can't rec-enable in destructive mode if transport is before start */
820 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
821 disengage_record_enable ();
824 playback_sample = frame;
827 if (complete_refill) {
828 while ((ret = do_refill_with_alloc ()) > 0) ;
830 ret = do_refill_with_alloc ();
837 AudioDiskstream::can_internal_playback_seek (framecnt_t distance)
839 ChannelList::iterator chan;
840 boost::shared_ptr<ChannelList> c = channels.reader();
842 for (chan = c->begin(); chan != c->end(); ++chan) {
843 if ((*chan)->playback_buf->read_space() < (size_t) distance) {
851 AudioDiskstream::internal_playback_seek (framecnt_t distance)
853 ChannelList::iterator chan;
854 boost::shared_ptr<ChannelList> c = channels.reader();
856 for (chan = c->begin(); chan != c->end(); ++chan) {
857 (*chan)->playback_buf->increment_read_ptr (distance);
860 if (first_recordable_frame < max_framepos) {
861 first_recordable_frame += distance;
863 playback_sample += distance;
869 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
870 framepos_t& start, framecnt_t cnt,
871 int channel, bool reversed)
873 framecnt_t this_read = 0;
875 framepos_t loop_end = 0;
876 framepos_t loop_start = 0;
877 framecnt_t offset = 0;
880 /* XXX we don't currently play loops in reverse. not sure why */
884 framecnt_t loop_length = 0;
886 /* Make the use of a Location atomic for this read operation.
888 Note: Locations don't get deleted, so all we care about
889 when I say "atomic" is that we are always pointing to
890 the same one and using a start/length values obtained
894 if ((loc = loop_location) != 0) {
895 loop_start = loc->start();
896 loop_end = loc->end();
897 loop_length = loop_end - loop_start;
900 /* if we are looping, ensure that the first frame we read is at the correct
901 position within the loop.
904 if (loc && start >= loop_end) {
905 //cerr << "start adjusted from " << start;
906 start = loop_start + ((start - loop_start) % loop_length);
907 //cerr << "to " << start << endl;
910 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
919 /* take any loop into account. we can't read past the end of the loop. */
921 if (loc && (loop_end - start < cnt)) {
922 this_read = loop_end - start;
923 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
930 if (this_read == 0) {
934 this_read = min(cnt,this_read);
936 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
937 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), id(), this_read,
944 swap_by_ptr (buf, buf + this_read - 1);
948 /* if we read to the end of the loop, go back to the beginning */
965 AudioDiskstream::do_refill_with_alloc ()
967 Sample* mix_buf = new Sample[disk_io_chunk_frames];
968 float* gain_buf = new float[disk_io_chunk_frames];
970 int ret = _do_refill(mix_buf, gain_buf);
979 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
983 RingBufferNPT<Sample>::rw_vector vector;
984 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
985 framecnt_t total_space;
986 framecnt_t zero_fill;
988 ChannelList::iterator i;
989 boost::shared_ptr<ChannelList> c = channels.reader();
996 assert(mixdown_buffer);
1004 c->front()->playback_buf->get_write_vector (&vector);
1006 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1010 /* if there are 2+ chunks of disk i/o possible for
1011 this track, let the caller know so that it can arrange
1012 for us to be called again, ASAP.
1015 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1019 /* if we're running close to normal speed and there isn't enough
1020 space to do disk_io_chunk_frames of I/O, then don't bother.
1022 at higher speeds, just do it because the sync between butler
1023 and audio thread may not be good enough.
1025 Note: it is a design assumption that disk_io_chunk_frames is smaller
1026 than the playback buffer size, so this check should never trip when
1027 the playback buffer is empty.
1030 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1034 /* when slaved, don't try to get too close to the read pointer. this
1035 leaves space for the buffer reversal to have something useful to
1039 if (_slaved && total_space < (framecnt_t) (c->front()->playback_buf->bufsize() / 2)) {
1043 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1045 total_space = min (disk_io_chunk_frames, total_space);
1049 if (file_frame == 0) {
1051 /* at start: nothing to do but fill with silence */
1053 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1055 ChannelInfo* chan (*i);
1056 chan->playback_buf->get_write_vector (&vector);
1057 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1058 if (vector.len[1]) {
1059 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1061 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1066 if (file_frame < total_space) {
1068 /* too close to the start: read what we can,
1069 and then zero fill the rest
1072 zero_fill = total_space - file_frame;
1073 total_space = file_frame;
1082 if (file_frame == max_framepos) {
1084 /* at end: nothing to do but fill with silence */
1086 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1088 ChannelInfo* chan (*i);
1089 chan->playback_buf->get_write_vector (&vector);
1090 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1091 if (vector.len[1]) {
1092 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1094 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1099 if (file_frame > max_framepos - total_space) {
1101 /* to close to the end: read what we can, and zero fill the rest */
1103 zero_fill = total_space - (max_framepos - file_frame);
1104 total_space = max_framepos - file_frame;
1111 framepos_t file_frame_tmp = 0;
1113 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1115 ChannelInfo* chan (*i);
1118 framecnt_t len1, len2;
1120 chan->playback_buf->get_write_vector (&vector);
1122 if ((framecnt_t) vector.len[0] > disk_io_chunk_frames) {
1124 /* we're not going to fill the first chunk, so certainly do not bother with the
1125 other part. it won't be connected with the part we do fill, as in:
1127 .... => writable space
1128 ++++ => readable space
1129 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1131 |......|+++++++++++++|...............................|
1136 So, just pretend that the buf1 part isn't there.
1146 file_frame_tmp = file_frame;
1148 buf1 = vector.buf[0];
1149 len1 = vector.len[0];
1150 buf2 = vector.buf[1];
1151 len2 = vector.len[1];
1153 to_read = min (ts, len1);
1154 to_read = min (to_read, disk_io_chunk_frames);
1156 assert (to_read >= 0);
1160 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1165 chan->playback_buf->increment_write_ptr (to_read);
1169 to_read = min (ts, len2);
1173 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1174 so read some or all of vector.len[1] as well.
1177 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan_n, reversed)) {
1182 chan->playback_buf->increment_write_ptr (to_read);
1191 file_frame = file_frame_tmp;
1192 assert (file_frame >= 0);
1199 /** Flush pending data to disk.
1201 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1202 * of data to disk. it will never write more than that. If it writes that
1203 * much and there is more than that waiting to be written, it will return 1,
1204 * otherwise 0 on success or -1 on failure.
1206 * If there is less than disk_io_chunk_frames to be written, no data will be
1207 * written at all unless @a force_flush is true.
1210 AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
1214 RingBufferNPT<Sample>::rw_vector vector;
1215 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1218 transvec.buf[0] = 0;
1219 transvec.buf[1] = 0;
1223 boost::shared_ptr<ChannelList> c = channels.reader();
1224 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1226 (*chan)->capture_buf->get_read_vector (&vector);
1228 total = vector.len[0] + vector.len[1];
1230 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1234 /* if there are 2+ chunks of disk i/o possible for
1235 this track, let the caller know so that it can arrange
1236 for us to be called again, ASAP.
1238 if we are forcing a flush, then if there is* any* extra
1239 work, let the caller know.
1241 if we are no longer recording and there is any extra work,
1242 let the caller know too.
1245 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1249 to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
1251 // check the transition buffer when recording destructive
1252 // important that we get this after the capture buf
1254 if (destructive()) {
1255 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1256 size_t transcount = transvec.len[0] + transvec.len[1];
1259 for (ti=0; ti < transcount; ++ti) {
1260 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1262 if (captrans.type == CaptureStart) {
1263 // by definition, the first data we got above represents the given capture pos
1265 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1266 (*chan)->curr_capture_cnt = 0;
1268 } else if (captrans.type == CaptureEnd) {
1270 // capture end, the capture_val represents total frames in capture
1272 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1274 // shorten to make the write a perfect fit
1275 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1277 if (nto_write < to_write) {
1278 ret = 1; // should we?
1280 to_write = nto_write;
1282 (*chan)->write_source->mark_capture_end ();
1284 // increment past this transition, but go no further
1289 // actually ends just beyond this chunk, so force more work
1297 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1301 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1302 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1306 (*chan)->capture_buf->increment_read_ptr (to_write);
1307 (*chan)->curr_capture_cnt += to_write;
1309 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1311 /* we wrote all of vector.len[0] but it wasn't an entire
1312 disk_io_chunk_frames of data, so arrange for some part
1313 of vector.len[1] to be flushed to disk as well.
1316 to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1318 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1319 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1323 (*chan)->capture_buf->increment_read_ptr (to_write);
1324 (*chan)->curr_capture_cnt += to_write;
1333 AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1335 uint32_t buffer_position;
1336 bool more_work = true;
1338 boost::shared_ptr<AudioRegion> region;
1339 framecnt_t total_capture;
1341 SourceList::iterator src;
1342 ChannelList::iterator chan;
1343 vector<CaptureInfo*>::iterator ci;
1344 boost::shared_ptr<ChannelList> c = channels.reader();
1346 bool mark_write_completed = false;
1350 /* butler is already stopped, but there may be work to do
1351 to flush remaining data to disk.
1354 while (more_work && !err) {
1355 switch (do_flush (TransportContext, true)) {
1362 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1367 /* XXX is there anything we can do if err != 0 ? */
1368 Glib::Mutex::Lock lm (capture_info_lock);
1370 if (capture_info.empty()) {
1374 if (abort_capture) {
1376 if (destructive()) {
1380 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1382 if ((*chan)->write_source) {
1384 (*chan)->write_source->mark_for_remove ();
1385 (*chan)->write_source->drop_references ();
1386 (*chan)->write_source.reset ();
1389 /* new source set up in "out" below */
1395 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1396 total_capture += (*ci)->frames;
1399 /* figure out the name for this take */
1401 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1403 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1407 s->update_header (capture_info.front()->start, when, twhen);
1408 s->set_captured_for (_name.val());
1409 s->mark_immutable ();
1411 if (Config->get_auto_analyse_audio()) {
1412 Analyser::queue_source_for_analysis (s, true);
1417 /* destructive tracks have a single, never changing region */
1419 if (destructive()) {
1421 /* send a signal that any UI can pick up to do the right thing. there is
1422 a small problem here in that a UI may need the peak data to be ready
1423 for the data that was recorded and this isn't interlocked with that
1424 process. this problem is deferred to the UI.
1427 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1431 string whole_file_region_name;
1432 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1434 /* Register a new region with the Session that
1435 describes the entire source. Do this first
1436 so that any sub-regions will obviously be
1437 children of this one (later!)
1443 plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1444 plist.add (Properties::length, total_capture);
1445 plist.add (Properties::name, whole_file_region_name);
1446 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1447 rx->set_automatic (true);
1448 rx->set_whole_file (true);
1450 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1451 region->special_set_position (capture_info.front()->start);
1455 catch (failed_constructor& err) {
1456 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1460 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1462 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1464 _playlist->clear_changes ();
1465 _playlist->freeze ();
1467 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1471 RegionFactory::region_name (region_name, whole_file_region_name, false);
1473 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1474 _name, (*ci)->start, (*ci)->frames, region_name));
1480 plist.add (Properties::start, buffer_position);
1481 plist.add (Properties::length, (*ci)->frames);
1482 plist.add (Properties::name, region_name);
1484 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1485 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1488 catch (failed_constructor& err) {
1489 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1490 continue; /* XXX is this OK? */
1493 i_am_the_modifier++;
1495 if (_playlist->explicit_relayering()) {
1496 /* We are in `explicit relayering' mode, so we must specify which layer this new region
1497 should end up on. Put it at the top.
1499 region->set_layer (_playlist->top_layer() + 1);
1500 region->set_pending_explicit_relayer (true);
1503 _playlist->add_region (region, (*ci)->start, 1, non_layered());
1504 i_am_the_modifier--;
1506 buffer_position += (*ci)->frames;
1510 _session.add_command (new StatefulDiffCommand (_playlist));
1513 mark_write_completed = true;
1516 reset_write_sources (mark_write_completed);
1520 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1524 capture_info.clear ();
1525 capture_start_frame = 0;
1529 AudioDiskstream::transport_looped (framepos_t transport_frame)
1531 if (was_recording) {
1532 // all we need to do is finish this capture, with modified capture length
1533 boost::shared_ptr<ChannelList> c = channels.reader();
1535 // adjust the capture length knowing that the data will be recorded to disk
1536 // only necessary after the first loop where we're recording
1537 if (capture_info.size() == 0) {
1538 capture_captured += _capture_offset;
1540 if (_alignment_style == ExistingMaterial) {
1541 capture_captured += _session.worst_output_latency();
1543 capture_captured += _roll_delay;
1549 // the next region will start recording via the normal mechanism
1550 // we'll set the start position to the current transport pos
1551 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1552 capture_start_frame = transport_frame;
1553 first_recordable_frame = transport_frame; // mild lie
1554 last_recordable_frame = max_framepos;
1555 was_recording = true;
1557 if (recordable() && destructive()) {
1558 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1560 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1561 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1563 if (transvec.len[0] > 0) {
1564 transvec.buf[0]->type = CaptureStart;
1565 transvec.buf[0]->capture_val = capture_start_frame;
1566 (*chan)->capture_transition_buf->increment_write_ptr(1);
1570 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1580 AudioDiskstream::finish_capture (boost::shared_ptr<ChannelList> c)
1582 was_recording = false;
1583 first_recordable_frame = max_framepos;
1584 last_recordable_frame = max_framepos;
1586 if (capture_captured == 0) {
1590 if (recordable() && destructive()) {
1591 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1593 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1594 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1596 if (transvec.len[0] > 0) {
1597 transvec.buf[0]->type = CaptureEnd;
1598 transvec.buf[0]->capture_val = capture_captured;
1599 (*chan)->capture_transition_buf->increment_write_ptr(1);
1603 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1609 CaptureInfo* ci = new CaptureInfo;
1611 ci->start = capture_start_frame;
1612 ci->frames = capture_captured;
1614 /* XXX theoretical race condition here. Need atomic exchange ?
1615 However, the circumstances when this is called right
1616 now (either on record-disable or transport_stopped)
1617 mean that no actual race exists. I think ...
1618 We now have a capture_info_lock, but it is only to be used
1619 to synchronize in the transport_stop and the capture info
1620 accessors, so that invalidation will not occur (both non-realtime).
1623 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1625 capture_info.push_back (ci);
1626 capture_captured = 0;
1628 /* now we've finished a capture, reset first_recordable_frame for next time */
1629 first_recordable_frame = max_framepos;
1633 AudioDiskstream::set_record_enabled (bool yn)
1635 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1639 /* can't rec-enable in destructive mode if transport is before start */
1641 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1645 /* yes, i know that this not proof against race conditions, but its
1646 good enough. i think.
1649 if (record_enabled() != yn) {
1651 engage_record_enable ();
1653 disengage_record_enable ();
1659 AudioDiskstream::engage_record_enable ()
1661 bool rolling = _session.transport_speed() != 0.0f;
1662 boost::shared_ptr<ChannelList> c = channels.reader();
1664 g_atomic_int_set (&_record_enabled, 1);
1665 capturing_sources.clear ();
1667 if (Config->get_monitoring_model() == HardwareMonitoring) {
1669 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1670 (*chan)->source.ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
1671 capturing_sources.push_back ((*chan)->write_source);
1672 (*chan)->write_source->mark_streaming_write_started ();
1676 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1677 capturing_sources.push_back ((*chan)->write_source);
1678 (*chan)->write_source->mark_streaming_write_started ();
1682 RecordEnableChanged (); /* EMIT SIGNAL */
1686 AudioDiskstream::disengage_record_enable ()
1688 g_atomic_int_set (&_record_enabled, 0);
1689 boost::shared_ptr<ChannelList> c = channels.reader();
1690 if (Config->get_monitoring_model() == HardwareMonitoring) {
1691 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1692 (*chan)->source.ensure_monitor_input (false);
1695 capturing_sources.clear ();
1696 RecordEnableChanged (); /* EMIT SIGNAL */
1700 AudioDiskstream::get_state ()
1702 XMLNode& node (Diskstream::get_state());
1704 LocaleGuard lg (X_("POSIX"));
1706 boost::shared_ptr<ChannelList> c = channels.reader();
1707 snprintf (buf, sizeof(buf), "%zd", c->size());
1708 node.add_property ("channels", buf);
1710 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1712 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1713 XMLNode* cs_grandchild;
1715 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1716 cs_grandchild = new XMLNode (X_("file"));
1717 cs_grandchild->add_property (X_("path"), (*i)->path());
1718 cs_child->add_child_nocopy (*cs_grandchild);
1721 /* store the location where capture will start */
1725 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1726 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1728 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1731 cs_child->add_property (X_("at"), buf);
1732 node.add_child_nocopy (*cs_child);
1739 AudioDiskstream::set_state (const XMLNode& node, int version)
1741 const XMLProperty* prop;
1742 XMLNodeList nlist = node.children();
1743 XMLNodeIterator niter;
1744 uint32_t nchans = 1;
1745 XMLNode* capture_pending_node = 0;
1746 LocaleGuard lg (X_("POSIX"));
1748 /* prevent write sources from being created */
1750 in_set_state = true;
1752 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1753 if ((*niter)->name() == IO::state_node_name) {
1754 deprecated_io_node = new XMLNode (**niter);
1757 if ((*niter)->name() == X_("CapturingSources")) {
1758 capture_pending_node = *niter;
1762 if (Diskstream::set_state (node, version)) {
1766 if ((prop = node.property ("channels")) != 0) {
1767 nchans = atoi (prop->value().c_str());
1770 // create necessary extra channels
1771 // we are always constructed with one and we always need one
1773 _n_channels.set(DataType::AUDIO, channels.reader()->size());
1775 if (nchans > _n_channels.n_audio()) {
1777 add_channel (nchans - _n_channels.n_audio());
1778 IO::PortCountChanged(_n_channels);
1780 } else if (nchans < _n_channels.n_audio()) {
1782 remove_channel (_n_channels.n_audio() - nchans);
1787 if (!destructive() && capture_pending_node) {
1788 /* destructive streams have one and only one source per channel,
1789 and so they never end up in pending capture in any useful
1792 use_pending_capture_data (*capture_pending_node);
1795 in_set_state = false;
1797 /* make sure this is clear before we do anything else */
1799 capturing_sources.clear ();
1801 /* write sources are handled when we handle the input set
1802 up of the IO that owns this DS (::non_realtime_input_change())
1809 AudioDiskstream::use_new_write_source (uint32_t n)
1811 boost::shared_ptr<ChannelList> c = channels.reader();
1813 if (!recordable()) {
1817 if (n >= c->size()) {
1818 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1822 ChannelInfo* chan = (*c)[n];
1825 if ((chan->write_source = _session.create_audio_source_for_session (
1826 n_channels().n_audio(), name(), n, destructive())) == 0) {
1827 throw failed_constructor();
1831 catch (failed_constructor &err) {
1832 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1833 chan->write_source.reset ();
1837 /* do not remove destructive files even if they are empty */
1839 chan->write_source->set_allow_remove_if_empty (!destructive());
1844 list<boost::shared_ptr<Source> >
1845 AudioDiskstream::steal_write_sources()
1847 /* not possible to steal audio write sources */
1848 list<boost::shared_ptr<Source> > ret;
1853 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1855 ChannelList::iterator chan;
1856 boost::shared_ptr<ChannelList> c = channels.reader();
1859 if (!_session.writable() || !recordable()) {
1863 capturing_sources.clear ();
1865 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1867 if (!destructive()) {
1869 if ((*chan)->write_source) {
1871 if (mark_write_complete) {
1872 (*chan)->write_source->mark_streaming_write_completed ();
1873 (*chan)->write_source->done_with_peakfile_writes ();
1876 if ((*chan)->write_source->removable()) {
1877 (*chan)->write_source->mark_for_remove ();
1878 (*chan)->write_source->drop_references ();
1881 (*chan)->write_source.reset ();
1884 use_new_write_source (n);
1886 if (record_enabled()) {
1887 capturing_sources.push_back ((*chan)->write_source);
1892 if ((*chan)->write_source == 0) {
1893 use_new_write_source (n);
1898 if (destructive() && !c->empty ()) {
1900 /* we now have all our write sources set up, so create the
1901 playlist's single region.
1904 if (_playlist->empty()) {
1905 setup_destructive_playlist ();
1911 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
1913 if (_session.get_block_size() > speed_buffer_size) {
1914 speed_buffer_size = _session.get_block_size();
1915 boost::shared_ptr<ChannelList> c = channels.reader();
1917 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1918 if ((*chan)->speed_buffer)
1919 delete [] (*chan)->speed_buffer;
1920 (*chan)->speed_buffer = new Sample[speed_buffer_size];
1923 allocate_temporary_buffers ();
1927 AudioDiskstream::allocate_temporary_buffers ()
1929 /* make sure the wrap buffer is at least large enough to deal
1930 with the speeds up to 1.2, to allow for micro-variation
1931 when slaving to MTC, Timecode etc.
1934 double const sp = max (fabsf (_actual_speed), 1.2f);
1935 framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1;
1937 if (required_wrap_size > wrap_buffer_size) {
1939 boost::shared_ptr<ChannelList> c = channels.reader();
1941 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1942 if ((*chan)->playback_wrap_buffer)
1943 delete [] (*chan)->playback_wrap_buffer;
1944 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
1945 if ((*chan)->capture_wrap_buffer)
1946 delete [] (*chan)->capture_wrap_buffer;
1947 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
1950 wrap_buffer_size = required_wrap_size;
1955 AudioDiskstream::monitor_input (bool yn)
1957 boost::shared_ptr<ChannelList> c = channels.reader();
1959 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1960 (*chan)->source.ensure_monitor_input (yn);
1965 AudioDiskstream::set_align_style_from_io ()
1967 bool have_physical = false;
1969 if (_alignment_choice != Automatic) {
1977 get_input_sources ();
1979 boost::shared_ptr<ChannelList> c = channels.reader();
1981 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1982 if ((*chan)->source.is_physical ()) {
1983 have_physical = true;
1988 if (have_physical) {
1989 set_align_style (ExistingMaterial);
1991 set_align_style (CaptureTime);
1996 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
1998 while (how_many--) {
1999 c->push_back (new ChannelInfo(
2000 _session.butler()->audio_diskstream_playback_buffer_size(),
2001 _session.butler()->audio_diskstream_capture_buffer_size(),
2002 speed_buffer_size, wrap_buffer_size));
2003 interpolation.add_channel_to (
2004 _session.butler()->audio_diskstream_playback_buffer_size(),
2008 _n_channels.set(DataType::AUDIO, c->size());
2014 AudioDiskstream::add_channel (uint32_t how_many)
2016 RCUWriter<ChannelList> writer (channels);
2017 boost::shared_ptr<ChannelList> c = writer.get_copy();
2019 return add_channel_to (c, how_many);
2023 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2025 while (how_many-- && !c->empty()) {
2028 interpolation.remove_channel_from ();
2031 _n_channels.set(DataType::AUDIO, c->size());
2037 AudioDiskstream::remove_channel (uint32_t how_many)
2039 RCUWriter<ChannelList> writer (channels);
2040 boost::shared_ptr<ChannelList> c = writer.get_copy();
2042 return remove_channel_from (c, how_many);
2046 AudioDiskstream::playback_buffer_load () const
2048 boost::shared_ptr<ChannelList> c = channels.reader();
2054 return (float) ((double) c->front()->playback_buf->read_space()/
2055 (double) c->front()->playback_buf->bufsize());
2059 AudioDiskstream::capture_buffer_load () const
2061 boost::shared_ptr<ChannelList> c = channels.reader();
2067 return (float) ((double) c->front()->capture_buf->write_space()/
2068 (double) c->front()->capture_buf->bufsize());
2072 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2074 const XMLProperty* prop;
2075 XMLNodeList nlist = node.children();
2076 XMLNodeIterator niter;
2077 boost::shared_ptr<AudioFileSource> fs;
2078 boost::shared_ptr<AudioFileSource> first_fs;
2079 SourceList pending_sources;
2080 framepos_t position;
2082 if ((prop = node.property (X_("at"))) == 0) {
2086 if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2090 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2091 if ((*niter)->name() == X_("file")) {
2093 if ((prop = (*niter)->property (X_("path"))) == 0) {
2097 // This protects sessions from errant CapturingSources in stored sessions
2099 if (stat (prop->value().c_str(), &sbuf)) {
2104 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2105 SourceFactory::createWritable (
2106 DataType::AUDIO, _session,
2107 prop->value(), string(), false, _session.frame_rate()));
2110 catch (failed_constructor& err) {
2111 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2112 _name, prop->value())
2117 pending_sources.push_back (fs);
2119 if (first_fs == 0) {
2123 fs->set_captured_for (_name.val());
2127 if (pending_sources.size() == 0) {
2128 /* nothing can be done */
2132 if (pending_sources.size() != _n_channels.n_audio()) {
2133 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2138 boost::shared_ptr<AudioRegion> region;
2144 plist.add (Properties::start, 0);
2145 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2146 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2148 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2150 region->set_automatic (true);
2151 region->set_whole_file (true);
2152 region->special_set_position (0);
2155 catch (failed_constructor& err) {
2156 error << string_compose (
2157 _("%1: cannot create whole-file region from pending capture sources"),
2163 _playlist->add_region (region, position);
2169 AudioDiskstream::set_non_layered (bool yn)
2171 if (yn != non_layered()) {
2174 _flags = Flag (_flags | NonLayered);
2176 _flags = Flag (_flags & ~NonLayered);
2184 AudioDiskstream::set_destructive (bool yn)
2186 if (yn != destructive()) {
2189 bool bounce_ignored;
2190 /* requestor should already have checked this and
2191 bounced if necessary and desired
2193 if (!can_become_destructive (bounce_ignored)) {
2196 _flags = Flag (_flags | Destructive);
2197 use_destructive_playlist ();
2199 _flags = Flag (_flags & ~Destructive);
2200 reset_write_sources (true, true);
2208 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2211 requires_bounce = false;
2215 /* is there only one region ? */
2217 if (_playlist->n_regions() != 1) {
2218 requires_bounce = true;
2222 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2224 requires_bounce = false;
2228 /* do the source(s) for the region cover the session start position ? */
2230 if (first->position() != _session.current_start_frame()) {
2231 if (first->start() > _session.current_start_frame()) {
2232 requires_bounce = true;
2237 /* is the source used by only 1 playlist ? */
2239 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2243 if (_session.playlists->source_use_count (afirst->source()) > 1) {
2244 requires_bounce = true;
2248 requires_bounce = false;
2253 AudioDiskstream::adjust_playback_buffering ()
2255 boost::shared_ptr<ChannelList> c = channels.reader();
2257 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2258 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2263 AudioDiskstream::adjust_capture_buffering ()
2265 boost::shared_ptr<ChannelList> c = channels.reader();
2267 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2268 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2273 AudioDiskstream::ChannelSource::is_physical () const
2279 return AudioEngine::instance()->port_is_physical (name);
2283 AudioDiskstream::ChannelSource::ensure_monitor_input (bool yn) const
2289 return AudioEngine::instance()->ensure_monitor_input (name, yn);
2292 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2294 current_capture_buffer = 0;
2295 current_playback_buffer = 0;
2296 curr_capture_cnt = 0;
2298 speed_buffer = new Sample[speed_size];
2299 playback_wrap_buffer = new Sample[wrap_size];
2300 capture_wrap_buffer = new Sample[wrap_size];
2302 playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2303 capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2304 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2306 /* touch the ringbuffer buffers, which will cause
2307 them to be mapped into locked physical RAM if
2308 we're running with mlockall(). this doesn't do
2312 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2313 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2314 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2318 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2320 delete playback_buf;
2321 playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2322 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2326 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2330 capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2331 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2334 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2336 write_source.reset ();
2338 delete [] speed_buffer;
2341 delete [] playback_wrap_buffer;
2342 playback_wrap_buffer = 0;
2344 delete [] capture_wrap_buffer;
2345 capture_wrap_buffer = 0;
2347 delete playback_buf;
2353 delete capture_transition_buf;
2354 capture_transition_buf = 0;
2359 AudioDiskstream::set_name (string const & name)
2361 Diskstream::set_name (name);
2363 /* get a new write source so that its name reflects the new diskstream name */
2365 boost::shared_ptr<ChannelList> c = channels.reader();
2366 ChannelList::iterator i;
2369 for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2370 use_new_write_source (n);