jack.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   This file is part of gmidimonitor
   5  *
   6  *   Copyright (C) 2007,2008 Nedko Arnaudov <nedko@arnaudov.name>
   7  *
   8  *   This program is free software; you can redistribute it and/or modify
   9  *   it under the terms of the GNU General Public License as published by
  10  *   the Free Software Foundation; version 2 of the License
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  *****************************************************************************/
  22
  23 #include <jack/jack.h>
  24 #include <jack/midiport.h>
  25 #include <gtk/gtk.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <assert.h>
  29
  30 #include "config.h"
  31
  32 #include "common.h"
  33 #include "jack.h"
  34 #include "memory_atomic.h"
  35 //#define LOG_LEVEL LOG_LEVEL_DEBUG
  36 #include "log.h"
  37 #include "list.h"
  38 #include "glade.h"
  39 #include "gm.h"
  40 #include "sysex.h"
  41
  42 #include "jack_compat.h"
  43
  44 jack_client_t * g_jack_client;
  45 jack_port_t * g_jack_input_port;
  46 rtsafe_memory_handle g_memory;
  47
  48 struct jack_midi_event_buffer
  49 {
  50   struct list_head siblings;
  51   size_t buffer_size;
  52   unsigned char buffer[0];
  53 };
  54
  55 pthread_mutex_t g_jack_midi_mutex;
  56 //pthread_cond_t g_jack_midi_cond;
  57
  58 /* transfer from jack process callback to main thread */
  59 /* new events are being put at list begining */
  60 struct list_head g_jack_midi_events_pending;
  61
  62 /* temporary storage used by jack process callback in case g_jack_midi_events_pending is locked by main thread */
  63 /* new events are being put at list begining */
  64 struct list_head g_jack_midi_events_pending_rt;
  65
  66 pthread_t g_jack_midi_tid;      /* jack_midi_thread id */
  67
  68 gboolean g_jack_midi_thread_exit; /* whther jack_midi_thread shoud exit */
  69
  70 int
  71 jack_process(jack_nframes_t nframes, void * context)
  72 {
  73   int ret;
  74   void * port_buf;
  75   jack_midi_event_t in_event;
  76   jack_nframes_t event_count;
  77   jack_position_t pos;
  78   jack_nframes_t i;
  79   struct jack_midi_event_buffer * event_buffer;
  80
  81   port_buf = jack_port_get_buffer(g_jack_input_port, nframes);
  82   event_count = jack_midi_get_event_count(port_buf);
  83   jack_transport_query(g_jack_client, &pos);
  84
  85   for (i = 0 ; i < event_count; i++)
  86   {
  87     jack_midi_event_get(&in_event, port_buf, i);
  88
  89     LOG_DEBUG("midi event with size %u received. (jack_process)", (unsigned int)in_event.size);
  90
  91     /* allocate memory for buffer copy */
  92     event_buffer = rtsafe_memory_allocate(g_memory, sizeof(struct jack_midi_event_buffer) + in_event.size);
  93     if (event_buffer == NULL)
  94     {
  95       LOG_ERROR("Ignored midi event with size %u because memory allocation failed.", (unsigned int)in_event.size);
  96       continue;
  97     }
  98
  99     /* copy buffer data */
 100     memcpy(event_buffer->buffer, in_event.buffer, in_event.size);
 101     event_buffer->buffer_size = in_event.size;
 102
 103     /* Add event buffer to g_jack_midi_events_pending_rt list */
 104     list_add(&event_buffer->siblings, &g_jack_midi_events_pending_rt);
 105   }
 106
 107   ret = pthread_mutex_trylock(&g_jack_midi_mutex);
 108   if (ret == 0)
 109   {
 110     /* We are lucky and we got the lock */
 111     LOG_DEBUG("Lucky");
 112
 113     /* Move pending events in g_jack_midi_events_pending_rt to begining of g_jack_midi_events_pending */
 114     list_splice_init(&g_jack_midi_events_pending_rt, &g_jack_midi_events_pending);
 115
 116     /* wakeup jack_midi_thread */
 117     //ret = pthread_cond_broadcast(&g_jack_midi_cond);
 118     //LOG_DEBUG("pthread_cond_broadcast() result is %d", ret);
 119     ret = pthread_mutex_unlock(&g_jack_midi_mutex);
 120     //LOG_DEBUG("pthread_mutex_unlock() result is %d", ret);
 121   }
 122   else
 123   {
 124     /* We are not lucky, jack_midi_thread has locked the mutex */
 125     LOG_DEBUG("Not lucky (%d)", ret);
 126   }
 127
 128   return 0;
 129 }
 130
 131 gboolean
 132 jack_midi_decode(
 133   guint8 * buffer,
 134   size_t buffer_size,
 135   GString * msg_str_ptr,
 136   GString * channel_str_ptr)
 137 {
 138   size_t i;
 139   unsigned int channel;
 140   unsigned int note;
 141   unsigned int velocity;
 142   const char * note_name;
 143   unsigned int octave;
 144   unsigned int controller;
 145   unsigned int value;
 146   const char * controller_name;
 147   signed int pitch;
 148   const char * drum_name;
 149
 150   if (buffer_size == 1 && buffer[0] == 0xFE)
 151   {
 152     g_string_sprintf(msg_str_ptr, "Active sensing");
 153     return FALSE;               /* disable */
 154   }
 155
 156   if (buffer_size == 1 && buffer[0] == 0xF8)
 157   {
 158     g_string_sprintf(msg_str_ptr, "Timing Clock");
 159     return FALSE;               /* disable */
 160   }
 161
 162   if (buffer_size == 3 && (buffer[0] >> 4) == 0x08)
 163   {
 164     channel = (buffer[0] & 0x0F) + 1; /* 1 .. 16 */
 165     assert(channel >= 1 && channel <= 16);
 166
 167     if (channel == 10)
 168     {
 169       return FALSE;                                 /* ignore note off for drums */
 170     }
 171
 172     note = buffer[1];
 173     if (note > 127)
 174     {
 175       goto unknown_event;
 176     }
 177
 178     velocity = buffer[2];
 179     if (velocity > 127)
 180     {
 181       goto unknown_event;
 182     }
 183
 184     note_name = g_note_names[note % 12];
 185     octave = note / 12 - 1;
 186
 187     g_string_sprintf(channel_str_ptr, "%u", channel);
 188
 189     g_string_sprintf(
 190       msg_str_ptr,
 191       "Note off, %s, octave %d, velocity %u",
 192       note_name,
 193       octave,
 194       velocity);
 195
 196     return TRUE;
 197   }
 198
 199   if (buffer_size == 3 && (buffer[0] >> 4) == 0x09)
 200   {
 201     channel = (buffer[0] & 0x0F) + 1; /* 1 .. 16 */
 202     assert(channel >= 1 && channel <= 16);
 203
 204     note = buffer[1];
 205     if (note > 127)
 206     {
 207       goto unknown_event;
 208     }
 209
 210     velocity = buffer[2];
 211     if (velocity > 127)
 212     {
 213       goto unknown_event;
 214     }
 215
 216     note_name = g_note_names[note % 12];
 217     octave = note / 12 - 1;
 218
 219     g_string_sprintf(channel_str_ptr, "%u", channel);
 220
 221     if (channel == 10)
 222     {
 223       drum_name = gm_get_drum_name(note);
 224     }
 225     else
 226     {
 227       drum_name = NULL;
 228     }
 229
 230     if (drum_name != NULL)
 231     {
 232       if (velocity == 0)
 233       {
 234         return FALSE;                                 /* ignore note off for drums */
 235       }
 236
 237       g_string_sprintf(
 238         msg_str_ptr,
 239         "Drum: %s (%s, octave %d, velocity %u)",
 240         drum_name,
 241         note_name,
 242         octave,
 243         velocity);
 244     }
 245     else
 246     {
 247       g_string_sprintf(
 248         msg_str_ptr,
 249         "Note on, %s, octave %d, velocity %u",
 250         note_name,
 251         octave,
 252         velocity);
 253     }
 254
 255     return TRUE;
 256   }
 257
 258   if (buffer_size == 3 && (buffer[0] >> 4) == 0x0A)
 259   {
 260     channel = (buffer[0] & 0x0F) + 1; /* 1 .. 16 */
 261     assert(channel >= 1 && channel <= 16);
 262
 263     note = buffer[1];
 264     if (note > 127)
 265     {
 266       goto unknown_event;
 267     }
 268
 269     velocity = buffer[2];
 270     if (velocity > 127)
 271     {
 272       goto unknown_event;
 273     }
 274
 275     note_name = g_note_names[note % 12];
 276     octave = note / 12 - 1;
 277
 278     g_string_sprintf(channel_str_ptr, "%u", channel);
 279
 280     g_string_sprintf(
 281       msg_str_ptr,
 282       "Polyphonic Key Pressure (Aftertouch), %s, octave %d, velocity %u",
 283       note_name,
 284       octave,
 285       velocity);
 286
 287     return TRUE;
 288   }
 289
 290   if (buffer_size == 3 && (buffer[0] >> 4) == 0x0B)
 291   {
 292     channel = (buffer[0] & 0x0F) + 1; /* 1 .. 16 */
 293     assert(channel >= 1 && channel <= 16);
 294
 295     controller = buffer[1];
 296     if (controller > 127)
 297     {
 298       goto unknown_event;
 299     }
 300
 301     value = buffer[2];
 302     if (value > 127)
 303     {
 304       goto unknown_event;
 305     }
 306
 307     g_string_sprintf(channel_str_ptr, "%u", channel);
 308
 309     controller_name = gm_get_controller_name(controller);
 310
 311     if (controller_name != NULL)
 312     {
 313       g_string_sprintf(
 314         msg_str_ptr,
 315         "CC %s (%u), value %u",
 316         controller_name,
 317         controller,
 318         value);
 319     }
 320     else
 321     {
 322       g_string_sprintf(
 323         msg_str_ptr,
 324         "CC %u, value %u",
 325         controller,
 326         value);
 327     }
 328
 329     return TRUE;
 330   }
 331
 332   if (buffer_size == 2 && (buffer[0] >> 4) == 0x0C)
 333   {
 334     channel = (buffer[0] & 0x0F) + 1; /* 1 .. 16 */
 335     assert(channel >= 1 && channel <= 16);
 336
 337     value = buffer[1];
 338     if (value > 127)
 339     {
 340       goto unknown_event;
 341     }
 342
 343     g_string_sprintf(channel_str_ptr, "%u", channel);
 344
 345     g_string_sprintf(
 346       msg_str_ptr,
 347       "Program change, %d (%s)",
 348       value,
 349       gm_get_instrument_name(value));
 350
 351     return TRUE;
 352   }
 353
 354   if (buffer_size == 3 && (buffer[0] >> 4) == 0x0E && buffer[1] <= 127 && buffer[1] <= 127)
 355   {
 356     channel = (buffer[0] & 0x0F) + 1; /* 1 .. 16 */
 357     assert(channel >= 1 && channel <= 16);
 358
 359     pitch = buffer[1];
 360     pitch |= (unsigned int)buffer[2] << 7;
 361     pitch -= 0x2000;
 362
 363     g_string_sprintf(channel_str_ptr, "%u", channel);
 364
 365     g_string_sprintf(
 366       msg_str_ptr,
 367       "Pitchwheel, %d",
 368       pitch);
 369
 370     return TRUE;
 371   }
 372
 373   if (buffer_size > 0 && buffer[0] == 0xF0)
 374   {
 375     decode_sysex(buffer, buffer_size, msg_str_ptr);
 376     return TRUE;
 377   }
 378
 379   if (buffer_size == 1 && buffer[0] == 0xFF)
 380   {
 381     g_string_sprintf(
 382       msg_str_ptr,
 383       "Reset");
 384
 385     return TRUE;
 386   }
 387
 388 unknown_event:
 389   g_string_sprintf(
 390     msg_str_ptr,
 391     "unknown midi event with size %u bytes:",
 392     (unsigned int)buffer_size);
 393
 394   for (i = 0 ; i < buffer_size ; i++)
 395   {
 396     g_string_append_printf(
 397       msg_str_ptr,
 398       " %02X",
 399       (unsigned int)(buffer[i]));
 400   }
 401
 402   return TRUE;
 403 }
 404
 405 /* The JACK MIDI input handling thread */
 406 void *
 407 jack_midi_thread(void * context_ptr)
 408 {
 409   struct jack_midi_event_buffer * event_buffer;
 410   struct list_head * node_ptr;
 411   GtkListStore * list_store_ptr;
 412   GtkWidget * child_ptr;
 413   GtkTreeIter iter;
 414   GString * time_str_ptr;
 415   GString * msg_str_ptr;
 416   GString * channel_str_ptr;
 417
 418   LOG_DEBUG("jack_midi_thread started");
 419
 420   child_ptr = get_glade_widget_child(g_main_window_ptr, "list");
 421
 422   list_store_ptr = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(child_ptr)));
 423
 424 loop:
 425   pthread_mutex_lock(&g_jack_midi_mutex);
 426
 427   if (g_jack_midi_thread_exit)
 428   {
 429     pthread_mutex_unlock(&g_jack_midi_mutex);
 430
 431     LOG_DEBUG("jack_midi_thread exiting");
 432     return NULL;
 433   }
 434
 435   rtsafe_memory_sleepy(g_memory);
 436
 437   //LOG_DEBUG("checking events...");
 438
 439   while (!list_empty(&g_jack_midi_events_pending))
 440   {
 441     node_ptr = g_jack_midi_events_pending.prev;
 442
 443     list_del(node_ptr);
 444
 445     event_buffer = list_entry(node_ptr, struct jack_midi_event_buffer, siblings);
 446
 447     if (g_midi_ignore)
 448     {
 449       goto deallocate_event;
 450     }
 451
 452     LOG_DEBUG("midi event with size %u received.", (unsigned int)event_buffer->buffer_size);
 453
 454     time_str_ptr = g_string_new("");
 455     channel_str_ptr = g_string_new("");
 456     msg_str_ptr = g_string_new("");
 457
 458     if (!jack_midi_decode(
 459           event_buffer->buffer,
 460           event_buffer->buffer_size,
 461           msg_str_ptr,
 462           channel_str_ptr))
 463     {
 464       /* ignoring specific event */
 465       goto deallocate_strings;
 466     }
 467
 468     /* get GTK thread lock */
 469     gdk_threads_enter();
 470
 471     if (g_row_count >= MAX_LIST_SIZE)
 472     {
 473       gtk_tree_model_get_iter_first(
 474         GTK_TREE_MODEL(list_store_ptr),
 475         &iter);
 476
 477       gtk_list_store_remove(
 478         list_store_ptr,
 479         &iter);
 480     }
 481
 482     /* Append an empty row to the list store. Iter will point to the new row */
 483     gtk_list_store_append(list_store_ptr, &iter);
 484
 485     gtk_list_store_set(
 486       list_store_ptr,
 487       &iter,
 488       COL_TIME, time_str_ptr->str,
 489       COL_CHANNEL, channel_str_ptr->str,
 490       COL_MESSAGE, msg_str_ptr->str,
 491       -1);
 492
 493     gtk_tree_view_scroll_to_cell(
 494       GTK_TREE_VIEW(child_ptr),
 495       gtk_tree_model_get_path(
 496         gtk_tree_view_get_model(GTK_TREE_VIEW(child_ptr)),
 497         &iter),
 498       NULL,
 499       TRUE,
 500       0.0,
 501       1.0);
 502
 503     /* Force update of scroll position. */
 504     /* Is it a bug that it does not update automagically ? */
 505     gtk_container_check_resize(GTK_CONTAINER(child_ptr));
 506
 507     g_row_count++;
 508
 509     /* release GTK thread lock */
 510     gdk_threads_leave();
 511
 512   deallocate_strings:
 513     g_string_free(channel_str_ptr, TRUE);
 514     g_string_free(msg_str_ptr, TRUE);
 515     g_string_free(time_str_ptr, TRUE);
 516
 517   deallocate_event:
 518     rtsafe_memory_deallocate(event_buffer);
 519   }
 520
 521   pthread_mutex_unlock(&g_jack_midi_mutex);
 522
 523   //LOG_DEBUG("waiting for more events...");
 524
 525   //pthread_cond_wait(&g_jack_midi_cond, &g_jack_midi_mutex);
 526   usleep(10000);
 527
 528   goto loop;
 529 }
 530
 531 void
 532 jack_destroy_pending_events()
 533 {
 534   struct jack_midi_event_buffer * event_buffer;
 535   struct list_head * node_ptr;
 536
 537   while (!list_empty(&g_jack_midi_events_pending))
 538   {
 539     LOG_DEBUG("Destroying pending event");
 540     node_ptr = g_jack_midi_events_pending.next;
 541
 542     list_del(node_ptr);
 543
 544     event_buffer = list_entry(node_ptr, struct jack_midi_event_buffer, siblings);
 545
 546     rtsafe_memory_deallocate(event_buffer);
 547   }
 548
 549   while (!list_empty(&g_jack_midi_events_pending_rt))
 550   {
 551     LOG_DEBUG("Destroying realtime pending event");
 552     node_ptr = g_jack_midi_events_pending_rt.next;
 553
 554     list_del(node_ptr);
 555
 556     event_buffer = list_entry(node_ptr, struct jack_midi_event_buffer, siblings);
 557
 558     rtsafe_memory_deallocate(event_buffer);
 559   }
 560 }
 561
 562 gboolean
 563 jack_init(const char * name)
 564 {
 565   int ret;
 566
 567   LOG_DEBUG("jack_init(\"%s\") called.", name);
 568
 569   if (!rtsafe_memory_init(
 570         100 * 1024,
 571         100,
 572         1000,
 573         &g_memory))
 574   {
 575     LOG_ERROR("RT-safe memory initialization failed.");
 576     goto fail;
 577   }
 578
 579   INIT_LIST_HEAD(&g_jack_midi_events_pending);
 580   INIT_LIST_HEAD(&g_jack_midi_events_pending_rt);
 581
 582   ret = pthread_mutex_init(&g_jack_midi_mutex,  NULL);
 583   if (ret != 0)
 584   {
 585     LOG_ERROR("Cannot initialize mutex.");
 586     goto fail_uninit_memory;
 587   }
 588
 589 /*   ret = pthread_cond_init(&g_jack_midi_cond,  NULL); */
 590 /*   if (ret != 0) */
 591 /*   { */
 592 /*     LOG_ERROR("Cannot initialize condition (variable)."); */
 593 /*     goto fail_uninit_mutex; */
 594 /*   } */
 595
 596   g_jack_midi_thread_exit = FALSE;
 597
 598   ret = pthread_create(&g_jack_midi_tid, NULL, jack_midi_thread, NULL);
 599   if (ret != 0)
 600   {
 601     LOG_ERROR("Cannot start JACK MIDI thread.");
 602     goto fail_uninit_cond;
 603   }
 604
 605   g_jack_client = jack_client_new(name);
 606   if (g_jack_client == NULL)
 607   {
 608     LOG_ERROR("Cannot create JACK client.");
 609     goto fail_stop_thread;
 610   }
 611
 612   ret = jack_set_process_callback(g_jack_client, jack_process, 0);
 613   if (ret != 0)
 614   {
 615     LOG_ERROR("Cannot set JACK process callback.");
 616     goto fail_close;
 617   }
 618
 619   g_jack_input_port = jack_port_register(g_jack_client, "midi_in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 620   if (g_jack_input_port == NULL)
 621   {
 622     LOG_ERROR("Failed to create input JACK MIDI port");
 623     goto fail_close;
 624   }
 625
 626   ret = jack_activate(g_jack_client);
 627   if (ret != 0)
 628   {
 629     LOG_ERROR("Cannot activate JACK client.");
 630     goto fail_close;
 631   }
 632
 633   return TRUE;
 634
 635 fail_close:
 636   jack_client_close(g_jack_client);
 637
 638 fail_stop_thread:
 639   jack_destroy_pending_events();
 640
 641   /* Tell jack_midi_thread to exit */
 642   pthread_mutex_lock(&g_jack_midi_mutex);
 643   g_jack_midi_thread_exit = TRUE;
 644   pthread_mutex_unlock(&g_jack_midi_mutex);
 645
 646   /* wakeup jack_midi_thread */
 647 /*   pthread_cond_broadcast(&g_jack_midi_cond); */
 648
 649   /* wait thread to finish */
 650   pthread_join(g_jack_midi_tid, NULL);
 651
 652 fail_uninit_cond:
 653 /*   pthread_cond_destroy(&g_jack_midi_cond); */
 654
 655 /* fail_uninit_mutex: */
 656   pthread_mutex_destroy(&g_jack_midi_mutex);
 657
 658 fail_uninit_memory:
 659   rtsafe_memory_uninit(g_memory);
 660
 661 fail:
 662   return FALSE;
 663 }
 664
 665 void
 666 jack_uninit()
 667 {
 668   LOG_DEBUG("jack_uninit() called.");
 669
 670   jack_deactivate(g_jack_client);
 671
 672   jack_client_close(g_jack_client);
 673
 674   /* Tell jack_midi_thread to exit */
 675   pthread_mutex_lock(&g_jack_midi_mutex);
 676   g_jack_midi_thread_exit = TRUE;
 677   pthread_mutex_unlock(&g_jack_midi_mutex);
 678
 679   /* wakeup jack_midi_thread */
 680 /*   pthread_cond_broadcast(&g_jack_midi_cond); */
 681
 682   /* wait thread to finish */
 683   pthread_join(g_jack_midi_tid, NULL);
 684
 685   jack_destroy_pending_events();
 686
 687 /*   pthread_cond_destroy(&g_jack_midi_cond); */
 688
 689   pthread_mutex_destroy(&g_jack_midi_mutex);
 690
 691   rtsafe_memory_uninit(g_memory);
 692 }