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