libs/ardour/midi_scene_changer.cc

   1 /*
   2     Copyright (C) 2014 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "evoral/MIDIEvent.hpp"
  21 #include "midi++/channel.h"
  22 #include "midi++/parser.h"
  23 #include "midi++/port.h"
  24
  25 #include "ardour/async_midi_port.h"
  26 #include "ardour/event_type_map.h"
  27 #include "ardour/midi_port.h"
  28 #include "ardour/midi_scene_change.h"
  29 #include "ardour/midi_scene_changer.h"
  30 #include "ardour/session.h"
  31
  32 #include "i18n.h"
  33
  34 using namespace ARDOUR;
  35
  36 MIDISceneChanger::MIDISceneChanger (Session& s)
  37         : SceneChanger (s)
  38         , _recording (true)
  39         , last_bank_message_time (-1)
  40         , last_program_message_time (-1)
  41         , last_delivered_program (-1)
  42         , last_delivered_bank (-1)
  43
  44 {
  45         _session.locations()->changed.connect_same_thread (*this, boost::bind (&MIDISceneChanger::locations_changed, this, _1));
  46         Location::scene_changed.connect_same_thread (*this, boost::bind (&MIDISceneChanger::gather, this));
  47 }
  48
  49 MIDISceneChanger::~MIDISceneChanger ()
  50 {
  51 }
  52
  53 void
  54 MIDISceneChanger::locations_changed (Locations::Change)
  55 {
  56         gather ();
  57 }
  58
  59 /** Use the session's list of locations to collect all patch changes.
  60  *
  61  * This is called whenever the locations change in anyway.
  62  */
  63 void
  64 MIDISceneChanger::gather ()
  65 {
  66         const Locations::LocationList& locations (_session.locations()->list());
  67         boost::shared_ptr<SceneChange> sc;
  68
  69         Glib::Threads::RWLock::WriterLock lm (scene_lock);
  70
  71         scenes.clear ();
  72
  73         for (Locations::LocationList::const_iterator l = locations.begin(); l != locations.end(); ++l) {
  74
  75                 if ((sc = (*l)->scene_change()) != 0) {
  76
  77                         boost::shared_ptr<MIDISceneChange> msc = boost::dynamic_pointer_cast<MIDISceneChange> (sc);
  78
  79                         if (msc) {
  80                                 scenes.insert (std::make_pair ((*l)->start(), msc));
  81                         }
  82                 }
  83         }
  84 }
  85
  86 void
  87 MIDISceneChanger::rt_deliver (MidiBuffer& mbuf, framepos_t when, boost::shared_ptr<MIDISceneChange> msc)
  88 {
  89         uint8_t buf[4];
  90         size_t cnt;
  91
  92         if ((cnt = msc->get_bank_msb_message (buf, sizeof (buf))) > 0) {
  93                 mbuf.push_back (when, cnt, buf);
  94
  95                 if ((cnt = msc->get_bank_lsb_message (buf, sizeof (buf))) > 0) {
  96                         mbuf.push_back (when, cnt, buf);
  97                 }
  98
  99                 last_delivered_bank = msc->bank();
 100         }
 101
 102         if ((cnt = msc->get_program_message (buf, sizeof (buf))) > 0) {
 103                 mbuf.push_back (when, cnt, buf);
 104
 105                 last_delivered_program = msc->program();
 106         }
 107 }
 108
 109 void
 110 MIDISceneChanger::non_rt_deliver (boost::shared_ptr<MIDISceneChange> msc)
 111 {
 112         uint8_t buf[4];
 113         size_t cnt;
 114         boost::shared_ptr<AsyncMIDIPort> aport = boost::dynamic_pointer_cast<AsyncMIDIPort>(output_port);
 115
 116         /* We use zero as the timestamp for these messages because we are in a
 117            non-RT/process context. Using zero means "deliver them as early as
 118            possible" (practically speaking, in the next process callback).
 119         */
 120
 121         if ((cnt = msc->get_bank_msb_message (buf, sizeof (buf))) > 0) {
 122                 aport->write (buf, cnt, 0);
 123
 124                 if ((cnt = msc->get_bank_lsb_message (buf, sizeof (buf))) > 0) {
 125                         aport->write (buf, cnt, 0);
 126                 }
 127
 128                 last_delivered_bank = msc->bank();
 129         }
 130
 131         if ((cnt = msc->get_program_message (buf, sizeof (buf))) > 0) {
 132                 aport->write (buf, cnt, 0);
 133                 last_delivered_program = msc->program();
 134         }
 135 }
 136
 137 void
 138 MIDISceneChanger::run (framepos_t start, framepos_t end)
 139 {
 140         if (!output_port || recording() || !_session.transport_rolling()) {
 141                 return;
 142         }
 143
 144         Glib::Threads::RWLock::ReaderLock lm (scene_lock, Glib::Threads::TRY_LOCK);
 145
 146         if (!lm.locked()) {
 147                 return;
 148         }
 149
 150         /* get lower bound of events to consider */
 151
 152         Scenes::const_iterator i = scenes.lower_bound (start);
 153         MidiBuffer& mbuf (output_port->get_midi_buffer (end-start));
 154
 155         while (i != scenes.end()) {
 156
 157                 if (i->first >= end) {
 158                         break;
 159                 }
 160
 161                 rt_deliver (mbuf, i->first - start, i->second);
 162
 163                 ++i;
 164         }
 165 }
 166
 167 void
 168 MIDISceneChanger::locate (framepos_t pos)
 169 {
 170         boost::shared_ptr<MIDISceneChange> msc;
 171
 172         {
 173                 Glib::Threads::RWLock::ReaderLock lm (scene_lock);
 174
 175                 if (scenes.empty()) {
 176                         return;
 177                 }
 178
 179                 Scenes::const_iterator i = scenes.lower_bound (pos);
 180
 181                 if (i != scenes.end()) {
 182
 183                         if (i->first != pos) {
 184                                 /* i points to first scene with position > pos, so back
 185                                  * up, if possible.
 186                                  */
 187                                 if (i != scenes.begin()) {
 188                                         --i;
 189                                 } else {
 190                                         return;
 191                                 }
 192                         }
 193                 } else {
 194                         /* go back to the final scene and use it */
 195                         --i;
 196                 }
 197
 198                 msc = i->second;
 199         }
 200
 201         if (msc->program() != last_delivered_program || msc->bank() != last_delivered_bank) {
 202                 non_rt_deliver (msc);
 203         }
 204 }
 205
 206 void
 207 MIDISceneChanger::set_input_port (MIDI::Port* mp)
 208 {
 209         input_port = mp;
 210
 211         incoming_connections.drop_connections();
 212
 213         if (input_port) {
 214
 215                 /* midi port is asynchronous. MIDI parsing will be carried out
 216                  * by the MIDI UI thread which will emit the relevant signals
 217                  * and thus invoke our callbacks as necessary.
 218                  */
 219
 220                 for (int channel = 0; channel < 16; ++channel) {
 221                         input_port->parser()->channel_bank_change[channel].connect_same_thread (incoming_connections, boost::bind (&MIDISceneChanger::bank_change_input, this, _1, _2, channel));
 222                         input_port->parser()->channel_program_change[channel].connect_same_thread (incoming_connections, boost::bind (&MIDISceneChanger::program_change_input, this, _1, _2, channel));
 223                 }
 224         }
 225 }
 226
 227 void
 228 MIDISceneChanger::set_output_port (boost::shared_ptr<MidiPort> mp)
 229 {
 230         output_port = mp;
 231 }
 232
 233 void
 234 MIDISceneChanger::set_recording (bool yn)
 235 {
 236         _recording = yn;
 237 }
 238
 239 bool
 240 MIDISceneChanger::recording() const
 241 {
 242         return _session.transport_rolling() && _session.get_record_enabled();
 243 }
 244
 245 void
 246 MIDISceneChanger::bank_change_input (MIDI::Parser& parser, unsigned short, int)
 247 {
 248         if (!recording()) {
 249                 return;
 250         }
 251
 252         last_bank_message_time = parser.get_timestamp ();
 253 }
 254
 255 void
 256 MIDISceneChanger::program_change_input (MIDI::Parser& parser, MIDI::byte program, int channel)
 257 {
 258         framecnt_t time = parser.get_timestamp ();
 259
 260         last_program_message_time = time;
 261
 262         if (!recording()) {
 263                 jump_to (input_port->channel (channel)->bank(), program);
 264                 return;
 265         }
 266
 267         Locations* locations (_session.locations ());
 268         Location* loc;
 269         bool new_mark = false;
 270         framecnt_t slop = (framecnt_t) floor ((Config->get_inter_scene_gap_msecs() / 1000.0) * _session.frame_rate());
 271
 272         /* check for marker at current location */
 273
 274         loc = locations->mark_at (time, slop);
 275
 276         if (!loc) {
 277                 /* create a new marker at the desired position */
 278
 279                 std::string new_name;
 280
 281                 if (!locations->next_available_name (new_name, _("Scene "))) {
 282                         std::cerr << "No new marker name available\n";
 283                         return;
 284                 }
 285
 286                 loc = new Location (_session, time, time, new_name, Location::IsMark);
 287                 new_mark = true;
 288         }
 289
 290         unsigned short bank = input_port->channel (channel)->bank();
 291
 292         MIDISceneChange* msc =new MIDISceneChange (channel, bank, program & 0x7f);
 293
 294         loc->set_scene_change (boost::shared_ptr<MIDISceneChange> (msc));
 295
 296         /* this will generate a "changed" signal to be emitted by locations,
 297            and we will call ::gather() to update our list of MIDI events.
 298         */
 299
 300         if (new_mark) {
 301                 locations->add (loc);
 302         }
 303 }
 304
 305 void
 306 MIDISceneChanger::jump_to (int bank, int program)
 307 {
 308         const Locations::LocationList& locations (_session.locations()->list());
 309         boost::shared_ptr<SceneChange> sc;
 310         framepos_t where = max_framepos;
 311
 312         for (Locations::LocationList::const_iterator l = locations.begin(); l != locations.end(); ++l) {
 313
 314                 if ((sc = (*l)->scene_change()) != 0) {
 315
 316                         boost::shared_ptr<MIDISceneChange> msc = boost::dynamic_pointer_cast<MIDISceneChange> (sc);
 317
 318                         if (msc->bank() == bank && msc->program() == program && (*l)->start() < where) {
 319                                 where = (*l)->start();
 320                         }
 321                 }
 322         }
 323
 324         if (where != max_framepos) {
 325                 _session.request_locate (where);
 326         }
 327 }