libs/ardour/smf_source.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3         Written by Dave Robillard, 2006
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include <vector>
  22
  23 #include <sys/time.h>
  24 #include <sys/stat.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27
  28 #include "pbd/mountpoint.h"
  29 #include "pbd/pathscanner.h"
  30 #include "pbd/stl_delete.h"
  31 #include "pbd/strsplit.h"
  32
  33 #include <glibmm/miscutils.h>
  34
  35 #include "evoral/Control.hpp"
  36
  37 #include "ardour/audioengine.h"
  38 #include "ardour/event_type_map.h"
  39 #include "ardour/midi_model.h"
  40 #include "ardour/midi_ring_buffer.h"
  41 #include "ardour/midi_state_tracker.h"
  42 #include "ardour/session.h"
  43 #include "ardour/smf_source.h"
  44
  45 #include "i18n.h"
  46
  47 using namespace ARDOUR;
  48 using namespace Glib;
  49
  50 /** Constructor used for new internal-to-session files.  File cannot exist. */
  51 SMFSource::SMFSource (Session& s, const ustring& path, Source::Flag flags)
  52         : Source(s, DataType::MIDI, path, flags)
  53         , MidiSource(s, path)
  54         , FileSource(s, DataType::MIDI, path, flags)
  55         , Evoral::SMF()
  56         , _last_ev_time_beats(0.0)
  57         , _last_ev_time_frames(0)
  58         , _smf_last_read_end (0)
  59         , _smf_last_read_time (0)
  60 {
  61         if (init(_path, false)) {
  62                 throw failed_constructor ();
  63         }
  64
  65         if (create(path)) {
  66                 throw failed_constructor ();
  67         }
  68
  69         load_model(true, true); // FIXME
  70 }
  71
  72 /** Constructor used for existing internal-to-session files. */
  73 SMFSource::SMFSource (Session& s, const XMLNode& node, bool must_exist)
  74         : Source(s, node)
  75         , MidiSource(s, node)
  76         , FileSource(s, node, must_exist)
  77         , _last_ev_time_beats(0.0)
  78         , _last_ev_time_frames(0)
  79         , _smf_last_read_end (0)
  80         , _smf_last_read_time (0)
  81 {
  82         if (set_state(node, Stateful::loading_state_version)) {
  83                 throw failed_constructor ();
  84         }
  85
  86         if (init(_path, true)) {
  87                 throw failed_constructor ();
  88         }
  89
  90         if (open(_path)) {
  91                 throw failed_constructor ();
  92         }
  93
  94         load_model(true, true); // FIXME
  95 }
  96
  97 SMFSource::~SMFSource ()
  98 {
  99         if (removable()) {
 100                 unlink (_path.c_str());
 101         }
 102 }
 103
 104 /** All stamps in audio frames */
 105 nframes_t
 106 SMFSource::read_unlocked (Evoral::EventSink<nframes_t>& destination, sframes_t source_start,
 107                           sframes_t start, nframes_t duration,
 108                           sframes_t stamp_offset, sframes_t negative_stamp_offset,
 109                           MidiStateTracker* tracker) const
 110 {
 111         int      ret  = 0;
 112         uint64_t time = 0; // in SMF ticks, 1 tick per _ppqn
 113
 114         _read_data_count = 0;
 115
 116         // Output parameters for read_event (which will allocate scratch in buffer as needed)
 117         uint32_t ev_delta_t = 0;
 118         uint32_t ev_type    = 0;
 119         uint32_t ev_size    = 0;
 120         uint8_t* ev_buffer  = 0;
 121
 122         size_t scratch_size = 0; // keep track of scratch to minimize reallocs
 123
 124         BeatsFramesConverter converter(_session.tempo_map(), source_start);
 125
 126         const uint64_t start_ticks = (uint64_t)(converter.from(start) * ppqn());
 127
 128         if (_smf_last_read_end == 0 || start != _smf_last_read_end) {
 129                 //cerr << "SMFSource::read_unlocked seeking to " << start << endl;
 130                 Evoral::SMF::seek_to_start();
 131                 while (time < start_ticks) {
 132                         ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
 133                         if (ret == -1) { // EOF
 134                                 _smf_last_read_end = start + duration;
 135                                 return duration;
 136                         }
 137                         time += ev_delta_t; // accumulate delta time
 138                 }
 139         } else {
 140                 time = _smf_last_read_time;
 141         }
 142
 143         _smf_last_read_end = start + duration;
 144
 145         while (true) {
 146                 ret = read_event(&ev_delta_t, &ev_size, &ev_buffer);
 147                 if (ret == -1) { // EOF
 148                         break;
 149                 }
 150
 151                 time += ev_delta_t; // accumulate delta time
 152                 _smf_last_read_time = time;
 153
 154                 if (ret == 0) { // meta-event (skipped, just accumulate time)
 155                         continue;
 156                 }
 157
 158                 ev_type = EventTypeMap::instance().midi_event_type(ev_buffer[0]);
 159
 160 #if 0
 161                 cerr << "+++ SMF source read "
 162                      << " delta = " << ev_delta_t
 163                      << " time = " << time
 164                      << " buf[0] " << hex << (int) ev_buffer[0] << dec
 165                      << " type = " << ev_type;
 166 #endif
 167
 168                 assert(time >= start_ticks);
 169                 const sframes_t ev_frame_time = converter.to(time / (double)ppqn()) + stamp_offset;
 170
 171 #if 0
 172                 cerr << " frames = " << ev_frame_time
 173                      << " w/offset = " << ev_frame_time - negative_stamp_offset
 174                      << endl;
 175 #endif
 176
 177                 if (ev_frame_time < start + duration) {
 178                         destination.write(ev_frame_time - negative_stamp_offset, ev_type, ev_size, ev_buffer);
 179
 180                         if (tracker) {
 181                                 if (ev_buffer[0] & MIDI_CMD_NOTE_ON) {
 182                                         tracker->add (ev_buffer[1], ev_buffer[0] & 0xf);
 183                                 } else if (ev_buffer[0] & MIDI_CMD_NOTE_OFF) {
 184                                         tracker->remove (ev_buffer[1], ev_buffer[0] & 0xf);
 185                                 }
 186                         }
 187                 } else {
 188                         break;
 189                 }
 190
 191                 _read_data_count += ev_size;
 192
 193                 if (ev_size > scratch_size) {
 194                         scratch_size = ev_size;
 195                 }
 196                 ev_size = scratch_size; // ensure read_event only allocates if necessary
 197         }
 198
 199         return duration;
 200 }
 201
 202 /** All stamps in audio frames */
 203 nframes_t
 204 SMFSource::write_unlocked (MidiRingBuffer<nframes_t>& source, sframes_t position, nframes_t duration)
 205 {
 206         _write_data_count = 0;
 207
 208         nframes_t         time;
 209         Evoral::EventType type;
 210         uint32_t          size;
 211
 212         size_t   buf_capacity = 4;
 213         uint8_t* buf          = (uint8_t*)malloc(buf_capacity);
 214
 215         if (_model && ! _model->writing()) {
 216                 _model->start_write();
 217         }
 218
 219         Evoral::MIDIEvent<nframes_t> ev;
 220
 221         while (true) {
 222                 bool ret = source.peek_time(&time);
 223                 if (!ret || time > _last_write_end + duration) {
 224                         break;
 225                 }
 226
 227                 ret = source.read_prefix(&time, &type, &size);
 228                 if (!ret) {
 229                         cerr << "ERROR: Unable to read event prefix, corrupt MIDI ring buffer" << endl;
 230                         break;
 231                 }
 232
 233                 if (size > buf_capacity) {
 234                         buf_capacity = size;
 235                         buf = (uint8_t*)realloc(buf, size);
 236                 }
 237
 238                 ret = source.read_contents(size, buf);
 239                 if (!ret) {
 240                         cerr << "ERROR: Read time/size but not buffer, corrupt MIDI ring buffer" << endl;
 241                         break;
 242                 }
 243
 244                 assert(time >= position);
 245                 time -= position;
 246
 247                 ev.set(buf, size, time);
 248                 ev.set_event_type(EventTypeMap::instance().midi_event_type(ev.buffer()[0]));
 249                 if (!(ev.is_channel_event() || ev.is_smf_meta_event() || ev.is_sysex())) {
 250                         /*cerr << "SMFSource: WARNING: caller tried to write non SMF-Event of type "
 251                                         << std::hex << int(ev.buffer()[0]) << endl;*/
 252                         continue;
 253                 }
 254
 255                 append_event_unlocked_frames(ev, position);
 256         }
 257
 258         if (_model) {
 259                 set_default_controls_interpolation();
 260         }
 261
 262         Evoral::SMF::flush();
 263         free(buf);
 264
 265         ViewDataRangeReady(position + _last_write_end, duration); /* EMIT SIGNAL */
 266
 267         return duration;
 268 }
 269
 270
 271 /** Append an event with a timestamp in beats (double) */
 272 void
 273 SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
 274 {
 275         assert(_writing);
 276         if (ev.size() == 0)  {
 277                 return;
 278         }
 279
 280         /*printf("SMFSource: %s - append_event_unlocked_beats time = %lf, size = %u, data = ",
 281                         name().c_str(), ev.time(), ev.size());
 282         for (size_t i = 0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
 283
 284         assert(ev.time() >= 0);
 285         if (ev.time() < _last_ev_time_beats) {
 286                 cerr << "SMFSource: Warning: Skipping event with non-monotonic time" << endl;
 287                 return;
 288         }
 289
 290         _length_beats = max(_length_beats, ev.time());
 291
 292         const double delta_time_beats   = ev.time() - _last_ev_time_beats;
 293         const uint32_t delta_time_ticks = (uint32_t)lrint(delta_time_beats * (double)ppqn());
 294
 295         Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
 296         _last_ev_time_beats = ev.time();
 297
 298         _write_data_count += ev.size();
 299
 300         if (_model) {
 301                 _model->append(ev);
 302         }
 303 }
 304
 305 /** Append an event with a timestamp in frames (nframes_t) */
 306 void
 307 SMFSource::append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev, sframes_t position)
 308 {
 309         assert(_writing);
 310         if (ev.size() == 0)  {
 311                 return;
 312         }
 313
 314         /*printf("SMFSource: %s - append_event_unlocked_frames time = %u, size = %u, data = ",
 315                         name().c_str(), ev.time(), ev.size());
 316         for (size_t i=0; i < ev.size(); ++i) printf("%X ", ev.buffer()[i]); printf("\n");*/
 317
 318         if (ev.time() < _last_ev_time_frames) {
 319                 cerr << "SMFSource: Warning: Skipping event with non-monotonic time" << endl;
 320                 return;
 321         }
 322
 323         BeatsFramesConverter converter(_session.tempo_map(), position);
 324
 325         _length_beats = max(_length_beats, converter.from(ev.time()));
 326
 327         const sframes_t delta_time_frames = ev.time() - _last_ev_time_frames;
 328         const double    delta_time_beats  = converter.from(delta_time_frames);
 329         const uint32_t  delta_time_ticks  = (uint32_t)(lrint(delta_time_beats * (double)ppqn()));
 330
 331         Evoral::SMF::append_event_delta(delta_time_ticks, ev.size(), ev.buffer());
 332         _last_ev_time_frames = ev.time();
 333
 334         _write_data_count += ev.size();
 335
 336         if (_model) {
 337                 const double ev_time_beats = converter.from(ev.time());
 338                 const Evoral::Event<double> beat_ev(
 339                                 ev.event_type(), ev_time_beats, ev.size(), (uint8_t*)ev.buffer());
 340                 _model->append(beat_ev);
 341         }
 342 }
 343
 344 XMLNode&
 345 SMFSource::get_state ()
 346 {
 347         return MidiSource::get_state();
 348 }
 349
 350 int
 351 SMFSource::set_state (const XMLNode& node, int version)
 352 {
 353         if (Source::set_state (node, version)) {
 354                 return -1;
 355         }
 356
 357         if (MidiSource::set_state (node, version)) {
 358                 return -1;
 359         }
 360
 361         if (FileSource::set_state (node, version)) {
 362                 return -1;
 363         }
 364
 365         return 0;
 366 }
 367
 368 void
 369 SMFSource::mark_streaming_midi_write_started (NoteMode mode, sframes_t start_frame)
 370 {
 371         Glib::Mutex::Lock lm (_lock);
 372         MidiSource::mark_streaming_midi_write_started (mode, start_frame);
 373         Evoral::SMF::begin_write ();
 374         _last_ev_time_beats = 0.0;
 375         _last_ev_time_frames = 0;
 376 }
 377
 378 void
 379 SMFSource::mark_streaming_write_completed ()
 380 {
 381         Glib::Mutex::Lock lm (_lock);
 382         MidiSource::mark_streaming_write_completed();
 383
 384         if (!writable()) {
 385                 return;
 386         }
 387
 388         _model->set_edited(false);
 389         Evoral::SMF::end_write ();
 390 }
 391
 392 bool
 393 SMFSource::safe_midi_file_extension (const Glib::ustring& file)
 394 {
 395         return (file.rfind(".mid") != Glib::ustring::npos);
 396 }
 397
 398 void
 399 SMFSource::load_model (bool lock, bool force_reload)
 400 {
 401         if (_writing) {
 402                 return;
 403         }
 404
 405         boost::shared_ptr<Glib::Mutex::Lock> lm;
 406         if (lock)
 407                 lm = boost::shared_ptr<Glib::Mutex::Lock>(new Glib::Mutex::Lock(_lock));
 408
 409         if (_model && !force_reload) {
 410                 return;
 411         }
 412
 413         if (! _model) {
 414                 _model = boost::shared_ptr<MidiModel>(new MidiModel(this));
 415                 //cerr << _name << " loaded new model " << _model.get() << endl;
 416         } else {
 417                 /*cerr << _name << " reloading model " << _model.get()
 418                         << " (" << _model->n_notes() << " notes)" << endl;*/
 419                 _model->clear();
 420         }
 421
 422         _model->start_write();
 423         Evoral::SMF::seek_to_start();
 424
 425         uint64_t time = 0; /* in SMF ticks */
 426         Evoral::Event<double> ev;
 427
 428         size_t scratch_size = 0; // keep track of scratch and minimize reallocs
 429
 430         uint32_t delta_t = 0;
 431         uint32_t size    = 0;
 432         uint8_t* buf     = NULL;
 433         int ret;
 434         while ((ret = read_event(&delta_t, &size, &buf)) >= 0) {
 435                 time += delta_t;
 436                 ev.set(buf, size, time / (double)ppqn());
 437
 438                 if (ret > 0) { // didn't skip (meta) event
 439                         ev.set_event_type(EventTypeMap::instance().midi_event_type(buf[0]));
 440                         _model->append(ev);
 441                 }
 442
 443                 if (ev.size() > scratch_size) {
 444                         scratch_size = ev.size();
 445                 }
 446                 ev.size() = scratch_size; // ensure read_event only allocates if necessary
 447
 448                 _length_beats = max(_length_beats, ev.time());
 449         }
 450
 451         set_default_controls_interpolation();
 452
 453         _model->end_write(false);
 454         _model->set_edited(false);
 455
 456         _model_iter = _model->begin();
 457
 458         free(buf);
 459 }
 460
 461 void
 462 SMFSource::set_default_controls_interpolation ()
 463 {
 464         // set interpolation style to defaults, can be changed by the GUI later
 465         Evoral::ControlSet::Controls controls = _model->controls();
 466         for (Evoral::ControlSet::Controls::iterator c = controls.begin(); c != controls.end(); ++c) {
 467                 (*c).second->list()->set_interpolation(
 468                         EventTypeMap::instance().interpolation_of((*c).first));
 469         }
 470 }
 471
 472
 473 void
 474 SMFSource::destroy_model ()
 475 {
 476         //cerr << _name << " destroying model " << _model.get() << endl;
 477         _model.reset();
 478 }
 479
 480 void
 481 SMFSource::flush_midi ()
 482 {
 483         Evoral::SMF::end_write();
 484 }
 485