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  *   Copyright (C) 2009 Frederic Peters <fpeters@0d.be>
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; version 2 of the License
  12  *
  13  *   This program is distributed in the hope that it will be useful,
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *   GNU General Public License for more details.
  17  *
  18  *   You should have received a copy of the GNU General Public License
  19  *   along with this program; if not, write to the Free Software
  20  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  *****************************************************************************/
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <stdbool.h>
  30 #include <stdint.h>
  31 #include <math.h>
  32 #include <jack/jack.h>
  33 #if defined(HAVE_JACK_MIDI)
  34 #include <jack/midiport.h>
  35 #endif
  36 #include <assert.h>
  37 #include <pthread.h>
  38
  39 #include <glib.h>
  40
  41 #include "jack_mixer.h"
  42 //#define LOG_LEVEL LOG_LEVEL_DEBUG
  43 #include "log.h"
  44
  45 #include "jack_compat.h"
  46
  47 struct kmeter {
  48   float          _z1;          // filter state
  49   float          _z2;          // filter state
  50   float          _rms;         // max rms value since last read()
  51   float          _dpk;         // current digital peak value
  52   int            _cnt;         // digital peak hold counter
  53   bool           _flag;        // flag set by read(), resets _rms
  54
  55   int     _hold;        // number of JACK periods to hold peak value
  56   float   _fall;        // per period fallback multiplier for peak value
  57   float   _omega;       // ballistics filter constant.
  58 };
  59
  60 struct channel {
  61   struct jack_mixer * mixer_ptr;
  62   char * name;
  63   bool stereo;
  64   bool out_mute;
  65   float volume_transition_seconds;
  66   unsigned int num_volume_transition_steps;
  67   float volume;
  68   jack_nframes_t volume_idx;
  69   float volume_new;
  70   float balance;
  71   jack_nframes_t balance_idx;
  72   float balance_new;
  73   float volume_left;
  74   float volume_left_new;
  75   float volume_right;
  76   float volume_right_new;
  77   float meter_left;
  78   float meter_right;
  79   float abspeak;
  80   struct kmeter kmeter_left;
  81   struct kmeter kmeter_right;
  82
  83   jack_port_t * port_left;
  84   jack_port_t * port_right;
  85
  86   jack_nframes_t peak_frames;
  87   float peak_left;
  88   float peak_right;
  89
  90   jack_default_audio_sample_t * tmp_mixed_frames_left;
  91   jack_default_audio_sample_t * tmp_mixed_frames_right;
  92   jack_default_audio_sample_t * frames_left;
  93   jack_default_audio_sample_t * frames_right;
  94   jack_default_audio_sample_t * prefader_frames_left;
  95   jack_default_audio_sample_t * prefader_frames_right;
  96
  97   jack_default_audio_sample_t * left_buffer_ptr;
  98   jack_default_audio_sample_t * right_buffer_ptr;
  99
 100   bool NaN_detected;
 101
 102   int8_t midi_cc_volume_index;
 103   int8_t midi_cc_balance_index;
 104   int8_t midi_cc_mute_index;
 105   int8_t midi_cc_solo_index;
 106   bool midi_cc_volume_picked_up;
 107   bool midi_cc_balance_picked_up;
 108
 109   bool midi_in_got_events;
 110   int midi_out_has_events;
 111   void (*midi_change_callback) (void*);
 112   void *midi_change_callback_data;
 113
 114   jack_mixer_scale_t midi_scale;
 115 };
 116
 117 struct output_channel {
 118   struct channel channel;
 119   GSList *soloed_channels;
 120   GSList *muted_channels;
 121   GSList *prefader_channels;
 122
 123   bool system; /* system channel, without any associated UI */
 124   bool prefader;
 125 };
 126
 127 struct jack_mixer {
 128   pthread_mutex_t mutex;
 129   jack_client_t * jack_client;
 130   GSList *input_channels_list;
 131   GSList *output_channels_list;
 132   GSList *soloed_channels;
 133
 134   jack_port_t * port_midi_in;
 135   jack_port_t * port_midi_out;
 136   int8_t last_midi_cc;
 137   enum midi_behavior_mode midi_behavior;
 138
 139   struct channel* midi_cc_map[128];
 140 };
 141
 142 static jack_mixer_output_channel_t
 143 create_output_channel(
 144   jack_mixer_t mixer,
 145   const char * channel_name,
 146   bool stereo,
 147   bool system);
 148
 149 static inline void
 150 update_channel_buffers(
 151   struct channel * channel_ptr,
 152   jack_nframes_t nframes);
 153
 154 static void
 155 unset_midi_cc_mapping(
 156   struct jack_mixer * mixer,
 157   int8_t cc);
 158
 159 float
 160 value_to_db(
 161   float value)
 162 {
 163   if (value <= 0)
 164   {
 165     return -INFINITY;
 166   }
 167
 168   return 20.0 * log10f(value);
 169 }
 170
 171 float
 172 db_to_value(
 173   float db)
 174 {
 175   return powf(10.0, db / 20.0);
 176 }
 177
 178 double
 179 interpolate(
 180   double start,
 181   double end,
 182   int step,
 183   int steps)
 184 {
 185   double ret;
 186   double frac = 0.01;
 187   LOG_DEBUG("%f -> %f, %d", start, end, step);
 188   if (start <= 0) {
 189     if (step <= frac * steps) {
 190       ret = frac * end * step / steps;
 191     }
 192     else {
 193       ret = db_to_value(value_to_db(frac * end) + (value_to_db(end) - value_to_db(frac * end)) * step / steps);;
 194     }
 195   }
 196   else if (end <= 0) {
 197     if (step >= (1 - frac) * steps) {
 198       ret = frac * start - frac * start * step / steps;
 199     }
 200     else {
 201       ret = db_to_value(value_to_db(start) + (value_to_db(frac * start) - value_to_db(start)) * step / steps);
 202     }
 203   }
 204   else {
 205     ret = db_to_value(value_to_db(start) + (value_to_db(end) - value_to_db(start)) *step /steps);
 206   }
 207   LOG_DEBUG("interpolate: %f", ret);
 208   return ret;
 209 }
 210
 211 #define channel_ptr ((struct channel *)channel)
 212
 213 const char*
 214 channel_get_name(
 215   jack_mixer_channel_t channel)
 216 {
 217   return channel_ptr->name;
 218 }
 219
 220 void
 221 channel_rename(
 222   jack_mixer_channel_t channel,
 223   const char * name)
 224 {
 225   char * new_name;
 226   size_t channel_name_size;
 227   char * port_name;
 228   int ret;
 229
 230   new_name = strdup(name);
 231   if (new_name == NULL)
 232   {
 233     return;
 234   }
 235
 236   if (channel_ptr->name)
 237   {
 238     free(channel_ptr->name);
 239   }
 240
 241   channel_ptr->name = new_name;
 242
 243   if (channel_ptr->stereo)
 244   {
 245     channel_name_size = strlen(name);
 246     port_name = malloc(channel_name_size + 3);
 247     memcpy(port_name, name, channel_name_size);
 248
 249     port_name[channel_name_size] = ' ';
 250     port_name[channel_name_size+1] = 'L';
 251     port_name[channel_name_size+2] = 0;
 252
 253     ret = jack_port_rename(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left, port_name);
 254     if (ret != 0)
 255     {
 256       /* what could we do here? */
 257     }
 258
 259     port_name[channel_name_size+1] = 'R';
 260
 261     ret = jack_port_rename(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_right, port_name);
 262     if (ret != 0)
 263     {
 264       /* what could we do here? */
 265     }
 266
 267     free(port_name);
 268   }
 269   else
 270   {
 271     ret = jack_port_rename(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left, name);
 272     if (ret != 0)
 273     {
 274       /* what could we do here? */
 275     }
 276   }
 277 }
 278
 279 bool
 280 channel_is_stereo(
 281   jack_mixer_channel_t channel)
 282 {
 283   return channel_ptr->stereo;
 284 }
 285
 286 int8_t
 287 channel_get_balance_midi_cc(
 288   jack_mixer_channel_t channel)
 289 {
 290   return channel_ptr->midi_cc_balance_index;
 291 }
 292
 293 /*
 294  * Remove assignment for given MIDI CC
 295  *
 296  * This is an internal (static) function
 297  */
 298 static void
 299 unset_midi_cc_mapping(
 300   struct jack_mixer * mixer,
 301   int8_t cc)
 302 {
 303   struct channel *channel = mixer->midi_cc_map[cc];
 304   if (!channel) {
 305     return;
 306   }
 307
 308   if (channel->midi_cc_volume_index == cc) {
 309     channel->midi_cc_volume_index = -1;
 310   }
 311   else if (channel->midi_cc_balance_index == cc) {
 312     channel->midi_cc_balance_index = -1;
 313   }
 314   else if (channel->midi_cc_mute_index == cc) {
 315     channel->midi_cc_mute_index = -1;
 316   }
 317   else if (channel->midi_cc_solo_index == cc) {
 318     channel->midi_cc_solo_index = -1;
 319   }
 320
 321   mixer->midi_cc_map[cc] = NULL;
 322 }
 323
 324 unsigned int
 325 channel_set_balance_midi_cc(
 326   jack_mixer_channel_t channel,
 327   int8_t new_cc)
 328 {
 329   if (new_cc < 0 || new_cc > 127) {
 330     return 2; /* error: outside limit CC */
 331   }
 332
 333   // remove previous assignment for this CC
 334   unset_midi_cc_mapping(channel_ptr->mixer_ptr, new_cc);
 335   // remove previous balance CC mapped to this channel (if any)
 336   if (channel_ptr->midi_cc_balance_index != -1) {
 337     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
 338   }
 339   channel_ptr->mixer_ptr->midi_cc_map[new_cc] = channel_ptr;
 340   channel_ptr->midi_cc_balance_index = new_cc;
 341   return 0;
 342 }
 343
 344 int8_t
 345 channel_get_volume_midi_cc(
 346   jack_mixer_channel_t channel)
 347 {
 348   return channel_ptr->midi_cc_volume_index;
 349 }
 350
 351 unsigned int
 352 channel_set_volume_midi_cc(
 353   jack_mixer_channel_t channel,
 354   int8_t new_cc)
 355 {
 356   if (new_cc< 0 || new_cc > 127) {
 357     return 2; /* error: outside limit CC */
 358   }
 359
 360   // remove previous assignment for this CC
 361   unset_midi_cc_mapping(channel_ptr->mixer_ptr, new_cc);
 362   // remove previous volume CC mapped to this channel (if any)
 363   if (channel_ptr->midi_cc_volume_index != -1) {
 364     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
 365   }
 366   channel_ptr->mixer_ptr->midi_cc_map[new_cc] = channel_ptr;
 367   channel_ptr->midi_cc_volume_index = new_cc;
 368   return 0;
 369 }
 370
 371 int8_t
 372 channel_get_mute_midi_cc(
 373   jack_mixer_channel_t channel)
 374 {
 375   return channel_ptr->midi_cc_mute_index;
 376 }
 377
 378 unsigned int
 379 channel_set_mute_midi_cc(
 380   jack_mixer_channel_t channel,
 381   int8_t new_cc)
 382 {
 383   if (new_cc < 0 || new_cc > 127) {
 384     return 2; /* error: outside limit CC */
 385   }
 386
 387   // remove previous assignment for this CC
 388   unset_midi_cc_mapping(channel_ptr->mixer_ptr, new_cc);
 389   // remove previous mute CC mapped to this channel (if any)
 390   if (channel_ptr->midi_cc_mute_index != -1) {
 391     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_mute_index] = NULL;
 392   }
 393   channel_ptr->mixer_ptr->midi_cc_map[new_cc] = channel_ptr;
 394   channel_ptr->midi_cc_mute_index = new_cc;
 395   return 0;
 396 }
 397
 398 int8_t
 399 channel_get_solo_midi_cc(
 400   jack_mixer_channel_t channel)
 401 {
 402   return channel_ptr->midi_cc_solo_index;
 403 }
 404
 405 void
 406 channel_set_midi_cc_volume_picked_up(
 407   jack_mixer_channel_t channel,
 408   bool status)
 409 {
 410   LOG_DEBUG("Setting channel %s volume picked up to %d", channel_ptr->name, status);
 411   channel_ptr->midi_cc_volume_picked_up = status;
 412 }
 413
 414 void
 415 channel_set_midi_cc_balance_picked_up(
 416   jack_mixer_channel_t channel,
 417   bool status)
 418 {
 419   LOG_DEBUG("Setting channel %s balance picked up to %d", channel_ptr->name, status);
 420   channel_ptr->midi_cc_balance_picked_up = status;
 421 }
 422
 423 unsigned int
 424 channel_set_solo_midi_cc(
 425   jack_mixer_channel_t channel,
 426   int8_t new_cc)
 427 {
 428   if (new_cc < 0 || new_cc > 127) {
 429     return 2; /* error: outside limit CC */
 430   }
 431
 432   // remove previous assignment for this CC
 433   unset_midi_cc_mapping(channel_ptr->mixer_ptr, new_cc);
 434   // remove previous solo CC mapped to this channel (if any)
 435   if (channel_ptr->midi_cc_solo_index != -1) {
 436     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_solo_index] = NULL;
 437   }
 438   channel_ptr->mixer_ptr->midi_cc_map[new_cc] = channel_ptr;
 439   channel_ptr->midi_cc_solo_index = new_cc;
 440   return 0;
 441 }
 442
 443 int
 444 channel_autoset_volume_midi_cc(
 445   jack_mixer_channel_t channel)
 446 {
 447   struct jack_mixer *mixer_ptr = channel_ptr->mixer_ptr;
 448
 449   for (int i = 11 ; i < 128 ; i++)
 450   {
 451     if (!mixer_ptr->midi_cc_map[i])
 452     {
 453       mixer_ptr->midi_cc_map[i] = channel_ptr;
 454       channel_ptr->midi_cc_volume_index = i;
 455
 456       LOG_DEBUG("New channel \"%s\" volume mapped to CC#%i", channel_ptr->name, i);
 457
 458       return i;
 459     }
 460   }
 461   return -1;
 462 }
 463
 464 int
 465 channel_autoset_balance_midi_cc(
 466   jack_mixer_channel_t channel)
 467 {
 468   struct jack_mixer *mixer_ptr = channel_ptr->mixer_ptr;
 469
 470   for (int i = 11; i < 128 ; i++)
 471   {
 472     if (!mixer_ptr->midi_cc_map[i])
 473     {
 474       mixer_ptr->midi_cc_map[i] = channel_ptr;
 475       channel_ptr->midi_cc_balance_index = i;
 476
 477       LOG_DEBUG("New channel \"%s\" balance mapped to CC#%i", channel_ptr->name, i);
 478
 479       return i;
 480     }
 481   }
 482   return -1;
 483 }
 484
 485 int
 486 channel_autoset_mute_midi_cc(
 487   jack_mixer_channel_t channel)
 488 {
 489   struct jack_mixer *mixer_ptr = channel_ptr->mixer_ptr;
 490
 491   for (int i = 11; i < 128 ; i++)
 492   {
 493     if (!mixer_ptr->midi_cc_map[i])
 494     {
 495       mixer_ptr->midi_cc_map[i] = channel_ptr;
 496       channel_ptr->midi_cc_mute_index = i;
 497
 498       LOG_DEBUG("New channel \"%s\" mute mapped to CC#%i", channel_ptr->name, i);
 499
 500       return i;
 501     }
 502   }
 503   return -1;
 504 }
 505
 506 int
 507 channel_autoset_solo_midi_cc(
 508   jack_mixer_channel_t channel)
 509 {
 510   struct jack_mixer *mixer_ptr = channel_ptr->mixer_ptr;
 511
 512   for (int i = 11; i < 128 ; i++)
 513   {
 514     if (!mixer_ptr->midi_cc_map[i])
 515     {
 516       mixer_ptr->midi_cc_map[i] = channel_ptr;
 517       channel_ptr->midi_cc_solo_index = i;
 518
 519       LOG_DEBUG("New channel \"%s\" solo mapped to CC#%i", channel_ptr->name, i);
 520
 521       return i;
 522     }
 523   }
 524   return -1;
 525 }
 526
 527 void
 528 remove_channel(
 529   jack_mixer_channel_t channel)
 530 {
 531   GSList *list_ptr;
 532   channel_ptr->mixer_ptr->input_channels_list = g_slist_remove(
 533                   channel_ptr->mixer_ptr->input_channels_list, channel_ptr);
 534   free(channel_ptr->name);
 535
 536   /* remove references to input channel from all output channels */
 537   for (list_ptr = channel_ptr->mixer_ptr->output_channels_list; list_ptr; list_ptr = g_slist_next(list_ptr))
 538   {
 539     struct output_channel *output_channel_ptr = list_ptr->data;
 540     output_channel_set_solo(output_channel_ptr, channel, false);
 541     output_channel_set_muted(output_channel_ptr, channel, false);
 542   }
 543
 544   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
 545   if (channel_ptr->stereo)
 546   {
 547     jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_right);
 548   }
 549
 550   if (channel_ptr->midi_cc_volume_index != -1)
 551   {
 552     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] == channel_ptr);
 553     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
 554   }
 555
 556   if (channel_ptr->midi_cc_balance_index != -1)
 557   {
 558     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] == channel_ptr);
 559     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
 560   }
 561
 562   if (channel_ptr->midi_cc_mute_index != -1)
 563   {
 564     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_mute_index] == channel_ptr);
 565     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_mute_index] = NULL;
 566   }
 567   if (channel_ptr->midi_cc_solo_index != -1)
 568   {
 569     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_solo_index] == channel_ptr);
 570     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_solo_index] = NULL;
 571   }
 572
 573   free(channel_ptr->frames_left);
 574   free(channel_ptr->frames_right);
 575   free(channel_ptr->prefader_frames_left);
 576   free(channel_ptr->prefader_frames_right);
 577
 578   free(channel_ptr);
 579 }
 580
 581 void
 582 channel_stereo_meter_read(
 583   jack_mixer_channel_t channel,
 584   double * left_ptr,
 585   double * right_ptr)
 586 {
 587   assert(channel_ptr);
 588   *left_ptr = value_to_db(channel_ptr->meter_left);
 589   *right_ptr = value_to_db(channel_ptr->meter_right);
 590 }
 591
 592
 593 void
 594 channel_mono_meter_read(
 595   jack_mixer_channel_t channel,
 596   double * mono_ptr)
 597 {
 598   *mono_ptr = value_to_db(channel_ptr->meter_left);
 599 }
 600
 601 void
 602 channel_stereo_kmeter_read(
 603   jack_mixer_channel_t channel,
 604   double * left_ptr,
 605   double * right_ptr,
 606   double * left_rms_ptr,
 607   double * right_rms_ptr)
 608 {
 609   assert(channel_ptr);
 610   *left_ptr = value_to_db(channel_ptr->kmeter_left._dpk);
 611   *right_ptr = value_to_db(channel_ptr->kmeter_right._dpk);
 612   *left_rms_ptr = value_to_db(channel_ptr->kmeter_left._rms);
 613   *right_rms_ptr = value_to_db(channel_ptr->kmeter_right._rms);
 614   channel_ptr->kmeter_left._flag = true;
 615   channel_ptr->kmeter_right._flag = true;
 616 }
 617
 618 void
 619 channel_mono_kmeter_read(
 620   jack_mixer_channel_t channel,
 621   double * mono_ptr,
 622   double * mono_rms_ptr)
 623 {
 624   *mono_ptr = value_to_db(channel_ptr->kmeter_left._dpk);
 625   *mono_rms_ptr = value_to_db(channel_ptr->kmeter_left._rms);
 626   channel_ptr->kmeter_left._flag = true;
 627 }
 628
 629 void
 630 channel_volume_write(
 631   jack_mixer_channel_t channel,
 632   double volume)
 633 {
 634   assert(channel_ptr);
 635   double value = db_to_value(volume);
 636   /*If changing volume and find we're in the middle of a previous transition,
 637    *then set current volume to place in transition to avoid a jump.*/
 638   if (channel_ptr->volume_new != channel_ptr->volume) {
 639     channel_ptr->volume = interpolate(channel_ptr->volume,
 640                                       channel_ptr->volume_new,
 641                                       channel_ptr->volume_idx,
 642                                       channel_ptr->num_volume_transition_steps);
 643   }
 644   channel_ptr->volume_idx = 0;
 645   if (channel_ptr->volume_new != value) {
 646     channel_ptr->midi_out_has_events |= CHANNEL_VOLUME;
 647   }
 648   channel_ptr->volume_new = value;
 649   LOG_DEBUG("\"%s\" volume -> %f", channel_ptr->name, value);
 650 }
 651
 652 double
 653 channel_volume_read(
 654   jack_mixer_channel_t channel)
 655 {
 656   assert(channel_ptr);
 657   return value_to_db(channel_ptr->volume_new);
 658 }
 659
 660 void
 661 channels_volumes_read(
 662   jack_mixer_t mixer_ptr)
 663 {
 664     GSList *node_ptr;
 665     struct channel *pChannel;
 666     struct jack_mixer * pMixer = (struct jack_mixer *)mixer_ptr;
 667
 668     for (node_ptr = pMixer->input_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 669     {
 670         pChannel = (struct channel *)node_ptr->data;
 671         double vol = channel_volume_read( (jack_mixer_channel_t)pChannel);
 672         printf("%s : volume is %f dbFS for mixer channel: %s\n", jack_get_client_name(pMixer->jack_client), vol, pChannel->name);
 673     }
 674 }
 675
 676 void
 677 channel_balance_write(
 678   jack_mixer_channel_t channel,
 679   double balance)
 680 {
 681   assert(channel_ptr);
 682   if (channel_ptr->balance != channel_ptr->balance_new) {
 683     channel_ptr->balance = channel_ptr->balance + channel_ptr->balance_idx *
 684       (channel_ptr->balance_new - channel_ptr->balance) /
 685       channel_ptr->num_volume_transition_steps;
 686   }
 687   channel_ptr->balance_idx = 0;
 688   if (channel_ptr->balance_new != balance) {
 689     channel_ptr->midi_out_has_events |= CHANNEL_BALANCE;
 690   }
 691   channel_ptr->balance_new = balance;
 692   LOG_DEBUG("\"%s\" balance -> %f", channel_ptr->name, balance);
 693 }
 694
 695 double
 696 channel_balance_read(
 697   jack_mixer_channel_t channel)
 698 {
 699   assert(channel_ptr);
 700   return channel_ptr->balance_new;
 701 }
 702
 703 double
 704 channel_abspeak_read(
 705   jack_mixer_channel_t channel)
 706 {
 707   assert(channel_ptr);
 708   if (channel_ptr->NaN_detected)
 709   {
 710     return sqrt(-1);
 711   }
 712   else
 713   {
 714     return value_to_db(channel_ptr->abspeak);
 715   }
 716 }
 717
 718 void
 719 channel_abspeak_reset(
 720   jack_mixer_channel_t channel)
 721 {
 722   channel_ptr->abspeak = 0;
 723   channel_ptr->NaN_detected = false;
 724 }
 725
 726 void
 727 channel_out_mute(
 728   jack_mixer_channel_t channel)
 729 {
 730   if (!channel_ptr->out_mute) {
 731     channel_ptr->out_mute = true;
 732     channel_ptr->midi_out_has_events |= CHANNEL_MUTE;
 733     LOG_DEBUG("\"%s\" muted", channel_ptr->name);
 734   }
 735 }
 736
 737 void
 738 channel_out_unmute(
 739   jack_mixer_channel_t channel)
 740 {
 741   if (channel_ptr->out_mute) {
 742     channel_ptr->out_mute = false;
 743     channel_ptr->midi_out_has_events |= CHANNEL_MUTE;
 744     LOG_DEBUG("\"%s\" un-muted", channel_ptr->name);
 745   }
 746 }
 747
 748 bool
 749 channel_is_out_muted(
 750   jack_mixer_channel_t channel)
 751 {
 752   return channel_ptr->out_mute;
 753 }
 754
 755 void
 756 channel_solo(
 757   jack_mixer_channel_t channel)
 758 {
 759   if (g_slist_find(channel_ptr->mixer_ptr->soloed_channels, channel) != NULL)
 760     return;
 761   channel_ptr->mixer_ptr->soloed_channels = g_slist_prepend(channel_ptr->mixer_ptr->soloed_channels, channel);
 762   channel_ptr->midi_out_has_events |= CHANNEL_SOLO;
 763   LOG_DEBUG("\"%s\" soloed", channel_ptr->name);
 764 }
 765
 766 void
 767 channel_unsolo(
 768   jack_mixer_channel_t channel)
 769 {
 770   if (g_slist_find(channel_ptr->mixer_ptr->soloed_channels, channel) == NULL)
 771     return;
 772   channel_ptr->mixer_ptr->soloed_channels = g_slist_remove(channel_ptr->mixer_ptr->soloed_channels, channel);
 773   channel_ptr->midi_out_has_events |= CHANNEL_SOLO;
 774   LOG_DEBUG("\"%s\" un-soloed", channel_ptr->name);
 775 }
 776
 777 bool
 778 channel_is_soloed(
 779   jack_mixer_channel_t channel)
 780 {
 781   if (g_slist_find(channel_ptr->mixer_ptr->soloed_channels, channel))
 782     return true;
 783   return false;
 784 }
 785
 786 void
 787 channel_set_midi_scale(
 788   jack_mixer_channel_t channel,
 789   jack_mixer_scale_t scale)
 790 {
 791   channel_ptr->midi_scale = scale;
 792 }
 793
 794 void
 795 channel_set_midi_change_callback(
 796   jack_mixer_channel_t channel,
 797   void (*midi_change_callback) (void*),
 798   void *user_data)
 799 {
 800   channel_ptr->midi_change_callback = midi_change_callback;
 801   channel_ptr->midi_change_callback_data = user_data;
 802 }
 803
 804 bool
 805 channel_get_midi_in_got_events(
 806   jack_mixer_channel_t channel)
 807 {
 808   bool t = channel_ptr->midi_in_got_events;
 809   channel_ptr->midi_in_got_events = false;
 810   return t;
 811 }
 812
 813 #undef channel_ptr
 814
 815 /* process input channels and mix them into main mix */
 816 static inline void
 817 mix_one(
 818   struct output_channel *output_mix_channel,
 819   GSList *channels_list,
 820   jack_nframes_t start,         /* index of first sample to process */
 821   jack_nframes_t end)           /* index of sample to stop processing before */
 822 {
 823   jack_nframes_t i;
 824
 825   GSList *node_ptr;
 826   struct channel * channel_ptr;
 827   jack_default_audio_sample_t frame_left;
 828   jack_default_audio_sample_t frame_right;
 829   struct channel *mix_channel = (struct channel*)output_mix_channel;
 830
 831   for (i = start; i < end; i++)
 832   {
 833     mix_channel->left_buffer_ptr[i] = mix_channel->tmp_mixed_frames_left[i] = 0.0;
 834     if (mix_channel->stereo)
 835       mix_channel->right_buffer_ptr[i] = mix_channel->tmp_mixed_frames_right[i] = 0.0;
 836   }
 837
 838   for (node_ptr = channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 839   {
 840     channel_ptr = node_ptr->data;
 841
 842     if (g_slist_find(output_mix_channel->muted_channels, channel_ptr) != NULL || channel_ptr->out_mute) {
 843       /* skip muted channels */
 844       continue;
 845     }
 846
 847     if ((!channel_ptr->mixer_ptr->soloed_channels && !output_mix_channel->soloed_channels) ||
 848         (channel_ptr->mixer_ptr->soloed_channels &&
 849          g_slist_find(channel_ptr->mixer_ptr->soloed_channels, channel_ptr) != NULL) ||
 850         (output_mix_channel->soloed_channels &&
 851         g_slist_find(output_mix_channel->soloed_channels, channel_ptr) != NULL)) {
 852
 853       for (i = start ; i < end ; i++)
 854       {
 855         if (! output_mix_channel->prefader &&
 856             g_slist_find(output_mix_channel->prefader_channels, channel_ptr) == NULL)
 857         {
 858           frame_left = channel_ptr->frames_left[i-start];
 859         }
 860         else {
 861           frame_left = channel_ptr->prefader_frames_left[i-start];
 862         }
 863         if (frame_left == NAN)
 864           break;
 865         mix_channel->tmp_mixed_frames_left[i] += frame_left;
 866         if (mix_channel->stereo)
 867         {
 868           if (! output_mix_channel->prefader &&
 869               g_slist_find(output_mix_channel->prefader_channels, channel_ptr) == NULL)
 870           {
 871             frame_right = channel_ptr->frames_right[i-start];
 872           }
 873           else {
 874             frame_right = channel_ptr->prefader_frames_right[i-start];
 875           }
 876           if (frame_right == NAN)
 877             break;
 878           mix_channel->tmp_mixed_frames_right[i] += frame_right;
 879         }
 880       }
 881     }
 882   }
 883
 884   /* process main mix channel */
 885   unsigned int steps = mix_channel->num_volume_transition_steps;
 886
 887   for (i = start ; i < end ; i++)
 888   {
 889     if (! output_mix_channel->prefader) {
 890       float volume = mix_channel->volume;
 891       float volume_new = mix_channel->volume_new;
 892       float vol = volume;
 893       float balance = mix_channel->balance;
 894       float balance_new = mix_channel->balance_new;
 895       float bal = balance;
 896       if (volume != volume_new) {
 897         vol = interpolate(volume, volume_new, mix_channel->volume_idx, steps);
 898       }
 899       if (balance != balance_new) {
 900         bal = mix_channel->balance_idx * (balance_new - balance) / steps + balance;
 901       }
 902
 903       float vol_l;
 904       float vol_r;
 905       if (mix_channel->stereo) {
 906         if (bal > 0) {
 907           vol_l = vol * (1 - bal);
 908           vol_r = vol;
 909         }
 910         else {
 911           vol_l = vol;
 912           vol_r = vol * (1 + bal);
 913         }
 914       }
 915       else {
 916         vol_l = vol * (1 - bal);
 917         vol_r = vol * (1 + bal);
 918       }
 919       mix_channel->tmp_mixed_frames_left[i] *= vol_l;
 920       mix_channel->tmp_mixed_frames_right[i] *= vol_r;
 921     }
 922
 923     frame_left = fabsf(mix_channel->tmp_mixed_frames_left[i]);
 924     if (mix_channel->peak_left < frame_left)
 925     {
 926       mix_channel->peak_left = frame_left;
 927
 928       if (frame_left > mix_channel->abspeak)
 929       {
 930         mix_channel->abspeak = frame_left;
 931       }
 932     }
 933
 934     if (mix_channel->stereo)
 935     {
 936       frame_right = fabsf(mix_channel->tmp_mixed_frames_right[i]);
 937       if (mix_channel->peak_right < frame_right)
 938       {
 939         mix_channel->peak_right = frame_right;
 940
 941         if (frame_right > mix_channel->abspeak)
 942         {
 943           mix_channel->abspeak = frame_right;
 944         }
 945       }
 946     }
 947
 948     if (mix_channel->stereo)
 949     {
 950       frame_left = fabsf(mix_channel->tmp_mixed_frames_left[i]);
 951       frame_right = fabsf(mix_channel->tmp_mixed_frames_right[i]);
 952
 953       if (mix_channel->peak_left < frame_left)
 954       {
 955         mix_channel->peak_left = frame_left;
 956
 957         if (frame_left > mix_channel->abspeak)
 958         {
 959           mix_channel->abspeak = frame_left;
 960         }
 961       }
 962
 963       if (mix_channel->peak_right < frame_right)
 964       {
 965         mix_channel->peak_right = frame_right;
 966
 967         if (frame_right > mix_channel->abspeak)
 968         {
 969           mix_channel->abspeak = frame_right;
 970         }
 971       }
 972     }
 973     else
 974     {
 975       if (mix_channel->peak_left < frame_left)
 976       {
 977         mix_channel->peak_left = frame_left;
 978
 979         if (frame_left > mix_channel->abspeak)
 980         {
 981           mix_channel->abspeak = frame_left;
 982         }
 983       }
 984     }
 985
 986     mix_channel->peak_frames++;
 987     if (mix_channel->peak_frames >= PEAK_FRAMES_CHUNK)
 988     {
 989       mix_channel->meter_left = mix_channel->peak_left;
 990       mix_channel->peak_left = 0.0;
 991
 992       if (mix_channel->stereo)
 993       {
 994         mix_channel->meter_right = mix_channel->peak_right;
 995         mix_channel->peak_right = 0.0;
 996       }
 997
 998       mix_channel->peak_frames = 0;
 999     }
1000     mix_channel->volume_idx++;
1001     if ((mix_channel->volume != mix_channel->volume_new) && (mix_channel->volume_idx == steps)) {
1002       mix_channel->volume = mix_channel->volume_new;
1003       mix_channel->volume_idx = 0;
1004     }
1005     mix_channel->balance_idx++;
1006     if ((mix_channel->balance != mix_channel->balance_new) && (mix_channel->balance_idx == steps)) {
1007       mix_channel->balance = mix_channel->balance_new;
1008       mix_channel->balance_idx = 0;
1009     }
1010
1011     if (!mix_channel->out_mute) {
1012         mix_channel->left_buffer_ptr[i] = mix_channel->tmp_mixed_frames_left[i];
1013         if (mix_channel->stereo)
1014           mix_channel->right_buffer_ptr[i] = mix_channel->tmp_mixed_frames_right[i];
1015     }
1016   }
1017   kmeter_process(&mix_channel->kmeter_left, mix_channel->tmp_mixed_frames_left, start, end);
1018   kmeter_process(&mix_channel->kmeter_right, mix_channel->tmp_mixed_frames_right, start, end);
1019 }
1020
1021 static inline void
1022 calc_channel_frames(
1023   struct channel *channel_ptr,
1024   jack_nframes_t start,
1025   jack_nframes_t end)
1026 {
1027   jack_nframes_t i;
1028   jack_default_audio_sample_t frame_left = 0.0f;
1029   jack_default_audio_sample_t frame_right = 0.0f;
1030   unsigned int steps = channel_ptr->num_volume_transition_steps;
1031
1032   for (i = start ; i < end ; i++)
1033   {
1034     if (i-start >= MAX_BLOCK_SIZE)
1035     {
1036       fprintf(stderr, "i-start too high: %d - %d\n", i, start);
1037     }
1038     channel_ptr->prefader_frames_left[i-start] = channel_ptr->left_buffer_ptr[i];
1039     if (channel_ptr->stereo)
1040       channel_ptr->prefader_frames_right[i-start] = channel_ptr->right_buffer_ptr[i];
1041
1042     if (!FLOAT_EXISTS(channel_ptr->left_buffer_ptr[i]))
1043     {
1044       channel_ptr->NaN_detected = true;
1045       channel_ptr->frames_left[i-start] = NAN;
1046       break;
1047     }
1048     float volume = channel_ptr->volume;
1049     float volume_new = channel_ptr->volume_new;
1050     float vol = volume;
1051     float balance = channel_ptr->balance;
1052     float balance_new = channel_ptr->balance_new;
1053     float bal = balance;
1054     if (channel_ptr->volume != channel_ptr->volume_new) {
1055       vol = interpolate(volume, volume_new, channel_ptr->volume_idx, steps);
1056     }
1057     if (channel_ptr->balance != channel_ptr->balance_new) {
1058       bal = channel_ptr->balance_idx * (balance_new - balance) / steps + balance;
1059     }
1060     float vol_l;
1061     float vol_r;
1062     if (channel_ptr->stereo) {
1063       if (bal > 0) {
1064         vol_l = vol * (1 - bal);
1065         vol_r = vol;
1066       }
1067       else {
1068         vol_l = vol;
1069         vol_r = vol * (1 + bal);
1070       }
1071     }
1072     else {
1073       vol_l = vol * (1 - bal);
1074       vol_r = vol * (1 + bal);
1075     }
1076     frame_left = channel_ptr->left_buffer_ptr[i] * vol_l;
1077     if (channel_ptr->stereo)
1078     {
1079       if (!FLOAT_EXISTS(channel_ptr->right_buffer_ptr[i]))
1080       {
1081         channel_ptr->NaN_detected = true;
1082         channel_ptr->frames_right[i-start] = NAN;
1083         break;
1084       }
1085
1086       frame_right = channel_ptr->right_buffer_ptr[i] * vol_r;
1087     }
1088     else
1089     {
1090       frame_right = channel_ptr->left_buffer_ptr[i] * vol_r;
1091     }
1092     channel_ptr->frames_left[i-start] = frame_left;
1093     channel_ptr->frames_right[i-start] = frame_right;
1094
1095     if (channel_ptr->stereo)
1096     {
1097       frame_left = fabsf(frame_left);
1098       frame_right = fabsf(frame_right);
1099
1100       if (channel_ptr->peak_left < frame_left)
1101       {
1102         channel_ptr->peak_left = frame_left;
1103
1104         if (frame_left > channel_ptr->abspeak)
1105         {
1106           channel_ptr->abspeak = frame_left;
1107         }
1108       }
1109
1110       if (channel_ptr->peak_right < frame_right)
1111       {
1112         channel_ptr->peak_right = frame_right;
1113
1114         if (frame_right > channel_ptr->abspeak)
1115         {
1116           channel_ptr->abspeak = frame_right;
1117         }
1118       }
1119     }
1120     else
1121     {
1122
1123       frame_left = (fabsf(frame_left) + fabsf(frame_right)) / 2;
1124
1125       if (channel_ptr->peak_left < frame_left)
1126       {
1127         channel_ptr->peak_left = frame_left;
1128
1129         if (frame_left > channel_ptr->abspeak)
1130         {
1131           channel_ptr->abspeak = frame_left;
1132         }
1133       }
1134     }
1135
1136     channel_ptr->peak_frames++;
1137     if (channel_ptr->peak_frames >= PEAK_FRAMES_CHUNK)
1138     {
1139       channel_ptr->meter_left = channel_ptr->peak_left;
1140       channel_ptr->peak_left = 0.0;
1141
1142       if (channel_ptr->stereo)
1143       {
1144         channel_ptr->meter_right = channel_ptr->peak_right;
1145         channel_ptr->peak_right = 0.0;
1146       }
1147
1148       channel_ptr->peak_frames = 0;
1149     }
1150
1151     channel_ptr->volume_idx++;
1152     if ((channel_ptr->volume != channel_ptr->volume_new) &&
1153      (channel_ptr->volume_idx == steps)) {
1154       channel_ptr->volume = channel_ptr->volume_new;
1155       channel_ptr->volume_idx = 0;
1156     }
1157     channel_ptr->balance_idx++;
1158     if ((channel_ptr->balance != channel_ptr->balance_new) &&
1159      (channel_ptr->balance_idx >= steps)) {
1160       channel_ptr->balance = channel_ptr->balance_new;
1161       channel_ptr->balance_idx = 0;
1162     }
1163   }
1164
1165   kmeter_process(&channel_ptr->kmeter_left, channel_ptr->frames_left, start, end);
1166   if (channel_ptr->stereo) kmeter_process(&channel_ptr->kmeter_right, channel_ptr->frames_right, start, end);
1167
1168 }
1169
1170 static inline void
1171 mix(
1172   struct jack_mixer * mixer_ptr,
1173   jack_nframes_t start,         /* index of first sample to process */
1174   jack_nframes_t end)           /* index of sample to stop processing before */
1175 {
1176   GSList *node_ptr;
1177   struct output_channel * output_channel_ptr;
1178   struct channel *channel_ptr;
1179
1180   for (node_ptr = mixer_ptr->input_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
1181   {
1182     channel_ptr = (struct channel*)node_ptr->data;
1183     calc_channel_frames(channel_ptr, start, end);
1184   }
1185
1186   for (node_ptr = mixer_ptr->output_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
1187   {
1188     output_channel_ptr = node_ptr->data;
1189     channel_ptr = (struct channel*)output_channel_ptr;
1190
1191     if (output_channel_ptr->system)
1192     {
1193       /* Don't bother mixing the channels if we are not connected */
1194       if (channel_ptr->stereo)
1195       {
1196         if (jack_port_connected(channel_ptr->port_left) == 0 &&
1197             jack_port_connected(channel_ptr->port_right) == 0)
1198           continue;
1199       }
1200       else {
1201         if (jack_port_connected(channel_ptr->port_left) == 0)
1202           continue;
1203       }
1204     }
1205
1206     mix_one(output_channel_ptr, mixer_ptr->input_channels_list, start, end);
1207   }
1208 }
1209
1210 static inline void
1211 update_channel_buffers(
1212   struct channel * channel_ptr,
1213   jack_nframes_t nframes)
1214 {
1215   channel_ptr->left_buffer_ptr = jack_port_get_buffer(channel_ptr->port_left, nframes);
1216
1217   if (channel_ptr->stereo)
1218   {
1219     channel_ptr->right_buffer_ptr = jack_port_get_buffer(channel_ptr->port_right, nframes);
1220   }
1221 }
1222
1223 #define mixer_ptr ((struct jack_mixer *)context)
1224
1225 static int
1226 process(
1227   jack_nframes_t nframes,
1228   void * context)
1229 {
1230   GSList *node_ptr;
1231   struct channel * channel_ptr;
1232 #if defined(HAVE_JACK_MIDI)
1233   jack_nframes_t i;
1234   jack_nframes_t event_count;
1235   jack_midi_event_t in_event;
1236   unsigned char* midi_out_buffer;
1237   void * midi_buffer;
1238   double volume, balance;
1239   uint8_t cc_channel_index;
1240   uint8_t cc_num, cc_val, cur_cc_val;
1241 #endif
1242
1243   for (node_ptr = mixer_ptr->input_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
1244   {
1245     channel_ptr = node_ptr->data;
1246     update_channel_buffers(channel_ptr, nframes);
1247   }
1248
1249   // Fill output buffers with the input
1250   for (node_ptr = mixer_ptr->output_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
1251   {
1252     channel_ptr = node_ptr->data;
1253     update_channel_buffers(channel_ptr, nframes);
1254   }
1255
1256 #if defined(HAVE_JACK_MIDI)
1257   midi_buffer = jack_port_get_buffer(mixer_ptr->port_midi_in, nframes);
1258   event_count = jack_midi_get_event_count(midi_buffer);
1259
1260   for (i = 0 ; i < event_count; i++)
1261   {
1262     jack_midi_event_get(&in_event, midi_buffer, i);
1263
1264     if (in_event.size != 3 ||
1265         (in_event.buffer[0] & 0xF0) != 0xB0 ||
1266         in_event.buffer[1] > 127 ||
1267         in_event.buffer[2] > 127)
1268     {
1269       continue;
1270     }
1271
1272     assert(in_event.time < nframes);
1273
1274     cc_num = (uint8_t)(in_event.buffer[1] & 0x7F);
1275     cc_val = (uint8_t)(in_event.buffer[2] & 0x7F);
1276     mixer_ptr->last_midi_cc = (int8_t)cc_num;
1277
1278     LOG_DEBUG("%u: CC#%u -> %u", (unsigned int)(in_event.buffer[0]), cc_num, cc_val);
1279
1280     /* do we have a mapping for particular CC? */
1281     channel_ptr = mixer_ptr->midi_cc_map[cc_num];
1282     if (channel_ptr)
1283     {
1284       if (channel_ptr->midi_cc_balance_index == cc_num)
1285       {
1286         if (cc_val < 63) {
1287           balance = MAP(cc_val, 0.0, 63.0, -1.0, -0.015625);
1288         }
1289         else {
1290           balance = MAP(cc_val, 64.0, 127.0, 0.0, 1.0);
1291         }
1292         if (mixer_ptr->midi_behavior == Pick_Up &&
1293             !channel_ptr->midi_cc_balance_picked_up &&
1294             channel_balance_read(channel_ptr) - balance < BALANCE_PICKUP_THRESHOLD)
1295         {
1296           channel_set_midi_cc_balance_picked_up(channel_ptr, true);
1297         }
1298         if ((mixer_ptr->midi_behavior == Pick_Up &&
1299             channel_ptr->midi_cc_balance_picked_up) ||
1300             mixer_ptr->midi_behavior == Jump_To_Value)
1301         {
1302           channel_balance_write(channel_ptr, balance);
1303
1304         }
1305       }
1306       else if (channel_ptr->midi_cc_volume_index == cc_num)
1307       {
1308         // Is a MIDI scale set for corresponding channel?
1309         if (channel_ptr->midi_scale) {
1310           volume = scale_scale_to_db(channel_ptr->midi_scale,
1311                                      (double)cc_val / 127);
1312           if (mixer_ptr->midi_behavior == Pick_Up &&
1313               !channel_ptr->midi_cc_volume_picked_up)
1314           {
1315               // MIDI control in pick-up mode but not picked up yet
1316               cur_cc_val = (uint8_t)(127 * scale_db_to_scale(
1317                 channel_ptr->midi_scale,
1318                 value_to_db(channel_ptr->volume)));
1319               if (cc_val == cur_cc_val)
1320               {
1321                 // Incoming MIDI CC value matches current volume level
1322                 // --> MIDI control is picked up
1323                 channel_set_midi_cc_volume_picked_up(channel_ptr, true);
1324               }
1325           }
1326           if ((mixer_ptr->midi_behavior == Pick_Up &&
1327               channel_ptr->midi_cc_volume_picked_up) ||
1328               mixer_ptr->midi_behavior == Jump_To_Value)
1329           {
1330             channel_volume_write(channel_ptr, volume);
1331           }
1332         }
1333       }
1334       else if (channel_ptr->midi_cc_mute_index == cc_num)
1335       {
1336         if (cc_val >= 64) {
1337           channel_out_mute(channel_ptr);
1338         }
1339         else {
1340           channel_out_unmute(channel_ptr);
1341         }
1342
1343       }
1344       else if (channel_ptr->midi_cc_solo_index == cc_num)
1345       {
1346         if (cc_val >= 64) {
1347             channel_solo(channel_ptr);
1348         }
1349         else {
1350             channel_unsolo(channel_ptr);
1351         }
1352       }
1353       channel_ptr->midi_in_got_events = true;
1354       if (channel_ptr->midi_change_callback) {
1355         channel_ptr->midi_change_callback(channel_ptr->midi_change_callback_data);
1356       }
1357     }
1358
1359   }
1360
1361   midi_buffer = jack_port_get_buffer(mixer_ptr->port_midi_out, nframes);
1362   jack_midi_clear_buffer(midi_buffer);
1363
1364   for(i=0; i<nframes; i++)
1365   {
1366     for (cc_channel_index=0; cc_channel_index<128; cc_channel_index++)
1367     {
1368       channel_ptr = mixer_ptr->midi_cc_map[cc_channel_index];
1369       if (!channel_ptr)
1370       {
1371         continue;
1372       }
1373       if (!channel_ptr->midi_out_has_events)
1374       {
1375         continue;
1376       }
1377       if (channel_ptr->midi_out_has_events & CHANNEL_VOLUME && channel_ptr->midi_scale)
1378       {
1379           midi_out_buffer = jack_midi_event_reserve(midi_buffer, 0, 3);
1380           if (!midi_out_buffer)
1381             continue;
1382
1383           midi_out_buffer[0] = 0xB0; /* control change */
1384           midi_out_buffer[1] = channel_ptr->midi_cc_volume_index;
1385           midi_out_buffer[2] = (unsigned char)(127 * scale_db_to_scale(channel_ptr->midi_scale,
1386                                                value_to_db(channel_ptr->volume_new)));
1387
1388           LOG_DEBUG(
1389             "%u: CC#%u <- %u",
1390             (unsigned int)midi_out_buffer[0],
1391             (unsigned int)midi_out_buffer[1],
1392             (unsigned int)midi_out_buffer[2]);
1393       }
1394       if (channel_ptr->midi_out_has_events & CHANNEL_BALANCE)
1395       {
1396           midi_out_buffer = jack_midi_event_reserve(midi_buffer, 0, 3);
1397           if (!midi_out_buffer)
1398             continue;
1399
1400           midi_out_buffer[0] = 0xB0; /* control change */
1401           midi_out_buffer[1] = channel_ptr->midi_cc_balance_index;
1402           balance = channel_balance_read(channel_ptr);
1403           if (balance < 0.0) {
1404             midi_out_buffer[2] = (unsigned char)(MAP(balance, -1.0, -0.015625, 0.0, 63.0) + 0.5);
1405           }
1406           else {
1407             midi_out_buffer[2] = (unsigned char)(MAP(balance, 0.0, 1.0, 64.0, 127.0) + 0.5);
1408           }
1409
1410           LOG_DEBUG(
1411             "%u: CC#%u <- %u",
1412             (unsigned int)midi_out_buffer[0],
1413             (unsigned int)midi_out_buffer[1],
1414             (unsigned int)midi_out_buffer[2]);
1415       }
1416       if (channel_ptr->midi_out_has_events & CHANNEL_MUTE)
1417       {
1418           midi_out_buffer = jack_midi_event_reserve(midi_buffer, 0, 3);
1419           if (!midi_out_buffer)
1420             continue;
1421
1422           midi_out_buffer[0] = 0xB0; /* control change */
1423           midi_out_buffer[1] = channel_ptr->midi_cc_mute_index;
1424           midi_out_buffer[2] = (unsigned char)(channel_is_out_muted(channel_ptr) ? 127 : 0);
1425
1426           LOG_DEBUG(
1427             "%u: CC#%u <- %u",
1428             (unsigned int)midi_out_buffer[0],
1429             (unsigned int)midi_out_buffer[1],
1430             (unsigned int)midi_out_buffer[2]);
1431       }
1432       if (channel_ptr->midi_out_has_events & CHANNEL_SOLO)
1433       {
1434           midi_out_buffer = jack_midi_event_reserve(midi_buffer, 0, 3);
1435           if (!midi_out_buffer)
1436             continue;
1437
1438           midi_out_buffer[0] = 0xB0; /* control change */
1439           midi_out_buffer[1] = channel_ptr->midi_cc_solo_index;
1440           midi_out_buffer[2] = (unsigned char)(channel_is_soloed(channel_ptr) ? 127 : 0);
1441
1442           LOG_DEBUG(
1443             "%u: CC#%u <- %u",
1444             (unsigned int)midi_out_buffer[0],
1445             (unsigned int)midi_out_buffer[1],
1446             (unsigned int)midi_out_buffer[2]);
1447       }
1448       channel_ptr->midi_out_has_events = 0;
1449     }
1450   }
1451
1452 #endif
1453
1454   mix(mixer_ptr, 0, nframes);
1455
1456   return 0;
1457 }
1458
1459 #undef mixer_ptr
1460
1461 jack_mixer_t
1462 create(
1463   const char * jack_client_name_ptr,
1464   bool stereo)
1465 {
1466   (void) stereo;
1467   int ret;
1468   struct jack_mixer * mixer_ptr;
1469   int i;
1470
1471
1472   mixer_ptr = malloc(sizeof(struct jack_mixer));
1473   if (mixer_ptr == NULL)
1474   {
1475     goto exit;
1476   }
1477
1478   ret = pthread_mutex_init(&mixer_ptr->mutex, NULL);
1479   if (ret != 0)
1480   {
1481     goto exit_free;
1482   }
1483
1484   mixer_ptr->input_channels_list = NULL;
1485   mixer_ptr->output_channels_list = NULL;
1486
1487   mixer_ptr->soloed_channels = NULL;
1488
1489   mixer_ptr->last_midi_cc = -1;
1490
1491   mixer_ptr->midi_behavior = Jump_To_Value;
1492
1493   for (i = 0 ; i < 128 ; i++)
1494   {
1495     mixer_ptr->midi_cc_map[i] = NULL;
1496   }
1497
1498   LOG_DEBUG("Initializing JACK");
1499   mixer_ptr->jack_client = jack_client_open(jack_client_name_ptr, 0, NULL);
1500   if (mixer_ptr->jack_client == NULL)
1501   {
1502     LOG_ERROR("Cannot create JACK client.");
1503     LOG_NOTICE("Please make sure JACK daemon is running.");
1504     goto exit_destroy_mutex;
1505   }
1506
1507   LOG_DEBUG("JACK client created");
1508
1509   LOG_DEBUG("Sample rate: %" PRIu32, jack_get_sample_rate(mixer_ptr->jack_client));
1510
1511
1512 #if defined(HAVE_JACK_MIDI)
1513   mixer_ptr->port_midi_in = jack_port_register(mixer_ptr->jack_client, "midi in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
1514   if (mixer_ptr->port_midi_in == NULL)
1515   {
1516     LOG_ERROR("Cannot create JACK MIDI in port");
1517     goto close_jack;
1518   }
1519
1520   mixer_ptr->port_midi_out = jack_port_register(mixer_ptr->jack_client, "midi out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
1521   if (mixer_ptr->port_midi_out == NULL)
1522   {
1523     LOG_ERROR("Cannot create JACK MIDI out port");
1524     goto close_jack;
1525   }
1526
1527 #endif
1528
1529   ret = jack_set_process_callback(mixer_ptr->jack_client, process, mixer_ptr);
1530   if (ret != 0)
1531   {
1532     LOG_ERROR("Cannot set JACK process callback");
1533     goto close_jack;
1534   }
1535
1536   ret = jack_activate(mixer_ptr->jack_client);
1537   if (ret != 0)
1538   {
1539     LOG_ERROR("Cannot activate JACK client");
1540     goto close_jack;
1541   }
1542
1543   return mixer_ptr;
1544
1545 close_jack:
1546   jack_client_close(mixer_ptr->jack_client); /* this should clear all other resources we obtained through the client handle */
1547
1548 exit_destroy_mutex:
1549   pthread_mutex_destroy(&mixer_ptr->mutex);
1550
1551 exit_free:
1552   free(mixer_ptr);
1553
1554 exit:
1555   return NULL;
1556 }
1557
1558 #define mixer_ctx_ptr ((struct jack_mixer *)mixer)
1559
1560 void
1561 destroy(
1562   jack_mixer_t mixer)
1563 {
1564   LOG_DEBUG("Uninitializing JACK");
1565
1566   assert(mixer_ctx_ptr->jack_client != NULL);
1567
1568   jack_client_close(mixer_ctx_ptr->jack_client);
1569
1570   pthread_mutex_destroy(&mixer_ctx_ptr->mutex);
1571
1572   free(mixer_ctx_ptr);
1573 }
1574
1575
1576 unsigned int
1577 get_channels_count(
1578   jack_mixer_t mixer)
1579 {
1580   return g_slist_length(mixer_ctx_ptr->input_channels_list);
1581 }
1582
1583 const char*
1584 get_client_name(
1585   jack_mixer_t mixer)
1586 {
1587   return jack_get_client_name(mixer_ctx_ptr->jack_client);
1588 }
1589
1590 int8_t
1591 get_last_midi_cc(
1592   jack_mixer_t mixer)
1593 {
1594   return mixer_ctx_ptr->last_midi_cc;
1595 }
1596
1597 unsigned int
1598 set_last_midi_cc(
1599   jack_mixer_t mixer,
1600   int8_t new_cc) {
1601   mixer_ctx_ptr->last_midi_cc = new_cc;
1602   return 0;
1603 }
1604
1605 int
1606 get_midi_behavior_mode(
1607   jack_mixer_t mixer)
1608 {
1609   return mixer_ctx_ptr->midi_behavior;
1610 }
1611
1612 unsigned int
1613 set_midi_behavior_mode(
1614   jack_mixer_t mixer,
1615   enum midi_behavior_mode mode)
1616 {
1617   mixer_ctx_ptr->midi_behavior = mode;
1618   return 0;
1619 }
1620
1621 jack_mixer_channel_t
1622 add_channel(
1623   jack_mixer_t mixer,
1624   const char * channel_name,
1625   bool stereo)
1626 {
1627   struct channel * channel_ptr;
1628   char * port_name = NULL;
1629   size_t channel_name_size;
1630
1631   channel_ptr = malloc(sizeof(struct channel));
1632   if (channel_ptr == NULL)
1633   {
1634     goto fail;
1635   }
1636
1637   channel_ptr->mixer_ptr = mixer_ctx_ptr;
1638
1639   channel_ptr->name = strdup(channel_name);
1640   if (channel_ptr->name == NULL)
1641   {
1642     goto fail_free_channel;
1643   }
1644
1645   channel_name_size = strlen(channel_name);
1646
1647   if (stereo)
1648   {
1649     port_name = malloc(channel_name_size + 3);
1650     if (port_name == NULL)
1651     {
1652         goto fail_free_channel_name;
1653     }
1654
1655     memcpy(port_name, channel_name, channel_name_size);
1656     port_name[channel_name_size] = ' ';
1657     port_name[channel_name_size+1] = 'L';
1658     port_name[channel_name_size+2] = 0;
1659
1660     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1661     if (channel_ptr->port_left == NULL)
1662     {
1663         goto fail_free_port_name;
1664     }
1665
1666     port_name[channel_name_size+1] = 'R';
1667
1668     channel_ptr->port_right = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1669     if (channel_ptr->port_right == NULL)
1670     {
1671         goto fail_unregister_left_channel;
1672     }
1673   }
1674   else
1675   {
1676     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, channel_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1677     if (channel_ptr->port_left == NULL)
1678     {
1679         goto fail_free_channel_name;
1680     }
1681   }
1682
1683   channel_ptr->stereo = stereo;
1684
1685   int sr = jack_get_sample_rate(channel_ptr->mixer_ptr->jack_client);
1686   int fsize = jack_get_buffer_size(channel_ptr->mixer_ptr->jack_client);
1687
1688   channel_ptr->volume_transition_seconds = VOLUME_TRANSITION_SECONDS;
1689   channel_ptr->num_volume_transition_steps =
1690     channel_ptr->volume_transition_seconds * sr + 1;
1691   channel_ptr->volume = 0.0;
1692   channel_ptr->volume_new = 0.0;
1693   channel_ptr->balance = 0.0;
1694   channel_ptr->balance_new = 0.0;
1695   channel_ptr->meter_left = -1.0;
1696   channel_ptr->meter_right = -1.0;
1697   channel_ptr->abspeak = 0.0;
1698   channel_ptr->out_mute = false;
1699
1700   kmeter_init(&channel_ptr->kmeter_left, sr, fsize, .5f, 15.0f);
1701   kmeter_init(&channel_ptr->kmeter_right, sr, fsize, .5f, 15.0f);
1702
1703   channel_ptr->peak_left = 0.0;
1704   channel_ptr->peak_right = 0.0;
1705   channel_ptr->peak_frames = 0;
1706
1707   channel_ptr->frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1708   channel_ptr->frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1709   channel_ptr->prefader_frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1710   channel_ptr->prefader_frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1711
1712   channel_ptr->NaN_detected = false;
1713
1714   channel_ptr->midi_cc_volume_index = -1;
1715   channel_ptr->midi_cc_balance_index = -1;
1716   channel_ptr->midi_cc_mute_index = -1;
1717   channel_ptr->midi_cc_solo_index = -1;
1718   channel_ptr->midi_cc_volume_picked_up = false;
1719   channel_ptr->midi_cc_balance_picked_up = false;
1720
1721   channel_ptr->midi_change_callback = NULL;
1722   channel_ptr->midi_change_callback_data = NULL;
1723   channel_ptr->midi_out_has_events = 0;
1724
1725   channel_ptr->midi_scale = NULL;
1726
1727   channel_ptr->mixer_ptr->input_channels_list = g_slist_prepend(
1728                   channel_ptr->mixer_ptr->input_channels_list, channel_ptr);
1729
1730   free(port_name);
1731   return channel_ptr;
1732
1733 fail_unregister_left_channel:
1734   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
1735
1736 fail_free_port_name:
1737   free(port_name);
1738
1739 fail_free_channel_name:
1740   free(channel_ptr->name);
1741
1742 fail_free_channel:
1743   free(channel_ptr);
1744   channel_ptr = NULL;
1745
1746 fail:
1747   return NULL;
1748 }
1749
1750 static jack_mixer_output_channel_t
1751 create_output_channel(
1752   jack_mixer_t mixer,
1753   const char * channel_name,
1754   bool stereo,
1755   bool system)
1756 {
1757   struct channel * channel_ptr;
1758   struct output_channel * output_channel_ptr;
1759   char * port_name = NULL;
1760   size_t channel_name_size;
1761
1762   output_channel_ptr = malloc(sizeof(struct output_channel));
1763   channel_ptr = (struct channel*)output_channel_ptr;
1764   if (channel_ptr == NULL)
1765   {
1766     goto fail;
1767   }
1768
1769   channel_ptr->mixer_ptr = mixer_ctx_ptr;
1770
1771   channel_ptr->name = strdup(channel_name);
1772   if (channel_ptr->name == NULL)
1773   {
1774     goto fail_free_channel;
1775   }
1776
1777   if (stereo)
1778   {
1779     channel_name_size = strlen(channel_name);
1780
1781     port_name = malloc(channel_name_size + 4);
1782     if (port_name == NULL)
1783     {
1784         goto fail_free_channel_name;
1785     }
1786
1787     memcpy(port_name, channel_name, channel_name_size);
1788     port_name[channel_name_size] = ' ';
1789     port_name[channel_name_size+1] = 'L';
1790     port_name[channel_name_size+2] = 0;
1791
1792     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
1793     if (channel_ptr->port_left == NULL)
1794     {
1795         goto fail_free_port_name;
1796     }
1797
1798     port_name[channel_name_size+1] = 'R';
1799
1800     channel_ptr->port_right = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
1801     if (channel_ptr->port_right == NULL)
1802     {
1803         goto fail_unregister_left_channel;
1804     }
1805   }
1806   else
1807   {
1808     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, channel_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
1809     if (channel_ptr->port_left == NULL)
1810     {
1811         goto fail_free_channel_name;
1812     }
1813   }
1814
1815   channel_ptr->stereo = stereo;
1816   channel_ptr->out_mute = false;
1817
1818   int sr = jack_get_sample_rate(channel_ptr->mixer_ptr->jack_client);
1819   int fsize = jack_get_buffer_size(channel_ptr->mixer_ptr->jack_client);
1820
1821   channel_ptr->volume_transition_seconds = VOLUME_TRANSITION_SECONDS;
1822   channel_ptr->num_volume_transition_steps =
1823     channel_ptr->volume_transition_seconds * sr + 1;
1824   channel_ptr->volume = 0.0;
1825   channel_ptr->volume_new = 0.0;
1826   channel_ptr->balance = 0.0;
1827   channel_ptr->balance_new = 0.0;
1828   channel_ptr->meter_left = -1.0;
1829   channel_ptr->meter_right = -1.0;
1830   channel_ptr->abspeak = 0.0;
1831   kmeter_init(&channel_ptr->kmeter_left, sr, fsize, 0.5f, 15.0f);
1832   kmeter_init(&channel_ptr->kmeter_right, sr, fsize, 0.5f, 15.0f);
1833
1834   channel_ptr->peak_left = 0.0;
1835   channel_ptr->peak_right = 0.0;
1836   channel_ptr->peak_frames = 0;
1837
1838   channel_ptr->tmp_mixed_frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1839   channel_ptr->tmp_mixed_frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1840   channel_ptr->frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1841   channel_ptr->frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1842   channel_ptr->prefader_frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1843   channel_ptr->prefader_frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1844
1845   channel_ptr->NaN_detected = false;
1846
1847   channel_ptr->midi_cc_volume_index = -1;
1848   channel_ptr->midi_cc_balance_index = -1;
1849   channel_ptr->midi_cc_mute_index = -1;
1850   channel_ptr->midi_cc_solo_index = -1;
1851   channel_ptr->midi_cc_volume_picked_up = false;
1852   channel_ptr->midi_cc_balance_picked_up = false;
1853
1854   channel_ptr->midi_change_callback = NULL;
1855   channel_ptr->midi_change_callback_data = NULL;
1856
1857   channel_ptr->midi_scale = NULL;
1858
1859   output_channel_ptr->soloed_channels = NULL;
1860   output_channel_ptr->muted_channels = NULL;
1861   output_channel_ptr->prefader_channels = NULL;
1862   output_channel_ptr->system = system;
1863   output_channel_ptr->prefader = false;
1864
1865   free(port_name);
1866   return output_channel_ptr;
1867
1868 fail_unregister_left_channel:
1869   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
1870
1871 fail_free_port_name:
1872   free(port_name);
1873
1874 fail_free_channel_name:
1875   free(channel_ptr->name);
1876
1877 fail_free_channel:
1878   free(channel_ptr);
1879   channel_ptr = NULL;
1880
1881 fail:
1882   return NULL;
1883 }
1884
1885 jack_mixer_output_channel_t
1886 add_output_channel(
1887   jack_mixer_t mixer,
1888   const char * channel_name,
1889   bool stereo,
1890   bool system)
1891 {
1892   struct output_channel *output_channel_ptr;
1893   struct channel *channel_ptr;
1894
1895   output_channel_ptr = create_output_channel(mixer, channel_name, stereo, system);
1896   if (output_channel_ptr == NULL) {
1897     return NULL;
1898   }
1899   channel_ptr = (struct channel*)output_channel_ptr;
1900
1901   ((struct jack_mixer*)mixer)->output_channels_list = g_slist_prepend(
1902                   ((struct jack_mixer*)mixer)->output_channels_list, channel_ptr);
1903
1904   return output_channel_ptr;
1905 }
1906
1907 void
1908 remove_channels(
1909   jack_mixer_t mixer)
1910 {
1911   GSList *list_ptr;
1912   for (list_ptr = mixer_ctx_ptr->input_channels_list; list_ptr; list_ptr = g_slist_next(list_ptr))
1913   {
1914     struct channel *input_channel_ptr = list_ptr->data;
1915     remove_channel((jack_mixer_channel_t)input_channel_ptr);
1916   }
1917 }
1918
1919 #define km ((struct kmeter *) kmeter)
1920
1921 void
1922 kmeter_init(
1923   jack_mixer_kmeter_t kmeter,
1924   int sr,
1925   int fsize,
1926   float hold,
1927   float fall)
1928 {
1929   km->_z1 = 0;
1930   km->_z2 = 0;
1931   km->_rms = 0;
1932   km->_dpk = 0;
1933   km->_cnt = 0;
1934   km->_flag = false;
1935
1936   float t;
1937   km->_omega = 9.72f / sr;
1938   t = (float) fsize / sr;
1939   km->_hold = (int)(hold / t + 0.5f);
1940   km->_fall = powf(10.0f, -0.05f * fall * t);
1941 }
1942
1943 void
1944 kmeter_process(
1945   jack_mixer_kmeter_t kmeter,
1946   jack_default_audio_sample_t *p,
1947   int start,
1948   int end)
1949 {
1950   int i;
1951   jack_default_audio_sample_t s, t, z1, z2;
1952
1953   if (km->_flag) {
1954     km->_rms = 0;
1955     km->_flag = 0;
1956   }
1957
1958   z1 = km->_z1;
1959   z2 = km->_z2;
1960
1961   t = 0;
1962
1963   for (i = start; i < end; i++) {
1964     s = p[i];
1965     s *= s;
1966     if (t < s) t = s;
1967     z1 += km->_omega * (s - z1);
1968     z2 += km->_omega * (z1 - z2);
1969   }
1970   t = sqrtf(t);
1971
1972   km->_z1 = z1 + 1e-20f;
1973   km->_z2 = z2 + 1e-20f;
1974
1975   s = sqrtf(2 * z2);
1976   if (s > km->_rms) km->_rms = s;
1977
1978   if (t > km->_dpk) {
1979     km->_dpk = t;
1980     km->_cnt = km->_hold;
1981   }
1982   else if (km->_cnt) {
1983     km->_cnt--;
1984   }
1985   else {
1986     km->_dpk *= km->_fall;
1987     km->_dpk += 1e-10f;
1988   }
1989 }
1990
1991 void
1992 remove_output_channel(
1993   jack_mixer_output_channel_t output_channel)
1994 {
1995   struct output_channel *output_channel_ptr = output_channel;
1996   struct channel *channel_ptr = output_channel;
1997
1998   channel_ptr->mixer_ptr->output_channels_list = g_slist_remove(
1999                   channel_ptr->mixer_ptr->output_channels_list, channel_ptr);
2000   free(channel_ptr->name);
2001
2002   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
2003   if (channel_ptr->stereo)
2004   {
2005     jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_right);
2006   }
2007
2008   if (channel_ptr->midi_cc_volume_index != -1)
2009   {
2010     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] == channel_ptr);
2011     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
2012   }
2013
2014   if (channel_ptr->midi_cc_balance_index != -1)
2015   {
2016     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] == channel_ptr);
2017     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
2018   }
2019
2020   if (channel_ptr->midi_cc_mute_index != -1)
2021   {
2022     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_mute_index] == channel_ptr);
2023     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_mute_index] = NULL;
2024   }
2025
2026   if (channel_ptr->midi_cc_solo_index != -1)
2027   {
2028     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_solo_index] == channel_ptr);
2029     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_solo_index] = NULL;
2030   }
2031
2032   g_slist_free(output_channel_ptr->soloed_channels);
2033   g_slist_free(output_channel_ptr->muted_channels);
2034   g_slist_free(output_channel_ptr->prefader_channels);
2035
2036   free(channel_ptr->tmp_mixed_frames_left);
2037   free(channel_ptr->tmp_mixed_frames_right);
2038   free(channel_ptr->frames_left);
2039   free(channel_ptr->frames_right);
2040   free(channel_ptr->prefader_frames_left);
2041   free(channel_ptr->prefader_frames_right);
2042
2043   free(channel_ptr);
2044 }
2045
2046 void
2047 output_channel_set_solo(
2048   jack_mixer_output_channel_t output_channel,
2049   jack_mixer_channel_t channel,
2050   bool solo_value)
2051 {
2052   struct output_channel *output_channel_ptr = output_channel;
2053
2054   if (solo_value) {
2055     if (g_slist_find(output_channel_ptr->soloed_channels, channel) != NULL)
2056       return;
2057     output_channel_ptr->soloed_channels = g_slist_prepend(output_channel_ptr->soloed_channels, channel);
2058   }
2059   else {
2060     if (g_slist_find(output_channel_ptr->soloed_channels, channel) == NULL)
2061       return;
2062     output_channel_ptr->soloed_channels = g_slist_remove(output_channel_ptr->soloed_channels, channel);
2063   }
2064 }
2065
2066 void
2067 output_channel_set_muted(
2068   jack_mixer_output_channel_t output_channel,
2069   jack_mixer_channel_t channel,
2070   bool muted_value)
2071 {
2072   struct output_channel *output_channel_ptr = output_channel;
2073
2074   if (muted_value) {
2075     if (g_slist_find(output_channel_ptr->muted_channels, channel) != NULL)
2076       return;
2077     output_channel_ptr->muted_channels = g_slist_prepend(output_channel_ptr->muted_channels, channel);
2078   }
2079   else {
2080     if (g_slist_find(output_channel_ptr->muted_channels, channel) == NULL)
2081       return;
2082     output_channel_ptr->muted_channels = g_slist_remove(output_channel_ptr->muted_channels, channel);
2083   }
2084 }
2085
2086 bool
2087 output_channel_is_muted(
2088   jack_mixer_output_channel_t output_channel,
2089   jack_mixer_channel_t channel)
2090 {
2091   struct output_channel *output_channel_ptr = output_channel;
2092
2093   if (g_slist_find(output_channel_ptr->muted_channels, channel) != NULL)
2094     return true;
2095   return false;
2096 }
2097
2098 bool
2099 output_channel_is_solo(
2100   jack_mixer_output_channel_t output_channel,
2101   jack_mixer_channel_t channel)
2102 {
2103   struct output_channel *output_channel_ptr = output_channel;
2104
2105   if (g_slist_find(output_channel_ptr->soloed_channels, channel) != NULL)
2106     return true;
2107   return false;
2108 }
2109
2110 void
2111 output_channel_set_prefader(
2112   jack_mixer_output_channel_t output_channel,
2113   bool pfl_value)
2114 {
2115   struct output_channel *output_channel_ptr = output_channel;
2116   output_channel_ptr->prefader = pfl_value;
2117 }
2118
2119 bool
2120 output_channel_is_prefader(
2121   jack_mixer_output_channel_t output_channel)
2122 {
2123   struct output_channel *output_channel_ptr = output_channel;
2124   return output_channel_ptr->prefader;
2125 }
2126
2127 void
2128 output_channel_set_in_prefader(
2129   jack_mixer_output_channel_t output_channel,
2130   jack_mixer_channel_t channel,
2131   bool prefader_value)
2132 {
2133   struct output_channel *output_channel_ptr = output_channel;
2134
2135   if (prefader_value) {
2136     if (g_slist_find(output_channel_ptr->prefader_channels, channel) != NULL)
2137       return;
2138     output_channel_ptr->prefader_channels = g_slist_prepend(output_channel_ptr->prefader_channels, channel);
2139   }
2140   else {
2141     if (g_slist_find(output_channel_ptr->prefader_channels, channel) == NULL)
2142       return;
2143     output_channel_ptr->prefader_channels = g_slist_remove(output_channel_ptr->prefader_channels, channel);
2144   }
2145 }
2146
2147 bool
2148 output_channel_is_in_prefader(
2149   jack_mixer_output_channel_t output_channel,
2150   jack_mixer_channel_t channel)
2151 {
2152   struct output_channel *output_channel_ptr = output_channel;
2153
2154   if (g_slist_find(output_channel_ptr->prefader_channels, channel) != NULL)
2155     return true;
2156   return false;
2157 }