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 <glibmm/thread.h>
35 #include "pbd/xml++.h"
36 #include "pbd/memento_command.h"
37 #include "pbd/enumwriter.h"
38 #include "pbd/stateful_diff_command.h"
40 #include "ardour/analyser.h"
41 #include "ardour/ardour.h"
42 #include "ardour/audio_buffer.h"
43 #include "ardour/audio_diskstream.h"
44 #include "ardour/audio_port.h"
45 #include "ardour/audioengine.h"
46 #include "ardour/audiofilesource.h"
48 #include "ardour/audioplaylist.h"
49 #include "ardour/audioregion.h"
50 #include "ardour/butler.h"
51 #include "ardour/configuration.h"
52 #include "ardour/cycle_timer.h"
53 #include "ardour/debug.h"
54 #include "ardour/io.h"
55 #include "ardour/playlist_factory.h"
56 #include "ardour/region_factory.h"
57 #include "ardour/send.h"
58 #include "ardour/session.h"
59 #include "ardour/source_factory.h"
60 #include "ardour/utils.h"
61 #include "ardour/session_playlists.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 , deprecated_io_node(NULL)
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 , deprecated_io_node(NULL)
89 , channels (new ChannelList)
94 if (set_state (node, Stateful::loading_state_version)) {
96 throw failed_constructor();
102 use_destructive_playlist ();
107 AudioDiskstream::init ()
109 /* there are no channels at this point, so these
110 two calls just get speed_buffer_size and wrap_buffer
111 size setup without duplicating their code.
114 set_block_size (_session.get_block_size());
115 allocate_temporary_buffers ();
118 assert(_n_channels == ChanCount(DataType::AUDIO, 1));
121 AudioDiskstream::~AudioDiskstream ()
123 DEBUG_TRACE (DEBUG::Destruction, string_compose ("Audio Diskstream %1 destructor\n", _name));
126 RCUWriter<ChannelList> writer (channels);
127 boost::shared_ptr<ChannelList> c = writer.get_copy();
129 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
138 delete deprecated_io_node;
142 AudioDiskstream::allocate_working_buffers()
144 assert(disk_io_frames() > 0);
146 _working_buffers_size = disk_io_frames();
147 _mixdown_buffer = new Sample[_working_buffers_size];
148 _gain_buffer = new gain_t[_working_buffers_size];
152 AudioDiskstream::free_working_buffers()
154 delete [] _mixdown_buffer;
155 delete [] _gain_buffer;
156 _working_buffers_size = 0;
162 AudioDiskstream::non_realtime_input_change ()
165 Glib::Mutex::Lock lm (state_lock);
167 if (input_change_pending == NoChange) {
172 RCUWriter<ChannelList> writer (channels);
173 boost::shared_ptr<ChannelList> c = writer.get_copy();
175 _n_channels.set(DataType::AUDIO, c->size());
177 if (_io->n_ports().n_audio() > _n_channels.n_audio()) {
178 add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
179 } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
180 remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().n_audio());
184 get_input_sources ();
185 set_capture_offset ();
187 if (first_input_change) {
188 set_align_style (_persistent_alignment_style);
189 first_input_change = false;
191 set_align_style_from_io ();
194 input_change_pending = NoChange;
196 /* implicit unlock */
199 /* reset capture files */
201 reset_write_sources (false);
203 /* now refill channel buffers */
205 if (speed() != 1.0f || speed() != -1.0f) {
206 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
208 seek (_session.transport_frame());
213 AudioDiskstream::non_realtime_locate (nframes_t location)
215 /* now refill channel buffers */
217 if (speed() != 1.0f || speed() != -1.0f) {
218 seek ((nframes_t) (location * (double) speed()));
225 AudioDiskstream::get_input_sources ()
227 boost::shared_ptr<ChannelList> c = channels.reader();
230 ChannelList::iterator chan;
231 uint32_t ni = _io->n_ports().n_audio();
232 vector<string> connections;
234 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
236 connections.clear ();
238 if (_io->nth (n)->get_connections (connections) == 0) {
240 if ((*chan)->source) {
241 // _source->disable_metering ();
247 (*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
253 AudioDiskstream::find_and_use_playlist (const string& name)
255 boost::shared_ptr<AudioPlaylist> playlist;
257 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlists->by_name (name))) == 0) {
258 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
262 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
266 return use_playlist (playlist);
270 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
272 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
274 Diskstream::use_playlist(playlist);
280 AudioDiskstream::use_new_playlist ()
283 boost::shared_ptr<AudioPlaylist> playlist;
285 if (!in_set_state && destructive()) {
290 newname = Playlist::bump_name (_playlist->name(), _session);
292 newname = Playlist::bump_name (_name, _session);
295 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
297 playlist->set_orig_diskstream_id (id());
298 return use_playlist (playlist);
306 AudioDiskstream::use_copy_playlist ()
308 assert(audio_playlist());
314 if (_playlist == 0) {
315 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
320 boost::shared_ptr<AudioPlaylist> playlist;
322 newname = Playlist::bump_name (_playlist->name(), _session);
324 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
325 playlist->set_orig_diskstream_id (id());
326 return use_playlist (playlist);
333 AudioDiskstream::setup_destructive_playlist ()
336 boost::shared_ptr<ChannelList> c = channels.reader();
338 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
339 srcs.push_back ((*chan)->write_source);
342 /* a single full-sized region */
344 assert (!srcs.empty ());
347 plist.add (Properties::name, _name.val());
348 plist.add (Properties::start, 0);
349 plist.add (Properties::length, max_frames - max_frames - srcs.front()->natural_position());
351 boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
352 _playlist->add_region (region, srcs.front()->natural_position());
356 AudioDiskstream::use_destructive_playlist ()
358 /* this is called from the XML-based constructor or ::set_destructive. when called,
359 we already have a playlist and a region, but we need to
360 set up our sources for write. we use the sources associated
361 with the (presumed single, full-extent) region.
364 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
367 reset_write_sources (false, true);
371 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
374 throw failed_constructor();
377 /* be sure to stretch the region out to the maximum length */
379 region->set_length (max_frames - region->position(), this);
382 ChannelList::iterator chan;
383 boost::shared_ptr<ChannelList> c = channels.reader();
385 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
386 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
387 assert((*chan)->write_source);
388 (*chan)->write_source->set_allow_remove_if_empty (false);
390 /* this might be false if we switched modes, so force it */
392 (*chan)->write_source->set_destructive (true);
395 /* the source list will never be reset for a destructive track */
399 AudioDiskstream::prepare_record_status(nframes_t capture_start_frame)
401 if (recordable() && destructive()) {
402 boost::shared_ptr<ChannelList> c = channels.reader();
403 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
405 RingBufferNPT<CaptureTransition>::rw_vector transvec;
406 (*chan)->capture_transition_buf->get_write_vector(&transvec);
408 if (transvec.len[0] > 0) {
409 transvec.buf[0]->type = CaptureStart;
410 transvec.buf[0]->capture_val = capture_start_frame;
411 (*chan)->capture_transition_buf->increment_write_ptr(1);
415 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
423 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
426 boost::shared_ptr<ChannelList> c = channels.reader();
427 ChannelList::iterator chan;
429 nframes_t rec_offset = 0;
430 nframes_t rec_nframes = 0;
431 bool collect_playback = false;
433 playback_distance = 0;
435 if (!_io || !_io->active()) {
439 check_record_status (transport_frame, nframes, can_record);
445 Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
451 adjust_capture_position = 0;
453 for (chan = c->begin(); chan != c->end(); ++chan) {
454 (*chan)->current_capture_buffer = 0;
455 (*chan)->current_playback_buffer = 0;
458 /* two conditions to test for here:
460 A: this track is rec-enabled, and the session has confirmed that we can record
461 B: this track is rec-enabled, has been recording, and we are set up for auto-punch-in
463 The second test is necessary to capture the extra material that arrives AFTER the transport
464 frame has left the punch range (which will cause the "can_record" argument to be false).
468 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
469 if (last_recordable_frame < first_recordable_frame) {
470 last_recordable_frame = max_frames;
473 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
475 calculate_record_range (ot, transport_frame, nframes, rec_nframes, rec_offset);
477 if (rec_nframes && !was_recording) {
478 capture_captured = 0;
479 was_recording = true;
482 if (can_record && !_last_capture_regions.empty()) {
483 _last_capture_regions.clear ();
488 uint32_t limit = _io->n_ports ().n_audio();
490 /* one or more ports could already have been removed from _io, but our
491 channel setup hasn't yet been updated. prevent us from trying to
492 use channels that correspond to missing ports. note that the
493 process callback (from which this is called) is always atomic
494 with respect to port removal/addition.
497 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
499 ChannelInfo* chaninfo (*chan);
501 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
503 if (rec_nframes <= chaninfo->capture_vector.len[0]) {
505 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
507 /* note: grab the entire port buffer, but only copy what we were supposed to
508 for recording, and use rec_offset
511 AudioPort* const ap = _io->audio (n);
513 assert(rec_nframes <= ap->get_audio_buffer(nframes).capacity());
514 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
519 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
521 if (rec_nframes > total) {
526 AudioPort* const ap = _io->audio (n);
529 Sample* buf = ap->get_audio_buffer(nframes).data();
530 nframes_t first = chaninfo->capture_vector.len[0];
532 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
533 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
534 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
535 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
537 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
544 finish_capture (rec_monitors_input, c);
551 /* data will be written to disk */
553 if (rec_nframes == nframes && rec_offset == 0) {
555 for (chan = c->begin(); chan != c->end(); ++chan) {
556 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
559 playback_distance = nframes;
564 /* we can't use the capture buffer as the playback buffer, because
565 we recorded only a part of the current process' cycle data
569 collect_playback = true;
572 adjust_capture_position = rec_nframes;
574 } else if (can_record && record_enabled()) {
576 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
578 for (chan = c->begin(); chan != c->end(); ++chan) {
579 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
582 playback_distance = nframes;
586 collect_playback = true;
589 if (collect_playback) {
591 /* we're doing playback */
593 nframes_t necessary_samples;
595 /* no varispeed playback if we're recording, because the output .... TBD */
597 if (rec_nframes == 0 && _actual_speed != 1.0f) {
598 necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
600 necessary_samples = nframes;
603 for (chan = c->begin(); chan != c->end(); ++chan) {
604 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
609 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
611 ChannelInfo* chaninfo (*chan);
613 if (necessary_samples <= chaninfo->playback_vector.len[0]) {
615 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
618 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
620 if (necessary_samples > total) {
621 cerr << _name << " Need " << necessary_samples << " total = " << total << endl;
622 cerr << "underrun for " << _name << endl;
628 memcpy ((char *) chaninfo->playback_wrap_buffer,
629 chaninfo->playback_vector.buf[0],
630 chaninfo->playback_vector.len[0] * sizeof (Sample));
631 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
632 chaninfo->playback_vector.buf[1],
633 (necessary_samples - chaninfo->playback_vector.len[0])
636 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
641 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
642 process_varispeed_playback(nframes, c);
644 playback_distance = nframes;
647 _speed = _target_speed;
653 if (commit (nframes)) {
662 AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
664 ChannelList::iterator chan;
666 interpolation.set_speed (_target_speed);
669 for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
670 ChannelInfo* chaninfo (*chan);
672 playback_distance = interpolation.interpolate (
673 channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
675 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
680 AudioDiskstream::commit (nframes_t /* nframes */)
682 bool need_butler = false;
684 if (!_io || !_io->active()) {
688 if (_actual_speed < 0.0) {
689 playback_sample -= playback_distance;
691 playback_sample += playback_distance;
694 boost::shared_ptr<ChannelList> c = channels.reader();
695 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
697 (*chan)->playback_buf->increment_read_ptr (playback_distance);
699 if (adjust_capture_position) {
700 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
704 if (adjust_capture_position != 0) {
705 capture_captured += adjust_capture_position;
706 adjust_capture_position = 0;
710 if (_io && _io->active()) {
711 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
716 if (_io && _io->active()) {
717 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
718 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
720 need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
728 AudioDiskstream::set_pending_overwrite (bool yn)
730 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
732 pending_overwrite = yn;
734 overwrite_frame = playback_sample;
735 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
739 AudioDiskstream::overwrite_existing_buffers ()
741 boost::shared_ptr<ChannelList> c = channels.reader();
742 Sample* mixdown_buffer;
745 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
747 overwrite_queued = false;
749 /* assume all are the same size */
750 nframes_t size = c->front()->playback_buf->bufsize();
752 mixdown_buffer = new Sample[size];
753 gain_buffer = new float[size];
755 /* reduce size so that we can fill the buffer correctly. */
761 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
763 start = overwrite_frame;
764 nframes_t cnt = size;
766 /* to fill the buffer without resetting the playback sample, we need to
767 do it one or two chunks (normally two).
769 |----------------------------------------------------------------------|
773 |<- second chunk->||<----------------- first chunk ------------------>|
777 nframes_t to_read = size - overwrite_offset;
779 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
780 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
781 _id, size, playback_sample) << endmsg;
789 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
790 start, cnt, *chan, n, reversed)) {
791 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
792 _id, size, playback_sample) << endmsg;
801 pending_overwrite = false;
802 delete [] gain_buffer;
803 delete [] mixdown_buffer;
808 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
812 ChannelList::iterator chan;
813 boost::shared_ptr<ChannelList> c = channels.reader();
815 Glib::Mutex::Lock lm (state_lock);
817 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
818 (*chan)->playback_buf->reset ();
819 (*chan)->capture_buf->reset ();
822 /* can't rec-enable in destructive mode if transport is before start */
824 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
825 disengage_record_enable ();
828 playback_sample = frame;
831 if (complete_refill) {
832 while ((ret = do_refill_with_alloc ()) > 0) ;
834 ret = do_refill_with_alloc ();
841 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
843 ChannelList::iterator chan;
844 boost::shared_ptr<ChannelList> c = channels.reader();
846 for (chan = c->begin(); chan != c->end(); ++chan) {
847 if ((*chan)->playback_buf->read_space() < distance) {
855 AudioDiskstream::internal_playback_seek (nframes_t distance)
857 ChannelList::iterator chan;
858 boost::shared_ptr<ChannelList> c = channels.reader();
860 for (chan = c->begin(); chan != c->end(); ++chan) {
861 (*chan)->playback_buf->increment_read_ptr (distance);
864 first_recordable_frame += distance;
865 playback_sample += distance;
871 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
872 ChannelInfo* /*channel_info*/, int channel, bool reversed)
874 nframes_t this_read = 0;
876 nframes_t loop_end = 0;
877 nframes_t loop_start = 0;
878 nframes_t offset = 0;
881 /* XXX we don't currently play loops in reverse. not sure why */
885 nframes_t loop_length = 0;
887 /* Make the use of a Location atomic for this read operation.
889 Note: Locations don't get deleted, so all we care about
890 when I say "atomic" is that we are always pointing to
891 the same one and using a start/length values obtained
895 if ((loc = loop_location) != 0) {
896 loop_start = loc->start();
897 loop_end = loc->end();
898 loop_length = loop_end - loop_start;
901 /* if we are looping, ensure that the first frame we read is at the correct
902 position within the loop.
905 if (loc && start >= loop_end) {
906 //cerr << "start adjusted from " << start;
907 start = loop_start + ((start - loop_start) % loop_length);
908 //cerr << "to " << start << endl;
911 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
920 /* take any loop into account. we can't read past the end of the loop. */
922 if (loc && (loop_end - start < cnt)) {
923 this_read = loop_end - start;
924 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
931 if (this_read == 0) {
935 this_read = min(cnt,this_read);
937 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
938 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
943 _read_data_count = _playlist->read_data_count();
947 swap_by_ptr (buf, buf + this_read - 1);
951 /* if we read to the end of the loop, go back to the beginning */
968 AudioDiskstream::do_refill_with_alloc ()
970 Sample* mix_buf = new Sample[disk_io_chunk_frames];
971 float* gain_buf = new float[disk_io_chunk_frames];
973 int ret = _do_refill(mix_buf, gain_buf);
982 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
986 RingBufferNPT<Sample>::rw_vector vector;
987 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
988 nframes_t total_space;
991 ChannelList::iterator i;
992 boost::shared_ptr<ChannelList> c = channels.reader();
999 assert(mixdown_buffer);
1000 assert(gain_buffer);
1007 c->front()->playback_buf->get_write_vector (&vector);
1009 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1013 /* if there are 2+ chunks of disk i/o possible for
1014 this track, let the caller know so that it can arrange
1015 for us to be called again, ASAP.
1018 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1022 /* if we're running close to normal speed and there isn't enough
1023 space to do disk_io_chunk_frames of I/O, then don't bother.
1025 at higher speeds, just do it because the sync between butler
1026 and audio thread may not be good enough.
1029 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1033 /* when slaved, don't try to get too close to the read pointer. this
1034 leaves space for the buffer reversal to have something useful to
1038 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1042 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1044 total_space = min (disk_io_chunk_frames, total_space);
1048 if (file_frame == 0) {
1050 /* at start: nothing to do but fill with silence */
1052 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1054 ChannelInfo* chan (*i);
1055 chan->playback_buf->get_write_vector (&vector);
1056 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1057 if (vector.len[1]) {
1058 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1060 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1065 if (file_frame < total_space) {
1067 /* too close to the start: read what we can,
1068 and then zero fill the rest
1071 zero_fill = total_space - file_frame;
1072 total_space = file_frame;
1082 if (file_frame == max_frames) {
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_frames - total_space) {
1101 /* to close to the end: read what we can, and zero fill the rest */
1103 zero_fill = total_space - (max_frames - file_frame);
1104 total_space = max_frames - file_frame;
1111 nframes_t file_frame_tmp = 0;
1113 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1115 ChannelInfo* chan (*i);
1118 nframes_t len1, len2;
1120 chan->playback_buf->get_write_vector (&vector);
1122 if (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);
1158 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1163 chan->playback_buf->increment_write_ptr (to_read);
1167 to_read = min (ts, len2);
1171 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1172 so read some or all of vector.len[1] as well.
1175 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1180 chan->playback_buf->increment_write_ptr (to_read);
1189 file_frame = file_frame_tmp;
1196 /** Flush pending data to disk.
1198 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1199 * of data to disk. it will never write more than that. If it writes that
1200 * much and there is more than that waiting to be written, it will return 1,
1201 * otherwise 0 on success or -1 on failure.
1203 * If there is less than disk_io_chunk_frames to be written, no data will be
1204 * written at all unless @a force_flush is true.
1207 AudioDiskstream::do_flush (RunContext /*context*/, bool force_flush)
1211 RingBufferNPT<Sample>::rw_vector vector;
1212 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1215 _write_data_count = 0;
1217 transvec.buf[0] = 0;
1218 transvec.buf[1] = 0;
1222 boost::shared_ptr<ChannelList> c = channels.reader();
1223 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1225 (*chan)->capture_buf->get_read_vector (&vector);
1227 total = vector.len[0] + vector.len[1];
1229 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1233 /* if there are 2+ chunks of disk i/o possible for
1234 this track, let the caller know so that it can arrange
1235 for us to be called again, ASAP.
1237 if we are forcing a flush, then if there is* any* extra
1238 work, let the caller know.
1240 if we are no longer recording and there is any extra work,
1241 let the caller know too.
1244 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1248 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1250 // check the transition buffer when recording destructive
1251 // important that we get this after the capture buf
1253 if (destructive()) {
1254 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1255 size_t transcount = transvec.len[0] + transvec.len[1];
1256 bool have_start = false;
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;
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 ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_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 (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 nframes_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 ();
1414 if (Config->get_auto_analyse_audio()) {
1415 Analyser::queue_source_for_analysis (s, true);
1420 /* destructive tracks have a single, never changing region */
1422 if (destructive()) {
1424 /* send a signal that any UI can pick up to do the right thing. there is
1425 a small problem here in that a UI may need the peak data to be ready
1426 for the data that was recorded and this isn't interlocked with that
1427 process. this problem is deferred to the UI.
1430 _playlist->LayeringChanged(); // XXX this may not get the UI to do the right thing
1434 string whole_file_region_name;
1435 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1437 /* Register a new region with the Session that
1438 describes the entire source. Do this first
1439 so that any sub-regions will obviously be
1440 children of this one (later!)
1446 plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1447 plist.add (Properties::length, total_capture);
1448 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_regions.push_back (region);
1466 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1468 _playlist->clear_history ();
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 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1483 plist.add (Properties::start, buffer_position);
1484 plist.add (Properties::length, (*ci)->frames);
1485 plist.add (Properties::name, region_name);
1487 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1488 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1491 catch (failed_constructor& err) {
1492 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1493 continue; /* XXX is this OK? */
1496 region->DropReferences.connect_same_thread (*this, boost::bind (&Diskstream::remove_region_from_last_capture, this, boost::weak_ptr<Region>(region)));
1498 _last_capture_regions.push_back (region);
1500 i_am_the_modifier++;
1501 _playlist->add_region (region, (*ci)->start, 1, non_layered());
1502 i_am_the_modifier--;
1504 buffer_position += (*ci)->frames;
1508 _session.add_command (new StatefulDiffCommand (_playlist));
1511 mark_write_completed = true;
1514 reset_write_sources (mark_write_completed);
1518 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1522 capture_info.clear ();
1523 capture_start_frame = 0;
1527 AudioDiskstream::transport_looped (nframes_t transport_frame)
1529 if (was_recording) {
1530 // all we need to do is finish this capture, with modified capture length
1531 boost::shared_ptr<ChannelList> c = channels.reader();
1533 // adjust the capture length knowing that the data will be recorded to disk
1534 // only necessary after the first loop where we're recording
1535 if (capture_info.size() == 0) {
1536 capture_captured += _capture_offset;
1538 if (_alignment_style == ExistingMaterial) {
1539 capture_captured += _session.worst_output_latency();
1541 capture_captured += _roll_delay;
1545 finish_capture (true, c);
1547 // the next region will start recording via the normal mechanism
1548 // we'll set the start position to the current transport pos
1549 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1550 capture_start_frame = transport_frame;
1551 first_recordable_frame = transport_frame; // mild lie
1552 last_recordable_frame = max_frames;
1553 was_recording = true;
1555 if (recordable() && destructive()) {
1556 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1558 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1559 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1561 if (transvec.len[0] > 0) {
1562 transvec.buf[0]->type = CaptureStart;
1563 transvec.buf[0]->capture_val = capture_start_frame;
1564 (*chan)->capture_transition_buf->increment_write_ptr(1);
1568 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1578 AudioDiskstream::finish_capture (bool /*rec_monitors_input*/, boost::shared_ptr<ChannelList> c)
1580 was_recording = false;
1581 first_recordable_frame = max_frames;
1582 last_recordable_frame = max_frames;
1584 if (capture_captured == 0) {
1588 if (recordable() && destructive()) {
1589 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1591 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1592 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1594 if (transvec.len[0] > 0) {
1595 transvec.buf[0]->type = CaptureEnd;
1596 transvec.buf[0]->capture_val = capture_captured;
1597 (*chan)->capture_transition_buf->increment_write_ptr(1);
1601 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1607 CaptureInfo* ci = new CaptureInfo;
1609 ci->start = capture_start_frame;
1610 ci->frames = capture_captured;
1612 /* XXX theoretical race condition here. Need atomic exchange ?
1613 However, the circumstances when this is called right
1614 now (either on record-disable or transport_stopped)
1615 mean that no actual race exists. I think ...
1616 We now have a capture_info_lock, but it is only to be used
1617 to synchronize in the transport_stop and the capture info
1618 accessors, so that invalidation will not occur (both non-realtime).
1621 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1623 capture_info.push_back (ci);
1624 capture_captured = 0;
1626 /* now we've finished a capture, reset first_recordable_frame for next time */
1627 first_recordable_frame = max_frames;
1631 AudioDiskstream::set_record_enabled (bool yn)
1633 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1637 /* can't rec-enable in destructive mode if transport is before start */
1639 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1643 /* yes, i know that this not proof against race conditions, but its
1644 good enough. i think.
1647 if (record_enabled() != yn) {
1649 engage_record_enable ();
1651 disengage_record_enable ();
1657 AudioDiskstream::engage_record_enable ()
1659 bool rolling = _session.transport_speed() != 0.0f;
1660 boost::shared_ptr<ChannelList> c = channels.reader();
1662 g_atomic_int_set (&_record_enabled, 1);
1663 capturing_sources.clear ();
1665 if (Config->get_monitoring_model() == HardwareMonitoring) {
1667 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1668 if ((*chan)->source) {
1669 (*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 if ((*chan)->source) {
1693 (*chan)->source->ensure_monitor_input (false);
1697 capturing_sources.clear ();
1698 RecordEnableChanged (); /* EMIT SIGNAL */
1702 AudioDiskstream::get_state ()
1704 XMLNode* node = new XMLNode ("AudioDiskstream");
1706 LocaleGuard lg (X_("POSIX"));
1707 boost::shared_ptr<ChannelList> c = channels.reader();
1709 node->add_property ("flags", enum_2_string (_flags));
1711 snprintf (buf, sizeof(buf), "%zd", c->size());
1712 node->add_property ("channels", buf);
1714 node->add_property ("playlist", _playlist->name());
1716 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1717 node->add_property ("speed", buf);
1719 node->add_property("name", _name);
1720 id().print (buf, sizeof (buf));
1721 node->add_property("id", buf);
1723 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1725 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1726 XMLNode* cs_grandchild;
1728 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1729 cs_grandchild = new XMLNode (X_("file"));
1730 cs_grandchild->add_property (X_("path"), (*i)->path());
1731 cs_child->add_child_nocopy (*cs_grandchild);
1734 /* store the location where capture will start */
1738 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1739 snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1741 snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1744 cs_child->add_property (X_("at"), buf);
1745 node->add_child_nocopy (*cs_child);
1749 node->add_child_copy (*_extra_xml);
1756 AudioDiskstream::set_state (const XMLNode& node, int /*version*/)
1758 const XMLProperty* prop;
1759 XMLNodeList nlist = node.children();
1760 XMLNodeIterator niter;
1761 uint32_t nchans = 1;
1762 XMLNode* capture_pending_node = 0;
1763 LocaleGuard lg (X_("POSIX"));
1765 in_set_state = true;
1767 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1768 if ((*niter)->name() == IO::state_node_name) {
1769 deprecated_io_node = new XMLNode (**niter);
1772 if ((*niter)->name() == X_("CapturingSources")) {
1773 capture_pending_node = *niter;
1777 /* prevent write sources from being created */
1779 in_set_state = true;
1781 if ((prop = node.property ("name")) != 0) {
1782 _name = prop->value();
1785 if (deprecated_io_node) {
1786 if ((prop = deprecated_io_node->property ("id")) != 0) {
1787 _id = prop->value ();
1790 if ((prop = node.property ("id")) != 0) {
1791 _id = prop->value ();
1795 if ((prop = node.property ("flags")) != 0) {
1796 _flags = Flag (string_2_enum (prop->value(), _flags));
1799 if ((prop = node.property ("channels")) != 0) {
1800 nchans = atoi (prop->value().c_str());
1803 // create necessary extra channels
1804 // we are always constructed with one and we always need one
1806 _n_channels.set(DataType::AUDIO, channels.reader()->size());
1808 if (nchans > _n_channels.n_audio()) {
1810 add_channel (nchans - _n_channels.n_audio());
1811 IO::PortCountChanged(_n_channels);
1813 } else if (nchans < _n_channels.n_audio()) {
1815 remove_channel (_n_channels.n_audio() - nchans);
1818 if ((prop = node.property ("playlist")) == 0) {
1823 bool had_playlist = (_playlist != 0);
1825 if (find_and_use_playlist (prop->value())) {
1829 if (!had_playlist) {
1830 _playlist->set_orig_diskstream_id (_id);
1833 if (!destructive() && capture_pending_node) {
1834 /* destructive streams have one and only one source per channel,
1835 and so they never end up in pending capture in any useful
1838 use_pending_capture_data (*capture_pending_node);
1843 if ((prop = node.property ("speed")) != 0) {
1844 double sp = atof (prop->value().c_str());
1846 if (realtime_set_speed (sp, false)) {
1847 non_realtime_set_speed ();
1851 in_set_state = false;
1853 /* make sure this is clear before we do anything else */
1855 capturing_sources.clear ();
1857 /* write sources are handled when we handle the input set
1858 up of the IO that owns this DS (::non_realtime_input_change())
1865 AudioDiskstream::use_new_write_source (uint32_t n)
1867 boost::shared_ptr<ChannelList> c = channels.reader();
1869 if (!recordable()) {
1873 if (n >= c->size()) {
1874 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1878 ChannelInfo* chan = (*c)[n];
1880 if (chan->write_source) {
1881 chan->write_source->done_with_peakfile_writes ();
1882 chan->write_source->set_allow_remove_if_empty (true);
1883 chan->write_source.reset ();
1887 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
1888 throw failed_constructor();
1892 catch (failed_constructor &err) {
1893 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1894 chan->write_source.reset ();
1898 /* do not remove destructive files even if they are empty */
1900 chan->write_source->set_allow_remove_if_empty (!destructive());
1902 /* until we write, this file is considered removable */
1904 chan->write_source->mark_for_remove ();
1910 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1912 ChannelList::iterator chan;
1913 boost::shared_ptr<ChannelList> c = channels.reader();
1916 if (!_session.writable() || !recordable()) {
1920 capturing_sources.clear ();
1922 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1923 if (!destructive()) {
1925 if ((*chan)->write_source && mark_write_complete) {
1926 (*chan)->write_source->mark_streaming_write_completed ();
1928 use_new_write_source (n);
1930 if (record_enabled()) {
1931 capturing_sources.push_back ((*chan)->write_source);
1935 if ((*chan)->write_source == 0) {
1936 use_new_write_source (n);
1941 if (destructive() && !c->empty ()) {
1943 /* we now have all our write sources set up, so create the
1944 playlist's single region.
1947 if (_playlist->empty()) {
1948 setup_destructive_playlist ();
1954 AudioDiskstream::rename_write_sources ()
1956 ChannelList::iterator chan;
1957 boost::shared_ptr<ChannelList> c = channels.reader();
1960 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1961 if ((*chan)->write_source != 0) {
1962 (*chan)->write_source->set_source_name (_name.val(), destructive());
1963 /* XXX what to do if one of them fails ? */
1971 AudioDiskstream::set_block_size (nframes_t /*nframes*/)
1973 if (_session.get_block_size() > speed_buffer_size) {
1974 speed_buffer_size = _session.get_block_size();
1975 boost::shared_ptr<ChannelList> c = channels.reader();
1977 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1978 if ((*chan)->speed_buffer)
1979 delete [] (*chan)->speed_buffer;
1980 (*chan)->speed_buffer = new Sample[speed_buffer_size];
1983 allocate_temporary_buffers ();
1987 AudioDiskstream::allocate_temporary_buffers ()
1989 /* make sure the wrap buffer is at least large enough to deal
1990 with the speeds up to 1.2, to allow for micro-variation
1991 when slaving to MTC, Timecode etc.
1994 double sp = max (fabsf (_actual_speed), 1.2f);
1995 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
1997 if (required_wrap_size > wrap_buffer_size) {
1999 boost::shared_ptr<ChannelList> c = channels.reader();
2001 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2002 if ((*chan)->playback_wrap_buffer)
2003 delete [] (*chan)->playback_wrap_buffer;
2004 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2005 if ((*chan)->capture_wrap_buffer)
2006 delete [] (*chan)->capture_wrap_buffer;
2007 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2010 wrap_buffer_size = required_wrap_size;
2015 AudioDiskstream::monitor_input (bool yn)
2017 boost::shared_ptr<ChannelList> c = channels.reader();
2019 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2021 if ((*chan)->source) {
2022 (*chan)->source->ensure_monitor_input (yn);
2028 AudioDiskstream::set_align_style_from_io ()
2030 bool have_physical = false;
2036 get_input_sources ();
2038 boost::shared_ptr<ChannelList> c = channels.reader();
2040 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2041 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2042 have_physical = true;
2047 if (have_physical) {
2048 set_align_style (ExistingMaterial);
2050 set_align_style (CaptureTime);
2055 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2057 while (how_many--) {
2058 c->push_back (new ChannelInfo(_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2059 interpolation.add_channel_to (_session.butler()->audio_diskstream_buffer_size(), speed_buffer_size);
2062 _n_channels.set(DataType::AUDIO, c->size());
2068 AudioDiskstream::add_channel (uint32_t how_many)
2070 RCUWriter<ChannelList> writer (channels);
2071 boost::shared_ptr<ChannelList> c = writer.get_copy();
2073 return add_channel_to (c, how_many);
2077 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2079 while (how_many-- && !c->empty()) {
2082 interpolation.remove_channel_from ();
2085 _n_channels.set(DataType::AUDIO, c->size());
2091 AudioDiskstream::remove_channel (uint32_t how_many)
2093 RCUWriter<ChannelList> writer (channels);
2094 boost::shared_ptr<ChannelList> c = writer.get_copy();
2096 return remove_channel_from (c, how_many);
2100 AudioDiskstream::playback_buffer_load () const
2102 boost::shared_ptr<ChannelList> c = channels.reader();
2104 return (float) ((double) c->front()->playback_buf->read_space()/
2105 (double) c->front()->playback_buf->bufsize());
2109 AudioDiskstream::capture_buffer_load () const
2111 boost::shared_ptr<ChannelList> c = channels.reader();
2113 return (float) ((double) c->front()->capture_buf->write_space()/
2114 (double) c->front()->capture_buf->bufsize());
2118 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2120 const XMLProperty* prop;
2121 XMLNodeList nlist = node.children();
2122 XMLNodeIterator niter;
2123 boost::shared_ptr<AudioFileSource> fs;
2124 boost::shared_ptr<AudioFileSource> first_fs;
2125 SourceList pending_sources;
2128 if ((prop = node.property (X_("at"))) == 0) {
2132 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2136 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2137 if ((*niter)->name() == X_("file")) {
2139 if ((prop = (*niter)->property (X_("path"))) == 0) {
2143 // This protects sessions from errant CapturingSources in stored sessions
2145 if (stat (prop->value().c_str(), &sbuf)) {
2150 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2151 SourceFactory::createWritable (DataType::AUDIO, _session,
2152 prop->value(), false, _session.frame_rate()));
2155 catch (failed_constructor& err) {
2156 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2157 _name, prop->value())
2162 pending_sources.push_back (fs);
2164 if (first_fs == 0) {
2168 fs->set_captured_for (_name.val());
2172 if (pending_sources.size() == 0) {
2173 /* nothing can be done */
2177 if (pending_sources.size() != _n_channels.n_audio()) {
2178 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2183 boost::shared_ptr<AudioRegion> region;
2189 plist.add (Properties::start, 0);
2190 plist.add (Properties::length, first_fs->length (first_fs->timeline_position()));
2191 plist.add (Properties::name, region_name_from_path (first_fs->name(), true));
2193 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, plist));
2195 region->set_automatic (true);
2196 region->set_whole_file (true);
2197 region->special_set_position (0);
2200 catch (failed_constructor& err) {
2201 error << string_compose (
2202 _("%1: cannot create whole-file region from pending capture sources"),
2208 _playlist->add_region (region, position);
2214 AudioDiskstream::set_non_layered (bool yn)
2216 if (yn != non_layered()) {
2219 _flags = Flag (_flags | NonLayered);
2221 _flags = Flag (_flags & ~NonLayered);
2229 AudioDiskstream::set_destructive (bool yn)
2231 if (yn != destructive()) {
2234 bool bounce_ignored;
2235 /* requestor should already have checked this and
2236 bounced if necessary and desired
2238 if (!can_become_destructive (bounce_ignored)) {
2241 _flags = Flag (_flags | Destructive);
2242 use_destructive_playlist ();
2244 _flags = Flag (_flags & ~Destructive);
2245 reset_write_sources (true, true);
2253 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2256 requires_bounce = false;
2260 /* is there only one region ? */
2262 if (_playlist->n_regions() != 1) {
2263 requires_bounce = true;
2267 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2269 requires_bounce = false;
2273 /* do the source(s) for the region cover the session start position ? */
2275 if (first->position() != _session.current_start_frame()) {
2276 if (first->start() > _session.current_start_frame()) {
2277 requires_bounce = true;
2282 /* is the source used by only 1 playlist ? */
2284 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2288 if (_session.playlists->source_use_count (afirst->source()) > 1) {
2289 requires_bounce = true;
2293 requires_bounce = false;
2297 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2301 current_capture_buffer = 0;
2302 current_playback_buffer = 0;
2303 curr_capture_cnt = 0;
2305 speed_buffer = new Sample[speed_size];
2306 playback_wrap_buffer = new Sample[wrap_size];
2307 capture_wrap_buffer = new Sample[wrap_size];
2309 playback_buf = new RingBufferNPT<Sample> (bufsize);
2310 capture_buf = new RingBufferNPT<Sample> (bufsize);
2311 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2313 /* touch the ringbuffer buffers, which will cause
2314 them to be mapped into locked physical RAM if
2315 we're running with mlockall(). this doesn't do
2319 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2320 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2321 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2324 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2326 write_source.reset ();
2328 delete [] speed_buffer;
2331 delete [] playback_wrap_buffer;
2332 playback_wrap_buffer = 0;
2334 delete [] capture_wrap_buffer;
2335 capture_wrap_buffer = 0;
2337 delete playback_buf;
2343 delete capture_transition_buf;
2344 capture_transition_buf = 0;