093d77f19d966e01a7f5825eda70e7a9b0b911c8
[ardour.git] / libs / ardour / midi_diskstream.cc
1 /*
2     Copyright (C) 2000-2003 Paul Davis
3
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.
8
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.
13
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.
17 */
18
19 #include <fstream>
20 #include <cstdio>
21 #include <unistd.h>
22 #include <cmath>
23 #include <cerrno>
24 #include <string>
25 #include <climits>
26 #include <fcntl.h>
27 #include <cstdlib>
28 #include <ctime>
29 #include <sys/stat.h>
30 #include <sys/mman.h>
31
32 #include "pbd/error.h"
33 #include "pbd/basename.h"
34 #include <glibmm/thread.h>
35 #include "pbd/xml++.h"
36 #include "pbd/memento_command.h"
37 #include "pbd/enumwriter.h"
38 #include "pbd/stateful_diff_command.h"
39 #include "pbd/stacktrace.h"
40
41 #include "ardour/ardour.h"
42 #include "ardour/audioengine.h"
43 #include "ardour/butler.h"
44 #include "ardour/configuration.h"
45 #include "ardour/cycle_timer.h"
46 #include "ardour/debug.h"
47 #include "ardour/io.h"
48 #include "ardour/midi_diskstream.h"
49 #include "ardour/midi_model.h"
50 #include "ardour/midi_playlist.h"
51 #include "ardour/midi_port.h"
52 #include "ardour/midi_region.h"
53 #include "ardour/playlist_factory.h"
54 #include "ardour/region_factory.h"
55 #include "ardour/route.h"
56 #include "ardour/send.h"
57 #include "ardour/session.h"
58 #include "ardour/session_playlists.h"
59 #include "ardour/smf_source.h"
60 #include "ardour/utils.h"
61
62 #include "midi++/types.h"
63
64 #include "i18n.h"
65 #include <locale.h>
66
67 using namespace std;
68 using namespace ARDOUR;
69 using namespace PBD;
70
71 framecnt_t MidiDiskstream::midi_readahead = 4096;
72
73 MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
74         : Diskstream(sess, name, flag)
75         , _playback_buf(0)
76         , _capture_buf(0)
77         , _note_mode(Sustained)
78         , _frames_written_to_ringbuffer(0)
79         , _frames_read_from_ringbuffer(0)
80         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
81 {
82         in_set_state = true;
83
84         init ();
85         use_new_playlist ();
86         use_new_write_source (0);
87
88         in_set_state = false;
89
90         assert(!destructive());
91 }
92
93 MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
94         : Diskstream(sess, node)
95         , _playback_buf(0)
96         , _capture_buf(0)
97         , _note_mode(Sustained)
98         , _frames_written_to_ringbuffer(0)
99         , _frames_read_from_ringbuffer(0)
100         , _gui_feed_buffer(AudioEngine::instance()->raw_buffer_size (DataType::MIDI))
101 {
102         in_set_state = true;
103
104         init ();
105
106         if (set_state (node, Stateful::loading_state_version)) {
107                 in_set_state = false;
108                 throw failed_constructor();
109         }
110
111         use_new_write_source (0);
112
113         in_set_state = false;
114 }
115
116 void
117 MidiDiskstream::init ()
118 {
119         /* there are no channels at this point, so these
120            two calls just get speed_buffer_size and wrap_buffer
121            size setup without duplicating their code.
122         */
123
124         set_block_size (_session.get_block_size());
125         allocate_temporary_buffers ();
126
127         const size_t size = _session.butler()->midi_diskstream_buffer_size();
128         _playback_buf = new MidiRingBuffer<framepos_t>(size);
129         _capture_buf = new MidiRingBuffer<framepos_t>(size);
130
131         _n_channels = ChanCount(DataType::MIDI, 1);
132
133         assert(recordable());
134 }
135
136 MidiDiskstream::~MidiDiskstream ()
137 {
138         Glib::Mutex::Lock lm (state_lock);
139 }
140
141
142 void
143 MidiDiskstream::non_realtime_locate (framepos_t position)
144 {
145         if (_write_source) {
146                 _write_source->set_timeline_position (position);
147         }
148         seek (position, false);
149 }
150
151
152 void
153 MidiDiskstream::non_realtime_input_change ()
154 {
155         {
156                 Glib::Mutex::Lock lm (state_lock);
157
158                 if (input_change_pending.type == IOChange::NoChange) {
159                         return;
160                 }
161
162                 if (input_change_pending.type & IOChange::ConfigurationChanged) {
163                         uint32_t ni = _io->n_ports().n_midi();
164
165                         if (ni != _n_channels.n_midi()) {
166                                 error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
167                                                          name(),
168                                                          _io->n_ports(),
169                                                          _n_channels, input_change_pending.type)
170                                       << endmsg;
171                         }
172
173                         if (ni == 0) {
174                                 _source_port.reset ();
175                         } else {
176                                 _source_port = _io->midi(0);
177                         }
178                 }
179
180                 if (input_change_pending.type & IOChange::ConnectionsChanged) {
181                         set_capture_offset ();
182                         set_align_style_from_io ();
183                 }
184
185                 input_change_pending.type = IOChange::NoChange;
186
187                 /* implicit unlock */
188         }
189
190         /* unlike with audio, there is never any need to reset write sources
191            based on input configuration changes because ... a MIDI track
192            has just 1 MIDI port as input, always.
193         */
194
195         /* now refill channel buffers */
196
197         if (speed() != 1.0f || speed() != -1.0f) {
198                 seek ((framepos_t) (_session.transport_frame() * (double) speed()));
199         }
200         else {
201                 seek (_session.transport_frame());
202         }
203
204         if (_write_source) {
205                 _write_source->set_last_write_end (_session.transport_frame());
206         }
207 }
208
209 int
210 MidiDiskstream::find_and_use_playlist (const string& name)
211 {
212         boost::shared_ptr<MidiPlaylist> playlist;
213
214         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
215                 playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
216         }
217
218         if (!playlist) {
219                 error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
220                 return -1;
221         }
222
223         return use_playlist (playlist);
224 }
225
226 int
227 MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
228 {
229         assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
230
231         Diskstream::use_playlist(playlist);
232
233         return 0;
234 }
235
236 int
237 MidiDiskstream::use_new_playlist ()
238 {
239         string newname;
240         boost::shared_ptr<MidiPlaylist> playlist;
241
242         if (!in_set_state && destructive()) {
243                 return 0;
244         }
245
246         if (_playlist) {
247                 newname = Playlist::bump_name (_playlist->name(), _session);
248         } else {
249                 newname = Playlist::bump_name (_name, _session);
250         }
251
252         if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
253                         DataType::MIDI, _session, newname, hidden()))) != 0) {
254
255                 return use_playlist (playlist);
256
257         } else {
258                 return -1;
259         }
260 }
261
262 int
263 MidiDiskstream::use_copy_playlist ()
264 {
265         assert(midi_playlist());
266
267         if (destructive()) {
268                 return 0;
269         }
270
271         if (_playlist == 0) {
272                 error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
273                 return -1;
274         }
275
276         string newname;
277         boost::shared_ptr<MidiPlaylist> playlist;
278
279         newname = Playlist::bump_name (_playlist->name(), _session);
280
281         if ((playlist  = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
282                 return use_playlist (playlist);
283         } else {
284                 return -1;
285         }
286 }
287
288 /** Overloaded from parent to die horribly
289  */
290 int
291 MidiDiskstream::set_destructive (bool yn)
292 {
293         yn = 0; // stop pedantic gcc complaints about unused parameter
294         assert( ! destructive());
295         assert( ! yn);
296         return -1;
297 }
298
299 void
300 MidiDiskstream::set_note_mode (NoteMode m)
301 {
302         _note_mode = m;
303         midi_playlist()->set_note_mode(m);
304         if (_write_source && _write_source->model())
305                 _write_source->model()->set_note_mode(m);
306 }
307
308 #if 0
309 static void
310 trace_midi (ostream& o, MIDI::byte *msg, size_t len)
311 {
312         using namespace MIDI;
313         eventType type;
314         const char trace_prefix = ':';
315
316         type = (eventType) (msg[0]&0xF0);
317
318         switch (type) {
319         case off:
320                 o << trace_prefix
321                    << "Channel "
322                    << (msg[0]&0xF)+1
323                    << " NoteOff NoteNum "
324                    << (int) msg[1]
325                    << " Vel "
326                    << (int) msg[2]
327                    << endl;
328                 break;
329
330         case on:
331                 o << trace_prefix
332                    << "Channel "
333                    << (msg[0]&0xF)+1
334                    << " NoteOn NoteNum "
335                    << (int) msg[1]
336                    << " Vel "
337                    << (int) msg[2]
338                    << endl;
339                 break;
340
341         case polypress:
342                 o << trace_prefix
343                    << "Channel "
344                    << (msg[0]&0xF)+1
345                    << " PolyPressure"
346                    << (int) msg[1]
347                    << endl;
348                 break;
349
350         case MIDI::controller:
351                 o << trace_prefix
352                    << "Channel "
353                    << (msg[0]&0xF)+1
354                    << " Controller "
355                    << (int) msg[1]
356                    << " Value "
357                    << (int) msg[2]
358                    << endl;
359                 break;
360
361         case program:
362                 o << trace_prefix
363                    << "Channel "
364                    << (msg[0]&0xF)+1
365                    <<  " Program Change ProgNum "
366                    << (int) msg[1]
367                    << endl;
368                 break;
369
370         case chanpress:
371                 o << trace_prefix
372                    << "Channel "
373                    << (msg[0]&0xF)+1
374                    << " Channel Pressure "
375                    << (int) msg[1]
376                    << endl;
377                 break;
378
379         case MIDI::pitchbend:
380                 o << trace_prefix
381                    << "Channel "
382                    << (msg[0]&0xF)+1
383                    << " Pitch Bend "
384                    << ((msg[2]<<7)|msg[1])
385                    << endl;
386                 break;
387
388         case MIDI::sysex:
389                 if (len == 1) {
390                         switch (msg[0]) {
391                         case 0xf8:
392                                 o << trace_prefix
393                                    << "Clock"
394                                    << endl;
395                                 break;
396                         case 0xfa:
397                                 o << trace_prefix
398                                    << "Start"
399                                    << endl;
400                                 break;
401                         case 0xfb:
402                                 o << trace_prefix
403                                    << "Continue"
404                                    << endl;
405                                 break;
406                         case 0xfc:
407                                 o << trace_prefix
408                                    << "Stop"
409                                    << endl;
410                                 break;
411                         case 0xfe:
412                                 o << trace_prefix
413                                    << "Active Sense"
414                                    << endl;
415                                 break;
416                         case 0xff:
417                                 o << trace_prefix
418                                    << "System Reset"
419                                    << endl;
420                                 break;
421                         default:
422                                 o << trace_prefix
423                                    << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
424                                    << endl;
425                                 break;
426                         }
427                 } else {
428                         o << trace_prefix
429                            << "System Exclusive (" << len << ") = [ " << hex;
430                         for (unsigned int i = 0; i < len; ++i) {
431                                 o << (int) msg[i] << ' ';
432                         }
433                         o << dec << ']' << endl;
434
435                 }
436                 break;
437
438         case MIDI::song:
439                 o << trace_prefix << "Song" << endl;
440                 break;
441
442         case MIDI::tune:
443                 o << trace_prefix << "Tune" << endl;
444                 break;
445
446         case MIDI::eox:
447                 o << trace_prefix << "End-of-System Exclusive" << endl;
448                 break;
449
450         case MIDI::timing:
451                 o << trace_prefix << "Timing" << endl;
452                 break;
453
454         case MIDI::start:
455                 o << trace_prefix << "Start" << endl;
456                 break;
457
458         case MIDI::stop:
459                 o << trace_prefix << "Stop" << endl;
460                 break;
461
462         case MIDI::contineu:
463                 o << trace_prefix << "Continue" << endl;
464                 break;
465
466         case active:
467                 o << trace_prefix << "Active Sense" << endl;
468                 break;
469
470         default:
471                 o << trace_prefix << "Unrecognized MIDI message" << endl;
472                 break;
473         }
474 }
475 #endif
476
477 int
478 MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, framecnt_t& playback_distance)
479 {
480         framecnt_t rec_offset = 0;
481         framecnt_t rec_nframes = 0;
482         bool      nominally_recording;
483         bool      re = record_enabled ();
484         bool      can_record = _session.actively_recording ();
485
486         playback_distance = 0;
487
488         check_record_status (transport_frame, can_record);
489
490         nominally_recording = (can_record && re);
491
492         if (nframes == 0) {
493                 return 0;
494         }
495
496         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
497
498         if (sp == 0) {
499                 return 1;
500         }
501
502         Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
503
504         if (!sm.locked()) {
505                 return 1;
506         }
507
508         adjust_capture_position = 0;
509
510         if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
511                 OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
512
513                 calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
514
515                 if (rec_nframes && !was_recording) {
516                         _write_source->mark_write_starting_now ();
517                         capture_captured = 0;
518                         was_recording = true;
519                 }
520         }
521
522         if (can_record && !_last_capture_sources.empty()) {
523                 _last_capture_sources.clear ();
524         }
525
526         if (nominally_recording || rec_nframes) {
527
528                 // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
529                 MidiBuffer& buf = sp->get_midi_buffer(nframes);
530                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
531                         const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
532                         assert(ev.buffer());
533 #ifndef NDEBUG
534                         if (DEBUG::MidiIO & PBD::debug_bits) {
535                                 const uint8_t* __data = ev.buffer();
536                                 DEBUG_STR_DECL(a);
537                                 DEBUG_STR_APPEND(a, string_compose ("mididiskstream %1 capture event @ %2 + %3 sz %4 ", this, ev.time(), transport_frame, ev.size()));
538                                 for (size_t i=0; i < ev.size(); ++i) {
539                                         DEBUG_STR_APPEND(a,hex);
540                                         DEBUG_STR_APPEND(a,"0x");
541                                         DEBUG_STR_APPEND(a,(int)__data[i]);
542                                         DEBUG_STR_APPEND(a,' ');
543                                 }
544                                 DEBUG_STR_APPEND(a,'\n');
545                                 DEBUG_TRACE (DEBUG::MidiIO, DEBUG_STR(a).str());
546                         }
547 #endif
548                         _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
549                 }
550
551                 if (buf.size() != 0) {
552                         Glib::Mutex::Lock lm (_gui_feed_buffer_mutex, Glib::TRY_LOCK);
553
554                         if (lm.locked ()) {
555                                 /* Copy this data into our GUI feed buffer and tell the GUI
556                                    that it can read it if it likes.
557                                 */
558                                 _gui_feed_buffer.clear ();
559                                 
560                                 for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
561                                         /* This may fail if buf is larger than _gui_feed_buffer, but it's not really
562                                            the end of the world if it does.
563                                         */
564                                         _gui_feed_buffer.push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
565                                 }
566                         }
567
568                         DataRecorded (_write_source); /* EMIT SIGNAL */
569                 }
570
571         } else {
572
573                 if (was_recording) {
574                         finish_capture ();
575                 }
576
577         }
578
579         if (rec_nframes) {
580
581                 /* data will be written to disk */
582
583                 if (rec_nframes == nframes && rec_offset == 0) {
584                         playback_distance = nframes;
585                 }
586
587                 adjust_capture_position = rec_nframes;
588
589         } else if (nominally_recording) {
590
591                 /* XXXX do this for MIDI !!!
592                    can't do actual capture yet - waiting for latency effects to finish before we start
593                    */
594
595                 playback_distance = nframes;
596
597         } else {
598
599                 /* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
600
601                 playback_distance = nframes;
602
603         }
604
605         return 0;
606 }
607
608 bool
609 MidiDiskstream::commit (framecnt_t playback_distance)
610 {
611         bool need_butler = false;
612
613         if (_actual_speed < 0.0) {
614                 playback_sample -= playback_distance;
615         } else {
616                 playback_sample += playback_distance;
617         }
618
619         if (adjust_capture_position != 0) {
620                 capture_captured += adjust_capture_position;
621                 adjust_capture_position = 0;
622         }
623
624         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
625         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
626         if ((frames_written - frames_read) + playback_distance < midi_readahead) {
627                 need_butler = true;
628         }
629
630         /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
631                 " = " << frames_written - frames_read
632                 << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
633
634         return need_butler;
635 }
636
637 void
638 MidiDiskstream::set_pending_overwrite (bool yn)
639 {
640         /* called from audio thread, so we can use the read ptr and playback sample as we wish */
641
642         _pending_overwrite = yn;
643         overwrite_frame = playback_sample;
644 }
645
646 int
647 MidiDiskstream::overwrite_existing_buffers ()
648 {
649         /* This is safe as long as the butler thread is suspended, which it should be */
650         _playback_buf->reset ();
651
652         g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
653         g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
654
655         read (overwrite_frame, disk_io_chunk_frames, false);
656         file_frame = overwrite_frame; // it was adjusted by ::read()
657         overwrite_queued = false;
658         _pending_overwrite = false;
659
660         return 0;
661 }
662
663 int
664 MidiDiskstream::seek (framepos_t frame, bool complete_refill)
665 {
666         Glib::Mutex::Lock lm (state_lock);
667         int ret = -1;
668
669         _playback_buf->reset();
670         _capture_buf->reset();
671         g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
672         g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
673
674         playback_sample = frame;
675         file_frame = frame;
676
677         if (complete_refill) {
678                 while ((ret = do_refill_with_alloc ()) > 0) ;
679         } else {
680                 ret = do_refill_with_alloc ();
681         }
682
683         return ret;
684 }
685
686 int
687 MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
688 {
689         uint32_t frames_read    = g_atomic_int_get(&_frames_read_from_ringbuffer);
690         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
691         return ((frames_written - frames_read) < distance);
692 }
693
694 int
695 MidiDiskstream::internal_playback_seek (framecnt_t distance)
696 {
697         first_recordable_frame += distance;
698         playback_sample += distance;
699
700         return 0;
701 }
702
703 /** @a start is set to the new frame position (TIME) read up to */
704 int
705 MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
706 {
707         framecnt_t this_read = 0;
708         bool reloop = false;
709         framepos_t loop_end = 0;
710         framepos_t loop_start = 0;
711         Location *loc = 0;
712
713         if (!reversed) {
714
715                 framecnt_t loop_length = 0;
716
717                 /* Make the use of a Location atomic for this read operation.
718
719                    Note: Locations don't get deleted, so all we care about
720                    when I say "atomic" is that we are always pointing to
721                    the same one and using a start/length values obtained
722                    just once.
723                 */
724
725                 if ((loc = loop_location) != 0) {
726                         loop_start = loc->start();
727                         loop_end = loc->end();
728                         loop_length = loop_end - loop_start;
729                 }
730
731                 /* if we are looping, ensure that the first frame we read is at the correct
732                    position within the loop.
733                 */
734
735                 if (loc && (start >= loop_end)) {
736                         //cerr << "start adjusted from " << start;
737                         start = loop_start + ((start - loop_start) % loop_length);
738                         //cerr << "to " << start << endl;
739                 }
740                 //cerr << "start is " << start << "  loopstart: " << loop_start << "  loopend: " << loop_end << endl;
741         }
742
743         while (dur) {
744
745                 /* take any loop into account. we can't read past the end of the loop. */
746
747                 if (loc && (loop_end - start < dur)) {
748                         this_read = loop_end - start;
749                         //cerr << "reloop true: thisread: " << this_read << "  dur: " << dur << endl;
750                         reloop = true;
751                 } else {
752                         reloop = false;
753                         this_read = dur;
754                 }
755
756                 if (this_read == 0) {
757                         break;
758                 }
759
760                 this_read = min(dur,this_read);
761
762                 if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
763                         error << string_compose(
764                                         _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
765                                         id(), this_read, start) << endmsg;
766                         return -1;
767                 }
768
769                 g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
770
771                 if (reversed) {
772
773                         // Swap note ons with note offs here.  etc?
774                         // Fully reversing MIDI requires look-ahead (well, behind) to find previous
775                         // CC values etc.  hard.
776
777                 } else {
778
779                         /* if we read to the end of the loop, go back to the beginning */
780
781                         if (reloop) {
782                                 // Synthesize LoopEvent here, because the next events
783                                 // written will have non-monotonic timestamps.
784                                 _playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
785                                 start = loop_start;
786                         } else {
787                                 start += this_read;
788                         }
789                 }
790
791                 dur -= this_read;
792                 //offset += this_read;
793         }
794
795         return 0;
796 }
797
798 int
799 MidiDiskstream::do_refill_with_alloc ()
800 {
801         return do_refill();
802 }
803
804 int
805 MidiDiskstream::do_refill ()
806 {
807         int     ret         = 0;
808         size_t  write_space = _playback_buf->write_space();
809         bool    reversed    = (_visible_speed * _session.transport_speed()) < 0.0f;
810
811         if (write_space == 0) {
812                 return 0;
813         }
814
815         if (reversed) {
816                 return 0;
817         }
818
819         /* at end: nothing to do */
820         if (file_frame == max_framepos) {
821                 return 0;
822         }
823
824         // At this point we...
825         assert(_playback_buf->write_space() > 0); // ... have something to write to, and
826         assert(file_frame <= max_framepos); // ... something to write
827
828         // now calculate how much time is in the ringbuffer.
829         // and lets write as much as we need to get this to be midi_readahead;
830         uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
831         uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
832         if ((frames_written - frames_read) >= midi_readahead) {
833                 return 0;
834         }
835
836         framecnt_t to_read = midi_readahead - (frames_written - frames_read);
837
838         //cout << "MDS read for midi_readahead " << to_read << "  rb_contains: "
839         //      << frames_written - frames_read << endl;
840
841         to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
842
843         if (read (file_frame, to_read, reversed)) {
844                 ret = -1;
845         }
846
847         return ret;
848 }
849
850 /** Flush pending data to disk.
851  *
852  * Important note: this function will write *AT MOST* disk_io_chunk_frames
853  * of data to disk. it will never write more than that.  If it writes that
854  * much and there is more than that waiting to be written, it will return 1,
855  * otherwise 0 on success or -1 on failure.
856  *
857  * If there is less than disk_io_chunk_frames to be written, no data will be
858  * written at all unless @a force_flush is true.
859  */
860 int
861 MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
862 {
863         framecnt_t to_write;
864         framecnt_t total;
865         int32_t ret = 0;
866
867         if (!_write_source) {
868                 return 0;
869         }
870
871         assert (!destructive());
872
873         total = _session.transport_frame() - _write_source->last_write_end();
874
875         if (total == 0 || 
876             _capture_buf->read_space() == 0 || 
877             (!force_flush && (total < disk_io_chunk_frames) && was_recording)) {
878                 goto out;
879         }
880
881         /* if there are 2+ chunks of disk i/o possible for
882            this track, let the caller know so that it can arrange
883            for us to be called again, ASAP.
884
885            if we are forcing a flush, then if there is* any* extra
886            work, let the caller know.
887
888            if we are no longer recording and there is any extra work,
889            let the caller know too.
890            */
891
892         if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
893                 ret = 1;
894         }
895
896         if (force_flush) {
897                 /* push out everything we have, right now */
898                 to_write = max_framecnt;
899         } else {
900                 to_write = disk_io_chunk_frames;
901         }
902
903         if (record_enabled() && ((total > disk_io_chunk_frames) || force_flush)) {
904                 if (_write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
905                         error << string_compose(_("MidiDiskstream %1: cannot write to disk"), id()) << endmsg;
906                         return -1;
907                 } 
908         }
909
910 out:
911         return ret;
912 }
913
914 void
915 MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
916 {
917         bool more_work = true;
918         int err = 0;
919         boost::shared_ptr<MidiRegion> region;
920         MidiRegion::SourceList srcs;
921         MidiRegion::SourceList::iterator src;
922         vector<CaptureInfo*>::iterator ci;
923
924         finish_capture ();
925
926         /* butler is already stopped, but there may be work to do
927            to flush remaining data to disk.
928            */
929
930         while (more_work && !err) {
931                 switch (do_flush (TransportContext, true)) {
932                 case 0:
933                         more_work = false;
934                         break;
935                 case 1:
936                         break;
937                 case -1:
938                         error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
939                         err++;
940                 }
941         }
942
943         /* XXX is there anything we can do if err != 0 ? */
944         Glib::Mutex::Lock lm (capture_info_lock);
945
946         if (capture_info.empty()) {
947                 goto no_capture_stuff_to_do;
948         }
949
950         if (abort_capture) {
951
952                 if (_write_source) {
953                         _write_source->mark_for_remove ();
954                         _write_source->drop_references ();
955                         _write_source.reset();
956                 }
957
958                 /* new source set up in "out" below */
959
960         } else {
961
962                 assert(_write_source);
963
964                 framecnt_t total_capture = 0;
965                 for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
966                         total_capture += (*ci)->frames;
967                 }
968
969                 if (_write_source->length (capture_info.front()->start) != 0) {
970
971                         /* phew, we have data */
972
973                         /* figure out the name for this take */
974
975                         srcs.push_back (_write_source);
976
977                         _write_source->set_timeline_position (capture_info.front()->start);
978                         _write_source->set_captured_for (_name);
979
980                         /* set length in beats to entire capture length */
981
982                         BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
983                         const double total_capture_beats = converter.from (total_capture);
984                         _write_source->set_length_beats (total_capture_beats);
985
986                         /* flush to disk: this step differs from the audio path,
987                            where all the data is already on disk.
988                         */
989
990                         _write_source->mark_midi_streaming_write_completed (Evoral::Sequence<Evoral::MusicalTime>::ResolveStuckNotes, total_capture_beats);
991
992                         /* we will want to be able to keep (over)writing the source
993                            but we don't want it to be removable. this also differs
994                            from the audio situation, where the source at this point
995                            must be considered immutable. luckily, we can rely on
996                            MidiSource::mark_streaming_write_completed() to have
997                            already done the necessary work for that.
998                         */
999
1000                         string whole_file_region_name;
1001                         whole_file_region_name = region_name_from_path (_write_source->name(), true);
1002
1003                         /* Register a new region with the Session that
1004                            describes the entire source. Do this first
1005                            so that any sub-regions will obviously be
1006                            children of this one (later!)
1007                         */
1008
1009                         try {
1010                                 PropertyList plist;
1011
1012                                 plist.add (Properties::name, whole_file_region_name);
1013                                 plist.add (Properties::whole_file, true);
1014                                 plist.add (Properties::automatic, true);
1015                                 plist.add (Properties::start, 0);
1016                                 plist.add (Properties::length, total_capture);
1017                                 plist.add (Properties::layer, 0);
1018
1019                                 boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1020
1021                                 region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1022                                 region->special_set_position (capture_info.front()->start);
1023                         }
1024
1025
1026                         catch (failed_constructor& err) {
1027                                 error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
1028                                 /* XXX what now? */
1029                         }
1030
1031                         _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
1032
1033                         _playlist->clear_changes ();
1034                         _playlist->freeze ();
1035
1036                         /* Session frame time of the initial capture in this pass, which is where the source starts */
1037                         framepos_t initial_capture = 0;
1038                         if (!capture_info.empty()) {
1039                                 initial_capture = capture_info.front()->start;
1040                         }
1041
1042                         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1043
1044                                 string region_name;
1045
1046                                 RegionFactory::region_name (region_name, _write_source->name(), false);
1047
1048                                 // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
1049
1050                                 try {
1051                                         PropertyList plist;
1052
1053                                         /* start of this region is the offset between the start of its capture and the start of the whole pass */
1054                                         plist.add (Properties::start, (*ci)->start - initial_capture);
1055                                         plist.add (Properties::length, (*ci)->frames);
1056                                         plist.add (Properties::length_beats, converter.from((*ci)->frames));
1057                                         plist.add (Properties::name, region_name);
1058
1059                                         boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
1060                                         region = boost::dynamic_pointer_cast<MidiRegion> (rx);
1061                                 }
1062
1063                                 catch (failed_constructor& err) {
1064                                         error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
1065                                         continue; /* XXX is this OK? */
1066                                 }
1067
1068                                 // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
1069
1070                                 i_am_the_modifier++;
1071                                 _playlist->add_region (region, (*ci)->start);
1072                                 i_am_the_modifier--;
1073                         }
1074
1075                         _playlist->thaw ();
1076                         _session.add_command (new StatefulDiffCommand(_playlist));
1077
1078                 } else {
1079
1080                         /* No data was recorded, so this capture will
1081                            effectively be aborted; do the same as we
1082                            do for an explicit abort.
1083                         */
1084
1085                         if (_write_source) {
1086                                 _write_source->mark_for_remove ();
1087                                 _write_source->drop_references ();
1088                                 _write_source.reset();
1089                         }
1090                 }
1091
1092         }
1093
1094         use_new_write_source (0);
1095
1096         for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
1097                 delete *ci;
1098         }
1099
1100         capture_info.clear ();
1101         capture_start_frame = 0;
1102
1103   no_capture_stuff_to_do:
1104
1105         if (_playlist) {
1106                 midi_playlist()->clear_note_trackers ();
1107         }
1108 }
1109
1110 void
1111 MidiDiskstream::transport_looped (framepos_t transport_frame)
1112 {
1113         if (was_recording) {
1114
1115                 // adjust the capture length knowing that the data will be recorded to disk
1116                 // only necessary after the first loop where we're recording
1117                 if (capture_info.size() == 0) {
1118                         capture_captured += _capture_offset;
1119
1120                         if (_alignment_style == ExistingMaterial) {
1121                                 capture_captured += _session.worst_output_latency();
1122                         } else {
1123                                 capture_captured += _roll_delay;
1124                         }
1125                 }
1126
1127                 finish_capture ();
1128
1129                 // the next region will start recording via the normal mechanism
1130                 // we'll set the start position to the current transport pos
1131                 // no latency adjustment or capture offset needs to be made, as that already happened the first time
1132                 capture_start_frame = transport_frame;
1133                 first_recordable_frame = transport_frame; // mild lie
1134                 last_recordable_frame = max_framepos;
1135                 was_recording = true;
1136         }
1137 }
1138
1139 void
1140 MidiDiskstream::finish_capture ()
1141 {
1142         was_recording = false;
1143
1144         if (capture_captured == 0) {
1145                 return;
1146         }
1147
1148         // Why must we destroy?
1149         assert(!destructive());
1150
1151         CaptureInfo* ci = new CaptureInfo;
1152
1153         ci->start  = capture_start_frame;
1154         ci->frames = capture_captured;
1155
1156         /* XXX theoretical race condition here. Need atomic exchange ?
1157            However, the circumstances when this is called right
1158            now (either on record-disable or transport_stopped)
1159            mean that no actual race exists. I think ...
1160            We now have a capture_info_lock, but it is only to be used
1161            to synchronize in the transport_stop and the capture info
1162            accessors, so that invalidation will not occur (both non-realtime).
1163         */
1164
1165         // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
1166
1167         capture_info.push_back (ci);
1168         capture_captured = 0;
1169 }
1170
1171 void
1172 MidiDiskstream::set_record_enabled (bool yn)
1173 {
1174         if (!recordable() || !_session.record_enabling_legal()) {
1175                 return;
1176         }
1177
1178         assert(!destructive());
1179
1180         /* yes, i know that this not proof against race conditions, but its
1181            good enough. i think.
1182         */
1183
1184         if (record_enabled() != yn) {
1185                 if (yn) {
1186                         engage_record_enable ();
1187                 } else {
1188                         disengage_record_enable ();
1189                 }
1190         }
1191 }
1192
1193 void
1194 MidiDiskstream::engage_record_enable ()
1195 {
1196         bool const rolling = _session.transport_speed() != 0.0f;
1197
1198         g_atomic_int_set (&_record_enabled, 1);
1199
1200         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1201         
1202         if (sp && Config->get_monitoring_model() == HardwareMonitoring) {
1203                 sp->request_jack_monitors_input (!(_session.config.get_auto_input() && rolling));
1204         }
1205
1206         RecordEnableChanged (); /* EMIT SIGNAL */
1207 }
1208
1209 void
1210 MidiDiskstream::disengage_record_enable ()
1211 {
1212         g_atomic_int_set (&_record_enabled, 0);
1213         RecordEnableChanged (); /* EMIT SIGNAL */
1214 }
1215
1216 XMLNode&
1217 MidiDiskstream::get_state ()
1218 {
1219         XMLNode& node (Diskstream::get_state());
1220         char buf[64];
1221         LocaleGuard lg (X_("POSIX"));
1222
1223         node.add_property("channel-mode", enum_2_string(get_channel_mode()));
1224         snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
1225         node.add_property("channel-mask", buf);
1226
1227         if (_write_source && _session.get_record_enabled()) {
1228
1229                 XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
1230                 XMLNode* cs_grandchild;
1231
1232                 cs_grandchild = new XMLNode (X_("file"));
1233                 cs_grandchild->add_property (X_("path"), _write_source->path());
1234                 cs_child->add_child_nocopy (*cs_grandchild);
1235
1236                 /* store the location where capture will start */
1237
1238                 Location* pi;
1239
1240                 if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
1241                         snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
1242                 } else {
1243                         snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
1244                 }
1245
1246                 cs_child->add_property (X_("at"), buf);
1247                 node.add_child_nocopy (*cs_child);
1248         }
1249
1250         return node;
1251 }
1252
1253 int
1254 MidiDiskstream::set_state (const XMLNode& node, int version)
1255 {
1256         const XMLProperty* prop;
1257         XMLNodeList nlist = node.children();
1258         XMLNodeIterator niter;
1259         XMLNode* capture_pending_node = 0;
1260         LocaleGuard lg (X_("POSIX"));
1261
1262         /* prevent write sources from being created */
1263
1264         in_set_state = true;
1265
1266         for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
1267                 assert ((*niter)->name() != IO::state_node_name);
1268
1269                 if ((*niter)->name() == X_("CapturingSources")) {
1270                         capture_pending_node = *niter;
1271                 }
1272         }
1273
1274         if (Diskstream::set_state (node, version)) {
1275                 return -1;
1276         }
1277
1278         ChannelMode channel_mode = AllChannels;
1279         if ((prop = node.property ("channel-mode")) != 0) {
1280                 channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
1281         }
1282
1283         unsigned int channel_mask = 0xFFFF;
1284         if ((prop = node.property ("channel-mask")) != 0) {
1285                 sscanf (prop->value().c_str(), "0x%x", &channel_mask);
1286                 if (channel_mask & (~0xFFFF)) {
1287                         warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
1288                 }
1289         }
1290
1291
1292         if (capture_pending_node) {
1293                 use_pending_capture_data (*capture_pending_node);
1294         }
1295
1296         set_channel_mode (channel_mode, channel_mask);
1297
1298         in_set_state = false;
1299
1300         return 0;
1301 }
1302
1303 int
1304 MidiDiskstream::use_new_write_source (uint32_t n)
1305 {
1306         if (!_session.writable() || !recordable()) {
1307                 return 1;
1308         }
1309
1310         assert(n == 0);
1311
1312         _write_source.reset();
1313
1314         try {
1315                 _write_source = boost::dynamic_pointer_cast<SMFSource>(
1316                         _session.create_midi_source_for_session (0, name ()));
1317
1318                 if (!_write_source) {
1319                         throw failed_constructor();
1320                 }
1321         }
1322
1323         catch (failed_constructor &err) {
1324                 error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
1325                 _write_source.reset();
1326                 return -1;
1327         }
1328
1329         return 0;
1330 }
1331
1332 list<boost::shared_ptr<Source> >
1333 MidiDiskstream::steal_write_sources()
1334 {
1335         list<boost::shared_ptr<Source> > ret;
1336
1337         /* put some data on the disk, even if its just a header for an empty file */
1338         boost::dynamic_pointer_cast<SMFSource> (_write_source)->ensure_disk_file ();
1339
1340         /* never let it go away */
1341         _write_source->mark_nonremovable ();
1342
1343         ret.push_back (_write_source);
1344
1345         /* get a new one */
1346
1347         use_new_write_source (0);
1348
1349         return ret;
1350 }
1351
1352 void
1353 MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
1354 {
1355         if (!_session.writable() || !recordable()) {
1356                 return;
1357         }
1358
1359         if (_write_source && mark_write_complete) {
1360                 _write_source->mark_streaming_write_completed ();
1361         }
1362         use_new_write_source (0);
1363 }
1364
1365 void
1366 MidiDiskstream::set_block_size (pframes_t /*nframes*/)
1367 {
1368 }
1369
1370 void
1371 MidiDiskstream::allocate_temporary_buffers ()
1372 {
1373 }
1374
1375 void
1376 MidiDiskstream::monitor_input (bool yn)
1377 {
1378         boost::shared_ptr<MidiPort> sp = _source_port.lock ();
1379         
1380         if (sp) {
1381                 sp->ensure_jack_monitors_input (yn);
1382         }
1383 }
1384
1385 void
1386 MidiDiskstream::set_align_style_from_io ()
1387 {
1388         if (_alignment_choice != Automatic) {
1389                 return;
1390         }
1391
1392         /* XXX Not sure what, if anything we can do with MIDI
1393            as far as capture alignment etc.
1394         */
1395
1396         set_align_style (ExistingMaterial);
1397 }
1398
1399
1400 float
1401 MidiDiskstream::playback_buffer_load () const
1402 {
1403         /* For MIDI it's not trivial to differentiate the following two cases:
1404            
1405            1.  The playback buffer is empty because the system has run out of time to fill it.
1406            2.  The playback buffer is empty because there is no more data on the playlist.
1407
1408            If we use a simple buffer load computation, we will report that the MIDI diskstream
1409            cannot keep up when #2 happens, when in fact it can.  Since MIDI data rates
1410            are so low compared to audio, just give a pretend answer here.
1411         */
1412         
1413         return 1;
1414 }
1415
1416 float
1417 MidiDiskstream::capture_buffer_load () const
1418 {
1419         /* We don't report playback buffer load, so don't report capture load either */
1420         
1421         return 1;
1422 }
1423
1424 int
1425 MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
1426 {
1427         return 0;
1428 }
1429
1430 /** Writes playback events from playback_sample for nframes to dst, translating time stamps
1431  *  so that an event at playback_sample has time = 0
1432  */
1433 void
1434 MidiDiskstream::get_playback (MidiBuffer& dst, framecnt_t nframes)
1435 {
1436         dst.clear();
1437         assert(dst.size() == 0);
1438
1439 #ifndef NDEBUG
1440         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1441                              "%1 MDS pre-read read %4..%5 from %2 write to %3\n", _name,
1442                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr(), playback_sample, playback_sample + nframes));
1443 //        cerr << "================\n";
1444 //        _playback_buf->dump (cerr);
1445 //        cerr << "----------------\n";
1446
1447         const size_t events_read = _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1448         DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
1449                              "%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
1450                              _name, events_read, playback_sample, playback_sample + nframes,
1451                              _playback_buf->read_space(), _playback_buf->write_space(),
1452                              _playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
1453 #else
1454         _playback_buf->read (dst, playback_sample, playback_sample + nframes);
1455 #endif
1456
1457         g_atomic_int_add (&_frames_read_from_ringbuffer, nframes);
1458 }
1459
1460 bool
1461 MidiDiskstream::set_name (string const & name)
1462 {
1463         Diskstream::set_name (name);
1464
1465         /* get a new write source so that its name reflects the new diskstream name */
1466         use_new_write_source (0);
1467
1468         return true;
1469 }
1470
1471 boost::shared_ptr<MidiBuffer>
1472 MidiDiskstream::get_gui_feed_buffer () const
1473 {
1474         boost::shared_ptr<MidiBuffer> b (new MidiBuffer (AudioEngine::instance()->raw_buffer_size (DataType::MIDI)));
1475         
1476         Glib::Mutex::Lock lm (_gui_feed_buffer_mutex);
1477         b->copy (_gui_feed_buffer);
1478         return b;
1479 }