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_ports().n_audio() > _n_channels.n_audio()) {
177 add_channel_to (c, _io->n_ports().n_audio() - _n_channels.n_audio());
178 } else if (_io->n_ports().n_audio() < _n_channels.n_audio()) {
179 remove_channel_from (c, _n_channels.n_audio() - _io->n_ports().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_ports().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->nth (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 (!_session.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 (_session.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() && _session.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_ports ().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 (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 (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;
794 _speed = _target_speed;
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;
822 interpolation.set_speed (_target_speed);
825 for (chan = c->begin(); chan != c->end(); ++chan, ++channel) {
826 ChannelInfo* chaninfo (*chan);
828 playback_distance = interpolation.interpolate (
829 channel, nframes, chaninfo->current_playback_buffer, chaninfo->speed_buffer);
833 // the idea behind phase is that when the speed is not 1.0, we have to
834 // interpolate between samples and then we have to store where we thought we were.
835 // rather than being at sample N or N+1, we were at N+0.8792922
836 // so the "phase" element, if you want to think about this way,
837 // varies from 0 to 1, representing the "offset" between samples
838 uint64_t phase = interpolation.get_last_phase();
840 interpolation.set_speed (_target_speed);
843 uint64_t phi = interpolation.get_phi();
844 uint64_t target_phi = interpolation.get_target_phi();
847 // index in the input buffers
850 // Linearly interpolate into the speed buffer
851 // using 40.24 fixed point math
853 // Fixed point is just an integer with an implied scaling factor.
854 // In 40.24 the scaling factor is 2^24 = 16777216,
855 // so a value of 10*2^24 (in integer space) is equivalent to 10.0.
857 // The advantage is that addition and modulus [like x = (x + y) % 2^40]
858 // have no rounding errors and no drift, and just require a single integer add.
861 const int64_t fractional_part_mask = 0xFFFFFF;
862 const Sample binary_scaling_factor = 16777216.0f;
864 // phi = fixed point speed
865 if (phi != target_phi) {
866 phi_delta = ((int64_t)(target_phi - phi)) / nframes;
871 for (chan = c->begin(); chan != c->end(); ++chan) {
873 Sample fractional_phase_part;
874 ChannelInfo* chaninfo (*chan);
877 phase = interpolation.get_last_phase();
879 for (nframes_t outsample = 0; outsample < nframes; ++outsample) {
881 fractional_phase_part = (phase & fractional_part_mask) / binary_scaling_factor;
882 chaninfo->speed_buffer[outsample] =
883 chaninfo->current_playback_buffer[i] * (1.0f - fractional_phase_part) +
884 chaninfo->current_playback_buffer[i+1] * fractional_phase_part;
885 phase += phi + phi_delta;
888 chaninfo->current_playback_buffer = chaninfo->speed_buffer;
891 playback_distance = i; // + 1;
892 interpolation.set_last_phase (phase & fractional_part_mask);
896 AudioDiskstream::commit (nframes_t nframes)
898 bool need_butler = false;
900 if (!_io || !_io->active()) {
904 if (_actual_speed < 0.0) {
905 playback_sample -= playback_distance;
907 playback_sample += playback_distance;
910 boost::shared_ptr<ChannelList> c = channels.reader();
911 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
913 (*chan)->playback_buf->increment_read_ptr (playback_distance);
915 if (adjust_capture_position) {
916 (*chan)->capture_buf->increment_write_ptr (adjust_capture_position);
920 if (adjust_capture_position != 0) {
921 capture_captured += adjust_capture_position;
922 adjust_capture_position = 0;
926 if (_io && _io->active()) {
927 need_butler = c->front()->playback_buf->write_space() >= c->front()->playback_buf->bufsize() / 2;
932 if (_io && _io->active()) {
933 need_butler = c->front()->playback_buf->write_space() >= disk_io_chunk_frames
934 || c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
936 need_butler = c->front()->capture_buf->read_space() >= disk_io_chunk_frames;
940 if (commit_should_unlock) {
950 AudioDiskstream::set_pending_overwrite (bool yn)
952 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
954 pending_overwrite = yn;
956 overwrite_frame = playback_sample;
957 overwrite_offset = channels.reader()->front()->playback_buf->get_read_ptr();
961 AudioDiskstream::overwrite_existing_buffers ()
963 boost::shared_ptr<ChannelList> c = channels.reader();
964 Sample* mixdown_buffer;
967 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
969 overwrite_queued = false;
971 /* assume all are the same size */
972 nframes_t size = c->front()->playback_buf->bufsize();
974 mixdown_buffer = new Sample[size];
975 gain_buffer = new float[size];
977 /* reduce size so that we can fill the buffer correctly. */
983 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
985 start = overwrite_frame;
986 nframes_t cnt = size;
988 /* to fill the buffer without resetting the playback sample, we need to
989 do it one or two chunks (normally two).
991 |----------------------------------------------------------------------|
995 |<- second chunk->||<----------------- first chunk ------------------>|
999 nframes_t to_read = size - overwrite_offset;
1001 if (read ((*chan)->playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, start, to_read, *chan, n, reversed)) {
1002 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
1003 _id, size, playback_sample) << endmsg;
1007 if (cnt > to_read) {
1011 if (read ((*chan)->playback_buf->buffer(), mixdown_buffer, gain_buffer,
1012 start, cnt, *chan, n, reversed)) {
1013 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
1014 _id, size, playback_sample) << endmsg;
1023 pending_overwrite = false;
1024 delete [] gain_buffer;
1025 delete [] mixdown_buffer;
1030 AudioDiskstream::seek (nframes_t frame, bool complete_refill)
1034 ChannelList::iterator chan;
1035 boost::shared_ptr<ChannelList> c = channels.reader();
1037 Glib::Mutex::Lock lm (state_lock);
1039 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1040 (*chan)->playback_buf->reset ();
1041 (*chan)->capture_buf->reset ();
1044 /* can't rec-enable in destructive mode if transport is before start */
1046 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
1047 disengage_record_enable ();
1050 playback_sample = frame;
1053 if (complete_refill) {
1054 while ((ret = do_refill_with_alloc ()) > 0) ;
1056 ret = do_refill_with_alloc ();
1063 AudioDiskstream::can_internal_playback_seek (nframes_t distance)
1065 ChannelList::iterator chan;
1066 boost::shared_ptr<ChannelList> c = channels.reader();
1068 for (chan = c->begin(); chan != c->end(); ++chan) {
1069 if ((*chan)->playback_buf->read_space() < distance) {
1077 AudioDiskstream::internal_playback_seek (nframes_t distance)
1079 ChannelList::iterator chan;
1080 boost::shared_ptr<ChannelList> c = channels.reader();
1082 for (chan = c->begin(); chan != c->end(); ++chan) {
1083 (*chan)->playback_buf->increment_read_ptr (distance);
1086 first_recordable_frame += distance;
1087 playback_sample += distance;
1093 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, nframes_t& start, nframes_t cnt,
1094 ChannelInfo* channel_info, int channel, bool reversed)
1096 nframes_t this_read = 0;
1097 bool reloop = false;
1098 nframes_t loop_end = 0;
1099 nframes_t loop_start = 0;
1100 nframes_t loop_length = 0;
1101 nframes_t offset = 0;
1104 /* XXX we don't currently play loops in reverse. not sure why */
1108 /* Make the use of a Location atomic for this read operation.
1110 Note: Locations don't get deleted, so all we care about
1111 when I say "atomic" is that we are always pointing to
1112 the same one and using a start/length values obtained
1116 if ((loc = loop_location) != 0) {
1117 loop_start = loc->start();
1118 loop_end = loc->end();
1119 loop_length = loop_end - loop_start;
1122 /* if we are looping, ensure that the first frame we read is at the correct
1123 position within the loop.
1126 if (loc && start >= loop_end) {
1127 //cerr << "start adjusted from " << start;
1128 start = loop_start + ((start - loop_start) % loop_length);
1129 //cerr << "to " << start << endl;
1132 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1141 /* take any loop into account. we can't read past the end of the loop. */
1143 if (loc && (loop_end - start < cnt)) {
1144 this_read = loop_end - start;
1145 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1152 if (this_read == 0) {
1156 this_read = min(cnt,this_read);
1158 if (audio_playlist()->read (buf+offset, mixdown_buffer, gain_buffer, start, this_read, channel) != this_read) {
1159 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1164 _read_data_count = _playlist->read_data_count();
1168 swap_by_ptr (buf, buf + this_read - 1);
1172 /* if we read to the end of the loop, go back to the beginning */
1182 offset += this_read;
1189 AudioDiskstream::do_refill_with_alloc ()
1191 Sample* mix_buf = new Sample[disk_io_chunk_frames];
1192 float* gain_buf = new float[disk_io_chunk_frames];
1194 int ret = _do_refill(mix_buf, gain_buf);
1203 AudioDiskstream::_do_refill (Sample* mixdown_buffer, float* gain_buffer)
1207 RingBufferNPT<Sample>::rw_vector vector;
1208 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1209 nframes_t total_space;
1210 nframes_t zero_fill;
1212 ChannelList::iterator i;
1213 boost::shared_ptr<ChannelList> c = channels.reader();
1220 assert(mixdown_buffer);
1221 assert(gain_buffer);
1228 c->front()->playback_buf->get_write_vector (&vector);
1230 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1234 /* if there are 2+ chunks of disk i/o possible for
1235 this track, let the caller know so that it can arrange
1236 for us to be called again, ASAP.
1239 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1243 /* if we're running close to normal speed and there isn't enough
1244 space to do disk_io_chunk_frames of I/O, then don't bother.
1246 at higher speeds, just do it because the sync between butler
1247 and audio thread may not be good enough.
1250 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1254 /* when slaved, don't try to get too close to the read pointer. this
1255 leaves space for the buffer reversal to have something useful to
1259 if (_slaved && total_space < (c->front()->playback_buf->bufsize() / 2)) {
1263 /* never do more than disk_io_chunk_frames worth of disk input per call (limit doesn't apply for memset) */
1265 total_space = min (disk_io_chunk_frames, total_space);
1269 if (file_frame == 0) {
1271 /* at start: nothing to do but fill with silence */
1273 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1275 ChannelInfo* chan (*i);
1276 chan->playback_buf->get_write_vector (&vector);
1277 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1278 if (vector.len[1]) {
1279 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1281 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1286 if (file_frame < total_space) {
1288 /* too close to the start: read what we can,
1289 and then zero fill the rest
1292 zero_fill = total_space - file_frame;
1293 total_space = file_frame;
1303 if (file_frame == max_frames) {
1305 /* at end: nothing to do but fill with silence */
1307 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1309 ChannelInfo* chan (*i);
1310 chan->playback_buf->get_write_vector (&vector);
1311 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1312 if (vector.len[1]) {
1313 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1315 chan->playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1320 if (file_frame > max_frames - total_space) {
1322 /* to close to the end: read what we can, and zero fill the rest */
1324 zero_fill = total_space - (max_frames - file_frame);
1325 total_space = max_frames - file_frame;
1332 nframes_t file_frame_tmp = 0;
1334 for (chan_n = 0, i = c->begin(); i != c->end(); ++i, ++chan_n) {
1336 ChannelInfo* chan (*i);
1339 nframes_t len1, len2;
1341 chan->playback_buf->get_write_vector (&vector);
1343 if (vector.len[0] > disk_io_chunk_frames) {
1345 /* we're not going to fill the first chunk, so certainly do not bother with the
1346 other part. it won't be connected with the part we do fill, as in:
1348 .... => writable space
1349 ++++ => readable space
1350 ^^^^ => 1 x disk_io_chunk_frames that would be filled
1352 |......|+++++++++++++|...............................|
1357 So, just pretend that the buf1 part isn't there.
1367 file_frame_tmp = file_frame;
1369 buf1 = vector.buf[0];
1370 len1 = vector.len[0];
1371 buf2 = vector.buf[1];
1372 len2 = vector.len[1];
1374 to_read = min (ts, len1);
1375 to_read = min (to_read, disk_io_chunk_frames);
1379 if (read (buf1, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1384 chan->playback_buf->increment_write_ptr (to_read);
1388 to_read = min (ts, len2);
1392 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1393 so read some or all of vector.len[1] as well.
1396 if (read (buf2, mixdown_buffer, gain_buffer, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1401 chan->playback_buf->increment_write_ptr (to_read);
1410 file_frame = file_frame_tmp;
1417 /** Flush pending data to disk.
1419 * Important note: this function will write *AT MOST* disk_io_chunk_frames
1420 * of data to disk. it will never write more than that. If it writes that
1421 * much and there is more than that waiting to be written, it will return 1,
1422 * otherwise 0 on success or -1 on failure.
1424 * If there is less than disk_io_chunk_frames to be written, no data will be
1425 * written at all unless @a force_flush is true.
1428 AudioDiskstream::do_flush (RunContext context, bool force_flush)
1432 RingBufferNPT<Sample>::rw_vector vector;
1433 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1436 _write_data_count = 0;
1438 transvec.buf[0] = 0;
1439 transvec.buf[1] = 0;
1443 boost::shared_ptr<ChannelList> c = channels.reader();
1444 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1446 (*chan)->capture_buf->get_read_vector (&vector);
1448 total = vector.len[0] + vector.len[1];
1450 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1454 /* if there are 2+ chunks of disk i/o possible for
1455 this track, let the caller know so that it can arrange
1456 for us to be called again, ASAP.
1458 if we are forcing a flush, then if there is* any* extra
1459 work, let the caller know.
1461 if we are no longer recording and there is any extra work,
1462 let the caller know too.
1465 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1469 to_write = min (disk_io_chunk_frames, (nframes_t) vector.len[0]);
1471 // check the transition buffer when recording destructive
1472 // important that we get this after the capture buf
1474 if (destructive()) {
1475 (*chan)->capture_transition_buf->get_read_vector(&transvec);
1476 size_t transcount = transvec.len[0] + transvec.len[1];
1477 bool have_start = false;
1480 for (ti=0; ti < transcount; ++ti) {
1481 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1483 if (captrans.type == CaptureStart) {
1484 // by definition, the first data we got above represents the given capture pos
1486 (*chan)->write_source->mark_capture_start (captrans.capture_val);
1487 (*chan)->curr_capture_cnt = 0;
1491 else if (captrans.type == CaptureEnd) {
1493 // capture end, the capture_val represents total frames in capture
1495 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
1497 // shorten to make the write a perfect fit
1498 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
1500 if (nto_write < to_write) {
1501 ret = 1; // should we?
1503 to_write = nto_write;
1505 (*chan)->write_source->mark_capture_end ();
1507 // increment past this transition, but go no further
1512 // actually ends just beyond this chunk, so force more work
1520 (*chan)->capture_transition_buf->increment_read_ptr(ti);
1524 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
1525 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1529 (*chan)->capture_buf->increment_read_ptr (to_write);
1530 (*chan)->curr_capture_cnt += to_write;
1532 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1534 /* we wrote all of vector.len[0] but it wasn't an entire
1535 disk_io_chunk_frames of data, so arrange for some part
1536 of vector.len[1] to be flushed to disk as well.
1539 to_write = min ((nframes_t)(disk_io_chunk_frames - to_write), (nframes_t) vector.len[1]);
1541 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1542 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1546 _write_data_count += (*chan)->write_source->write_data_count();
1548 (*chan)->capture_buf->increment_read_ptr (to_write);
1549 (*chan)->curr_capture_cnt += to_write;
1558 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1560 uint32_t buffer_position;
1561 bool more_work = true;
1563 boost::shared_ptr<AudioRegion> region;
1564 nframes_t total_capture;
1566 SourceList::iterator src;
1567 ChannelList::iterator chan;
1568 vector<CaptureInfo*>::iterator ci;
1569 boost::shared_ptr<ChannelList> c = channels.reader();
1571 bool mark_write_completed = false;
1573 finish_capture (true, c);
1575 /* butler is already stopped, but there may be work to do
1576 to flush remaining data to disk.
1579 while (more_work && !err) {
1580 switch (do_flush (TransportContext, true)) {
1587 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1592 /* XXX is there anything we can do if err != 0 ? */
1593 Glib::Mutex::Lock lm (capture_info_lock);
1595 if (capture_info.empty()) {
1599 if (abort_capture) {
1601 if (destructive()) {
1605 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1607 if ((*chan)->write_source) {
1609 (*chan)->write_source->mark_for_remove ();
1610 (*chan)->write_source->drop_references ();
1611 (*chan)->write_source.reset ();
1614 /* new source set up in "out" below */
1620 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1621 total_capture += (*ci)->frames;
1624 /* figure out the name for this take */
1626 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1628 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1632 s->update_header (capture_info.front()->start, when, twhen);
1633 s->set_captured_for (_name);
1634 s->mark_immutable ();
1635 if (Config->get_auto_analyse_audio()) {
1636 Analyser::queue_source_for_analysis (s, true);
1641 /* destructive tracks have a single, never changing region */
1643 if (destructive()) {
1645 /* send a signal that any UI can pick up to do the right thing. there is
1646 a small problem here in that a UI may need the peak data to be ready
1647 for the data that was recorded and this isn't interlocked with that
1648 process. this problem is deferred to the UI.
1651 _playlist->Modified();
1655 string whole_file_region_name;
1656 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1658 /* Register a new region with the Session that
1659 describes the entire source. Do this first
1660 so that any sub-regions will obviously be
1661 children of this one (later!)
1665 boost::shared_ptr<Region> rx (RegionFactory::create (srcs,
1666 c->front()->write_source->last_capture_start_frame(), total_capture,
1667 whole_file_region_name, 0,
1668 Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
1670 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1671 region->special_set_position (capture_info.front()->start);
1675 catch (failed_constructor& err) {
1676 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1680 _last_capture_regions.push_back (region);
1682 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1684 XMLNode &before = _playlist->get_state();
1685 _playlist->freeze ();
1687 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1691 _session.region_name (region_name, whole_file_region_name, false);
1693 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add region " << region_name << endl;
1696 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
1697 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1700 catch (failed_constructor& err) {
1701 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1702 continue; /* XXX is this OK? */
1705 region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
1707 _last_capture_regions.push_back (region);
1709 i_am_the_modifier++;
1710 _playlist->add_region (region, (*ci)->start, 1, non_layered());
1711 i_am_the_modifier--;
1713 buffer_position += (*ci)->frames;
1717 XMLNode &after = _playlist->get_state();
1718 _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
1721 mark_write_completed = true;
1724 reset_write_sources (mark_write_completed);
1728 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1732 capture_info.clear ();
1733 capture_start_frame = 0;
1737 AudioDiskstream::transport_looped (nframes_t transport_frame)
1739 if (was_recording) {
1740 // all we need to do is finish this capture, with modified capture length
1741 boost::shared_ptr<ChannelList> c = channels.reader();
1743 // adjust the capture length knowing that the data will be recorded to disk
1744 // only necessary after the first loop where we're recording
1745 if (capture_info.size() == 0) {
1746 capture_captured += _capture_offset;
1748 if (_alignment_style == ExistingMaterial) {
1749 capture_captured += _session.worst_output_latency();
1751 capture_captured += _roll_delay;
1755 finish_capture (true, c);
1757 // the next region will start recording via the normal mechanism
1758 // we'll set the start position to the current transport pos
1759 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1760 capture_start_frame = transport_frame;
1761 first_recordable_frame = transport_frame; // mild lie
1762 last_recordable_frame = max_frames;
1763 was_recording = true;
1765 if (recordable() && destructive()) {
1766 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1768 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1769 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1771 if (transvec.len[0] > 0) {
1772 transvec.buf[0]->type = CaptureStart;
1773 transvec.buf[0]->capture_val = capture_start_frame;
1774 (*chan)->capture_transition_buf->increment_write_ptr(1);
1778 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1788 AudioDiskstream::finish_capture (bool rec_monitors_input, boost::shared_ptr<ChannelList> c)
1790 was_recording = false;
1792 if (capture_captured == 0) {
1796 if (recordable() && destructive()) {
1797 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1799 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1800 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1802 if (transvec.len[0] > 0) {
1803 transvec.buf[0]->type = CaptureEnd;
1804 transvec.buf[0]->capture_val = capture_captured;
1805 (*chan)->capture_transition_buf->increment_write_ptr(1);
1809 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1815 CaptureInfo* ci = new CaptureInfo;
1817 ci->start = capture_start_frame;
1818 ci->frames = capture_captured;
1820 /* XXX theoretical race condition here. Need atomic exchange ?
1821 However, the circumstances when this is called right
1822 now (either on record-disable or transport_stopped)
1823 mean that no actual race exists. I think ...
1824 We now have a capture_info_lock, but it is only to be used
1825 to synchronize in the transport_stop and the capture info
1826 accessors, so that invalidation will not occur (both non-realtime).
1829 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1831 capture_info.push_back (ci);
1832 capture_captured = 0;
1834 /* now we've finished a capture, reset first_recordable_frame for next time */
1835 first_recordable_frame = max_frames;
1839 AudioDiskstream::set_record_enabled (bool yn)
1841 if (!recordable() || !_session.record_enabling_legal() || _io->n_ports().n_audio() == 0) {
1845 /* can't rec-enable in destructive mode if transport is before start */
1847 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
1851 if (yn && channels.reader()->front()->source == 0) {
1853 /* pick up connections not initiated *from* the IO object
1854 we're associated with.
1857 get_input_sources ();
1860 /* yes, i know that this not proof against race conditions, but its
1861 good enough. i think.
1864 if (record_enabled() != yn) {
1866 engage_record_enable ();
1868 disengage_record_enable ();
1874 AudioDiskstream::engage_record_enable ()
1876 bool rolling = _session.transport_speed() != 0.0f;
1877 boost::shared_ptr<ChannelList> c = channels.reader();
1879 g_atomic_int_set (&_record_enabled, 1);
1880 capturing_sources.clear ();
1882 if (Config->get_monitoring_model() == HardwareMonitoring) {
1884 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1885 if ((*chan)->source) {
1886 (*chan)->source->ensure_monitor_input (!(_session.config.get_auto_input() && rolling));
1888 capturing_sources.push_back ((*chan)->write_source);
1889 (*chan)->write_source->mark_streaming_write_started ();
1893 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1894 capturing_sources.push_back ((*chan)->write_source);
1895 (*chan)->write_source->mark_streaming_write_started ();
1899 RecordEnableChanged (); /* EMIT SIGNAL */
1903 AudioDiskstream::disengage_record_enable ()
1905 g_atomic_int_set (&_record_enabled, 0);
1906 boost::shared_ptr<ChannelList> c = channels.reader();
1907 if (Config->get_monitoring_model() == HardwareMonitoring) {
1908 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1909 if ((*chan)->source) {
1910 (*chan)->source->ensure_monitor_input (false);
1914 capturing_sources.clear ();
1915 RecordEnableChanged (); /* EMIT SIGNAL */
1919 AudioDiskstream::get_state ()
1921 XMLNode* node = new XMLNode ("AudioDiskstream");
1923 LocaleGuard lg (X_("POSIX"));
1924 boost::shared_ptr<ChannelList> c = channels.reader();
1926 node->add_property ("flags", enum_2_string (_flags));
1928 snprintf (buf, sizeof(buf), "%zd", c->size());
1929 node->add_property ("channels", buf);
1931 node->add_property ("playlist", _playlist->name());
1933 snprintf (buf, sizeof(buf), "%.12g", _visible_speed);
1934 node->add_property ("speed", buf);
1936 node->add_property("name", _name);
1937 id().print (buf, sizeof (buf));
1938 node->add_property("id", buf);
1940 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1942 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1943 XMLNode* cs_grandchild;
1945 for (vector<boost::shared_ptr<AudioFileSource> >::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1946 cs_grandchild = new XMLNode (X_("file"));
1947 cs_grandchild->add_property (X_("path"), (*i)->path());
1948 cs_child->add_child_nocopy (*cs_grandchild);
1951 /* store the location where capture will start */
1955 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1956 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1958 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
1961 cs_child->add_property (X_("at"), buf);
1962 node->add_child_nocopy (*cs_child);
1966 node->add_child_copy (*_extra_xml);
1973 AudioDiskstream::set_state (const XMLNode& node)
1975 const XMLProperty* prop;
1976 XMLNodeList nlist = node.children();
1977 XMLNodeIterator niter;
1978 uint32_t nchans = 1;
1979 XMLNode* capture_pending_node = 0;
1980 LocaleGuard lg (X_("POSIX"));
1982 in_set_state = true;
1984 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1985 if ((*niter)->name() == IO::state_node_name) {
1986 deprecated_io_node = new XMLNode (**niter);
1989 if ((*niter)->name() == X_("CapturingSources")) {
1990 capture_pending_node = *niter;
1994 /* prevent write sources from being created */
1996 in_set_state = true;
1998 if ((prop = node.property ("name")) != 0) {
1999 _name = prop->value();
2002 if (deprecated_io_node) {
2003 if ((prop = deprecated_io_node->property ("id")) != 0) {
2004 _id = prop->value ();
2007 if ((prop = node.property ("id")) != 0) {
2008 _id = prop->value ();
2012 if ((prop = node.property ("flags")) != 0) {
2013 _flags = Flag (string_2_enum (prop->value(), _flags));
2016 if ((prop = node.property ("channels")) != 0) {
2017 nchans = atoi (prop->value().c_str());
2020 // create necessary extra channels
2021 // we are always constructed with one and we always need one
2023 _n_channels.set(DataType::AUDIO, channels.reader()->size());
2025 if (nchans > _n_channels.n_audio()) {
2027 add_channel (nchans - _n_channels.n_audio());
2028 IO::PortCountChanged(_n_channels);
2030 } else if (nchans < _n_channels.n_audio()) {
2032 remove_channel (_n_channels.n_audio() - nchans);
2035 if ((prop = node.property ("playlist")) == 0) {
2040 bool had_playlist = (_playlist != 0);
2042 if (find_and_use_playlist (prop->value())) {
2046 if (!had_playlist) {
2047 _playlist->set_orig_diskstream_id (_id);
2050 if (!destructive() && capture_pending_node) {
2051 /* destructive streams have one and only one source per channel,
2052 and so they never end up in pending capture in any useful
2055 use_pending_capture_data (*capture_pending_node);
2060 if ((prop = node.property ("speed")) != 0) {
2061 double sp = atof (prop->value().c_str());
2063 if (realtime_set_speed (sp, false)) {
2064 non_realtime_set_speed ();
2068 in_set_state = false;
2070 /* make sure this is clear before we do anything else */
2072 capturing_sources.clear ();
2074 /* write sources are handled when we handle the input set
2075 up of the IO that owns this DS (::non_realtime_input_change())
2082 AudioDiskstream::use_new_write_source (uint32_t n)
2084 boost::shared_ptr<ChannelList> c = channels.reader();
2086 if (!recordable()) {
2090 if (n >= c->size()) {
2091 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2095 ChannelInfo* chan = (*c)[n];
2097 if (chan->write_source) {
2098 chan->write_source->done_with_peakfile_writes ();
2099 chan->write_source->set_allow_remove_if_empty (true);
2100 chan->write_source.reset ();
2104 if ((chan->write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2105 throw failed_constructor();
2109 catch (failed_constructor &err) {
2110 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2111 chan->write_source.reset ();
2115 /* do not remove destructive files even if they are empty */
2117 chan->write_source->set_allow_remove_if_empty (!destructive());
2123 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2125 ChannelList::iterator chan;
2126 boost::shared_ptr<ChannelList> c = channels.reader();
2129 if (!recordable()) {
2133 capturing_sources.clear ();
2135 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2136 if (!destructive()) {
2138 if ((*chan)->write_source && mark_write_complete) {
2139 (*chan)->write_source->mark_streaming_write_completed ();
2141 use_new_write_source (n);
2143 if (record_enabled()) {
2144 capturing_sources.push_back ((*chan)->write_source);
2148 if ((*chan)->write_source == 0) {
2149 use_new_write_source (n);
2154 if (destructive()) {
2156 /* we now have all our write sources set up, so create the
2157 playlist's single region.
2160 if (_playlist->empty()) {
2161 setup_destructive_playlist ();
2167 AudioDiskstream::rename_write_sources ()
2169 ChannelList::iterator chan;
2170 boost::shared_ptr<ChannelList> c = channels.reader();
2173 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
2174 if ((*chan)->write_source != 0) {
2175 (*chan)->write_source->set_source_name (_name, destructive());
2176 /* XXX what to do if one of them fails ? */
2184 AudioDiskstream::set_block_size (nframes_t nframes)
2186 if (_session.get_block_size() > speed_buffer_size) {
2187 speed_buffer_size = _session.get_block_size();
2188 boost::shared_ptr<ChannelList> c = channels.reader();
2190 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2191 if ((*chan)->speed_buffer)
2192 delete [] (*chan)->speed_buffer;
2193 (*chan)->speed_buffer = new Sample[speed_buffer_size];
2196 allocate_temporary_buffers ();
2200 AudioDiskstream::allocate_temporary_buffers ()
2202 /* make sure the wrap buffer is at least large enough to deal
2203 with the speeds up to 1.2, to allow for micro-variation
2204 when slaving to MTC, SMPTE etc.
2207 double sp = max (fabsf (_actual_speed), 1.2f);
2208 nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * sp) + 1;
2210 if (required_wrap_size > wrap_buffer_size) {
2212 boost::shared_ptr<ChannelList> c = channels.reader();
2214 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2215 if ((*chan)->playback_wrap_buffer)
2216 delete [] (*chan)->playback_wrap_buffer;
2217 (*chan)->playback_wrap_buffer = new Sample[required_wrap_size];
2218 if ((*chan)->capture_wrap_buffer)
2219 delete [] (*chan)->capture_wrap_buffer;
2220 (*chan)->capture_wrap_buffer = new Sample[required_wrap_size];
2223 wrap_buffer_size = required_wrap_size;
2228 AudioDiskstream::monitor_input (bool yn)
2230 boost::shared_ptr<ChannelList> c = channels.reader();
2232 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2234 if ((*chan)->source) {
2235 (*chan)->source->ensure_monitor_input (yn);
2241 AudioDiskstream::set_align_style_from_io ()
2243 bool have_physical = false;
2249 get_input_sources ();
2251 boost::shared_ptr<ChannelList> c = channels.reader();
2253 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
2254 if ((*chan)->source && (*chan)->source->flags() & JackPortIsPhysical) {
2255 have_physical = true;
2260 if (have_physical) {
2261 set_align_style (ExistingMaterial);
2263 set_align_style (CaptureTime);
2268 AudioDiskstream::add_channel_to (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2271 while (how_many--) {
2272 c->push_back (new ChannelInfo(_session.audio_diskstream_buffer_size(), speed_buffer_size, wrap_buffer_size));
2273 interpolation.add_channel_to (_session.audio_diskstream_buffer_size(), speed_buffer_size);
2276 _n_channels.set(DataType::AUDIO, c->size());
2282 AudioDiskstream::add_channel (uint32_t how_many)
2284 RCUWriter<ChannelList> writer (channels);
2285 boost::shared_ptr<ChannelList> c = writer.get_copy();
2287 return add_channel_to (c, how_many);
2291 AudioDiskstream::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
2293 while (how_many-- && !c->empty()) {
2294 // FIXME: crash (thread safe with RCU?)
2295 // memory leak, when disabled.... :(
2298 interpolation.remove_channel_from ();
2301 _n_channels.set(DataType::AUDIO, c->size());
2307 AudioDiskstream::remove_channel (uint32_t how_many)
2309 RCUWriter<ChannelList> writer (channels);
2310 boost::shared_ptr<ChannelList> c = writer.get_copy();
2312 return remove_channel_from (c, how_many);
2316 AudioDiskstream::playback_buffer_load () const
2318 boost::shared_ptr<ChannelList> c = channels.reader();
2320 return (float) ((double) c->front()->playback_buf->read_space()/
2321 (double) c->front()->playback_buf->bufsize());
2325 AudioDiskstream::capture_buffer_load () const
2327 boost::shared_ptr<ChannelList> c = channels.reader();
2329 return (float) ((double) c->front()->capture_buf->write_space()/
2330 (double) c->front()->capture_buf->bufsize());
2334 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2336 const XMLProperty* prop;
2337 XMLNodeList nlist = node.children();
2338 XMLNodeIterator niter;
2339 boost::shared_ptr<AudioFileSource> fs;
2340 boost::shared_ptr<AudioFileSource> first_fs;
2341 SourceList pending_sources;
2344 if ((prop = node.property (X_("at"))) == 0) {
2348 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2352 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2353 if ((*niter)->name() == X_("file")) {
2355 if ((prop = (*niter)->property (X_("path"))) == 0) {
2359 // This protects sessions from errant CapturingSources in stored sessions
2361 if (stat (prop->value().c_str(), &sbuf)) {
2366 fs = boost::dynamic_pointer_cast<AudioFileSource> (
2367 SourceFactory::createWritable (DataType::AUDIO, _session,
2368 prop->value(), true,
2369 false, _session.frame_rate()));
2372 catch (failed_constructor& err) {
2373 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2374 _name, prop->value())
2379 pending_sources.push_back (fs);
2381 if (first_fs == 0) {
2385 fs->set_captured_for (_name);
2389 if (pending_sources.size() == 0) {
2390 /* nothing can be done */
2394 if (pending_sources.size() != _n_channels.n_audio()) {
2395 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2400 boost::shared_ptr<AudioRegion> region;
2403 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
2404 pending_sources, 0, first_fs->length(first_fs->timeline_position()),
2405 region_name_from_path (first_fs->name(), true), 0,
2406 Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
2407 region->special_set_position (0);
2410 catch (failed_constructor& err) {
2411 error << string_compose (
2412 _("%1: cannot create whole-file region from pending capture sources"),
2419 region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
2420 pending_sources, 0, first_fs->length(first_fs->timeline_position()),
2421 region_name_from_path (first_fs->name(), true)));
2424 catch (failed_constructor& err) {
2425 error << string_compose (_("%1: cannot create region from pending capture sources"),
2432 _playlist->add_region (region, position);
2438 AudioDiskstream::set_non_layered (bool yn)
2440 if (yn != non_layered()) {
2443 _flags = Flag (_flags | NonLayered);
2445 _flags = Flag (_flags & ~NonLayered);
2453 AudioDiskstream::set_destructive (bool yn)
2455 bool bounce_ignored;
2457 if (yn != destructive()) {
2460 /* requestor should already have checked this and
2461 bounced if necessary and desired
2463 if (!can_become_destructive (bounce_ignored)) {
2466 _flags = Flag (_flags | Destructive);
2467 use_destructive_playlist ();
2469 _flags = Flag (_flags & ~Destructive);
2470 reset_write_sources (true, true);
2478 AudioDiskstream::can_become_destructive (bool& requires_bounce) const
2481 requires_bounce = false;
2485 /* is there only one region ? */
2487 if (_playlist->n_regions() != 1) {
2488 requires_bounce = true;
2492 boost::shared_ptr<Region> first = _playlist->find_next_region (_session.current_start_frame(), Start, 1);
2495 /* do the source(s) for the region cover the session start position ? */
2497 if (first->position() != _session.current_start_frame()) {
2498 if (first->start() > _session.current_start_frame()) {
2499 requires_bounce = true;
2504 /* is the source used by only 1 playlist ? */
2506 boost::shared_ptr<AudioRegion> afirst = boost::dynamic_pointer_cast<AudioRegion> (first);
2510 if (afirst->source()->used() > 1) {
2511 requires_bounce = true;
2515 requires_bounce = false;
2519 AudioDiskstream::ChannelInfo::ChannelInfo (nframes_t bufsize, nframes_t speed_size, nframes_t wrap_size)
2523 current_capture_buffer = 0;
2524 current_playback_buffer = 0;
2525 curr_capture_cnt = 0;
2527 speed_buffer = new Sample[speed_size];
2528 playback_wrap_buffer = new Sample[wrap_size];
2529 capture_wrap_buffer = new Sample[wrap_size];
2531 playback_buf = new RingBufferNPT<Sample> (bufsize);
2532 capture_buf = new RingBufferNPT<Sample> (bufsize);
2533 capture_transition_buf = new RingBufferNPT<CaptureTransition> (256);
2535 /* touch the ringbuffer buffers, which will cause
2536 them to be mapped into locked physical RAM if
2537 we're running with mlockall(). this doesn't do
2541 memset (playback_buf->buffer(), 0, sizeof (Sample) * playback_buf->bufsize());
2542 memset (capture_buf->buffer(), 0, sizeof (Sample) * capture_buf->bufsize());
2543 memset (capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * capture_transition_buf->bufsize());
2546 AudioDiskstream::ChannelInfo::~ChannelInfo ()
2549 write_source.reset ();
2552 delete [] speed_buffer;
2555 delete [] playback_wrap_buffer;
2556 playback_wrap_buffer = 0;
2558 delete [] capture_wrap_buffer;
2559 capture_wrap_buffer = 0;
2561 delete playback_buf;
2567 delete capture_transition_buf;
2568 capture_transition_buf = 0;