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/stacktrace.h>
40 #include <ardour/ardour.h>
41 #include <ardour/audioengine.h>
42 #include <ardour/audio_diskstream.h>
43 #include <ardour/utils.h>
44 #include <ardour/configuration.h>
45 #include <ardour/audiofilesource.h>
46 #include <ardour/send.h>
47 #include <ardour/region_factory.h>
48 #include <ardour/audioplaylist.h>
49 #include <ardour/playlist_factory.h>
50 #include <ardour/cycle_timer.h>
51 #include <ardour/audioregion.h>
52 #include <ardour/audio_port.h>
53 #include <ardour/source_factory.h>
59 using namespace ARDOUR;
62 size_t AudioDiskstream::_working_buffers_size = 0;
63 Sample* AudioDiskstream::_mixdown_buffer = 0;
64 gain_t* AudioDiskstream::_gain_buffer = 0;
66 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
67 : Diskstream(sess, name, flag)
68 , deprecated_io_node(NULL)
69 , channels (new ChannelList)
71 /* prevent any write sources from being created */
81 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
82 : Diskstream(sess, node)
83 , deprecated_io_node(NULL)
84 , channels (new ChannelList)
89 if (set_state (node)) {
91 throw failed_constructor();
97 use_destructive_playlist ();
102 AudioDiskstream::init (Diskstream::Flag f)
106 /* there are no channels at this point, so these
107 two calls just get speed_buffer_size and wrap_buffer
108 size setup without duplicating their code.
111 set_block_size (_session.get_block_size());
112 allocate_temporary_buffers ();
115 assert(_n_channels == ChanCount(DataType::AUDIO, 1));
118 AudioDiskstream::~AudioDiskstream ()
123 RCUWriter<ChannelList> writer (channels);
124 boost::shared_ptr<ChannelList> c = writer.get_copy();
126 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
137 AudioDiskstream::allocate_working_buffers()
139 assert(disk_io_frames() > 0);
141 _working_buffers_size = disk_io_frames();
142 _mixdown_buffer = new Sample[_working_buffers_size];
143 _gain_buffer = new gain_t[_working_buffers_size];
147 AudioDiskstream::free_working_buffers()
149 delete [] _mixdown_buffer;
150 delete [] _gain_buffer;
151 _working_buffers_size = 0;
157 AudioDiskstream::non_realtime_input_change ()
160 Glib::Mutex::Lock lm (state_lock);
162 if (input_change_pending == NoChange) {
167 RCUWriter<ChannelList> writer (channels);
168 boost::shared_ptr<ChannelList> c = writer.get_copy();
170 _n_channels.set(DataType::AUDIO, c->size());
172 if (_io->n_inputs().n_audio() > _n_channels.n_audio()) {
173 add_channel_to (c, _io->n_inputs().n_audio() - _n_channels.n_audio());
174 } else if (_io->n_inputs().n_audio() < _n_channels.n_audio()) {
175 remove_channel_from (c, _n_channels.n_audio() - _io->n_inputs().n_audio());
179 get_input_sources ();
180 set_capture_offset ();
182 if (first_input_change) {
183 set_align_style (_persistent_alignment_style);
184 first_input_change = false;
186 set_align_style_from_io ();
189 input_change_pending = NoChange;
191 /* implicit unlock */
194 /* reset capture files */
196 reset_write_sources (false);
198 /* now refill channel buffers */
200 if (speed() != 1.0f || speed() != -1.0f) {
201 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
203 seek (_session.transport_frame());
208 AudioDiskstream::get_input_sources ()
210 boost::shared_ptr<ChannelList> c = channels.reader();
213 ChannelList::iterator chan;
214 uint32_t ni = _io->n_inputs().n_audio();
215 vector<string> connections;
217 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
219 connections.clear ();
221 if (_io->input(n)->get_connections (connections) == 0) {
223 if ((*chan)->source) {
224 // _source->disable_metering ();
230 (*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
236 AudioDiskstream::find_and_use_playlist (const string& name)
238 boost::shared_ptr<AudioPlaylist> playlist;
240 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
241 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
245 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
249 return use_playlist (playlist);
253 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
255 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
257 Diskstream::use_playlist(playlist);
263 AudioDiskstream::use_new_playlist ()
266 boost::shared_ptr<AudioPlaylist> playlist;
268 if (!in_set_state && destructive()) {
273 newname = Playlist::bump_name (_playlist->name(), _session);
275 newname = Playlist::bump_name (_name, _session);
278 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
280 playlist->set_orig_diskstream_id (id());
281 return use_playlist (playlist);
289 AudioDiskstream::use_copy_playlist ()
291 assert(audio_playlist());
297 if (_playlist == 0) {
298 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
303 boost::shared_ptr<AudioPlaylist> playlist;
305 newname = Playlist::bump_name (_playlist->name(), _session);
307 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
308 playlist->set_orig_diskstream_id (id());
309 return use_playlist (playlist);
316 AudioDiskstream::setup_destructive_playlist ()
319 boost::shared_ptr<ChannelList> c = channels.reader();
321 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
322 srcs.push_back ((*chan)->write_source);
325 /* a single full-sized region */
327 boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
328 _playlist->add_region (region, srcs.front()->natural_position());
332 AudioDiskstream::use_destructive_playlist ()
334 /* this is called from the XML-based constructor or ::set_destructive. when called,
335 we already have a playlist and a region, but we need to
336 set up our sources for write. we use the sources associated
337 with the (presumed single, full-extent) region.
340 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
343 reset_write_sources (false, true);
347 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
350 throw failed_constructor();
353 /* be sure to stretch the region out to the maximum length */
355 region->set_length (max_frames - region->position(), this);
358 ChannelList::iterator chan;
359 boost::shared_ptr<ChannelList> c = channels.reader();
361 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
362 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
363 assert((*chan)->write_source);
364 (*chan)->write_source->set_allow_remove_if_empty (false);
366 /* this might be false if we switched modes, so force it */
368 (*chan)->write_source->set_destructive (true);
371 /* the source list will never be reset for a destructive track */
375 AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
377 int possibly_recording;
380 const int transport_rolling = 0x4;
381 const int track_rec_enabled = 0x2;
382 const int global_rec_enabled = 0x1;
384 /* merge together the 3 factors that affect record status, and compute
388 rolling = _session.transport_speed() != 0.0f;
389 possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
390 change = possibly_recording ^ last_possibly_recording;
392 if (possibly_recording == last_possibly_recording) {
398 /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
400 if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) ||
401 ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
403 /* starting to record: compute first+last frames */
405 first_recordable_frame = transport_frame + _capture_offset;
406 last_recordable_frame = max_frames;
407 capture_start_frame = transport_frame;
409 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
411 /* was stopped, now rolling (and recording) */
413 if (_alignment_style == ExistingMaterial) {
414 first_recordable_frame += _session.worst_output_latency();
416 first_recordable_frame += _roll_delay;
421 /* was rolling, but record state changed */
423 if (_alignment_style == ExistingMaterial) {
425 if (!Config->get_punch_in()) {
427 /* manual punch in happens at the correct transport frame
428 because the user hit a button. but to get alignment correct
429 we have to back up the position of the new region to the
430 appropriate spot given the roll delay.
433 capture_start_frame -= _roll_delay;
435 /* XXX paul notes (august 2005): i don't know why
439 first_recordable_frame += _capture_offset;
443 /* autopunch toggles recording at the precise
444 transport frame, and then the DS waits
445 to start recording for a time that depends
446 on the output latency.
449 first_recordable_frame += _session.worst_output_latency();
454 if (Config->get_punch_in()) {
455 first_recordable_frame += _roll_delay;
457 capture_start_frame -= _roll_delay;
463 if (recordable() && destructive()) {
464 boost::shared_ptr<ChannelList> c = channels.reader();
465 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
467 RingBufferNPT<CaptureTransition>::rw_vector transvec;
468 (*chan)->capture_transition_buf->get_write_vector(&transvec);
470 if (transvec.len[0] > 0) {
471 transvec.buf[0]->type = CaptureStart;
472 transvec.buf[0]->capture_val = capture_start_frame;
473 (*chan)->capture_transition_buf->increment_write_ptr(1);
477 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
483 } else if (!record_enabled() || !can_record) {
487 last_recordable_frame = transport_frame + _capture_offset;
489 if (_alignment_style == ExistingMaterial) {
490 last_recordable_frame += _session.worst_output_latency();
492 last_recordable_frame += _roll_delay;
496 last_possibly_recording = possibly_recording;
500 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
503 boost::shared_ptr<ChannelList> c = channels.reader();
504 ChannelList::iterator chan;
506 nframes_t rec_offset = 0;
507 nframes_t rec_nframes = 0;
508 bool nominally_recording;
509 bool re = record_enabled ();
510 bool collect_playback = false;
512 /* if we've already processed the frames corresponding to this call,
513 just return. this allows multiple routes that are taking input
514 from this diskstream to call our ::process() method, but have
515 this stuff only happen once. more commonly, it allows both
516 the AudioTrack that is using this AudioDiskstream *and* the Session
517 to call process() without problems.
524 commit_should_unlock = false;
526 check_record_status (transport_frame, nframes, can_record);
528 nominally_recording = (can_record && re);
535 /* This lock is held until the end of AudioDiskstream::commit, so these two functions
536 must always be called as a pair. The only exception is if this function
537 returns a non-zero value, in which case, ::commit should not be called.
540 // If we can't take the state lock return.
541 if (!state_lock.trylock()) {
544 commit_should_unlock = true;
545 adjust_capture_position = 0;
547 for (chan = c->begin(); chan != c->end(); ++chan) {
548 (*chan)->current_capture_buffer = 0;
549 (*chan)->current_playback_buffer = 0;
552 if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
555 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
556 if (last_recordable_frame < first_recordable_frame) {
557 last_recordable_frame = max_frames;
560 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
567 case OverlapInternal:
568 /* ---------- recrange
571 rec_nframes = nframes;
576 /* |--------| recrange
579 rec_nframes = transport_frame + nframes - first_recordable_frame;
581 rec_offset = first_recordable_frame - transport_frame;
586 /* |--------| recrange
589 rec_nframes = last_recordable_frame - transport_frame;
593 case OverlapExternal:
594 /* |--------| recrange
595 -------------- transrange
597 rec_nframes = last_recordable_frame - first_recordable_frame;
598 rec_offset = first_recordable_frame - transport_frame;
602 if (rec_nframes && !was_recording) {
603 capture_captured = 0;
604 was_recording = true;
609 if (can_record && !_last_capture_regions.empty()) {
610 _last_capture_regions.clear ();
613 if (nominally_recording || rec_nframes) {
615 uint32_t limit = _io->n_inputs ().n_audio();
617 /* one or more ports could already have been removed from _io, but our
618 channel setup hasn't yet been updated. prevent us from trying to
619 use channels that correspond to missing ports. note that the
620 process callback (from which this is called) is always atomic
621 with respect to port removal/addition.
624 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
626 ChannelInfo* chaninfo (*chan);
628 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
630 if (rec_nframes <= chaninfo->capture_vector.len[0]) {
632 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
634 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
638 AudioPort* const ap = _io->audio_input(n);
640 assert(rec_nframes <= ap->get_audio_buffer().capacity());
641 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer().data(rec_nframes, offset + rec_offset), sizeof (Sample) * rec_nframes);
645 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
647 if (rec_nframes > total) {
652 AudioPort* const ap = _io->audio_input(n);
655 Sample* buf = ap->get_audio_buffer().data(nframes, offset);
656 nframes_t first = chaninfo->capture_vector.len[0];
658 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
659 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
660 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
661 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
663 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
670 finish_capture (rec_monitors_input, c);
677 /* data will be written to disk */
679 if (rec_nframes == nframes && rec_offset == 0) {
681 for (chan = c->begin(); chan != c->end(); ++chan) {
682 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
685 playback_distance = nframes;
690 /* we can't use the capture buffer as the playback buffer, because
691 we recorded only a part of the current process' cycle data
695 collect_playback = true;
698 adjust_capture_position = rec_nframes;
700 } else if (nominally_recording) {
702 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
704 for (chan = c->begin(); chan != c->end(); ++chan) {
705 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
708 playback_distance = nframes;
712 collect_playback = true;
715 if (collect_playback) {
717 /* we're doing playback */
719 nframes_t necessary_samples;
721 /* no varispeed playback if we're recording, because the output .... TBD */
723 if (rec_nframes == 0 && _actual_speed != 1.0f) {
724 necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
726 necessary_samples = nframes;
729 for (chan = c->begin(); chan != c->end(); ++chan) {
730 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
735 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
737 ChannelInfo* chaninfo (*chan);
739 if (necessary_samples <= chaninfo->playback_vector.len[0]) {
741 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
744 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
746 if (necessary_samples > total) {
752 memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
753 chaninfo->playback_vector.len[0] * sizeof (Sample));
754 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
755 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
757 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
762 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
764 uint64_t phase = last_phase;
768 // Linearly interpolate into the alt buffer
769 // using 40.24 fixp maths (swh)
771 if (phi != target_phi) {
772 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
777 for (chan = c->begin(); chan != c->end(); ++chan) {
780 ChannelInfo* chaninfo (*chan);
785 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
787 fr = (phase & 0xFFFFFF) / 16777216.0f;
788 chaninfo->speed_buffer[outsample] =
789 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
790 chaninfo->current_playback_buffer[i+1] * fr;
791 phase += phi + phi_delta;
794 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
797 playback_distance = i; // + 1;
798 last_phase = (phase & 0xFFFFFF);
801 playback_distance = nframes;
815 /* we're exiting with failure, so ::commit will not
816 be called. unlock the state lock.
819 commit_should_unlock = false;
827 AudioDiskstream::commit (nframes_t nframes)
829 bool need_butler = false;
831 if (_actual_speed < 0.0) {
832 playback_sample -= playback_distance;
834 playback_sample += playback_distance;
837 boost::shared_ptr<ChannelList> c = channels.reader();
838 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
840 (*chan)->playback_buf->increment_read_ptr (playback_distance);
842 if (adjust_capture_position) {
843 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
847 if (adjust_capture_position != 0) {
848 capture_captured += adjust_capture_position;
849 adjust_capture_position = 0;
853 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
855 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
856 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
859 if (commit_should_unlock) {
869 AudioDiskstream::set_pending_overwrite (bool yn)
871 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
873 pending_overwrite = yn;
875 overwrite_frame = playback_sample;
876 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
880 AudioDiskstream::overwrite_existing_buffers ()
882 boost::shared_ptr<ChannelList> c = channels.reader();
883 Sample* mixdown_buffer;
886 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
888 overwrite_queued = false;
890 /* assume all are the same size */
891 nframes_t size = c->front()->playback_buf->bufsize();
893 mixdown_buffer = new Sample[size];
894 gain_buffer = new float[size];
896 /* reduce size so that we can fill the buffer correctly. */
902 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
904 start = overwrite_frame;
905 nframes_t cnt = size;
907 /* to fill the buffer without resetting the playback sample, we need to
908 do it one or two chunks (normally two).
910 |----------------------------------------------------------------------|
914 |<- second chunk->||<----------------- first chunk ------------------>|
918 nframes_t to_read = size - overwrite_offset;
920 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
921 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
922 _id, size, playback_sample) << endmsg;
930 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
931 start, cnt, *chan, n, reversed)) {
932 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
933 _id, size, playback_sample) << endmsg;
942 pending_overwrite = false;
943 delete [] gain_buffer;
944 delete [] mixdown_buffer;
949 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
953 ChannelList::iterator chan;
954 boost::shared_ptr<ChannelList> c = channels.reader();
956 Glib::Mutex::Lock lm (state_lock);
958 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
959 (*chan)->playback_buf->reset ();
960 (*chan)->capture_buf->reset ();
963 /* can't rec-enable in destructive mode if transport is before start */
965 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
966 disengage_record_enable ();
969 playback_sample = frame;
972 if (complete_refill) {
973 while ((ret = do_refill_with_alloc ()) > 0) ;
975 ret = do_refill_with_alloc ();
982 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
984 ChannelList::iterator chan;
985 boost::shared_ptr<ChannelList> c = channels.reader();
987 for (chan = c->begin(); chan != c->end(); ++chan) {
988 if ((*chan)->playback_buf->read_space() < distance) {
996 AudioDiskstream::internal_playback_seek (nframes_t distance)
998 ChannelList::iterator chan;
999 boost::shared_ptr<ChannelList> c = channels.reader();
1001 for (chan = c->begin(); chan != c->end(); ++chan) {
1002 (*chan)->playback_buf->increment_read_ptr (distance);
1005 first_recordable_frame += distance;
1006 playback_sample += distance;
1012 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1013 ChannelInfo* channel_info, int channel, bool reversed)
1015 nframes_t this_read = 0;
1016 bool reloop = false;
1017 nframes_t loop_end = 0;
1018 nframes_t loop_start = 0;
1019 nframes_t loop_length = 0;
1020 nframes_t offset = 0;
1023 /* XXX we don't currently play loops in reverse. not sure why */
1027 /* Make the use of a Location atomic for this read operation.
1029 Note: Locations don't get deleted, so all we care about
1030 when I say "atomic" is that we are always pointing to
1031 the same one and using a start/length values obtained
1035 if ((loc = loop_location) != 0) {
1036 loop_start = loc->start();
1037 loop_end = loc->end();
1038 loop_length = loop_end - loop_start;
1041 /* if we are looping, ensure that the first frame we read is at the correct
1042 position within the loop.
1045 if (loc && start >= loop_end) {
1046 //cerr << "start adjusted from " << start;
1047 start = loop_start + ((start - loop_start) % loop_length);
1048 //cerr << "to " << start << endl;
1051 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1060 /* take any loop into account. we can't read past the end of the loop. */
1062 if (loc && (loop_end - start < cnt)) {
1063 this_read = loop_end - start;
1064 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1071 if (this_read == 0) {
1075 this_read = min(cnt,this_read);
1077 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1078 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1083 _read_data_count = _playlist->read_data_count();
1087 swap_by_ptr (buf, buf + this_read - 1);
1091 /* if we read to the end of the loop, go back to the beginning */
1101 offset += this_read;
1108 AudioDiskstream::do_refill_with_alloc ()
1110 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1111 float* gain_buf = new float[disk_io_chunk_frames];
1113 int ret = _do_refill(mix_buf, gain_buf);
1122 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1126 RingBufferNPT<Sample>::rw_vector vector;
1127 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1128 nframes_t total_space;
1129 nframes_t zero_fill;
1131 ChannelList::iterator i;
1132 boost::shared_ptr<ChannelList> c = channels.reader();
1139 assert(mixdown_buffer);
1140 assert(gain_buffer);
1147 c->front()->playback_buf->get_write_vector (&vector);
1149 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1153 /* if there are 2+ chunks of disk i/o possible for
1154 this track, let the caller know so that it can arrange
1155 for us to be called again, ASAP.
1158 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1162 /* if we're running close to normal speed and there isn't enough
1163 space to do disk_io_chunk_frames of I/O, then don't bother.
1165 at higher speeds, just do it because the sync between butler
1166 and audio thread may not be good enough.
1169 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1173 /* when slaved, don't try to get too close to the read pointer. this
1174 leaves space for the buffer reversal to have something useful to
1178 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1182 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1184 total_space = min (disk_io_chunk_frames, total_space);
1188 if (file_frame == 0) {
1190 /* at start: nothing to do but fill with silence */
1192 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1194 ChannelInfo* chan (*i);
1195 chan->playback_buf->get_write_vector (&vector);
1196 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1197 if (vector.len[1]) {
1198 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1200 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1205 if (file_frame < total_space) {
1207 /* too close to the start: read what we can,
1208 and then zero fill the rest
1211 zero_fill = total_space - file_frame;
1212 total_space = file_frame;
1222 if (file_frame == max_frames) {
1224 /* at end: nothing to do but fill with silence */
1226 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1228 ChannelInfo* chan (*i);
1229 chan->playback_buf->get_write_vector (&vector);
1230 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1231 if (vector.len[1]) {
1232 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1234 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1239 if (file_frame > max_frames - total_space) {
1241 /* to close to the end: read what we can, and zero fill the rest */
1243 zero_fill = total_space - (max_frames - file_frame);
1244 total_space = max_frames - file_frame;
1251 nframes_t file_frame_tmp = 0;
1253 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1255 ChannelInfo* chan (*i);
1258 nframes_t len1, len2;
1260 chan->playback_buf->get_write_vector (&vector);
1262 if (vector.len[0] > disk_io_chunk_frames) {
1264 /* we're not going to fill the first chunk, so certainly do not bother with the
1265 other part. it won't be connected with the part we do fill, as in:
1267 .... => writable space
1268 ++++ => readable space
1269 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1271 |......|+++++++++++++|...............................|
1276 So, just pretend that the buf1 part isn't there.
1286 file_frame_tmp = file_frame;
1288 buf1 = vector.buf[0];
1289 len1 = vector.len[0];
1290 buf2 = vector.buf[1];
1291 len2 = vector.len[1];
1293 to_read = min (ts, len1);
1294 to_read = min (to_read, disk_io_chunk_frames);
1298 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1303 chan->playback_buf->increment_write_ptr (to_read);
1307 to_read = min (ts, len2);
1311 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1312 so read some or all of vector.len[1] as well.
1315 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1320 chan->playback_buf->increment_write_ptr (to_read);
1329 file_frame = file_frame_tmp;
1336 /** Flush pending data to disk.
1338 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1339 * of data to disk. it will never write more than that. If it writes that
1340 * much and there is more than that waiting to be written, it will return 1,
1341 * otherwise 0 on success or -1 on failure.
1343 * If there is less than disk_io_chunk_frames to be written, no data will be
1344 * written at all unless @a force_flush is true.
1347 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1351 RingBufferNPT<Sample>::rw_vector vector;
1352 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1355 _write_data_count = 0;
1357 transvec.buf[0] = 0;
1358 transvec.buf[1] = 0;
1362 boost::shared_ptr<ChannelList> c = channels.reader();
1363 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1365 (*chan)->capture_buf->get_read_vector (&vector);
1367 total = vector.len[0] + vector.len[1];
1369 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1373 /* if there are 2+ chunks of disk i/o possible for
1374 this track, let the caller know so that it can arrange
1375 for us to be called again, ASAP.
1377 if we are forcing a flush, then if there is* any* extra
1378 work, let the caller know.
1380 if we are no longer recording and there is any extra work,
1381 let the caller know too.
1384 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1388 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1390 // check the transition buffer when recording destructive
1391 // important that we get this after the capture buf
1393 if (destructive()) {
1394 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1395 size_t transcount = transvec.len[0] + transvec.len[1];
1396 bool have_start = false;
1399 for (ti=0; ti < transcount; ++ti) {
1400 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1402 if (captrans.type == CaptureStart) {
1403 // by definition, the first data we got above represents the given capture pos
1405 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1406 (*chan)->curr_capture_cnt = 0;
1410 else if (captrans.type == CaptureEnd) {
1412 // capture end, the capture_val represents total frames in capture
1414 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1416 // shorten to make the write a perfect fit
1417 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1419 if (nto_write < to_write) {
1420 ret = 1; // should we?
1422 to_write = nto_write;
1424 (*chan)->write_source->mark_capture_end ();
1426 // increment past this transition, but go no further
1431 // actually ends just beyond this chunk, so force more work
1439 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1443 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1444 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1448 (*chan)->capture_buf->increment_read_ptr (to_write);
1449 (*chan)->curr_capture_cnt += to_write;
1451 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1453 /* we wrote all of vector.len[0] but it wasn't an entire
1454 disk_io_chunk_frames of data, so arrange for some part
1455 of vector.len[1] to be flushed to disk as well.
1458 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1460 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1461 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1465 _write_data_count += (*chan)->write_source->write_data_count();
1467 (*chan)->capture_buf->increment_read_ptr (to_write);
1468 (*chan)->curr_capture_cnt += to_write;
1477 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1479 uint32_t buffer_position;
1480 bool more_work = true;
1482 boost::shared_ptr<AudioRegion> region;
1483 nframes_t total_capture;
1485 SourceList::iterator src;
1486 ChannelList::iterator chan;
1487 vector<CaptureInfo*>::iterator ci;
1488 boost::shared_ptr<ChannelList> c = channels.reader();
1490 bool mark_write_completed = false;
1492 finish_capture (true, c);
1494 /* butler is already stopped, but there may be work to do
1495 to flush remaining data to disk.
1498 while (more_work && !err) {
1499 switch (do_flush (Session::TransportContext, true)) {
1506 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1511 /* XXX is there anything we can do if err != 0 ? */
1512 Glib::Mutex::Lock lm (capture_info_lock);
1514 if (capture_info.empty()) {
1518 if (abort_capture) {
1520 if (destructive()) {
1524 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1526 if ((*chan)->write_source) {
1528 (*chan)->write_source->mark_for_remove ();
1529 (*chan)->write_source->drop_references ();
1530 (*chan)->write_source.reset ();
1533 /* new source set up in "out" below */
1539 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1540 total_capture += (*ci)->frames;
1543 /* figure out the name for this take */
1545 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1547 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1551 s->update_header (capture_info.front()->start, when, twhen);
1552 s->set_captured_for (_name);
1553 s->mark_immutable ();
1557 /* destructive tracks have a single, never changing region */
1559 if (destructive()) {
1561 /* send a signal that any UI can pick up to do the right thing. there is
1562 a small problem here in that a UI may need the peak data to be ready
1563 for the data that was recorded and this isn't interlocked with that
1564 process. this problem is deferred to the UI.
1567 _playlist->Modified();
1571 string whole_file_region_name;
1572 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1574 /* Register a new region with the Session that
1575 describes the entire source. Do this first
1576 so that any sub-regions will obviously be
1577 children of this one (later!)
1581 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1582 whole_file_region_name,
1583 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1585 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1586 region->special_set_position (capture_info.front()->start);
1590 catch (failed_constructor& err) {
1591 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1595 _last_capture_regions.push_back (region);
1597 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1599 XMLNode &before = _playlist->get_state();
1600 _playlist->freeze ();
1602 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1606 _session.region_name (region_name, whole_file_region_name, false);
1608 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1611 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1612 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1615 catch (failed_constructor& err) {
1616 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1617 continue; /* XXX is this OK? */
1620 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1622 _last_capture_regions.push_back (region);
1624 i_am_the_modifier++;
1625 _playlist->add_region (region, (*ci)->start);
1626 i_am_the_modifier--;
1628 buffer_position += (*ci)->frames;
1632 XMLNode &after = _playlist->get_state();
1633 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1636 mark_write_completed = true;
1639 reset_write_sources (mark_write_completed);
1643 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1647 capture_info.clear ();
1648 capture_start_frame = 0;
1652 AudioDiskstream::transport_looped (nframes_t transport_frame)
1654 if (was_recording) {
1655 // all we need to do is finish this capture, with modified capture length
1656 boost::shared_ptr<ChannelList> c = channels.reader();
1658 // adjust the capture length knowing that the data will be recorded to disk
1659 // only necessary after the first loop where we're recording
1660 if (capture_info.size() == 0) {
1661 capture_captured += _capture_offset;
1663 if (_alignment_style == ExistingMaterial) {
1664 capture_captured += _session.worst_output_latency();
1666 capture_captured += _roll_delay;
1670 finish_capture (true, c);
1672 // the next region will start recording via the normal mechanism
1673 // we'll set the start position to the current transport pos
1674 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1675 capture_start_frame = transport_frame;
1676 first_recordable_frame = transport_frame; // mild lie
1677 last_recordable_frame = max_frames;
1678 was_recording = true;
1680 if (recordable() && destructive()) {
1681 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1683 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1684 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1686 if (transvec.len[0] > 0) {
1687 transvec.buf[0]->type = CaptureStart;
1688 transvec.buf[0]->capture_val = capture_start_frame;
1689 (*chan)->capture_transition_buf->increment_write_ptr(1);
1693 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1703 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1705 was_recording = false;
1707 if (capture_captured == 0) {
1711 if (recordable() && destructive()) {
1712 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1714 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1715 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1717 if (transvec.len[0] > 0) {
1718 transvec.buf[0]->type = CaptureEnd;
1719 transvec.buf[0]->capture_val = capture_captured;
1720 (*chan)->capture_transition_buf->increment_write_ptr(1);
1724 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1730 CaptureInfo* ci = new CaptureInfo;
1732 ci->start = capture_start_frame;
1733 ci->frames = capture_captured;
1735 /* XXX theoretical race condition here. Need atomic exchange ?
1736 However, the circumstances when this is called right
1737 now (either on record-disable or transport_stopped)
1738 mean that no actual race exists. I think ...
1739 We now have a capture_info_lock, but it is only to be used
1740 to synchronize in the transport_stop and the capture info
1741 accessors, so that invalidation will not occur (both non-realtime).
1744 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1746 capture_info.push_back (ci);
1747 capture_captured = 0;
1749 /* now we've finished a capture, reset first_recordable_frame for next time */
1750 first_recordable_frame = max_frames;
1754 AudioDiskstream::set_record_enabled (bool yn)
1756 if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs().n_audio() == 0) {
1760 /* can't rec-enable in destructive mode if transport is before start */
1762 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1766 if (yn && channels.reader()->front()->source == 0) {
1768 /* pick up connections not initiated *from* the IO object
1769 we're associated with.
1772 get_input_sources ();
1775 /* yes, i know that this not proof against race conditions, but its
1776 good enough. i think.
1779 if (record_enabled() != yn) {
1781 engage_record_enable ();
1783 disengage_record_enable ();
1789 AudioDiskstream::engage_record_enable ()
1791 bool rolling = _session.transport_speed() != 0.0f;
1792 boost::shared_ptr<ChannelList> c = channels.reader();
1794 g_atomic_int_set (&_record_enabled, 1);
1795 capturing_sources.clear ();
1797 if (Config->get_monitoring_model() == HardwareMonitoring) {
1799 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1800 if ((*chan)->source) {
1801 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1803 capturing_sources.push_back ((*chan)->write_source);
1804 (*chan)->write_source->mark_streaming_write_started ();
1808 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1809 capturing_sources.push_back ((*chan)->write_source);
1810 (*chan)->write_source->mark_streaming_write_started ();
1814 RecordEnableChanged (); /* EMIT SIGNAL */
1818 AudioDiskstream::disengage_record_enable ()
1820 g_atomic_int_set (&_record_enabled, 0);
1821 boost::shared_ptr<ChannelList> c = channels.reader();
1822 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1823 if (Config->get_monitoring_model() == HardwareMonitoring) {
1824 if ((*chan)->source) {
1825 (*chan)->source->ensure_monitor_input (false);
1829 capturing_sources.clear ();
1830 RecordEnableChanged (); /* EMIT SIGNAL */
1834 AudioDiskstream::get_state ()
1836 XMLNode* node = new XMLNode ("AudioDiskstream");
1838 LocaleGuard lg (X_("POSIX"));
1839 boost::shared_ptr<ChannelList> c = channels.reader();
1841 node->add_property ("flags", enum_2_string (_flags));
1843 snprintf (buf, sizeof(buf), "%zd", c->size());
1844 node->add_property ("channels", buf);
1846 node->add_property ("playlist", _playlist->name());
1848 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1849 node->add_property ("speed", buf);
1851 node->add_property("name", _name);
1852 id().print (buf, sizeof (buf));
1853 node->add_property("id", buf);
1855 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1857 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1858 XMLNode* cs_grandchild;
1860 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1861 cs_grandchild = new XMLNode (X_("file"));
1862 cs_grandchild->add_property (X_("path"), (*i)->path());
1863 cs_child->add_child_nocopy (*cs_grandchild);
1866 /* store the location where capture will start */
1870 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1871 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1873 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1876 cs_child->add_property (X_("at"), buf);
1877 node->add_child_nocopy (*cs_child);
1881 node->add_child_copy (*_extra_xml);
1888 AudioDiskstream::set_state (const XMLNode& node)
1890 const XMLProperty* prop;
1891 XMLNodeList nlist = node.children();
1892 XMLNodeIterator niter;
1893 uint32_t nchans = 1;
1894 XMLNode* capture_pending_node = 0;
1895 LocaleGuard lg (X_("POSIX"));
1897 in_set_state = true;
1899 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1900 if ((*niter)->name() == IO::state_node_name) {
1901 deprecated_io_node = new XMLNode (**niter);
1904 if ((*niter)->name() == X_("CapturingSources")) {
1905 capture_pending_node = *niter;
1909 /* prevent write sources from being created */
1911 in_set_state = true;
1913 if ((prop = node.property ("name")) != 0) {
1914 _name = prop->value();
1917 if (deprecated_io_node) {
1918 if ((prop = deprecated_io_node->property ("id")) != 0) {
1919 _id = prop->value ();
1922 if ((prop = node.property ("id")) != 0) {
1923 _id = prop->value ();
1927 if ((prop = node.property ("flags")) != 0) {
1928 _flags = Flag (string_2_enum (prop->value(), _flags));
1931 if ((prop = node.property ("channels")) != 0) {
1932 nchans = atoi (prop->value().c_str());
1935 // create necessary extra channels
1936 // we are always constructed with one and we always need one
1938 _n_channels.set(DataType::AUDIO, channels.reader()->size());
1940 if (nchans > _n_channels.n_audio()) {
1942 add_channel (nchans - _n_channels.n_audio());
1944 } else if (nchans < _n_channels.n_audio()) {
1946 remove_channel (_n_channels.n_audio() - nchans);
1949 if ((prop = node.property ("playlist")) == 0) {
1954 bool had_playlist = (_playlist != 0);
1956 if (find_and_use_playlist (prop->value())) {
1960 if (!had_playlist) {
1961 _playlist->set_orig_diskstream_id (_id);
1964 if (!destructive() && capture_pending_node) {
1965 /* destructive streams have one and only one source per channel,
1966 and so they never end up in pending capture in any useful
1969 use_pending_capture_data (*capture_pending_node);
1974 if ((prop = node.property ("speed")) != 0) {
1975 double sp = atof (prop->value().c_str());
1977 if (realtime_set_speed (sp, false)) {
1978 non_realtime_set_speed ();
1982 in_set_state = false;
1984 /* make sure this is clear before we do anything else */
1986 capturing_sources.clear ();
1988 /* write sources are handled when we handle the input set
1989 up of the IO that owns this DS (::non_realtime_input_change())
1992 in_set_state = false;
1998 AudioDiskstream::use_new_write_source (uint32_t n)
2000 boost::shared_ptr<ChannelList> c = channels.reader();
2002 if (!recordable()) {
2006 if (n >= c->size()) {
2007 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2011 ChannelInfo* chan = (*c)[n];
2013 if (chan->write_source) {
2014 chan->write_source->done_with_peakfile_writes ();
2015 chan->write_source->set_allow_remove_if_empty (true);
2016 chan->write_source.reset ();
2020 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2021 throw failed_constructor();
2025 catch (failed_constructor &err) {
2026 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2027 chan->write_source.reset ();
2031 /* do not remove destructive files even if they are empty */
2033 chan->write_source->set_allow_remove_if_empty (!destructive());
2039 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2041 ChannelList::iterator chan;
2042 boost::shared_ptr<ChannelList> c = channels.reader();
2045 if (!recordable()) {
2049 capturing_sources.clear ();
2051 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2052 if (!destructive()) {
2054 if ((*chan)->write_source && mark_write_complete) {
2055 (*chan)->write_source->mark_streaming_write_completed ();
2057 use_new_write_source (n);
2059 if (record_enabled()) {
2060 capturing_sources.push_back ((*chan)->write_source);
2064 if ((*chan)->write_source == 0) {
2065 use_new_write_source (n);
2070 if (destructive()) {
2072 /* we now have all our write sources set up, so create the
2073 playlist's single region.
2076 if (_playlist->empty()) {
2077 setup_destructive_playlist ();
2083 AudioDiskstream::rename_write_sources ()
2085 ChannelList::iterator chan;
2086 boost::shared_ptr<ChannelList> c = channels.reader();
2089 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2090 if ((*chan)->write_source != 0) {
2091 (*chan)->write_source->set_source_name (_name, destructive());
2092 /* XXX what to do if one of them fails ? */
2100 AudioDiskstream::set_block_size (nframes_t nframes)
2102 if (_session.get_block_size() > speed_buffer_size) {
2103 speed_buffer_size = _session.get_block_size();
2104 boost::shared_ptr<ChannelList> c = channels.reader();
2106 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2107 if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2108 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2111 allocate_temporary_buffers ();
2115 AudioDiskstream::allocate_temporary_buffers ()
2117 /* make sure the wrap buffer is at least large enough to deal
2118 with the speeds up to 1.2, to allow for micro-variation
2119 when slaving to MTC, SMPTE etc.
2122 double sp = max (fabsf (_actual_speed), 1.2f);
2123 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2125 if (required_wrap_size > wrap_buffer_size) {
2127 boost::shared_ptr<ChannelList> c = channels.reader();
2129 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2130 if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2131 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2132 if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2133 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2136 wrap_buffer_size = required_wrap_size;
2141 AudioDiskstream::monitor_input (bool yn)
2143 boost::shared_ptr<ChannelList> c = channels.reader();
2145 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2147 if ((*chan)->source) {
2148 (*chan)->source->ensure_monitor_input (yn);
2154 AudioDiskstream::set_align_style_from_io ()
2156 bool have_physical = false;
2162 get_input_sources ();
2164 boost::shared_ptr<ChannelList> c = channels.reader();
2166 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2167 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2168 have_physical = true;
2173 if (have_physical) {
2174 set_align_style (ExistingMaterial);
2176 set_align_style (CaptureTime);
2181 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2183 while (how_many--) {
2184 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2187 _n_channels.set(DataType::AUDIO, c->size());
2193 AudioDiskstream::add_channel (uint32_t how_many)
2195 RCUWriter<ChannelList> writer (channels);
2196 boost::shared_ptr<ChannelList> c = writer.get_copy();
2198 return add_channel_to (c, how_many);
2202 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2204 while (--how_many && !c->empty()) {
2209 _n_channels.set(DataType::AUDIO, c->size());
2215 AudioDiskstream::remove_channel (uint32_t how_many)
2217 RCUWriter<ChannelList> writer (channels);
2218 boost::shared_ptr<ChannelList> c = writer.get_copy();
2220 return remove_channel_from (c, how_many);
2224 AudioDiskstream::playback_buffer_load () const
2226 boost::shared_ptr<ChannelList> c = channels.reader();
2228 return (float) ((double) c->front()->playback_buf->read_space()/
2229 (double) c->front()->playback_buf->bufsize());
2233 AudioDiskstream::capture_buffer_load () const
2235 boost::shared_ptr<ChannelList> c = channels.reader();
2237 return (float) ((double) c->front()->capture_buf->write_space()/
2238 (double) c->front()->capture_buf->bufsize());
2242 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2244 const XMLProperty* prop;
2245 XMLNodeList nlist = node.children();
2246 XMLNodeIterator niter;
2247 boost::shared_ptr<AudioFileSource> fs;
2248 boost::shared_ptr<AudioFileSource> first_fs;
2249 SourceList pending_sources;
2252 if ((prop = node.property (X_("at"))) == 0) {
2256 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2260 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2261 if ((*niter)->name() == X_("file")) {
2263 if ((prop = (*niter)->property (X_("path"))) == 0) {
2267 // This protects sessions from errant CapturingSources in stored sessions
2269 if (stat (prop->value().c_str(), &sbuf)) {
2274 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2275 SourceFactory::createWritable (DataType::AUDIO, _session, prop->value(), false, _session.frame_rate()));
2278 catch (failed_constructor& err) {
2279 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2280 _name, prop->value())
2285 pending_sources.push_back (fs);
2287 if (first_fs == 0) {
2291 fs->set_captured_for (_name);
2295 if (pending_sources.size() == 0) {
2296 /* nothing can be done */
2300 if (pending_sources.size() != _n_channels.n_audio()) {
2301 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2306 boost::shared_ptr<AudioRegion> region;
2309 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2310 region_name_from_path (first_fs->name(), true),
2311 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2312 region->special_set_position (0);
2315 catch (failed_constructor& err) {
2316 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2324 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2327 catch (failed_constructor& err) {
2328 error << string_compose (_("%1: cannot create region from pending capture sources"),
2335 _playlist->add_region (region, position);
2341 AudioDiskstream::set_destructive (bool yn)
2343 bool bounce_ignored;
2345 if (yn != destructive()) {
2348 /* requestor should already have checked this and
2349 bounced if necessary and desired
2351 if (!can_become_destructive (bounce_ignored)) {
2354 _flags = Flag (_flags | Destructive);
2355 use_destructive_playlist ();
2357 _flags = Flag (_flags & ~Destructive);
2358 reset_write_sources (true, true);
2366 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2369 requires_bounce = false;
2373 /* is there only one region ? */
2375 if (_playlist->n_regions() != 1) {
2376 requires_bounce = true;
2380 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2383 /* do the source(s) for the region cover the session start position ? */
2385 if (first->position() != _session.current_start_frame()) {
2386 if (first->start() > _session.current_start_frame()) {
2387 requires_bounce = true;
2392 /* is the source used by only 1 playlist ? */
2394 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2398 if (afirst->source()->used() > 1) {
2399 requires_bounce = true;
2403 requires_bounce = false;
2407 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2411 current_capture_buffer = 0;
2412 current_playback_buffer = 0;
2413 curr_capture_cnt = 0;
2415 speed_buffer = new Sample[speed_size];
2416 playback_wrap_buffer = new Sample[wrap_size];
2417 capture_wrap_buffer = new Sample[wrap_size];
2419 playback_buf = new RingBufferNPT<Sample> (bufsize);
2420 capture_buf = new RingBufferNPT<Sample> (bufsize);
2421 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2423 /* touch the ringbuffer buffers, which will cause
2424 them to be mapped into locked physical RAM if
2425 we're running with mlockall(). this doesn't do
2429 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2430 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2431 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2434 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2437 write_source.reset ();
2441 delete [] speed_buffer;
2445 if (playback_wrap_buffer) {
2446 delete [] playback_wrap_buffer;
2447 playback_wrap_buffer = 0;
2450 if (capture_wrap_buffer) {
2451 delete [] capture_wrap_buffer;
2452 capture_wrap_buffer = 0;
2456 delete playback_buf;
2465 if (capture_transition_buf) {
2466 delete capture_transition_buf;
2467 capture_transition_buf = 0;