libs/ardour/midi_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 #include <sys/stat.h>
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <poll.h>
  24 #include <float.h>
  25 #include <cerrno>
  26 #include <ctime>
  27 #include <cmath>
  28 #include <iomanip>
  29 #include <algorithm>
  30
  31 #include <pbd/xml++.h>
  32 #include <pbd/pthread_utils.h>
  33 #include <pbd/basename.h>
  34
  35 #include <ardour/midi_source.h>
  36 #include <ardour/midi_ring_buffer.h>
  37 #include <ardour/session.h>
  38 #include <ardour/session_directory.h>
  39 #include <ardour/source_factory.h>
  40
  41 #include "i18n.h"
  42
  43 using namespace std;
  44 using namespace ARDOUR;
  45 using namespace PBD;
  46
  47 sigc::signal<void,MidiSource *> MidiSource::MidiSourceCreated;
  48
  49 MidiSource::MidiSource (Session& s, string name)
  50         : Source (s, name, DataType::MIDI)
  51         , _timeline_position(0)
  52         , _model(new MidiModel(s))
  53         , _model_loaded (false)
  54         , _writing (false)
  55 {
  56         _read_data_count = 0;
  57         _write_data_count = 0;
  58 }
  59
  60 MidiSource::MidiSource (Session& s, const XMLNode& node)
  61         : Source (s, node)
  62         , _timeline_position(0)
  63         , _model(new MidiModel(s))
  64         , _model_loaded (false)
  65         , _writing (false)
  66 {
  67         _read_data_count = 0;
  68         _write_data_count = 0;
  69
  70         if (set_state (node)) {
  71                 throw failed_constructor();
  72         }
  73 }
  74
  75 MidiSource::~MidiSource ()
  76 {
  77 }
  78
  79 XMLNode&
  80 MidiSource::get_state ()
  81 {
  82         XMLNode& node (Source::get_state());
  83
  84         if (_captured_for.length()) {
  85                 node.add_property ("captured-for", _captured_for);
  86         }
  87
  88         return node;
  89 }
  90
  91 int
  92 MidiSource::set_state (const XMLNode& node)
  93 {
  94         const XMLProperty* prop;
  95
  96         Source::set_state (node);
  97
  98         if ((prop = node.property ("captured-for")) != 0) {
  99                 _captured_for = prop->value();
 100         }
 101
 102         return 0;
 103 }
 104
 105 nframes_t
 106 MidiSource::read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const
 107 {
 108         Glib::Mutex::Lock lm (_lock);
 109         if (_model_loaded && _model) {
 110                 /*const size_t n_events = */_model->read(dst, start, cnt, stamp_offset);
 111                 //cout << "Read " << n_events << " events from model." << endl;
 112                 return cnt;
 113         } else {
 114                 return read_unlocked (dst, start, cnt, stamp_offset);
 115         }
 116 }
 117
 118 nframes_t
 119 MidiSource::write (MidiRingBuffer& dst, nframes_t cnt)
 120 {
 121         Glib::Mutex::Lock lm (_lock);
 122         return write_unlocked (dst, cnt);
 123 }
 124
 125 bool
 126 MidiSource::file_changed (string path)
 127 {
 128         struct stat stat_file;
 129
 130         int e1 = stat (path.c_str(), &stat_file);
 131
 132         return ( !e1 );
 133 }
 134
 135 void
 136 MidiSource::mark_streaming_midi_write_started (NoteMode mode)
 137 {
 138         if (_model) {
 139                 _model->set_note_mode(mode);
 140                 _model->start_write();
 141         }
 142
 143         _writing = true;
 144 }
 145
 146 void
 147 MidiSource::mark_streaming_write_started ()
 148 {
 149         if (_model)
 150                 _model->start_write();
 151
 152         _writing = true;
 153 }
 154
 155 void
 156 MidiSource::mark_streaming_write_completed ()
 157 {
 158         if (_model)
 159                 _model->end_write(false); // FIXME: param?
 160
 161         _writing = false;
 162 }
 163
 164 void
 165 MidiSource::session_saved()
 166 {
 167         flush();
 168
 169         if (_model && _model_loaded && _model->edited()) {
 170                 string newname;
 171                 const string basename = PBD::basename_nosuffix(_name);
 172                 string::size_type last_dash = basename.find_last_of("-");
 173                 if (last_dash == string::npos || last_dash == basename.find_first_of("-")) {
 174                         newname = basename + "-1";
 175                 } else {
 176                         stringstream ss(basename.substr(last_dash+1));
 177                         unsigned write_count = 0;
 178                         ss >> write_count;
 179                         cerr << "WRITE COUNT: " << write_count << endl;
 180                         ++write_count; // start at 1
 181                         ss.clear();
 182                         ss << basename.substr(0, last_dash) << "-" << write_count;
 183                         newname = ss.str();
 184                 }
 185
 186                 string newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
 187
 188                 boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
 189                                 SourceFactory::createWritable(DataType::MIDI, _session, newpath, 1, 0, true));
 190
 191                 newsrc->set_timeline_position(_timeline_position);
 192                 _model->write_to(newsrc);
 193
 194                 newsrc->set_model(_model);
 195                 _model.reset();
 196                 _model_loaded = false;
 197
 198                 newsrc->flush();
 199
 200                 Switched.emit(newsrc);
 201         }
 202 }
 203