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 snd_seq_t* g_seq_ptr = NULL;
  24 jack_client_t* g_jack_client = NULL;
  25 int g_quit = 0; // a flag which will be set by our signal handler when it's time to exit
  26
  27 #if LASH_SUPPORT
  28 lash_client_t* g_lashc = NULL;
  29
  30 void init_lash(int argc, char* argv[])
  31 {
  32    lash_event_t * lash_event_ptr = NULL;
  33
  34    /* LASH setup */
  35    g_lashc = lash_init( lash_extract_args(&argc, &argv), "jackctlmmc", 0, LASH_PROTOCOL_VERSION);
  36
  37    if (g_lashc == NULL)
  38    {
  39       printMMCMessage("Failed to connect to LASH. Session management will not occur.\n");
  40    }
  41    else
  42    {
  43       lash_event_ptr = lash_event_new_with_type(LASH_Client_Name);
  44       lash_event_set_string(lash_event_ptr, "jackctlmmc");
  45       lash_send_event(g_lashc, lash_event_ptr);
  46    }
  47
  48    // register JACK and ALSA clients with lash
  49    lash_alsa_client_id(g_lashc, snd_seq_client_id(g_seq_ptr));
  50    lash_jack_client_name(g_lashc, "jackctlmmc");
  51 }
  52
  53 void process_lash_event(lash_event_t * event_ptr)
  54 {
  55    enum LASH_Event_Type type;
  56    const char * str;
  57
  58    type = lash_event_get_type(event_ptr);
  59    str = lash_event_get_string(event_ptr);
  60
  61    switch (type)
  62    {
  63       case LASH_Quit:
  64          printMMCMessage("LASH_Quit received.\n");
  65          g_lashc = NULL;
  66          g_quit = 1;
  67          break;
  68       case LASH_Save_File:
  69       case LASH_Restore_File:
  70       case LASH_Save_Data_Set:
  71       default:
  72          printMMCMessage("LASH Event. Type = %u, string = \"%s\"\n",
  73                (unsigned int)type,
  74                (str == NULL)?"":str);
  75    }
  76 }
  77
  78 void process_lash_config(lash_config_t * config_ptr)
  79 {
  80    const char * key;
  81    const void * data;
  82    size_t data_size;
  83
  84    key = lash_config_get_key(config_ptr);
  85    data = lash_config_get_value(config_ptr);
  86    data_size = lash_config_get_value_size(config_ptr);
  87
  88    printMMCMessage("LASH Config. Key = \"%s\"\n", key);
  89 }
  90 #endif // LASH_SUPPORT
  91
  92 int init_alsa_sequencer(const char* appName)
  93 {
  94    snd_seq_port_info_t * seq_port_info = NULL;
  95    int ret = 0;
  96
  97    /* ALSA sequencer initialisation */
  98    ret = snd_seq_open( &g_seq_ptr, "default", SND_SEQ_OPEN_INPUT, 0);
  99    if (ret < 0)
 100       return ret;
 101
 102    // setup alsa sequencer port
 103    snd_seq_port_info_alloca(&seq_port_info);
 104    snd_seq_port_info_set_capability(seq_port_info, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE);
 105    snd_seq_port_info_set_type( seq_port_info, SND_SEQ_PORT_TYPE_APPLICATION);
 106    snd_seq_port_info_set_midi_channels(seq_port_info, 16);
 107    snd_seq_port_info_set_port_specified(seq_port_info, 1);
 108    snd_seq_port_info_set_name(seq_port_info, "midi in");
 109    snd_seq_port_info_set_port(seq_port_info, 0);
 110
 111    ret = snd_seq_create_port(g_seq_ptr, seq_port_info);
 112
 113    if (ret < 0)
 114       printMMCMessage("Error with alsa sequencer initialization, %s\n", snd_strerror(ret));
 115    else // all is well, register the sequencer with whatever name was passed in
 116       snd_seq_set_client_name(g_seq_ptr, appName);
 117
 118    return ret;
 119 }
 120
 121 int init_jack(const char* appName)
 122 {
 123    jack_status_t status;
 124    g_jack_client = jack_client_open(appName, JackNoStartServer, &status);
 125
 126    if (!g_jack_client) // something went wrong
 127       return -1; // todo: check status to see exactly what happened
 128
 129    return 0;
 130 }
 131
 132 int activate_jack()
 133 {
 134    /* tell jack that we are ready to do our thing */
 135    return jack_activate(g_jack_client);
 136 }
 137
 138 void listen_loop (uint32_t frameRate, uint32_t jitterTolerance, int verbose, uint8_t deviceID)
 139 {
 140    snd_seq_event_t * seq_event_ptr = NULL;
 141
 142    int npfd = snd_seq_poll_descriptors_count(g_seq_ptr, POLLIN);
 143    struct pollfd * pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
 144    snd_seq_poll_descriptors(g_seq_ptr, pfd, npfd, POLLIN);
 145
 146    while(!g_quit)
 147    {
 148       if (poll(pfd, npfd, 250) > 0 && snd_seq_event_input(g_seq_ptr, &seq_event_ptr) >= 0)
 149       {
 150          if (seq_event_ptr->type == SND_SEQ_EVENT_SYSEX &&
 151                ((uint8_t *)seq_event_ptr->data.ext.ptr)[0] == 0xF0 &&
 152                ((uint8_t *)seq_event_ptr->data.ext.ptr)[1] == 0x7F &&
 153                ((uint8_t *)seq_event_ptr->data.ext.ptr)[3] == 0x06)
 154          {
 155             const uint8_t messageDeviceID = ((uint8_t *)seq_event_ptr->data.ext.ptr)[2];
 156             if (messageDeviceID == deviceID)
 157             {
 158                const char mmcCommand = ((char *)seq_event_ptr->data.ext.ptr)[4];
 159                switch (mmcCommand)
 160                {
 161                   case 1:                 /* stop */
 162                      if (verbose)
 163                         printMMCMessage("MMC Stop -> JACK transport stop\n");
 164                      jack_transport_stop(g_jack_client);
 165                      break;
 166                   case 2:                 /* play */
 167                   case 3:                 /* deferred play */
 168                      if (verbose)
 169                         printMMCMessage("MMC Play -> JACK transport start\n");
 170                      jack_transport_start(g_jack_client);
 171                      break;
 172                   case 4:
 173                      if (verbose)
 174                         printf("MMC Fast Forward -> Ignored\n");
 175                      break;
 176                   case 5:                 /* rewind */
 177                      if (verbose)
 178                         printMMCMessage("MMC Play -> JACK transport locate to 0\n");
 179                      jack_transport_locate(g_jack_client, 0);
 180                      break;
 181                   case 6:
 182                      if (verbose)
 183                         printf("MMC Record Strobe (Punch In) -> Ignored\n");
 184                      break;
 185                   case 7:
 186                      if (verbose)
 187                         printf("MMC Record Exit (Punch out) -> Ignored\n");
 188                      break;
 189                   case 8:
 190                      if (verbose)
 191                         printf("MMC Record Ready (Record Pause) -> Ignored\n");
 192                      break;
 193                   case 9:                 /* pause */
 194                      if (verbose)
 195                         printf("MMC Pause -> JACK transport stop\n");
 196                      jack_transport_stop(g_jack_client);
 197                      break;
 198                   case 0x44:              /* goto */
 199                      if (((uint8_t*)seq_event_ptr->data.ext.ptr)[5] == 0x06 &&
 200                            ((uint8_t*)seq_event_ptr->data.ext.ptr)[6] == 0x01)
 201                      {
 202                         // some devices call hour 0 "60". Mask off the upper bits
 203                         uint8_t hour = ((uint8_t*)seq_event_ptr->data.ext.ptr)[7] & 0x1f;
 204                         uint8_t minute = ((uint8_t*)seq_event_ptr->data.ext.ptr)[8];
 205                         uint8_t second = ((uint8_t*)seq_event_ptr->data.ext.ptr)[9];
 206                         uint8_t frame = ((uint8_t*)seq_event_ptr->data.ext.ptr)[10];
 207                         uint8_t subframe = ((uint8_t*)seq_event_ptr->data.ext.ptr)[11]; // percentage of a frame: 0 - 99
 208                         jack_position_t jack_pos;
 209
 210                         // get Jack's current framerate and position
 211                         jack_transport_query(g_jack_client, &jack_pos);
 212                         uint32_t jack_frame_rate = jack_pos.frame_rate;
 213                         uint32_t jack_time_ms = (jack_pos.frame * 1000) / jack_frame_rate;
 214                         uint32_t device_time_ms = ((subframe * 10) / frameRate + // subframe == 1/100th of a frame
 215                               (frame * 1000) / frameRate +
 216                               (second * 1000) +
 217                               (minute * 60 * 1000) +
 218                               (hour * 60 * 60 * 1000));
 219
 220                         // difference in milliseconds from JACK's reported transport to the MIDI goto's time
 221                         uint32_t jitter = (device_time_ms > jack_time_ms ? (device_time_ms - jack_time_ms) : (jack_time_ms - device_time_ms));
 222
 223                         if (verbose)
 224                            printMMCMessage("MMC locate to hour: %d, minute: %d, second: %d, frame: %d, subframe: %d\n",
 225                                  hour,
 226                                  minute,
 227                                  second,
 228                                  frame,
 229                                  subframe);
 230
 231                         // check if the JACK clock is far enough away from the MMC time to care
 232                         if (jitter > jitterTolerance)
 233                         {  // it is, change it.
 234                            jack_pos.valid = 0; // only the frame number will be valid since that's all we're changing
 235
 236                            // need a placeholder so that we can keep precision while not letting the integer overflow
 237                            uint64_t placeholder =  (uint64_t)device_time_ms * jack_frame_rate / 1000;
 238                            jack_pos.frame = placeholder;
 239
 240                            jack_transport_reposition(g_jack_client, &jack_pos);
 241
 242                            if (verbose)
 243                               printMMCMessage("Difference between JACK time and MMC destination time in ms: %d. New position is outside of jitter range -> repositioning JACK.\n", jitter);
 244                         }
 245                         else if (verbose)
 246                         {
 247                            if (verbose)
 248                               printMMCMessage("Difference between JACK time and MMC destination time in ms: %d. New position is within jitter range -> ignoring.\n", jitter);
 249                         }
 250
 251                      }
 252                      break;
 253                   case 0x48:              /* step */
 254                      {
 255                         int step;
 256                         jack_position_t jack_pos;
 257
 258                         step = ((uint8_t*)seq_event_ptr->data.ext.ptr)[6];
 259                         if (step > 0x40)
 260                         {
 261                            step &= 0x3F;
 262                            step = -step;
 263                         }
 264
 265                         if (verbose)
 266                            printf("MMC Step %d\n", step);
 267
 268                         // get Jack's current framerate and position
 269                         jack_transport_query(g_jack_client, &jack_pos);
 270
 271                         jack_pos.valid = 0; // only the frame number will be valid since that's all we're changing
 272
 273                         jack_pos.frame += (int64_t)step * (int64_t)jack_pos.frame_rate / (int64_t)10;
 274
 275                         jack_transport_reposition(g_jack_client, &jack_pos);
 276                      }
 277                      break;
 278                   default:
 279                      if (verbose)
 280                         printMMCMessage("unsupported MMC command: 0x%x\n", mmcCommand);
 281                }
 282             }
 283             else if (verbose)
 284             {
 285                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",
 286                       messageDeviceID,
 287                       deviceID);
 288
 289             }
 290          }
 291       }
 292
 293 #if LASH_SUPPORT
 294       /* Process LASH events */
 295       {
 296          lash_event_t * lash_event_ptr = NULL;
 297          lash_config_t * lash_config_ptr = NULL;
 298          while ((lash_event_ptr = lash_get_event(g_lashc)) != NULL)
 299          {
 300             process_lash_event(lash_event_ptr);
 301             lash_event_destroy(lash_event_ptr);
 302          }
 303
 304          /* Process LASH configs */
 305          while ((lash_config_ptr = lash_get_config(g_lashc)) != NULL)
 306          {
 307             process_lash_config(lash_config_ptr);
 308             lash_config_destroy(lash_config_ptr);
 309          }
 310       }
 311 #endif
 312    }
 313 }
 314
 315 void cleanup_globals()
 316 {
 317    int ret = 0;
 318
 319    if (g_seq_ptr)
 320    {
 321       ret = snd_seq_close(g_seq_ptr);
 322       if (ret < 0)
 323       {
 324          printMMCMessage("Cannot close sequncer, %s\n", snd_strerror(ret));
 325       }
 326    }
 327
 328    if (g_jack_client)
 329    {
 330       jack_deactivate(g_jack_client);
 331       jack_client_close(g_jack_client);
 332    }
 333 }