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(this))
  53         , _writing (false)
  54 {
  55         _read_data_count = 0;
  56         _write_data_count = 0;
  57 }
  58
  59 MidiSource::MidiSource (Session& s, const XMLNode& node)
  60         : Source (s, node)
  61         , _timeline_position(0)
  62         , _model(new MidiModel(this))
  63         , _writing (false)
  64 {
  65         _read_data_count = 0;
  66         _write_data_count = 0;
  67
  68         if (set_state (node)) {
  69                 throw failed_constructor();
  70         }
  71 }
  72
  73 MidiSource::~MidiSource ()
  74 {
  75 }
  76
  77 XMLNode&
  78 MidiSource::get_state ()
  79 {
  80         XMLNode& node (Source::get_state());
  81
  82         if (_captured_for.length()) {
  83                 node.add_property ("captured-for", _captured_for);
  84         }
  85
  86         return node;
  87 }
  88
  89 int
  90 MidiSource::set_state (const XMLNode& node)
  91 {
  92         const XMLProperty* prop;
  93
  94         Source::set_state (node);
  95
  96         if ((prop = node.property ("captured-for")) != 0) {
  97                 _captured_for = prop->value();
  98         }
  99
 100         return 0;
 101 }
 102
 103 nframes_t
 104 MidiSource::midi_read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset, nframes_t negative_stamp_offset) const
 105 {
 106         Glib::Mutex::Lock lm (_lock);
 107         if (_model) {
 108                 //const size_t n_events =
 109                 _model->read(dst, start, cnt, stamp_offset - negative_stamp_offset);
 110                 //cout << "Read " << n_events << " events from model." << endl;
 111                 return cnt;
 112         } else {
 113                 return read_unlocked (dst, start, cnt, stamp_offset, negative_stamp_offset);
 114         }
 115 }
 116
 117 nframes_t
 118 MidiSource::midi_write (MidiRingBuffer& dst, nframes_t cnt)
 119 {
 120         Glib::Mutex::Lock lm (_lock);
 121         return write_unlocked (dst, cnt);
 122 }
 123
 124 bool
 125 MidiSource::file_changed (string path)
 126 {
 127         struct stat stat_file;
 128
 129         int e1 = stat (path.c_str(), &stat_file);
 130
 131         return ( !e1 );
 132 }
 133
 134 void
 135 MidiSource::mark_streaming_midi_write_started (NoteMode mode, nframes_t start_frame)
 136 {
 137         set_timeline_position(start_frame); // why do I have a feeling this can break somehow...
 138
 139         if (_model) {
 140                 _model->set_note_mode(mode);
 141                 _model->start_write();
 142         }
 143
 144         _writing = true;
 145 }
 146
 147 void
 148 MidiSource::mark_streaming_write_started ()
 149 {
 150         if (_model)
 151                 _model->start_write();
 152
 153         _writing = true;
 154 }
 155
 156 void
 157 MidiSource::mark_streaming_write_completed ()
 158 {
 159         if (_model)
 160                 _model->end_write(false); // FIXME: param?
 161
 162         _writing = false;
 163 }
 164
 165 void
 166 MidiSource::session_saved()
 167 {
 168         flush_midi();
 169
 170         if (_model && _model->edited()) {
 171                 string newname;
 172                 const string basename = PBD::basename_nosuffix(_name);
 173                 string::size_type last_dash = basename.find_last_of("-");
 174                 if (last_dash == string::npos || last_dash == basename.find_first_of("-")) {
 175                         newname = basename + "-1";
 176                 } else {
 177                         stringstream ss(basename.substr(last_dash+1));
 178                         unsigned write_count = 0;
 179                         ss >> write_count;
 180                         cerr << "WRITE COUNT: " << write_count << endl;
 181                         ++write_count; // start at 1
 182                         ss.clear();
 183                         ss << basename.substr(0, last_dash) << "-" << write_count;
 184                         newname = ss.str();
 185                 }
 186
 187                 string newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
 188
 189                 boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
 190                                 SourceFactory::createWritable(DataType::MIDI, _session, newpath, 1, 0, true));
 191
 192                 newsrc->set_timeline_position(_timeline_position);
 193                 _model->write_to(newsrc);
 194
 195                 // cyclic dependency here, ugly :(
 196                 newsrc->set_model(_model);
 197                 _model->set_midi_source(newsrc.get());
 198
 199                 newsrc->flush_midi();
 200
 201                 Switched.emit(newsrc);
 202         }
 203 }
 204