2 Copyright (C) 2000-2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 #include <pbd/error.h>
34 #include <pbd/basename.h>
35 #include <glibmm/thread.h>
36 #include <pbd/xml++.h>
37 #include <pbd/memento_command.h>
38 #include <pbd/enumwriter.h>
39 #include <pbd/stacktrace.h>
41 #include <ardour/ardour.h>
42 #include <ardour/audioengine.h>
43 #include <ardour/audio_diskstream.h>
44 #include <ardour/utils.h>
45 #include <ardour/configuration.h>
46 #include <ardour/audiofilesource.h>
47 #include <ardour/send.h>
48 #include <ardour/region_factory.h>
49 #include <ardour/audioplaylist.h>
50 #include <ardour/playlist_factory.h>
51 #include <ardour/cycle_timer.h>
52 #include <ardour/audioregion.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 == 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 = c->size();
172 if (_io->n_inputs() > _n_channels) {
173 add_channel_to (c, _io->n_inputs() - _n_channels);
174 } else if (_io->n_inputs() < _n_channels) {
175 remove_channel_from (c, _n_channels - _io->n_inputs());
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();
216 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
218 const char **connections = _io->input(n)->get_connections ();
220 if (connections == 0 || connections[0] == 0) {
222 if ((*chan)->source) {
223 // _source->disable_metering ();
229 (*chan)->source = _session.engine().get_port_by_name (connections[0]);
239 AudioDiskstream::find_and_use_playlist (const string& name)
241 boost::shared_ptr<AudioPlaylist> playlist;
243 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
244 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (_session, name));
248 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
252 return use_playlist (playlist);
256 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
258 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
260 Diskstream::use_playlist(playlist);
266 AudioDiskstream::use_new_playlist ()
269 boost::shared_ptr<AudioPlaylist> playlist;
271 if (!in_set_state && destructive()) {
276 newname = Playlist::bump_name (_playlist->name(), _session);
278 newname = Playlist::bump_name (_name, _session);
281 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (_session, newname, hidden()))) != 0) {
283 playlist->set_orig_diskstream_id (id());
284 return use_playlist (playlist);
292 AudioDiskstream::use_copy_playlist ()
294 assert(audio_playlist());
300 if (_playlist == 0) {
301 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
306 boost::shared_ptr<AudioPlaylist> playlist;
308 newname = Playlist::bump_name (_playlist->name(), _session);
310 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
311 playlist->set_orig_diskstream_id (id());
312 return use_playlist (playlist);
319 AudioDiskstream::setup_destructive_playlist ()
322 boost::shared_ptr<ChannelList> c = channels.reader();
324 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
325 srcs.push_back ((*chan)->write_source);
328 /* a single full-sized region */
330 boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
331 _playlist->add_region (region, srcs.front()->natural_position());
335 AudioDiskstream::use_destructive_playlist ()
337 /* this is called from the XML-based constructor or ::set_destructive. when called,
338 we already have a playlist and a region, but we need to
339 set up our sources for write. we use the sources associated
340 with the (presumed single, full-extent) region.
343 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
346 reset_write_sources (false, true);
350 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
353 throw failed_constructor();
356 /* be sure to stretch the region out to the maximum length */
358 region->set_length (max_frames - region->position(), this);
361 ChannelList::iterator chan;
362 boost::shared_ptr<ChannelList> c = channels.reader();
364 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
365 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
366 assert((*chan)->write_source);
367 (*chan)->write_source->set_allow_remove_if_empty (false);
369 /* this might be false if we switched modes, so force it */
371 (*chan)->write_source->set_destructive (true);
374 /* the source list will never be reset for a destructive track */
378 AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
380 int possibly_recording;
383 const int transport_rolling = 0x4;
384 const int track_rec_enabled = 0x2;
385 const int global_rec_enabled = 0x1;
387 /* merge together the 3 factors that affect record status, and compute
391 rolling = _session.transport_speed() != 0.0f;
392 possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
393 change = possibly_recording ^ last_possibly_recording;
395 if (possibly_recording == last_possibly_recording) {
401 /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
403 if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) ||
404 ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
406 /* starting to record: compute first+last frames */
408 first_recordable_frame = transport_frame + _capture_offset;
409 last_recordable_frame = max_frames;
410 capture_start_frame = transport_frame;
412 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
414 /* was stopped, now rolling (and recording) */
416 if (_alignment_style == ExistingMaterial) {
417 first_recordable_frame += _session.worst_output_latency();
419 first_recordable_frame += _roll_delay;
424 /* was rolling, but record state changed */
426 if (_alignment_style == ExistingMaterial) {
428 if (!Config->get_punch_in()) {
430 /* manual punch in happens at the correct transport frame
431 because the user hit a button. but to get alignment correct
432 we have to back up the position of the new region to the
433 appropriate spot given the roll delay.
436 capture_start_frame -= _roll_delay;
438 /* XXX paul notes (august 2005): i don't know why
442 first_recordable_frame += _capture_offset;
446 /* autopunch toggles recording at the precise
447 transport frame, and then the DS waits
448 to start recording for a time that depends
449 on the output latency.
452 first_recordable_frame += _session.worst_output_latency();
457 if (Config->get_punch_in()) {
458 first_recordable_frame += _roll_delay;
460 capture_start_frame -= _roll_delay;
466 if (recordable() && destructive()) {
467 boost::shared_ptr<ChannelList> c = channels.reader();
468 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
470 RingBufferNPT<CaptureTransition>::rw_vector transvec;
471 (*chan)->capture_transition_buf->get_write_vector(&transvec);
473 if (transvec.len[0] > 0) {
474 transvec.buf[0]->type = CaptureStart;
475 transvec.buf[0]->capture_val = capture_start_frame;
476 (*chan)->capture_transition_buf->increment_write_ptr(1);
480 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
486 } else if (!record_enabled() || !can_record) {
490 last_recordable_frame = transport_frame + _capture_offset;
492 if (_alignment_style == ExistingMaterial) {
493 last_recordable_frame += _session.worst_output_latency();
495 last_recordable_frame += _roll_delay;
499 last_possibly_recording = possibly_recording;
503 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
506 boost::shared_ptr<ChannelList> c = channels.reader();
507 ChannelList::iterator chan;
509 nframes_t rec_offset = 0;
510 nframes_t rec_nframes = 0;
511 bool nominally_recording;
512 bool re = record_enabled ();
513 bool collect_playback = false;
515 /* if we've already processed the frames corresponding to this call,
516 just return. this allows multiple routes that are taking input
517 from this diskstream to call our ::process() method, but have
518 this stuff only happen once. more commonly, it allows both
519 the AudioTrack that is using this AudioDiskstream *and* the Session
520 to call process() without problems.
527 commit_should_unlock = false;
529 check_record_status (transport_frame, nframes, can_record);
531 nominally_recording = (can_record && re);
538 /* This lock is held until the end of AudioDiskstream::commit, so these two functions
539 must always be called as a pair. The only exception is if this function
540 returns a non-zero value, in which case, ::commit should not be called.
543 // If we can't take the state lock return.
544 if (!state_lock.trylock()) {
547 commit_should_unlock = true;
548 adjust_capture_position = 0;
550 for (chan = c->begin(); chan != c->end(); ++chan) {
551 (*chan)->current_capture_buffer = 0;
552 (*chan)->current_playback_buffer = 0;
555 if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
558 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
559 if (last_recordable_frame < first_recordable_frame) {
560 last_recordable_frame = max_frames;
564 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
571 case OverlapInternal:
572 /* ---------- recrange
575 rec_nframes = nframes;
580 /* |--------| recrange
583 rec_nframes = transport_frame + nframes - first_recordable_frame;
585 rec_offset = first_recordable_frame - transport_frame;
590 /* |--------| recrange
593 rec_nframes = last_recordable_frame - transport_frame;
597 case OverlapExternal:
598 /* |--------| recrange
599 -------------- transrange
601 rec_nframes = last_recordable_frame - first_recordable_frame;
602 rec_offset = first_recordable_frame - transport_frame;
606 if (rec_nframes && !was_recording) {
607 capture_captured = 0;
608 was_recording = true;
613 if (can_record && !_last_capture_regions.empty()) {
614 _last_capture_regions.clear ();
617 if (nominally_recording || rec_nframes) {
619 uint32_t limit = _io->n_inputs ();
621 /* one or more ports could already have been removed from _io, but our
622 channel setup hasn't yet been updated. prevent us from trying to
623 use channels that correspond to missing ports. note that the
624 process callback (from which this is called) is always atomic
625 with respect to port removal/addition.
628 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
630 ChannelInfo* chaninfo (*chan);
632 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
634 if (rec_nframes <= chaninfo->capture_vector.len[0]) {
636 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
638 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
642 memcpy (chaninfo->current_capture_buffer, _io->input(n)->get_buffer (rec_nframes) + offset + rec_offset, sizeof (Sample) * rec_nframes);
646 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
648 if (rec_nframes > total) {
650 if (Config->get_stop_recording_on_xrun()) {
655 Sample* buf = _io->input (n)->get_buffer (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) {
748 if (Config->get_stop_recording_on_xrun()) {
754 memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
755 chaninfo->playback_vector.len[0] * sizeof (Sample));
756 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
757 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
759 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
764 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
766 uint64_t phase = last_phase;
770 // Linearly interpolate into the alt buffer
771 // using 40.24 fixp maths (swh)
773 if (phi != target_phi) {
774 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
779 for (chan = c->begin(); chan != c->end(); ++chan) {
782 ChannelInfo* chaninfo (*chan);
787 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
789 fr = (phase & 0xFFFFFF) / 16777216.0f;
790 chaninfo->speed_buffer[outsample] =
791 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
792 chaninfo->current_playback_buffer[i+1] * fr;
793 phase += phi + phi_delta;
796 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
799 playback_distance = i; // + 1;
800 last_phase = (phase & 0xFFFFFF);
803 playback_distance = nframes;
816 /* we're exiting with failure, so ::commit will not
817 be called. unlock the state lock.
820 commit_should_unlock = false;
828 AudioDiskstream::commit (nframes_t nframes)
830 bool need_butler = false;
832 if (_actual_speed < 0.0) {
833 playback_sample -= playback_distance;
835 playback_sample += playback_distance;
838 boost::shared_ptr<ChannelList> c = channels.reader();
839 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
841 (*chan)->playback_buf->increment_read_ptr (playback_distance);
843 if (adjust_capture_position) {
844 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
848 if (adjust_capture_position != 0) {
849 capture_captured += adjust_capture_position;
850 adjust_capture_position = 0;
854 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
856 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
857 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
860 if (commit_should_unlock) {
870 AudioDiskstream::set_pending_overwrite (bool yn)
872 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
874 pending_overwrite = yn;
876 overwrite_frame = playback_sample;
877 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
881 AudioDiskstream::overwrite_existing_buffers ()
883 boost::shared_ptr<ChannelList> c = channels.reader();
884 Sample* mixdown_buffer;
887 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
889 overwrite_queued = false;
891 /* assume all are the same size */
892 nframes_t size = c->front()->playback_buf->bufsize();
894 mixdown_buffer = new Sample[size];
895 gain_buffer = new float[size];
897 /* reduce size so that we can fill the buffer correctly. */
903 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
905 start = overwrite_frame;
906 nframes_t cnt = size;
908 /* to fill the buffer without resetting the playback sample, we need to
909 do it one or two chunks (normally two).
911 |----------------------------------------------------------------------|
915 |<- second chunk->||<----------------- first chunk ------------------>|
919 nframes_t to_read = size - overwrite_offset;
921 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
922 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
923 _id, size, playback_sample) << endmsg;
931 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
932 start, cnt, *chan, n, reversed)) {
933 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
934 _id, size, playback_sample) << endmsg;
943 pending_overwrite = false;
944 delete [] gain_buffer;
945 delete [] mixdown_buffer;
950 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
954 ChannelList::iterator chan;
955 boost::shared_ptr<ChannelList> c = channels.reader();
957 Glib::Mutex::Lock lm (state_lock);
959 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
960 (*chan)->playback_buf->reset ();
961 (*chan)->capture_buf->reset ();
964 /* can't rec-enable in destructive mode if transport is before start */
966 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
967 disengage_record_enable ();
970 playback_sample = frame;
973 if (complete_refill) {
974 while ((ret = do_refill_with_alloc ()) > 0) ;
976 ret = do_refill_with_alloc ();
983 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
985 ChannelList::iterator chan;
986 boost::shared_ptr<ChannelList> c = channels.reader();
988 for (chan = c->begin(); chan != c->end(); ++chan) {
989 if ((*chan)->playback_buf->read_space() < distance) {
997 AudioDiskstream::internal_playback_seek (nframes_t distance)
999 ChannelList::iterator chan;
1000 boost::shared_ptr<ChannelList> c = channels.reader();
1002 for (chan = c->begin(); chan != c->end(); ++chan) {
1003 (*chan)->playback_buf->increment_read_ptr (distance);
1006 first_recordable_frame += distance;
1007 playback_sample += distance;
1013 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1014 ChannelInfo* channel_info, int channel, bool reversed)
1016 nframes_t this_read = 0;
1017 bool reloop = false;
1018 nframes_t loop_end = 0;
1019 nframes_t loop_start = 0;
1020 nframes_t loop_length = 0;
1021 nframes_t offset = 0;
1022 nframes_t xfade_samples = 0;
1023 Sample xfade_buf[128];
1026 /* XXX we don't currently play loops in reverse. not sure why */
1030 /* Make the use of a Location atomic for this read operation.
1032 Note: Locations don't get deleted, so all we care about
1033 when I say "atomic" is that we are always pointing to
1034 the same one and using a start/length values obtained
1038 if ((loc = loop_location) != 0) {
1039 loop_start = loc->start();
1040 loop_end = loc->end();
1041 loop_length = loop_end - loop_start;
1044 /* if we are looping, ensure that the first frame we read is at the correct
1045 position within the loop.
1048 if (loc && start >= loop_end) {
1049 //cerr << "start adjusted from " << start;
1050 start = loop_start + ((start - loop_start) % loop_length);
1051 //cerr << "to " << start << endl;
1054 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1063 /* take any loop into account. we can't read past the end of the loop. */
1065 if (loc && (loop_end - start < cnt)) {
1066 this_read = loop_end - start;
1067 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1074 if (this_read == 0) {
1078 this_read = min(cnt,this_read);
1080 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1081 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1086 // xfade loop boundary if appropriate
1088 if (xfade_samples > 0) {
1089 // just do a linear xfade for this short bit
1091 xfade_samples = min(xfade_samples, this_read);
1093 float delta = 1.0f / xfade_samples;
1095 Sample * tmpbuf = buf+offset;
1097 for (size_t i=0; i < xfade_samples; ++i) {
1098 *tmpbuf = (*tmpbuf * scale) + xfade_buf[i]*(1.0f - scale);
1106 _read_data_count = _playlist->read_data_count();
1110 swap_by_ptr (buf, buf + this_read - 1);
1115 /* if we read to the end of the loop, go back to the beginning */
1118 // read crossfade samples to apply to the next read
1120 xfade_samples = min((nframes_t) 128, cnt-this_read);
1122 if (audio_playlist()->read (xfade_buf, mixdown_buffer, gain_buffer, start, xfade_samples, channel) != xfade_samples) {
1123 error << string_compose(_("AudioDiskstream %1: cannot read xfade samples %2 from playlist at frame %3"),
1124 _id, xfade_samples,start) << endmsg;
1125 memset(xfade_buf, 0, xfade_samples * sizeof(Sample)); // just in case
1133 offset += this_read;
1140 AudioDiskstream::do_refill_with_alloc ()
1142 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1143 float* gain_buf = new float[disk_io_chunk_frames];
1145 int ret = _do_refill(mix_buf, gain_buf);
1154 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1158 RingBufferNPT<Sample>::rw_vector vector;
1159 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1160 nframes_t total_space;
1161 nframes_t zero_fill;
1163 ChannelList::iterator i;
1164 boost::shared_ptr<ChannelList> c = channels.reader();
1171 assert(mixdown_buffer);
1172 assert(gain_buffer);
1179 c->front()->playback_buf->get_write_vector (&vector);
1181 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1185 /* if there are 2+ chunks of disk i/o possible for
1186 this track, let the caller know so that it can arrange
1187 for us to be called again, ASAP.
1190 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1194 /* if we're running close to normal speed and there isn't enough
1195 space to do disk_io_chunk_frames of I/O, then don't bother.
1197 at higher speeds, just do it because the sync between butler
1198 and audio thread may not be good enough.
1201 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1205 /* when slaved, don't try to get too close to the read pointer. this
1206 leaves space for the buffer reversal to have something useful to
1210 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1214 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1216 total_space = min (disk_io_chunk_frames, total_space);
1220 if (file_frame == 0) {
1222 /* at start: nothing to do but fill with silence */
1224 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1226 ChannelInfo* chan (*i);
1227 chan->playback_buf->get_write_vector (&vector);
1228 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1229 if (vector.len[1]) {
1230 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1232 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1237 if (file_frame < total_space) {
1239 /* too close to the start: read what we can,
1240 and then zero fill the rest
1243 zero_fill = total_space - file_frame;
1244 total_space = file_frame;
1254 if (file_frame == max_frames) {
1256 /* at end: nothing to do but fill with silence */
1258 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1260 ChannelInfo* chan (*i);
1261 chan->playback_buf->get_write_vector (&vector);
1262 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1263 if (vector.len[1]) {
1264 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1266 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1271 if (file_frame > max_frames - total_space) {
1273 /* to close to the end: read what we can, and zero fill the rest */
1275 zero_fill = total_space - (max_frames - file_frame);
1276 total_space = max_frames - file_frame;
1283 nframes_t file_frame_tmp = 0;
1285 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1287 ChannelInfo* chan (*i);
1290 nframes_t len1, len2;
1292 chan->playback_buf->get_write_vector (&vector);
1294 if (vector.len[0] > disk_io_chunk_frames) {
1296 /* we're not going to fill the first chunk, so certainly do not bother with the
1297 other part. it won't be connected with the part we do fill, as in:
1299 .... => writable space
1300 ++++ => readable space
1301 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1303 |......|+++++++++++++|...............................|
1308 So, just pretend that the buf1 part isn't there.
1318 file_frame_tmp = file_frame;
1320 buf1 = vector.buf[0];
1321 len1 = vector.len[0];
1322 buf2 = vector.buf[1];
1323 len2 = vector.len[1];
1325 to_read = min (ts, len1);
1326 to_read = min (to_read, disk_io_chunk_frames);
1330 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1335 chan->playback_buf->increment_write_ptr (to_read);
1339 to_read = min (ts, len2);
1343 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1344 so read some or all of vector.len[1] as well.
1347 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1352 chan->playback_buf->increment_write_ptr (to_read);
1361 file_frame = file_frame_tmp;
1368 /** Flush pending data to disk.
1370 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1371 * of data to disk. it will never write more than that. If it writes that
1372 * much and there is more than that waiting to be written, it will return 1,
1373 * otherwise 0 on success or -1 on failure.
1375 * If there is less than disk_io_chunk_frames to be written, no data will be
1376 * written at all unless @a force_flush is true.
1379 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1383 RingBufferNPT<Sample>::rw_vector vector;
1384 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1387 _write_data_count = 0;
1389 transvec.buf[0] = 0;
1390 transvec.buf[1] = 0;
1394 boost::shared_ptr<ChannelList> c = channels.reader();
1395 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1397 (*chan)->capture_buf->get_read_vector (&vector);
1399 total = vector.len[0] + vector.len[1];
1401 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1405 /* if there are 2+ chunks of disk i/o possible for
1406 this track, let the caller know so that it can arrange
1407 for us to be called again, ASAP.
1409 if we are forcing a flush, then if there is* any* extra
1410 work, let the caller know.
1412 if we are no longer recording and there is any extra work,
1413 let the caller know too.
1416 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1420 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1422 // check the transition buffer when recording destructive
1423 // important that we get this after the capture buf
1425 if (destructive()) {
1426 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1427 size_t transcount = transvec.len[0] + transvec.len[1];
1428 bool have_start = false;
1431 for (ti=0; ti < transcount; ++ti) {
1432 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1434 if (captrans.type == CaptureStart) {
1435 // by definition, the first data we got above represents the given capture pos
1437 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1438 (*chan)->curr_capture_cnt = 0;
1442 else if (captrans.type == CaptureEnd) {
1444 // capture end, the capture_val represents total frames in capture
1446 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1448 // shorten to make the write a perfect fit
1449 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1451 if (nto_write < to_write) {
1452 ret = 1; // should we?
1454 to_write = nto_write;
1456 (*chan)->write_source->mark_capture_end ();
1458 // increment past this transition, but go no further
1463 // actually ends just beyond this chunk, so force more work
1471 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1475 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1476 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1480 (*chan)->capture_buf->increment_read_ptr (to_write);
1481 (*chan)->curr_capture_cnt += to_write;
1483 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1485 /* we wrote all of vector.len[0] but it wasn't an entire
1486 disk_io_chunk_frames of data, so arrange for some part
1487 of vector.len[1] to be flushed to disk as well.
1490 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1492 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1493 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1497 _write_data_count += (*chan)->write_source->write_data_count();
1499 (*chan)->capture_buf->increment_read_ptr (to_write);
1500 (*chan)->curr_capture_cnt += to_write;
1509 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1511 uint32_t buffer_position;
1512 bool more_work = true;
1514 boost::shared_ptr<AudioRegion> region;
1515 nframes_t total_capture;
1517 SourceList::iterator src;
1518 ChannelList::iterator chan;
1519 vector<CaptureInfo*>::iterator ci;
1520 boost::shared_ptr<ChannelList> c = channels.reader();
1522 bool mark_write_completed = false;
1524 finish_capture (true, c);
1526 /* butler is already stopped, but there may be work to do
1527 to flush remaining data to disk.
1530 while (more_work && !err) {
1531 switch (do_flush (Session::TransportContext, true)) {
1538 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1543 /* XXX is there anything we can do if err != 0 ? */
1544 Glib::Mutex::Lock lm (capture_info_lock);
1546 if (capture_info.empty()) {
1550 if (abort_capture) {
1552 if (destructive()) {
1556 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1558 if ((*chan)->write_source) {
1560 (*chan)->write_source->mark_for_remove ();
1561 (*chan)->write_source->drop_references ();
1562 (*chan)->write_source.reset ();
1565 /* new source set up in "out" below */
1571 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1572 total_capture += (*ci)->frames;
1575 /* figure out the name for this take */
1577 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1579 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1583 s->update_header (capture_info.front()->start, when, twhen);
1584 s->set_captured_for (_name);
1585 s->mark_immutable ();
1589 /* destructive tracks have a single, never changing region */
1591 if (destructive()) {
1593 /* send a signal that any UI can pick up to do the right thing. there is
1594 a small problem here in that a UI may need the peak data to be ready
1595 for the data that was recorded and this isn't interlocked with that
1596 process. this problem is deferred to the UI.
1599 _playlist->Modified();
1603 string whole_file_region_name;
1604 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1606 /* Register a new region with the Session that
1607 describes the entire source. Do this first
1608 so that any sub-regions will obviously be
1609 children of this one (later!)
1613 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1614 whole_file_region_name,
1615 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1617 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1618 region->special_set_position (capture_info.front()->start);
1622 catch (failed_constructor& err) {
1623 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1627 _last_capture_regions.push_back (region);
1629 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1631 XMLNode &before = _playlist->get_state();
1632 _playlist->freeze ();
1634 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1638 _session.region_name (region_name, whole_file_region_name, false);
1640 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1643 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1644 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1647 catch (failed_constructor& err) {
1648 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1649 continue; /* XXX is this OK? */
1652 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1654 _last_capture_regions.push_back (region);
1656 i_am_the_modifier++;
1657 _playlist->add_region (region, (*ci)->start);
1658 i_am_the_modifier--;
1660 buffer_position += (*ci)->frames;
1664 XMLNode &after = _playlist->get_state();
1665 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1668 mark_write_completed = true;
1671 reset_write_sources (mark_write_completed);
1675 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1679 capture_info.clear ();
1680 capture_start_frame = 0;
1684 AudioDiskstream::transport_looped (nframes_t transport_frame)
1686 if (was_recording) {
1687 // all we need to do is finish this capture, with modified capture length
1688 boost::shared_ptr<ChannelList> c = channels.reader();
1690 // adjust the capture length knowing that the data will be recorded to disk
1691 // only necessary after the first loop where we're recording
1692 if (capture_info.size() == 0) {
1693 capture_captured += _capture_offset;
1695 if (_alignment_style == ExistingMaterial) {
1696 capture_captured += _session.worst_output_latency();
1698 capture_captured += _roll_delay;
1702 finish_capture (true, c);
1704 // the next region will start recording via the normal mechanism
1705 // we'll set the start position to the current transport pos
1706 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1707 capture_start_frame = transport_frame;
1708 first_recordable_frame = transport_frame; // mild lie
1709 last_recordable_frame = max_frames;
1710 was_recording = true;
1712 if (recordable() && destructive()) {
1713 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1715 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1716 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1718 if (transvec.len[0] > 0) {
1719 transvec.buf[0]->type = CaptureStart;
1720 transvec.buf[0]->capture_val = capture_start_frame;
1721 (*chan)->capture_transition_buf->increment_write_ptr(1);
1725 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1735 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1737 was_recording = false;
1739 if (capture_captured == 0) {
1743 if (recordable() && destructive()) {
1744 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1746 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1747 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1749 if (transvec.len[0] > 0) {
1750 transvec.buf[0]->type = CaptureEnd;
1751 transvec.buf[0]->capture_val = capture_captured;
1752 (*chan)->capture_transition_buf->increment_write_ptr(1);
1756 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1762 CaptureInfo* ci = new CaptureInfo;
1764 ci->start = capture_start_frame;
1765 ci->frames = capture_captured;
1767 /* XXX theoretical race condition here. Need atomic exchange ?
1768 However, the circumstances when this is called right
1769 now (either on record-disable or transport_stopped)
1770 mean that no actual race exists. I think ...
1771 We now have a capture_info_lock, but it is only to be used
1772 to synchronize in the transport_stop and the capture info
1773 accessors, so that invalidation will not occur (both non-realtime).
1776 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1778 capture_info.push_back (ci);
1779 capture_captured = 0;
1783 AudioDiskstream::set_record_enabled (bool yn)
1785 if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs() == 0) {
1789 /* can't rec-enable in destructive mode if transport is before start */
1791 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1795 if (yn && channels.reader()->front()->source == 0) {
1797 /* pick up connections not initiated *from* the IO object
1798 we're associated with.
1801 get_input_sources ();
1804 /* yes, i know that this not proof against race conditions, but its
1805 good enough. i think.
1808 if (record_enabled() != yn) {
1810 engage_record_enable ();
1812 disengage_record_enable ();
1818 AudioDiskstream::engage_record_enable ()
1820 bool rolling = _session.transport_speed() != 0.0f;
1821 boost::shared_ptr<ChannelList> c = channels.reader();
1823 g_atomic_int_set (&_record_enabled, 1);
1824 capturing_sources.clear ();
1826 if (Config->get_monitoring_model() == HardwareMonitoring) {
1828 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1829 if ((*chan)->source) {
1830 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1832 capturing_sources.push_back ((*chan)->write_source);
1836 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1837 capturing_sources.push_back ((*chan)->write_source);
1841 RecordEnableChanged (); /* EMIT SIGNAL */
1845 AudioDiskstream::disengage_record_enable ()
1847 g_atomic_int_set (&_record_enabled, 0);
1848 boost::shared_ptr<ChannelList> c = channels.reader();
1849 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1850 if (Config->get_monitoring_model() == HardwareMonitoring) {
1851 if ((*chan)->source) {
1852 (*chan)->source->ensure_monitor_input (false);
1856 capturing_sources.clear ();
1857 RecordEnableChanged (); /* EMIT SIGNAL */
1861 AudioDiskstream::get_state ()
1863 XMLNode* node = new XMLNode ("AudioDiskstream");
1865 LocaleGuard lg (X_("POSIX"));
1866 boost::shared_ptr<ChannelList> c = channels.reader();
1868 node->add_property ("flags", enum_2_string (_flags));
1870 snprintf (buf, sizeof(buf), "%zd", c->size());
1871 node->add_property ("channels", buf);
1873 node->add_property ("playlist", _playlist->name());
1875 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1876 node->add_property ("speed", buf);
1878 node->add_property("name", _name);
1879 id().print (buf, sizeof (buf));
1880 node->add_property("id", buf);
1882 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1884 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1885 XMLNode* cs_grandchild;
1887 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1888 cs_grandchild = new XMLNode (X_("file"));
1889 cs_grandchild->add_property (X_("path"), (*i)->path());
1890 cs_child->add_child_nocopy (*cs_grandchild);
1893 /* store the location where capture will start */
1897 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1898 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1900 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1903 cs_child->add_property (X_("at"), buf);
1904 node->add_child_nocopy (*cs_child);
1908 node->add_child_copy (*_extra_xml);
1915 AudioDiskstream::set_state (const XMLNode& node)
1917 const XMLProperty* prop;
1918 XMLNodeList nlist = node.children();
1919 XMLNodeIterator niter;
1920 uint32_t nchans = 1;
1921 XMLNode* capture_pending_node = 0;
1922 LocaleGuard lg (X_("POSIX"));
1924 in_set_state = true;
1926 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1927 if ((*niter)->name() == IO::state_node_name) {
1928 deprecated_io_node = new XMLNode (**niter);
1931 if ((*niter)->name() == X_("CapturingSources")) {
1932 capture_pending_node = *niter;
1936 /* prevent write sources from being created */
1938 in_set_state = true;
1940 if ((prop = node.property ("name")) != 0) {
1941 _name = prop->value();
1944 if (deprecated_io_node) {
1945 if ((prop = deprecated_io_node->property ("id")) != 0) {
1946 _id = prop->value ();
1949 if ((prop = node.property ("id")) != 0) {
1950 _id = prop->value ();
1954 if ((prop = node.property ("flags")) != 0) {
1955 _flags = Flag (string_2_enum (prop->value(), _flags));
1958 if ((prop = node.property ("channels")) != 0) {
1959 nchans = atoi (prop->value().c_str());
1962 // create necessary extra channels
1963 // we are always constructed with one and we always need one
1965 _n_channels = channels.reader()->size();
1967 if (nchans > _n_channels) {
1969 add_channel (nchans - _n_channels);
1971 } else if (nchans < _n_channels) {
1973 remove_channel (_n_channels - nchans);
1976 if ((prop = node.property ("playlist")) == 0) {
1981 bool had_playlist = (_playlist != 0);
1983 if (find_and_use_playlist (prop->value())) {
1987 if (!had_playlist) {
1988 _playlist->set_orig_diskstream_id (_id);
1991 if (!destructive() && capture_pending_node) {
1992 /* destructive streams have one and only one source per channel,
1993 and so they never end up in pending capture in any useful
1996 use_pending_capture_data (*capture_pending_node);
2001 if ((prop = node.property ("speed")) != 0) {
2002 double sp = atof (prop->value().c_str());
2004 if (realtime_set_speed (sp, false)) {
2005 non_realtime_set_speed ();
2009 in_set_state = false;
2011 /* make sure this is clear before we do anything else */
2013 capturing_sources.clear ();
2015 /* write sources are handled when we handle the input set
2016 up of the IO that owns this DS (::non_realtime_input_change())
2019 in_set_state = false;
2025 AudioDiskstream::use_new_write_source (uint32_t n)
2027 boost::shared_ptr<ChannelList> c = channels.reader();
2029 if (!recordable()) {
2033 if (n >= c->size()) {
2034 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2038 ChannelInfo* chan = (*c)[n];
2040 if (chan->write_source) {
2041 chan->write_source->done_with_peakfile_writes ();
2042 chan->write_source->set_allow_remove_if_empty (true);
2043 chan->write_source.reset ();
2047 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2048 throw failed_constructor();
2052 catch (failed_constructor &err) {
2053 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2054 chan->write_source.reset ();
2058 /* do not remove destructive files even if they are empty */
2060 chan->write_source->set_allow_remove_if_empty (!destructive());
2066 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2068 ChannelList::iterator chan;
2069 boost::shared_ptr<ChannelList> c = channels.reader();
2072 if (!recordable()) {
2076 capturing_sources.clear ();
2078 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2079 if (!destructive()) {
2081 if ((*chan)->write_source && mark_write_complete) {
2082 (*chan)->write_source->mark_streaming_write_completed ();
2084 use_new_write_source (n);
2086 if (record_enabled()) {
2087 capturing_sources.push_back ((*chan)->write_source);
2091 if ((*chan)->write_source == 0) {
2092 use_new_write_source (n);
2097 if (destructive()) {
2099 /* we now have all our write sources set up, so create the
2100 playlist's single region.
2103 if (_playlist->empty()) {
2104 setup_destructive_playlist ();
2110 AudioDiskstream::rename_write_sources ()
2112 ChannelList::iterator chan;
2113 boost::shared_ptr<ChannelList> c = channels.reader();
2116 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2117 if ((*chan)->write_source != 0) {
2118 (*chan)->write_source->set_name (_name, destructive());
2119 /* XXX what to do if one of them fails ? */
2127 AudioDiskstream::set_block_size (nframes_t nframes)
2129 if (_session.get_block_size() > speed_buffer_size) {
2130 speed_buffer_size = _session.get_block_size();
2131 boost::shared_ptr<ChannelList> c = channels.reader();
2133 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2134 if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2135 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2138 allocate_temporary_buffers ();
2142 AudioDiskstream::allocate_temporary_buffers ()
2144 /* make sure the wrap buffer is at least large enough to deal
2145 with the speeds up to 1.2, to allow for micro-variation
2146 when slaving to MTC, SMPTE etc.
2149 double sp = max (fabsf (_actual_speed), 1.2f);
2150 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2152 if (required_wrap_size > wrap_buffer_size) {
2154 boost::shared_ptr<ChannelList> c = channels.reader();
2156 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2157 if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2158 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2159 if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2160 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2163 wrap_buffer_size = required_wrap_size;
2168 AudioDiskstream::monitor_input (bool yn)
2170 boost::shared_ptr<ChannelList> c = channels.reader();
2172 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2174 if ((*chan)->source) {
2175 (*chan)->source->ensure_monitor_input (yn);
2181 AudioDiskstream::set_align_style_from_io ()
2183 bool have_physical = false;
2189 get_input_sources ();
2191 boost::shared_ptr<ChannelList> c = channels.reader();
2193 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2194 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2195 have_physical = true;
2200 if (have_physical) {
2201 set_align_style (ExistingMaterial);
2203 set_align_style (CaptureTime);
2208 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2210 while (how_many--) {
2211 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2214 _n_channels = c->size();
2220 AudioDiskstream::add_channel (uint32_t how_many)
2222 RCUWriter<ChannelList> writer (channels);
2223 boost::shared_ptr<ChannelList> c = writer.get_copy();
2225 return add_channel_to (c, how_many);
2229 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2231 while (--how_many && !c->empty()) {
2236 _n_channels = c->size();
2242 AudioDiskstream::remove_channel (uint32_t how_many)
2244 RCUWriter<ChannelList> writer (channels);
2245 boost::shared_ptr<ChannelList> c = writer.get_copy();
2247 return remove_channel_from (c, how_many);
2251 AudioDiskstream::playback_buffer_load () const
2253 boost::shared_ptr<ChannelList> c = channels.reader();
2255 return (float) ((double) c->front()->playback_buf->read_space()/
2256 (double) c->front()->playback_buf->bufsize());
2260 AudioDiskstream::capture_buffer_load () const
2262 boost::shared_ptr<ChannelList> c = channels.reader();
2264 return (float) ((double) c->front()->capture_buf->write_space()/
2265 (double) c->front()->capture_buf->bufsize());
2269 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2271 const XMLProperty* prop;
2272 XMLNodeList nlist = node.children();
2273 XMLNodeIterator niter;
2274 boost::shared_ptr<AudioFileSource> fs;
2275 boost::shared_ptr<AudioFileSource> first_fs;
2276 SourceList pending_sources;
2279 if ((prop = node.property (X_("at"))) == 0) {
2283 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2287 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2288 if ((*niter)->name() == X_("file")) {
2290 if ((prop = (*niter)->property (X_("path"))) == 0) {
2294 // This protects sessions from errant CapturingSources in stored sessions
2296 if (stat (prop->value().c_str(), &sbuf)) {
2301 fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (_session, prop->value(), false, _session.frame_rate()));
2304 catch (failed_constructor& err) {
2305 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2306 _name, prop->value())
2311 pending_sources.push_back (fs);
2313 if (first_fs == 0) {
2317 fs->set_captured_for (_name);
2321 if (pending_sources.size() == 0) {
2322 /* nothing can be done */
2326 if (pending_sources.size() != _n_channels) {
2327 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2332 boost::shared_ptr<AudioRegion> region;
2335 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2336 region_name_from_path (first_fs->name(), true),
2337 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2338 region->special_set_position (0);
2341 catch (failed_constructor& err) {
2342 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2350 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2353 catch (failed_constructor& err) {
2354 error << string_compose (_("%1: cannot create region from pending capture sources"),
2361 _playlist->add_region (region, position);
2367 AudioDiskstream::set_destructive (bool yn)
2369 bool bounce_ignored;
2371 if (yn != destructive()) {
2374 /* requestor should already have checked this and
2375 bounced if necessary and desired
2377 if (!can_become_destructive (bounce_ignored)) {
2380 _flags = Flag (_flags | Destructive);
2381 use_destructive_playlist ();
2383 _flags = Flag (_flags & ~Destructive);
2384 reset_write_sources (true, true);
2392 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2395 requires_bounce = false;
2399 /* is there only one region ? */
2401 if (_playlist->n_regions() != 1) {
2402 requires_bounce = true;
2406 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2409 /* do the source(s) for the region cover the session start position ? */
2411 if (first->position() != _session.current_start_frame()) {
2412 if (first->start() > _session.current_start_frame()) {
2413 requires_bounce = true;
2418 /* is the source used by only 1 playlist ? */
2420 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2424 if (afirst->source()->used() > 1) {
2425 requires_bounce = true;
2429 requires_bounce = false;
2433 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2437 current_capture_buffer = 0;
2438 current_playback_buffer = 0;
2439 curr_capture_cnt = 0;
2441 speed_buffer = new Sample[speed_size];
2442 playback_wrap_buffer = new Sample[wrap_size];
2443 capture_wrap_buffer = new Sample[wrap_size];
2445 playback_buf = new RingBufferNPT<Sample> (bufsize);
2446 capture_buf = new RingBufferNPT<Sample> (bufsize);
2447 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2449 /* touch the ringbuffer buffers, which will cause
2450 them to be mapped into locked physical RAM if
2451 we're running with mlockall(). this doesn't do
2455 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2456 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2457 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2460 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2463 write_source.reset ();
2467 delete [] speed_buffer;
2471 if (playback_wrap_buffer) {
2472 delete [] playback_wrap_buffer;
2473 playback_wrap_buffer = 0;
2476 if (capture_wrap_buffer) {
2477 delete [] capture_wrap_buffer;
2478 capture_wrap_buffer = 0;
2482 delete playback_buf;
2491 if (capture_transition_buf) {
2492 delete capture_transition_buf;
2493 capture_transition_buf = 0;