2 Copyright (C) 2009-2016 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.
20 #include "ardour/analyser.h"
21 #include "ardour/audioengine.h"
22 #include "ardour/audiofilesource.h"
23 #include "ardour/audio_buffer.h"
24 #include "ardour/audioplaylist.h"
25 #include "ardour/audioregion.h"
26 #include "ardour/butler.h"
27 #include "ardour/debug.h"
28 #include "ardour/disk_writer.h"
29 #include "ardour/midi_playlist.h"
30 #include "ardour/midi_source.h"
31 #include "ardour/midi_track.h"
32 #include "ardour/port.h"
33 #include "ardour/region_factory.h"
34 #include "ardour/session.h"
35 #include "ardour/smf_source.h"
39 using namespace ARDOUR;
43 ARDOUR::samplecnt_t DiskWriter::_chunk_samples = DiskWriter::default_chunk_samples ();
44 PBD::Signal0<void> DiskWriter::Overrun;
46 DiskWriter::DiskWriter (Session& s, string const & str, DiskIOProcessor::Flag f)
47 : DiskIOProcessor (s, str, f)
50 , capture_start_sample (0)
51 , capture_captured (0)
52 , was_recording (false)
53 , first_recordable_sample (max_samplepos)
54 , last_recordable_sample (max_samplepos)
55 , last_possibly_recording (0)
56 , _alignment_style (ExistingMaterial)
57 , _num_captured_loops (0)
58 , _accumulated_capture_offset (0)
59 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
61 DiskIOProcessor::init ();
64 DiskWriter::~DiskWriter ()
66 DEBUG_TRACE (DEBUG::Destruction, string_compose ("DiskWriter %1 @ %2 deleted\n", _name, this));
68 boost::shared_ptr<ChannelList> c = channels.reader();
70 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
71 (*chan)->write_source.reset ();
76 DiskWriter::default_chunk_samples ()
82 DiskWriter::set_write_source_name (string const & str)
84 _write_source_name = str;
89 DiskWriter::check_record_status (samplepos_t transport_sample, double speed, bool can_record)
91 int possibly_recording;
92 const int transport_rolling = 0x4;
93 const int track_rec_enabled = 0x2;
94 const int global_rec_enabled = 0x1;
95 const int fully_rec_enabled = (transport_rolling |track_rec_enabled | global_rec_enabled);
97 /* merge together the 3 factors that affect record status, and compute what has changed. */
99 possibly_recording = (speed != 0.0f ? 4 : 0) | (record_enabled() ? 2 : 0) | (can_record ? 1 : 0);
101 if (possibly_recording == last_possibly_recording) {
105 if (possibly_recording == fully_rec_enabled) {
107 if (last_possibly_recording == fully_rec_enabled) {
112 if (_session.config.get_punch_in () && 0 != (loc = _session.locations()->auto_punch_location ())) {
113 capture_start_sample = loc->start ();
115 capture_start_sample = _session.transport_sample ();
118 first_recordable_sample = capture_start_sample;
120 if (_alignment_style == ExistingMaterial) {
121 first_recordable_sample += _capture_offset + _playback_offset;
124 if (_session.config.get_punch_out () && 0 != (loc = _session.locations()->auto_punch_location ())) {
125 /* this freezes the punch-out point when starting to record.
127 * We should allow to move it or at least allow to disable punch-out
130 last_recordable_sample = loc->end ();
131 if (_alignment_style == ExistingMaterial) {
132 last_recordable_sample += _capture_offset + _playback_offset;
135 last_recordable_sample = max_samplepos;
138 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %2 (STS: %3) CS:%4 FRS: %5 IL: %7, OL: %8 CO: %r9 PO: %10 WOL: %11 WIL: %12\n",
141 _session.transport_sample(),
142 capture_start_sample,
143 first_recordable_sample,
144 last_recordable_sample,
149 _session.worst_output_latency(),
150 _session.worst_input_latency()));
153 prepare_record_status (capture_start_sample);
157 last_possibly_recording = possibly_recording;
161 DiskWriter::calculate_record_range (Evoral::OverlapType ot, samplepos_t transport_sample, samplecnt_t nframes, samplecnt_t & rec_nframes, samplecnt_t & rec_offset)
164 case Evoral::OverlapNone:
168 case Evoral::OverlapInternal:
169 /* ---------- recrange
172 rec_nframes = nframes;
176 case Evoral::OverlapStart:
177 /* |--------| recrange
180 rec_nframes = transport_sample + nframes - first_recordable_sample;
182 rec_offset = first_recordable_sample - transport_sample;
186 case Evoral::OverlapEnd:
187 /* |--------| recrange
188 * |-------- transrange
190 rec_nframes = last_recordable_sample - transport_sample;
194 case Evoral::OverlapExternal:
195 /* |--------| recrange
196 * -------------- transrange
198 rec_nframes = last_recordable_sample - first_recordable_sample;
199 rec_offset = first_recordable_sample - transport_sample;
203 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 rec? %2 @ %3 (for %4) FRF %5 LRF %6 : rf %7 @ %8\n",
204 _name, enum_2_string (ot), transport_sample, nframes,
205 first_recordable_sample, last_recordable_sample, rec_nframes, rec_offset));
209 DiskWriter::engage_record_enable ()
211 g_atomic_int_set (&_record_enabled, 1);
215 DiskWriter::disengage_record_enable ()
217 g_atomic_int_set (&_record_enabled, 0);
221 DiskWriter::engage_record_safe ()
223 g_atomic_int_set (&_record_safe, 1);
227 DiskWriter::disengage_record_safe ()
229 g_atomic_int_set (&_record_safe, 0);
232 /** Get the start position (in session samples) of the nth capture in the current pass */
234 DiskWriter::get_capture_start_sample (uint32_t n) const
236 Glib::Threads::Mutex::Lock lm (capture_info_lock);
238 if (capture_info.size() > n) {
239 /* this is a completed capture */
240 return capture_info[n]->start;
242 /* this is the currently in-progress capture */
243 return capture_start_sample;
248 DiskWriter::get_captured_samples (uint32_t n) const
250 Glib::Threads::Mutex::Lock lm (capture_info_lock);
252 if (capture_info.size() > n) {
253 /* this is a completed capture */
254 return capture_info[n]->samples;
256 /* this is the currently in-progress capture */
257 return capture_captured;
262 DiskWriter::set_align_style (AlignStyle a, bool force)
264 if (record_enabled() && _session.actively_recording()) {
268 if ((a != _alignment_style) || force) {
269 _alignment_style = a;
270 AlignmentStyleChanged ();
277 XMLNode& node (DiskIOProcessor::state ());
278 node.set_property (X_("type"), X_("diskwriter"));
279 node.set_property (X_("record-safe"), (_record_safe ? X_("yes" : "no")));
284 DiskWriter::set_state (const XMLNode& node, int version)
286 if (DiskIOProcessor::set_state (node, version)) {
290 if (!node.get_property (X_("record-safe"), _record_safe)) {
291 _record_safe = false;
294 reset_write_sources (false, true);
300 DiskWriter::non_realtime_locate (samplepos_t position)
302 if (_midi_write_source) {
303 _midi_write_source->set_timeline_position (position);
306 DiskIOProcessor::non_realtime_locate (position);
311 DiskWriter::prepare_record_status (samplepos_t capture_start_sample)
313 if (recordable() && destructive()) {
314 boost::shared_ptr<ChannelList> c = channels.reader ();
315 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
317 RingBufferNPT<CaptureTransition>::rw_vector transitions;
318 (*chan)->capture_transition_buf->get_write_vector (&transitions);
320 if (transitions.len[0] > 0) {
321 transitions.buf[0]->type = CaptureStart;
322 transitions.buf[0]->capture_val = capture_start_sample;
323 (*chan)->capture_transition_buf->increment_write_ptr(1);
326 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
334 /** Do some record stuff [not described in this comment!]
337 * - Setup playback_distance with the nframes, or nframes adjusted
338 * for current varispeed, if appropriate.
339 * - Setup current_playback_buffer in each ChannelInfo to point to data
340 * that someone can read playback_distance worth of data from.
343 DiskWriter::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample,
344 double speed, pframes_t nframes, bool result_required)
346 if (!_active && !_pending_active) {
349 _active = _pending_active;
352 boost::shared_ptr<ChannelList> c = channels.reader();
353 ChannelList::iterator chan;
355 samplecnt_t rec_offset = 0;
356 samplecnt_t rec_nframes = 0;
357 bool nominally_recording;
359 bool re = record_enabled ();
360 bool punch_in = _session.config.get_punch_in () && _session.locations()->auto_punch_location ();
361 bool can_record = _session.actively_recording ();
362 can_record |= speed != 0 && _session.get_record_enabled () && punch_in && _session.transport_sample () <= _session.locations()->auto_punch_location ()->start ();
364 _need_butler = false;
367 if (speed != 0 && re) {
368 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: run() start: %2 end: %3 NF: %4\n", _name, start_sample, end_sample, nframes));
372 check_record_status (start_sample, speed, can_record);
378 nominally_recording = (can_record && re);
380 // Safeguard against situations where process() goes haywire when autopunching
381 // and last_recordable_sample < first_recordable_sample
383 if (last_recordable_sample < first_recordable_sample) {
384 last_recordable_sample = max_samplepos;
387 const Location* const loop_loc = _loop_location;
388 samplepos_t loop_start = 0;
389 samplepos_t loop_end = 0;
390 samplepos_t loop_length = 0;
393 get_location_times (loop_loc, &loop_start, &loop_end, &loop_length);
396 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && punch_in)) {
398 Evoral::OverlapType ot = Evoral::coverage (first_recordable_sample, last_recordable_sample, start_sample, end_sample);
399 // XXX should this be transport_sample + nframes - 1 ? coverage() expects its parameter ranges to include their end points
400 // XXX also, first_recordable_sample & last_recordable_sample may both be == max_samplepos: coverage() will return OverlapNone in that case. Is thak OK?
401 calculate_record_range (ot, start_sample, nframes, rec_nframes, rec_offset);
403 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: this time record %2 of %3 samples, offset %4\n", _name, rec_nframes, nframes, rec_offset));
405 if (rec_nframes && !was_recording) {
406 capture_captured = 0;
409 /* Loop recording, so pretend the capture started at the loop
410 start rgardless of what time it is now, so the source starts
411 at the loop start and can handle time wrapping around.
412 Otherwise, start the source right now as usual.
414 capture_captured = start_sample - loop_start;
415 capture_start_sample = loop_start;
418 if (_midi_write_source) {
419 _midi_write_source->mark_write_starting_now (capture_start_sample, capture_captured, loop_length);
422 g_atomic_int_set (const_cast<gint*> (&_samples_pending_write), 0);
423 g_atomic_int_set (const_cast<gint*> (&_num_captured_loops), 0);
425 was_recording = true;
429 /* For audio: not writing samples to the capture ringbuffer offsets
430 * the recording. For midi: we need to keep track of the record range
431 * and subtract the accumulated difference from the event time.
434 _accumulated_capture_offset += rec_offset;
436 _accumulated_capture_offset += nframes;
441 if (can_record && !_last_capture_sources.empty ()) {
442 _last_capture_sources.clear ();
449 const size_t n_buffers = bufs.count().n_audio();
451 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
453 ChannelInfo* chaninfo (*chan);
454 AudioBuffer& buf (bufs.get_audio (n%n_buffers));
456 chaninfo->buf->get_write_vector (&chaninfo->rw_vector);
458 if (rec_nframes <= (samplecnt_t) chaninfo->rw_vector.len[0]) {
460 Sample *incoming = buf.data (rec_offset);
461 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * rec_nframes);
465 samplecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
467 if (rec_nframes > total) {
468 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
469 DEBUG_THREAD_SELF, name(), rec_nframes, total));
474 Sample *incoming = buf.data (rec_offset);
475 samplecnt_t first = chaninfo->rw_vector.len[0];
477 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * first);
478 memcpy (chaninfo->rw_vector.buf[1], incoming + first, sizeof (Sample) * (rec_nframes - first));
481 chaninfo->buf->increment_write_ptr (rec_nframes);
487 // Pump entire port buffer into the ring buffer (TODO: split cycles?)
488 MidiBuffer& buf = bufs.get_midi (0);
489 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_route);
490 MidiChannelFilter* filter = mt ? &mt->capture_filter() : 0;
492 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
493 Evoral::Event<MidiBuffer::TimeType> ev (*i, false);
494 if (ev.time() + rec_offset > rec_nframes) {
498 if (DEBUG_ENABLED(DEBUG::MidiIO)) {
499 const uint8_t* __data = ev.buffer();
501 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), start_sample, ev.size()));
502 for (size_t i=0; i < ev.size(); ++i) {
503 DEBUG_STR_APPEND(a,hex);
504 DEBUG_STR_APPEND(a,"0x");
505 DEBUG_STR_APPEND(a,(int)__data[i]);
506 DEBUG_STR_APPEND(a,' ');
508 DEBUG_STR_APPEND(a,'\n');
509 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
512 /* Write events to the capture buffer in samples from session start,
513 but ignoring looping so event time progresses monotonically.
514 The source knows the loop length so it knows exactly where the
515 event occurs in the series of recorded loops and can implement
516 any desirable behaviour. We don't want to send event with
517 transport time here since that way the source can not
518 reconstruct their actual time; future clever MIDI looping should
519 probably be implemented in the source instead of here.
521 const samplecnt_t loop_offset = _num_captured_loops * loop_length;
522 const samplepos_t event_time = start_sample + loop_offset - _accumulated_capture_offset + ev.time();
523 if (event_time < 0 || event_time < first_recordable_sample) {
524 /* Event out of range, skip */
528 bool skip_event = false;
530 /* skip injected immediate/out-of-band events */
531 MidiBuffer const& ieb (mt->immediate_event_buffer());
532 for (MidiBuffer::const_iterator j = ieb.begin(); j != ieb.end(); ++j) {
542 if (!filter || !filter->filter(ev.buffer(), ev.size())) {
543 _midi_buf->write (event_time, ev.event_type(), ev.size(), ev.buffer());
546 g_atomic_int_add (const_cast<gint*>(&_samples_pending_write), nframes);
548 if (buf.size() != 0) {
549 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
552 /* Copy this data into our GUI feed buffer and tell the GUI
553 that it can read it if it likes.
555 _gui_feed_buffer.clear ();
557 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
558 /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
559 the end of the world if it does.
561 _gui_feed_buffer.push_back ((*i).time() + start_sample, (*i).size(), (*i).buffer());
565 DataRecorded (_midi_write_source); /* EMIT SIGNAL */
568 capture_captured += rec_nframes;
569 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 now captured %2 (by %3)\n", name(), capture_captured, rec_nframes));
573 /* not recording this time, but perhaps we were before .. */
577 _accumulated_capture_offset = 0;
581 /* AUDIO BUTLER REQUIRED CODE */
583 if (_playlists[DataType::AUDIO] && !c->empty()) {
584 if (((samplecnt_t) c->front()->buf->read_space() >= _chunk_samples)) {
589 /* MIDI BUTLER REQUIRED CODE */
591 if (_playlists[DataType::MIDI] && (_midi_buf->read_space() < _midi_buf->bufsize() / 2)) {
595 // DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 writer run, needs butler = %2\n", name(), _need_butler));
599 DiskWriter::finish_capture (boost::shared_ptr<ChannelList> c)
601 was_recording = false;
602 first_recordable_sample = max_samplepos;
603 last_recordable_sample = max_samplepos;
605 if (capture_captured == 0) {
609 if (recordable() && destructive()) {
610 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
612 RingBufferNPT<CaptureTransition>::rw_vector transvec;
613 (*chan)->capture_transition_buf->get_write_vector(&transvec);
615 if (transvec.len[0] > 0) {
616 transvec.buf[0]->type = CaptureEnd;
617 transvec.buf[0]->capture_val = capture_captured;
618 (*chan)->capture_transition_buf->increment_write_ptr(1);
622 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
628 CaptureInfo* ci = new CaptureInfo;
630 ci->start = capture_start_sample;
631 ci->samples = capture_captured;
633 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->samples));
635 /* XXX theoretical race condition here. Need atomic exchange ?
636 However, the circumstances when this is called right
637 now (either on record-disable or transport_stopped)
638 mean that no actual race exists. I think ...
639 We now have a capture_info_lock, but it is only to be used
640 to synchronize in the transport_stop and the capture info
641 accessors, so that invalidation will not occur (both non-realtime).
644 capture_info.push_back (ci);
645 capture_captured = 0;
647 /* now we've finished a capture, reset first_recordable_sample for next time */
648 first_recordable_sample = max_samplepos;
651 boost::shared_ptr<MidiBuffer>
652 DiskWriter::get_gui_feed_buffer () const
654 boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
656 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex);
657 b->copy (_gui_feed_buffer);
662 DiskWriter::set_record_enabled (bool yn)
664 if (!recordable() || !_session.record_enabling_legal() || record_safe ()) {
668 /* can't rec-enable in destructive mode if transport is before start */
670 if (destructive() && yn && _session.transport_sample() < _session.current_start_sample()) {
674 /* yes, i know that this not proof against race conditions, but its
675 good enough. i think.
678 if (record_enabled() != yn) {
680 engage_record_enable ();
682 disengage_record_enable ();
685 RecordEnableChanged (); /* EMIT SIGNAL */
690 DiskWriter::set_record_safe (bool yn)
692 if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty()) {
696 /* can't rec-safe in destructive mode if transport is before start ????
699 if (destructive() && yn && _session.transport_sample() < _session.current_start_sample()) {
703 /* yes, i know that this not proof against race conditions, but its
704 good enough. i think.
707 if (record_safe () != yn) {
709 engage_record_safe ();
711 disengage_record_safe ();
714 RecordSafeChanged (); /* EMIT SIGNAL */
719 DiskWriter::prep_record_enable ()
721 if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty() || record_safe ()) { // REQUIRES REVIEW "|| record_safe ()"
725 /* can't rec-enable in destructive mode if transport is before start */
727 if (destructive() && _session.transport_sample() < _session.current_start_sample()) {
731 boost::shared_ptr<ChannelList> c = channels.reader();
733 capturing_sources.clear ();
735 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
736 capturing_sources.push_back ((*chan)->write_source);
737 Source::Lock lock((*chan)->write_source->mutex());
738 (*chan)->write_source->mark_streaming_write_started (lock);
745 DiskWriter::prep_record_disable ()
747 capturing_sources.clear ();
752 DiskWriter::buffer_load () const
754 boost::shared_ptr<ChannelList> c = channels.reader();
760 return (float) ((double) c->front()->buf->write_space()/
761 (double) c->front()->buf->bufsize());
765 DiskWriter::set_note_mode (NoteMode m)
769 boost::shared_ptr<MidiPlaylist> mp = boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
772 mp->set_note_mode (m);
775 if (_midi_write_source && _midi_write_source->model())
776 _midi_write_source->model()->set_note_mode(m);
780 DiskWriter::seek (samplepos_t sample, bool complete_refill)
783 ChannelList::iterator chan;
784 boost::shared_ptr<ChannelList> c = channels.reader();
786 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
787 (*chan)->buf->reset ();
791 g_atomic_int_set(&_samples_read_from_ringbuffer, 0);
792 g_atomic_int_set(&_samples_written_to_ringbuffer, 0);
794 /* can't rec-enable in destructive mode if transport is before start */
796 if (destructive() && record_enabled() && sample < _session.current_start_sample()) {
797 disengage_record_enable ();
800 playback_sample = sample;
806 DiskWriter::do_flush (RunContext ctxt, bool force_flush)
810 RingBufferNPT<Sample>::rw_vector vector;
811 RingBufferNPT<CaptureTransition>::rw_vector transvec;
819 boost::shared_ptr<ChannelList> c = channels.reader();
820 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
822 (*chan)->buf->get_read_vector (&vector);
824 total = vector.len[0] + vector.len[1];
826 if (total == 0 || (total < _chunk_samples && !force_flush && was_recording)) {
830 /* if there are 2+ chunks of disk i/o possible for
831 this track, let the caller know so that it can arrange
832 for us to be called again, ASAP.
834 if we are forcing a flush, then if there is* any* extra
835 work, let the caller know.
837 if we are no longer recording and there is any extra work,
838 let the caller know too.
841 if (total >= 2 * _chunk_samples || ((force_flush || !was_recording) && total > _chunk_samples)) {
845 to_write = min (_chunk_samples, (samplecnt_t) vector.len[0]);
847 // check the transition buffer when recording destructive
848 // important that we get this after the capture buf
851 (*chan)->capture_transition_buf->get_read_vector(&transvec);
852 size_t transcount = transvec.len[0] + transvec.len[1];
855 for (ti=0; ti < transcount; ++ti) {
856 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
858 if (captrans.type == CaptureStart) {
859 // by definition, the first data we got above represents the given capture pos
861 (*chan)->write_source->mark_capture_start (captrans.capture_val);
862 (*chan)->curr_capture_cnt = 0;
864 } else if (captrans.type == CaptureEnd) {
866 // capture end, the capture_val represents total samples in capture
868 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
870 // shorten to make the write a perfect fit
871 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
873 if (nto_write < to_write) {
874 ret = 1; // should we?
876 to_write = nto_write;
878 (*chan)->write_source->mark_capture_end ();
880 // increment past this transition, but go no further
885 // actually ends just beyond this chunk, so force more work
893 (*chan)->capture_transition_buf->increment_read_ptr(ti);
897 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
898 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
902 (*chan)->buf->increment_read_ptr (to_write);
903 (*chan)->curr_capture_cnt += to_write;
905 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < _chunk_samples) && !destructive()) {
907 /* we wrote all of vector.len[0] but it wasn't an entire
908 disk_write_chunk_samples of data, so arrange for some part
909 of vector.len[1] to be flushed to disk as well.
912 to_write = min ((samplecnt_t)(_chunk_samples - to_write), (samplecnt_t) vector.len[1]);
914 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 additional write of %2\n", name(), to_write));
916 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
917 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
921 (*chan)->buf->increment_read_ptr (to_write);
922 (*chan)->curr_capture_cnt += to_write;
928 if (_midi_write_source) {
930 const samplecnt_t total = g_atomic_int_get(const_cast<gint*> (&_samples_pending_write));
933 _midi_buf->read_space() == 0 ||
934 (!force_flush && (total < _chunk_samples) && was_recording)) {
938 /* if there are 2+ chunks of disk i/o possible for
939 this track), let the caller know so that it can arrange
940 for us to be called again, ASAP.
942 if we are forcing a flush, then if there is* any* extra
943 work, let the caller know.
945 if we are no longer recording and there is any extra work,
946 let the caller know too.
949 if (total >= 2 * _chunk_samples || ((force_flush || !was_recording) && total > _chunk_samples)) {
954 /* push out everything we have, right now */
955 to_write = UINT32_MAX;
957 to_write = _chunk_samples;
960 if (record_enabled() && ((total > _chunk_samples) || force_flush)) {
961 Source::Lock lm(_midi_write_source->mutex());
962 if (_midi_write_source->midi_write (lm, *_midi_buf, get_capture_start_sample (0), to_write) != to_write) {
963 error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
966 g_atomic_int_add(const_cast<gint*> (&_samples_pending_write), -to_write);
976 DiskWriter::reset_write_sources (bool mark_write_complete, bool /*force*/)
978 ChannelList::iterator chan;
979 boost::shared_ptr<ChannelList> c = channels.reader();
982 if (!_session.writable() || !recordable()) {
986 capturing_sources.clear ();
988 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
990 if (!destructive()) {
992 if ((*chan)->write_source) {
994 if (mark_write_complete) {
995 Source::Lock lock((*chan)->write_source->mutex());
996 (*chan)->write_source->mark_streaming_write_completed (lock);
997 (*chan)->write_source->done_with_peakfile_writes ();
1000 if ((*chan)->write_source->removable()) {
1001 (*chan)->write_source->mark_for_remove ();
1002 (*chan)->write_source->drop_references ();
1005 (*chan)->write_source.reset ();
1008 use_new_write_source (DataType::AUDIO, n);
1010 if (record_enabled()) {
1011 capturing_sources.push_back ((*chan)->write_source);
1016 if ((*chan)->write_source == 0) {
1017 use_new_write_source (DataType::AUDIO, n);
1022 if (_midi_write_source) {
1023 if (mark_write_complete) {
1024 Source::Lock lm(_midi_write_source->mutex());
1025 _midi_write_source->mark_streaming_write_completed (lm);
1029 if (_playlists[DataType::MIDI]) {
1030 use_new_write_source (DataType::MIDI);
1033 if (destructive() && !c->empty ()) {
1035 /* we now have all our write sources set up, so create the
1036 playlist's single region.
1039 if (_playlists[DataType::MIDI]->empty()) {
1040 setup_destructive_playlist ();
1046 DiskWriter::use_new_write_source (DataType dt, uint32_t n)
1048 if (dt == DataType::MIDI) {
1050 _accumulated_capture_offset = 0;
1051 _midi_write_source.reset();
1054 _midi_write_source = boost::dynamic_pointer_cast<SMFSource>(
1055 _session.create_midi_source_for_session (write_source_name ()));
1057 if (!_midi_write_source) {
1058 throw failed_constructor();
1062 catch (failed_constructor &err) {
1063 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1064 _midi_write_source.reset();
1068 boost::shared_ptr<ChannelList> c = channels.reader();
1070 if (!recordable()) {
1074 if (n >= c->size()) {
1075 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1079 ChannelInfo* chan = (*c)[n];
1082 if ((chan->write_source = _session.create_audio_source_for_session (
1083 c->size(), write_source_name(), n, destructive())) == 0) {
1084 throw failed_constructor();
1088 catch (failed_constructor &err) {
1089 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1090 chan->write_source.reset ();
1094 /* do not remove destructive files even if they are empty */
1096 chan->write_source->set_allow_remove_if_empty (!destructive());
1103 DiskWriter::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1105 bool more_work = true;
1107 samplecnt_t total_capture;
1108 SourceList audio_srcs;
1109 SourceList midi_srcs;
1110 ChannelList::iterator chan;
1111 vector<CaptureInfo*>::iterator ci;
1112 boost::shared_ptr<ChannelList> c = channels.reader();
1114 bool mark_write_completed = false;
1119 /* butler is already stopped, but there may be work to do
1120 to flush remaining data to disk.
1123 while (more_work && !err) {
1124 switch (do_flush (TransportContext, true)) {
1131 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1136 /* XXX is there anything we can do if err != 0 ? */
1137 Glib::Threads::Mutex::Lock lm (capture_info_lock);
1139 if (capture_info.empty()) {
1143 if (abort_capture) {
1145 if (destructive()) {
1149 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1151 if ((*chan)->write_source) {
1153 (*chan)->write_source->mark_for_remove ();
1154 (*chan)->write_source->drop_references ();
1155 (*chan)->write_source.reset ();
1158 /* new source set up in "out" below */
1161 if (_midi_write_source) {
1162 _midi_write_source->mark_for_remove ();
1163 _midi_write_source->drop_references ();
1164 _midi_write_source.reset();
1170 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1171 total_capture += (*ci)->samples;
1174 /* figure out the name for this take */
1176 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1178 boost::shared_ptr<AudioFileSource> as = (*chan)->write_source;
1181 audio_srcs.push_back (as);
1182 as->update_header (capture_info.front()->start, when, twhen);
1183 as->set_captured_for (_name.val());
1184 as->mark_immutable ();
1186 if (Config->get_auto_analyse_audio()) {
1187 Analyser::queue_source_for_analysis (as, true);
1190 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("newly captured source %1 length %2\n", as->path(), as->length (0)));
1193 if (_midi_write_source) {
1194 midi_srcs.push_back (_midi_write_source);
1201 if (_midi_write_source) {
1203 if (_midi_write_source->length (capture_info.front()->start) == 0) {
1204 /* No data was recorded, so this capture will
1205 effectively be aborted; do the same as we
1206 do for an explicit abort.
1208 if (_midi_write_source) {
1209 _midi_write_source->mark_for_remove ();
1210 _midi_write_source->drop_references ();
1211 _midi_write_source.reset();
1217 /* phew, we have data */
1219 Source::Lock source_lock(_midi_write_source->mutex());
1221 /* figure out the name for this take */
1223 midi_srcs.push_back (_midi_write_source);
1225 _midi_write_source->set_timeline_position (capture_info.front()->start);
1226 _midi_write_source->set_captured_for (_name);
1228 /* set length in beats to entire capture length */
1230 BeatsSamplesConverter converter (_session.tempo_map(), capture_info.front()->start);
1231 const Temporal::Beats total_capture_beats = converter.from (total_capture);
1232 _midi_write_source->set_length_beats (total_capture_beats);
1234 /* flush to disk: this step differs from the audio path,
1235 where all the data is already on disk.
1238 _midi_write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Temporal::Beats>::ResolveStuckNotes, total_capture_beats);
1241 _last_capture_sources.insert (_last_capture_sources.end(), audio_srcs.begin(), audio_srcs.end());
1242 _last_capture_sources.insert (_last_capture_sources.end(), midi_srcs.begin(), midi_srcs.end());
1246 _route->use_captured_sources (audio_srcs, capture_info);
1247 _route->use_captured_sources (midi_srcs, capture_info);
1250 mark_write_completed = true;
1253 reset_write_sources (mark_write_completed);
1257 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1261 capture_info.clear ();
1262 capture_start_sample = 0;
1266 DiskWriter::transport_looped (samplepos_t transport_sample)
1268 if (was_recording) {
1269 // all we need to do is finish this capture, with modified capture length
1270 boost::shared_ptr<ChannelList> c = channels.reader();
1274 // the next region will start recording via the normal mechanism
1275 // we'll set the start position to the current transport pos
1276 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1277 capture_start_sample = transport_sample;
1278 first_recordable_sample = transport_sample; // mild lie
1279 last_recordable_sample = max_samplepos;
1280 was_recording = true;
1282 if (recordable() && destructive()) {
1283 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1285 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1286 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1288 if (transvec.len[0] > 0) {
1289 transvec.buf[0]->type = CaptureStart;
1290 transvec.buf[0]->capture_val = capture_start_sample;
1291 (*chan)->capture_transition_buf->increment_write_ptr(1);
1295 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1303 /* Here we only keep track of the number of captured loops so monotonic
1304 event times can be delivered to the write source in process(). Trying
1305 to be clever here is a world of trouble, it is better to simply record
1306 the input in a straightforward non-destructive way. In the future when
1307 we want to implement more clever MIDI looping modes it should be done in
1308 the Source and/or entirely after the capture is finished.
1310 if (was_recording) {
1311 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1316 DiskWriter::setup_destructive_playlist ()
1319 boost::shared_ptr<ChannelList> c = channels.reader();
1321 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1322 srcs.push_back ((*chan)->write_source);
1325 /* a single full-sized region */
1327 assert (!srcs.empty ());
1330 plist.add (Properties::name, _name.val());
1331 plist.add (Properties::start, 0);
1332 plist.add (Properties::length, max_samplepos - srcs.front()->natural_position());
1334 boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
1335 _playlists[DataType::AUDIO]->add_region (region, srcs.front()->natural_position());
1337 /* apply region properties and update write sources */
1338 use_destructive_playlist();
1342 DiskWriter::use_destructive_playlist ()
1344 /* this is called from the XML-based constructor or ::set_destructive. when called,
1345 we already have a playlist and a region, but we need to
1346 set up our sources for write. we use the sources associated
1347 with the (presumed single, full-extent) region.
1350 boost::shared_ptr<Region> rp;
1352 const RegionList& rl (_playlists[DataType::AUDIO]->region_list_property().rlist());
1353 if (rl.size() > 0) {
1354 /* this can happen when dragging a region onto a tape track */
1355 assert((rl.size() == 1));
1361 reset_write_sources (false, true);
1365 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
1368 throw failed_constructor();
1371 /* be sure to stretch the region out to the maximum length (non-musical)*/
1373 region->set_length (max_samplepos - region->position(), 0);
1376 ChannelList::iterator chan;
1377 boost::shared_ptr<ChannelList> c = channels.reader();
1379 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1380 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
1381 assert((*chan)->write_source);
1382 (*chan)->write_source->set_allow_remove_if_empty (false);
1384 // should be set when creating the source or loading the state
1385 assert ((*chan)->write_source->destructive());
1388 /* the source list will never be reset for a destructive track */
1392 DiskWriter::adjust_buffering ()
1394 boost::shared_ptr<ChannelList> c = channels.reader();
1396 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1397 (*chan)->resize (_session.butler()->audio_diskstream_capture_buffer_size());
1402 DiskWriter::realtime_handle_transport_stopped ()
1407 DiskWriter::set_name (string const & str)
1409 string my_name = X_("recorder:");
1412 if (_name != my_name) {
1413 SessionObject::set_name (my_name);
1420 DiskWriter::steal_write_source_name ()
1422 if (_playlists[DataType::MIDI]) {
1423 string our_old_name = _midi_write_source->name();
1425 /* this will bump the name of the current write source to the next one
1426 * (e.g. "MIDI 1-1" gets renamed to "MIDI 1-2"), thus leaving the
1427 * current write source name (e.g. "MIDI 1-1" available). See the
1428 * comments in Session::create_midi_source_by_stealing_name() about why
1433 string new_path = _session.new_midi_source_path (name());
1435 if (_midi_write_source->rename (new_path)) {
1442 return our_old_name;
1445 return std::string();
1449 DiskWriter::configure_io (ChanCount in, ChanCount out)
1451 if (!DiskIOProcessor::configure_io (in, out)) {
1455 reset_write_sources (false, true);