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