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/audio_port.h>
54 #include <ardour/source_factory.h>
60 using namespace ARDOUR;
63 size_t AudioDiskstream::_working_buffers_size = 0;
64 Sample* AudioDiskstream::_mixdown_buffer = 0;
65 gain_t* AudioDiskstream::_gain_buffer = 0;
67 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
68 : Diskstream(sess, name, flag)
69 , deprecated_io_node(NULL)
70 , channels (new ChannelList)
72 /* prevent any write sources from being created */
82 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
83 : Diskstream(sess, node)
84 , deprecated_io_node(NULL)
85 , channels (new ChannelList)
90 if (set_state (node)) {
92 throw failed_constructor();
98 use_destructive_playlist ();
103 AudioDiskstream::init (Diskstream::Flag f)
107 /* there are no channels at this point, so these
108 two calls just get speed_buffer_size and wrap_buffer
109 size setup without duplicating their code.
112 set_block_size (_session.get_block_size());
113 allocate_temporary_buffers ();
116 assert(_n_channels == ChanCount(DataType::AUDIO, 1));
119 AudioDiskstream::~AudioDiskstream ()
124 RCUWriter<ChannelList> writer (channels);
125 boost::shared_ptr<ChannelList> c = writer.get_copy();
127 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
138 AudioDiskstream::allocate_working_buffers()
140 assert(disk_io_frames() > 0);
142 _working_buffers_size = disk_io_frames();
143 _mixdown_buffer = new Sample[_working_buffers_size];
144 _gain_buffer = new gain_t[_working_buffers_size];
148 AudioDiskstream::free_working_buffers()
150 delete [] _mixdown_buffer;
151 delete [] _gain_buffer;
152 _working_buffers_size = 0;
158 AudioDiskstream::non_realtime_input_change ()
161 Glib::Mutex::Lock lm (state_lock);
163 if (input_change_pending == NoChange) {
168 RCUWriter<ChannelList> writer (channels);
169 boost::shared_ptr<ChannelList> c = writer.get_copy();
171 _n_channels.set(DataType::AUDIO, c->size());
173 if (_io->n_inputs().n_audio() > _n_channels.n_audio()) {
174 add_channel_to (c, _io->n_inputs().n_audio() - _n_channels.n_audio());
175 } else if (_io->n_inputs().n_audio() < _n_channels.n_audio()) {
176 remove_channel_from (c, _n_channels.n_audio() - _io->n_inputs().n_audio());
180 get_input_sources ();
181 set_capture_offset ();
183 if (first_input_change) {
184 set_align_style (_persistent_alignment_style);
185 first_input_change = false;
187 set_align_style_from_io ();
190 input_change_pending = NoChange;
192 /* implicit unlock */
195 /* reset capture files */
197 reset_write_sources (false);
199 /* now refill channel buffers */
201 if (speed() != 1.0f || speed() != -1.0f) {
202 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
204 seek (_session.transport_frame());
209 AudioDiskstream::get_input_sources ()
211 boost::shared_ptr<ChannelList> c = channels.reader();
214 ChannelList::iterator chan;
215 uint32_t ni = _io->n_inputs().n_audio();
217 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
219 const char **connections = _io->input(n)->get_connections ();
221 if (connections == 0 || connections[0] == 0) {
223 if ((*chan)->source) {
224 // _source->disable_metering ();
230 (*chan)->source = dynamic_cast<AudioPort*>(
231 _session.engine().get_port_by_name (connections[0]) );
241 AudioDiskstream::find_and_use_playlist (const string& name)
243 boost::shared_ptr<AudioPlaylist> playlist;
245 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
246 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
250 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
254 return use_playlist (playlist);
258 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
260 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
262 Diskstream::use_playlist(playlist);
268 AudioDiskstream::use_new_playlist ()
271 boost::shared_ptr<AudioPlaylist> playlist;
273 if (!in_set_state && destructive()) {
278 newname = Playlist::bump_name (_playlist->name(), _session);
280 newname = Playlist::bump_name (_name, _session);
283 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
285 playlist->set_orig_diskstream_id (id());
286 return use_playlist (playlist);
294 AudioDiskstream::use_copy_playlist ()
296 assert(audio_playlist());
302 if (_playlist == 0) {
303 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
308 boost::shared_ptr<AudioPlaylist> playlist;
310 newname = Playlist::bump_name (_playlist->name(), _session);
312 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
313 playlist->set_orig_diskstream_id (id());
314 return use_playlist (playlist);
321 AudioDiskstream::setup_destructive_playlist ()
324 boost::shared_ptr<ChannelList> c = channels.reader();
326 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
327 srcs.push_back ((*chan)->write_source);
330 /* a single full-sized region */
332 boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
333 _playlist->add_region (region, srcs.front()->natural_position());
337 AudioDiskstream::use_destructive_playlist ()
339 /* this is called from the XML-based constructor or ::set_destructive. when called,
340 we already have a playlist and a region, but we need to
341 set up our sources for write. we use the sources associated
342 with the (presumed single, full-extent) region.
345 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
348 reset_write_sources (false, true);
352 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
355 throw failed_constructor();
358 /* be sure to stretch the region out to the maximum length */
360 region->set_length (max_frames - region->position(), this);
363 ChannelList::iterator chan;
364 boost::shared_ptr<ChannelList> c = channels.reader();
366 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
367 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
368 assert((*chan)->write_source);
369 (*chan)->write_source->set_allow_remove_if_empty (false);
371 /* this might be false if we switched modes, so force it */
373 (*chan)->write_source->set_destructive (true);
376 /* the source list will never be reset for a destructive track */
380 AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
382 int possibly_recording;
385 const int transport_rolling = 0x4;
386 const int track_rec_enabled = 0x2;
387 const int global_rec_enabled = 0x1;
389 /* merge together the 3 factors that affect record status, and compute
393 rolling = _session.transport_speed() != 0.0f;
394 possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
395 change = possibly_recording ^ last_possibly_recording;
397 if (possibly_recording == last_possibly_recording) {
403 /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
405 if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) ||
406 ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
408 /* starting to record: compute first+last frames */
410 first_recordable_frame = transport_frame + _capture_offset;
411 last_recordable_frame = max_frames;
412 capture_start_frame = transport_frame;
414 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
416 /* was stopped, now rolling (and recording) */
418 if (_alignment_style == ExistingMaterial) {
419 first_recordable_frame += _session.worst_output_latency();
421 first_recordable_frame += _roll_delay;
426 /* was rolling, but record state changed */
428 if (_alignment_style == ExistingMaterial) {
430 if (!Config->get_punch_in()) {
432 /* manual punch in happens at the correct transport frame
433 because the user hit a button. but to get alignment correct
434 we have to back up the position of the new region to the
435 appropriate spot given the roll delay.
438 capture_start_frame -= _roll_delay;
440 /* XXX paul notes (august 2005): i don't know why
444 first_recordable_frame += _capture_offset;
448 /* autopunch toggles recording at the precise
449 transport frame, and then the DS waits
450 to start recording for a time that depends
451 on the output latency.
454 first_recordable_frame += _session.worst_output_latency();
459 if (Config->get_punch_in()) {
460 first_recordable_frame += _roll_delay;
462 capture_start_frame -= _roll_delay;
468 if (recordable() && destructive()) {
469 boost::shared_ptr<ChannelList> c = channels.reader();
470 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
472 RingBufferNPT<CaptureTransition>::rw_vector transvec;
473 (*chan)->capture_transition_buf->get_write_vector(&transvec);
475 if (transvec.len[0] > 0) {
476 transvec.buf[0]->type = CaptureStart;
477 transvec.buf[0]->capture_val = capture_start_frame;
478 (*chan)->capture_transition_buf->increment_write_ptr(1);
482 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
488 } else if (!record_enabled() || !can_record) {
492 last_recordable_frame = transport_frame + _capture_offset;
494 if (_alignment_style == ExistingMaterial) {
495 last_recordable_frame += _session.worst_output_latency();
497 last_recordable_frame += _roll_delay;
501 last_possibly_recording = possibly_recording;
505 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, nframes_t offset, bool can_record, bool rec_monitors_input)
508 boost::shared_ptr<ChannelList> c = channels.reader();
509 ChannelList::iterator chan;
511 nframes_t rec_offset = 0;
512 nframes_t rec_nframes = 0;
513 bool nominally_recording;
514 bool re = record_enabled ();
515 bool collect_playback = false;
517 /* if we've already processed the frames corresponding to this call,
518 just return. this allows multiple routes that are taking input
519 from this diskstream to call our ::process() method, but have
520 this stuff only happen once. more commonly, it allows both
521 the AudioTrack that is using this AudioDiskstream *and* the Session
522 to call process() without problems.
529 commit_should_unlock = false;
531 check_record_status (transport_frame, nframes, can_record);
533 nominally_recording = (can_record && re);
540 /* This lock is held until the end of AudioDiskstream::commit, so these two functions
541 must always be called as a pair. The only exception is if this function
542 returns a non-zero value, in which case, ::commit should not be called.
545 // If we can't take the state lock return.
546 if (!state_lock.trylock()) {
549 commit_should_unlock = true;
550 adjust_capture_position = 0;
552 for (chan = c->begin(); chan != c->end(); ++chan) {
553 (*chan)->current_capture_buffer = 0;
554 (*chan)->current_playback_buffer = 0;
557 if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
560 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
567 case OverlapInternal:
568 /* ---------- recrange
571 rec_nframes = nframes;
576 /* |--------| recrange
579 rec_nframes = transport_frame + nframes - first_recordable_frame;
581 rec_offset = first_recordable_frame - transport_frame;
586 /* |--------| recrange
589 rec_nframes = last_recordable_frame - transport_frame;
593 case OverlapExternal:
594 /* |--------| recrange
595 -------------- transrange
597 rec_nframes = last_recordable_frame - first_recordable_frame;
598 rec_offset = first_recordable_frame - transport_frame;
602 if (rec_nframes && !was_recording) {
603 capture_captured = 0;
604 was_recording = true;
609 if (can_record && !_last_capture_regions.empty()) {
610 _last_capture_regions.clear ();
613 if (nominally_recording || rec_nframes) {
615 uint32_t limit = _io->n_inputs ().n_audio();
617 /* one or more ports could already have been removed from _io, but our
618 channel setup hasn't yet been updated. prevent us from trying to
619 use channels that correspond to missing ports. note that the
620 process callback (from which this is called) is always atomic
621 with respect to port removal/addition.
624 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
626 ChannelInfo* chaninfo (*chan);
628 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
630 if (rec_nframes <= chaninfo->capture_vector.len[0]) {
632 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
634 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
638 AudioPort* const ap = _io->audio_input(n);
640 assert(rec_nframes <= ap->get_audio_buffer().capacity());
641 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer().data(rec_nframes, offset + rec_offset), sizeof (Sample) * rec_nframes);
645 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
647 if (rec_nframes > total) {
652 AudioPort* const ap = _io->audio_input(n);
655 Sample* buf = ap->get_audio_buffer().data(nframes, offset);
656 nframes_t first = chaninfo->capture_vector.len[0];
658 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
659 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
660 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
661 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
663 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
670 finish_capture (rec_monitors_input, c);
677 /* data will be written to disk */
679 if (rec_nframes == nframes && rec_offset == 0) {
681 for (chan = c->begin(); chan != c->end(); ++chan) {
682 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
685 playback_distance = nframes;
690 /* we can't use the capture buffer as the playback buffer, because
691 we recorded only a part of the current process' cycle data
695 collect_playback = true;
698 adjust_capture_position = rec_nframes;
700 } else if (nominally_recording) {
702 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
704 for (chan = c->begin(); chan != c->end(); ++chan) {
705 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
708 playback_distance = nframes;
712 collect_playback = true;
715 if (collect_playback) {
717 /* we're doing playback */
719 nframes_t necessary_samples;
721 /* no varispeed playback if we're recording, because the output .... TBD */
723 if (rec_nframes == 0 && _actual_speed != 1.0f) {
724 necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
726 necessary_samples = nframes;
729 for (chan = c->begin(); chan != c->end(); ++chan) {
730 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
735 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
737 ChannelInfo* chaninfo (*chan);
739 if (necessary_samples <= chaninfo->playback_vector.len[0]) {
741 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
744 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
746 if (necessary_samples > total) {
752 memcpy ((char *) chaninfo->playback_wrap_buffer, chaninfo->playback_vector.buf[0],
753 chaninfo->playback_vector.len[0] * sizeof (Sample));
754 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0], chaninfo->playback_vector.buf[1],
755 (necessary_samples - chaninfo->playback_vector.len[0]) * sizeof (Sample));
757 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
762 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
764 uint64_t phase = last_phase;
767 // Linearly interpolate into the alt buffer
768 // using 40.24 fixp maths (swh)
770 for (chan = c->begin(); chan != c->end(); ++chan) {
773 ChannelInfo* chaninfo (*chan);
778 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
780 fr = (phase & 0xFFFFFF) / 16777216.0f;
781 chaninfo->speed_buffer[outsample] =
782 chaninfo->current_playback_buffer[i] * (1.0f - fr) +
783 chaninfo->current_playback_buffer[i+1] * fr;
787 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
790 playback_distance = i + 1;
791 last_phase = (phase & 0xFFFFFF);
794 playback_distance = nframes;
806 /* we're exiting with failure, so ::commit will not
807 be called. unlock the state lock.
810 commit_should_unlock = false;
818 AudioDiskstream::commit (nframes_t nframes)
820 bool need_butler = false;
822 if (_actual_speed < 0.0) {
823 playback_sample -= playback_distance;
825 playback_sample += playback_distance;
828 boost::shared_ptr<ChannelList> c = channels.reader();
829 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
831 (*chan)->playback_buf->increment_read_ptr (playback_distance);
833 if (adjust_capture_position) {
834 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
838 if (adjust_capture_position != 0) {
839 capture_captured += adjust_capture_position;
840 adjust_capture_position = 0;
844 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
846 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
847 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
850 if (commit_should_unlock) {
860 AudioDiskstream::set_pending_overwrite (bool yn)
862 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
864 pending_overwrite = yn;
866 overwrite_frame = playback_sample;
867 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
871 AudioDiskstream::overwrite_existing_buffers ()
873 boost::shared_ptr<ChannelList> c = channels.reader();
874 Sample* mixdown_buffer;
877 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
879 overwrite_queued = false;
881 /* assume all are the same size */
882 nframes_t size = c->front()->playback_buf->bufsize();
884 mixdown_buffer = new Sample[size];
885 gain_buffer = new float[size];
887 /* reduce size so that we can fill the buffer correctly. */
893 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
895 start = overwrite_frame;
896 nframes_t cnt = size;
898 /* to fill the buffer without resetting the playback sample, we need to
899 do it one or two chunks (normally two).
901 |----------------------------------------------------------------------|
905 |<- second chunk->||<----------------- first chunk ------------------>|
909 nframes_t to_read = size - overwrite_offset;
911 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
912 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
913 _id, size, playback_sample) << endmsg;
921 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
922 start, cnt, *chan, n, reversed)) {
923 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
924 _id, size, playback_sample) << endmsg;
933 pending_overwrite = false;
934 delete [] gain_buffer;
935 delete [] mixdown_buffer;
940 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
944 ChannelList::iterator chan;
945 boost::shared_ptr<ChannelList> c = channels.reader();
947 Glib::Mutex::Lock lm (state_lock);
949 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
950 (*chan)->playback_buf->reset ();
951 (*chan)->capture_buf->reset ();
954 /* can't rec-enable in destructive mode if transport is before start */
956 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
957 disengage_record_enable ();
960 playback_sample = frame;
963 if (complete_refill) {
964 while ((ret = do_refill_with_alloc ()) > 0) ;
966 ret = do_refill_with_alloc ();
973 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
975 ChannelList::iterator chan;
976 boost::shared_ptr<ChannelList> c = channels.reader();
978 for (chan = c->begin(); chan != c->end(); ++chan) {
979 if ((*chan)->playback_buf->read_space() < distance) {
987 AudioDiskstream::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 (*chan)->playback_buf->increment_read_ptr (distance);
996 first_recordable_frame += distance;
997 playback_sample += distance;
1003 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1004 ChannelInfo* channel_info, int channel, bool reversed)
1006 nframes_t this_read = 0;
1007 bool reloop = false;
1008 nframes_t loop_end = 0;
1009 nframes_t loop_start = 0;
1010 nframes_t loop_length = 0;
1011 nframes_t offset = 0;
1014 /* XXX we don't currently play loops in reverse. not sure why */
1018 /* Make the use of a Location atomic for this read operation.
1020 Note: Locations don't get deleted, so all we care about
1021 when I say "atomic" is that we are always pointing to
1022 the same one and using a start/length values obtained
1026 if ((loc = loop_location) != 0) {
1027 loop_start = loc->start();
1028 loop_end = loc->end();
1029 loop_length = loop_end - loop_start;
1032 /* if we are looping, ensure that the first frame we read is at the correct
1033 position within the loop.
1036 if (loc && start >= loop_end) {
1037 //cerr << "start adjusted from " << start;
1038 start = loop_start + ((start - loop_start) % loop_length);
1039 //cerr << "to " << start << endl;
1042 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1051 /* take any loop into account. we can't read past the end of the loop. */
1053 if (loc && (loop_end - start < cnt)) {
1054 this_read = loop_end - start;
1055 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1062 if (this_read == 0) {
1066 this_read = min(cnt,this_read);
1068 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1069 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1074 _read_data_count = _playlist->read_data_count();
1078 swap_by_ptr (buf, buf + this_read - 1);
1082 /* if we read to the end of the loop, go back to the beginning */
1092 offset += this_read;
1099 AudioDiskstream::do_refill_with_alloc ()
1101 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1102 float* gain_buf = new float[disk_io_chunk_frames];
1104 int ret = _do_refill(mix_buf, gain_buf);
1113 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1117 RingBufferNPT<Sample>::rw_vector vector;
1118 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1119 nframes_t total_space;
1120 nframes_t zero_fill;
1122 ChannelList::iterator i;
1123 boost::shared_ptr<ChannelList> c = channels.reader();
1130 assert(mixdown_buffer);
1131 assert(gain_buffer);
1138 c->front()->playback_buf->get_write_vector (&vector);
1140 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1144 /* if there are 2+ chunks of disk i/o possible for
1145 this track, let the caller know so that it can arrange
1146 for us to be called again, ASAP.
1149 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1153 /* if we're running close to normal speed and there isn't enough
1154 space to do disk_io_chunk_frames of I/O, then don't bother.
1156 at higher speeds, just do it because the sync between butler
1157 and audio thread may not be good enough.
1160 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1164 /* when slaved, don't try to get too close to the read pointer. this
1165 leaves space for the buffer reversal to have something useful to
1169 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1173 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1175 total_space = min (disk_io_chunk_frames, total_space);
1179 if (file_frame == 0) {
1181 /* at start: nothing to do but fill with silence */
1183 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1185 ChannelInfo* chan (*i);
1186 chan->playback_buf->get_write_vector (&vector);
1187 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1188 if (vector.len[1]) {
1189 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1191 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1196 if (file_frame < total_space) {
1198 /* too close to the start: read what we can,
1199 and then zero fill the rest
1202 zero_fill = total_space - file_frame;
1203 total_space = file_frame;
1213 if (file_frame == max_frames) {
1215 /* at end: nothing to do but fill with silence */
1217 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1219 ChannelInfo* chan (*i);
1220 chan->playback_buf->get_write_vector (&vector);
1221 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1222 if (vector.len[1]) {
1223 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1225 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1230 if (file_frame > max_frames - total_space) {
1232 /* to close to the end: read what we can, and zero fill the rest */
1234 zero_fill = total_space - (max_frames - file_frame);
1235 total_space = max_frames - file_frame;
1242 nframes_t file_frame_tmp = 0;
1244 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1246 ChannelInfo* chan (*i);
1249 nframes_t len1, len2;
1251 chan->playback_buf->get_write_vector (&vector);
1253 if (vector.len[0] > disk_io_chunk_frames) {
1255 /* we're not going to fill the first chunk, so certainly do not bother with the
1256 other part. it won't be connected with the part we do fill, as in:
1258 .... => writable space
1259 ++++ => readable space
1260 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1262 |......|+++++++++++++|...............................|
1267 So, just pretend that the buf1 part isn't there.
1277 file_frame_tmp = file_frame;
1279 buf1 = vector.buf[0];
1280 len1 = vector.len[0];
1281 buf2 = vector.buf[1];
1282 len2 = vector.len[1];
1284 to_read = min (ts, len1);
1285 to_read = min (to_read, disk_io_chunk_frames);
1289 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1294 chan->playback_buf->increment_write_ptr (to_read);
1298 to_read = min (ts, len2);
1302 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1303 so read some or all of vector.len[1] as well.
1306 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1311 chan->playback_buf->increment_write_ptr (to_read);
1320 file_frame = file_frame_tmp;
1327 /** Flush pending data to disk.
1329 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1330 * of data to disk. it will never write more than that. If it writes that
1331 * much and there is more than that waiting to be written, it will return 1,
1332 * otherwise 0 on success or -1 on failure.
1334 * If there is less than disk_io_chunk_frames to be written, no data will be
1335 * written at all unless @a force_flush is true.
1338 AudioDiskstream::do_flush (Session::RunContext context, bool force_flush)
1342 RingBufferNPT<Sample>::rw_vector vector;
1343 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1346 _write_data_count = 0;
1348 transvec.buf[0] = 0;
1349 transvec.buf[1] = 0;
1353 boost::shared_ptr<ChannelList> c = channels.reader();
1354 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1356 (*chan)->capture_buf->get_read_vector (&vector);
1358 total = vector.len[0] + vector.len[1];
1360 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1364 /* if there are 2+ chunks of disk i/o possible for
1365 this track, let the caller know so that it can arrange
1366 for us to be called again, ASAP.
1368 if we are forcing a flush, then if there is* any* extra
1369 work, let the caller know.
1371 if we are no longer recording and there is any extra work,
1372 let the caller know too.
1375 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1379 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1381 // check the transition buffer when recording destructive
1382 // important that we get this after the capture buf
1384 if (destructive()) {
1385 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1386 size_t transcount = transvec.len[0] + transvec.len[1];
1387 bool have_start = false;
1390 for (ti=0; ti < transcount; ++ti) {
1391 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1393 if (captrans.type == CaptureStart) {
1394 // by definition, the first data we got above represents the given capture pos
1396 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1397 (*chan)->curr_capture_cnt = 0;
1401 else if (captrans.type == CaptureEnd) {
1403 // capture end, the capture_val represents total frames in capture
1405 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1407 // shorten to make the write a perfect fit
1408 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1410 if (nto_write < to_write) {
1411 ret = 1; // should we?
1413 to_write = nto_write;
1415 (*chan)->write_source->mark_capture_end ();
1417 // increment past this transition, but go no further
1422 // actually ends just beyond this chunk, so force more work
1430 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1434 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1435 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1439 (*chan)->capture_buf->increment_read_ptr (to_write);
1440 (*chan)->curr_capture_cnt += to_write;
1442 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1444 /* we wrote all of vector.len[0] but it wasn't an entire
1445 disk_io_chunk_frames of data, so arrange for some part
1446 of vector.len[1] to be flushed to disk as well.
1449 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1451 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1452 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1456 _write_data_count += (*chan)->write_source->write_data_count();
1458 (*chan)->capture_buf->increment_read_ptr (to_write);
1459 (*chan)->curr_capture_cnt += to_write;
1468 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1470 uint32_t buffer_position;
1471 bool more_work = true;
1473 boost::shared_ptr<AudioRegion> region;
1474 nframes_t total_capture;
1476 SourceList::iterator src;
1477 ChannelList::iterator chan;
1478 vector<CaptureInfo*>::iterator ci;
1479 boost::shared_ptr<ChannelList> c = channels.reader();
1481 bool mark_write_completed = false;
1483 finish_capture (true, c);
1485 /* butler is already stopped, but there may be work to do
1486 to flush remaining data to disk.
1489 while (more_work && !err) {
1490 switch (do_flush (Session::TransportContext, true)) {
1497 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1502 /* XXX is there anything we can do if err != 0 ? */
1503 Glib::Mutex::Lock lm (capture_info_lock);
1505 if (capture_info.empty()) {
1509 if (abort_capture) {
1511 if (destructive()) {
1515 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1517 if ((*chan)->write_source) {
1519 (*chan)->write_source->mark_for_remove ();
1520 (*chan)->write_source->drop_references ();
1521 (*chan)->write_source.reset ();
1524 /* new source set up in "out" below */
1530 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1531 total_capture += (*ci)->frames;
1534 /* figure out the name for this take */
1536 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1538 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1542 s->update_header (capture_info.front()->start, when, twhen);
1543 s->set_captured_for (_name);
1544 s->mark_immutable ();
1548 /* destructive tracks have a single, never changing region */
1550 if (destructive()) {
1552 /* send a signal that any UI can pick up to do the right thing. there is
1553 a small problem here in that a UI may need the peak data to be ready
1554 for the data that was recorded and this isn't interlocked with that
1555 process. this problem is deferred to the UI.
1558 _playlist->Modified();
1562 string whole_file_region_name;
1563 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1565 /* Register a new region with the Session that
1566 describes the entire source. Do this first
1567 so that any sub-regions will obviously be
1568 children of this one (later!)
1572 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, c->front()->write_source->last_capture_start_frame(), total_capture,
1573 whole_file_region_name,
1574 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
1576 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1577 region->special_set_position (capture_info.front()->start);
1581 catch (failed_constructor& err) {
1582 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1586 _last_capture_regions.push_back (region);
1588 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1590 XMLNode &before = _playlist->get_state();
1591 _playlist->freeze ();
1593 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1597 _session.region_name (region_name, whole_file_region_name, false);
1599 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1602 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1603 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1606 catch (failed_constructor& err) {
1607 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1608 continue; /* XXX is this OK? */
1611 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1613 _last_capture_regions.push_back (region);
1615 i_am_the_modifier++;
1616 _playlist->add_region (region, (*ci)->start);
1617 i_am_the_modifier--;
1619 buffer_position += (*ci)->frames;
1623 XMLNode &after = _playlist->get_state();
1624 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1627 mark_write_completed = true;
1630 reset_write_sources (mark_write_completed);
1634 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1638 capture_info.clear ();
1639 capture_start_frame = 0;
1643 AudioDiskstream::transport_looped (nframes_t transport_frame)
1645 if (was_recording) {
1646 // all we need to do is finish this capture, with modified capture length
1647 boost::shared_ptr<ChannelList> c = channels.reader();
1649 // adjust the capture length knowing that the data will be recorded to disk
1650 // only necessary after the first loop where we're recording
1651 if (capture_info.size() == 0) {
1652 capture_captured += _capture_offset;
1654 if (_alignment_style == ExistingMaterial) {
1655 capture_captured += _session.worst_output_latency();
1657 capture_captured += _roll_delay;
1661 finish_capture (true, c);
1663 // the next region will start recording via the normal mechanism
1664 // we'll set the start position to the current transport pos
1665 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1666 capture_start_frame = transport_frame;
1667 first_recordable_frame = transport_frame; // mild lie
1668 last_recordable_frame = max_frames;
1669 was_recording = true;
1671 if (recordable() && destructive()) {
1672 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1674 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1675 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1677 if (transvec.len[0] > 0) {
1678 transvec.buf[0]->type = CaptureStart;
1679 transvec.buf[0]->capture_val = capture_start_frame;
1680 (*chan)->capture_transition_buf->increment_write_ptr(1);
1684 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1694 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1696 was_recording = false;
1698 if (capture_captured == 0) {
1702 if (recordable() && destructive()) {
1703 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1705 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1706 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1708 if (transvec.len[0] > 0) {
1709 transvec.buf[0]->type = CaptureEnd;
1710 transvec.buf[0]->capture_val = capture_captured;
1711 (*chan)->capture_transition_buf->increment_write_ptr(1);
1715 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1721 CaptureInfo* ci = new CaptureInfo;
1723 ci->start = capture_start_frame;
1724 ci->frames = capture_captured;
1726 /* XXX theoretical race condition here. Need atomic exchange ?
1727 However, the circumstances when this is called right
1728 now (either on record-disable or transport_stopped)
1729 mean that no actual race exists. I think ...
1730 We now have a capture_info_lock, but it is only to be used
1731 to synchronize in the transport_stop and the capture info
1732 accessors, so that invalidation will not occur (both non-realtime).
1735 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1737 capture_info.push_back (ci);
1738 capture_captured = 0;
1742 AudioDiskstream::set_record_enabled (bool yn)
1744 if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs().n_audio() == 0) {
1748 /* can't rec-enable in destructive mode if transport is before start */
1750 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1754 if (yn && channels.reader()->front()->source == 0) {
1756 /* pick up connections not initiated *from* the IO object
1757 we're associated with.
1760 get_input_sources ();
1763 /* yes, i know that this not proof against race conditions, but its
1764 good enough. i think.
1767 if (record_enabled() != yn) {
1769 engage_record_enable ();
1771 disengage_record_enable ();
1777 AudioDiskstream::engage_record_enable ()
1779 bool rolling = _session.transport_speed() != 0.0f;
1780 boost::shared_ptr<ChannelList> c = channels.reader();
1782 g_atomic_int_set (&_record_enabled, 1);
1783 capturing_sources.clear ();
1785 if (Config->get_monitoring_model() == HardwareMonitoring) {
1787 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1788 if ((*chan)->source) {
1789 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1791 capturing_sources.push_back ((*chan)->write_source);
1795 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1796 capturing_sources.push_back ((*chan)->write_source);
1800 RecordEnableChanged (); /* EMIT SIGNAL */
1804 AudioDiskstream::disengage_record_enable ()
1806 g_atomic_int_set (&_record_enabled, 0);
1807 boost::shared_ptr<ChannelList> c = channels.reader();
1808 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1809 if (Config->get_monitoring_model() == HardwareMonitoring) {
1810 if ((*chan)->source) {
1811 (*chan)->source->ensure_monitor_input (false);
1815 capturing_sources.clear ();
1816 RecordEnableChanged (); /* EMIT SIGNAL */
1820 AudioDiskstream::get_state ()
1822 XMLNode* node = new XMLNode ("AudioDiskstream");
1824 LocaleGuard lg (X_("POSIX"));
1825 boost::shared_ptr<ChannelList> c = channels.reader();
1827 node->add_property ("flags", enum_2_string (_flags));
1829 snprintf (buf, sizeof(buf), "%zd", c->size());
1830 node->add_property ("channels", buf);
1832 node->add_property ("playlist", _playlist->name());
1834 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1835 node->add_property ("speed", buf);
1837 node->add_property("name", _name);
1838 id().print (buf, sizeof (buf));
1839 node->add_property("id", buf);
1841 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1843 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1844 XMLNode* cs_grandchild;
1846 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1847 cs_grandchild = new XMLNode (X_("file"));
1848 cs_grandchild->add_property (X_("path"), (*i)->path());
1849 cs_child->add_child_nocopy (*cs_grandchild);
1852 /* store the location where capture will start */
1856 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1857 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1859 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1862 cs_child->add_property (X_("at"), buf);
1863 node->add_child_nocopy (*cs_child);
1867 node->add_child_copy (*_extra_xml);
1874 AudioDiskstream::set_state (const XMLNode& node)
1876 const XMLProperty* prop;
1877 XMLNodeList nlist = node.children();
1878 XMLNodeIterator niter;
1879 uint32_t nchans = 1;
1880 XMLNode* capture_pending_node = 0;
1881 LocaleGuard lg (X_("POSIX"));
1883 in_set_state = true;
1885 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1886 if ((*niter)->name() == IO::state_node_name) {
1887 deprecated_io_node = new XMLNode (**niter);
1890 if ((*niter)->name() == X_("CapturingSources")) {
1891 capture_pending_node = *niter;
1895 /* prevent write sources from being created */
1897 in_set_state = true;
1899 if ((prop = node.property ("name")) != 0) {
1900 _name = prop->value();
1903 if (deprecated_io_node) {
1904 if ((prop = deprecated_io_node->property ("id")) != 0) {
1905 _id = prop->value ();
1908 if ((prop = node.property ("id")) != 0) {
1909 _id = prop->value ();
1913 if ((prop = node.property ("flags")) != 0) {
1914 _flags = Flag (string_2_enum (prop->value(), _flags));
1917 if ((prop = node.property ("channels")) != 0) {
1918 nchans = atoi (prop->value().c_str());
1921 // create necessary extra channels
1922 // we are always constructed with one and we always need one
1924 _n_channels.set(DataType::AUDIO, channels.reader()->size());
1926 if (nchans > _n_channels.n_audio()) {
1928 add_channel (nchans - _n_channels.n_audio());
1930 } else if (nchans < _n_channels.n_audio()) {
1932 remove_channel (_n_channels.n_audio() - nchans);
1935 if ((prop = node.property ("playlist")) == 0) {
1940 bool had_playlist = (_playlist != 0);
1942 if (find_and_use_playlist (prop->value())) {
1946 if (!had_playlist) {
1947 _playlist->set_orig_diskstream_id (_id);
1950 if (!destructive() && capture_pending_node) {
1951 /* destructive streams have one and only one source per channel,
1952 and so they never end up in pending capture in any useful
1955 use_pending_capture_data (*capture_pending_node);
1960 if ((prop = node.property ("speed")) != 0) {
1961 double sp = atof (prop->value().c_str());
1963 if (realtime_set_speed (sp, false)) {
1964 non_realtime_set_speed ();
1968 in_set_state = false;
1970 /* make sure this is clear before we do anything else */
1972 capturing_sources.clear ();
1974 /* write sources are handled when we handle the input set
1975 up of the IO that owns this DS (::non_realtime_input_change())
1978 in_set_state = false;
1984 AudioDiskstream::use_new_write_source (uint32_t n)
1986 boost::shared_ptr<ChannelList> c = channels.reader();
1988 if (!recordable()) {
1992 if (n >= c->size()) {
1993 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1997 ChannelInfo* chan = (*c)[n];
1999 if (chan->write_source) {
2000 chan->write_source->done_with_peakfile_writes ();
2001 chan->write_source->set_allow_remove_if_empty (true);
2002 chan->write_source.reset ();
2006 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2007 throw failed_constructor();
2011 catch (failed_constructor &err) {
2012 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2013 chan->write_source.reset ();
2017 /* do not remove destructive files even if they are empty */
2019 chan->write_source->set_allow_remove_if_empty (!destructive());
2025 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2027 ChannelList::iterator chan;
2028 boost::shared_ptr<ChannelList> c = channels.reader();
2031 if (!recordable()) {
2035 capturing_sources.clear ();
2037 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2038 if (!destructive()) {
2040 if ((*chan)->write_source && mark_write_complete) {
2041 (*chan)->write_source->mark_streaming_write_completed ();
2043 use_new_write_source (n);
2045 if (record_enabled()) {
2046 capturing_sources.push_back ((*chan)->write_source);
2050 if ((*chan)->write_source == 0) {
2051 use_new_write_source (n);
2056 if (destructive()) {
2058 /* we now have all our write sources set up, so create the
2059 playlist's single region.
2062 if (_playlist->empty()) {
2063 setup_destructive_playlist ();
2069 AudioDiskstream::rename_write_sources ()
2071 ChannelList::iterator chan;
2072 boost::shared_ptr<ChannelList> c = channels.reader();
2075 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2076 if ((*chan)->write_source != 0) {
2077 (*chan)->write_source->set_source_name (_name, destructive());
2078 /* XXX what to do if one of them fails ? */
2086 AudioDiskstream::set_block_size (nframes_t nframes)
2088 if (_session.get_block_size() > speed_buffer_size) {
2089 speed_buffer_size = _session.get_block_size();
2090 boost::shared_ptr<ChannelList> c = channels.reader();
2092 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2093 if ((*chan)->speed_buffer) delete [] (*chan)->speed_buffer;
2094 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2097 allocate_temporary_buffers ();
2101 AudioDiskstream::allocate_temporary_buffers ()
2103 /* make sure the wrap buffer is at least large enough to deal
2104 with the speeds up to 1.2, to allow for micro-variation
2105 when slaving to MTC, SMPTE etc.
2108 double sp = max (fabsf (_actual_speed), 1.2f);
2109 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2111 if (required_wrap_size > wrap_buffer_size) {
2113 boost::shared_ptr<ChannelList> c = channels.reader();
2115 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2116 if ((*chan)->playback_wrap_buffer) delete [] (*chan)->playback_wrap_buffer;
2117 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2118 if ((*chan)->capture_wrap_buffer) delete [] (*chan)->capture_wrap_buffer;
2119 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2122 wrap_buffer_size = required_wrap_size;
2127 AudioDiskstream::monitor_input (bool yn)
2129 boost::shared_ptr<ChannelList> c = channels.reader();
2131 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2133 if ((*chan)->source) {
2134 (*chan)->source->ensure_monitor_input (yn);
2140 AudioDiskstream::set_align_style_from_io ()
2142 bool have_physical = false;
2148 get_input_sources ();
2150 boost::shared_ptr<ChannelList> c = channels.reader();
2152 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2153 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2154 have_physical = true;
2159 if (have_physical) {
2160 set_align_style (ExistingMaterial);
2162 set_align_style (CaptureTime);
2167 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2169 while (how_many--) {
2170 c->push_back (new ChannelInfo(_session.diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2173 _n_channels.set(DataType::AUDIO, c->size());
2179 AudioDiskstream::add_channel (uint32_t how_many)
2181 RCUWriter<ChannelList> writer (channels);
2182 boost::shared_ptr<ChannelList> c = writer.get_copy();
2184 return add_channel_to (c, how_many);
2188 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2190 while (--how_many && !c->empty()) {
2195 _n_channels.set(DataType::AUDIO, c->size());
2201 AudioDiskstream::remove_channel (uint32_t how_many)
2203 RCUWriter<ChannelList> writer (channels);
2204 boost::shared_ptr<ChannelList> c = writer.get_copy();
2206 return remove_channel_from (c, how_many);
2210 AudioDiskstream::playback_buffer_load () const
2212 boost::shared_ptr<ChannelList> c = channels.reader();
2214 return (float) ((double) c->front()->playback_buf->read_space()/
2215 (double) c->front()->playback_buf->bufsize());
2219 AudioDiskstream::capture_buffer_load () const
2221 boost::shared_ptr<ChannelList> c = channels.reader();
2223 return (float) ((double) c->front()->capture_buf->write_space()/
2224 (double) c->front()->capture_buf->bufsize());
2228 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2230 const XMLProperty* prop;
2231 XMLNodeList nlist = node.children();
2232 XMLNodeIterator niter;
2233 boost::shared_ptr<AudioFileSource> fs;
2234 boost::shared_ptr<AudioFileSource> first_fs;
2235 SourceList pending_sources;
2238 if ((prop = node.property (X_("at"))) == 0) {
2242 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2246 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2247 if ((*niter)->name() == X_("file")) {
2249 if ((prop = (*niter)->property (X_("path"))) == 0) {
2254 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2255 SourceFactory::createWritable (DataType::AUDIO, _session, prop->value(), false, _session.frame_rate()));
2258 catch (failed_constructor& err) {
2259 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2260 _name, prop->value())
2265 pending_sources.push_back (fs);
2267 if (first_fs == 0) {
2271 fs->set_captured_for (_name);
2275 if (pending_sources.size() == 0) {
2276 /* nothing can be done */
2280 if (pending_sources.size() != _n_channels.n_audio()) {
2281 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2286 boost::shared_ptr<AudioRegion> region;
2289 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
2290 region_name_from_path (first_fs->name(), true),
2291 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
2292 region->special_set_position (0);
2295 catch (failed_constructor& err) {
2296 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2304 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
2307 catch (failed_constructor& err) {
2308 error << string_compose (_("%1: cannot create region from pending capture sources"),
2315 _playlist->add_region (region, position);
2321 AudioDiskstream::set_destructive (bool yn)
2323 bool bounce_ignored;
2325 if (yn != destructive()) {
2328 /* requestor should already have checked this and
2329 bounced if necessary and desired
2331 if (!can_become_destructive (bounce_ignored)) {
2334 _flags = Flag (_flags | Destructive);
2335 use_destructive_playlist ();
2337 _flags = Flag (_flags & ~Destructive);
2338 reset_write_sources (true, true);
2346 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2349 requires_bounce = false;
2353 /* is there only one region ? */
2355 if (_playlist->n_regions() != 1) {
2356 requires_bounce = true;
2360 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2363 /* do the source(s) for the region cover the session start position ? */
2365 if (first->position() != _session.current_start_frame()) {
2366 if (first->start() > _session.current_start_frame()) {
2367 requires_bounce = true;
2372 /* is the source used by only 1 playlist ? */
2374 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2378 if (afirst->source()->used() > 1) {
2379 requires_bounce = true;
2383 requires_bounce = false;
2387 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2391 current_capture_buffer = 0;
2392 current_playback_buffer = 0;
2393 curr_capture_cnt = 0;
2395 speed_buffer = new Sample[speed_size];
2396 playback_wrap_buffer = new Sample[wrap_size];
2397 capture_wrap_buffer = new Sample[wrap_size];
2399 playback_buf = new RingBufferNPT<Sample> (bufsize);
2400 capture_buf = new RingBufferNPT<Sample> (bufsize);
2401 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2403 /* touch the ringbuffer buffers, which will cause
2404 them to be mapped into locked physical RAM if
2405 we're running with mlockall(). this doesn't do
2409 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2410 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2411 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2414 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2417 write_source.reset ();
2421 delete [] speed_buffer;
2425 if (playback_wrap_buffer) {
2426 delete [] playback_wrap_buffer;
2427 playback_wrap_buffer = 0;
2430 if (capture_wrap_buffer) {
2431 delete [] capture_wrap_buffer;
2432 capture_wrap_buffer = 0;
2436 delete playback_buf;
2445 if (capture_transition_buf) {
2446 delete capture_transition_buf;
2447 capture_transition_buf = 0;