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 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
565 case OverlapInternal:
566 /* ---------- recrange
569 rec_nframes = nframes;
574 /* |--------| recrange
577 rec_nframes = transport_frame + nframes - first_recordable_frame;
579 rec_offset = first_recordable_frame - transport_frame;
584 /* |--------| recrange
587 rec_nframes = last_recordable_frame - transport_frame;
591 case OverlapExternal:
592 /* |--------| recrange
593 -------------- transrange
595 rec_nframes = last_recordable_frame - first_recordable_frame;
596 rec_offset = first_recordable_frame - transport_frame;
600 if (rec_nframes && !was_recording) {
601 capture_captured = 0;
602 was_recording = true;
607 if (can_record && !_last_capture_regions.empty()) {
608 _last_capture_regions.clear ();
611 if (nominally_recording || rec_nframes) {
613 uint32_t limit = _io->n_inputs ();
615 /* one or more ports could already have been removed from _io, but our
616 channel setup hasn't yet been updated. prevent us from trying to
617 use channels that correspond to missing ports. note that the
618 process callback (from which this is called) is always atomic
619 with respect to port removal/addition.
622 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
624 ChannelInfo* chaninfo (*chan);
626 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
628 if (rec_nframes <= chaninfo->capture_vector.len[0]) {
630 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
632 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
636 memcpy (chaninfo->current_capture_buffer, _io->input(n)->get_buffer (rec_nframes) + offset + rec_offset, sizeof (Sample) * rec_nframes);
640 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
642 if (rec_nframes > total) {
647 Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
648 nframes_t first = chaninfo->capture_vector.len[0];
650 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
651 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
652 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
653 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
655 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
662 finish_capture (rec_monitors_input, c);
669 /* data will be written to disk */
671 if (rec_nframes == nframes && rec_offset == 0) {
673 for (chan = c->begin(); chan != c->end(); ++chan) {
674 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
677 playback_distance = nframes;
682 /* we can't use the capture buffer as the playback buffer, because
683 we recorded only a part of the current process' cycle data
687 collect_playback = true;
690 adjust_capture_position = rec_nframes;
692 } else if (nominally_recording) {
694 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
696 for (chan = c->begin(); chan != c->end(); ++chan) {
697 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
700 playback_distance = nframes;
704 collect_playback = true;
707 if (collect_playback) {
709 /* we're doing playback */
711 nframes_t necessary_samples;
713 /* no varispeed playback if we're recording, because the output .... TBD */
715 if (rec_nframes == 0 && _actual_speed != 1.0f) {
716 necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
718 necessary_samples = nframes;
721 for (chan = c->begin(); chan != c->end(); ++chan) {
722 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
727 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
729 ChannelInfo* chaninfo (*chan);
731 if (necessary_samples <= chaninfo->playback_vector.len[0]) {
733 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
736 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
738 if (necessary_samples > total) {
744 memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
745 chaninfo->playback_vector.len[0] * sizeof (Sample));
746 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
747 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
749 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
754 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
756 uint64_t phase = last_phase;
759 // Linearly interpolate into the alt buffer
760 // using 40.24 fixp maths (swh)
762 for (chan = c->begin(); chan != c->end(); ++chan) {
765 ChannelInfo* chaninfo (*chan);
770 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
772 fr = (phase & 0xFFFFFF) / 16777216.0f;
773 chaninfo->speed_buffer[outsample] =
774 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
775 chaninfo->current_playback_buffer[i+1] * fr;
779 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
782 playback_distance = i + 1;
783 last_phase = (phase & 0xFFFFFF);
786 playback_distance = nframes;
798 /* we're exiting with failure, so ::commit will not
799 be called. unlock the state lock.
802 commit_should_unlock = false;
810 AudioDiskstream::commit (nframes_t nframes)
812 bool need_butler = false;
814 if (_actual_speed < 0.0) {
815 playback_sample -= playback_distance;
817 playback_sample += playback_distance;
820 boost::shared_ptr<ChannelList> c = channels.reader();
821 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
823 (*chan)->playback_buf->increment_read_ptr (playback_distance);
825 if (adjust_capture_position) {
826 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
830 if (adjust_capture_position != 0) {
831 capture_captured += adjust_capture_position;
832 adjust_capture_position = 0;
836 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
838 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
839 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
842 if (commit_should_unlock) {
852 AudioDiskstream::set_pending_overwrite (bool yn)
854 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
856 pending_overwrite = yn;
858 overwrite_frame = playback_sample;
859 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
863 AudioDiskstream::overwrite_existing_buffers ()
865 boost::shared_ptr<ChannelList> c = channels.reader();
866 Sample* mixdown_buffer;
869 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
871 overwrite_queued = false;
873 /* assume all are the same size */
874 nframes_t size = c->front()->playback_buf->bufsize();
876 mixdown_buffer = new Sample[size];
877 gain_buffer = new float[size];
879 /* reduce size so that we can fill the buffer correctly. */
885 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
887 start = overwrite_frame;
888 nframes_t cnt = size;
890 /* to fill the buffer without resetting the playback sample, we need to
891 do it one or two chunks (normally two).
893 |----------------------------------------------------------------------|
897 |<- second chunk->||<----------------- first chunk ------------------>|
901 nframes_t to_read = size - overwrite_offset;
903 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
904 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
905 _id, size, playback_sample) << endmsg;
913 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
914 start, cnt, *chan, n, reversed)) {
915 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
916 _id, size, playback_sample) << endmsg;
925 pending_overwrite = false;
926 delete [] gain_buffer;
927 delete [] mixdown_buffer;
932 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
936 ChannelList::iterator chan;
937 boost::shared_ptr<ChannelList> c = channels.reader();
939 Glib::Mutex::Lock lm (state_lock);
941 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
942 (*chan)->playback_buf->reset ();
943 (*chan)->capture_buf->reset ();
946 /* can't rec-enable in destructive mode if transport is before start */
948 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
949 disengage_record_enable ();
952 playback_sample = frame;
955 if (complete_refill) {
956 while ((ret = do_refill_with_alloc ()) > 0) ;
958 ret = do_refill_with_alloc ();
965 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
967 ChannelList::iterator chan;
968 boost::shared_ptr<ChannelList> c = channels.reader();
970 for (chan = c->begin(); chan != c->end(); ++chan) {
971 if ((*chan)->playback_buf->read_space() < distance) {
979 AudioDiskstream::internal_playback_seek (nframes_t distance)
981 ChannelList::iterator chan;
982 boost::shared_ptr<ChannelList> c = channels.reader();
984 for (chan = c->begin(); chan != c->end(); ++chan) {
985 (*chan)->playback_buf->increment_read_ptr (distance);
988 first_recordable_frame += distance;
989 playback_sample += distance;
995 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
996 ChannelInfo* channel_info, int channel, bool reversed)
998 nframes_t this_read = 0;
1000 nframes_t loop_end = 0;
1001 nframes_t loop_start = 0;
1002 nframes_t loop_length = 0;
1003 nframes_t offset = 0;
1004 nframes_t xfade_samples = 0;
1005 Sample xfade_buf[128];
1008 /* XXX we don't currently play loops in reverse. not sure why */
1012 /* Make the use of a Location atomic for this read operation.
1014 Note: Locations don't get deleted, so all we care about
1015 when I say "atomic" is that we are always pointing to
1016 the same one and using a start/length values obtained
1020 if ((loc = loop_location) != 0) {
1021 loop_start = loc->start();
1022 loop_end = loc->end();
1023 loop_length = loop_end - loop_start;
1026 /* if we are looping, ensure that the first frame we read is at the correct
1027 position within the loop.
1030 if (loc && start >= loop_end) {
1031 //cerr << "start adjusted from " << start;
1032 start = loop_start + ((start - loop_start) % loop_length);
1033 //cerr << "to " << start << endl;
1036 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1045 /* take any loop into account. we can't read past the end of the loop. */
1047 if (loc && (loop_end - start < cnt)) {
1048 this_read = loop_end - start;
1049 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1056 if (this_read == 0) {
1060 this_read = min(cnt,this_read);
1062 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1063 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1068 // xfade loop boundary if appropriate
1070 if (xfade_samples > 0) {
1071 // just do a linear xfade for this short bit
1073 xfade_samples = min(xfade_samples, this_read);
1075 float delta = 1.0f / xfade_samples;
1077 Sample * tmpbuf = buf+offset;
1079 for (size_t i=0; i < xfade_samples; ++i) {
1080 *tmpbuf = (*tmpbuf * scale) + xfade_buf[i]*(1.0f - scale);
1088 _read_data_count = _playlist->read_data_count();
1092 swap_by_ptr (buf, buf + this_read - 1);
1097 /* if we read to the end of the loop, go back to the beginning */
1100 // read crossfade samples to apply to the next read
1102 xfade_samples = min((nframes_t) 128, cnt-this_read);
1104 if (audio_playlist()->read (xfade_buf, mixdown_buffer, gain_buffer, start, xfade_samples, channel) != xfade_samples) {
1105 error << string_compose(_("AudioDiskstream %1: cannot read xfade samples %2 from playlist at frame %3"),
1106 _id, xfade_samples,start) << endmsg;
1107 memset(xfade_buf, 0, xfade_samples * sizeof(Sample)); // just in case
1115 offset += this_read;
1122 AudioDiskstream::do_refill_with_alloc ()
1124 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1125 float* gain_buf = new float[disk_io_chunk_frames];
1127 int ret = _do_refill(mix_buf, gain_buf);
1136 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1140 RingBufferNPT<Sample>::rw_vector vector;
1141 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1142 nframes_t total_space;
1143 nframes_t zero_fill;
1145 ChannelList::iterator i;
1146 boost::shared_ptr<ChannelList> c = channels.reader();
1153 assert(mixdown_buffer);
1154 assert(gain_buffer);
1161 c->front()->playback_buf->get_write_vector (&vector);
1163 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1167 /* if there are 2+ chunks of disk i/o possible for
1168 this track, let the caller know so that it can arrange
1169 for us to be called again, ASAP.
1172 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1176 /* if we're running close to normal speed and there isn't enough
1177 space to do disk_io_chunk_frames of I/O, then don't bother.
1179 at higher speeds, just do it because the sync between butler
1180 and audio thread may not be good enough.
1183 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1187 /* when slaved, don't try to get too close to the read pointer. this
1188 leaves space for the buffer reversal to have something useful to
1192 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1196 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1198 total_space = min (disk_io_chunk_frames, total_space);
1202 if (file_frame == 0) {
1204 /* at start: nothing to do but fill with silence */
1206 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1208 ChannelInfo* chan (*i);
1209 chan->playback_buf->get_write_vector (&vector);
1210 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1211 if (vector.len[1]) {
1212 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1214 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1219 if (file_frame < total_space) {
1221 /* too close to the start: read what we can,
1222 and then zero fill the rest
1225 zero_fill = total_space - file_frame;
1226 total_space = file_frame;
1236 if (file_frame == max_frames) {
1238 /* at end: nothing to do but fill with silence */
1240 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1242 ChannelInfo* chan (*i);
1243 chan->playback_buf->get_write_vector (&vector);
1244 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1245 if (vector.len[1]) {
1246 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1248 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1253 if (file_frame > max_frames - total_space) {
1255 /* to close to the end: read what we can, and zero fill the rest */
1257 zero_fill = total_space - (max_frames - file_frame);
1258 total_space = max_frames - file_frame;
1265 nframes_t file_frame_tmp = 0;
1267 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1269 ChannelInfo* chan (*i);
1272 nframes_t len1, len2;
1274 chan->playback_buf->get_write_vector (&vector);
1276 if (vector.len[0] > disk_io_chunk_frames) {
1278 /* we're not going to fill the first chunk, so certainly do not bother with the
1279 other part. it won't be connected with the part we do fill, as in:
1281 .... => writable space
1282 ++++ => readable space
1283 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1285 |......|+++++++++++++|...............................|
1290 So, just pretend that the buf1 part isn't there.
1300 file_frame_tmp = file_frame;
1302 buf1 = vector.buf[0];
1303 len1 = vector.len[0];
1304 buf2 = vector.buf[1];
1305 len2 = vector.len[1];
1307 to_read = min (ts, len1);
1308 to_read = min (to_read, disk_io_chunk_frames);
1312 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1317 chan->playback_buf->increment_write_ptr (to_read);
1321 to_read = min (ts, len2);
1325 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1326 so read some or all of vector.len[1] as well.
1329 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1334 chan->playback_buf->increment_write_ptr (to_read);
1343 file_frame = file_frame_tmp;
1350 /** Flush pending data to disk.
1352 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1353 * of data to disk. it will never write more than that. If it writes that
1354 * much and there is more than that waiting to be written, it will return 1,
1355 * otherwise 0 on success or -1 on failure.
1357 * If there is less than disk_io_chunk_frames to be written, no data will be
1358 * written at all unless @a force_flush is true.
1361 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1365 RingBufferNPT<Sample>::rw_vector vector;
1366 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1369 _write_data_count = 0;
1371 transvec.buf[0] = 0;
1372 transvec.buf[1] = 0;
1376 boost::shared_ptr<ChannelList> c = channels.reader();
1377 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1379 (*chan)->capture_buf->get_read_vector (&vector);
1381 total = vector.len[0] + vector.len[1];
1383 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1387 /* if there are 2+ chunks of disk i/o possible for
1388 this track, let the caller know so that it can arrange
1389 for us to be called again, ASAP.
1391 if we are forcing a flush, then if there is* any* extra
1392 work, let the caller know.
1394 if we are no longer recording and there is any extra work,
1395 let the caller know too.
1398 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1402 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1404 // check the transition buffer when recording destructive
1405 // important that we get this after the capture buf
1407 if (destructive()) {
1408 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1409 size_t transcount = transvec.len[0] + transvec.len[1];
1410 bool have_start = false;
1413 for (ti=0; ti < transcount; ++ti) {
1414 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1416 if (captrans.type == CaptureStart) {
1417 // by definition, the first data we got above represents the given capture pos
1419 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1420 (*chan)->curr_capture_cnt = 0;
1424 else if (captrans.type == CaptureEnd) {
1426 // capture end, the capture_val represents total frames in capture
1428 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1430 // shorten to make the write a perfect fit
1431 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1433 if (nto_write < to_write) {
1434 ret = 1; // should we?
1436 to_write = nto_write;
1438 (*chan)->write_source->mark_capture_end ();
1440 // increment past this transition, but go no further
1445 // actually ends just beyond this chunk, so force more work
1453 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1457 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1458 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1462 (*chan)->capture_buf->increment_read_ptr (to_write);
1463 (*chan)->curr_capture_cnt += to_write;
1465 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1467 /* we wrote all of vector.len[0] but it wasn't an entire
1468 disk_io_chunk_frames of data, so arrange for some part
1469 of vector.len[1] to be flushed to disk as well.
1472 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1474 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1475 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1479 _write_data_count += (*chan)->write_source->write_data_count();
1481 (*chan)->capture_buf->increment_read_ptr (to_write);
1482 (*chan)->curr_capture_cnt += to_write;
1491 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1493 uint32_t buffer_position;
1494 bool more_work = true;
1496 boost::shared_ptr<AudioRegion> region;
1497 nframes_t total_capture;
1499 SourceList::iterator src;
1500 ChannelList::iterator chan;
1501 vector<CaptureInfo*>::iterator ci;
1502 boost::shared_ptr<ChannelList> c = channels.reader();
1504 bool mark_write_completed = false;
1506 finish_capture (true, c);
1508 /* butler is already stopped, but there may be work to do
1509 to flush remaining data to disk.
1512 while (more_work && !err) {
1513 switch (do_flush (Session::TransportContext, true)) {
1520 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1525 /* XXX is there anything we can do if err != 0 ? */
1526 Glib::Mutex::Lock lm (capture_info_lock);
1528 if (capture_info.empty()) {
1532 if (abort_capture) {
1534 if (destructive()) {
1538 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1540 if ((*chan)->write_source) {
1542 (*chan)->write_source->mark_for_remove ();
1543 (*chan)->write_source->drop_references ();
1544 (*chan)->write_source.reset ();
1547 /* new source set up in "out" below */
1553 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1554 total_capture += (*ci)->frames;
1557 /* figure out the name for this take */
1559 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1561 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1565 s->update_header (capture_info.front()->start, when, twhen);
1566 s->set_captured_for (_name);
1567 s->mark_immutable ();
1571 /* destructive tracks have a single, never changing region */
1573 if (destructive()) {
1575 /* send a signal that any UI can pick up to do the right thing. there is
1576 a small problem here in that a UI may need the peak data to be ready
1577 for the data that was recorded and this isn't interlocked with that
1578 process. this problem is deferred to the UI.
1581 _playlist->Modified();
1585 string whole_file_region_name;
1586 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1588 /* Register a new region with the Session that
1589 describes the entire source. Do this first
1590 so that any sub-regions will obviously be
1591 children of this one (later!)
1595 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1596 whole_file_region_name,
1597 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1599 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1600 region->special_set_position (capture_info.front()->start);
1604 catch (failed_constructor& err) {
1605 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1609 _last_capture_regions.push_back (region);
1611 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1613 XMLNode &before = _playlist->get_state();
1614 _playlist->freeze ();
1616 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1620 _session.region_name (region_name, whole_file_region_name, false);
1622 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1625 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1626 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1629 catch (failed_constructor& err) {
1630 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1631 continue; /* XXX is this OK? */
1634 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1636 _last_capture_regions.push_back (region);
1638 i_am_the_modifier++;
1639 _playlist->add_region (region, (*ci)->start);
1640 i_am_the_modifier--;
1642 buffer_position += (*ci)->frames;
1646 XMLNode &after = _playlist->get_state();
1647 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1650 mark_write_completed = true;
1653 reset_write_sources (mark_write_completed);
1657 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1661 capture_info.clear ();
1662 capture_start_frame = 0;
1666 AudioDiskstream::transport_looped (nframes_t transport_frame)
1668 if (was_recording) {
1669 // all we need to do is finish this capture, with modified capture length
1670 boost::shared_ptr<ChannelList> c = channels.reader();
1672 // adjust the capture length knowing that the data will be recorded to disk
1673 // only necessary after the first loop where we're recording
1674 if (capture_info.size() == 0) {
1675 capture_captured += _capture_offset;
1677 if (_alignment_style == ExistingMaterial) {
1678 capture_captured += _session.worst_output_latency();
1680 capture_captured += _roll_delay;
1684 finish_capture (true, c);
1686 // the next region will start recording via the normal mechanism
1687 // we'll set the start position to the current transport pos
1688 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1689 capture_start_frame = transport_frame;
1690 first_recordable_frame = transport_frame; // mild lie
1691 last_recordable_frame = max_frames;
1692 was_recording = true;
1694 if (recordable() && destructive()) {
1695 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1697 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1698 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1700 if (transvec.len[0] > 0) {
1701 transvec.buf[0]->type = CaptureStart;
1702 transvec.buf[0]->capture_val = capture_start_frame;
1703 (*chan)->capture_transition_buf->increment_write_ptr(1);
1707 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1717 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1719 was_recording = false;
1721 if (capture_captured == 0) {
1725 if (recordable() && destructive()) {
1726 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1728 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1729 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1731 if (transvec.len[0] > 0) {
1732 transvec.buf[0]->type = CaptureEnd;
1733 transvec.buf[0]->capture_val = capture_captured;
1734 (*chan)->capture_transition_buf->increment_write_ptr(1);
1738 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1744 CaptureInfo* ci = new CaptureInfo;
1746 ci->start = capture_start_frame;
1747 ci->frames = capture_captured;
1749 /* XXX theoretical race condition here. Need atomic exchange ?
1750 However, the circumstances when this is called right
1751 now (either on record-disable or transport_stopped)
1752 mean that no actual race exists. I think ...
1753 We now have a capture_info_lock, but it is only to be used
1754 to synchronize in the transport_stop and the capture info
1755 accessors, so that invalidation will not occur (both non-realtime).
1758 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1760 capture_info.push_back (ci);
1761 capture_captured = 0;
1765 AudioDiskstream::set_record_enabled (bool yn)
1767 if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs() == 0) {
1771 /* can't rec-enable in destructive mode if transport is before start */
1773 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1777 if (yn && channels.reader()->front()->source == 0) {
1779 /* pick up connections not initiated *from* the IO object
1780 we're associated with.
1783 get_input_sources ();
1786 /* yes, i know that this not proof against race conditions, but its
1787 good enough. i think.
1790 if (record_enabled() != yn) {
1792 engage_record_enable ();
1794 disengage_record_enable ();
1800 AudioDiskstream::engage_record_enable ()
1802 bool rolling = _session.transport_speed() != 0.0f;
1803 boost::shared_ptr<ChannelList> c = channels.reader();
1805 g_atomic_int_set (&_record_enabled, 1);
1806 capturing_sources.clear ();
1808 if (Config->get_monitoring_model() == HardwareMonitoring) {
1810 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1811 if ((*chan)->source) {
1812 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1814 capturing_sources.push_back ((*chan)->write_source);
1818 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1819 capturing_sources.push_back ((*chan)->write_source);
1823 RecordEnableChanged (); /* EMIT SIGNAL */
1827 AudioDiskstream::disengage_record_enable ()
1829 g_atomic_int_set (&_record_enabled, 0);
1830 boost::shared_ptr<ChannelList> c = channels.reader();
1831 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1832 if (Config->get_monitoring_model() == HardwareMonitoring) {
1833 if ((*chan)->source) {
1834 (*chan)->source->ensure_monitor_input (false);
1838 capturing_sources.clear ();
1839 RecordEnableChanged (); /* EMIT SIGNAL */
1843 AudioDiskstream::get_state ()
1845 XMLNode* node = new XMLNode ("AudioDiskstream");
1847 LocaleGuard lg (X_("POSIX"));
1848 boost::shared_ptr<ChannelList> c = channels.reader();
1850 node->add_property ("flags", enum_2_string (_flags));
1852 snprintf (buf, sizeof(buf), "%zd", c->size());
1853 node->add_property ("channels", buf);
1855 node->add_property ("playlist", _playlist->name());
1857 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1858 node->add_property ("speed", buf);
1860 node->add_property("name", _name);
1861 id().print (buf, sizeof (buf));
1862 node->add_property("id", buf);
1864 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1866 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1867 XMLNode* cs_grandchild;
1869 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1870 cs_grandchild = new XMLNode (X_("file"));
1871 cs_grandchild->add_property (X_("path"), (*i)->path());
1872 cs_child->add_child_nocopy (*cs_grandchild);
1875 /* store the location where capture will start */
1879 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1880 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1882 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1885 cs_child->add_property (X_("at"), buf);
1886 node->add_child_nocopy (*cs_child);
1890 node->add_child_copy (*_extra_xml);
1897 AudioDiskstream::set_state (const XMLNode& node)
1899 const XMLProperty* prop;
1900 XMLNodeList nlist = node.children();
1901 XMLNodeIterator niter;
1902 uint32_t nchans = 1;
1903 XMLNode* capture_pending_node = 0;
1904 LocaleGuard lg (X_("POSIX"));
1906 in_set_state = true;
1908 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1909 if ((*niter)->name() == IO::state_node_name) {
1910 deprecated_io_node = new XMLNode (**niter);
1913 if ((*niter)->name() == X_("CapturingSources")) {
1914 capture_pending_node = *niter;
1918 /* prevent write sources from being created */
1920 in_set_state = true;
1922 if ((prop = node.property ("name")) != 0) {
1923 _name = prop->value();
1926 if (deprecated_io_node) {
1927 if ((prop = deprecated_io_node->property ("id")) != 0) {
1928 _id = prop->value ();
1931 if ((prop = node.property ("id")) != 0) {
1932 _id = prop->value ();
1936 if ((prop = node.property ("flags")) != 0) {
1937 _flags = Flag (string_2_enum (prop->value(), _flags));
1940 if ((prop = node.property ("channels")) != 0) {
1941 nchans = atoi (prop->value().c_str());
1944 // create necessary extra channels
1945 // we are always constructed with one and we always need one
1947 _n_channels = channels.reader()->size();
1949 if (nchans > _n_channels) {
1951 add_channel (nchans - _n_channels);
1953 } else if (nchans < _n_channels) {
1955 remove_channel (_n_channels - nchans);
1958 if ((prop = node.property ("playlist")) == 0) {
1963 bool had_playlist = (_playlist != 0);
1965 if (find_and_use_playlist (prop->value())) {
1969 if (!had_playlist) {
1970 _playlist->set_orig_diskstream_id (_id);
1973 if (!destructive() && capture_pending_node) {
1974 /* destructive streams have one and only one source per channel,
1975 and so they never end up in pending capture in any useful
1978 use_pending_capture_data (*capture_pending_node);
1983 if ((prop = node.property ("speed")) != 0) {
1984 double sp = atof (prop->value().c_str());
1986 if (realtime_set_speed (sp, false)) {
1987 non_realtime_set_speed ();
1991 in_set_state = false;
1993 /* make sure this is clear before we do anything else */
1995 capturing_sources.clear ();
1997 /* write sources are handled when we handle the input set
1998 up of the IO that owns this DS (::non_realtime_input_change())
2001 in_set_state = false;
2007 AudioDiskstream::use_new_write_source (uint32_t n)
2009 boost::shared_ptr<ChannelList> c = channels.reader();
2011 if (!recordable()) {
2015 if (n >= c->size()) {
2016 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2020 ChannelInfo* chan = (*c)[n];
2022 if (chan->write_source) {
2023 chan->write_source->done_with_peakfile_writes ();
2024 chan->write_source->set_allow_remove_if_empty (true);
2025 chan->write_source.reset ();
2029 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2030 throw failed_constructor();
2034 catch (failed_constructor &err) {
2035 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2036 chan->write_source.reset ();
2040 /* do not remove destructive files even if they are empty */
2042 chan->write_source->set_allow_remove_if_empty (!destructive());
2048 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2050 ChannelList::iterator chan;
2051 boost::shared_ptr<ChannelList> c = channels.reader();
2054 if (!recordable()) {
2058 capturing_sources.clear ();
2060 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2061 if (!destructive()) {
2063 if ((*chan)->write_source && mark_write_complete) {
2064 (*chan)->write_source->mark_streaming_write_completed ();
2066 use_new_write_source (n);
2068 if (record_enabled()) {
2069 capturing_sources.push_back ((*chan)->write_source);
2073 if ((*chan)->write_source == 0) {
2074 use_new_write_source (n);
2079 if (destructive()) {
2081 /* we now have all our write sources set up, so create the
2082 playlist's single region.
2085 if (_playlist->empty()) {
2086 setup_destructive_playlist ();
2092 AudioDiskstream::rename_write_sources ()
2094 ChannelList::iterator chan;
2095 boost::shared_ptr<ChannelList> c = channels.reader();
2098 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2099 if ((*chan)->write_source != 0) {
2100 (*chan)->write_source->set_name (_name, destructive());
2101 /* XXX what to do if one of them fails ? */
2109 AudioDiskstream::set_block_size (nframes_t nframes)
2111 if (_session.get_block_size() > speed_buffer_size) {
2112 speed_buffer_size = _session.get_block_size();
2113 boost::shared_ptr<ChannelList> c = channels.reader();
2115 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2116 if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2117 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2120 allocate_temporary_buffers ();
2124 AudioDiskstream::allocate_temporary_buffers ()
2126 /* make sure the wrap buffer is at least large enough to deal
2127 with the speeds up to 1.2, to allow for micro-variation
2128 when slaving to MTC, SMPTE etc.
2131 double sp = max (fabsf (_actual_speed), 1.2f);
2132 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2134 if (required_wrap_size > wrap_buffer_size) {
2136 boost::shared_ptr<ChannelList> c = channels.reader();
2138 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2139 if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2140 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2141 if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2142 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2145 wrap_buffer_size = required_wrap_size;
2150 AudioDiskstream::monitor_input (bool yn)
2152 boost::shared_ptr<ChannelList> c = channels.reader();
2154 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2156 if ((*chan)->source) {
2157 (*chan)->source->ensure_monitor_input (yn);
2163 AudioDiskstream::set_align_style_from_io ()
2165 bool have_physical = false;
2171 get_input_sources ();
2173 boost::shared_ptr<ChannelList> c = channels.reader();
2175 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2176 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2177 have_physical = true;
2182 if (have_physical) {
2183 set_align_style (ExistingMaterial);
2185 set_align_style (CaptureTime);
2190 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2192 while (how_many--) {
2193 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2196 _n_channels = c->size();
2202 AudioDiskstream::add_channel (uint32_t how_many)
2204 RCUWriter<ChannelList> writer (channels);
2205 boost::shared_ptr<ChannelList> c = writer.get_copy();
2207 return add_channel_to (c, how_many);
2211 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2213 while (--how_many && !c->empty()) {
2218 _n_channels = c->size();
2224 AudioDiskstream::remove_channel (uint32_t how_many)
2226 RCUWriter<ChannelList> writer (channels);
2227 boost::shared_ptr<ChannelList> c = writer.get_copy();
2229 return remove_channel_from (c, how_many);
2233 AudioDiskstream::playback_buffer_load () const
2235 boost::shared_ptr<ChannelList> c = channels.reader();
2237 return (float) ((double) c->front()->playback_buf->read_space()/
2238 (double) c->front()->playback_buf->bufsize());
2242 AudioDiskstream::capture_buffer_load () const
2244 boost::shared_ptr<ChannelList> c = channels.reader();
2246 return (float) ((double) c->front()->capture_buf->write_space()/
2247 (double) c->front()->capture_buf->bufsize());
2251 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2253 const XMLProperty* prop;
2254 XMLNodeList nlist = node.children();
2255 XMLNodeIterator niter;
2256 boost::shared_ptr<AudioFileSource> fs;
2257 boost::shared_ptr<AudioFileSource> first_fs;
2258 SourceList pending_sources;
2261 if ((prop = node.property (X_("at"))) == 0) {
2265 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2269 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2270 if ((*niter)->name() == X_("file")) {
2272 if ((prop = (*niter)->property (X_("path"))) == 0) {
2277 fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (_session, prop->value(), false, _session.frame_rate()));
2280 catch (failed_constructor& err) {
2281 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2282 _name, prop->value())
2287 pending_sources.push_back (fs);
2289 if (first_fs == 0) {
2293 fs->set_captured_for (_name);
2297 if (pending_sources.size() == 0) {
2298 /* nothing can be done */
2302 if (pending_sources.size() != _n_channels) {
2303 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2308 boost::shared_ptr<AudioRegion> region;
2311 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2312 region_name_from_path (first_fs->name(), true),
2313 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2314 region->special_set_position (0);
2317 catch (failed_constructor& err) {
2318 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2326 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2329 catch (failed_constructor& err) {
2330 error << string_compose (_("%1: cannot create region from pending capture sources"),
2337 _playlist->add_region (region, position);
2343 AudioDiskstream::set_destructive (bool yn)
2345 bool bounce_ignored;
2347 if (yn != destructive()) {
2350 /* requestor should already have checked this and
2351 bounced if necessary and desired
2353 if (!can_become_destructive (bounce_ignored)) {
2356 _flags = Flag (_flags | Destructive);
2357 use_destructive_playlist ();
2359 _flags = Flag (_flags & ~Destructive);
2360 reset_write_sources (true, true);
2368 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2371 requires_bounce = false;
2375 /* is there only one region ? */
2377 if (_playlist->n_regions() != 1) {
2378 requires_bounce = true;
2382 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2385 /* do the source(s) for the region cover the session start position ? */
2387 if (first->position() != _session.current_start_frame()) {
2388 if (first->start() > _session.current_start_frame()) {
2389 requires_bounce = true;
2394 /* is the source used by only 1 playlist ? */
2396 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2400 if (afirst->source()->used() > 1) {
2401 requires_bounce = true;
2405 requires_bounce = false;
2409 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2413 current_capture_buffer = 0;
2414 current_playback_buffer = 0;
2415 curr_capture_cnt = 0;
2417 speed_buffer = new Sample[speed_size];
2418 playback_wrap_buffer = new Sample[wrap_size];
2419 capture_wrap_buffer = new Sample[wrap_size];
2421 playback_buf = new RingBufferNPT<Sample> (bufsize);
2422 capture_buf = new RingBufferNPT<Sample> (bufsize);
2423 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2425 /* touch the ringbuffer buffers, which will cause
2426 them to be mapped into locked physical RAM if
2427 we're running with mlockall(). this doesn't do
2431 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2432 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2433 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2436 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2439 write_source.reset ();
2443 delete [] speed_buffer;
2447 if (playback_wrap_buffer) {
2448 delete [] playback_wrap_buffer;
2449 playback_wrap_buffer = 0;
2452 if (capture_wrap_buffer) {
2453 delete [] capture_wrap_buffer;
2454 capture_wrap_buffer = 0;
2458 delete playback_buf;
2467 if (capture_transition_buf) {
2468 delete capture_transition_buf;
2469 capture_transition_buf = 0;