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/utils.h"
60 #include "ardour/session_playlists.h"
61 #include "ardour/route.h"
67 using namespace ARDOUR;
70 size_t AudioDiskstream::_working_buffers_size = 0;
71 Sample* AudioDiskstream::_mixdown_buffer = 0;
72 gain_t* AudioDiskstream::_gain_buffer = 0;
74 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
75 : Diskstream(sess, name, flag)
76 , channels (new ChannelList)
78 /* prevent any write sources from being created */
85 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
86 : Diskstream(sess, node)
87 , channels (new ChannelList)
92 if (set_state (node, Stateful::loading_state_version)) {
94 throw failed_constructor();
100 use_destructive_playlist ();
105 AudioDiskstream::init ()
107 /* there are no channels at this point, so these
108 two calls just get speed_buffer_size and wrap_buffer
109 size setup without duplicating their code.
112 set_block_size (_session.get_block_size());
113 allocate_temporary_buffers ();
116 AudioDiskstream::~AudioDiskstream ()
118 DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
121 RCUWriter<ChannelList> writer (channels);
122 boost::shared_ptr<ChannelList> c = writer.get_copy();
124 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
135 AudioDiskstream::allocate_working_buffers()
137 assert(disk_io_frames() > 0);
139 _working_buffers_size = disk_io_frames();
140 _mixdown_buffer = new Sample[_working_buffers_size];
141 _gain_buffer = new gain_t[_working_buffers_size];
145 AudioDiskstream::free_working_buffers()
147 delete [] _mixdown_buffer;
148 delete [] _gain_buffer;
149 _working_buffers_size = 0;
155 AudioDiskstream::non_realtime_input_change ()
158 Glib::Mutex::Lock lm (state_lock);
160 if (input_change_pending.type == IOChange::NoChange) {
164 if (input_change_pending.type == IOChange::ConfigurationChanged) {
165 RCUWriter<ChannelList> writer (channels);
166 boost::shared_ptr<ChannelList> c = writer.get_copy();
168 _n_channels.set(DataType::AUDIO, c->size());
170 if (_io->n_ports().n_audio() > _n_channels.n_audio()) {
171 add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
172 } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
173 remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
177 if (input_change_pending.type & IOChange::ConnectionsChanged) {
178 get_input_sources ();
179 set_capture_offset ();
180 set_align_style_from_io ();
183 input_change_pending = IOChange::NoChange;
185 /* implicit unlock */
188 /* reset capture files */
190 reset_write_sources (false);
192 /* now refill channel buffers */
194 if (speed() != 1.0f || speed() != -1.0f) {
195 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
197 seek (_session.transport_frame());
202 AudioDiskstream::non_realtime_locate (framepos_t location)
204 /* now refill channel buffers */
206 if (speed() != 1.0f || speed() != -1.0f) {
207 seek ((framepos_t) (location * (double) speed()));
214 AudioDiskstream::get_input_sources ()
216 boost::shared_ptr<ChannelList> c = channels.reader();
219 ChannelList::iterator chan;
220 uint32_t ni = _io->n_ports().n_audio();
221 vector<string> connections;
223 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
225 connections.clear ();
227 if (_io->nth (n)->get_connections (connections) == 0) {
228 if (!(*chan)->source.name.empty()) {
229 // _source->disable_metering ();
231 (*chan)->source.name = string();
233 (*chan)->source.name = connections[0];
239 AudioDiskstream::find_and_use_playlist (const string& name)
241 boost::shared_ptr<AudioPlaylist> playlist;
243 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) == 0) {
244 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
248 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
252 return use_playlist (playlist);
256 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
258 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
260 Diskstream::use_playlist(playlist);
266 AudioDiskstream::use_new_playlist ()
269 boost::shared_ptr<AudioPlaylist> playlist;
271 if (!in_set_state && destructive()) {
276 newname = Playlist::bump_name (_playlist->name(), _session);
278 newname = Playlist::bump_name (_name, _session);
281 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
283 playlist->set_orig_diskstream_id (id());
284 return use_playlist (playlist);
292 AudioDiskstream::use_copy_playlist ()
294 assert(audio_playlist());
300 if (_playlist == 0) {
301 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
306 boost::shared_ptr<AudioPlaylist> playlist;
308 newname = Playlist::bump_name (_playlist->name(), _session);
310 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
311 playlist->set_orig_diskstream_id (id());
312 return use_playlist (playlist);
319 AudioDiskstream::setup_destructive_playlist ()
322 boost::shared_ptr<ChannelList> c = channels.reader();
324 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
325 srcs.push_back ((*chan)->write_source);
328 /* a single full-sized region */
330 assert (!srcs.empty ());
333 plist.add (Properties::name, _name.val());
334 plist.add (Properties::start, 0);
335 plist.add (Properties::length, max_framepos - (max_framepos - srcs.front()->natural_position()));
337 boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
338 _playlist->add_region (region, srcs.front()->natural_position());
342 AudioDiskstream::use_destructive_playlist ()
344 /* this is called from the XML-based constructor or ::set_destructive. when called,
345 we already have a playlist and a region, but we need to
346 set up our sources for write. we use the sources associated
347 with the (presumed single, full-extent) region.
350 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
353 reset_write_sources (false, true);
357 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
360 throw failed_constructor();
363 /* be sure to stretch the region out to the maximum length */
365 region->set_length (max_framepos - region->position());
368 ChannelList::iterator chan;
369 boost::shared_ptr<ChannelList> c = channels.reader();
371 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
372 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
373 assert((*chan)->write_source);
374 (*chan)->write_source->set_allow_remove_if_empty (false);
376 /* this might be false if we switched modes, so force it */
378 (*chan)->write_source->set_destructive (true);
381 /* the source list will never be reset for a destructive track */
385 AudioDiskstream::prepare_record_status(framepos_t capture_start_frame)
387 if (recordable() && destructive()) {
388 boost::shared_ptr<ChannelList> c = channels.reader();
389 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
391 RingBufferNPT<CaptureTransition>::rw_vector transitions;
392 (*chan)->capture_transition_buf->get_write_vector (&transitions);
394 if (transitions.len[0] > 0) {
395 transitions.buf[0]->type = CaptureStart;
396 transitions.buf[0]->capture_val = capture_start_frame;
397 (*chan)->capture_transition_buf->increment_write_ptr(1);
400 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
408 AudioDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
411 boost::shared_ptr<ChannelList> c = channels.reader();
412 ChannelList::iterator chan;
414 framecnt_t rec_offset = 0;
415 framecnt_t rec_nframes = 0;
416 bool collect_playback = false;
418 playback_distance = 0;
420 if (!_io || !_io->active()) {
424 check_record_status (transport_frame, can_record);
430 Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
436 adjust_capture_position = 0;
438 for (chan = c->begin(); chan != c->end(); ++chan) {
439 (*chan)->current_capture_buffer = 0;
440 (*chan)->current_playback_buffer = 0;
443 // Safeguard against situations where process() goes haywire when autopunching
444 // and last_recordable_frame < first_recordable_frame
446 if (last_recordable_frame < first_recordable_frame) {
447 last_recordable_frame = max_framepos;
450 if (record_enabled()) {
452 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
453 calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
455 if (rec_nframes && !was_recording) {
456 capture_captured = 0;
457 was_recording = true;
461 if (can_record && !_last_capture_sources.empty()) {
462 _last_capture_sources.clear ();
467 uint32_t limit = _io->n_ports ().n_audio();
469 /* one or more ports could already have been removed from _io, but our
470 channel setup hasn't yet been updated. prevent us from trying to
471 use channels that correspond to missing ports. note that the
472 process callback (from which this is called) is always atomic
473 with respect to port removal/addition.
476 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
478 ChannelInfo* chaninfo (*chan);
480 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
482 if (rec_nframes <= (framecnt_t) chaninfo->capture_vector.len[0]) {
484 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
486 /* note: grab the entire port buffer, but only copy what we were supposed to
487 for recording, and use rec_offset
490 AudioPort* const ap = _io->audio (n);
492 assert(rec_nframes <= (framecnt_t) ap->get_audio_buffer(nframes).capacity());
493 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
498 framecnt_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
500 if (rec_nframes > total) {
505 AudioPort* const ap = _io->audio (n);
508 Sample* buf = ap->get_audio_buffer(nframes).data();
509 framecnt_t first = chaninfo->capture_vector.len[0];
511 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
512 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
513 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
514 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
516 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
523 finish_capture (rec_monitors_input, c);
530 /* data will be written to disk */
532 if (rec_nframes == nframes && rec_offset == 0) {
534 for (chan = c->begin(); chan != c->end(); ++chan) {
535 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
538 playback_distance = nframes;
543 /* we can't use the capture buffer as the playback buffer, because
544 we recorded only a part of the current process' cycle data
548 collect_playback = true;
551 adjust_capture_position = rec_nframes;
553 } else if (can_record && record_enabled()) {
555 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
557 for (chan = c->begin(); chan != c->end(); ++chan) {
558 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
561 playback_distance = nframes;
565 collect_playback = true;
568 if (collect_playback) {
570 /* we're doing playback */
572 framecnt_t necessary_samples;
574 /* no varispeed playback if we're recording, because the output .... TBD */
576 if (rec_nframes == 0 && _actual_speed != 1.0f) {
577 necessary_samples = (framecnt_t) floor ((nframes * fabs (_actual_speed))) + 1;
579 necessary_samples = nframes;
582 for (chan = c->begin(); chan != c->end(); ++chan) {
583 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
588 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
590 ChannelInfo* chaninfo (*chan);
592 if (necessary_samples <= (framecnt_t) chaninfo->playback_vector.len[0]) {
594 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
597 framecnt_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
599 if (necessary_samples > total) {
600 cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
601 cerr << "underrun for " << _name << endl;
607 memcpy ((char *) chaninfo->playback_wrap_buffer,
608 chaninfo->playback_vector.buf[0],
609 chaninfo->playback_vector.len[0] * sizeof (Sample));
610 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
611 chaninfo->playback_vector.buf[1],
612 (necessary_samples - chaninfo->playback_vector.len[0])
615 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
620 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
621 process_varispeed_playback(nframes, c);
623 playback_distance = nframes;
626 _speed = _target_speed;
632 if (commit (nframes)) {
641 AudioDiskstream::process_varispeed_playback (pframes_t nframes, boost::shared_ptr<ChannelList> c)
643 ChannelList::iterator chan;
645 interpolation.set_speed (_target_speed);
648 for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
649 ChannelInfo* chaninfo (*chan);
651 playback_distance = interpolation.interpolate (
652 channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
654 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
659 AudioDiskstream::commit (framecnt_t /* nframes */)
661 bool need_butler = false;
663 if (!_io || !_io->active()) {
667 if (_actual_speed < 0.0) {
668 playback_sample -= playback_distance;
670 playback_sample += playback_distance;
673 boost::shared_ptr<ChannelList> c = channels.reader();
674 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
676 (*chan)->playback_buf->increment_read_ptr (playback_distance);
678 if (adjust_capture_position) {
679 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
683 if (adjust_capture_position != 0) {
684 capture_captured += adjust_capture_position;
685 adjust_capture_position = 0;
693 if (_io && _io->active()) {
694 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
699 if (_io && _io->active()) {
700 need_butler = ((framecnt_t) c->front()->playback_buf->write_space() >= disk_io_chunk_frames)
701 || ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
703 need_butler = ((framecnt_t) c->front()->capture_buf->read_space() >= disk_io_chunk_frames);
711 AudioDiskstream::set_pending_overwrite (bool yn)
713 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
715 _pending_overwrite = yn;
717 overwrite_frame = playback_sample;
719 boost::shared_ptr<ChannelList> c = channels.reader ();
721 overwrite_offset = c->front()->playback_buf->get_read_ptr();
726 AudioDiskstream::overwrite_existing_buffers ()
728 boost::shared_ptr<ChannelList> c = channels.reader();
730 _pending_overwrite = false;
734 Sample* mixdown_buffer;
737 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
739 overwrite_queued = false;
741 /* assume all are the same size */
742 framecnt_t size = c->front()->playback_buf->bufsize();
744 mixdown_buffer = new Sample[size];
745 gain_buffer = new float[size];
747 /* reduce size so that we can fill the buffer correctly (ringbuffers
748 can only handle size-1, otherwise they appear to be empty)
755 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
757 start = overwrite_frame;
758 framecnt_t cnt = size;
760 /* to fill the buffer without resetting the playback sample, we need to
761 do it one or two chunks (normally two).
763 |----------------------------------------------------------------------|
767 |<- second chunk->||<----------------- first chunk ------------------>|
771 framecnt_t to_read = size - overwrite_offset;
773 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
774 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
775 _id, size, playback_sample) << endmsg;
783 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
784 start, cnt, *chan, n, reversed)) {
785 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
786 _id, size, playback_sample) << endmsg;
795 _pending_overwrite = false;
796 delete [] gain_buffer;
797 delete [] mixdown_buffer;
802 AudioDiskstream::seek (framepos_t frame, bool complete_refill)
806 ChannelList::iterator chan;
807 boost::shared_ptr<ChannelList> c = channels.reader();
809 Glib::Mutex::Lock lm (state_lock);
811 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
812 (*chan)->playback_buf->reset ();
813 (*chan)->capture_buf->reset ();
816 /* can't rec-enable in destructive mode if transport is before start */
818 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
819 disengage_record_enable ();
822 playback_sample = frame;
825 if (complete_refill) {
826 while ((ret = do_refill_with_alloc ()) > 0) ;
828 ret = do_refill_with_alloc ();
835 AudioDiskstream::can_internal_playback_seek (framecnt_t distance)
837 ChannelList::iterator chan;
838 boost::shared_ptr<ChannelList> c = channels.reader();
840 for (chan = c->begin(); chan != c->end(); ++chan) {
841 if ((*chan)->playback_buf->read_space() < (size_t) distance) {
849 AudioDiskstream::internal_playback_seek (framecnt_t distance)
851 ChannelList::iterator chan;
852 boost::shared_ptr<ChannelList> c = channels.reader();
854 for (chan = c->begin(); chan != c->end(); ++chan) {
855 (*chan)->playback_buf->increment_read_ptr (distance);
858 if (first_recordable_frame < max_framepos) {
859 first_recordable_frame += distance;
861 playback_sample += distance;
867 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer,
868 framepos_t& start, framecnt_t cnt,
869 ChannelInfo* /*channel_info*/, int channel, bool reversed)
871 framecnt_t this_read = 0;
873 framepos_t loop_end = 0;
874 framepos_t loop_start = 0;
875 framecnt_t offset = 0;
878 /* XXX we don't currently play loops in reverse. not sure why */
882 framecnt_t loop_length = 0;
884 /* Make the use of a Location atomic for this read operation.
886 Note: Locations don't get deleted, so all we care about
887 when I say "atomic" is that we are always pointing to
888 the same one and using a start/length values obtained
892 if ((loc = loop_location) != 0) {
893 loop_start = loc->start();
894 loop_end = loc->end();
895 loop_length = loop_end - loop_start;
898 /* if we are looping, ensure that the first frame we read is at the correct
899 position within the loop.
902 if (loc && start >= loop_end) {
903 //cerr << "start adjusted from " << start;
904 start = loop_start + ((start - loop_start) % loop_length);
905 //cerr << "to " << start << endl;
908 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
917 /* take any loop into account. we can't read past the end of the loop. */
919 if (loc && (loop_end - start < cnt)) {
920 this_read = loop_end - start;
921 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
928 if (this_read == 0) {
932 this_read = min(cnt,this_read);
934 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
935 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
940 _read_data_count = _playlist->read_data_count();
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, 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, 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 _write_data_count = 0;
1220 transvec.buf[0] = 0;
1221 transvec.buf[1] = 0;
1225 boost::shared_ptr<ChannelList> c = channels.reader();
1226 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1228 (*chan)->capture_buf->get_read_vector (&vector);
1230 total = vector.len[0] + vector.len[1];
1232 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1236 /* if there are 2+ chunks of disk i/o possible for
1237 this track, let the caller know so that it can arrange
1238 for us to be called again, ASAP.
1240 if we are forcing a flush, then if there is* any* extra
1241 work, let the caller know.
1243 if we are no longer recording and there is any extra work,
1244 let the caller know too.
1247 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1251 to_write = min (disk_io_chunk_frames, (framecnt_t) vector.len[0]);
1253 // check the transition buffer when recording destructive
1254 // important that we get this after the capture buf
1256 if (destructive()) {
1257 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1258 size_t transcount = transvec.len[0] + transvec.len[1];
1261 for (ti=0; ti < transcount; ++ti) {
1262 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1264 if (captrans.type == CaptureStart) {
1265 // by definition, the first data we got above represents the given capture pos
1267 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1268 (*chan)->curr_capture_cnt = 0;
1270 } else if (captrans.type == CaptureEnd) {
1272 // capture end, the capture_val represents total frames in capture
1274 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1276 // shorten to make the write a perfect fit
1277 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1279 if (nto_write < to_write) {
1280 ret = 1; // should we?
1282 to_write = nto_write;
1284 (*chan)->write_source->mark_capture_end ();
1286 // increment past this transition, but go no further
1291 // actually ends just beyond this chunk, so force more work
1299 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1303 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1304 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1308 (*chan)->capture_buf->increment_read_ptr (to_write);
1309 (*chan)->curr_capture_cnt += to_write;
1311 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1313 /* we wrote all of vector.len[0] but it wasn't an entire
1314 disk_io_chunk_frames of data, so arrange for some part
1315 of vector.len[1] to be flushed to disk as well.
1318 to_write = min ((framecnt_t)(disk_io_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1320 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1321 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1325 _write_data_count += (*chan)->write_source->write_data_count();
1327 (*chan)->capture_buf->increment_read_ptr (to_write);
1328 (*chan)->curr_capture_cnt += to_write;
1337 AudioDiskstream::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1339 uint32_t buffer_position;
1340 bool more_work = true;
1342 boost::shared_ptr<AudioRegion> region;
1343 framecnt_t total_capture;
1345 SourceList::iterator src;
1346 ChannelList::iterator chan;
1347 vector<CaptureInfo*>::iterator ci;
1348 boost::shared_ptr<ChannelList> c = channels.reader();
1350 bool mark_write_completed = false;
1352 finish_capture (true, c);
1354 /* butler is already stopped, but there may be work to do
1355 to flush remaining data to disk.
1358 while (more_work && !err) {
1359 switch (do_flush (TransportContext, true)) {
1366 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1371 /* XXX is there anything we can do if err != 0 ? */
1372 Glib::Mutex::Lock lm (capture_info_lock);
1374 if (capture_info.empty()) {
1378 if (abort_capture) {
1380 if (destructive()) {
1384 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1386 if ((*chan)->write_source) {
1388 (*chan)->write_source->mark_for_remove ();
1389 (*chan)->write_source->drop_references ();
1390 (*chan)->write_source.reset ();
1393 /* new source set up in "out" below */
1399 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1400 total_capture += (*ci)->frames;
1403 /* figure out the name for this take */
1405 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1407 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1411 s->update_header (capture_info.front()->start, when, twhen);
1412 s->set_captured_for (_name.val());
1413 s->mark_immutable ();
1415 if (Config->get_auto_analyse_audio()) {
1416 Analyser::queue_source_for_analysis (s, true);
1421 /* destructive tracks have a single, never changing region */
1423 if (destructive()) {
1425 /* send a signal that any UI can pick up to do the right thing. there is
1426 a small problem here in that a UI may need the peak data to be ready
1427 for the data that was recorded and this isn't interlocked with that
1428 process. this problem is deferred to the UI.
1431 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1435 string whole_file_region_name;
1436 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1438 /* Register a new region with the Session that
1439 describes the entire source. Do this first
1440 so that any sub-regions will obviously be
1441 children of this one (later!)
1447 plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1448 plist.add (Properties::length, total_capture);
1449 plist.add (Properties::name, whole_file_region_name);
1450 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1451 rx->set_automatic (true);
1452 rx->set_whole_file (true);
1454 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1455 region->special_set_position (capture_info.front()->start);
1459 catch (failed_constructor& err) {
1460 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1464 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1466 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1468 _playlist->clear_changes ();
1469 _playlist->freeze ();
1471 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1475 RegionFactory::region_name (region_name, whole_file_region_name, false);
1477 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1478 _name, (*ci)->start, (*ci)->frames, region_name));
1484 plist.add (Properties::start, buffer_position);
1485 plist.add (Properties::length, (*ci)->frames);
1486 plist.add (Properties::name, region_name);
1488 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1489 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1492 catch (failed_constructor& err) {
1493 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1494 continue; /* XXX is this OK? */
1497 i_am_the_modifier++;
1499 if (_playlist->explicit_relayering()) {
1500 /* We are in `explicit relayering' mode, so we must specify which layer this new region
1501 should end up on. Put it at the top.
1503 region->set_layer (_playlist->top_layer() + 1);
1504 region->set_pending_explicit_relayer (true);
1507 _playlist->add_region (region, (*ci)->start, 1, non_layered());
1508 i_am_the_modifier--;
1510 buffer_position += (*ci)->frames;
1514 _session.add_command (new StatefulDiffCommand (_playlist));
1517 mark_write_completed = true;
1520 reset_write_sources (mark_write_completed);
1524 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1528 capture_info.clear ();
1529 capture_start_frame = 0;
1533 AudioDiskstream::transport_looped (framepos_t transport_frame)
1535 if (was_recording) {
1536 // all we need to do is finish this capture, with modified capture length
1537 boost::shared_ptr<ChannelList> c = channels.reader();
1539 // adjust the capture length knowing that the data will be recorded to disk
1540 // only necessary after the first loop where we're recording
1541 if (capture_info.size() == 0) {
1542 capture_captured += _capture_offset;
1544 if (_alignment_style == ExistingMaterial) {
1545 capture_captured += _session.worst_output_latency();
1547 capture_captured += _roll_delay;
1551 finish_capture (true, c);
1553 // the next region will start recording via the normal mechanism
1554 // we'll set the start position to the current transport pos
1555 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1556 capture_start_frame = transport_frame;
1557 first_recordable_frame = transport_frame; // mild lie
1558 last_recordable_frame = max_framepos;
1559 was_recording = true;
1561 if (recordable() && destructive()) {
1562 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1564 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1565 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1567 if (transvec.len[0] > 0) {
1568 transvec.buf[0]->type = CaptureStart;
1569 transvec.buf[0]->capture_val = capture_start_frame;
1570 (*chan)->capture_transition_buf->increment_write_ptr(1);
1574 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1584 AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
1586 was_recording = false;
1587 first_recordable_frame = max_framepos;
1588 last_recordable_frame = max_framepos;
1590 if (capture_captured == 0) {
1594 if (recordable() && destructive()) {
1595 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1597 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1598 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1600 if (transvec.len[0] > 0) {
1601 transvec.buf[0]->type = CaptureEnd;
1602 transvec.buf[0]->capture_val = capture_captured;
1603 (*chan)->capture_transition_buf->increment_write_ptr(1);
1607 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1613 CaptureInfo* ci = new CaptureInfo;
1615 ci->start = capture_start_frame;
1616 ci->frames = capture_captured;
1618 /* XXX theoretical race condition here. Need atomic exchange ?
1619 However, the circumstances when this is called right
1620 now (either on record-disable or transport_stopped)
1621 mean that no actual race exists. I think ...
1622 We now have a capture_info_lock, but it is only to be used
1623 to synchronize in the transport_stop and the capture info
1624 accessors, so that invalidation will not occur (both non-realtime).
1627 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1629 capture_info.push_back (ci);
1630 capture_captured = 0;
1632 /* now we've finished a capture, reset first_recordable_frame for next time */
1633 first_recordable_frame = max_framepos;
1637 AudioDiskstream::set_record_enabled (bool yn)
1639 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1643 /* can't rec-enable in destructive mode if transport is before start */
1645 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1649 /* yes, i know that this not proof against race conditions, but its
1650 good enough. i think.
1653 if (record_enabled() != yn) {
1655 engage_record_enable ();
1657 disengage_record_enable ();
1663 AudioDiskstream::engage_record_enable ()
1665 bool rolling = _session.transport_speed() != 0.0f;
1666 boost::shared_ptr<ChannelList> c = channels.reader();
1668 g_atomic_int_set (&_record_enabled, 1);
1669 capturing_sources.clear ();
1671 if (Config->get_monitoring_model() == HardwareMonitoring) {
1673 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1674 (*chan)->source.ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
1675 capturing_sources.push_back ((*chan)->write_source);
1676 (*chan)->write_source->mark_streaming_write_started ();
1680 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1681 capturing_sources.push_back ((*chan)->write_source);
1682 (*chan)->write_source->mark_streaming_write_started ();
1686 RecordEnableChanged (); /* EMIT SIGNAL */
1690 AudioDiskstream::disengage_record_enable ()
1692 g_atomic_int_set (&_record_enabled, 0);
1693 boost::shared_ptr<ChannelList> c = channels.reader();
1694 if (Config->get_monitoring_model() == HardwareMonitoring) {
1695 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1696 (*chan)->source.ensure_monitor_input (false);
1699 capturing_sources.clear ();
1700 RecordEnableChanged (); /* EMIT SIGNAL */
1704 AudioDiskstream::get_state ()
1706 XMLNode& node (Diskstream::get_state());
1708 LocaleGuard lg (X_("POSIX"));
1710 boost::shared_ptr<ChannelList> c = channels.reader();
1711 snprintf (buf, sizeof(buf), "%zd", c->size());
1712 node.add_property ("channels", buf);
1714 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1716 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1717 XMLNode* cs_grandchild;
1719 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1720 cs_grandchild = new XMLNode (X_("file"));
1721 cs_grandchild->add_property (X_("path"), (*i)->path());
1722 cs_child->add_child_nocopy (*cs_grandchild);
1725 /* store the location where capture will start */
1729 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1730 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1732 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1735 cs_child->add_property (X_("at"), buf);
1736 node.add_child_nocopy (*cs_child);
1743 AudioDiskstream::set_state (const XMLNode& node, int version)
1745 const XMLProperty* prop;
1746 XMLNodeList nlist = node.children();
1747 XMLNodeIterator niter;
1748 uint32_t nchans = 1;
1749 XMLNode* capture_pending_node = 0;
1750 LocaleGuard lg (X_("POSIX"));
1752 /* prevent write sources from being created */
1754 in_set_state = true;
1756 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1757 if ((*niter)->name() == IO::state_node_name) {
1758 deprecated_io_node = new XMLNode (**niter);
1761 if ((*niter)->name() == X_("CapturingSources")) {
1762 capture_pending_node = *niter;
1766 if (Diskstream::set_state (node, version)) {
1770 if ((prop = node.property ("channels")) != 0) {
1771 nchans = atoi (prop->value().c_str());
1774 // create necessary extra channels
1775 // we are always constructed with one and we always need one
1777 _n_channels.set(DataType::AUDIO, channels.reader()->size());
1779 if (nchans > _n_channels.n_audio()) {
1781 add_channel (nchans - _n_channels.n_audio());
1782 IO::PortCountChanged(_n_channels);
1784 } else if (nchans < _n_channels.n_audio()) {
1786 remove_channel (_n_channels.n_audio() - nchans);
1791 if (!destructive() && capture_pending_node) {
1792 /* destructive streams have one and only one source per channel,
1793 and so they never end up in pending capture in any useful
1796 use_pending_capture_data (*capture_pending_node);
1799 in_set_state = false;
1801 /* make sure this is clear before we do anything else */
1803 capturing_sources.clear ();
1805 /* write sources are handled when we handle the input set
1806 up of the IO that owns this DS (::non_realtime_input_change())
1813 AudioDiskstream::use_new_write_source (uint32_t n)
1815 boost::shared_ptr<ChannelList> c = channels.reader();
1817 if (!recordable()) {
1821 if (n >= c->size()) {
1822 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1826 ChannelInfo* chan = (*c)[n];
1829 if ((chan->write_source = _session.create_audio_source_for_session (
1830 n_channels().n_audio(), name(), n, destructive())) == 0) {
1831 throw failed_constructor();
1835 catch (failed_constructor &err) {
1836 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1837 chan->write_source.reset ();
1841 /* do not remove destructive files even if they are empty */
1843 chan->write_source->set_allow_remove_if_empty (!destructive());
1848 list<boost::shared_ptr<Source> >
1849 AudioDiskstream::steal_write_sources()
1851 /* not possible to steal audio write sources */
1852 list<boost::shared_ptr<Source> > ret;
1857 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1859 ChannelList::iterator chan;
1860 boost::shared_ptr<ChannelList> c = channels.reader();
1863 if (!_session.writable() || !recordable()) {
1867 capturing_sources.clear ();
1869 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1871 if (!destructive()) {
1873 if ((*chan)->write_source) {
1875 if (mark_write_complete) {
1876 (*chan)->write_source->mark_streaming_write_completed ();
1877 (*chan)->write_source->done_with_peakfile_writes ();
1880 if ((*chan)->write_source->removable()) {
1881 (*chan)->write_source->mark_for_remove ();
1882 (*chan)->write_source->drop_references ();
1885 (*chan)->write_source.reset ();
1888 use_new_write_source (n);
1890 if (record_enabled()) {
1891 capturing_sources.push_back ((*chan)->write_source);
1896 if ((*chan)->write_source == 0) {
1897 use_new_write_source (n);
1902 if (destructive() && !c->empty ()) {
1904 /* we now have all our write sources set up, so create the
1905 playlist's single region.
1908 if (_playlist->empty()) {
1909 setup_destructive_playlist ();
1915 AudioDiskstream::set_block_size (pframes_t /*nframes*/)
1917 if (_session.get_block_size() > speed_buffer_size) {
1918 speed_buffer_size = _session.get_block_size();
1919 boost::shared_ptr<ChannelList> c = channels.reader();
1921 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1922 if ((*chan)->speed_buffer)
1923 delete [] (*chan)->speed_buffer;
1924 (*chan)->speed_buffer = new Sample[speed_buffer_size];
1927 allocate_temporary_buffers ();
1931 AudioDiskstream::allocate_temporary_buffers ()
1933 /* make sure the wrap buffer is at least large enough to deal
1934 with the speeds up to 1.2, to allow for micro-variation
1935 when slaving to MTC, Timecode etc.
1938 double const sp = max (fabsf (_actual_speed), 1.2f);
1939 framecnt_t required_wrap_size = (framecnt_t) floor (_session.get_block_size() * sp) + 1;
1941 if (required_wrap_size > wrap_buffer_size) {
1943 boost::shared_ptr<ChannelList> c = channels.reader();
1945 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1946 if ((*chan)->playback_wrap_buffer)
1947 delete [] (*chan)->playback_wrap_buffer;
1948 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
1949 if ((*chan)->capture_wrap_buffer)
1950 delete [] (*chan)->capture_wrap_buffer;
1951 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
1954 wrap_buffer_size = required_wrap_size;
1959 AudioDiskstream::monitor_input (bool yn)
1961 boost::shared_ptr<ChannelList> c = channels.reader();
1963 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1964 (*chan)->source.ensure_monitor_input (yn);
1969 AudioDiskstream::set_align_style_from_io ()
1971 bool have_physical = false;
1973 if (_alignment_choice != Automatic) {
1981 get_input_sources ();
1983 boost::shared_ptr<ChannelList> c = channels.reader();
1985 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1986 if ((*chan)->source.is_physical ()) {
1987 have_physical = true;
1992 if (have_physical) {
1993 set_align_style (ExistingMaterial);
1995 set_align_style (CaptureTime);
2000 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2002 while (how_many--) {
2003 c->push_back (new ChannelInfo(
2004 _session.butler()->audio_diskstream_playback_buffer_size(),
2005 _session.butler()->audio_diskstream_capture_buffer_size(),
2006 speed_buffer_size, wrap_buffer_size));
2007 interpolation.add_channel_to (
2008 _session.butler()->audio_diskstream_playback_buffer_size(),
2012 _n_channels.set(DataType::AUDIO, c->size());
2018 AudioDiskstream::add_channel (uint32_t how_many)
2020 RCUWriter<ChannelList> writer (channels);
2021 boost::shared_ptr<ChannelList> c = writer.get_copy();
2023 return add_channel_to (c, how_many);
2027 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2029 while (how_many-- && !c->empty()) {
2032 interpolation.remove_channel_from ();
2035 _n_channels.set(DataType::AUDIO, c->size());
2041 AudioDiskstream::remove_channel (uint32_t how_many)
2043 RCUWriter<ChannelList> writer (channels);
2044 boost::shared_ptr<ChannelList> c = writer.get_copy();
2046 return remove_channel_from (c, how_many);
2050 AudioDiskstream::playback_buffer_load () const
2052 boost::shared_ptr<ChannelList> c = channels.reader();
2058 return (float) ((double) c->front()->playback_buf->read_space()/
2059 (double) c->front()->playback_buf->bufsize());
2063 AudioDiskstream::capture_buffer_load () const
2065 boost::shared_ptr<ChannelList> c = channels.reader();
2071 return (float) ((double) c->front()->capture_buf->write_space()/
2072 (double) c->front()->capture_buf->bufsize());
2076 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2078 const XMLProperty* prop;
2079 XMLNodeList nlist = node.children();
2080 XMLNodeIterator niter;
2081 boost::shared_ptr<AudioFileSource> fs;
2082 boost::shared_ptr<AudioFileSource> first_fs;
2083 SourceList pending_sources;
2084 framepos_t position;
2086 if ((prop = node.property (X_("at"))) == 0) {
2090 if (sscanf (prop->value().c_str(), "%" PRIu64, &position) != 1) {
2094 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2095 if ((*niter)->name() == X_("file")) {
2097 if ((prop = (*niter)->property (X_("path"))) == 0) {
2101 // This protects sessions from errant CapturingSources in stored sessions
2103 if (stat (prop->value().c_str(), &sbuf)) {
2108 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2109 SourceFactory::createWritable (
2110 DataType::AUDIO, _session,
2111 prop->value(), string(), false, _session.frame_rate()));
2114 catch (failed_constructor& err) {
2115 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2116 _name, prop->value())
2121 pending_sources.push_back (fs);
2123 if (first_fs == 0) {
2127 fs->set_captured_for (_name.val());
2131 if (pending_sources.size() == 0) {
2132 /* nothing can be done */
2136 if (pending_sources.size() != _n_channels.n_audio()) {
2137 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2142 boost::shared_ptr<AudioRegion> region;
2148 plist.add (Properties::start, 0);
2149 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2150 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2152 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2154 region->set_automatic (true);
2155 region->set_whole_file (true);
2156 region->special_set_position (0);
2159 catch (failed_constructor& err) {
2160 error << string_compose (
2161 _("%1: cannot create whole-file region from pending capture sources"),
2167 _playlist->add_region (region, position);
2173 AudioDiskstream::set_non_layered (bool yn)
2175 if (yn != non_layered()) {
2178 _flags = Flag (_flags | NonLayered);
2180 _flags = Flag (_flags & ~NonLayered);
2188 AudioDiskstream::set_destructive (bool yn)
2190 if (yn != destructive()) {
2193 bool bounce_ignored;
2194 /* requestor should already have checked this and
2195 bounced if necessary and desired
2197 if (!can_become_destructive (bounce_ignored)) {
2200 _flags = Flag (_flags | Destructive);
2201 use_destructive_playlist ();
2203 _flags = Flag (_flags & ~Destructive);
2204 reset_write_sources (true, true);
2212 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2215 requires_bounce = false;
2219 /* is there only one region ? */
2221 if (_playlist->n_regions() != 1) {
2222 requires_bounce = true;
2226 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2228 requires_bounce = false;
2232 /* do the source(s) for the region cover the session start position ? */
2234 if (first->position() != _session.current_start_frame()) {
2235 if (first->start() > _session.current_start_frame()) {
2236 requires_bounce = true;
2241 /* is the source used by only 1 playlist ? */
2243 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2247 if (_session.playlists->source_use_count (afirst->source()) > 1) {
2248 requires_bounce = true;
2252 requires_bounce = false;
2257 AudioDiskstream::adjust_playback_buffering ()
2259 boost::shared_ptr<ChannelList> c = channels.reader();
2261 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2262 (*chan)->resize_playback (_session.butler()->audio_diskstream_playback_buffer_size());
2267 AudioDiskstream::adjust_capture_buffering ()
2269 boost::shared_ptr<ChannelList> c = channels.reader();
2271 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2272 (*chan)->resize_capture (_session.butler()->audio_diskstream_capture_buffer_size());
2277 AudioDiskstream::ChannelSource::is_physical () const
2283 return AudioEngine::instance()->port_is_physical (name);
2287 AudioDiskstream::ChannelSource::ensure_monitor_input (bool yn) const
2293 return AudioEngine::instance()->ensure_monitor_input (name, yn);
2296 AudioDiskstream::ChannelInfo::ChannelInfo (framecnt_t playback_bufsize, framecnt_t capture_bufsize, framecnt_t speed_size, framecnt_t wrap_size)
2299 current_capture_buffer = 0;
2300 current_playback_buffer = 0;
2301 curr_capture_cnt = 0;
2303 speed_buffer = new Sample[speed_size];
2304 playback_wrap_buffer = new Sample[wrap_size];
2305 capture_wrap_buffer = new Sample[wrap_size];
2307 playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2308 capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2309 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2311 /* touch the ringbuffer buffers, which will cause
2312 them to be mapped into locked physical RAM if
2313 we're running with mlockall(). this doesn't do
2317 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2318 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2319 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2323 AudioDiskstream::ChannelInfo::resize_playback (framecnt_t playback_bufsize)
2325 delete playback_buf;
2326 playback_buf = new RingBufferNPT<Sample> (playback_bufsize);
2327 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2331 AudioDiskstream::ChannelInfo::resize_capture (framecnt_t capture_bufsize)
2335 capture_buf = new RingBufferNPT<Sample> (capture_bufsize);
2336 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2339 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2341 write_source.reset ();
2343 delete [] speed_buffer;
2346 delete [] playback_wrap_buffer;
2347 playback_wrap_buffer = 0;
2349 delete [] capture_wrap_buffer;
2350 capture_wrap_buffer = 0;
2352 delete playback_buf;
2358 delete capture_transition_buf;
2359 capture_transition_buf = 0;
2364 AudioDiskstream::set_name (string const & name)
2366 Diskstream::set_name (name);
2368 /* get a new write source so that its name reflects the new diskstream name */
2370 boost::shared_ptr<ChannelList> c = channels.reader();
2371 ChannelList::iterator i;
2374 for (n = 0, i = c->begin(); i != c->end(); ++i, ++n) {
2375 use_new_write_source (n);