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) {
653 Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
654 nframes_t first = chaninfo->capture_vector.len[0];
656 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
657 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
658 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
659 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
661 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
668 finish_capture (rec_monitors_input, c);
675 /* data will be written to disk */
677 if (rec_nframes == nframes && rec_offset == 0) {
679 for (chan = c->begin(); chan != c->end(); ++chan) {
680 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
683 playback_distance = nframes;
688 /* we can't use the capture buffer as the playback buffer, because
689 we recorded only a part of the current process' cycle data
693 collect_playback = true;
696 adjust_capture_position = rec_nframes;
698 } else if (nominally_recording) {
700 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
702 for (chan = c->begin(); chan != c->end(); ++chan) {
703 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
706 playback_distance = nframes;
710 collect_playback = true;
713 if (collect_playback) {
715 /* we're doing playback */
717 nframes_t necessary_samples;
719 /* no varispeed playback if we're recording, because the output .... TBD */
721 if (rec_nframes == 0 && _actual_speed != 1.0f) {
722 necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
724 necessary_samples = nframes;
727 for (chan = c->begin(); chan != c->end(); ++chan) {
728 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
733 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
735 ChannelInfo* chaninfo (*chan);
737 if (necessary_samples <= chaninfo->playback_vector.len[0]) {
739 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
742 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
744 if (necessary_samples > total) {
750 memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
751 chaninfo->playback_vector.len[0] * sizeof (Sample));
752 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
753 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
755 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
760 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
762 uint64_t phase = last_phase;
766 // Linearly interpolate into the alt buffer
767 // using 40.24 fixp maths (swh)
769 if (phi != target_phi) {
770 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
775 for (chan = c->begin(); chan != c->end(); ++chan) {
778 ChannelInfo* chaninfo (*chan);
783 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
785 fr = (phase & 0xFFFFFF) / 16777216.0f;
786 chaninfo->speed_buffer[outsample] =
787 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
788 chaninfo->current_playback_buffer[i+1] * fr;
789 phase += phi + phi_delta;
792 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
795 playback_distance = i; // + 1;
796 last_phase = (phase & 0xFFFFFF);
799 playback_distance = nframes;
812 /* we're exiting with failure, so ::commit will not
813 be called. unlock the state lock.
816 commit_should_unlock = false;
824 AudioDiskstream::commit (nframes_t nframes)
826 bool need_butler = false;
828 if (_actual_speed < 0.0) {
829 playback_sample -= playback_distance;
831 playback_sample += playback_distance;
834 boost::shared_ptr<ChannelList> c = channels.reader();
835 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
837 (*chan)->playback_buf->increment_read_ptr (playback_distance);
839 if (adjust_capture_position) {
840 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
844 if (adjust_capture_position != 0) {
845 capture_captured += adjust_capture_position;
846 adjust_capture_position = 0;
850 if (_io && _io->active()) {
851 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
856 if (_io && _io->active()) {
857 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
858 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
860 need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
864 if (commit_should_unlock) {
874 AudioDiskstream::set_pending_overwrite (bool yn)
876 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
878 pending_overwrite = yn;
880 overwrite_frame = playback_sample;
881 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
885 AudioDiskstream::overwrite_existing_buffers ()
887 boost::shared_ptr<ChannelList> c = channels.reader();
888 Sample* mixdown_buffer;
891 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
893 overwrite_queued = false;
895 /* assume all are the same size */
896 nframes_t size = c->front()->playback_buf->bufsize();
898 mixdown_buffer = new Sample[size];
899 gain_buffer = new float[size];
901 /* reduce size so that we can fill the buffer correctly. */
907 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
909 start = overwrite_frame;
910 nframes_t cnt = size;
912 /* to fill the buffer without resetting the playback sample, we need to
913 do it one or two chunks (normally two).
915 |----------------------------------------------------------------------|
919 |<- second chunk->||<----------------- first chunk ------------------>|
923 nframes_t to_read = size - overwrite_offset;
925 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
926 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
927 _id, size, playback_sample) << endmsg;
935 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
936 start, cnt, *chan, n, reversed)) {
937 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
938 _id, size, playback_sample) << endmsg;
947 pending_overwrite = false;
948 delete [] gain_buffer;
949 delete [] mixdown_buffer;
954 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
958 ChannelList::iterator chan;
959 boost::shared_ptr<ChannelList> c = channels.reader();
961 Glib::Mutex::Lock lm (state_lock);
963 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
964 (*chan)->playback_buf->reset ();
965 (*chan)->capture_buf->reset ();
968 /* can't rec-enable in destructive mode if transport is before start */
970 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
971 disengage_record_enable ();
974 playback_sample = frame;
977 if (complete_refill) {
978 while ((ret = do_refill_with_alloc ()) > 0) ;
980 ret = do_refill_with_alloc ();
987 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
989 ChannelList::iterator chan;
990 boost::shared_ptr<ChannelList> c = channels.reader();
992 for (chan = c->begin(); chan != c->end(); ++chan) {
993 if ((*chan)->playback_buf->read_space() < distance) {
1001 AudioDiskstream::internal_playback_seek (nframes_t distance)
1003 ChannelList::iterator chan;
1004 boost::shared_ptr<ChannelList> c = channels.reader();
1006 for (chan = c->begin(); chan != c->end(); ++chan) {
1007 (*chan)->playback_buf->increment_read_ptr (distance);
1010 first_recordable_frame += distance;
1011 playback_sample += distance;
1017 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1018 ChannelInfo* channel_info, int channel, bool reversed)
1020 nframes_t this_read = 0;
1021 bool reloop = false;
1022 nframes_t loop_end = 0;
1023 nframes_t loop_start = 0;
1024 nframes_t loop_length = 0;
1025 nframes_t offset = 0;
1026 nframes_t xfade_samples = 0;
1027 Sample xfade_buf[128];
1030 /* XXX we don't currently play loops in reverse. not sure why */
1034 /* Make the use of a Location atomic for this read operation.
1036 Note: Locations don't get deleted, so all we care about
1037 when I say "atomic" is that we are always pointing to
1038 the same one and using a start/length values obtained
1042 if ((loc = loop_location) != 0) {
1043 loop_start = loc->start();
1044 loop_end = loc->end();
1045 loop_length = loop_end - loop_start;
1048 /* if we are looping, ensure that the first frame we read is at the correct
1049 position within the loop.
1052 if (loc && start >= loop_end) {
1053 //cerr << "start adjusted from " << start;
1054 start = loop_start + ((start - loop_start) % loop_length);
1055 //cerr << "to " << start << endl;
1058 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1067 /* take any loop into account. we can't read past the end of the loop. */
1069 if (loc && (loop_end - start < cnt)) {
1070 this_read = loop_end - start;
1071 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1078 if (this_read == 0) {
1082 this_read = min(cnt,this_read);
1084 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1085 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1090 // xfade loop boundary if appropriate
1092 if (xfade_samples > 0) {
1093 // just do a linear xfade for this short bit
1095 xfade_samples = min(xfade_samples, this_read);
1097 float delta = 1.0f / xfade_samples;
1099 Sample * tmpbuf = buf+offset;
1101 for (size_t i=0; i < xfade_samples; ++i) {
1102 *tmpbuf = (*tmpbuf * scale) + xfade_buf[i]*(1.0f - scale);
1110 _read_data_count = _playlist->read_data_count();
1114 swap_by_ptr (buf, buf + this_read - 1);
1119 /* if we read to the end of the loop, go back to the beginning */
1122 // read crossfade samples to apply to the next read
1124 xfade_samples = min((nframes_t) 128, cnt-this_read);
1126 if (audio_playlist()->read (xfade_buf, mixdown_buffer, gain_buffer, start, xfade_samples, channel) != xfade_samples) {
1127 error << string_compose(_("AudioDiskstream %1: cannot read xfade samples %2 from playlist at frame %3"),
1128 _id, xfade_samples,start) << endmsg;
1129 memset(xfade_buf, 0, xfade_samples * sizeof(Sample)); // just in case
1137 offset += this_read;
1144 AudioDiskstream::do_refill_with_alloc ()
1146 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1147 float* gain_buf = new float[disk_io_chunk_frames];
1149 int ret = _do_refill(mix_buf, gain_buf);
1158 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1162 RingBufferNPT<Sample>::rw_vector vector;
1163 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1164 nframes_t total_space;
1165 nframes_t zero_fill;
1167 ChannelList::iterator i;
1168 boost::shared_ptr<ChannelList> c = channels.reader();
1175 assert(mixdown_buffer);
1176 assert(gain_buffer);
1183 c->front()->playback_buf->get_write_vector (&vector);
1185 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1189 /* if there are 2+ chunks of disk i/o possible for
1190 this track, let the caller know so that it can arrange
1191 for us to be called again, ASAP.
1194 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1198 /* if we're running close to normal speed and there isn't enough
1199 space to do disk_io_chunk_frames of I/O, then don't bother.
1201 at higher speeds, just do it because the sync between butler
1202 and audio thread may not be good enough.
1205 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1209 /* when slaved, don't try to get too close to the read pointer. this
1210 leaves space for the buffer reversal to have something useful to
1214 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1218 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1220 total_space = min (disk_io_chunk_frames, total_space);
1224 if (file_frame == 0) {
1226 /* at start: nothing to do but fill with silence */
1228 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1230 ChannelInfo* chan (*i);
1231 chan->playback_buf->get_write_vector (&vector);
1232 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1233 if (vector.len[1]) {
1234 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1236 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1241 if (file_frame < total_space) {
1243 /* too close to the start: read what we can,
1244 and then zero fill the rest
1247 zero_fill = total_space - file_frame;
1248 total_space = file_frame;
1258 if (file_frame == max_frames) {
1260 /* at end: nothing to do but fill with silence */
1262 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1264 ChannelInfo* chan (*i);
1265 chan->playback_buf->get_write_vector (&vector);
1266 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1267 if (vector.len[1]) {
1268 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1270 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1275 if (file_frame > max_frames - total_space) {
1277 /* to close to the end: read what we can, and zero fill the rest */
1279 zero_fill = total_space - (max_frames - file_frame);
1280 total_space = max_frames - file_frame;
1287 nframes_t file_frame_tmp = 0;
1289 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1291 ChannelInfo* chan (*i);
1294 nframes_t len1, len2;
1296 chan->playback_buf->get_write_vector (&vector);
1298 if (vector.len[0] > disk_io_chunk_frames) {
1300 /* we're not going to fill the first chunk, so certainly do not bother with the
1301 other part. it won't be connected with the part we do fill, as in:
1303 .... => writable space
1304 ++++ => readable space
1305 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1307 |......|+++++++++++++|...............................|
1312 So, just pretend that the buf1 part isn't there.
1322 file_frame_tmp = file_frame;
1324 buf1 = vector.buf[0];
1325 len1 = vector.len[0];
1326 buf2 = vector.buf[1];
1327 len2 = vector.len[1];
1329 to_read = min (ts, len1);
1330 to_read = min (to_read, disk_io_chunk_frames);
1334 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1339 chan->playback_buf->increment_write_ptr (to_read);
1343 to_read = min (ts, len2);
1347 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1348 so read some or all of vector.len[1] as well.
1351 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1356 chan->playback_buf->increment_write_ptr (to_read);
1365 file_frame = file_frame_tmp;
1372 /** Flush pending data to disk.
1374 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1375 * of data to disk. it will never write more than that. If it writes that
1376 * much and there is more than that waiting to be written, it will return 1,
1377 * otherwise 0 on success or -1 on failure.
1379 * If there is less than disk_io_chunk_frames to be written, no data will be
1380 * written at all unless @a force_flush is true.
1383 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1387 RingBufferNPT<Sample>::rw_vector vector;
1388 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1391 _write_data_count = 0;
1393 transvec.buf[0] = 0;
1394 transvec.buf[1] = 0;
1398 boost::shared_ptr<ChannelList> c = channels.reader();
1399 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1401 (*chan)->capture_buf->get_read_vector (&vector);
1403 total = vector.len[0] + vector.len[1];
1405 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1409 /* if there are 2+ chunks of disk i/o possible for
1410 this track, let the caller know so that it can arrange
1411 for us to be called again, ASAP.
1413 if we are forcing a flush, then if there is* any* extra
1414 work, let the caller know.
1416 if we are no longer recording and there is any extra work,
1417 let the caller know too.
1420 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1424 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1426 // check the transition buffer when recording destructive
1427 // important that we get this after the capture buf
1429 if (destructive()) {
1430 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1431 size_t transcount = transvec.len[0] + transvec.len[1];
1432 bool have_start = false;
1435 for (ti=0; ti < transcount; ++ti) {
1436 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1438 if (captrans.type == CaptureStart) {
1439 // by definition, the first data we got above represents the given capture pos
1441 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1442 (*chan)->curr_capture_cnt = 0;
1446 else if (captrans.type == CaptureEnd) {
1448 // capture end, the capture_val represents total frames in capture
1450 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1452 // shorten to make the write a perfect fit
1453 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1455 if (nto_write < to_write) {
1456 ret = 1; // should we?
1458 to_write = nto_write;
1460 (*chan)->write_source->mark_capture_end ();
1462 // increment past this transition, but go no further
1467 // actually ends just beyond this chunk, so force more work
1475 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1479 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1480 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1484 (*chan)->capture_buf->increment_read_ptr (to_write);
1485 (*chan)->curr_capture_cnt += to_write;
1487 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1489 /* we wrote all of vector.len[0] but it wasn't an entire
1490 disk_io_chunk_frames of data, so arrange for some part
1491 of vector.len[1] to be flushed to disk as well.
1494 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1496 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1497 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1501 _write_data_count += (*chan)->write_source->write_data_count();
1503 (*chan)->capture_buf->increment_read_ptr (to_write);
1504 (*chan)->curr_capture_cnt += to_write;
1513 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1515 uint32_t buffer_position;
1516 bool more_work = true;
1518 boost::shared_ptr<AudioRegion> region;
1519 nframes_t total_capture;
1521 SourceList::iterator src;
1522 ChannelList::iterator chan;
1523 vector<CaptureInfo*>::iterator ci;
1524 boost::shared_ptr<ChannelList> c = channels.reader();
1526 bool mark_write_completed = false;
1528 finish_capture (true, c);
1530 /* butler is already stopped, but there may be work to do
1531 to flush remaining data to disk.
1534 while (more_work && !err) {
1535 switch (do_flush (Session::TransportContext, true)) {
1542 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1547 /* XXX is there anything we can do if err != 0 ? */
1548 Glib::Mutex::Lock lm (capture_info_lock);
1550 if (capture_info.empty()) {
1554 if (abort_capture) {
1556 if (destructive()) {
1560 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1562 if ((*chan)->write_source) {
1564 (*chan)->write_source->mark_for_remove ();
1565 (*chan)->write_source->drop_references ();
1566 (*chan)->write_source.reset ();
1569 /* new source set up in "out" below */
1575 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1576 total_capture += (*ci)->frames;
1579 /* figure out the name for this take */
1581 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1583 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1587 s->update_header (capture_info.front()->start, when, twhen);
1588 s->set_captured_for (_name);
1589 s->mark_immutable ();
1593 /* destructive tracks have a single, never changing region */
1595 if (destructive()) {
1597 /* send a signal that any UI can pick up to do the right thing. there is
1598 a small problem here in that a UI may need the peak data to be ready
1599 for the data that was recorded and this isn't interlocked with that
1600 process. this problem is deferred to the UI.
1603 _playlist->Modified();
1607 string whole_file_region_name;
1608 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1610 /* Register a new region with the Session that
1611 describes the entire source. Do this first
1612 so that any sub-regions will obviously be
1613 children of this one (later!)
1617 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1618 whole_file_region_name,
1619 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1621 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1622 region->special_set_position (capture_info.front()->start);
1626 catch (failed_constructor& err) {
1627 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1631 _last_capture_regions.push_back (region);
1633 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1635 XMLNode &before = _playlist->get_state();
1636 _playlist->freeze ();
1638 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1642 _session.region_name (region_name, whole_file_region_name, false);
1644 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1647 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1648 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1651 catch (failed_constructor& err) {
1652 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1653 continue; /* XXX is this OK? */
1656 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1658 _last_capture_regions.push_back (region);
1660 i_am_the_modifier++;
1661 _playlist->add_region (region, (*ci)->start);
1662 i_am_the_modifier--;
1664 buffer_position += (*ci)->frames;
1668 XMLNode &after = _playlist->get_state();
1669 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1672 mark_write_completed = true;
1675 reset_write_sources (mark_write_completed);
1679 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1683 capture_info.clear ();
1684 capture_start_frame = 0;
1688 AudioDiskstream::transport_looped (nframes_t transport_frame)
1690 if (was_recording) {
1691 // all we need to do is finish this capture, with modified capture length
1692 boost::shared_ptr<ChannelList> c = channels.reader();
1694 // adjust the capture length knowing that the data will be recorded to disk
1695 // only necessary after the first loop where we're recording
1696 if (capture_info.size() == 0) {
1697 capture_captured += _capture_offset;
1699 if (_alignment_style == ExistingMaterial) {
1700 capture_captured += _session.worst_output_latency();
1702 capture_captured += _roll_delay;
1706 finish_capture (true, c);
1708 // the next region will start recording via the normal mechanism
1709 // we'll set the start position to the current transport pos
1710 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1711 capture_start_frame = transport_frame;
1712 first_recordable_frame = transport_frame; // mild lie
1713 last_recordable_frame = max_frames;
1714 was_recording = true;
1716 if (recordable() && destructive()) {
1717 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1719 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1720 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1722 if (transvec.len[0] > 0) {
1723 transvec.buf[0]->type = CaptureStart;
1724 transvec.buf[0]->capture_val = capture_start_frame;
1725 (*chan)->capture_transition_buf->increment_write_ptr(1);
1729 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1739 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1741 was_recording = false;
1743 if (capture_captured == 0) {
1747 if (recordable() && destructive()) {
1748 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1750 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1751 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1753 if (transvec.len[0] > 0) {
1754 transvec.buf[0]->type = CaptureEnd;
1755 transvec.buf[0]->capture_val = capture_captured;
1756 (*chan)->capture_transition_buf->increment_write_ptr(1);
1760 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1766 CaptureInfo* ci = new CaptureInfo;
1768 ci->start = capture_start_frame;
1769 ci->frames = capture_captured;
1771 /* XXX theoretical race condition here. Need atomic exchange ?
1772 However, the circumstances when this is called right
1773 now (either on record-disable or transport_stopped)
1774 mean that no actual race exists. I think ...
1775 We now have a capture_info_lock, but it is only to be used
1776 to synchronize in the transport_stop and the capture info
1777 accessors, so that invalidation will not occur (both non-realtime).
1780 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1782 capture_info.push_back (ci);
1783 capture_captured = 0;
1787 AudioDiskstream::set_record_enabled (bool yn)
1789 if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs() == 0) {
1793 /* can't rec-enable in destructive mode if transport is before start */
1795 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1799 if (yn && channels.reader()->front()->source == 0) {
1801 /* pick up connections not initiated *from* the IO object
1802 we're associated with.
1805 get_input_sources ();
1808 /* yes, i know that this not proof against race conditions, but its
1809 good enough. i think.
1812 if (record_enabled() != yn) {
1814 engage_record_enable ();
1816 disengage_record_enable ();
1822 AudioDiskstream::engage_record_enable ()
1824 bool rolling = _session.transport_speed() != 0.0f;
1825 boost::shared_ptr<ChannelList> c = channels.reader();
1827 g_atomic_int_set (&_record_enabled, 1);
1828 capturing_sources.clear ();
1830 if (Config->get_monitoring_model() == HardwareMonitoring) {
1832 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1833 if ((*chan)->source) {
1834 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1836 capturing_sources.push_back ((*chan)->write_source);
1840 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1841 capturing_sources.push_back ((*chan)->write_source);
1845 RecordEnableChanged (); /* EMIT SIGNAL */
1849 AudioDiskstream::disengage_record_enable ()
1851 g_atomic_int_set (&_record_enabled, 0);
1852 boost::shared_ptr<ChannelList> c = channels.reader();
1853 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1854 if (Config->get_monitoring_model() == HardwareMonitoring) {
1855 if ((*chan)->source) {
1856 (*chan)->source->ensure_monitor_input (false);
1860 capturing_sources.clear ();
1861 RecordEnableChanged (); /* EMIT SIGNAL */
1865 AudioDiskstream::get_state ()
1867 XMLNode* node = new XMLNode ("AudioDiskstream");
1869 LocaleGuard lg (X_("POSIX"));
1870 boost::shared_ptr<ChannelList> c = channels.reader();
1872 node->add_property ("flags", enum_2_string (_flags));
1874 snprintf (buf, sizeof(buf), "%zd", c->size());
1875 node->add_property ("channels", buf);
1877 node->add_property ("playlist", _playlist->name());
1879 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1880 node->add_property ("speed", buf);
1882 node->add_property("name", _name);
1883 id().print (buf, sizeof (buf));
1884 node->add_property("id", buf);
1886 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1888 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1889 XMLNode* cs_grandchild;
1891 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1892 cs_grandchild = new XMLNode (X_("file"));
1893 cs_grandchild->add_property (X_("path"), (*i)->path());
1894 cs_child->add_child_nocopy (*cs_grandchild);
1897 /* store the location where capture will start */
1901 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1902 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1904 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1907 cs_child->add_property (X_("at"), buf);
1908 node->add_child_nocopy (*cs_child);
1912 node->add_child_copy (*_extra_xml);
1919 AudioDiskstream::set_state (const XMLNode& node)
1921 const XMLProperty* prop;
1922 XMLNodeList nlist = node.children();
1923 XMLNodeIterator niter;
1924 uint32_t nchans = 1;
1925 XMLNode* capture_pending_node = 0;
1926 LocaleGuard lg (X_("POSIX"));
1928 in_set_state = true;
1930 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1931 if ((*niter)->name() == IO::state_node_name) {
1932 deprecated_io_node = new XMLNode (**niter);
1935 if ((*niter)->name() == X_("CapturingSources")) {
1936 capture_pending_node = *niter;
1940 /* prevent write sources from being created */
1942 in_set_state = true;
1944 if ((prop = node.property ("name")) != 0) {
1945 _name = prop->value();
1948 if (deprecated_io_node) {
1949 if ((prop = deprecated_io_node->property ("id")) != 0) {
1950 _id = prop->value ();
1953 if ((prop = node.property ("id")) != 0) {
1954 _id = prop->value ();
1958 if ((prop = node.property ("flags")) != 0) {
1959 _flags = Flag (string_2_enum (prop->value(), _flags));
1962 if ((prop = node.property ("channels")) != 0) {
1963 nchans = atoi (prop->value().c_str());
1966 // create necessary extra channels
1967 // we are always constructed with one and we always need one
1969 _n_channels = channels.reader()->size();
1971 if (nchans > _n_channels) {
1973 add_channel (nchans - _n_channels);
1974 IO::MoreOutputs(_n_channels);
1976 } else if (nchans < _n_channels) {
1978 remove_channel (_n_channels - nchans);
1981 if ((prop = node.property ("playlist")) == 0) {
1986 bool had_playlist = (_playlist != 0);
1988 if (find_and_use_playlist (prop->value())) {
1992 if (!had_playlist) {
1993 _playlist->set_orig_diskstream_id (_id);
1996 if (!destructive() && capture_pending_node) {
1997 /* destructive streams have one and only one source per channel,
1998 and so they never end up in pending capture in any useful
2001 use_pending_capture_data (*capture_pending_node);
2006 if ((prop = node.property ("speed")) != 0) {
2007 double sp = atof (prop->value().c_str());
2009 if (realtime_set_speed (sp, false)) {
2010 non_realtime_set_speed ();
2014 in_set_state = false;
2016 /* make sure this is clear before we do anything else */
2018 capturing_sources.clear ();
2020 /* write sources are handled when we handle the input set
2021 up of the IO that owns this DS (::non_realtime_input_change())
2028 AudioDiskstream::use_new_write_source (uint32_t n)
2030 boost::shared_ptr<ChannelList> c = channels.reader();
2032 if (!recordable()) {
2036 if (n >= c->size()) {
2037 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2041 ChannelInfo* chan = (*c)[n];
2043 if (chan->write_source) {
2044 chan->write_source->done_with_peakfile_writes ();
2045 chan->write_source->set_allow_remove_if_empty (true);
2046 chan->write_source.reset ();
2050 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2051 throw failed_constructor();
2055 catch (failed_constructor &err) {
2056 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2057 chan->write_source.reset ();
2061 /* do not remove destructive files even if they are empty */
2063 chan->write_source->set_allow_remove_if_empty (!destructive());
2069 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2071 ChannelList::iterator chan;
2072 boost::shared_ptr<ChannelList> c = channels.reader();
2075 if (!recordable()) {
2079 capturing_sources.clear ();
2081 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2082 if (!destructive()) {
2084 if ((*chan)->write_source && mark_write_complete) {
2085 (*chan)->write_source->mark_streaming_write_completed ();
2087 use_new_write_source (n);
2089 if (record_enabled()) {
2090 capturing_sources.push_back ((*chan)->write_source);
2094 if ((*chan)->write_source == 0) {
2095 use_new_write_source (n);
2100 if (destructive()) {
2102 /* we now have all our write sources set up, so create the
2103 playlist's single region.
2106 if (_playlist->empty()) {
2107 setup_destructive_playlist ();
2113 AudioDiskstream::rename_write_sources ()
2115 ChannelList::iterator chan;
2116 boost::shared_ptr<ChannelList> c = channels.reader();
2119 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2120 if ((*chan)->write_source != 0) {
2121 (*chan)->write_source->set_name (_name, destructive());
2122 /* XXX what to do if one of them fails ? */
2130 AudioDiskstream::set_block_size (nframes_t nframes)
2132 if (_session.get_block_size() > speed_buffer_size) {
2133 speed_buffer_size = _session.get_block_size();
2134 boost::shared_ptr<ChannelList> c = channels.reader();
2136 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2137 if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2138 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2141 allocate_temporary_buffers ();
2145 AudioDiskstream::allocate_temporary_buffers ()
2147 /* make sure the wrap buffer is at least large enough to deal
2148 with the speeds up to 1.2, to allow for micro-variation
2149 when slaving to MTC, SMPTE etc.
2152 double sp = max (fabsf (_actual_speed), 1.2f);
2153 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2155 if (required_wrap_size > wrap_buffer_size) {
2157 boost::shared_ptr<ChannelList> c = channels.reader();
2159 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2160 if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2161 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2162 if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2163 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2166 wrap_buffer_size = required_wrap_size;
2171 AudioDiskstream::monitor_input (bool yn)
2173 boost::shared_ptr<ChannelList> c = channels.reader();
2175 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2177 if ((*chan)->source) {
2178 (*chan)->source->ensure_monitor_input (yn);
2184 AudioDiskstream::set_align_style_from_io ()
2186 bool have_physical = false;
2192 get_input_sources ();
2194 boost::shared_ptr<ChannelList> c = channels.reader();
2196 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2197 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2198 have_physical = true;
2203 if (have_physical) {
2204 set_align_style (ExistingMaterial);
2206 set_align_style (CaptureTime);
2211 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2213 while (how_many--) {
2214 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2217 _n_channels = c->size();
2223 AudioDiskstream::add_channel (uint32_t how_many)
2225 RCUWriter<ChannelList> writer (channels);
2226 boost::shared_ptr<ChannelList> c = writer.get_copy();
2228 return add_channel_to (c, how_many);
2232 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2234 while (--how_many && !c->empty()) {
2239 _n_channels = c->size();
2245 AudioDiskstream::remove_channel (uint32_t how_many)
2247 RCUWriter<ChannelList> writer (channels);
2248 boost::shared_ptr<ChannelList> c = writer.get_copy();
2250 return remove_channel_from (c, how_many);
2254 AudioDiskstream::playback_buffer_load () const
2256 boost::shared_ptr<ChannelList> c = channels.reader();
2258 return (float) ((double) c->front()->playback_buf->read_space()/
2259 (double) c->front()->playback_buf->bufsize());
2263 AudioDiskstream::capture_buffer_load () const
2265 boost::shared_ptr<ChannelList> c = channels.reader();
2267 return (float) ((double) c->front()->capture_buf->write_space()/
2268 (double) c->front()->capture_buf->bufsize());
2272 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2274 const XMLProperty* prop;
2275 XMLNodeList nlist = node.children();
2276 XMLNodeIterator niter;
2277 boost::shared_ptr<AudioFileSource> fs;
2278 boost::shared_ptr<AudioFileSource> first_fs;
2279 SourceList pending_sources;
2282 if ((prop = node.property (X_("at"))) == 0) {
2286 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2290 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2291 if ((*niter)->name() == X_("file")) {
2293 if ((prop = (*niter)->property (X_("path"))) == 0) {
2297 // This protects sessions from errant CapturingSources in stored sessions
2299 if (stat (prop->value().c_str(), &sbuf)) {
2304 fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (_session, prop->value(), false, _session.frame_rate()));
2307 catch (failed_constructor& err) {
2308 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2309 _name, prop->value())
2314 pending_sources.push_back (fs);
2316 if (first_fs == 0) {
2320 fs->set_captured_for (_name);
2324 if (pending_sources.size() == 0) {
2325 /* nothing can be done */
2329 if (pending_sources.size() != _n_channels) {
2330 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2335 boost::shared_ptr<AudioRegion> region;
2338 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2339 region_name_from_path (first_fs->name(), true),
2340 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2341 region->special_set_position (0);
2344 catch (failed_constructor& err) {
2345 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2353 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2356 catch (failed_constructor& err) {
2357 error << string_compose (_("%1: cannot create region from pending capture sources"),
2364 _playlist->add_region (region, position);
2370 AudioDiskstream::set_destructive (bool yn)
2372 bool bounce_ignored;
2374 if (yn != destructive()) {
2377 /* requestor should already have checked this and
2378 bounced if necessary and desired
2380 if (!can_become_destructive (bounce_ignored)) {
2383 _flags = Flag (_flags | Destructive);
2384 use_destructive_playlist ();
2386 _flags = Flag (_flags & ~Destructive);
2387 reset_write_sources (true, true);
2395 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2398 requires_bounce = false;
2402 /* is there only one region ? */
2404 if (_playlist->n_regions() != 1) {
2405 requires_bounce = true;
2409 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2412 /* do the source(s) for the region cover the session start position ? */
2414 if (first->position() != _session.current_start_frame()) {
2415 if (first->start() > _session.current_start_frame()) {
2416 requires_bounce = true;
2421 /* is the source used by only 1 playlist ? */
2423 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2427 if (afirst->source()->used() > 1) {
2428 requires_bounce = true;
2432 requires_bounce = false;
2436 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2440 current_capture_buffer = 0;
2441 current_playback_buffer = 0;
2442 curr_capture_cnt = 0;
2444 speed_buffer = new Sample[speed_size];
2445 playback_wrap_buffer = new Sample[wrap_size];
2446 capture_wrap_buffer = new Sample[wrap_size];
2448 playback_buf = new RingBufferNPT<Sample> (bufsize);
2449 capture_buf = new RingBufferNPT<Sample> (bufsize);
2450 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2452 /* touch the ringbuffer buffers, which will cause
2453 them to be mapped into locked physical RAM if
2454 we're running with mlockall(). this doesn't do
2458 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2459 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2460 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2463 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2466 write_source.reset ();
2470 delete [] speed_buffer;
2474 if (playback_wrap_buffer) {
2475 delete [] playback_wrap_buffer;
2476 playback_wrap_buffer = 0;
2479 if (capture_wrap_buffer) {
2480 delete [] capture_wrap_buffer;
2481 capture_wrap_buffer = 0;
2485 delete playback_buf;
2494 if (capture_transition_buf) {
2495 delete capture_transition_buf;
2496 capture_transition_buf = 0;