libs/ardour/midi_source.cc

   1 /*
   2     Copyright (C) 2006 Paul Davis
   3     Author: David Robillard
   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 #include <sys/stat.h>
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <float.h>
  24 #include <cerrno>
  25 #include <ctime>
  26 #include <cmath>
  27 #include <iomanip>
  28 #include <algorithm>
  29
  30 #include <glibmm/fileutils.h>
  31 #include <glibmm/miscutils.h>
  32
  33 #include "pbd/xml++.h"
  34 #include "pbd/pthread_utils.h"
  35 #include "pbd/basename.h"
  36
  37 #include "evoral/Control.hpp"
  38 #include "evoral/EventSink.hpp"
  39
  40 #include "ardour/debug.h"
  41 #include "ardour/file_source.h"
  42 #include "ardour/midi_channel_filter.h"
  43 #include "ardour/midi_model.h"
  44 #include "ardour/midi_source.h"
  45 #include "ardour/midi_state_tracker.h"
  46 #include "ardour/session.h"
  47 #include "ardour/session_directory.h"
  48 #include "ardour/source_factory.h"
  49
  50 #include "i18n.h"
  51
  52 namespace ARDOUR { template <typename T> class MidiRingBuffer; }
  53
  54 using namespace std;
  55 using namespace ARDOUR;
  56 using namespace PBD;
  57
  58 PBD::Signal1<void,MidiSource*> MidiSource::MidiSourceCreated;
  59
  60 MidiSource::MidiSource (Session& s, string name, Source::Flag flags)
  61         : Source(s, DataType::MIDI, name, flags)
  62         , _writing(false)
  63         , _model_iter_valid(false)
  64         , _length_beats(0.0)
  65         , _last_read_end(0)
  66         , _capture_length(0)
  67         , _capture_loop_length(0)
  68 {
  69 }
  70
  71 MidiSource::MidiSource (Session& s, const XMLNode& node)
  72         : Source(s, node)
  73         , _writing(false)
  74         , _model_iter_valid(false)
  75         , _length_beats(0.0)
  76         , _last_read_end(0)
  77         , _capture_length(0)
  78         , _capture_loop_length(0)
  79 {
  80         if (set_state (node, Stateful::loading_state_version)) {
  81                 throw failed_constructor();
  82         }
  83 }
  84
  85 MidiSource::~MidiSource ()
  86 {
  87 }
  88
  89 XMLNode&
  90 MidiSource::get_state ()
  91 {
  92         XMLNode& node (Source::get_state());
  93
  94         if (_captured_for.length()) {
  95                 node.add_property ("captured-for", _captured_for);
  96         }
  97
  98         for (InterpolationStyleMap::const_iterator i = _interpolation_style.begin(); i != _interpolation_style.end(); ++i) {
  99                 XMLNode* child = node.add_child (X_("InterpolationStyle"));
 100                 child->add_property (X_("parameter"), EventTypeMap::instance().to_symbol (i->first));
 101                 child->add_property (X_("style"), enum_2_string (i->second));
 102         }
 103
 104         for (AutomationStateMap::const_iterator i = _automation_state.begin(); i != _automation_state.end(); ++i) {
 105                 XMLNode* child = node.add_child (X_("AutomationState"));
 106                 child->add_property (X_("parameter"), EventTypeMap::instance().to_symbol (i->first));
 107                 child->add_property (X_("state"), enum_2_string (i->second));
 108         }
 109
 110         return node;
 111 }
 112
 113 int
 114 MidiSource::set_state (const XMLNode& node, int /*version*/)
 115 {
 116         const XMLProperty* prop;
 117         if ((prop = node.property ("captured-for")) != 0) {
 118                 _captured_for = prop->value();
 119         }
 120
 121         XMLNodeList children = node.children ();
 122         for (XMLNodeConstIterator i = children.begin(); i != children.end(); ++i) {
 123                 if ((*i)->name() == X_("InterpolationStyle")) {
 124                         if ((prop = (*i)->property (X_("parameter"))) == 0) {
 125                                 error << _("Missing parameter property on InterpolationStyle") << endmsg;
 126                                 return -1;
 127                         }
 128                         Evoral::Parameter p = EventTypeMap::instance().from_symbol (prop->value());
 129
 130                         if ((prop = (*i)->property (X_("style"))) == 0) {
 131                                 error << _("Missing style property on InterpolationStyle") << endmsg;
 132                                 return -1;
 133                         }
 134                         Evoral::ControlList::InterpolationStyle s = static_cast<Evoral::ControlList::InterpolationStyle>(
 135                                 string_2_enum (prop->value(), s));
 136                         set_interpolation_of (p, s);
 137
 138                 } else if ((*i)->name() == X_("AutomationState")) {
 139                         if ((prop = (*i)->property (X_("parameter"))) == 0) {
 140                                 error << _("Missing parameter property on AutomationState") << endmsg;
 141                                 return -1;
 142                         }
 143                         Evoral::Parameter p = EventTypeMap::instance().from_symbol (prop->value());
 144
 145                         if ((prop = (*i)->property (X_("state"))) == 0) {
 146                                 error << _("Missing state property on AutomationState") << endmsg;
 147                                 return -1;
 148                         }
 149                         AutoState s = static_cast<AutoState> (string_2_enum (prop->value(), s));
 150                         set_automation_state_of (p, s);
 151                 }
 152         }
 153
 154         return 0;
 155 }
 156
 157 bool
 158 MidiSource::empty () const
 159 {
 160         return !_length_beats;
 161 }
 162
 163 framecnt_t
 164 MidiSource::length (framepos_t pos) const
 165 {
 166         if (!_length_beats) {
 167                 return 0;
 168         }
 169
 170         BeatsFramesConverter converter(_session.tempo_map(), pos);
 171         return converter.to(_length_beats);
 172 }
 173
 174 void
 175 MidiSource::update_length (framecnt_t)
 176 {
 177         // You're not the boss of me!
 178 }
 179
 180 void
 181 MidiSource::invalidate (const Lock& lock, std::set<Evoral::Sequence<Evoral::Beats>::WeakNotePtr>* notes)
 182 {
 183         _model_iter_valid = false;
 184         _model_iter.invalidate(notes);
 185 }
 186
 187 framecnt_t
 188 MidiSource::midi_read (const Lock&                        lm,
 189                        Evoral::EventSink<framepos_t>&     dst,
 190                        framepos_t                         source_start,
 191                        framepos_t                         start,
 192                        framecnt_t                         cnt,
 193                        MidiStateTracker*                  tracker,
 194                        MidiChannelFilter*                 filter,
 195                        const std::set<Evoral::Parameter>& filtered) const
 196 {
 197         BeatsFramesConverter converter(_session.tempo_map(), source_start);
 198
 199         DEBUG_TRACE (DEBUG::MidiSourceIO,
 200                      string_compose ("MidiSource::midi_read() %5 sstart %1 start %2 cnt %3 tracker %4\n",
 201                                      source_start, start, cnt, tracker, name()));
 202
 203         if (_model) {
 204                 // Find appropriate model iterator
 205                 Evoral::Sequence<Evoral::Beats>::const_iterator& i = _model_iter;
 206                 const bool linear_read = _last_read_end != 0 && start == _last_read_end;
 207                 if (!linear_read || !_model_iter_valid) {
 208                         // Cached iterator is invalid, search for the first event past start
 209                         i = _model->begin(converter.from(start), false, filtered,
 210                                           linear_read ? &_model->active_notes() : NULL);
 211                         _model_iter_valid = true;
 212                         if (!linear_read) {
 213                                 _model->active_notes().clear();
 214                         }
 215                 }
 216
 217                 _last_read_end = start + cnt;
 218
 219                 // Copy events in [start, start + cnt) into dst
 220                 for (; i != _model->end(); ++i) {
 221                         const framecnt_t time_frames = converter.to(i->time());
 222                         if (time_frames < start + cnt) {
 223                                 if (filter && filter->filter(i->buffer(), i->size())) {
 224                                         DEBUG_TRACE (DEBUG::MidiSourceIO,
 225                                                      string_compose ("%1: filter event @ %2 type %3 size %4\n",
 226                                                                      _name, time_frames + source_start, i->event_type(), i->size()));
 227                                         continue;
 228                                 }
 229
 230                                 // Offset by source start to convert event time to session time
 231                                 dst.write (time_frames + source_start, i->event_type(), i->size(), i->buffer());
 232
 233                                 DEBUG_TRACE (DEBUG::MidiSourceIO,
 234                                              string_compose ("%1: add event @ %2 type %3 size %4\n",
 235                                                              _name, time_frames + source_start, i->event_type(), i->size()));
 236
 237                                 if (tracker) {
 238                                         tracker->track (*i);
 239                                 }
 240                         } else {
 241                                 DEBUG_TRACE (DEBUG::MidiSourceIO,
 242                                              string_compose ("%1: reached end with event @ %2 vs. %3\n",
 243                                                              _name, time_frames, start+cnt));
 244                                 break;
 245                         }
 246                 }
 247                 return cnt;
 248         } else {
 249                 return read_unlocked (lm, dst, source_start, start, cnt, tracker, filter);
 250         }
 251 }
 252
 253 framecnt_t
 254 MidiSource::midi_write (const Lock&                 lm,
 255                         MidiRingBuffer<framepos_t>& source,
 256                         framepos_t                  source_start,
 257                         framecnt_t                  cnt)
 258 {
 259         const framecnt_t ret = write_unlocked (lm, source, source_start, cnt);
 260
 261         if (cnt == max_framecnt) {
 262                 _last_read_end = 0;
 263                 invalidate(lm);
 264         } else {
 265                 _capture_length += cnt;
 266         }
 267
 268         return ret;
 269 }
 270
 271 void
 272 MidiSource::mark_streaming_midi_write_started (const Lock& lock, NoteMode mode)
 273 {
 274         if (_model) {
 275                 _model->set_note_mode (mode);
 276                 _model->start_write ();
 277         }
 278
 279         _writing = true;
 280 }
 281
 282 void
 283 MidiSource::mark_write_starting_now (framecnt_t position,
 284                                      framecnt_t capture_length,
 285                                      framecnt_t loop_length)
 286 {
 287         /* I'm not sure if this is the best way to approach this, but
 288            _capture_length needs to be set up with the transport frame
 289            when a record actually starts, as it is used by
 290            SMFSource::write_unlocked to decide whether incoming notes
 291            are within the correct time range.
 292            mark_streaming_midi_write_started (perhaps a more logical
 293            place to do this) is not called at exactly the time when
 294            record starts, and I don't think it necessarily can be
 295            because it is not RT-safe.
 296         */
 297
 298         set_timeline_position(position);
 299         _capture_length      = capture_length;
 300         _capture_loop_length = loop_length;
 301
 302         BeatsFramesConverter converter(_session.tempo_map(), position);
 303         _length_beats = converter.from(capture_length);
 304 }
 305
 306 void
 307 MidiSource::mark_streaming_write_started (const Lock& lock)
 308 {
 309         NoteMode note_mode = _model ? _model->note_mode() : Sustained;
 310         mark_streaming_midi_write_started (lock, note_mode);
 311 }
 312
 313 void
 314 MidiSource::mark_midi_streaming_write_completed (const Lock&                                      lock,
 315                                                  Evoral::Sequence<Evoral::Beats>::StuckNoteOption option,
 316                                                  Evoral::Beats                                    end)
 317 {
 318         if (_model) {
 319                 _model->end_write (option, end);
 320
 321                 /* Make captured controls discrete to play back user input exactly. */
 322                 for (MidiModel::Controls::iterator i = _model->controls().begin(); i != _model->controls().end(); ++i) {
 323                         if (i->second->list()) {
 324                                 i->second->list()->set_interpolation(Evoral::ControlList::Discrete);
 325                                 _interpolation_style.insert(std::make_pair(i->second->parameter(), Evoral::ControlList::Discrete));
 326                         }
 327                 }
 328         }
 329
 330         invalidate(lock);
 331         _writing = false;
 332 }
 333
 334 void
 335 MidiSource::mark_streaming_write_completed (const Lock& lock)
 336 {
 337         mark_midi_streaming_write_completed (lock, Evoral::Sequence<Evoral::Beats>::DeleteStuckNotes);
 338 }
 339
 340 int
 341 MidiSource::write_to (const Lock& lock, boost::shared_ptr<MidiSource> newsrc, Evoral::Beats begin, Evoral::Beats end)
 342 {
 343         Lock newsrc_lock (newsrc->mutex ());
 344
 345         newsrc->set_timeline_position (_timeline_position);
 346         newsrc->copy_interpolation_from (this);
 347         newsrc->copy_automation_state_from (this);
 348
 349         if (_model) {
 350                 if (begin == Evoral::MinBeats && end == Evoral::MaxBeats) {
 351                         _model->write_to (newsrc, newsrc_lock);
 352                 } else {
 353                         _model->write_section_to (newsrc, newsrc_lock, begin, end);
 354                 }
 355         } else {
 356                 error << string_compose (_("programming error: %1"), X_("no model for MidiSource during ::clone()"));
 357                 return -1;
 358         }
 359
 360         newsrc->flush_midi(newsrc_lock);
 361
 362         /* force a reload of the model if the range is partial */
 363
 364         if (begin != Evoral::MinBeats || end != Evoral::MaxBeats) {
 365                 newsrc->load_model (newsrc_lock, true);
 366         } else {
 367                 newsrc->set_model (newsrc_lock, _model);
 368         }
 369
 370         /* this file is not removable (but since it is MIDI, it is mutable) */
 371
 372         boost::dynamic_pointer_cast<FileSource> (newsrc)->prevent_deletion ();
 373
 374         return 0;
 375 }
 376
 377 void
 378 MidiSource::session_saved()
 379 {
 380         Lock lm (_lock);
 381
 382         /* this writes a copy of the data to disk.
 383            XXX do we need to do this every time?
 384         */
 385
 386         if (_model && _model->edited()) {
 387                 /* The model is edited, write its contents into the current source
 388                    file (overwiting previous contents). */
 389
 390                 /* Temporarily drop our reference to the model so that as the model
 391                    pushes its current state to us, we don't try to update it. */
 392                 boost::shared_ptr<MidiModel> mm = _model;
 393                 _model.reset ();
 394
 395                 /* Flush model contents to disk. */
 396                 mm->sync_to_source (lm);
 397
 398                 /* Reacquire model. */
 399                 _model = mm;
 400
 401         } else {
 402                 flush_midi(lm);
 403         }
 404 }
 405
 406 void
 407 MidiSource::set_note_mode(const Lock& lock, NoteMode mode)
 408 {
 409         if (_model) {
 410                 _model->set_note_mode(mode);
 411         }
 412 }
 413
 414 void
 415 MidiSource::drop_model (const Lock& lock)
 416 {
 417         _model.reset();
 418         invalidate(lock);
 419         ModelChanged (); /* EMIT SIGNAL */
 420 }
 421
 422 void
 423 MidiSource::set_model (const Lock& lock, boost::shared_ptr<MidiModel> m)
 424 {
 425         _model = m;
 426         invalidate(lock);
 427         ModelChanged (); /* EMIT SIGNAL */
 428 }
 429
 430 Evoral::ControlList::InterpolationStyle
 431 MidiSource::interpolation_of (Evoral::Parameter p) const
 432 {
 433         InterpolationStyleMap::const_iterator i = _interpolation_style.find (p);
 434         if (i == _interpolation_style.end()) {
 435                 return EventTypeMap::instance().interpolation_of (p);
 436         }
 437
 438         return i->second;
 439 }
 440
 441 AutoState
 442 MidiSource::automation_state_of (Evoral::Parameter p) const
 443 {
 444         AutomationStateMap::const_iterator i = _automation_state.find (p);
 445         if (i == _automation_state.end()) {
 446                 /* default to `play', otherwise if MIDI is recorded /
 447                    imported with controllers etc. they are by default
 448                    not played back, which is a little surprising.
 449                 */
 450                 return Play;
 451         }
 452
 453         return i->second;
 454 }
 455
 456 /** Set interpolation style to be used for a given parameter.  This change will be
 457  *  propagated to anyone who needs to know.
 458  */
 459 void
 460 MidiSource::set_interpolation_of (Evoral::Parameter p, Evoral::ControlList::InterpolationStyle s)
 461 {
 462         if (interpolation_of (p) == s) {
 463                 return;
 464         }
 465
 466         if (EventTypeMap::instance().interpolation_of (p) == s) {
 467                 /* interpolation type is being set to the default, so we don't need a note in our map */
 468                 _interpolation_style.erase (p);
 469         } else {
 470                 _interpolation_style[p] = s;
 471         }
 472
 473         InterpolationChanged (p, s); /* EMIT SIGNAL */
 474 }
 475
 476 void
 477 MidiSource::set_automation_state_of (Evoral::Parameter p, AutoState s)
 478 {
 479         if (automation_state_of (p) == s) {
 480                 return;
 481         }
 482
 483         if (s == Play) {
 484                 /* automation state is being set to the default, so we don't need a note in our map */
 485                 _automation_state.erase (p);
 486         } else {
 487                 _automation_state[p] = s;
 488         }
 489
 490         AutomationStateChanged (p, s); /* EMIT SIGNAL */
 491 }
 492
 493 void
 494 MidiSource::copy_interpolation_from (boost::shared_ptr<MidiSource> s)
 495 {
 496         copy_interpolation_from (s.get ());
 497 }
 498
 499 void
 500 MidiSource::copy_automation_state_from (boost::shared_ptr<MidiSource> s)
 501 {
 502         copy_automation_state_from (s.get ());
 503 }
 504
 505 void
 506 MidiSource::copy_interpolation_from (MidiSource* s)
 507 {
 508         _interpolation_style = s->_interpolation_style;
 509
 510         /* XXX: should probably emit signals here */
 511 }
 512
 513 void
 514 MidiSource::copy_automation_state_from (MidiSource* s)
 515 {
 516         _automation_state = s->_automation_state;
 517
 518         /* XXX: should probably emit signals here */
 519 }