2 Copyright (C) 2000-2003 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.
18 $Id: diskstream.cc 567 2006-06-07 14:54:12Z trutkin $
34 #include <pbd/error.h>
35 #include <pbd/basename.h>
36 #include <glibmm/thread.h>
37 #include <pbd/xml++.h>
39 #include <ardour/ardour.h>
40 #include <ardour/audioengine.h>
41 #include <ardour/audio_diskstream.h>
42 #include <ardour/utils.h>
43 #include <ardour/configuration.h>
44 #include <ardour/audiofilesource.h>
45 #include <ardour/destructive_filesource.h>
46 #include <ardour/send.h>
47 #include <ardour/audioplaylist.h>
48 #include <ardour/cycle_timer.h>
49 #include <ardour/audioregion.h>
55 using namespace ARDOUR;
58 jack_nframes_t AudioDiskstream::disk_io_chunk_frames;
60 sigc::signal<void,AudioDiskstream*> AudioDiskstream::AudioDiskstreamCreated;
61 sigc::signal<void,list<AudioFileSource*>*> AudioDiskstream::DeleteSources;
62 sigc::signal<void> AudioDiskstream::DiskOverrun;
63 sigc::signal<void> AudioDiskstream::DiskUnderrun;
65 AudioDiskstream::AudioDiskstream (Session &sess, const string &name, Flag flag)
69 /* prevent any write sources from being created */
78 AudioDiskstreamCreated (this); /* EMIT SIGNAL */
81 AudioDiskstream::AudioDiskstream (Session& sess, const XMLNode& node)
88 if (set_state (node)) {
90 throw failed_constructor();
96 use_destructive_playlist ();
99 AudioDiskstreamCreated (this); /* EMIT SIGNAL */
103 AudioDiskstream::init_channel (ChannelInfo &chan)
105 chan.playback_wrap_buffer = 0;
106 chan.capture_wrap_buffer = 0;
107 chan.speed_buffer = 0;
108 chan.peak_power = 0.0f;
109 chan.write_source = 0;
111 chan.current_capture_buffer = 0;
112 chan.current_playback_buffer = 0;
113 chan.curr_capture_cnt = 0;
115 chan.playback_buf = new RingBufferNPT<Sample> (_session.diskstream_buffer_size());
116 chan.capture_buf = new RingBufferNPT<Sample> (_session.diskstream_buffer_size());
117 chan.capture_transition_buf = new RingBufferNPT<CaptureTransition> (128);
120 /* touch the ringbuffer buffers, which will cause
121 them to be mapped into locked physical RAM if
122 we're running with mlockall(). this doesn't do
125 memset (chan.playback_buf->buffer(), 0, sizeof (Sample) * chan.playback_buf->bufsize());
126 memset (chan.capture_buf->buffer(), 0, sizeof (Sample) * chan.capture_buf->bufsize());
127 memset (chan.capture_transition_buf->buffer(), 0, sizeof (CaptureTransition) * chan.capture_transition_buf->bufsize());
132 AudioDiskstream::init (Flag f)
138 _alignment_style = ExistingMaterial;
139 _persistent_alignment_style = ExistingMaterial;
140 first_input_change = true;
142 i_am_the_modifier = 0;
143 g_atomic_int_set (&_record_enabled, 0);
144 was_recording = false;
145 capture_start_frame = 0;
146 capture_captured = 0;
147 _visible_speed = 1.0f;
148 _actual_speed = 1.0f;
149 _buffer_reallocation_required = false;
150 _seek_required = false;
151 first_recordable_frame = max_frames;
152 last_recordable_frame = max_frames;
157 adjust_capture_position = 0;
158 last_possibly_recording = 0;
160 wrap_buffer_size = 0;
161 speed_buffer_size = 0;
163 phi = (uint64_t) (0x1000000);
166 playback_distance = 0;
167 _read_data_count = 0;
168 _write_data_count = 0;
169 deprecated_io_node = 0;
171 /* there are no channels at this point, so these
172 two calls just get speed_buffer_size and wrap_buffer
173 size setup without duplicating their code.
176 set_block_size (_session.get_block_size());
177 allocate_temporary_buffers ();
179 pending_overwrite = false;
181 overwrite_queued = false;
182 input_change_pending = NoChange;
189 AudioDiskstream::destroy_channel (ChannelInfo &chan)
191 if (chan.write_source) {
192 chan.write_source->release ();
193 chan.write_source = 0;
196 if (chan.speed_buffer) {
197 delete [] chan.speed_buffer;
200 if (chan.playback_wrap_buffer) {
201 delete [] chan.playback_wrap_buffer;
203 if (chan.capture_wrap_buffer) {
204 delete [] chan.capture_wrap_buffer;
207 delete chan.playback_buf;
208 delete chan.capture_buf;
209 delete chan.capture_transition_buf;
211 chan.playback_buf = 0;
212 chan.capture_buf = 0;
215 AudioDiskstream::~AudioDiskstream ()
217 Glib::Mutex::Lock lm (state_lock);
223 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
224 destroy_channel((*chan));
231 AudioDiskstream::handle_input_change (IOChange change, void *src)
233 Glib::Mutex::Lock lm (state_lock);
235 if (!(input_change_pending & change)) {
236 input_change_pending = IOChange (input_change_pending|change);
237 _session.request_input_change_handling ();
242 AudioDiskstream::non_realtime_input_change ()
245 Glib::Mutex::Lock lm (state_lock);
247 if (input_change_pending == NoChange) {
251 if (input_change_pending & ConfigurationChanged) {
253 if (_io->n_inputs() > _n_channels) {
255 // we need to add new channel infos
257 int diff = _io->n_inputs() - channels.size();
259 for (int i = 0; i < diff; ++i) {
263 } else if (_io->n_inputs() < _n_channels) {
265 // we need to get rid of channels
267 int diff = channels.size() - _io->n_inputs();
269 for (int i = 0; i < diff; ++i) {
275 get_input_sources ();
276 set_capture_offset ();
278 if (first_input_change) {
279 set_align_style (_persistent_alignment_style);
280 first_input_change = false;
282 set_align_style_from_io ();
285 input_change_pending = NoChange;
288 /* reset capture files */
290 reset_write_sources (false);
292 /* now refill channel buffers */
294 if (speed() != 1.0f || speed() != -1.0f) {
295 seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()));
298 seek (_session.transport_frame());
303 AudioDiskstream::get_input_sources ()
305 uint32_t ni = _io->n_inputs();
307 for (uint32_t n = 0; n < ni; ++n) {
309 const char **connections = _io->input(n)->get_connections ();
310 ChannelInfo& chan = channels[n];
312 if (connections == 0 || connections[0] == 0) {
315 // _source->disable_metering ();
321 chan.source = _session.engine().get_port_by_name (connections[0]);
331 AudioDiskstream::find_and_use_playlist (const string& name)
334 AudioPlaylist* playlist;
336 if ((pl = _session.get_playlist (name)) == 0) {
337 error << string_compose(_("AudioDiskstream: Session doesn't know about a Playlist called \"%1\""), name) << endmsg;
341 if ((playlist = dynamic_cast<AudioPlaylist*> (pl)) == 0) {
342 error << string_compose(_("AudioDiskstream: Playlist \"%1\" isn't an audio playlist"), name) << endmsg;
346 return use_playlist (playlist);
350 AudioDiskstream::use_playlist (AudioPlaylist* playlist)
353 Glib::Mutex::Lock lm (state_lock);
355 if (playlist == _playlist) {
359 plstate_connection.disconnect();
360 plmod_connection.disconnect ();
361 plgone_connection.disconnect ();
367 _playlist = playlist;
370 if (!in_set_state && recordable()) {
371 reset_write_sources (false);
374 plstate_connection = _playlist->StateChanged.connect (mem_fun (*this, &AudioDiskstream::playlist_changed));
375 plmod_connection = _playlist->Modified.connect (mem_fun (*this, &AudioDiskstream::playlist_modified));
376 plgone_connection = _playlist->GoingAway.connect (mem_fun (*this, &AudioDiskstream::playlist_deleted));
379 if (!overwrite_queued) {
380 _session.request_overwrite_buffer (this);
381 overwrite_queued = true;
384 PlaylistChanged (); /* EMIT SIGNAL */
385 _session.set_dirty ();
391 AudioDiskstream::playlist_deleted (Playlist* pl)
393 /* this catches an ordering issue with session destruction. playlists
394 are destroyed before diskstreams. we have to invalidate any handles
395 we have to the playlist.
402 AudioDiskstream::use_new_playlist ()
405 AudioPlaylist* playlist;
407 if (!in_set_state && destructive()) {
412 newname = Playlist::bump_name (_playlist->name(), _session);
414 newname = Playlist::bump_name (_name, _session);
417 if ((playlist = new AudioPlaylist (_session, newname, hidden())) != 0) {
418 playlist->set_orig_diskstream_id (id());
419 return use_playlist (playlist);
426 AudioDiskstream::use_copy_playlist ()
432 if (_playlist == 0) {
433 error << string_compose(_("AudioDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
438 AudioPlaylist* playlist;
440 newname = Playlist::bump_name (_playlist->name(), _session);
442 if ((playlist = new AudioPlaylist (*_playlist, newname)) != 0) {
443 playlist->set_orig_diskstream_id (id());
444 return use_playlist (playlist);
451 AudioDiskstream::setup_destructive_playlist ()
453 AudioRegion::SourceList srcs;
455 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
456 srcs.push_back ((*chan).write_source);
459 /* a single full-sized region */
461 AudioRegion* region = new AudioRegion (srcs, 0, max_frames, _name);
462 _playlist->add_region (*region, 0);
466 AudioDiskstream::use_destructive_playlist ()
468 /* use the sources associated with the single full-extent region */
470 Playlist::RegionList* rl = _playlist->regions_at (0);
473 reset_write_sources (false, true);
477 AudioRegion* region = dynamic_cast<AudioRegion*> (rl->front());
480 throw failed_constructor();
486 ChannelList::iterator chan;
488 for (n = 0, chan = channels.begin(); chan != channels.end(); ++chan, ++n) {
489 (*chan).write_source = dynamic_cast<AudioFileSource*>(®ion->source (n));
490 (*chan).write_source->set_allow_remove_if_empty (false);
493 /* the source list will never be reset for a destructive track */
497 AudioDiskstream::set_io (IO& io)
500 set_align_style_from_io ();
504 AudioDiskstream::set_name (string str, void *src)
507 _playlist->set_name (str);
510 if (!in_set_state && recordable()) {
511 /* rename existing capture files so that they have the correct name */
512 return rename_write_sources ();
522 AudioDiskstream::set_speed (double sp)
524 _session.request_diskstream_speed (*this, sp);
526 /* to force a rebuffering at the right place */
531 AudioDiskstream::realtime_set_speed (double sp, bool global)
533 bool changed = false;
534 double new_speed = sp * _session.transport_speed();
536 if (_visible_speed != sp) {
541 if (new_speed != _actual_speed) {
543 jack_nframes_t required_wrap_size = (jack_nframes_t) floor (_session.get_block_size() *
544 fabs (new_speed)) + 1;
546 if (required_wrap_size > wrap_buffer_size) {
547 _buffer_reallocation_required = true;
550 _actual_speed = new_speed;
551 phi = (uint64_t) (0x1000000 * fabs(_actual_speed));
556 _seek_required = true;
558 speed_changed (); /* EMIT SIGNAL */
561 return _buffer_reallocation_required || _seek_required;
565 AudioDiskstream::non_realtime_set_speed ()
567 if (_buffer_reallocation_required)
569 Glib::Mutex::Lock lm (state_lock);
570 allocate_temporary_buffers ();
572 _buffer_reallocation_required = false;
575 if (_seek_required) {
576 if (speed() != 1.0f || speed() != -1.0f) {
577 seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()), true);
580 seek (_session.transport_frame(), true);
583 _seek_required = false;
588 AudioDiskstream::prepare ()
591 playback_distance = 0;
595 AudioDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
597 int possibly_recording;
600 const int transport_rolling = 0x4;
601 const int track_rec_enabled = 0x2;
602 const int global_rec_enabled = 0x1;
604 /* merge together the 3 factors that affect record status, and compute
608 rolling = _session.transport_speed() != 0.0f;
609 possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
610 change = possibly_recording ^ last_possibly_recording;
612 if (possibly_recording == last_possibly_recording) {
618 /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
620 if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) ||
621 ((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
623 /* starting to record: compute first+last frames */
625 first_recordable_frame = transport_frame + _capture_offset;
626 last_recordable_frame = max_frames;
627 capture_start_frame = transport_frame;
629 if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
631 /* was stopped, now rolling (and recording) */
633 if (_alignment_style == ExistingMaterial) {
634 first_recordable_frame += _session.worst_output_latency();
636 first_recordable_frame += _roll_delay;
641 /* was rolling, but record state changed */
643 if (_alignment_style == ExistingMaterial) {
646 if (!_session.get_punch_in()) {
648 /* manual punch in happens at the correct transport frame
649 because the user hit a button. but to get alignment correct
650 we have to back up the position of the new region to the
651 appropriate spot given the roll delay.
654 capture_start_frame -= _roll_delay;
656 /* XXX paul notes (august 2005): i don't know why
660 first_recordable_frame += _capture_offset;
664 /* autopunch toggles recording at the precise
665 transport frame, and then the DS waits
666 to start recording for a time that depends
667 on the output latency.
670 first_recordable_frame += _session.worst_output_latency();
675 if (_session.get_punch_in()) {
676 first_recordable_frame += _roll_delay;
678 capture_start_frame -= _roll_delay;
684 if (_flags & Recordable) {
685 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
687 RingBufferNPT<CaptureTransition>::rw_vector transvec;
688 (*chan).capture_transition_buf->get_write_vector(&transvec);
690 if (transvec.len[0] > 0) {
691 transvec.buf[0]->type = CaptureStart;
692 transvec.buf[0]->capture_val = capture_start_frame;
693 (*chan).capture_transition_buf->increment_write_ptr(1);
697 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
703 } else if (!record_enabled() || !can_record) {
707 last_recordable_frame = transport_frame + _capture_offset;
709 if (_alignment_style == ExistingMaterial) {
710 last_recordable_frame += _session.worst_output_latency();
712 last_recordable_frame += _roll_delay;
716 last_possibly_recording = possibly_recording;
720 AudioDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input)
723 ChannelList::iterator c;
725 jack_nframes_t rec_offset = 0;
726 jack_nframes_t rec_nframes = 0;
727 bool nominally_recording;
728 bool re = record_enabled ();
729 bool collect_playback = false;
731 /* if we've already processed the frames corresponding to this call,
732 just return. this allows multiple routes that are taking input
733 from this diskstream to call our ::process() method, but have
734 this stuff only happen once. more commonly, it allows both
735 the AudioTrack that is using this AudioDiskstream *and* the Session
736 to call process() without problems.
743 check_record_status (transport_frame, nframes, can_record);
745 nominally_recording = (can_record && re);
752 /* This lock is held until the end of AudioDiskstream::commit, so these two functions
753 must always be called as a pair. The only exception is if this function
754 returns a non-zero value, in which case, ::commit should not be called.
757 // If we can't take the state lock return.
758 if (!state_lock.trylock()) {
762 adjust_capture_position = 0;
764 for (c = channels.begin(); c != channels.end(); ++c) {
765 (*c).current_capture_buffer = 0;
766 (*c).current_playback_buffer = 0;
769 if (nominally_recording || (_session.get_record_enabled() && _session.get_punch_in())) {
772 ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
779 case OverlapInternal:
780 /* ---------- recrange
783 rec_nframes = nframes;
788 /* |--------| recrange
791 rec_nframes = transport_frame + nframes - first_recordable_frame;
793 rec_offset = first_recordable_frame - transport_frame;
798 /* |--------| recrange
801 rec_nframes = last_recordable_frame - transport_frame;
805 case OverlapExternal:
806 /* |--------| recrange
807 -------------- transrange
809 rec_nframes = last_recordable_frame - last_recordable_frame;
810 rec_offset = first_recordable_frame - transport_frame;
814 if (rec_nframes && !was_recording) {
815 capture_captured = 0;
816 was_recording = true;
821 if (can_record && !_last_capture_regions.empty()) {
822 _last_capture_regions.clear ();
825 if (nominally_recording || rec_nframes) {
827 for (n = 0, c = channels.begin(); c != channels.end(); ++c, ++n) {
829 ChannelInfo& chan (*c);
831 chan.capture_buf->get_write_vector (&chan.capture_vector);
833 if (rec_nframes <= chan.capture_vector.len[0]) {
835 chan.current_capture_buffer = chan.capture_vector.buf[0];
837 /* note: grab the entire port buffer, but only copy what we were supposed to for recording, and use
841 memcpy (chan.current_capture_buffer, _io->input(n)->get_buffer (rec_nframes) + offset + rec_offset, sizeof (Sample) * rec_nframes);
845 jack_nframes_t total = chan.capture_vector.len[0] + chan.capture_vector.len[1];
847 if (rec_nframes > total) {
852 Sample* buf = _io->input (n)->get_buffer (nframes) + offset;
853 jack_nframes_t first = chan.capture_vector.len[0];
855 memcpy (chan.capture_wrap_buffer, buf, sizeof (Sample) * first);
856 memcpy (chan.capture_vector.buf[0], buf, sizeof (Sample) * first);
857 memcpy (chan.capture_wrap_buffer+first, buf + first, sizeof (Sample) * (rec_nframes - first));
858 memcpy (chan.capture_vector.buf[1], buf + first, sizeof (Sample) * (rec_nframes - first));
860 chan.current_capture_buffer = chan.capture_wrap_buffer;
867 finish_capture (rec_monitors_input);
874 /* data will be written to disk */
876 if (rec_nframes == nframes && rec_offset == 0) {
878 for (c = channels.begin(); c != channels.end(); ++c) {
879 (*c).current_playback_buffer = (*c).current_capture_buffer;
882 playback_distance = nframes;
887 /* we can't use the capture buffer as the playback buffer, because
888 we recorded only a part of the current process' cycle data
892 collect_playback = true;
895 adjust_capture_position = rec_nframes;
897 } else if (nominally_recording) {
899 /* can't do actual capture yet - waiting for latency effects to finish before we start*/
901 for (c = channels.begin(); c != channels.end(); ++c) {
902 (*c).current_playback_buffer = (*c).current_capture_buffer;
905 playback_distance = nframes;
909 collect_playback = true;
912 if (collect_playback) {
914 /* we're doing playback */
916 jack_nframes_t necessary_samples;
918 /* no varispeed playback if we're recording, because the output .... TBD */
920 if (rec_nframes == 0 && _actual_speed != 1.0f) {
921 necessary_samples = (jack_nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
923 necessary_samples = nframes;
926 for (c = channels.begin(); c != channels.end(); ++c) {
927 (*c).playback_buf->get_read_vector (&(*c).playback_vector);
932 for (c = channels.begin(); c != channels.end(); ++c, ++n) {
934 ChannelInfo& chan (*c);
936 if (necessary_samples <= chan.playback_vector.len[0]) {
938 chan.current_playback_buffer = chan.playback_vector.buf[0];
941 jack_nframes_t total = chan.playback_vector.len[0] + chan.playback_vector.len[1];
943 if (necessary_samples > total) {
949 memcpy ((char *) chan.playback_wrap_buffer, chan.playback_vector.buf[0],
950 chan.playback_vector.len[0] * sizeof (Sample));
951 memcpy (chan.playback_wrap_buffer + chan.playback_vector.len[0], chan.playback_vector.buf[1],
952 (necessary_samples - chan.playback_vector.len[0]) * sizeof (Sample));
954 chan.current_playback_buffer = chan.playback_wrap_buffer;
959 if (rec_nframes == 0 && _actual_speed != 1.0f && _actual_speed != -1.0f) {
961 uint64_t phase = last_phase;
962 jack_nframes_t i = 0;
964 // Linearly interpolate into the alt buffer
965 // using 40.24 fixp maths (swh)
967 for (c = channels.begin(); c != channels.end(); ++c) {
970 ChannelInfo& chan (*c);
975 for (jack_nframes_t outsample = 0; outsample < nframes; ++outsample) {
977 fr = (phase & 0xFFFFFF) / 16777216.0f;
978 chan.speed_buffer[outsample] =
979 chan.current_playback_buffer[i] * (1.0f - fr) +
980 chan.current_playback_buffer[i+1] * fr;
984 chan.current_playback_buffer = chan.speed_buffer;
987 playback_distance = i + 1;
988 last_phase = (phase & 0xFFFFFF);
991 playback_distance = nframes;
1003 /* we're exiting with failure, so ::commit will not
1004 be called. unlock the state lock.
1007 state_lock.unlock();
1014 AudioDiskstream::recover ()
1016 state_lock.unlock();
1021 AudioDiskstream::commit (jack_nframes_t nframes)
1023 bool need_butler = false;
1025 if (_actual_speed < 0.0) {
1026 playback_sample -= playback_distance;
1028 playback_sample += playback_distance;
1031 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
1033 (*chan).playback_buf->increment_read_ptr (playback_distance);
1035 if (adjust_capture_position) {
1036 (*chan).capture_buf->increment_write_ptr (adjust_capture_position);
1040 if (adjust_capture_position != 0) {
1041 capture_captured += adjust_capture_position;
1042 adjust_capture_position = 0;
1046 need_butler = channels[0].playback_buf->write_space() >= channels[0].playback_buf->bufsize() / 2;
1048 need_butler = channels[0].playback_buf->write_space() >= disk_io_chunk_frames
1049 || channels[0].capture_buf->read_space() >= disk_io_chunk_frames;
1052 state_lock.unlock();
1060 AudioDiskstream::set_pending_overwrite (bool yn)
1062 /* called from audio thread, so we can use the read ptr and playback sample as we wish */
1064 pending_overwrite = yn;
1066 overwrite_frame = playback_sample;
1067 overwrite_offset = channels.front().playback_buf->get_read_ptr();
1071 AudioDiskstream::overwrite_existing_buffers ()
1073 Sample* mixdown_buffer;
1077 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1079 overwrite_queued = false;
1081 /* assume all are the same size */
1082 jack_nframes_t size = channels[0].playback_buf->bufsize();
1084 mixdown_buffer = new Sample[size];
1085 gain_buffer = new float[size];
1086 workbuf = new char[size*4];
1088 /* reduce size so that we can fill the buffer correctly. */
1092 jack_nframes_t start;
1094 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan, ++n) {
1096 start = overwrite_frame;
1097 jack_nframes_t cnt = size;
1099 /* to fill the buffer without resetting the playback sample, we need to
1100 do it one or two chunks (normally two).
1102 |----------------------------------------------------------------------|
1106 |<- second chunk->||<----------------- first chunk ------------------>|
1110 jack_nframes_t to_read = size - overwrite_offset;
1112 if (read ((*chan).playback_buf->buffer() + overwrite_offset, mixdown_buffer, gain_buffer, workbuf,
1113 start, to_read, *chan, n, reversed)) {
1114 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
1115 _id, size, playback_sample) << endmsg;
1119 if (cnt > to_read) {
1123 if (read ((*chan).playback_buf->buffer(), mixdown_buffer, gain_buffer, workbuf,
1124 start, cnt, *chan, n, reversed)) {
1125 error << string_compose(_("AudioDiskstream %1: when refilling, cannot read %2 from playlist at frame %3"),
1126 _id, size, playback_sample) << endmsg;
1135 pending_overwrite = false;
1136 delete [] gain_buffer;
1137 delete [] mixdown_buffer;
1143 AudioDiskstream::seek (jack_nframes_t frame, bool complete_refill)
1145 Glib::Mutex::Lock lm (state_lock);
1148 ChannelList::iterator chan;
1150 for (n = 0, chan = channels.begin(); chan != channels.end(); ++chan, ++n) {
1151 (*chan).playback_buf->reset ();
1152 (*chan).capture_buf->reset ();
1155 playback_sample = frame;
1158 if (complete_refill) {
1159 while ((ret = do_refill (0, 0, 0)) > 0);
1161 ret = do_refill (0, 0, 0);
1168 AudioDiskstream::can_internal_playback_seek (jack_nframes_t distance)
1170 ChannelList::iterator chan;
1172 for (chan = channels.begin(); chan != channels.end(); ++chan) {
1173 if ((*chan).playback_buf->read_space() < distance) {
1181 AudioDiskstream::internal_playback_seek (jack_nframes_t distance)
1183 ChannelList::iterator chan;
1185 for (chan = channels.begin(); chan != channels.end(); ++chan) {
1186 (*chan).playback_buf->increment_read_ptr (distance);
1189 first_recordable_frame += distance;
1190 playback_sample += distance;
1196 AudioDiskstream::read (Sample* buf, Sample* mixdown_buffer, float* gain_buffer, char * workbuf, jack_nframes_t& start, jack_nframes_t cnt,
1197 ChannelInfo& channel_info, int channel, bool reversed)
1199 jack_nframes_t this_read = 0;
1200 bool reloop = false;
1201 jack_nframes_t loop_end = 0;
1202 jack_nframes_t loop_start = 0;
1203 jack_nframes_t loop_length = 0;
1204 jack_nframes_t offset = 0;
1208 /* Make the use of a Location atomic for this read operation.
1210 Note: Locations don't get deleted, so all we care about
1211 when I say "atomic" is that we are always pointing to
1212 the same one and using a start/length values obtained
1216 if ((loc = loop_location) != 0) {
1217 loop_start = loc->start();
1218 loop_end = loc->end();
1219 loop_length = loop_end - loop_start;
1222 /* if we are looping, ensure that the first frame we read is at the correct
1223 position within the loop.
1226 if (loc && start >= loop_end) {
1227 //cerr << "start adjusted from " << start;
1228 start = loop_start + ((start - loop_start) % loop_length);
1229 //cerr << "to " << start << endl;
1231 //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
1236 /* take any loop into account. we can't read past the end of the loop. */
1238 if (loc && (loop_end - start < cnt)) {
1239 this_read = loop_end - start;
1240 //cerr << "reloop true: thisread: " << this_read << " cnt: " << cnt << endl;
1247 if (this_read == 0) {
1251 this_read = min(cnt,this_read);
1253 if (_playlist->read (buf+offset, mixdown_buffer, gain_buffer, workbuf, start, this_read, channel) != this_read) {
1254 error << string_compose(_("AudioDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
1259 _read_data_count = _playlist->read_data_count();
1263 /* don't adjust start, since caller has already done that
1266 swap_by_ptr (buf, buf + this_read - 1);
1270 /* if we read to the end of the loop, go back to the beginning */
1280 offset += this_read;
1287 AudioDiskstream::do_refill (Sample* mixdown_buffer, float* gain_buffer, char * workbuf)
1290 jack_nframes_t to_read;
1291 RingBufferNPT<Sample>::rw_vector vector;
1295 bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
1296 jack_nframes_t total_space;
1297 jack_nframes_t zero_fill;
1299 ChannelList::iterator i;
1302 channels.front().playback_buf->get_write_vector (&vector);
1304 if ((total_space = vector.len[0] + vector.len[1]) == 0) {
1308 /* if there are 2+ chunks of disk i/o possible for
1309 this track, let the caller know so that it can arrange
1310 for us to be called again, ASAP.
1313 if (total_space >= (_slaved?3:2) * disk_io_chunk_frames) {
1317 /* if we're running close to normal speed and there isn't enough
1318 space to do disk_io_chunk_frames of I/O, then don't bother.
1320 at higher speeds, just do it because the sync between butler
1321 and audio thread may not be good enough.
1324 if ((total_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
1328 /* when slaved, don't try to get too close to the read pointer. this
1329 leaves space for the buffer reversal to have something useful to
1333 if (_slaved && total_space < (channels.front().playback_buf->bufsize() / 2)) {
1337 total_space = min (disk_io_chunk_frames, total_space);
1341 if (file_frame == 0) {
1343 /* at start: nothing to do but fill with silence */
1345 for (chan_n = 0, i = channels.begin(); i != channels.end(); ++i, ++chan_n) {
1347 ChannelInfo& chan (*i);
1348 chan.playback_buf->get_write_vector (&vector);
1349 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1350 if (vector.len[1]) {
1351 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1353 chan.playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1358 if (file_frame < total_space) {
1360 /* too close to the start: read what we can,
1361 and then zero fill the rest
1364 zero_fill = total_space - file_frame;
1365 total_space = file_frame;
1370 /* move read position backwards because we are going
1371 to reverse the data.
1374 file_frame -= total_space;
1380 if (file_frame == max_frames) {
1382 /* at end: nothing to do but fill with silence */
1384 for (chan_n = 0, i = channels.begin(); i != channels.end(); ++i, ++chan_n) {
1386 ChannelInfo& chan (*i);
1387 chan.playback_buf->get_write_vector (&vector);
1388 memset (vector.buf[0], 0, sizeof(Sample) * vector.len[0]);
1389 if (vector.len[1]) {
1390 memset (vector.buf[1], 0, sizeof(Sample) * vector.len[1]);
1392 chan.playback_buf->increment_write_ptr (vector.len[0] + vector.len[1]);
1397 if (file_frame > max_frames - total_space) {
1399 /* to close to the end: read what we can, and zero fill the rest */
1401 zero_fill = total_space - (max_frames - file_frame);
1402 total_space = max_frames - file_frame;
1409 /* Please note: the code to allocate buffers isn't run
1410 during normal butler thread operation. Its there
1411 for other times when we need to call do_refill()
1412 from somewhere other than the butler thread.
1415 if (mixdown_buffer == 0) {
1416 mixdown_buffer = new Sample[disk_io_chunk_frames];
1417 free_mixdown = true;
1419 free_mixdown = false;
1422 if (gain_buffer == 0) {
1423 gain_buffer = new float[disk_io_chunk_frames];
1430 workbuf = new char[disk_io_chunk_frames * 4];
1431 free_workbuf = true;
1433 free_workbuf = false;
1436 jack_nframes_t file_frame_tmp = 0;
1438 for (chan_n = 0, i = channels.begin(); i != channels.end(); ++i, ++chan_n) {
1440 ChannelInfo& chan (*i);
1443 jack_nframes_t len1, len2;
1445 chan.playback_buf->get_write_vector (&vector);
1448 file_frame_tmp = file_frame;
1451 buf1 = vector.buf[1];
1452 len1 = vector.len[1];
1453 buf2 = vector.buf[0];
1454 len2 = vector.len[0];
1456 buf1 = vector.buf[0];
1457 len1 = vector.len[0];
1458 buf2 = vector.buf[1];
1459 len2 = vector.len[1];
1463 to_read = min (ts, len1);
1464 to_read = min (to_read, disk_io_chunk_frames);
1468 if (read (buf1, mixdown_buffer, gain_buffer, workbuf, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1473 chan.playback_buf->increment_write_ptr (to_read);
1477 to_read = min (ts, len2);
1482 /* we read all of vector.len[0], but it wasn't an entire disk_io_chunk_frames of data,
1483 so read some or all of vector.len[1] as well.
1486 if (read (buf2, mixdown_buffer, gain_buffer, workbuf, file_frame_tmp, to_read, chan, chan_n, reversed)) {
1491 chan.playback_buf->increment_write_ptr (to_read);
1500 file_frame = file_frame_tmp;
1504 delete [] mixdown_buffer;
1507 delete [] gain_buffer;
1517 AudioDiskstream::do_flush (char * workbuf, bool force_flush)
1521 RingBufferNPT<Sample>::rw_vector vector;
1522 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1523 jack_nframes_t total;
1525 /* important note: this function will write *AT MOST*
1526 disk_io_chunk_frames of data to disk. it will never
1527 write more than that. if its writes that much and there
1528 is more than that waiting to be written, it will return 1,
1529 otherwise 0 on success or -1 on failure.
1531 if there is less than disk_io_chunk_frames to be written,
1532 no data will be written at all unless `force_flush' is true.
1535 _write_data_count = 0;
1537 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
1539 (*chan).capture_buf->get_read_vector (&vector);
1541 total = vector.len[0] + vector.len[1];
1544 if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
1549 /* if there are 2+ chunks of disk i/o possible for
1550 this track, let the caller know so that it can arrange
1551 for us to be called again, ASAP.
1553 if we are forcing a flush, then if there is* any* extra
1554 work, let the caller know.
1556 if we are no longer recording and there is any extra work,
1557 let the caller know too.
1560 if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
1564 to_write = min (disk_io_chunk_frames, (jack_nframes_t) vector.len[0]);
1567 // check the transition buffer when recording destructive
1568 // important that we get this after the capture buf
1570 if (destructive()) {
1571 (*chan).capture_transition_buf->get_read_vector(&transvec);
1572 size_t transcount = transvec.len[0] + transvec.len[1];
1573 bool have_start = false;
1576 for (ti=0; ti < transcount; ++ti) {
1577 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
1579 if (captrans.type == CaptureStart) {
1580 // by definition, the first data we got above represents the given capture pos
1582 (*chan).write_source->mark_capture_start (captrans.capture_val);
1583 (*chan).curr_capture_cnt = 0;
1587 else if (captrans.type == CaptureEnd) {
1589 // capture end, the capture_val represents total frames in capture
1591 if (captrans.capture_val <= (*chan).curr_capture_cnt + to_write) {
1593 // shorten to make the write a perfect fit
1594 uint32_t nto_write = (captrans.capture_val - (*chan).curr_capture_cnt);
1596 if (nto_write < to_write) {
1597 ret = 1; // should we?
1599 to_write = nto_write;
1601 (*chan).write_source->mark_capture_end ();
1603 // increment past this transition, but go no further
1608 // actually ends just beyond this chunk, so force more work
1616 (*chan).capture_transition_buf->increment_read_ptr(ti);
1620 if ((!(*chan).write_source) || (*chan).write_source->write (vector.buf[0], to_write, workbuf) != to_write) {
1621 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1625 (*chan).capture_buf->increment_read_ptr (to_write);
1626 (*chan).curr_capture_cnt += to_write;
1628 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < disk_io_chunk_frames) && !destructive()) {
1630 /* we wrote all of vector.len[0] but it wasn't an entire
1631 disk_io_chunk_frames of data, so arrange for some part
1632 of vector.len[1] to be flushed to disk as well.
1635 to_write = min ((jack_nframes_t)(disk_io_chunk_frames - to_write), (jack_nframes_t) vector.len[1]);
1637 if ((*chan).write_source->write (vector.buf[1], to_write, workbuf) != to_write) {
1638 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), _id) << endmsg;
1642 _write_data_count += (*chan).write_source->write_data_count();
1644 (*chan).capture_buf->increment_read_ptr (to_write);
1645 (*chan).curr_capture_cnt += to_write;
1654 AudioDiskstream::playlist_changed (Change ignored)
1656 playlist_modified ();
1660 AudioDiskstream::playlist_modified ()
1662 if (!i_am_the_modifier && !overwrite_queued) {
1663 _session.request_overwrite_buffer (this);
1664 overwrite_queued = true;
1669 AudioDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
1671 uint32_t buffer_position;
1672 bool more_work = true;
1674 AudioRegion* region = 0;
1675 jack_nframes_t total_capture;
1676 AudioRegion::SourceList srcs;
1677 AudioRegion::SourceList::iterator src;
1678 ChannelList::iterator chan;
1679 vector<CaptureInfo*>::iterator ci;
1681 list<AudioFileSource*>* deletion_list;
1682 bool mark_write_completed = false;
1684 finish_capture (true);
1686 /* butler is already stopped, but there may be work to do
1687 to flush remaining data to disk.
1690 while (more_work && !err) {
1691 switch (do_flush ( _session.conversion_buffer(Session::TransportContext), true)) {
1698 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1703 /* XXX is there anything we can do if err != 0 ? */
1704 Glib::Mutex::Lock lm (capture_info_lock);
1706 if (capture_info.empty()) {
1710 if (abort_capture) {
1712 ChannelList::iterator chan;
1714 deletion_list = new list<AudioFileSource*>;
1716 for ( chan = channels.begin(); chan != channels.end(); ++chan) {
1718 if ((*chan).write_source) {
1720 (*chan).write_source->mark_for_remove ();
1721 (*chan).write_source->release ();
1723 deletion_list->push_back ((*chan).write_source);
1725 (*chan).write_source = 0;
1728 /* new source set up in "out" below */
1731 if (!deletion_list->empty()) {
1732 DeleteSources (deletion_list);
1734 delete deletion_list;
1740 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1741 total_capture += (*ci)->frames;
1744 /* figure out the name for this take */
1746 for (n = 0, chan = channels.begin(); chan != channels.end(); ++chan, ++n) {
1748 AudioFileSource* s = (*chan).write_source;
1752 AudioFileSource* fsrc;
1756 if ((fsrc = dynamic_cast<AudioFileSource *>(s)) != 0) {
1757 fsrc->update_header (capture_info.front()->start, when, twhen);
1760 s->set_captured_for (_name);
1765 /* destructive tracks have a single, never changing region */
1767 if (destructive()) {
1769 /* send a signal that any UI can pick up to do the right thing. there is
1770 a small problem here in that a UI may need the peak data to be ready
1771 for the data that was recorded and this isn't interlocked with that
1772 process. this problem is deferred to the UI.
1775 _playlist->Modified();
1779 /* Register a new region with the Session that
1780 describes the entire source. Do this first
1781 so that any sub-regions will obviously be
1782 children of this one (later!)
1786 region = new AudioRegion (srcs, channels[0].write_source->last_capture_start_frame(), total_capture,
1787 region_name_from_path (channels[0].write_source->name()),
1788 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile));
1790 region->special_set_position (capture_info.front()->start);
1794 catch (failed_constructor& err) {
1795 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1799 _last_capture_regions.push_back (region);
1801 // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
1803 _session.add_undo (_playlist->get_memento());
1804 _playlist->freeze ();
1806 for (buffer_position = channels[0].write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1809 _session.region_name (region_name, channels[0].write_source->name(), false);
1811 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1814 region = new AudioRegion (srcs, buffer_position, (*ci)->frames, region_name);
1817 catch (failed_constructor& err) {
1818 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1819 continue; /* XXX is this OK? */
1822 _last_capture_regions.push_back (region);
1824 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1826 i_am_the_modifier++;
1827 _playlist->add_region (*region, (*ci)->start);
1828 i_am_the_modifier--;
1830 buffer_position += (*ci)->frames;
1834 _session.add_redo_no_execute (_playlist->get_memento());
1837 mark_write_completed = true;
1839 reset_write_sources (mark_write_completed);
1842 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1846 capture_info.clear ();
1847 capture_start_frame = 0;
1851 AudioDiskstream::finish_capture (bool rec_monitors_input)
1853 was_recording = false;
1855 if (capture_captured == 0) {
1859 if (recordable() && destructive()) {
1860 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
1862 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1863 (*chan).capture_transition_buf->get_write_vector(&transvec);
1866 if (transvec.len[0] > 0) {
1867 transvec.buf[0]->type = CaptureEnd;
1868 transvec.buf[0]->capture_val = capture_captured;
1869 (*chan).capture_transition_buf->increment_write_ptr(1);
1873 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
1879 CaptureInfo* ci = new CaptureInfo;
1881 ci->start = capture_start_frame;
1882 ci->frames = capture_captured;
1884 /* XXX theoretical race condition here. Need atomic exchange ?
1885 However, the circumstances when this is called right
1886 now (either on record-disable or transport_stopped)
1887 mean that no actual race exists. I think ...
1888 We now have a capture_info_lock, but it is only to be used
1889 to synchronize in the transport_stop and the capture info
1890 accessors, so that invalidation will not occur (both non-realtime).
1893 // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1895 capture_info.push_back (ci);
1896 capture_captured = 0;
1900 AudioDiskstream::set_record_enabled (bool yn, void* src)
1902 bool rolling = _session.transport_speed() != 0.0f;
1904 if (!recordable() || !_session.record_enabling_legal()) {
1908 /* if we're turning on rec-enable, there needs to be an
1912 if (yn && channels[0].source == 0) {
1914 /* pick up connections not initiated *from* the IO object
1915 we're associated with.
1918 get_input_sources ();
1921 /* yes, i know that this not proof against race conditions, but its
1922 good enough. i think.
1925 if (record_enabled() != yn) {
1927 g_atomic_int_set (&_record_enabled, 1);
1928 capturing_sources.clear ();
1929 if (Config->get_use_hardware_monitoring()) {
1930 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
1931 if ((*chan).source) {
1932 (*chan).source->request_monitor_input (!(_session.get_auto_input() && rolling));
1934 capturing_sources.push_back ((*chan).write_source);
1937 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
1938 capturing_sources.push_back ((*chan).write_source);
1943 g_atomic_int_set (&_record_enabled, 0);
1944 if (Config->get_use_hardware_monitoring()) {
1945 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
1946 if ((*chan).source) {
1947 (*chan).source->request_monitor_input (false);
1951 capturing_sources.clear ();
1954 record_enable_changed (src); /* EMIT SIGNAL */
1959 AudioDiskstream::get_state ()
1961 XMLNode* node = new XMLNode ("AudioDiskstream");
1963 LocaleGuard lg (X_("POSIX"));
1965 snprintf (buf, sizeof(buf), "0x%x", _flags);
1966 node->add_property ("flags", buf);
1968 snprintf (buf, sizeof(buf), "%zd", channels.size());
1969 node->add_property ("channels", buf);
1971 node->add_property ("playlist", _playlist->name());
1973 snprintf (buf, sizeof(buf), "%f", _visible_speed);
1974 node->add_property ("speed", buf);
1976 node->add_property("name", _name);
1977 snprintf (buf, sizeof(buf), "%" PRIu64, id());
1978 node->add_property("id", buf);
1980 if (!capturing_sources.empty() && _session.get_record_enabled()) {
1982 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1983 XMLNode* cs_grandchild;
1985 for (vector<AudioFileSource*>::iterator i = capturing_sources.begin(); i != capturing_sources.end(); ++i) {
1986 cs_grandchild = new XMLNode (X_("file"));
1987 cs_grandchild->add_property (X_("path"), (*i)->path());
1988 cs_child->add_child_nocopy (*cs_grandchild);
1991 /* store the location where capture will start */
1995 if (_session.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1996 snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
1998 snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
2001 cs_child->add_property (X_("at"), buf);
2002 node->add_child_nocopy (*cs_child);
2006 node->add_child_copy (*_extra_xml);
2013 AudioDiskstream::set_state (const XMLNode& node)
2015 const XMLProperty* prop;
2016 XMLNodeList nlist = node.children();
2017 XMLNodeIterator niter;
2018 uint32_t nchans = 1;
2019 XMLNode* capture_pending_node = 0;
2020 LocaleGuard lg (X_("POSIX"));
2022 in_set_state = true;
2024 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2025 if ((*niter)->name() == IO::state_node_name) {
2026 deprecated_io_node = new XMLNode (**niter);
2029 if ((*niter)->name() == X_("CapturingSources")) {
2030 capture_pending_node = *niter;
2034 /* prevent write sources from being created */
2036 in_set_state = true;
2038 if ((prop = node.property ("name")) != 0) {
2039 _name = prop->value();
2042 if (deprecated_io_node) {
2043 if ((prop = deprecated_io_node->property ("id")) != 0) {
2044 sscanf (prop->value().c_str(), "%" PRIu64, &_id);
2047 if ((prop = node.property ("id")) != 0) {
2048 sscanf (prop->value().c_str(), "%" PRIu64, &_id);
2052 if ((prop = node.property ("flags")) != 0) {
2053 _flags = strtol (prop->value().c_str(), 0, 0);
2056 if ((prop = node.property ("channels")) != 0) {
2057 nchans = atoi (prop->value().c_str());
2060 // create necessary extra channels
2061 // we are always constructed with one
2062 // and we always need one
2064 if (nchans > _n_channels) {
2066 // we need to add new channel infos
2067 //LockMonitor lm (state_lock, __LINE__, __FILE__);
2069 int diff = nchans - channels.size();
2071 for (int i=0; i < diff; ++i) {
2075 } else if (nchans < _n_channels) {
2077 // we need to get rid of channels
2078 //LockMonitor lm (state_lock, __LINE__, __FILE__);
2080 int diff = channels.size() - nchans;
2082 for (int i = 0; i < diff; ++i) {
2087 if ((prop = node.property ("playlist")) == 0) {
2092 bool had_playlist = (_playlist != 0);
2094 if (find_and_use_playlist (prop->value())) {
2098 if (!had_playlist) {
2099 _playlist->set_orig_diskstream_id (_id);
2102 if (!destructive() && capture_pending_node) {
2103 /* destructive streams have one and only one source per channel,
2104 and so they never end up in pending capture in any useful
2107 use_pending_capture_data (*capture_pending_node);
2112 if ((prop = node.property ("speed")) != 0) {
2113 double sp = atof (prop->value().c_str());
2115 if (realtime_set_speed (sp, false)) {
2116 non_realtime_set_speed ();
2120 _n_channels = channels.size();
2122 in_set_state = false;
2124 /* make sure this is clear before we do anything else */
2126 capturing_sources.clear ();
2128 /* write sources are handled when we handle the input set
2129 up of the IO that owns this DS (::non_realtime_input_change())
2132 in_set_state = false;
2138 AudioDiskstream::use_new_write_source (uint32_t n)
2140 if (!recordable()) {
2144 if (n >= channels.size()) {
2145 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
2149 ChannelInfo &chan = channels[n];
2151 if (chan.write_source) {
2153 if (AudioFileSource::is_empty (chan.write_source->path())) {
2154 chan.write_source->mark_for_remove ();
2155 chan.write_source->release();
2156 delete chan.write_source;
2158 chan.write_source->release();
2159 chan.write_source = 0;
2164 if ((chan.write_source = _session.create_audio_source_for_session (*this, n, destructive())) == 0) {
2165 throw failed_constructor();
2169 catch (failed_constructor &err) {
2170 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
2171 chan.write_source = 0;
2175 chan.write_source->use ();
2177 /* do not remove destructive files even if they are empty */
2179 chan.write_source->set_allow_remove_if_empty (!destructive());
2185 AudioDiskstream::reset_write_sources (bool mark_write_complete, bool force)
2187 ChannelList::iterator chan;
2190 if (!recordable()) {
2194 capturing_sources.clear ();
2196 for (chan = channels.begin(), n = 0; chan != channels.end(); ++chan, ++n) {
2197 if (!destructive()) {
2199 if ((*chan).write_source && mark_write_complete) {
2200 (*chan).write_source->mark_streaming_write_completed ();
2202 use_new_write_source (n);
2204 if (record_enabled()) {
2205 capturing_sources.push_back ((*chan).write_source);
2209 if ((*chan).write_source == 0) {
2210 use_new_write_source (n);
2215 if (destructive()) {
2217 /* we now have all our write sources set up, so create the
2218 playlist's single region.
2221 if (_playlist->empty()) {
2222 setup_destructive_playlist ();
2228 AudioDiskstream::rename_write_sources ()
2230 ChannelList::iterator chan;
2233 for (chan = channels.begin(), n = 0; chan != channels.end(); ++chan, ++n) {
2234 if ((*chan).write_source != 0) {
2235 (*chan).write_source->set_name (_name, destructive());
2236 /* XXX what to do if one of them fails ? */
2244 AudioDiskstream::set_block_size (jack_nframes_t nframes)
2246 if (_session.get_block_size() > speed_buffer_size) {
2247 speed_buffer_size = _session.get_block_size();
2249 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
2250 if ((*chan).speed_buffer) delete [] (*chan).speed_buffer;
2251 (*chan).speed_buffer = new Sample[speed_buffer_size];
2254 allocate_temporary_buffers ();
2258 AudioDiskstream::allocate_temporary_buffers ()
2260 /* make sure the wrap buffer is at least large enough to deal
2261 with the speeds up to 1.2, to allow for micro-variation
2262 when slaving to MTC, SMPTE etc.
2265 double sp = max (fabsf (_actual_speed), 1.2f);
2266 jack_nframes_t required_wrap_size = (jack_nframes_t) floor (_session.get_block_size() * sp) + 1;
2268 if (required_wrap_size > wrap_buffer_size) {
2270 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
2271 if ((*chan).playback_wrap_buffer) delete [] (*chan).playback_wrap_buffer;
2272 (*chan).playback_wrap_buffer = new Sample[required_wrap_size];
2273 if ((*chan).capture_wrap_buffer) delete [] (*chan).capture_wrap_buffer;
2274 (*chan).capture_wrap_buffer = new Sample[required_wrap_size];
2277 wrap_buffer_size = required_wrap_size;
2282 AudioDiskstream::monitor_input (bool yn)
2284 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
2286 if ((*chan).source) {
2287 (*chan).source->request_monitor_input (yn);
2293 AudioDiskstream::set_capture_offset ()
2296 /* can't capture, so forget it */
2300 _capture_offset = _io->input_latency();
2304 AudioDiskstream::set_persistent_align_style (AlignStyle a)
2306 _persistent_alignment_style = a;
2310 AudioDiskstream::set_align_style_from_io ()
2312 bool have_physical = false;
2318 get_input_sources ();
2320 for (ChannelList::iterator chan = channels.begin(); chan != channels.end(); ++chan) {
2321 if ((*chan).source && (*chan).source->flags() & JackPortIsPhysical) {
2322 have_physical = true;
2327 if (have_physical) {
2328 set_align_style (ExistingMaterial);
2330 set_align_style (CaptureTime);
2335 AudioDiskstream::set_align_style (AlignStyle a)
2337 if (record_enabled() && _session.actively_recording()) {
2342 if (a != _alignment_style) {
2343 _alignment_style = a;
2344 AlignmentStyleChanged ();
2349 AudioDiskstream::add_channel ()
2351 /* XXX need to take lock??? */
2355 init_channel (chan);
2357 chan.speed_buffer = new Sample[speed_buffer_size];
2358 chan.playback_wrap_buffer = new Sample[wrap_buffer_size];
2359 chan.capture_wrap_buffer = new Sample[wrap_buffer_size];
2361 channels.push_back (chan);
2363 _n_channels = channels.size();
2369 AudioDiskstream::remove_channel ()
2371 if (channels.size() > 1) {
2372 /* XXX need to take lock??? */
2373 ChannelInfo & chan = channels.back();
2374 destroy_channel (chan);
2375 channels.pop_back();
2377 _n_channels = channels.size();
2385 AudioDiskstream::playback_buffer_load () const
2387 return (float) ((double) channels.front().playback_buf->read_space()/
2388 (double) channels.front().playback_buf->bufsize());
2392 AudioDiskstream::capture_buffer_load () const
2394 return (float) ((double) channels.front().capture_buf->write_space()/
2395 (double) channels.front().capture_buf->bufsize());
2399 AudioDiskstream::set_loop (Location *location)
2402 if (location->start() >= location->end()) {
2403 error << string_compose(_("Location \"%1\" not valid for track loop (start >= end)"), location->name()) << endl;
2408 loop_location = location;
2410 LoopSet (location); /* EMIT SIGNAL */
2415 AudioDiskstream::get_capture_start_frame (uint32_t n)
2417 Glib::Mutex::Lock lm (capture_info_lock);
2419 if (capture_info.size() > n) {
2420 return capture_info[n]->start;
2423 return capture_start_frame;
2428 AudioDiskstream::get_captured_frames (uint32_t n)
2430 Glib::Mutex::Lock lm (capture_info_lock);
2432 if (capture_info.size() > n) {
2433 return capture_info[n]->frames;
2436 return capture_captured;
2441 AudioDiskstream::punch_in ()
2446 AudioDiskstream::punch_out ()
2451 AudioDiskstream::use_pending_capture_data (XMLNode& node)
2453 const XMLProperty* prop;
2454 XMLNodeList nlist = node.children();
2455 XMLNodeIterator niter;
2456 AudioFileSource* fs;
2457 AudioFileSource* first_fs = 0;
2458 AudioRegion::SourceList pending_sources;
2459 jack_nframes_t position;
2461 if ((prop = node.property (X_("at"))) == 0) {
2465 if (sscanf (prop->value().c_str(), "%" PRIu32, &position) != 1) {
2469 for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
2470 if ((*niter)->name() == X_("file")) {
2472 if ((prop = (*niter)->property (X_("path"))) == 0) {
2477 fs = new SndFileSource (prop->value(),
2478 Config->get_native_file_data_format(),
2479 Config->get_native_file_header_format(),
2480 _session.frame_rate());
2483 catch (failed_constructor& err) {
2484 error << string_compose (_("%1: cannot restore pending capture source file %2"),
2485 _name, prop->value())
2490 pending_sources.push_back (fs);
2492 if (first_fs == 0) {
2496 fs->set_captured_for (_name);
2500 if (pending_sources.size() == 0) {
2501 /* nothing can be done */
2505 if (pending_sources.size() != _n_channels) {
2506 error << string_compose (_("%1: incorrect number of pending sources listed - ignoring them all"), _name)
2511 AudioRegion* region;
2514 region = new AudioRegion (pending_sources, 0, first_fs->length(),
2515 region_name_from_path (first_fs->name()),
2516 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile));
2518 region->special_set_position (0);
2521 catch (failed_constructor& err) {
2522 error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
2530 region = new AudioRegion (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name()));
2533 catch (failed_constructor& err) {
2534 error << string_compose (_("%1: cannot create region from pending capture sources"),
2541 _playlist->add_region (*region, position);
2547 AudioDiskstream::set_roll_delay (jack_nframes_t nframes)
2549 _roll_delay = nframes;
2553 AudioDiskstream::set_destructive (bool yn)
2555 if (yn != destructive()) {
2556 reset_write_sources (true, true);
2558 _flags |= Destructive;
2560 _flags &= ~Destructive;