jack_mixer.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   This file is part of jack_mixer
   5  *
   6  *   Copyright (C) 2006 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 "config.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdbool.h>
  28 #include <math.h>
  29 #include <jack/jack.h>
  30 #if defined(HAVE_JACK_MIDI)
  31 #include <jack/midiport.h>
  32 #endif
  33 #include <assert.h>
  34 #include <pthread.h>
  35
  36 #include "jack_mixer.h"
  37 #include "list.h"
  38 //#define LOG_LEVEL LOG_LEVEL_DEBUG
  39 #include "log.h"
  40
  41 #include "jack_compat.h"
  42
  43 #define PEAK_FRAMES_CHUNK 4800
  44
  45 #define FLOAT_EXISTS(x) (!((x) - (x)))
  46
  47 struct channel
  48 {
  49   struct list_head siblings;
  50   struct jack_mixer * mixer_ptr;
  51   char * name;
  52   bool stereo;
  53   float volume;
  54   float balance;
  55   bool muted;
  56   bool soloed;
  57   float volume_left;
  58   float volume_right;
  59   float meter_left;
  60   float meter_right;
  61   float abspeak;
  62   jack_port_t * port_left;
  63   jack_port_t * port_right;
  64
  65   jack_nframes_t peak_frames;
  66   float peak_left;
  67   float peak_right;
  68
  69   bool NaN_detected;
  70
  71   struct channel ** cc_map_volume_ptr_ptr;
  72   struct channel ** cc_map_balance_ptr_ptr;
  73
  74   jack_default_audio_sample_t * left_buffer_ptr;
  75   jack_default_audio_sample_t * right_buffer_ptr;
  76
  77   bool midi_modified;
  78
  79   jack_mixer_scale_t midi_scale;
  80 };
  81
  82 struct jack_mixer
  83 {
  84   pthread_mutex_t mutex;
  85   jack_client_t * jack_client;
  86   struct list_head channels_list;
  87   struct channel main_mix_channel;
  88   unsigned int channels_count;
  89   unsigned int soloed_channels_count;
  90
  91   jack_port_t * port_midi_in;
  92
  93   struct
  94   {
  95     bool balance;               /* volume or balance is controlled by this mapping */
  96     struct channel * channel_ptr;
  97   } midi_cc_map[128];
  98 };
  99
 100 float value_to_db(float value)
 101 {
 102   if (value <= 0)
 103   {
 104     return -INFINITY;
 105   }
 106
 107   return 20.0 * log10f(value);
 108 }
 109
 110 float db_to_value(float db)
 111 {
 112   return powf(10.0, db/20.0);
 113 }
 114
 115 void
 116 calc_channel_volumes(struct channel * channel_ptr)
 117 {
 118   if (channel_ptr->muted)
 119   {
 120     channel_ptr->volume_left = 0;
 121     channel_ptr->volume_right = 0;
 122     return;
 123   }
 124
 125   if (channel_ptr->mixer_ptr->soloed_channels_count > 0 && !channel_ptr->soloed) /* there are soloed channels but we are not one of them */
 126   {
 127     channel_ptr->volume_left = 0;
 128     channel_ptr->volume_right = 0;
 129     return;
 130   }
 131
 132   if (channel_ptr->stereo)
 133   {
 134     if (channel_ptr->balance > 0)
 135     {
 136       channel_ptr->volume_left = channel_ptr->volume * (1 - channel_ptr->balance);
 137       channel_ptr->volume_right = channel_ptr->volume;
 138     }
 139     else
 140     {
 141       channel_ptr->volume_left = channel_ptr->volume;
 142       channel_ptr->volume_right = channel_ptr->volume * (1 + channel_ptr->balance);
 143     }
 144   }
 145   else
 146   {
 147     channel_ptr->volume_left = channel_ptr->volume * (1 - channel_ptr->balance);
 148     channel_ptr->volume_right = channel_ptr->volume * (1 + channel_ptr->balance);
 149   }
 150 }
 151
 152 void
 153 calc_all_channel_volumes(
 154   struct jack_mixer * mixer_ptr)
 155 {
 156   struct list_head * node_ptr;
 157   struct channel * channel_ptr;
 158
 159   list_for_each(node_ptr, &mixer_ptr->channels_list)
 160   {
 161     channel_ptr = list_entry(node_ptr, struct channel, siblings);
 162     calc_channel_volumes(channel_ptr);
 163   }
 164 }
 165
 166 #define channel_ptr ((struct channel *)channel)
 167
 168 const char * channel_get_name(jack_mixer_channel_t channel)
 169 {
 170   return channel_ptr->name;
 171 }
 172
 173 void channel_rename(jack_mixer_channel_t channel, const char * name)
 174 {
 175   char * new_name;
 176   size_t channel_name_size;
 177   char * port_name;
 178   int ret;
 179
 180   new_name = strdup(name);
 181   if (new_name == NULL)
 182   {
 183     return;
 184   }
 185
 186   if (channel_ptr->name)
 187   {
 188     free(channel_ptr->name);
 189   }
 190
 191   channel_ptr->name = new_name;
 192
 193   if (channel_ptr->stereo)
 194   {
 195     channel_name_size = strlen(name);
 196     port_name = malloc(channel_name_size + 3);
 197     memcpy(port_name, name, channel_name_size);
 198
 199     port_name[channel_name_size] = ' ';
 200     port_name[channel_name_size+1] = 'L';
 201     port_name[channel_name_size+2] = 0;
 202
 203     ret = jack_port_set_name(channel_ptr->port_left, port_name);
 204     if (ret != 0)
 205     {
 206       /* what could we do here? */
 207     }
 208
 209     port_name[channel_name_size+1] = 'R';
 210
 211     ret = jack_port_set_name(channel_ptr->port_right, port_name);
 212     if (ret != 0)
 213     {
 214       /* what could we do here? */
 215     }
 216
 217     free(port_name);
 218   }
 219   else
 220   {
 221     ret = jack_port_set_name(channel_ptr->port_left, name);
 222     if (ret != 0)
 223     {
 224       /* what could we do here? */
 225     }
 226   }
 227 }
 228
 229 bool channel_is_stereo(jack_mixer_channel_t channel)
 230 {
 231   return channel_ptr->stereo;
 232 }
 233
 234 void remove_channel(jack_mixer_channel_t channel)
 235 {
 236   list_del(&channel_ptr->siblings);
 237   free(channel_ptr->name);
 238
 239   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
 240   if (channel_ptr->stereo)
 241   {
 242     jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_right);
 243   }
 244
 245   channel_ptr->mixer_ptr->channels_count--;
 246
 247   if (channel_ptr->cc_map_volume_ptr_ptr != NULL)
 248   {
 249     assert(*(channel_ptr->cc_map_volume_ptr_ptr) == channel_ptr);
 250     *(channel_ptr->cc_map_volume_ptr_ptr) = NULL;
 251   }
 252
 253   if (channel_ptr->cc_map_balance_ptr_ptr != NULL)
 254   {
 255     assert(*(channel_ptr->cc_map_balance_ptr_ptr) == channel_ptr);
 256     *(channel_ptr->cc_map_balance_ptr_ptr) = NULL;
 257   }
 258
 259   free(channel_ptr);
 260 }
 261
 262 void channel_stereo_meter_read(jack_mixer_channel_t channel, double * left_ptr, double * right_ptr)
 263 {
 264   assert(channel_ptr);
 265   *left_ptr = value_to_db(channel_ptr->meter_left);
 266   *right_ptr = value_to_db(channel_ptr->meter_right);
 267 }
 268
 269 void channel_mono_meter_read(jack_mixer_channel_t channel, double * mono_ptr)
 270 {
 271   *mono_ptr = value_to_db(channel_ptr->meter_left);
 272 }
 273
 274 bool
 275 channel_is_midi_modified(
 276   jack_mixer_channel_t channel)
 277 {
 278   bool midi_modified;
 279
 280   assert(channel_ptr);
 281   midi_modified = channel_ptr->midi_modified;
 282   channel_ptr->midi_modified = false;
 283
 284   return midi_modified;
 285 }
 286
 287 void channel_volume_write(jack_mixer_channel_t channel, double volume)
 288 {
 289   assert(channel_ptr);
 290   channel_ptr->volume = db_to_value(volume);
 291   calc_channel_volumes(channel_ptr);
 292 }
 293
 294 double
 295 channel_volume_read(
 296   jack_mixer_channel_t channel)
 297 {
 298   assert(channel_ptr);
 299   return value_to_db(channel_ptr->volume);
 300 }
 301
 302 void channel_balance_write(jack_mixer_channel_t channel, double balance)
 303 {
 304   assert(channel_ptr);
 305   channel_ptr->balance = balance;
 306   calc_channel_volumes(channel_ptr);
 307 }
 308
 309 double
 310 channel_balance_read(
 311   jack_mixer_channel_t channel)
 312 {
 313   assert(channel_ptr);
 314   return channel_ptr->balance;
 315 }
 316
 317 double channel_abspeak_read(jack_mixer_channel_t channel)
 318 {
 319   assert(channel_ptr);
 320   if (channel_ptr->NaN_detected)
 321   {
 322     return sqrt(-1);
 323   }
 324   else
 325   {
 326     return value_to_db(channel_ptr->abspeak);
 327   }
 328 }
 329
 330 void channel_abspeak_reset(jack_mixer_channel_t channel)
 331 {
 332   channel_ptr->abspeak = 0;
 333   channel_ptr->NaN_detected = false;
 334 }
 335
 336 void channel_mute(jack_mixer_channel_t channel)
 337 {
 338   channel_ptr->muted = true;
 339   calc_channel_volumes(channel_ptr);
 340 }
 341
 342 void channel_unmute(jack_mixer_channel_t channel)
 343 {
 344   channel_ptr->muted = false;
 345   calc_channel_volumes(channel_ptr);
 346 }
 347
 348 void channel_solo(jack_mixer_channel_t channel)
 349 {
 350   if (!channel_ptr->soloed)
 351   {
 352     channel_ptr->soloed = true;
 353     channel_ptr->mixer_ptr->soloed_channels_count++;
 354
 355     if (channel_ptr->mixer_ptr->soloed_channels_count == 1)
 356     {
 357       calc_all_channel_volumes(channel_ptr->mixer_ptr);
 358     }
 359     else
 360     {
 361       calc_channel_volumes(channel_ptr);
 362     }
 363   }
 364 }
 365
 366 void channel_unsolo(jack_mixer_channel_t channel)
 367 {
 368   if (channel_ptr->soloed)
 369   {
 370     channel_ptr->soloed = false;
 371     channel_ptr->mixer_ptr->soloed_channels_count--;
 372
 373     if (channel_ptr->mixer_ptr->soloed_channels_count == 0)
 374     {
 375       calc_all_channel_volumes(channel_ptr->mixer_ptr);
 376     }
 377     else
 378     {
 379       calc_channel_volumes(channel_ptr);
 380     }
 381   }
 382 }
 383
 384 bool channel_is_muted(jack_mixer_channel_t channel)
 385 {
 386   return channel_ptr->muted;
 387 }
 388
 389 bool channel_is_soloed(jack_mixer_channel_t channel)
 390 {
 391   return channel_ptr->soloed;
 392 }
 393
 394 void
 395 channel_set_midi_scale(
 396   jack_mixer_channel_t channel,
 397   jack_mixer_scale_t scale)
 398 {
 399   channel_ptr->midi_scale = scale;
 400 }
 401
 402 #undef channel_ptr
 403
 404 /* process input channels and mix them into main mix */
 405 static
 406 inline
 407 void
 408 mix(
 409   struct jack_mixer * mixer_ptr,
 410   jack_nframes_t start,         /* index of first sample to process */
 411   jack_nframes_t end)           /* index of sample to stop processing before */
 412 {
 413   jack_nframes_t i;
 414   struct list_head * node_ptr;
 415   struct channel * channel_ptr;
 416   jack_default_audio_sample_t frame_left;
 417   jack_default_audio_sample_t frame_right;
 418
 419   list_for_each(node_ptr, &mixer_ptr->channels_list)
 420   {
 421     channel_ptr = list_entry(node_ptr, struct channel, siblings);
 422
 423     for (i = start ; i < end ; i++)
 424     {
 425       if (!FLOAT_EXISTS(channel_ptr->left_buffer_ptr[i]))
 426       {
 427         channel_ptr->NaN_detected = true;
 428         break;
 429       }
 430
 431       frame_left = channel_ptr->left_buffer_ptr[i] * channel_ptr->volume_left;
 432       mixer_ptr->main_mix_channel.left_buffer_ptr[i] += frame_left;
 433
 434       if (channel_ptr->stereo)
 435       {
 436         if (!FLOAT_EXISTS(channel_ptr->right_buffer_ptr[i]))
 437         {
 438           channel_ptr->NaN_detected = true;
 439           break;
 440         }
 441
 442         frame_right = channel_ptr->right_buffer_ptr[i] * channel_ptr->volume_right;
 443       }
 444       else
 445       {
 446         frame_right = channel_ptr->left_buffer_ptr[i] * channel_ptr->volume_right;
 447       }
 448
 449       mixer_ptr->main_mix_channel.right_buffer_ptr[i] += frame_right;
 450
 451       if (channel_ptr->stereo)
 452       {
 453         frame_left = fabsf(frame_left);
 454         frame_right = fabsf(frame_right);
 455
 456         if (channel_ptr->peak_left < frame_left)
 457         {
 458           channel_ptr->peak_left = frame_left;
 459
 460           if (frame_left > channel_ptr->abspeak)
 461           {
 462             channel_ptr->abspeak = frame_left;
 463           }
 464         }
 465
 466         if (channel_ptr->peak_right < frame_right)
 467         {
 468           channel_ptr->peak_right = frame_right;
 469
 470           if (frame_right > channel_ptr->abspeak)
 471           {
 472             channel_ptr->abspeak = frame_right;
 473           }
 474         }
 475       }
 476       else
 477       {
 478         frame_left = (fabsf(frame_left) + fabsf(frame_right)) / 2;
 479
 480         if (channel_ptr->peak_left < frame_left)
 481         {
 482           channel_ptr->peak_left = frame_left;
 483
 484           if (frame_left > channel_ptr->abspeak)
 485           {
 486             channel_ptr->abspeak = frame_left;
 487           }
 488         }
 489       }
 490
 491       channel_ptr->peak_frames++;
 492       if (channel_ptr->peak_frames >= PEAK_FRAMES_CHUNK)
 493       {
 494         channel_ptr->meter_left = channel_ptr->peak_left;
 495         channel_ptr->peak_left = 0.0;
 496
 497         if (channel_ptr->stereo)
 498         {
 499           channel_ptr->meter_right = channel_ptr->peak_right;
 500           channel_ptr->peak_right = 0.0;
 501         }
 502
 503         channel_ptr->peak_frames = 0;
 504       }
 505     }
 506   }
 507
 508   /* process main mix channel */
 509   for (i = start ; i < end ; i++)
 510   {
 511     mixer_ptr->main_mix_channel.left_buffer_ptr[i] *= mixer_ptr->main_mix_channel.volume_left;
 512     mixer_ptr->main_mix_channel.right_buffer_ptr[i] *= mixer_ptr->main_mix_channel.volume_right;
 513
 514     frame_left = fabsf(mixer_ptr->main_mix_channel.left_buffer_ptr[i]);
 515     if (mixer_ptr->main_mix_channel.peak_left < frame_left)
 516     {
 517       mixer_ptr->main_mix_channel.peak_left = frame_left;
 518
 519       if (frame_left > mixer_ptr->main_mix_channel.abspeak)
 520       {
 521         mixer_ptr->main_mix_channel.abspeak = frame_left;
 522       }
 523     }
 524
 525     frame_right = fabsf(mixer_ptr->main_mix_channel.right_buffer_ptr[i]);
 526     if (mixer_ptr->main_mix_channel.peak_right < frame_right)
 527     {
 528       mixer_ptr->main_mix_channel.peak_right = frame_right;
 529
 530       if (frame_right > mixer_ptr->main_mix_channel.abspeak)
 531       {
 532         mixer_ptr->main_mix_channel.abspeak = frame_right;
 533       }
 534     }
 535
 536     mixer_ptr->main_mix_channel.peak_frames++;
 537     if (mixer_ptr->main_mix_channel.peak_frames >= PEAK_FRAMES_CHUNK)
 538     {
 539       mixer_ptr->main_mix_channel.meter_left = mixer_ptr->main_mix_channel.peak_left;
 540       mixer_ptr->main_mix_channel.peak_left = 0.0;
 541
 542       mixer_ptr->main_mix_channel.meter_right = mixer_ptr->main_mix_channel.peak_right;
 543       mixer_ptr->main_mix_channel.peak_right = 0.0;
 544
 545       mixer_ptr->main_mix_channel.peak_frames = 0;
 546     }
 547   }
 548 }
 549
 550 static
 551 inline
 552 void
 553 update_channel_buffers(
 554   struct channel * channel_ptr,
 555   jack_nframes_t nframes)
 556 {
 557   channel_ptr->left_buffer_ptr = jack_port_get_buffer(channel_ptr->port_left, nframes);
 558
 559   if (channel_ptr->stereo)
 560   {
 561     channel_ptr->right_buffer_ptr = jack_port_get_buffer(channel_ptr->port_right, nframes);
 562   }
 563 }
 564
 565 #define mixer_ptr ((struct jack_mixer *)context)
 566
 567 int
 568 process(jack_nframes_t nframes, void * context)
 569 {
 570   jack_nframes_t i;
 571   struct list_head * node_ptr;
 572   struct channel * channel_ptr;
 573 #if defined(HAVE_JACK_MIDI)
 574   jack_nframes_t event_count;
 575   jack_midi_event_t in_event;
 576   void * midi_buffer;
 577   signed char byte;
 578 #endif
 579   jack_nframes_t offset;
 580
 581   update_channel_buffers(&mixer_ptr->main_mix_channel, nframes);
 582
 583   list_for_each(node_ptr, &mixer_ptr->channels_list)
 584   {
 585     channel_ptr = list_entry(node_ptr, struct channel, siblings);
 586
 587     update_channel_buffers(channel_ptr, nframes);
 588   }
 589
 590   for (i = 0 ; i < nframes ; i++)
 591   {
 592     mixer_ptr->main_mix_channel.left_buffer_ptr[i] = 0.0;
 593     mixer_ptr->main_mix_channel.right_buffer_ptr[i] = 0.0;
 594   }
 595
 596   offset = 0;
 597
 598 #if defined(HAVE_JACK_MIDI)
 599   midi_buffer = jack_port_get_buffer(mixer_ptr->port_midi_in, nframes);
 600   event_count = jack_midi_get_event_count(midi_buffer);
 601
 602   for (i = 0 ; i < event_count; i++)
 603   {
 604     jack_midi_event_get(&in_event, midi_buffer, i);
 605
 606     if (in_event.size != 3 ||
 607         (in_event.buffer[0] & 0xF0) != 0xB0 ||
 608         in_event.buffer[1] > 127 ||
 609         in_event.buffer[2] > 127)
 610     {
 611       continue;
 612     }
 613
 614     assert(in_event.time < nframes);
 615
 616     LOG_DEBUG(
 617       "%u: CC#%u -> %u",
 618       (unsigned int)(in_event.buffer[0] & 0x0F),
 619       (unsigned int)in_event.buffer[1],
 620       (unsigned int)in_event.buffer[2]);
 621
 622     channel_ptr = mixer_ptr->midi_cc_map[in_event.buffer[1]].channel_ptr;
 623
 624     /* if we have mapping for particular CC and MIDI scale is set for corresponding channel */
 625     if (channel_ptr != NULL && channel_ptr->midi_scale != NULL)
 626     {
 627       assert(in_event.time >= offset);
 628
 629       if (in_event.time > offset)
 630       {
 631         mix(mixer_ptr, offset, in_event.time);
 632         offset = in_event.time;
 633       }
 634
 635       if (mixer_ptr->midi_cc_map[in_event.buffer[1]].balance)
 636       {
 637         byte = in_event.buffer[2];
 638         if (byte == 0)
 639         {
 640           byte = 1;
 641         }
 642         byte -= 64;
 643
 644         channel_ptr->balance = (float)byte / 63;
 645         LOG_DEBUG("\"%s\" balance -> %f", channel_ptr->name, channel_ptr->balance);
 646       }
 647       else
 648       {
 649         channel_ptr->volume = db_to_value(scale_scale_to_db(channel_ptr->midi_scale, (double)in_event.buffer[2] / 127));
 650         LOG_DEBUG("\"%s\" volume -> %f", channel_ptr->name, channel_ptr->volume);
 651       }
 652
 653       calc_channel_volumes(channel_ptr);
 654
 655       channel_ptr->midi_modified = true;
 656     }
 657
 658   }
 659
 660 #endif
 661
 662   mix(mixer_ptr, offset, nframes);
 663
 664   return 0;
 665 }
 666
 667 #undef mixer_ptr
 668
 669 jack_mixer_t
 670 create(
 671   const char * jack_client_name_ptr)
 672 {
 673   int ret;
 674   struct jack_mixer * mixer_ptr;
 675   int i;
 676
 677
 678   mixer_ptr = malloc(sizeof(struct jack_mixer));
 679   if (mixer_ptr == NULL)
 680   {
 681     goto exit;
 682   }
 683
 684   ret = pthread_mutex_init(&mixer_ptr->mutex, NULL);
 685   if (ret != 0)
 686   {
 687     goto exit_free;
 688   }
 689
 690   INIT_LIST_HEAD(&mixer_ptr->channels_list);
 691
 692   mixer_ptr->channels_count = 0;
 693   mixer_ptr->soloed_channels_count = 0;
 694
 695   for (i = 0 ; i < 128 ; i++)
 696   {
 697     mixer_ptr->midi_cc_map[i].channel_ptr = NULL;
 698   }
 699
 700   mixer_ptr->midi_cc_map[7].channel_ptr = &mixer_ptr->main_mix_channel;
 701   mixer_ptr->midi_cc_map[7].balance = false;
 702   mixer_ptr->main_mix_channel.cc_map_volume_ptr_ptr = &mixer_ptr->midi_cc_map[7].channel_ptr;
 703
 704   mixer_ptr->midi_cc_map[8].channel_ptr = &mixer_ptr->main_mix_channel;
 705   mixer_ptr->midi_cc_map[8].balance = true;
 706   mixer_ptr->main_mix_channel.cc_map_balance_ptr_ptr = &mixer_ptr->midi_cc_map[8].channel_ptr;
 707
 708   LOG_DEBUG("Initializing JACK");
 709   mixer_ptr->jack_client = jack_client_new(jack_client_name_ptr);
 710   if (mixer_ptr->jack_client == NULL)
 711   {
 712     LOG_ERROR("Cannot create JACK client.");
 713     LOG_NOTICE("Please make sure JACK daemon is running.");
 714     goto exit_destroy_mutex;
 715   }
 716
 717   LOG_DEBUG("JACK client created");
 718
 719   LOG_DEBUG("Sample rate: %" PRIu32, jack_get_sample_rate(mixer_ptr->jack_client));
 720
 721   mixer_ptr->main_mix_channel.mixer_ptr = mixer_ptr;
 722
 723 #if defined(HAVE_JACK_MIDI)
 724   mixer_ptr->port_midi_in = jack_port_register(mixer_ptr->jack_client, "midi in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
 725   if (mixer_ptr->port_midi_in == NULL)
 726   {
 727     LOG_ERROR("Cannot create JACK port");
 728     goto close_jack;
 729   }
 730 #endif
 731
 732   mixer_ptr->main_mix_channel.port_left = jack_port_register(mixer_ptr->jack_client, "main out L", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 733   if (mixer_ptr->main_mix_channel.port_left == NULL)
 734   {
 735     LOG_ERROR("Cannot create JACK port");
 736     goto close_jack;
 737   }
 738
 739   mixer_ptr->main_mix_channel.port_right = jack_port_register(mixer_ptr->jack_client, "main out R", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
 740   if (mixer_ptr->main_mix_channel.port_right == NULL)
 741   {
 742     LOG_ERROR("Cannot create JACK port");
 743     goto close_jack;
 744   }
 745
 746   mixer_ptr->main_mix_channel.stereo = true;
 747
 748   mixer_ptr->main_mix_channel.name = "MAIN";
 749
 750   mixer_ptr->main_mix_channel.volume = 0.0;
 751   mixer_ptr->main_mix_channel.balance = 0.0;
 752   mixer_ptr->main_mix_channel.muted = false;
 753   mixer_ptr->main_mix_channel.soloed = false;
 754   mixer_ptr->main_mix_channel.meter_left = 0.0;
 755   mixer_ptr->main_mix_channel.meter_right = 0.0;
 756   mixer_ptr->main_mix_channel.abspeak = 0.0;
 757
 758   mixer_ptr->main_mix_channel.peak_left = 0.0;
 759   mixer_ptr->main_mix_channel.peak_right = 0.0;
 760   mixer_ptr->main_mix_channel.peak_frames = 0;
 761
 762   mixer_ptr->main_mix_channel.NaN_detected = false;
 763   mixer_ptr->main_mix_channel.midi_modified = false;
 764
 765   mixer_ptr->main_mix_channel.midi_scale = NULL;
 766
 767   calc_channel_volumes(&mixer_ptr->main_mix_channel);
 768
 769         ret = jack_set_process_callback(mixer_ptr->jack_client, process, mixer_ptr);
 770   if (ret != 0)
 771   {
 772     LOG_ERROR("Cannot set JACK process callback");
 773     goto close_jack;
 774   }
 775
 776   ret = jack_activate(mixer_ptr->jack_client);
 777   if (ret != 0)
 778   {
 779     LOG_ERROR("Cannot activate JACK client");
 780     goto close_jack;
 781   }
 782
 783   return mixer_ptr;
 784
 785 close_jack:
 786   jack_client_close(mixer_ptr->jack_client); /* this should clear all other resources we obtained through the client handle */
 787
 788 exit_destroy_mutex:
 789   pthread_mutex_destroy(&mixer_ptr->mutex);
 790
 791 exit_free:
 792   free(mixer_ptr);
 793
 794 exit:
 795   return NULL;
 796 }
 797
 798 #define mixer_ctx_ptr ((struct jack_mixer *)mixer)
 799
 800 void
 801 destroy(
 802   jack_mixer_t mixer)
 803 {
 804   LOG_DEBUG("Uninitializing JACK");
 805
 806   assert(mixer_ctx_ptr->jack_client != NULL);
 807
 808   jack_client_close(mixer_ctx_ptr->jack_client);
 809
 810   pthread_mutex_destroy(&mixer_ctx_ptr->mutex);
 811
 812   free(mixer_ctx_ptr);
 813 }
 814
 815 jack_mixer_channel_t
 816 get_main_mix_channel(
 817   jack_mixer_t mixer)
 818 {
 819   return &mixer_ctx_ptr->main_mix_channel;
 820 }
 821
 822 unsigned int
 823 get_channels_count(
 824   jack_mixer_t mixer)
 825 {
 826   return mixer_ctx_ptr->channels_count;
 827 }
 828
 829 jack_mixer_channel_t
 830 add_channel(
 831   jack_mixer_t mixer,
 832   const char * channel_name,
 833   bool stereo)
 834 {
 835   struct channel * channel_ptr;
 836   char * port_name;
 837   size_t channel_name_size;
 838   int i;
 839
 840   channel_ptr = malloc(sizeof(struct channel));
 841   if (channel_ptr == NULL)
 842   {
 843     goto fail;
 844   }
 845
 846   channel_ptr->mixer_ptr = mixer_ctx_ptr;
 847
 848   channel_ptr->name = strdup(channel_name);
 849   if (channel_ptr->name == NULL)
 850   {
 851     goto fail_free_channel;
 852   }
 853
 854   if (stereo)
 855   {
 856     channel_name_size = strlen(channel_name);
 857
 858     port_name = malloc(channel_name_size + 3);
 859     if (port_name == NULL)
 860     {
 861         goto fail_free_channel_name;
 862     }
 863
 864     memcpy(port_name, channel_name, channel_name_size);
 865     port_name[channel_name_size] = ' ';
 866     port_name[channel_name_size+1] = 'L';
 867     port_name[channel_name_size+2] = 0;
 868
 869     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 870     if (channel_ptr->port_left == NULL)
 871     {
 872         goto fail_free_port_name;
 873     }
 874
 875     port_name[channel_name_size+1] = 'R';
 876
 877     channel_ptr->port_right = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 878     if (channel_ptr->port_right == NULL)
 879     {
 880         goto fail_unregister_left_channel;
 881     }
 882   }
 883   else
 884   {
 885     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, channel_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
 886     if (channel_ptr->port_left == NULL)
 887     {
 888         goto fail_free_channel_name;
 889     }
 890   }
 891
 892   channel_ptr->stereo = stereo;
 893
 894   channel_ptr->volume = 0.0;
 895   channel_ptr->balance = 0.0;
 896   channel_ptr->muted = false;
 897   channel_ptr->soloed = false;
 898   channel_ptr->meter_left = -1.0;
 899   channel_ptr->meter_right = -1.0;
 900   channel_ptr->abspeak = 0.0;
 901
 902   channel_ptr->peak_left = 0.0;
 903   channel_ptr->peak_right = 0.0;
 904   channel_ptr->peak_frames = 0;
 905
 906   channel_ptr->NaN_detected = false;
 907   channel_ptr->midi_modified = false;
 908
 909   channel_ptr->midi_scale = NULL;
 910
 911   calc_channel_volumes(channel_ptr);
 912
 913   list_add_tail(&channel_ptr->siblings, &channel_ptr->mixer_ptr->channels_list);
 914   channel_ptr->mixer_ptr->channels_count++;
 915
 916   for (i = 11 ; i < 128 ; i++)
 917   {
 918     if (mixer_ctx_ptr->midi_cc_map[i].channel_ptr == NULL)
 919     {
 920       mixer_ctx_ptr->midi_cc_map[i].channel_ptr = channel_ptr;
 921       mixer_ctx_ptr->midi_cc_map[i].balance = false;
 922       channel_ptr->cc_map_volume_ptr_ptr = &mixer_ctx_ptr->midi_cc_map[i].channel_ptr;
 923
 924       LOG_NOTICE("New channel \"%s\" volume mapped to CC#%i", channel_name, i);
 925
 926       break;
 927     }
 928   }
 929
 930   for (; i < 128 ; i++)
 931   {
 932     if (mixer_ctx_ptr->midi_cc_map[i].channel_ptr == NULL)
 933     {
 934       mixer_ctx_ptr->midi_cc_map[i].channel_ptr = channel_ptr;
 935       mixer_ctx_ptr->midi_cc_map[i].balance = true;
 936       channel_ptr->cc_map_balance_ptr_ptr = &mixer_ctx_ptr->midi_cc_map[i].channel_ptr;
 937
 938       LOG_NOTICE("New channel \"%s\" balance mapped to CC#%i", channel_name, i);
 939
 940       break;
 941     }
 942   }
 943
 944   return channel_ptr;
 945
 946 fail_unregister_left_channel:
 947   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
 948
 949 fail_free_port_name:
 950   free(port_name);
 951
 952 fail_free_channel_name:
 953   free(channel_ptr->name);
 954
 955 fail_free_channel:
 956   free(channel_ptr);
 957   channel_ptr = NULL;
 958
 959 fail:
 960   return NULL;
 961 }