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.
22 #include "ardour/analyser.h"
23 #include "ardour/audioengine.h"
24 #include "ardour/audiofilesource.h"
25 #include "ardour/audio_buffer.h"
26 #include "ardour/audioplaylist.h"
27 #include "ardour/audioregion.h"
28 #include "ardour/butler.h"
29 #include "ardour/debug.h"
30 #include "ardour/disk_writer.h"
31 #include "ardour/midi_playlist.h"
32 #include "ardour/midi_source.h"
33 #include "ardour/midi_track.h"
34 #include "ardour/port.h"
35 #include "ardour/region_factory.h"
36 #include "ardour/session.h"
37 #include "ardour/smf_source.h"
39 using namespace ARDOUR;
43 ARDOUR::framecnt_t DiskWriter::_chunk_frames = DiskWriter::default_chunk_frames ();
44 PBD::Signal0<void> DiskWriter::Overrun;
46 DiskWriter::DiskWriter (Session& s, string const & str, DiskIOProcessor::Flag f)
47 : DiskIOProcessor (s, str, f)
48 , capture_start_frame (0)
49 , capture_captured (0)
50 , was_recording (false)
51 , adjust_capture_position (0)
53 , first_recordable_frame (max_framepos)
54 , last_recordable_frame (max_framepos)
55 , last_possibly_recording (0)
56 , _alignment_style (ExistingMaterial)
57 , _alignment_choice (Automatic)
58 , _num_captured_loops (0)
59 , _accumulated_capture_offset (0)
60 , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
62 DiskIOProcessor::init ();
66 DiskWriter::default_chunk_frames ()
72 DiskWriter::set_write_source_name (string const & str)
74 _write_source_name = str;
79 DiskWriter::check_record_status (framepos_t transport_frame, bool can_record)
81 int possibly_recording;
84 const int transport_rolling = 0x4;
85 const int track_rec_enabled = 0x2;
86 const int global_rec_enabled = 0x1;
87 const int fully_rec_enabled = (transport_rolling|track_rec_enabled|global_rec_enabled);
89 /* merge together the 3 factors that affect record status, and compute
93 rolling = _session.transport_speed() != 0.0f;
94 possibly_recording = (rolling << 2) | ((int)record_enabled() << 1) | (int)can_record;
95 change = possibly_recording ^ last_possibly_recording;
97 if (possibly_recording == last_possibly_recording) {
101 const framecnt_t existing_material_offset = _session.worst_playback_latency();
103 if (possibly_recording == fully_rec_enabled) {
105 if (last_possibly_recording == fully_rec_enabled) {
109 capture_start_frame = _session.transport_frame();
110 first_recordable_frame = capture_start_frame + _capture_offset;
111 last_recordable_frame = max_framepos;
113 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 (%9) FRF = %2 CSF = %4 CO = %5, EMO = %6 RD = %8 WOL %10 WTL %11\n",
114 name(), first_recordable_frame, last_recordable_frame, capture_start_frame,
116 existing_material_offset,
118 _session.transport_frame(),
119 _session.worst_output_latency(),
120 _session.worst_track_latency()));
123 if (_alignment_style == ExistingMaterial) {
124 first_recordable_frame += existing_material_offset;
125 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tshift FRF by EMO %1\n",
126 first_recordable_frame));
129 prepare_record_status (capture_start_frame);
133 if (last_possibly_recording == fully_rec_enabled) {
135 /* we were recording last time */
137 if (change & transport_rolling) {
139 /* transport-change (stopped rolling): last_recordable_frame was set in ::prepare_to_stop(). We
140 * had to set it there because we likely rolled past the stopping point to declick out,
141 * and then backed up.
147 last_recordable_frame = _session.transport_frame() + _capture_offset;
149 if (_alignment_style == ExistingMaterial) {
150 last_recordable_frame += existing_material_offset;
156 last_possibly_recording = possibly_recording;
160 DiskWriter::calculate_record_range (Evoral::OverlapType ot, framepos_t transport_frame, framecnt_t nframes,
161 framecnt_t & rec_nframes, framecnt_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_frame + nframes - first_recordable_frame;
182 rec_offset = first_recordable_frame - transport_frame;
186 case Evoral::OverlapEnd:
187 /* |--------| recrange
188 * |-------- transrange
190 rec_nframes = last_recordable_frame - transport_frame;
194 case Evoral::OverlapExternal:
195 /* |--------| recrange
196 * -------------- transrange
198 rec_nframes = last_recordable_frame - first_recordable_frame;
199 rec_offset = first_recordable_frame - transport_frame;
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_frame, nframes,
205 first_recordable_frame, last_recordable_frame, rec_nframes, rec_offset));
209 DiskWriter::prepare_to_stop (framepos_t transport_frame, framepos_t audible_frame)
211 switch (_alignment_style) {
212 case ExistingMaterial:
213 last_recordable_frame = transport_frame + _capture_offset;
214 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose("%1: prepare to stop sets last recordable frame to %2 + %3 = %4\n", _name, transport_frame, _capture_offset, last_recordable_frame));
218 last_recordable_frame = audible_frame; // note that capture_offset is zero
219 /* we may already have captured audio before the last_recordable_frame (audible frame),
222 if (last_recordable_frame > capture_start_frame) {
223 capture_captured = min (capture_captured, last_recordable_frame - capture_start_frame);
225 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose("%1: prepare to stop sets last recordable frame to audible frame @ %2\n", _name, audible_frame));
232 DiskWriter::engage_record_enable ()
234 g_atomic_int_set (&_record_enabled, 1);
238 DiskWriter::disengage_record_enable ()
240 g_atomic_int_set (&_record_enabled, 0);
244 DiskWriter::engage_record_safe ()
246 g_atomic_int_set (&_record_safe, 1);
250 DiskWriter::disengage_record_safe ()
252 g_atomic_int_set (&_record_safe, 0);
255 /** Get the start position (in session frames) of the nth capture in the current pass */
257 DiskWriter::get_capture_start_frame (uint32_t n) const
259 Glib::Threads::Mutex::Lock lm (capture_info_lock);
261 if (capture_info.size() > n) {
262 /* this is a completed capture */
263 return capture_info[n]->start;
265 /* this is the currently in-progress capture */
266 return capture_start_frame;
271 DiskWriter::get_captured_frames (uint32_t n) const
273 Glib::Threads::Mutex::Lock lm (capture_info_lock);
275 if (capture_info.size() > n) {
276 /* this is a completed capture */
277 return capture_info[n]->frames;
279 /* this is the currently in-progress capture */
280 return capture_captured;
285 DiskWriter::set_input_latency (framecnt_t l)
291 DiskWriter::set_capture_offset ()
293 switch (_alignment_style) {
294 case ExistingMaterial:
295 _capture_offset = _input_latency;
304 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: using IO latency, capture offset set to %2 with style = %3\n", name(), _capture_offset, enum_2_string (_alignment_style)));
309 DiskWriter::set_align_style (AlignStyle a, bool force)
311 if (record_enabled() && _session.actively_recording()) {
315 if ((a != _alignment_style) || force) {
316 _alignment_style = a;
317 set_capture_offset ();
318 AlignmentStyleChanged ();
323 DiskWriter::set_align_style_from_io ()
325 bool have_physical = false;
327 if (_alignment_choice != Automatic) {
335 boost::shared_ptr<IO> input = _route->input ();
339 vector<string> connections;
340 boost::shared_ptr<ChannelList> c = channels.reader();
342 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan, ++n) {
344 if ((input->nth (n).get()) && (input->nth (n)->get_connections (connections) == 0)) {
345 if (AudioEngine::instance()->port_is_physical (connections[0])) {
346 have_physical = true;
351 connections.clear ();
356 // compensate for latency when bouncing from master or mixbus.
357 // we need to use "ExistingMaterial" to pick up the master bus' latency
358 // see also Route::direct_feeds_according_to_reality
361 if (_session.master_out() && ios.fed_by (_session.master_out()->output())) {
362 have_physical = true;
364 for (uint32_t n = 0; n < NUM_MIXBUSES && !have_physical; ++n) {
365 if (_session.get_mixbus (n) && ios.fed_by (_session.get_mixbus(n)->output())) {
366 have_physical = true;
372 set_align_style (ExistingMaterial);
374 set_align_style (CaptureTime);
379 DiskWriter::set_align_choice (AlignChoice a, bool force)
381 if (record_enabled() && _session.actively_recording()) {
385 if ((a != _alignment_choice) || force) {
386 _alignment_choice = a;
388 switch (_alignment_choice) {
390 set_align_style_from_io ();
392 case UseExistingMaterial:
393 set_align_style (ExistingMaterial);
396 set_align_style (CaptureTime);
403 DiskWriter::state (bool full)
405 XMLNode& node (DiskIOProcessor::state (full));
406 node.add_property (X_("capture-alignment"), enum_2_string (_alignment_choice));
407 node.add_property (X_("record-safe"), (_record_safe ? X_("yes" : "no")));
412 DiskWriter::set_state (const XMLNode& node, int version)
414 XMLProperty const * prop;
416 if (DiskIOProcessor::set_state (node, version)) {
420 if ((prop = node.property (X_("capture-alignment"))) != 0) {
421 set_align_choice (AlignChoice (string_2_enum (prop->value(), _alignment_choice)), true);
423 set_align_choice (Automatic, true);
427 if ((prop = node.property ("record-safe")) != 0) {
428 _record_safe = PBD::string_is_affirmative (prop->value()) ? 1 : 0;
435 DiskWriter::non_realtime_locate (framepos_t position)
437 if (_midi_write_source) {
438 _midi_write_source->set_timeline_position (position);
441 DiskIOProcessor::non_realtime_locate (position);
446 DiskWriter::prepare_record_status(framepos_t capture_start_frame)
448 if (recordable() && destructive()) {
449 boost::shared_ptr<ChannelList> c = channels.reader();
450 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
452 RingBufferNPT<CaptureTransition>::rw_vector transitions;
453 (*chan)->capture_transition_buf->get_write_vector (&transitions);
455 if (transitions.len[0] > 0) {
456 transitions.buf[0]->type = CaptureStart;
457 transitions.buf[0]->capture_val = capture_start_frame;
458 (*chan)->capture_transition_buf->increment_write_ptr(1);
461 fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
469 /** Do some record stuff [not described in this comment!]
472 * - Setup playback_distance with the nframes, or nframes adjusted
473 * for current varispeed, if appropriate.
474 * - Setup current_playback_buffer in each ChannelInfo to point to data
475 * that someone can read playback_distance worth of data from.
478 DiskWriter::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
479 double speed, pframes_t nframes, bool result_required)
482 boost::shared_ptr<ChannelList> c = channels.reader();
483 ChannelList::iterator chan;
484 framecnt_t rec_offset = 0;
485 framecnt_t rec_nframes = 0;
486 bool nominally_recording;
487 bool re = record_enabled ();
488 bool can_record = _session.actively_recording ();
490 _need_butler = false;
492 check_record_status (start_frame, can_record);
498 nominally_recording = (can_record && re);
500 // Safeguard against situations where process() goes haywire when autopunching
501 // and last_recordable_frame < first_recordable_frame
503 if (last_recordable_frame < first_recordable_frame) {
504 last_recordable_frame = max_framepos;
507 const Location* const loop_loc = loop_location;
508 framepos_t loop_start = 0;
509 framepos_t loop_end = 0;
510 framepos_t loop_length = 0;
513 get_location_times (loop_loc, &loop_start, &loop_end, &loop_length);
516 adjust_capture_position = 0;
518 if (nominally_recording || (re && was_recording && _session.get_record_enabled() && (_session.config.get_punch_in() || _session.preroll_record_punch_enabled()))) {
520 Evoral::OverlapType ot = Evoral::coverage (first_recordable_frame, last_recordable_frame, start_frame, end_frame);
521 // XXX should this be transport_frame + nframes - 1 ? coverage() expects its parameter ranges to include their end points
522 // XXX also, first_recordable_frame & last_recordable_frame may both be == max_framepos: coverage() will return OverlapNone in that case. Is thak OK?
523 calculate_record_range (ot, start_frame, nframes, rec_nframes, rec_offset);
525 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: this time record %2 of %3 frames, offset %4\n", _name, rec_nframes, nframes, rec_offset));
527 if (rec_nframes && !was_recording) {
528 capture_captured = 0;
531 /* Loop recording, so pretend the capture started at the loop
532 start rgardless of what time it is now, so the source starts
533 at the loop start and can handle time wrapping around.
534 Otherwise, start the source right now as usual.
536 capture_captured = start_frame - loop_start;
537 capture_start_frame = loop_start;
540 _midi_write_source->mark_write_starting_now (capture_start_frame, capture_captured, loop_length);
542 g_atomic_int_set(const_cast<gint*> (&_frames_pending_write), 0);
543 g_atomic_int_set(const_cast<gint*> (&_num_captured_loops), 0);
545 was_recording = true;
549 /* For audio: not writing frames to the capture ringbuffer offsets
550 * the recording. For midi: we need to keep track of the record range
551 * and subtract the accumulated difference from the event time.
554 _accumulated_capture_offset += rec_offset;
556 _accumulated_capture_offset += nframes;
561 if (can_record && !_last_capture_sources.empty()) {
562 _last_capture_sources.clear ();
569 const size_t n_buffers = bufs.count().n_audio();
571 for (n = 0; chan != c->end(); ++chan, ++n) {
573 ChannelInfo* chaninfo (*chan);
574 AudioBuffer& buf (bufs.get_audio (n%n_buffers));
576 chaninfo->buf->get_write_vector (&chaninfo->rw_vector);
578 if (rec_nframes <= (framecnt_t) chaninfo->rw_vector.len[0]) {
580 Sample *incoming = buf.data (rec_offset);
581 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * rec_nframes);
585 framecnt_t total = chaninfo->rw_vector.len[0] + chaninfo->rw_vector.len[1];
587 if (rec_nframes > total) {
588 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 overrun in %2, rec_nframes = %3 total space = %4\n",
589 DEBUG_THREAD_SELF, name(), rec_nframes, total));
594 Sample *incoming = buf.data (rec_offset);
595 framecnt_t first = chaninfo->rw_vector.len[0];
597 memcpy (chaninfo->rw_vector.buf[0], incoming, sizeof (Sample) * first);
598 memcpy (chaninfo->rw_vector.buf[1], incoming + first, sizeof (Sample) * (rec_nframes - first));
601 chaninfo->buf->increment_write_ptr (rec_nframes);
607 // Pump entire port buffer into the ring buffer (TODO: split cycles?)
608 MidiBuffer& buf = bufs.get_midi (0);
609 boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack>(_route);
610 MidiChannelFilter* filter = mt ? &mt->capture_filter() : 0;
612 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
613 Evoral::Event<MidiBuffer::TimeType> ev(*i, false);
614 if (ev.time() + rec_offset > rec_nframes) {
618 if (DEBUG_ENABLED(DEBUG::MidiIO)) {
619 const uint8_t* __data = ev.buffer();
621 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), start_frame, ev.size()));
622 for (size_t i=0; i < ev.size(); ++i) {
623 DEBUG_STR_APPEND(a,hex);
624 DEBUG_STR_APPEND(a,"0x");
625 DEBUG_STR_APPEND(a,(int)__data[i]);
626 DEBUG_STR_APPEND(a,' ');
628 DEBUG_STR_APPEND(a,'\n');
629 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
632 /* Write events to the capture buffer in frames from session start,
633 but ignoring looping so event time progresses monotonically.
634 The source knows the loop length so it knows exactly where the
635 event occurs in the series of recorded loops and can implement
636 any desirable behaviour. We don't want to send event with
637 transport time here since that way the source can not
638 reconstruct their actual time; future clever MIDI looping should
639 probably be implemented in the source instead of here.
641 const framecnt_t loop_offset = _num_captured_loops * loop_length;
642 const framepos_t event_time = start_frame + loop_offset - _accumulated_capture_offset + ev.time();
643 if (event_time < 0 || event_time < first_recordable_frame) {
644 /* Event out of range, skip */
648 if (!filter || !filter->filter(ev.buffer(), ev.size())) {
649 _midi_buf->write (event_time, ev.event_type(), ev.size(), ev.buffer());
652 g_atomic_int_add(const_cast<gint*>(&_frames_pending_write), nframes);
654 if (buf.size() != 0) {
655 Glib::Threads::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::Threads::TRY_LOCK);
658 /* Copy this data into our GUI feed buffer and tell the GUI
659 that it can read it if it likes.
661 _gui_feed_buffer.clear ();
663 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
664 /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
665 the end of the world if it does.
667 _gui_feed_buffer.push_back ((*i).time() + start_frame, (*i).size(), (*i).buffer());
671 DataRecorded (_midi_write_source); /* EMIT SIGNAL */
674 capture_captured += rec_nframes;
675 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 now captured %2 (by %3)\n", name(), capture_captured, rec_nframes));
679 /* not recording this time, but perhaps we were before .. */
683 _accumulated_capture_offset = 0;
687 /* AUDIO BUTLER REQUIRED CODE */
689 if (_playlists[DataType::AUDIO] && !c->empty()) {
690 if (((framecnt_t) c->front()->buf->read_space() >= _chunk_frames)) {
695 /* MIDI BUTLER REQUIRED CODE */
697 if (_playlists[DataType::MIDI] && (_midi_buf->read_space() < _midi_buf->bufsize() / 2)) {
701 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 writer run, needs butler = %2\n", name(), _need_butler));
705 DiskWriter::finish_capture (boost::shared_ptr<ChannelList> c)
707 was_recording = false;
708 first_recordable_frame = max_framepos;
709 last_recordable_frame = max_framepos;
711 if (capture_captured == 0) {
715 if (recordable() && destructive()) {
716 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
718 RingBufferNPT<CaptureTransition>::rw_vector transvec;
719 (*chan)->capture_transition_buf->get_write_vector(&transvec);
721 if (transvec.len[0] > 0) {
722 transvec.buf[0]->type = CaptureEnd;
723 transvec.buf[0]->capture_val = capture_captured;
724 (*chan)->capture_transition_buf->increment_write_ptr(1);
728 fatal << string_compose (_("programmer error: %1"), X_("capture_transition_buf is full when stopping record! inconceivable!")) << endmsg;
734 CaptureInfo* ci = new CaptureInfo;
736 ci->start = capture_start_frame;
737 ci->frames = capture_captured;
739 /* XXX theoretical race condition here. Need atomic exchange ?
740 However, the circumstances when this is called right
741 now (either on record-disable or transport_stopped)
742 mean that no actual race exists. I think ...
743 We now have a capture_info_lock, but it is only to be used
744 to synchronize in the transport_stop and the capture info
745 accessors, so that invalidation will not occur (both non-realtime).
748 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("Finish capture, add new CI, %1 + %2\n", ci->start, ci->frames));
750 capture_info.push_back (ci);
751 capture_captured = 0;
753 /* now we've finished a capture, reset first_recordable_frame for next time */
754 first_recordable_frame = max_framepos;
758 DiskWriter::set_record_enabled (bool yn)
760 if (!recordable() || !_session.record_enabling_legal() || record_safe ()) {
764 /* can't rec-enable in destructive mode if transport is before start */
766 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
770 /* yes, i know that this not proof against race conditions, but its
771 good enough. i think.
774 if (record_enabled() != yn) {
776 engage_record_enable ();
778 disengage_record_enable ();
781 RecordEnableChanged (); /* EMIT SIGNAL */
786 DiskWriter::set_record_safe (bool yn)
788 if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty()) {
792 /* can't rec-safe in destructive mode if transport is before start ????
795 if (destructive() && yn && _session.transport_frame() < _session.current_start_frame()) {
799 /* yes, i know that this not proof against race conditions, but its
800 good enough. i think.
803 if (record_safe () != yn) {
805 engage_record_safe ();
807 disengage_record_safe ();
810 RecordSafeChanged (); /* EMIT SIGNAL */
815 DiskWriter::prep_record_enable ()
817 if (!recordable() || !_session.record_enabling_legal() || channels.reader()->empty() || record_safe ()) { // REQUIRES REVIEW "|| record_safe ()"
821 /* can't rec-enable in destructive mode if transport is before start */
823 if (destructive() && _session.transport_frame() < _session.current_start_frame()) {
827 boost::shared_ptr<ChannelList> c = channels.reader();
829 capturing_sources.clear ();
831 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
832 capturing_sources.push_back ((*chan)->write_source);
833 Source::Lock lock((*chan)->write_source->mutex());
834 (*chan)->write_source->mark_streaming_write_started (lock);
841 DiskWriter::prep_record_disable ()
843 capturing_sources.clear ();
848 DiskWriter::buffer_load () const
850 boost::shared_ptr<ChannelList> c = channels.reader();
856 return (float) ((double) c->front()->buf->write_space()/
857 (double) c->front()->buf->bufsize());
861 DiskWriter::set_note_mode (NoteMode m)
865 boost::shared_ptr<MidiPlaylist> mp = boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
868 mp->set_note_mode (m);
871 if (_midi_write_source && _midi_write_source->model())
872 _midi_write_source->model()->set_note_mode(m);
876 DiskWriter::seek (framepos_t frame, bool complete_refill)
879 ChannelList::iterator chan;
880 boost::shared_ptr<ChannelList> c = channels.reader();
882 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
883 (*chan)->buf->reset ();
887 g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
888 g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
890 /* can't rec-enable in destructive mode if transport is before start */
892 if (destructive() && record_enabled() && frame < _session.current_start_frame()) {
893 disengage_record_enable ();
896 playback_sample = frame;
903 DiskWriter::do_flush (RunContext ctxt, bool force_flush)
907 RingBufferNPT<Sample>::rw_vector vector;
908 RingBufferNPT<CaptureTransition>::rw_vector transvec;
916 boost::shared_ptr<ChannelList> c = channels.reader();
917 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
919 (*chan)->buf->get_read_vector (&vector);
921 total = vector.len[0] + vector.len[1];
923 if (total == 0 || (total < _chunk_frames && !force_flush && was_recording)) {
927 /* if there are 2+ chunks of disk i/o possible for
928 this track, let the caller know so that it can arrange
929 for us to be called again, ASAP.
931 if we are forcing a flush, then if there is* any* extra
932 work, let the caller know.
934 if we are no longer recording and there is any extra work,
935 let the caller know too.
938 if (total >= 2 * _chunk_frames || ((force_flush || !was_recording) && total > _chunk_frames)) {
942 to_write = min (_chunk_frames, (framecnt_t) vector.len[0]);
944 // check the transition buffer when recording destructive
945 // important that we get this after the capture buf
948 (*chan)->capture_transition_buf->get_read_vector(&transvec);
949 size_t transcount = transvec.len[0] + transvec.len[1];
952 for (ti=0; ti < transcount; ++ti) {
953 CaptureTransition & captrans = (ti < transvec.len[0]) ? transvec.buf[0][ti] : transvec.buf[1][ti-transvec.len[0]];
955 if (captrans.type == CaptureStart) {
956 // by definition, the first data we got above represents the given capture pos
958 (*chan)->write_source->mark_capture_start (captrans.capture_val);
959 (*chan)->curr_capture_cnt = 0;
961 } else if (captrans.type == CaptureEnd) {
963 // capture end, the capture_val represents total frames in capture
965 if (captrans.capture_val <= (*chan)->curr_capture_cnt + to_write) {
967 // shorten to make the write a perfect fit
968 uint32_t nto_write = (captrans.capture_val - (*chan)->curr_capture_cnt);
970 if (nto_write < to_write) {
971 ret = 1; // should we?
973 to_write = nto_write;
975 (*chan)->write_source->mark_capture_end ();
977 // increment past this transition, but go no further
982 // actually ends just beyond this chunk, so force more work
990 (*chan)->capture_transition_buf->increment_read_ptr(ti);
994 if ((!(*chan)->write_source) || (*chan)->write_source->write (vector.buf[0], to_write) != to_write) {
995 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
999 (*chan)->buf->increment_read_ptr (to_write);
1000 (*chan)->curr_capture_cnt += to_write;
1002 if ((to_write == vector.len[0]) && (total > to_write) && (to_write < _chunk_frames) && !destructive()) {
1004 /* we wrote all of vector.len[0] but it wasn't an entire
1005 disk_write_chunk_frames of data, so arrange for some part
1006 of vector.len[1] to be flushed to disk as well.
1009 to_write = min ((framecnt_t)(_chunk_frames - to_write), (framecnt_t) vector.len[1]);
1011 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 additional write of %2\n", name(), to_write));
1013 if ((*chan)->write_source->write (vector.buf[1], to_write) != to_write) {
1014 error << string_compose(_("AudioDiskstream %1: cannot write to disk"), id()) << endmsg;
1018 (*chan)->buf->increment_read_ptr (to_write);
1019 (*chan)->curr_capture_cnt += to_write;
1031 DiskWriter::reset_write_sources (bool mark_write_complete, bool /*force*/)
1033 ChannelList::iterator chan;
1034 boost::shared_ptr<ChannelList> c = channels.reader();
1037 if (!_session.writable() || !recordable()) {
1041 capturing_sources.clear ();
1043 for (chan = c->begin(), n = 0; chan != c->end(); ++chan, ++n) {
1045 if (!destructive()) {
1047 if ((*chan)->write_source) {
1049 if (mark_write_complete) {
1050 Source::Lock lock((*chan)->write_source->mutex());
1051 (*chan)->write_source->mark_streaming_write_completed (lock);
1052 (*chan)->write_source->done_with_peakfile_writes ();
1055 if ((*chan)->write_source->removable()) {
1056 (*chan)->write_source->mark_for_remove ();
1057 (*chan)->write_source->drop_references ();
1060 (*chan)->write_source.reset ();
1063 use_new_write_source (DataType::AUDIO, n);
1065 if (record_enabled()) {
1066 capturing_sources.push_back ((*chan)->write_source);
1071 if ((*chan)->write_source == 0) {
1072 use_new_write_source (DataType::AUDIO, n);
1077 if (_midi_write_source) {
1078 if (mark_write_complete) {
1079 Source::Lock lm(_midi_write_source->mutex());
1080 _midi_write_source->mark_streaming_write_completed (lm);
1083 use_new_write_source (DataType::MIDI);
1085 if (destructive() && !c->empty ()) {
1087 /* we now have all our write sources set up, so create the
1088 playlist's single region.
1091 if (_playlists[DataType::MIDI]->empty()) {
1092 setup_destructive_playlist ();
1099 DiskWriter::use_new_write_source (DataType dt, uint32_t n)
1101 if (dt == DataType::MIDI) {
1103 _accumulated_capture_offset = 0;
1104 _midi_write_source.reset();
1107 _midi_write_source = boost::dynamic_pointer_cast<SMFSource>(
1108 _session.create_midi_source_for_session (write_source_name ()));
1110 if (!_midi_write_source) {
1111 throw failed_constructor();
1115 catch (failed_constructor &err) {
1116 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1117 _midi_write_source.reset();
1121 boost::shared_ptr<ChannelList> c = channels.reader();
1123 if (!recordable()) {
1127 if (n >= c->size()) {
1128 error << string_compose (_("AudioDiskstream: channel %1 out of range"), n) << endmsg;
1132 ChannelInfo* chan = (*c)[n];
1135 if ((chan->write_source = _session.create_audio_source_for_session (
1136 c->size(), write_source_name(), n, destructive())) == 0) {
1137 throw failed_constructor();
1141 catch (failed_constructor &err) {
1142 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1143 chan->write_source.reset ();
1147 /* do not remove destructive files even if they are empty */
1149 chan->write_source->set_allow_remove_if_empty (!destructive());
1156 DiskWriter::transport_stopped_wallclock (struct tm& when, time_t twhen, bool abort_capture)
1158 uint32_t buffer_position;
1159 bool more_work = true;
1161 boost::shared_ptr<AudioRegion> region;
1162 framecnt_t total_capture;
1164 SourceList::iterator src;
1165 ChannelList::iterator chan;
1166 vector<CaptureInfo*>::iterator ci;
1167 boost::shared_ptr<ChannelList> c = channels.reader();
1169 bool mark_write_completed = false;
1173 boost::shared_ptr<AudioPlaylist> pl = boost::dynamic_pointer_cast<AudioPlaylist> (_playlists[DataType::AUDIO]);
1175 /* butler is already stopped, but there may be work to do
1176 to flush remaining data to disk.
1179 while (more_work && !err) {
1180 switch (do_flush (TransportContext, true)) {
1187 error << string_compose(_("AudioDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1192 /* XXX is there anything we can do if err != 0 ? */
1193 Glib::Threads::Mutex::Lock lm (capture_info_lock);
1195 if (capture_info.empty()) {
1199 if (abort_capture) {
1201 if (destructive()) {
1205 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1207 if ((*chan)->write_source) {
1209 (*chan)->write_source->mark_for_remove ();
1210 (*chan)->write_source->drop_references ();
1211 (*chan)->write_source.reset ();
1214 /* new source set up in "out" below */
1220 for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1221 total_capture += (*ci)->frames;
1224 /* figure out the name for this take */
1226 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1228 boost::shared_ptr<AudioFileSource> s = (*chan)->write_source;
1232 s->update_header (capture_info.front()->start, when, twhen);
1233 s->set_captured_for (_name.val());
1234 s->mark_immutable ();
1236 if (Config->get_auto_analyse_audio()) {
1237 Analyser::queue_source_for_analysis (s, true);
1240 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("newly captured source %1 length %2\n", s->path(), s->length (0)));
1248 /* destructive tracks have a single, never changing region */
1250 if (destructive()) {
1252 /* send a signal that any UI can pick up to do the right thing. there is
1253 a small problem here in that a UI may need the peak data to be ready
1254 for the data that was recorded and this isn't interlocked with that
1255 process. this problem is deferred to the UI.
1258 pl->LayeringChanged(); // XXX this may not get the UI to do the right thing
1262 string whole_file_region_name;
1263 whole_file_region_name = region_name_from_path (c->front()->write_source->name(), true);
1265 /* Register a new region with the Session that
1266 describes the entire source. Do this first
1267 so that any sub-regions will obviously be
1268 children of this one (later!)
1274 plist.add (Properties::start, c->front()->write_source->last_capture_start_frame());
1275 plist.add (Properties::length, total_capture);
1276 plist.add (Properties::name, whole_file_region_name);
1277 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1278 rx->set_automatic (true);
1279 rx->set_whole_file (true);
1281 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1282 region->special_set_position (capture_info.front()->start);
1286 catch (failed_constructor& err) {
1287 error << string_compose(_("%1: could not create region for complete audio file"), _name) << endmsg;
1291 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1293 pl->clear_changes ();
1294 pl->set_capture_insertion_in_progress (true);
1297 const framepos_t preroll_off = _session.preroll_record_trim_len ();
1298 for (buffer_position = c->front()->write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1302 RegionFactory::region_name (region_name, whole_file_region_name, false);
1304 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture bufpos %5 start @ %2 length %3 add new region %4\n",
1305 _name, (*ci)->start, (*ci)->frames, region_name, buffer_position));
1311 plist.add (Properties::start, buffer_position);
1312 plist.add (Properties::length, (*ci)->frames);
1313 plist.add (Properties::name, region_name);
1315 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1316 region = boost::dynamic_pointer_cast<AudioRegion> (rx);
1317 if (preroll_off > 0) {
1318 region->trim_front (buffer_position + preroll_off);
1322 catch (failed_constructor& err) {
1323 error << _("AudioDiskstream: could not create region for captured audio!") << endmsg;
1324 continue; /* XXX is this OK? */
1327 i_am_the_modifier++;
1329 pl->add_region (region, (*ci)->start + preroll_off, 1, non_layered());
1330 pl->set_layer (region, DBL_MAX);
1331 i_am_the_modifier--;
1333 buffer_position += (*ci)->frames;
1337 pl->set_capture_insertion_in_progress (false);
1338 _session.add_command (new StatefulDiffCommand (pl));
1341 mark_write_completed = true;
1344 reset_write_sources (mark_write_completed);
1348 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1352 capture_info.clear ();
1353 capture_start_frame = 0;
1361 DiskWriter::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
1363 bool more_work = true;
1365 boost::shared_ptr<MidiRegion> region;
1366 MidiRegion::SourceList srcs;
1367 MidiRegion::SourceList::iterator src;
1368 vector<CaptureInfo*>::iterator ci;
1372 /* butler is already stopped, but there may be work to do
1373 to flush remaining data to disk.
1376 while (more_work && !err) {
1377 switch (do_flush (TransportContext, true)) {
1384 error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
1389 /* XXX is there anything we can do if err != 0 ? */
1390 Glib::Threads::Mutex::Lock lm (capture_info_lock);
1392 if (capture_info.empty()) {
1393 goto no_capture_stuff_to_do;
1396 if (abort_capture) {
1398 if (_write_source) {
1399 _write_source->mark_for_remove ();
1400 _write_source->drop_references ();
1401 _write_source.reset();
1404 /* new source set up in "out" below */
1408 framecnt_t total_capture = 0;
1409 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1410 total_capture += (*ci)->frames;
1413 if (_write_source->length (capture_info.front()->start) != 0) {
1415 /* phew, we have data */
1417 Source::Lock source_lock(_write_source->mutex());
1419 /* figure out the name for this take */
1421 srcs.push_back (_write_source);
1423 _write_source->set_timeline_position (capture_info.front()->start);
1424 _write_source->set_captured_for (_name);
1426 /* set length in beats to entire capture length */
1428 BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
1429 const Evoral::Beats total_capture_beats = converter.from (total_capture);
1430 _write_source->set_length_beats (total_capture_beats);
1432 /* flush to disk: this step differs from the audio path,
1433 where all the data is already on disk.
1436 _write_source->mark_midi_streaming_write_completed (source_lock, Evoral::Sequence<Evoral::Beats>::ResolveStuckNotes, total_capture_beats);
1438 /* we will want to be able to keep (over)writing the source
1439 but we don't want it to be removable. this also differs
1440 from the audio situation, where the source at this point
1441 must be considered immutable. luckily, we can rely on
1442 MidiSource::mark_streaming_write_completed() to have
1443 already done the necessary work for that.
1446 string whole_file_region_name;
1447 whole_file_region_name = region_name_from_path (_write_source->name(), true);
1449 /* Register a new region with the Session that
1450 describes the entire source. Do this first
1451 so that any sub-regions will obviously be
1452 children of this one (later!)
1458 plist.add (Properties::name, whole_file_region_name);
1459 plist.add (Properties::whole_file, true);
1460 plist.add (Properties::automatic, true);
1461 plist.add (Properties::start, 0);
1462 plist.add (Properties::length, total_capture);
1463 plist.add (Properties::layer, 0);
1465 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1467 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1468 region->special_set_position (capture_info.front()->start);
1472 catch (failed_constructor& err) {
1473 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1477 _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1479 _playlist->clear_changes ();
1480 _playlist->freeze ();
1482 /* Session frame time of the initial capture in this pass, which is where the source starts */
1483 framepos_t initial_capture = 0;
1484 if (!capture_info.empty()) {
1485 initial_capture = capture_info.front()->start;
1488 const framepos_t preroll_off = _session.preroll_record_trim_len ();
1489 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1493 RegionFactory::region_name (region_name, _write_source->name(), false);
1495 DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 capture start @ %2 length %3 add new region %4\n",
1496 _name, (*ci)->start, (*ci)->frames, region_name));
1499 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1504 /* start of this region is the offset between the start of its capture and the start of the whole pass */
1505 plist.add (Properties::start, (*ci)->start - initial_capture);
1506 plist.add (Properties::length, (*ci)->frames);
1507 plist.add (Properties::length_beats, converter.from((*ci)->frames).to_double());
1508 plist.add (Properties::name, region_name);
1510 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1511 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1512 if (preroll_off > 0) {
1513 region->trim_front ((*ci)->start - initial_capture + preroll_off);
1517 catch (failed_constructor& err) {
1518 error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1519 continue; /* XXX is this OK? */
1522 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1524 i_am_the_modifier++;
1525 _playlist->add_region (region, (*ci)->start + preroll_off);
1526 i_am_the_modifier--;
1530 _session.add_command (new StatefulDiffCommand(_playlist));
1534 /* No data was recorded, so this capture will
1535 effectively be aborted; do the same as we
1536 do for an explicit abort.
1539 if (_write_source) {
1540 _write_source->mark_for_remove ();
1541 _write_source->drop_references ();
1542 _write_source.reset();
1548 use_new_write_source (0);
1550 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1554 capture_info.clear ();
1555 capture_start_frame = 0;
1557 no_capture_stuff_to_do:
1564 DiskWriter::transport_looped (framepos_t transport_frame)
1566 if (was_recording) {
1567 // all we need to do is finish this capture, with modified capture length
1568 boost::shared_ptr<ChannelList> c = channels.reader();
1572 // the next region will start recording via the normal mechanism
1573 // we'll set the start position to the current transport pos
1574 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1575 capture_start_frame = transport_frame;
1576 first_recordable_frame = transport_frame; // mild lie
1577 last_recordable_frame = max_framepos;
1578 was_recording = true;
1580 if (recordable() && destructive()) {
1581 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1583 RingBufferNPT<CaptureTransition>::rw_vector transvec;
1584 (*chan)->capture_transition_buf->get_write_vector(&transvec);
1586 if (transvec.len[0] > 0) {
1587 transvec.buf[0]->type = CaptureStart;
1588 transvec.buf[0]->capture_val = capture_start_frame;
1589 (*chan)->capture_transition_buf->increment_write_ptr(1);
1593 fatal << X_("programming error: capture_transition_buf is full on rec loop! inconceivable!")
1601 /* Here we only keep track of the number of captured loops so monotonic
1602 event times can be delivered to the write source in process(). Trying
1603 to be clever here is a world of trouble, it is better to simply record
1604 the input in a straightforward non-destructive way. In the future when
1605 we want to implement more clever MIDI looping modes it should be done in
1606 the Source and/or entirely after the capture is finished.
1608 if (was_recording) {
1609 g_atomic_int_add(const_cast<gint*> (&_num_captured_loops), 1);
1614 DiskWriter::setup_destructive_playlist ()
1617 boost::shared_ptr<ChannelList> c = channels.reader();
1619 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1620 srcs.push_back ((*chan)->write_source);
1623 /* a single full-sized region */
1625 assert (!srcs.empty ());
1628 plist.add (Properties::name, _name.val());
1629 plist.add (Properties::start, 0);
1630 plist.add (Properties::length, max_framepos - srcs.front()->natural_position());
1632 boost::shared_ptr<Region> region (RegionFactory::create (srcs, plist));
1633 _playlists[DataType::AUDIO]->add_region (region, srcs.front()->natural_position());
1635 /* apply region properties and update write sources */
1636 use_destructive_playlist();
1640 DiskWriter::use_destructive_playlist ()
1642 /* this is called from the XML-based constructor or ::set_destructive. when called,
1643 we already have a playlist and a region, but we need to
1644 set up our sources for write. we use the sources associated
1645 with the (presumed single, full-extent) region.
1648 boost::shared_ptr<Region> rp;
1650 const RegionList& rl (_playlists[DataType::AUDIO]->region_list_property().rlist());
1651 if (rl.size() > 0) {
1652 /* this can happen when dragging a region onto a tape track */
1653 assert((rl.size() == 1));
1659 reset_write_sources (false, true);
1663 boost::shared_ptr<AudioRegion> region = boost::dynamic_pointer_cast<AudioRegion> (rp);
1666 throw failed_constructor();
1669 /* be sure to stretch the region out to the maximum length (non-musical)*/
1671 region->set_length (max_framepos - region->position(), 0);
1674 ChannelList::iterator chan;
1675 boost::shared_ptr<ChannelList> c = channels.reader();
1677 for (n = 0, chan = c->begin(); chan != c->end(); ++chan, ++n) {
1678 (*chan)->write_source = boost::dynamic_pointer_cast<AudioFileSource>(region->source (n));
1679 assert((*chan)->write_source);
1680 (*chan)->write_source->set_allow_remove_if_empty (false);
1682 /* this might be false if we switched modes, so force it */
1684 #ifdef XXX_OLD_DESTRUCTIVE_API_XXX
1685 (*chan)->write_source->set_destructive (true);
1687 // should be set when creating the source or loading the state
1688 assert ((*chan)->write_source->destructive());
1692 /* the source list will never be reset for a destructive track */
1696 DiskWriter::adjust_buffering ()
1698 boost::shared_ptr<ChannelList> c = channels.reader();
1700 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
1701 (*chan)->resize (_session.butler()->audio_diskstream_capture_buffer_size());