common.c

   1 /*
   2  * Control JACK transport using MMC (MIDI)
   3  *
   4  * Copyright (c) 2006,2007,2008,2010 Nedko Arnaudov <nedko@arnaudov.name>
   5  * Copyright (c) 2008 Alex Montgomery <apmontgomery@gmail.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License as published by the Free Software
   9  * Foundation; version 2 of the License.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT ANY
  12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  18  */
  19
  20 #include "common.h"
  21
  22 // common globals
  23 int g_quit = 0; // a flag which will be set by our signal handler when it's time to exit
  24 snd_seq_t* g_seq_ptr = NULL;
  25 jack_client_t* g_jack_client = NULL;
  26 int g_isListening = 0;
  27
  28 #if LASH_SUPPORT
  29 lash_client_t* g_lashc = NULL;
  30
  31 void init_lash(int argc, char* argv[])
  32 {
  33    lash_event_t * lash_event_ptr = NULL;
  34
  35    /* LASH setup */
  36    g_lashc = lash_init( lash_extract_args(&argc, &argv), "jackctlmmc", 0, LASH_PROTOCOL_VERSION);
  37
  38    if (g_lashc == NULL)
  39    {
  40       printMMCMessage("Failed to connect to LASH. Session management will not occur.\n");
  41    }
  42
  43    // register JACK and ALSA clients with lash
  44    lash_alsa_client_id(g_lashc, snd_seq_client_id(g_seq_ptr));
  45    lash_jack_client_name(g_lashc, "jackctlmmc");
  46 }
  47
  48 void process_lash_event(lash_event_t * event_ptr)
  49 {
  50    enum LASH_Event_Type type;
  51    const char * str;
  52
  53    type = lash_event_get_type(event_ptr);
  54    str = lash_event_get_string(event_ptr);
  55
  56    switch (type)
  57    {
  58       case LASH_Quit:
  59          printMMCMessage("LASH_Quit received.\n");
  60          g_lashc = NULL;
  61          g_quit = 1;
  62          break;
  63       case LASH_Save_File:
  64       case LASH_Restore_File:
  65       case LASH_Save_Data_Set:
  66       default:
  67          printMMCMessage("LASH Event. Type = %u, string = \"%s\"\n",
  68                (unsigned int)type,
  69                (str == NULL)?"":str);
  70    }
  71 }
  72
  73 void process_lash_config(lash_config_t * config_ptr)
  74 {
  75    const char * key;
  76    const void * data;
  77    size_t data_size;
  78
  79    key = lash_config_get_key(config_ptr);
  80    data = lash_config_get_value(config_ptr);
  81    data_size = lash_config_get_value_size(config_ptr);
  82
  83    printMMCMessage("LASH Config. Key = \"%s\"\n", key);
  84 }
  85 #endif // LASH_SUPPORT
  86
  87 #if JACK_MIDI_SUPPORT
  88
  89 jack_port_t* g_jackMidiIn = NULL;
  90
  91 int jack_process_cb(jack_nframes_t numFrames, void* cbContext)
  92 {
  93    if (g_isListening)
  94    {
  95       uint8_t* inBuffer = 0;
  96       int numMidiEvents = 0;
  97       jack_midi_event_t currEvent;
  98       int midiIndex = 0;
  99       MidiSettings* settings = (MidiSettings*) cbContext;
 100
 101       inBuffer = jack_port_get_buffer(g_jackMidiIn, numFrames);
 102       numMidiEvents = jack_midi_get_event_count(inBuffer);
 103
 104       for (midiIndex = 0; midiIndex < numMidiEvents; ++midiIndex)
 105       {
 106          jack_midi_event_get(&currEvent, inBuffer, midiIndex);
 107          handle_midi(currEvent.buffer, settings);
 108       }
 109    }
 110
 111    return 0;
 112 }
 113
 114 int init_jack_midi(MidiSettings* settings)
 115 {
 116    int errorCode = 0;
 117
 118    errorCode = jack_set_process_callback(g_jack_client, &jack_process_cb, settings);
 119    g_jackMidiIn = jack_port_register(g_jack_client, "in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput | JackPortIsTerminal, 1024);
 120    return (errorCode == 0 && g_jackMidiIn != 0);
 121 }
 122 #endif // JACK_MIDI_SUPPORT
 123
 124 int init_alsa_sequencer(const char* appName)
 125 {
 126    snd_seq_port_info_t * seq_port_info = NULL;
 127    int ret = 0;
 128
 129    /* ALSA sequencer initialisation */
 130    ret = snd_seq_open( &g_seq_ptr, "default", SND_SEQ_OPEN_INPUT, 0);
 131    if (ret < 0)
 132       return ret;
 133
 134    // setup alsa sequencer port
 135    snd_seq_port_info_alloca(&seq_port_info);
 136    snd_seq_port_info_set_capability(seq_port_info, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
 137    snd_seq_port_info_set_type( seq_port_info, SND_SEQ_PORT_TYPE_APPLICATION);
 138    snd_seq_port_info_set_midi_channels(seq_port_info, 16);
 139    snd_seq_port_info_set_port_specified(seq_port_info, 1);
 140    snd_seq_port_info_set_name(seq_port_info, "midi in");
 141    snd_seq_port_info_set_port(seq_port_info, 0);
 142
 143    ret = snd_seq_create_port(g_seq_ptr, seq_port_info);
 144
 145    if (ret < 0)
 146       printMMCMessage("Error with alsa sequencer initialization, %s\n", snd_strerror(ret));
 147    else // all is well, register the sequencer with whatever name was passed in
 148       snd_seq_set_client_name(g_seq_ptr, appName);
 149
 150    return ret;
 151 }
 152
 153 int init_jack(const char* appName)
 154 {
 155    jack_status_t status;
 156    g_jack_client = jack_client_open(appName, JackNoStartServer, &status);
 157
 158    if (!g_jack_client) // something went wrong
 159       return -1; // todo: check status to see exactly what happened
 160
 161    return 0;
 162 }
 163
 164 int activate_jack()
 165 {
 166    /* tell jack that we are ready to do our thing */
 167    return jack_activate(g_jack_client);
 168 }
 169
 170 void handle_midi(uint8_t* midiBuff, MidiSettings* settings)
 171 {
 172    if (midiBuff[0] == 0xF0 && midiBuff[1] == 0x7F && midiBuff[3] == 0x06)
 173    {
 174       const uint8_t messageDeviceID = midiBuff[2];
 175       if (messageDeviceID == settings->deviceID)
 176       {
 177          const char mmcCommand = midiBuff[4];
 178          switch (mmcCommand)
 179          {
 180             case 1:                 /* stop */
 181                if (settings->verbose)
 182                   printMMCMessage("MMC Stop -> JACK transport stop\n");
 183                jack_transport_stop(g_jack_client);
 184                break;
 185             case 2:                 /* play */
 186             case 3:                 /* deferred play */
 187                if (settings->verbose)
 188                   printMMCMessage("MMC Play -> JACK transport start\n");
 189                jack_transport_start(g_jack_client);
 190                break;
 191             case 4:
 192                if (settings->verbose)
 193                   printMMCMessage("MMC Fast Forward -> Ignored\n");
 194                break;
 195             case 5:                 /* rewind */
 196                if (settings->verbose)
 197                   printMMCMessage("MMC Play -> JACK transport locate to 0\n");
 198                jack_transport_locate(g_jack_client, 0);
 199                break;
 200             case 6:
 201                if (settings->verbose)
 202                   printMMCMessage("MMC Record Strobe (Punch In) -> Ignored\n");
 203                break;
 204             case 7:
 205                if (settings->verbose)
 206                   printMMCMessage("MMC Record Exit (Punch out) -> Ignored\n");
 207                break;
 208             case 8:
 209                if (settings->verbose)
 210                   printMMCMessage("MMC Record Ready (Record Pause) -> Ignored\n");
 211                break;
 212             case 9:                 /* pause */
 213                if (settings->verbose)
 214                   printMMCMessage("MMC Pause -> JACK transport stop\n");
 215                jack_transport_stop(g_jack_client);
 216                break;
 217             case 0x44:              /* goto */
 218                if (midiBuff[5] == 0x06 && midiBuff[6] == 0x01)
 219                {
 220                   // some devices call hour 0 "60". Mask off the upper bits
 221                   uint8_t hour = (midiBuff[7] & 0x1f);
 222                   uint8_t minute = midiBuff[8];
 223                   uint8_t second = midiBuff[9];
 224                   uint8_t frame = midiBuff[10];
 225                   uint8_t subframe = midiBuff[11]; // percentage of a frame: 0 - 99
 226                   jack_position_t jack_pos;
 227
 228                   // get Jack's current framerate and position
 229                   jack_transport_query(g_jack_client, &jack_pos);
 230                   uint32_t jack_frame_rate = jack_pos.frame_rate;
 231                   uint32_t jack_time_ms = (jack_pos.frame * 1000) / jack_frame_rate;
 232                   uint32_t device_time_ms = ((subframe * 10) / settings->frameRate + // subframe == 1/100th of a frame
 233                         (frame * 1000) / settings->frameRate +
 234                         (second * 1000) +
 235                         (minute * 60 * 1000) +
 236                         (hour * 60 * 60 * 1000));
 237
 238                   // difference in milliseconds from JACK's reported transport to the MIDI goto's time
 239                   uint32_t jitter = (device_time_ms > jack_time_ms ? (device_time_ms - jack_time_ms) : (jack_time_ms - device_time_ms));
 240
 241                   if (settings->verbose)
 242                      printMMCMessage("MMC locate to hour: %d, minute: %d, second: %d, frame: %d, subframe: %d\n",
 243                            hour,
 244                            minute,
 245                            second,
 246                            frame,
 247                            subframe);
 248
 249                   // check if the JACK clock is far enough away from the MMC time to care
 250                   if (jitter > settings->jitterTolerance)
 251                   {  // it is, change it.
 252                      jack_pos.valid = 0; // only the frame number will be valid since that's all we're changing
 253
 254                      // need a placeholder so that we can keep precision while not letting the integer overflow
 255                      uint64_t placeholder =  (uint64_t)device_time_ms * jack_frame_rate / 1000;
 256                      jack_pos.frame = placeholder;
 257
 258                      jack_transport_reposition(g_jack_client, &jack_pos);
 259                   }
 260                   else if (settings->verbose)
 261                      printMMCMessage("New position is %d ms away and within jitter range, ignoring.\n", jitter);
 262                }
 263                break;
 264             case 0x48:              /* step */
 265                {
 266                   int step;
 267                   jack_position_t jack_pos;
 268
 269                   step = midiBuff[6];
 270                   if (step > 0x40)
 271                   {
 272                      step &= 0x3F;
 273                      step = -step;
 274                   }
 275
 276                   if (settings->verbose)
 277                      printMMCMessage("MMC Step %d\n", step);
 278
 279                   // get Jack's current framerate and position
 280                   jack_transport_query(g_jack_client, &jack_pos);
 281
 282                   jack_pos.valid = 0; // only the frame number will be valid since that's all we're changing
 283
 284                   jack_pos.frame += (int64_t)step * (int64_t)jack_pos.frame_rate / (int64_t)10;
 285
 286                   jack_transport_reposition(g_jack_client, &jack_pos);
 287                }
 288                break;
 289             default:
 290                if (settings->verbose)
 291                   printMMCMessage("unsupported MMC command: 0x%x\n", mmcCommand);
 292          }
 293       }
 294       else if (settings->verbose)
 295       {
 296          printMMCMessage("MMC command received for device ID %x while listening for commands from device ID %x. Have you specified the correct device ID to listen to?\n",
 297                 messageDeviceID,
 298                 settings->deviceID);
 299
 300       }
 301    }
 302 }
 303
 304 void listen_loop (MidiSettings* settings)
 305 {
 306    snd_seq_event_t * seq_event_ptr = NULL;
 307
 308    int npfd = snd_seq_poll_descriptors_count(g_seq_ptr, POLLIN);
 309    struct pollfd * pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
 310    snd_seq_poll_descriptors(g_seq_ptr, pfd, npfd, POLLIN);
 311
 312    while(!g_quit)
 313    {
 314       if (poll(pfd, npfd, 250) > 0 && snd_seq_event_input(g_seq_ptr, &seq_event_ptr) >= 0 && seq_event_ptr->type == SND_SEQ_EVENT_SYSEX)
 315          handle_midi((uint8_t *)seq_event_ptr->data.ext.ptr, settings);
 316
 317 #if LASH_SUPPORT
 318       /* Process LASH events */
 319       {
 320          lash_event_t * lash_event_ptr = NULL;
 321          lash_config_t * lash_config_ptr = NULL;
 322          while ((lash_event_ptr = lash_get_event(g_lashc)) != NULL)
 323          {
 324             process_lash_event(lash_event_ptr);
 325             lash_event_destroy(lash_event_ptr);
 326          }
 327
 328          /* Process LASH configs */
 329          while ((lash_config_ptr = lash_get_config(g_lashc)) != NULL)
 330          {
 331             process_lash_config(lash_config_ptr);
 332             lash_config_destroy(lash_config_ptr);
 333          }
 334       }
 335 #endif
 336    }
 337 }
 338
 339 void cleanup_globals()
 340 {
 341    int ret = 0;
 342
 343    if (g_seq_ptr)
 344    {
 345       ret = snd_seq_close(g_seq_ptr);
 346       if (ret < 0)
 347       {
 348          printMMCMessage("Cannot close sequncer, %s\n", snd_strerror(ret));
 349       }
 350    }
 351
 352    if (g_jack_client)
 353    {
 354       jack_deactivate(g_jack_client);
 355       jack_client_close(g_jack_client);
 356    }
 357 }