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         , _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(s))
  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::read (MidiRingBuffer& dst, nframes_t start, nframes_t cnt, nframes_t stamp_offset) const
 105 {
 106         Glib::Mutex::Lock lm (_lock);
 107         if (_model) {
 108                 /*const size_t n_events = */_model->read(dst, start, cnt, stamp_offset);
 109                 //cout << "Read " << n_events << " events from model." << endl;
 110                 return cnt;
 111         } else {
 112                 return read_unlocked (dst, start, cnt, stamp_offset);
 113         }
 114 }
 115
 116 nframes_t
 117 MidiSource::write (MidiRingBuffer& dst, nframes_t cnt)
 118 {
 119         Glib::Mutex::Lock lm (_lock);
 120         return write_unlocked (dst, cnt);
 121 }
 122
 123 bool
 124 MidiSource::file_changed (string path)
 125 {
 126         struct stat stat_file;
 127
 128         int e1 = stat (path.c_str(), &stat_file);
 129
 130         return ( !e1 );
 131 }
 132
 133 void
 134 MidiSource::mark_streaming_midi_write_started (NoteMode mode)
 135 {
 136         if (_model) {
 137                 _model->set_note_mode(mode);
 138                 _model->start_write();
 139         }
 140
 141         _writing = true;
 142 }
 143
 144 void
 145 MidiSource::mark_streaming_write_started ()
 146 {
 147         if (_model)
 148                 _model->start_write();
 149
 150         _writing = true;
 151 }
 152
 153 void
 154 MidiSource::mark_streaming_write_completed ()
 155 {
 156         if (_model)
 157                 _model->end_write(false); // FIXME: param?
 158
 159         _writing = false;
 160 }
 161
 162 void
 163 MidiSource::session_saved()
 164 {
 165         flush_header();
 166         flush_footer();
 167
 168         if (_model && _model->edited()) {
 169                 string newname;
 170                 const string basename = PBD::basename_nosuffix(_name);
 171                 string::size_type last_dash = basename.find_last_of("-");
 172                 if (last_dash == string::npos || last_dash == basename.find_first_of("-")) {
 173                         newname = basename + "-1";
 174                 } else {
 175                         stringstream ss(basename.substr(last_dash+1));
 176                         unsigned write_count = 0;
 177                         ss >> write_count;
 178                         cerr << "WRITE COUNT: " << write_count << endl;
 179                         ++write_count; // start at 1
 180                         ss.clear();
 181                         ss << basename.substr(0, last_dash) << "-" << write_count;
 182                         newname = ss.str();
 183                 }
 184
 185                 string newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
 186
 187                 boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
 188                                 SourceFactory::createWritable(DataType::MIDI, _session, newpath, 1, 0, true));
 189
 190                 newsrc->set_timeline_position(_timeline_position);
 191                 _model->write_to(newsrc);
 192
 193                 newsrc->set_model(_model);
 194                 _model.reset();
 195
 196                 newsrc->flush_header();
 197                 newsrc->flush_footer();
 198
 199                 Switched.emit(newsrc);
 200         }
 201 }
 202