2 Copyright (C) 2000-2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 #include "pbd/error.h"
34 #include <glibmm/thread.h>
35 #include "pbd/xml++.h"
36 #include "pbd/memento_command.h"
37 #include "pbd/enumwriter.h"
38 #include "pbd/stacktrace.h"
40 #include "ardour/ardour.h"
41 #include "ardour/audioengine.h"
42 #include "ardour/analyser.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"
55 #include "ardour/audio_buffer.h"
56 #include "ardour/session.h"
57 #include "ardour/io.h"
63 using namespace ARDOUR;
66 size_t AudioDiskstream::_working_buffers_size = 0;
67 Sample* AudioDiskstream::_mixdown_buffer = 0;
68 gain_t* AudioDiskstream::_gain_buffer = 0;
70 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
71 : Diskstream(sess, name, flag)
72 , deprecated_io_node(NULL)
73 , channels (new ChannelList)
75 /* prevent any write sources from being created */
85 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
86 : Diskstream(sess, node)
87 , deprecated_io_node(NULL)
88 , channels (new ChannelList)
93 if (set_state (node)) {
95 throw failed_constructor();
101 use_destructive_playlist ();
106 AudioDiskstream::init (Diskstream::Flag f)
110 /* there are no channels at this point, so these
111 two calls just get speed_buffer_size and wrap_buffer
112 size setup without duplicating their code.
115 set_block_size (_session.get_block_size());
116 allocate_temporary_buffers ();
119 assert(_n_channels == ChanCount(DataType::AUDIO, 1));
122 AudioDiskstream::~AudioDiskstream ()
127 RCUWriter<ChannelList> writer (channels);
128 boost::shared_ptr<ChannelList> c = writer.get_copy();
130 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
141 AudioDiskstream::allocate_working_buffers()
143 assert(disk_io_frames() > 0);
145 _working_buffers_size = disk_io_frames();
146 _mixdown_buffer = new Sample[_working_buffers_size];
147 _gain_buffer = new gain_t[_working_buffers_size];
151 AudioDiskstream::free_working_buffers()
153 delete [] _mixdown_buffer;
154 delete [] _gain_buffer;
155 _working_buffers_size = 0;
161 AudioDiskstream::non_realtime_input_change ()
164 Glib::Mutex::Lock lm (state_lock);
166 if (input_change_pending == NoChange) {
171 RCUWriter<ChannelList> writer (channels);
172 boost::shared_ptr<ChannelList> c = writer.get_copy();
174 _n_channels.set(DataType::AUDIO, c->size());
176 if (_io->n_inputs().n_audio() > _n_channels.n_audio()) {
177 add_channel_to (c, _io->n_inputs().n_audio() - _n_channels.n_audio());
178 } else if (_io->n_inputs().n_audio() < _n_channels.n_audio()) {
179 remove_channel_from (c, _n_channels.n_audio() - _io->n_inputs().n_audio());
183 get_input_sources ();
184 set_capture_offset ();
186 if (first_input_change) {
187 set_align_style (_persistent_alignment_style);
188 first_input_change = false;
190 set_align_style_from_io ();
193 input_change_pending = NoChange;
195 /* implicit unlock */
198 /* reset capture files */
200 reset_write_sources (false);
202 /* now refill channel buffers */
204 if (speed() != 1.0f || speed() != -1.0f) {
205 seek ((nframes_t) (_session.transport_frame() * (double) speed()));
207 seek (_session.transport_frame());
212 AudioDiskstream::non_realtime_locate (nframes_t location)
214 /* now refill channel buffers */
216 if (speed() != 1.0f || speed() != -1.0f) {
217 seek ((nframes_t) (location * (double) speed()));
224 AudioDiskstream::get_input_sources ()
226 boost::shared_ptr<ChannelList> c = channels.reader();
229 ChannelList::iterator chan;
230 uint32_t ni = _io->n_inputs().n_audio();
231 vector<string> connections;
233 for (n = 0, chan = c->begin(); chan != c->end() && n < ni; ++chan, ++n) {
235 connections.clear ();
237 if (_io->input(n)->get_connections (connections) == 0) {
239 if ((*chan)->source) {
240 // _source->disable_metering ();
246 (*chan)->source = dynamic_cast<AudioPort*>(_session.engine().get_port_by_name (connections[0]) );
252 AudioDiskstream::find_and_use_playlist (const string& name)
254 boost::shared_ptr<AudioPlaylist> playlist;
256 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (_session.playlist_by_name (name))) == 0) {
257 playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, name));
261 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
265 return use_playlist (playlist);
269 AudioDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
271 assert(boost::dynamic_pointer_cast<AudioPlaylist>(playlist));
273 Diskstream::use_playlist(playlist);
279 AudioDiskstream::use_new_playlist ()
282 boost::shared_ptr<AudioPlaylist> playlist;
284 if (!in_set_state && destructive()) {
289 newname = Playlist::bump_name (_playlist->name(), _session);
291 newname = Playlist::bump_name (_name, _session);
294 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist> (PlaylistFactory::create (DataType::AUDIO, _session, newname, hidden()))) != 0) {
296 playlist->set_orig_diskstream_id (id());
297 return use_playlist (playlist);
305 AudioDiskstream::use_copy_playlist ()
307 assert(audio_playlist());
313 if (_playlist == 0) {
314 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
319 boost::shared_ptr<AudioPlaylist> playlist;
321 newname = Playlist::bump_name (_playlist->name(), _session);
323 if ((playlist = boost::dynamic_pointer_cast<AudioPlaylist>(PlaylistFactory::create (audio_playlist(), newname))) != 0) {
324 playlist->set_orig_diskstream_id (id());
325 return use_playlist (playlist);
332 AudioDiskstream::setup_destructive_playlist ()
335 boost::shared_ptr<ChannelList> c = channels.reader();
337 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
338 srcs.push_back ((*chan)->write_source);
341 /* a single full-sized region */
343 boost::shared_ptr<Region> region (RegionFactory::create (srcs, 0, max_frames - srcs.front()->natural_position(), _name));
344 _playlist->add_region (region, srcs.front()->natural_position());
348 AudioDiskstream::use_destructive_playlist ()
350 /* this is called from the XML-based constructor or ::set_destructive. when called,
351 we already have a playlist and a region, but we need to
352 set up our sources for write. we use the sources associated
353 with the (presumed single, full-extent) region.
356 boost::shared_ptr<Region> rp = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
359 reset_write_sources (false, true);
363 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
366 throw failed_constructor();
369 /* be sure to stretch the region out to the maximum length */
371 region->set_length (max_frames - region->position(), this);
374 ChannelList::iterator chan;
375 boost::shared_ptr<ChannelList> c = channels.reader();
377 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
378 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
379 assert((*chan)->write_source);
380 (*chan)->write_source->set_allow_remove_if_empty (false);
382 /* this might be false if we switched modes, so force it */
384 (*chan)->write_source->set_destructive (true);
387 /* the source list will never be reset for a destructive track */
391 AudioDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
393 int possibly_recording;
396 const int transport_rolling = 0x4;
397 const int track_rec_enabled = 0x2;
398 const int global_rec_enabled = 0x1;
400 /* merge together the 3 factors that affect record status, and compute
404 rolling = _session.transport_speed() != 0.0f;
405 possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
406 change = possibly_recording ^ last_possibly_recording;
408 if (possibly_recording == last_possibly_recording) {
414 /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
416 if (((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record)) ||
417 ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
419 /* starting to record: compute first+last frames */
421 first_recordable_frame = transport_frame + _capture_offset;
422 last_recordable_frame = max_frames;
423 capture_start_frame = transport_frame;
425 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
427 /* was stopped, now rolling (and recording) */
429 if (_alignment_style == ExistingMaterial) {
430 first_recordable_frame += _session.worst_output_latency();
432 first_recordable_frame += _roll_delay;
437 /* was rolling, but record state changed */
439 if (_alignment_style == ExistingMaterial) {
441 if (!Config->get_punch_in()) {
443 /* manual punch in happens at the correct transport frame
444 because the user hit a button. but to get alignment correct
445 we have to back up the position of the new region to the
446 appropriate spot given the roll delay.
449 capture_start_frame -= _roll_delay;
451 /* XXX paul notes (august 2005): i don't know why
455 first_recordable_frame += _capture_offset;
459 /* autopunch toggles recording at the precise
460 transport frame, and then the DS waits
461 to start recording for a time that depends
462 on the output latency.
465 first_recordable_frame += _session.worst_output_latency();
470 if (Config->get_punch_in()) {
471 first_recordable_frame += _roll_delay;
473 capture_start_frame -= _roll_delay;
479 if (recordable() && destructive()) {
480 boost::shared_ptr<ChannelList> c = channels.reader();
481 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
483 RingBufferNPT<CaptureTransition>::rw_vector transvec;
484 (*chan)->capture_transition_buf->get_write_vector(&transvec);
486 if (transvec.len[0] > 0) {
487 transvec.buf[0]->type = CaptureStart;
488 transvec.buf[0]->capture_val = capture_start_frame;
489 (*chan)->capture_transition_buf->increment_write_ptr(1);
493 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
499 } else if (!record_enabled() || !can_record) {
503 last_recordable_frame = transport_frame + _capture_offset;
505 if (_alignment_style == ExistingMaterial) {
506 last_recordable_frame += _session.worst_output_latency();
508 last_recordable_frame += _roll_delay;
512 last_possibly_recording = possibly_recording;
516 AudioDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
519 boost::shared_ptr<ChannelList> c = channels.reader();
520 ChannelList::iterator chan;
522 nframes_t rec_offset = 0;
523 nframes_t rec_nframes = 0;
524 bool nominally_recording;
525 bool re = record_enabled ();
526 bool collect_playback = false;
528 /* if we've already processed the frames corresponding to this call,
529 just return. this allows multiple routes that are taking input
530 from this diskstream to call our ::process() method, but have
531 this stuff only happen once. more commonly, it allows both
532 the AudioTrack that is using this AudioDiskstream *and* the Session
533 to call process() without problems.
540 commit_should_unlock = false;
542 if (!_io || !_io->active()) {
547 check_record_status (transport_frame, nframes, can_record);
549 nominally_recording = (can_record && re);
556 /* This lock is held until the end of AudioDiskstream::commit, so these two functions
557 must always be called as a pair. The only exception is if this function
558 returns a non-zero value, in which case, ::commit should not be called.
561 // If we can't take the state lock return.
562 if (!state_lock.trylock()) {
565 commit_should_unlock = true;
566 adjust_capture_position = 0;
568 for (chan = c->begin(); chan != c->end(); ++chan) {
569 (*chan)->current_capture_buffer = 0;
570 (*chan)->current_playback_buffer = 0;
573 if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
576 // Safeguard against situations where process() goes haywire when autopunching and last_recordable_frame < first_recordable_frame
577 if (last_recordable_frame < first_recordable_frame) {
578 last_recordable_frame = max_frames;
581 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
588 case OverlapInternal:
589 /* ---------- recrange
592 rec_nframes = nframes;
597 /* |--------| recrange
600 rec_nframes = transport_frame + nframes - first_recordable_frame;
602 rec_offset = first_recordable_frame - transport_frame;
607 /* |--------| recrange
610 rec_nframes = last_recordable_frame - transport_frame;
614 case OverlapExternal:
615 /* |--------| recrange
616 -------------- transrange
618 rec_nframes = last_recordable_frame - first_recordable_frame;
619 rec_offset = first_recordable_frame - transport_frame;
623 if (rec_nframes && !was_recording) {
624 capture_captured = 0;
625 was_recording = true;
630 if (can_record && !_last_capture_regions.empty()) {
631 _last_capture_regions.clear ();
634 if (nominally_recording || rec_nframes) {
636 uint32_t limit = _io->n_inputs ().n_audio();
638 /* one or more ports could already have been removed from _io, but our
639 channel setup hasn't yet been updated. prevent us from trying to
640 use channels that correspond to missing ports. note that the
641 process callback (from which this is called) is always atomic
642 with respect to port removal/addition.
645 for (n = 0, chan = c->begin(); chan != c->end() && n < limit; ++chan, ++n) {
647 ChannelInfo* chaninfo (*chan);
649 chaninfo->capture_buf->get_write_vector (&chaninfo->capture_vector);
651 if (rec_nframes <= chaninfo->capture_vector.len[0]) {
653 chaninfo->current_capture_buffer = chaninfo->capture_vector.buf[0];
655 /* note: grab the entire port buffer, but only copy what we were supposed to
656 for recording, and use rec_offset
659 AudioPort* const ap = _io->audio_input(n);
661 assert(rec_nframes <= ap->get_audio_buffer(nframes).capacity());
662 memcpy (chaninfo->current_capture_buffer, ap->get_audio_buffer (rec_nframes).data(rec_offset), sizeof (Sample) * rec_nframes);
667 nframes_t total = chaninfo->capture_vector.len[0] + chaninfo->capture_vector.len[1];
669 if (rec_nframes > total) {
674 AudioPort* const ap = _io->audio_input(n);
677 Sample* buf = ap->get_audio_buffer(nframes).data();
678 nframes_t first = chaninfo->capture_vector.len[0];
680 memcpy (chaninfo->capture_wrap_buffer, buf, sizeof (Sample) * first);
681 memcpy (chaninfo->capture_vector.buf[0], buf, sizeof (Sample) * first);
682 memcpy (chaninfo->capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
683 memcpy (chaninfo->capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
685 chaninfo->current_capture_buffer = chaninfo->capture_wrap_buffer;
692 finish_capture (rec_monitors_input, c);
699 /* data will be written to disk */
701 if (rec_nframes == nframes && rec_offset == 0) {
703 for (chan = c->begin(); chan != c->end(); ++chan) {
704 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
707 playback_distance = nframes;
712 /* we can't use the capture buffer as the playback buffer, because
713 we recorded only a part of the current process' cycle data
717 collect_playback = true;
720 adjust_capture_position = rec_nframes;
722 } else if (nominally_recording) {
724 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
726 for (chan = c->begin(); chan != c->end(); ++chan) {
727 (*chan)->current_playback_buffer = (*chan)->current_capture_buffer;
730 playback_distance = nframes;
734 collect_playback = true;
737 if (collect_playback) {
739 /* we're doing playback */
741 nframes_t necessary_samples;
743 /* no varispeed playback if we're recording, because the output .... TBD */
745 if (rec_nframes == 0 && _actual_speed != 1.0f) {
746 necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
748 necessary_samples = nframes;
751 for (chan = c->begin(); chan != c->end(); ++chan) {
752 (*chan)->playback_buf->get_read_vector (&(*chan)->playback_vector);
757 for (chan = c->begin(); chan != c->end(); ++chan, ++n) {
759 ChannelInfo* chaninfo (*chan);
761 if (necessary_samples <= chaninfo->playback_vector.len[0]) {
763 chaninfo->current_playback_buffer = chaninfo->playback_vector.buf[0];
766 nframes_t total = chaninfo->playback_vector.len[0] + chaninfo->playback_vector.len[1];
768 if (necessary_samples > total) {
769 cerr << "underrun for " << _name << endl;
775 memcpy ((char *) chaninfo->playback_wrap_buffer,
776 chaninfo->playback_vector.buf[0],
777 chaninfo->playback_vector.len[0] * sizeof (Sample));
778 memcpy (chaninfo->playback_wrap_buffer + chaninfo->playback_vector.len[0],
779 chaninfo->playback_vector.buf[1],
780 (necessary_samples - chaninfo->playback_vector.len[0])
783 chaninfo->current_playback_buffer = chaninfo->playback_wrap_buffer;
788 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
789 process_varispeed_playback(nframes, c);
791 playback_distance = nframes;
805 /* we're exiting with failure, so ::commit will not
806 be called. unlock the state lock.
809 commit_should_unlock = false;
817 AudioDiskstream::process_varispeed_playback(nframes_t nframes, boost::shared_ptr<ChannelList> c)
819 ChannelList::iterator chan;
821 // the idea behind phase is that when the speed is not 1.0, we have to
822 // interpolate between samples and then we have to store where we thought we were.
823 // rather than being at sample N or N+1, we were at N+0.8792922
824 // so the "phase" element, if you want to think about this way,
825 // varies from 0 to 1, representing the "offset" between samples
826 uint64_t phase = last_phase;
831 // index in the input buffers
834 // Linearly interpolate into the speed buffer
835 // using 40.24 fixed point math
837 // Fixed point is just an integer with an implied scaling factor.
838 // In 40.24 the scaling factor is 2^24 = 16777216,
839 // so a value of 10*2^24 (in integer space) is equivalent to 10.0.
841 // The advantage is that addition and modulus [like x = (x + y) % 2^40]
842 // have no rounding errors and no drift, and just require a single integer add.
845 const int64_t fractional_part_mask = 0xFFFFFF;
846 const Sample binary_scaling_factor = 16777216.0f;
848 // phi = fixed point speed
849 if (phi != target_phi) {
850 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
855 for (chan = c->begin(); chan != c->end(); ++chan) {
857 Sample fractional_phase_part;
858 ChannelInfo* chaninfo (*chan);
863 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
865 fractional_phase_part = (phase & fractional_part_mask) / binary_scaling_factor;
866 chaninfo->speed_buffer[outsample] =
867 chaninfo->current_playback_buffer[i] * (1.0f - fractional_phase_part) +
868 chaninfo->current_playback_buffer[i+1] * fractional_phase_part;
869 phase += phi + phi_delta;
872 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
875 playback_distance = i; // + 1;
876 last_phase = (phase & fractional_part_mask);
880 AudioDiskstream::commit (nframes_t nframes)
882 bool need_butler = false;
884 if (!_io || !_io->active()) {
888 if (_actual_speed < 0.0) {
889 playback_sample -= playback_distance;
891 playback_sample += playback_distance;
894 boost::shared_ptr<ChannelList> c = channels.reader();
895 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
897 (*chan)->playback_buf->increment_read_ptr (playback_distance);
899 if (adjust_capture_position) {
900 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
904 if (adjust_capture_position != 0) {
905 capture_captured += adjust_capture_position;
906 adjust_capture_position = 0;
910 if (_io && _io->active()) {
911 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
916 if (_io && _io->active()) {
917 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
918 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
920 need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
924 if (commit_should_unlock) {
934 AudioDiskstream::set_pending_overwrite (bool yn)
936 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
938 pending_overwrite = yn;
940 overwrite_frame = playback_sample;
941 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
945 AudioDiskstream::overwrite_existing_buffers ()
947 boost::shared_ptr<ChannelList> c = channels.reader();
948 Sample* mixdown_buffer;
951 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
953 overwrite_queued = false;
955 /* assume all are the same size */
956 nframes_t size = c->front()->playback_buf->bufsize();
958 mixdown_buffer = new Sample[size];
959 gain_buffer = new float[size];
961 /* reduce size so that we can fill the buffer correctly. */
967 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
969 start = overwrite_frame;
970 nframes_t cnt = size;
972 /* to fill the buffer without resetting the playback sample, we need to
973 do it one or two chunks (normally two).
975 |----------------------------------------------------------------------|
979 |<- second chunk->||<----------------- first chunk ------------------>|
983 nframes_t to_read = size - overwrite_offset;
985 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
986 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
987 _id, size, playback_sample) << endmsg;
995 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
996 start, cnt, *chan, n, reversed)) {
997 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
998 _id, size, playback_sample) << endmsg;
1007 pending_overwrite = false;
1008 delete [] gain_buffer;
1009 delete [] mixdown_buffer;
1014 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
1018 ChannelList::iterator chan;
1019 boost::shared_ptr<ChannelList> c = channels.reader();
1021 Glib::Mutex::Lock lm (state_lock);
1023 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1024 (*chan)->playback_buf->reset ();
1025 (*chan)->capture_buf->reset ();
1028 /* can't rec-enable in destructive mode if transport is before start */
1030 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
1031 disengage_record_enable ();
1034 playback_sample = frame;
1037 if (complete_refill) {
1038 while ((ret = do_refill_with_alloc ()) > 0) ;
1040 ret = do_refill_with_alloc ();
1047 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
1049 ChannelList::iterator chan;
1050 boost::shared_ptr<ChannelList> c = channels.reader();
1052 for (chan = c->begin(); chan != c->end(); ++chan) {
1053 if ((*chan)->playback_buf->read_space() < distance) {
1061 AudioDiskstream::internal_playback_seek (nframes_t distance)
1063 ChannelList::iterator chan;
1064 boost::shared_ptr<ChannelList> c = channels.reader();
1066 for (chan = c->begin(); chan != c->end(); ++chan) {
1067 (*chan)->playback_buf->increment_read_ptr (distance);
1070 first_recordable_frame += distance;
1071 playback_sample += distance;
1077 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1078 ChannelInfo* channel_info, int channel, bool reversed)
1080 nframes_t this_read = 0;
1081 bool reloop = false;
1082 nframes_t loop_end = 0;
1083 nframes_t loop_start = 0;
1084 nframes_t loop_length = 0;
1085 nframes_t offset = 0;
1088 /* XXX we don't currently play loops in reverse. not sure why */
1092 /* Make the use of a Location atomic for this read operation.
1094 Note: Locations don't get deleted, so all we care about
1095 when I say "atomic" is that we are always pointing to
1096 the same one and using a start/length values obtained
1100 if ((loc = loop_location) != 0) {
1101 loop_start = loc->start();
1102 loop_end = loc->end();
1103 loop_length = loop_end - loop_start;
1106 /* if we are looping, ensure that the first frame we read is at the correct
1107 position within the loop.
1110 if (loc && start >= loop_end) {
1111 //cerr << "start adjusted from " << start;
1112 start = loop_start + ((start - loop_start) % loop_length);
1113 //cerr << "to " << start << endl;
1116 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1125 /* take any loop into account. we can't read past the end of the loop. */
1127 if (loc && (loop_end - start < cnt)) {
1128 this_read = loop_end - start;
1129 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1136 if (this_read == 0) {
1140 this_read = min(cnt,this_read);
1142 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1143 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1148 _read_data_count = _playlist->read_data_count();
1152 swap_by_ptr (buf, buf + this_read - 1);
1156 /* if we read to the end of the loop, go back to the beginning */
1166 offset += this_read;
1173 AudioDiskstream::do_refill_with_alloc ()
1175 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1176 float* gain_buf = new float[disk_io_chunk_frames];
1178 int ret = _do_refill(mix_buf, gain_buf);
1187 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1191 RingBufferNPT<Sample>::rw_vector vector;
1192 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1193 nframes_t total_space;
1194 nframes_t zero_fill;
1196 ChannelList::iterator i;
1197 boost::shared_ptr<ChannelList> c = channels.reader();
1204 assert(mixdown_buffer);
1205 assert(gain_buffer);
1212 c->front()->playback_buf->get_write_vector (&vector);
1214 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1218 /* if there are 2+ chunks of disk i/o possible for
1219 this track, let the caller know so that it can arrange
1220 for us to be called again, ASAP.
1223 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1227 /* if we're running close to normal speed and there isn't enough
1228 space to do disk_io_chunk_frames of I/O, then don't bother.
1230 at higher speeds, just do it because the sync between butler
1231 and audio thread may not be good enough.
1234 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1238 /* when slaved, don't try to get too close to the read pointer. this
1239 leaves space for the buffer reversal to have something useful to
1243 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1247 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1249 total_space = min (disk_io_chunk_frames, total_space);
1253 if (file_frame == 0) {
1255 /* at start: nothing to do but fill with silence */
1257 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1259 ChannelInfo* chan (*i);
1260 chan->playback_buf->get_write_vector (&vector);
1261 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1262 if (vector.len[1]) {
1263 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1265 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1270 if (file_frame < total_space) {
1272 /* too close to the start: read what we can,
1273 and then zero fill the rest
1276 zero_fill = total_space - file_frame;
1277 total_space = file_frame;
1287 if (file_frame == max_frames) {
1289 /* at end: nothing to do but fill with silence */
1291 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1293 ChannelInfo* chan (*i);
1294 chan->playback_buf->get_write_vector (&vector);
1295 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1296 if (vector.len[1]) {
1297 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1299 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1304 if (file_frame > max_frames - total_space) {
1306 /* to close to the end: read what we can, and zero fill the rest */
1308 zero_fill = total_space - (max_frames - file_frame);
1309 total_space = max_frames - file_frame;
1316 nframes_t file_frame_tmp = 0;
1318 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1320 ChannelInfo* chan (*i);
1323 nframes_t len1, len2;
1325 chan->playback_buf->get_write_vector (&vector);
1327 if (vector.len[0] > disk_io_chunk_frames) {
1329 /* we're not going to fill the first chunk, so certainly do not bother with the
1330 other part. it won't be connected with the part we do fill, as in:
1332 .... => writable space
1333 ++++ => readable space
1334 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1336 |......|+++++++++++++|...............................|
1341 So, just pretend that the buf1 part isn't there.
1351 file_frame_tmp = file_frame;
1353 buf1 = vector.buf[0];
1354 len1 = vector.len[0];
1355 buf2 = vector.buf[1];
1356 len2 = vector.len[1];
1358 to_read = min (ts, len1);
1359 to_read = min (to_read, disk_io_chunk_frames);
1363 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1368 chan->playback_buf->increment_write_ptr (to_read);
1372 to_read = min (ts, len2);
1376 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1377 so read some or all of vector.len[1] as well.
1380 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1385 chan->playback_buf->increment_write_ptr (to_read);
1394 file_frame = file_frame_tmp;
1401 /** Flush pending data to disk.
1403 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1404 * of data to disk. it will never write more than that. If it writes that
1405 * much and there is more than that waiting to be written, it will return 1,
1406 * otherwise 0 on success or -1 on failure.
1408 * If there is less than disk_io_chunk_frames to be written, no data will be
1409 * written at all unless @a force_flush is true.
1412 AudioDiskstream::do_flush (RunContext context, bool force_flush)
1416 RingBufferNPT<Sample>::rw_vector vector;
1417 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1420 _write_data_count = 0;
1422 transvec.buf[0] = 0;
1423 transvec.buf[1] = 0;
1427 boost::shared_ptr<ChannelList> c = channels.reader();
1428 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1430 (*chan)->capture_buf->get_read_vector (&vector);
1432 total = vector.len[0] + vector.len[1];
1434 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1438 /* if there are 2+ chunks of disk i/o possible for
1439 this track, let the caller know so that it can arrange
1440 for us to be called again, ASAP.
1442 if we are forcing a flush, then if there is* any* extra
1443 work, let the caller know.
1445 if we are no longer recording and there is any extra work,
1446 let the caller know too.
1449 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1453 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1455 // check the transition buffer when recording destructive
1456 // important that we get this after the capture buf
1458 if (destructive()) {
1459 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1460 size_t transcount = transvec.len[0] + transvec.len[1];
1461 bool have_start = false;
1464 for (ti=0; ti < transcount; ++ti) {
1465 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1467 if (captrans.type == CaptureStart) {
1468 // by definition, the first data we got above represents the given capture pos
1470 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1471 (*chan)->curr_capture_cnt = 0;
1475 else if (captrans.type == CaptureEnd) {
1477 // capture end, the capture_val represents total frames in capture
1479 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1481 // shorten to make the write a perfect fit
1482 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1484 if (nto_write < to_write) {
1485 ret = 1; // should we?
1487 to_write = nto_write;
1489 (*chan)->write_source->mark_capture_end ();
1491 // increment past this transition, but go no further
1496 // actually ends just beyond this chunk, so force more work
1504 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1508 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1509 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1513 (*chan)->capture_buf->increment_read_ptr (to_write);
1514 (*chan)->curr_capture_cnt += to_write;
1516 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1518 /* we wrote all of vector.len[0] but it wasn't an entire
1519 disk_io_chunk_frames of data, so arrange for some part
1520 of vector.len[1] to be flushed to disk as well.
1523 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1525 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1526 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1530 _write_data_count += (*chan)->write_source->write_data_count();
1532 (*chan)->capture_buf->increment_read_ptr (to_write);
1533 (*chan)->curr_capture_cnt += to_write;
1542 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1544 uint32_t buffer_position;
1545 bool more_work = true;
1547 boost::shared_ptr<AudioRegion> region;
1548 nframes_t total_capture;
1550 SourceList::iterator src;
1551 ChannelList::iterator chan;
1552 vector<CaptureInfo*>::iterator ci;
1553 boost::shared_ptr<ChannelList> c = channels.reader();
1555 bool mark_write_completed = false;
1557 finish_capture (true, c);
1559 /* butler is already stopped, but there may be work to do
1560 to flush remaining data to disk.
1563 while (more_work && !err) {
1564 switch (do_flush (TransportContext, true)) {
1571 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1576 /* XXX is there anything we can do if err != 0 ? */
1577 Glib::Mutex::Lock lm (capture_info_lock);
1579 if (capture_info.empty()) {
1583 if (abort_capture) {
1585 if (destructive()) {
1589 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1591 if ((*chan)->write_source) {
1593 (*chan)->write_source->mark_for_remove ();
1594 (*chan)->write_source->drop_references ();
1595 (*chan)->write_source.reset ();
1598 /* new source set up in "out" below */
1604 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1605 total_capture += (*ci)->frames;
1608 /* figure out the name for this take */
1610 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1612 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1616 s->update_header (capture_info.front()->start, when, twhen);
1617 s->set_captured_for (_name);
1618 s->mark_immutable ();
1619 if (Config->get_auto_analyse_audio()) {
1620 Analyser::queue_source_for_analysis (s, true);
1625 /* destructive tracks have a single, never changing region */
1627 if (destructive()) {
1629 /* send a signal that any UI can pick up to do the right thing. there is
1630 a small problem here in that a UI may need the peak data to be ready
1631 for the data that was recorded and this isn't interlocked with that
1632 process. this problem is deferred to the UI.
1635 _playlist->Modified();
1639 string whole_file_region_name;
1640 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1642 /* Register a new region with the Session that
1643 describes the entire source. Do this first
1644 so that any sub-regions will obviously be
1645 children of this one (later!)
1649 boost::shared_ptr<Region> rx (RegionFactory::create (srcs,
1650 c->front()->write_source->last_capture_start_frame(), total_capture,
1651 whole_file_region_name, 0,
1652 Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
1654 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1655 region->special_set_position (capture_info.front()->start);
1659 catch (failed_constructor& err) {
1660 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1664 _last_capture_regions.push_back (region);
1666 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1668 XMLNode &before = _playlist->get_state();
1669 _playlist->freeze ();
1671 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1675 _session.region_name (region_name, whole_file_region_name, false);
1677 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1680 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1681 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1684 catch (failed_constructor& err) {
1685 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1686 continue; /* XXX is this OK? */
1689 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1691 _last_capture_regions.push_back (region);
1693 i_am_the_modifier++;
1694 _playlist->add_region (region, (*ci)->start, 1, non_layered());
1695 i_am_the_modifier--;
1697 buffer_position += (*ci)->frames;
1701 XMLNode &after = _playlist->get_state();
1702 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1705 mark_write_completed = true;
1708 reset_write_sources (mark_write_completed);
1712 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1716 capture_info.clear ();
1717 capture_start_frame = 0;
1721 AudioDiskstream::transport_looped (nframes_t transport_frame)
1723 if (was_recording) {
1724 // all we need to do is finish this capture, with modified capture length
1725 boost::shared_ptr<ChannelList> c = channels.reader();
1727 // adjust the capture length knowing that the data will be recorded to disk
1728 // only necessary after the first loop where we're recording
1729 if (capture_info.size() == 0) {
1730 capture_captured += _capture_offset;
1732 if (_alignment_style == ExistingMaterial) {
1733 capture_captured += _session.worst_output_latency();
1735 capture_captured += _roll_delay;
1739 finish_capture (true, c);
1741 // the next region will start recording via the normal mechanism
1742 // we'll set the start position to the current transport pos
1743 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1744 capture_start_frame = transport_frame;
1745 first_recordable_frame = transport_frame; // mild lie
1746 last_recordable_frame = max_frames;
1747 was_recording = true;
1749 if (recordable() && destructive()) {
1750 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1752 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1753 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1755 if (transvec.len[0] > 0) {
1756 transvec.buf[0]->type = CaptureStart;
1757 transvec.buf[0]->capture_val = capture_start_frame;
1758 (*chan)->capture_transition_buf->increment_write_ptr(1);
1762 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1772 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1774 was_recording = false;
1776 if (capture_captured == 0) {
1780 if (recordable() && destructive()) {
1781 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1783 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1784 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1786 if (transvec.len[0] > 0) {
1787 transvec.buf[0]->type = CaptureEnd;
1788 transvec.buf[0]->capture_val = capture_captured;
1789 (*chan)->capture_transition_buf->increment_write_ptr(1);
1793 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1799 CaptureInfo* ci = new CaptureInfo;
1801 ci->start = capture_start_frame;
1802 ci->frames = capture_captured;
1804 /* XXX theoretical race condition here. Need atomic exchange ?
1805 However, the circumstances when this is called right
1806 now (either on record-disable or transport_stopped)
1807 mean that no actual race exists. I think ...
1808 We now have a capture_info_lock, but it is only to be used
1809 to synchronize in the transport_stop and the capture info
1810 accessors, so that invalidation will not occur (both non-realtime).
1813 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1815 capture_info.push_back (ci);
1816 capture_captured = 0;
1818 /* now we've finished a capture, reset first_recordable_frame for next time */
1819 first_recordable_frame = max_frames;
1823 AudioDiskstream::set_record_enabled (bool yn)
1825 if (!recordable() || !_session.record_enabling_legal() || _io->n_inputs().n_audio() == 0) {
1829 /* can't rec-enable in destructive mode if transport is before start */
1831 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1835 if (yn && channels.reader()->front()->source == 0) {
1837 /* pick up connections not initiated *from* the IO object
1838 we're associated with.
1841 get_input_sources ();
1844 /* yes, i know that this not proof against race conditions, but its
1845 good enough. i think.
1848 if (record_enabled() != yn) {
1850 engage_record_enable ();
1852 disengage_record_enable ();
1858 AudioDiskstream::engage_record_enable ()
1860 bool rolling = _session.transport_speed() != 0.0f;
1861 boost::shared_ptr<ChannelList> c = channels.reader();
1863 g_atomic_int_set (&_record_enabled, 1);
1864 capturing_sources.clear ();
1866 if (Config->get_monitoring_model() == HardwareMonitoring) {
1868 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1869 if ((*chan)->source) {
1870 (*chan)->source->ensure_monitor_input (!(Config->get_auto_input() && rolling));
1872 capturing_sources.push_back ((*chan)->write_source);
1873 (*chan)->write_source->mark_streaming_write_started ();
1877 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1878 capturing_sources.push_back ((*chan)->write_source);
1879 (*chan)->write_source->mark_streaming_write_started ();
1883 RecordEnableChanged (); /* EMIT SIGNAL */
1887 AudioDiskstream::disengage_record_enable ()
1889 g_atomic_int_set (&_record_enabled, 0);
1890 boost::shared_ptr<ChannelList> c = channels.reader();
1891 if (Config->get_monitoring_model() == HardwareMonitoring) {
1892 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1893 if ((*chan)->source) {
1894 (*chan)->source->ensure_monitor_input (false);
1898 capturing_sources.clear ();
1899 RecordEnableChanged (); /* EMIT SIGNAL */
1903 AudioDiskstream::get_state ()
1905 XMLNode* node = new XMLNode ("AudioDiskstream");
1907 LocaleGuard lg (X_("POSIX"));
1908 boost::shared_ptr<ChannelList> c = channels.reader();
1910 node->add_property ("flags", enum_2_string (_flags));
1912 snprintf (buf, sizeof(buf), "%zd", c->size());
1913 node->add_property ("channels", buf);
1915 node->add_property ("playlist", _playlist->name());
1917 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1918 node->add_property ("speed", buf);
1920 node->add_property("name", _name);
1921 id().print (buf, sizeof (buf));
1922 node->add_property("id", buf);
1924 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1926 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1927 XMLNode* cs_grandchild;
1929 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1930 cs_grandchild = new XMLNode (X_("file"));
1931 cs_grandchild->add_property (X_("path"), (*i)->path());
1932 cs_child->add_child_nocopy (*cs_grandchild);
1935 /* store the location where capture will start */
1939 if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1940 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1942 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1945 cs_child->add_property (X_("at"), buf);
1946 node->add_child_nocopy (*cs_child);
1950 node->add_child_copy (*_extra_xml);
1957 AudioDiskstream::set_state (const XMLNode& node)
1959 const XMLProperty* prop;
1960 XMLNodeList nlist = node.children();
1961 XMLNodeIterator niter;
1962 uint32_t nchans = 1;
1963 XMLNode* capture_pending_node = 0;
1964 LocaleGuard lg (X_("POSIX"));
1966 in_set_state = true;
1968 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1969 if ((*niter)->name() == IO::state_node_name) {
1970 deprecated_io_node = new XMLNode (**niter);
1973 if ((*niter)->name() == X_("CapturingSources")) {
1974 capture_pending_node = *niter;
1978 /* prevent write sources from being created */
1980 in_set_state = true;
1982 if ((prop = node.property ("name")) != 0) {
1983 _name = prop->value();
1986 if (deprecated_io_node) {
1987 if ((prop = deprecated_io_node->property ("id")) != 0) {
1988 _id = prop->value ();
1991 if ((prop = node.property ("id")) != 0) {
1992 _id = prop->value ();
1996 if ((prop = node.property ("flags")) != 0) {
1997 _flags = Flag (string_2_enum (prop->value(), _flags));
2000 if ((prop = node.property ("channels")) != 0) {
2001 nchans = atoi (prop->value().c_str());
2004 // create necessary extra channels
2005 // we are always constructed with one and we always need one
2007 _n_channels.set(DataType::AUDIO, channels.reader()->size());
2009 if (nchans > _n_channels.n_audio()) {
2011 add_channel (nchans - _n_channels.n_audio());
2012 IO::PortCountChanged(_n_channels);
2014 } else if (nchans < _n_channels.n_audio()) {
2016 remove_channel (_n_channels.n_audio() - nchans);
2019 if ((prop = node.property ("playlist")) == 0) {
2024 bool had_playlist = (_playlist != 0);
2026 if (find_and_use_playlist (prop->value())) {
2030 if (!had_playlist) {
2031 _playlist->set_orig_diskstream_id (_id);
2034 if (!destructive() && capture_pending_node) {
2035 /* destructive streams have one and only one source per channel,
2036 and so they never end up in pending capture in any useful
2039 use_pending_capture_data (*capture_pending_node);
2044 if ((prop = node.property ("speed")) != 0) {
2045 double sp = atof (prop->value().c_str());
2047 if (realtime_set_speed (sp, false)) {
2048 non_realtime_set_speed ();
2052 in_set_state = false;
2054 /* make sure this is clear before we do anything else */
2056 capturing_sources.clear ();
2058 /* write sources are handled when we handle the input set
2059 up of the IO that owns this DS (::non_realtime_input_change())
2066 AudioDiskstream::use_new_write_source (uint32_t n)
2068 boost::shared_ptr<ChannelList> c = channels.reader();
2070 if (!recordable()) {
2074 if (n >= c->size()) {
2075 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2079 ChannelInfo* chan = (*c)[n];
2081 if (chan->write_source) {
2082 chan->write_source->done_with_peakfile_writes ();
2083 chan->write_source->set_allow_remove_if_empty (true);
2084 chan->write_source.reset ();
2088 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2089 throw failed_constructor();
2093 catch (failed_constructor &err) {
2094 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2095 chan->write_source.reset ();
2099 /* do not remove destructive files even if they are empty */
2101 chan->write_source->set_allow_remove_if_empty (!destructive());
2107 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2109 ChannelList::iterator chan;
2110 boost::shared_ptr<ChannelList> c = channels.reader();
2113 if (!recordable()) {
2117 capturing_sources.clear ();
2119 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2120 if (!destructive()) {
2122 if ((*chan)->write_source && mark_write_complete) {
2123 (*chan)->write_source->mark_streaming_write_completed ();
2125 use_new_write_source (n);
2127 if (record_enabled()) {
2128 capturing_sources.push_back ((*chan)->write_source);
2132 if ((*chan)->write_source == 0) {
2133 use_new_write_source (n);
2138 if (destructive()) {
2140 /* we now have all our write sources set up, so create the
2141 playlist's single region.
2144 if (_playlist->empty()) {
2145 setup_destructive_playlist ();
2151 AudioDiskstream::rename_write_sources ()
2153 ChannelList::iterator chan;
2154 boost::shared_ptr<ChannelList> c = channels.reader();
2157 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2158 if ((*chan)->write_source != 0) {
2159 (*chan)->write_source->set_source_name (_name, destructive());
2160 /* XXX what to do if one of them fails ? */
2168 AudioDiskstream::set_block_size (nframes_t nframes)
2170 if (_session.get_block_size() > speed_buffer_size) {
2171 speed_buffer_size = _session.get_block_size();
2172 boost::shared_ptr<ChannelList> c = channels.reader();
2174 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2175 if ((*chan)->speed_buffer)
2176 delete [] (*chan)->speed_buffer;
2177 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2180 allocate_temporary_buffers ();
2184 AudioDiskstream::allocate_temporary_buffers ()
2186 /* make sure the wrap buffer is at least large enough to deal
2187 with the speeds up to 1.2, to allow for micro-variation
2188 when slaving to MTC, SMPTE etc.
2191 double sp = max (fabsf (_actual_speed), 1.2f);
2192 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2194 if (required_wrap_size > wrap_buffer_size) {
2196 boost::shared_ptr<ChannelList> c = channels.reader();
2198 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2199 if ((*chan)->playback_wrap_buffer)
2200 delete [] (*chan)->playback_wrap_buffer;
2201 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2202 if ((*chan)->capture_wrap_buffer)
2203 delete [] (*chan)->capture_wrap_buffer;
2204 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2207 wrap_buffer_size = required_wrap_size;
2212 AudioDiskstream::monitor_input (bool yn)
2214 boost::shared_ptr<ChannelList> c = channels.reader();
2216 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2218 if ((*chan)->source) {
2219 (*chan)->source->ensure_monitor_input (yn);
2225 AudioDiskstream::set_align_style_from_io ()
2227 bool have_physical = false;
2233 get_input_sources ();
2235 boost::shared_ptr<ChannelList> c = channels.reader();
2237 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2238 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2239 have_physical = true;
2244 if (have_physical) {
2245 set_align_style (ExistingMaterial);
2247 set_align_style (CaptureTime);
2252 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2254 while (how_many--) {
2255 c->push_back (new ChannelInfo(_session.audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2258 _n_channels.set(DataType::AUDIO, c->size());
2264 AudioDiskstream::add_channel (uint32_t how_many)
2266 RCUWriter<ChannelList> writer (channels);
2267 boost::shared_ptr<ChannelList> c = writer.get_copy();
2269 return add_channel_to (c, how_many);
2273 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2275 while (how_many-- && !c->empty()) {
2276 //delete c->back(); // FIXME: crash (thread safe with RCU?)
2280 _n_channels.set(DataType::AUDIO, c->size());
2286 AudioDiskstream::remove_channel (uint32_t how_many)
2288 RCUWriter<ChannelList> writer (channels);
2289 boost::shared_ptr<ChannelList> c = writer.get_copy();
2291 return remove_channel_from (c, how_many);
2295 AudioDiskstream::playback_buffer_load () const
2297 boost::shared_ptr<ChannelList> c = channels.reader();
2299 return (float) ((double) c->front()->playback_buf->read_space()/
2300 (double) c->front()->playback_buf->bufsize());
2304 AudioDiskstream::capture_buffer_load () const
2306 boost::shared_ptr<ChannelList> c = channels.reader();
2308 return (float) ((double) c->front()->capture_buf->write_space()/
2309 (double) c->front()->capture_buf->bufsize());
2313 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2315 const XMLProperty* prop;
2316 XMLNodeList nlist = node.children();
2317 XMLNodeIterator niter;
2318 boost::shared_ptr<AudioFileSource> fs;
2319 boost::shared_ptr<AudioFileSource> first_fs;
2320 SourceList pending_sources;
2323 if ((prop = node.property (X_("at"))) == 0) {
2327 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2331 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2332 if ((*niter)->name() == X_("file")) {
2334 if ((prop = (*niter)->property (X_("path"))) == 0) {
2338 // This protects sessions from errant CapturingSources in stored sessions
2340 if (stat (prop->value().c_str(), &sbuf)) {
2345 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2346 SourceFactory::createWritable (DataType::AUDIO, _session,
2347 prop->value(), true,
2348 false, _session.frame_rate()));
2351 catch (failed_constructor& err) {
2352 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2353 _name, prop->value())
2358 pending_sources.push_back (fs);
2360 if (first_fs == 0) {
2364 fs->set_captured_for (_name);
2368 if (pending_sources.size() == 0) {
2369 /* nothing can be done */
2373 if (pending_sources.size() != _n_channels.n_audio()) {
2374 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2379 boost::shared_ptr<AudioRegion> region;
2382 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
2383 pending_sources, 0, first_fs->length(first_fs->timeline_position()),
2384 region_name_from_path (first_fs->name(), true), 0,
2385 Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
2386 region->special_set_position (0);
2389 catch (failed_constructor& err) {
2390 error << string_compose (
2391 _("%1: cannot create whole-file region from pending capture sources"),
2398 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
2399 pending_sources, 0, first_fs->length(first_fs->timeline_position()),
2400 region_name_from_path (first_fs->name(), true)));
2403 catch (failed_constructor& err) {
2404 error << string_compose (_("%1: cannot create region from pending capture sources"),
2411 _playlist->add_region (region, position);
2417 AudioDiskstream::set_non_layered (bool yn)
2419 if (yn != non_layered()) {
2422 _flags = Flag (_flags | NonLayered);
2424 _flags = Flag (_flags & ~NonLayered);
2432 AudioDiskstream::set_destructive (bool yn)
2434 bool bounce_ignored;
2436 if (yn != destructive()) {
2439 /* requestor should already have checked this and
2440 bounced if necessary and desired
2442 if (!can_become_destructive (bounce_ignored)) {
2445 _flags = Flag (_flags | Destructive);
2446 use_destructive_playlist ();
2448 _flags = Flag (_flags & ~Destructive);
2449 reset_write_sources (true, true);
2457 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2460 requires_bounce = false;
2464 /* is there only one region ? */
2466 if (_playlist->n_regions() != 1) {
2467 requires_bounce = true;
2471 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2474 /* do the source(s) for the region cover the session start position ? */
2476 if (first->position() != _session.current_start_frame()) {
2477 if (first->start() > _session.current_start_frame()) {
2478 requires_bounce = true;
2483 /* is the source used by only 1 playlist ? */
2485 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2489 if (afirst->source()->used() > 1) {
2490 requires_bounce = true;
2494 requires_bounce = false;
2498 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2502 current_capture_buffer = 0;
2503 current_playback_buffer = 0;
2504 curr_capture_cnt = 0;
2506 speed_buffer = new Sample[speed_size];
2507 playback_wrap_buffer = new Sample[wrap_size];
2508 capture_wrap_buffer = new Sample[wrap_size];
2510 playback_buf = new RingBufferNPT<Sample> (bufsize);
2511 capture_buf = new RingBufferNPT<Sample> (bufsize);
2512 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2514 /* touch the ringbuffer buffers, which will cause
2515 them to be mapped into locked physical RAM if
2516 we're running with mlockall(). this doesn't do
2520 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2521 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2522 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2525 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2528 write_source.reset ();
2531 delete [] speed_buffer;
2534 delete [] playback_wrap_buffer;
2535 playback_wrap_buffer = 0;
2537 delete [] capture_wrap_buffer;
2538 capture_wrap_buffer = 0;
2540 delete playback_buf;
2546 delete capture_transition_buf;
2547 capture_transition_buf = 0;