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 PEAK_FRAMES_CHUNK 4800
  47
  48 // we don't know how much to allocate, but we don't want to wait with
  49 // allocating until we're in the process() callback, so we just take a
  50 // fairly big chunk: 4 periods per buffer, 4096 samples per period.
  51 // (not sure if the '*4' is needed)
  52 #define MAX_BLOCK_SIZE (4 * 4096)
  53
  54 #define FLOAT_EXISTS(x) (!((x) - (x)))
  55
  56 struct channel
  57 {
  58   struct jack_mixer * mixer_ptr;
  59   char * name;
  60   bool stereo;
  61   float volume;
  62   float balance;
  63   float volume_left;
  64   float volume_right;
  65   float meter_left;
  66   float meter_right;
  67   float abspeak;
  68   jack_port_t * port_left;
  69   jack_port_t * port_right;
  70
  71   jack_nframes_t peak_frames;
  72   float peak_left;
  73   float peak_right;
  74
  75   jack_default_audio_sample_t * frames_left;
  76   jack_default_audio_sample_t * frames_right;
  77   jack_default_audio_sample_t * prefader_frames_left;
  78   jack_default_audio_sample_t * prefader_frames_right;
  79
  80   bool NaN_detected;
  81
  82   int midi_cc_volume_index;
  83   int midi_cc_balance_index;
  84
  85   jack_default_audio_sample_t * left_buffer_ptr;
  86   jack_default_audio_sample_t * right_buffer_ptr;
  87
  88   bool midi_in_got_events;
  89   void (*midi_change_callback) (void*);
  90   void *midi_change_callback_data;
  91   bool midi_out_has_events;
  92
  93   jack_mixer_scale_t midi_scale;
  94 };
  95
  96 struct output_channel {
  97   struct channel channel;
  98   GSList *soloed_channels;
  99   GSList *muted_channels;
 100   bool system; /* system channel, without any associated UI */
 101   bool prefader;
 102 };
 103
 104 struct jack_mixer
 105 {
 106   pthread_mutex_t mutex;
 107   jack_client_t * jack_client;
 108   GSList *input_channels_list;
 109   GSList *output_channels_list;
 110   struct output_channel *main_mix_channel;
 111
 112   jack_port_t * port_midi_in;
 113   jack_port_t * port_midi_out;
 114   unsigned int last_midi_channel;
 115
 116   struct channel* midi_cc_map[128];
 117 };
 118
 119 static jack_mixer_output_channel_t create_output_channel(
 120   jack_mixer_t mixer,
 121   const char * channel_name,
 122   bool stereo,
 123   bool system);
 124
 125 static inline void
 126 update_channel_buffers(
 127   struct channel * channel_ptr,
 128   jack_nframes_t nframes);
 129
 130
 131 float
 132 value_to_db(
 133   float value)
 134 {
 135   if (value <= 0)
 136   {
 137     return -INFINITY;
 138   }
 139
 140   return 20.0 * log10f(value);
 141 }
 142
 143 float
 144 db_to_value(
 145   float db)
 146 {
 147   return powf(10.0, db/20.0);
 148 }
 149
 150 void
 151 calc_channel_volumes(
 152   struct channel * channel_ptr)
 153 {
 154   if (channel_ptr->stereo)
 155   {
 156     if (channel_ptr->balance > 0)
 157     {
 158       channel_ptr->volume_left = channel_ptr->volume * (1 - channel_ptr->balance);
 159       channel_ptr->volume_right = channel_ptr->volume;
 160     }
 161     else
 162     {
 163       channel_ptr->volume_left = channel_ptr->volume;
 164       channel_ptr->volume_right = channel_ptr->volume * (1 + channel_ptr->balance);
 165     }
 166   }
 167   else
 168   {
 169     channel_ptr->volume_left = channel_ptr->volume * (1 - channel_ptr->balance);
 170     channel_ptr->volume_right = channel_ptr->volume * (1 + channel_ptr->balance);
 171   }
 172 }
 173
 174 void
 175 calc_all_channel_volumes(
 176   struct jack_mixer * mixer_ptr)
 177 {
 178   struct channel * channel_ptr;
 179   GSList *list_ptr;
 180
 181   for (list_ptr = mixer_ptr->input_channels_list; list_ptr; list_ptr = g_slist_next(list_ptr))
 182   {
 183     channel_ptr = list_ptr->data;
 184     calc_channel_volumes(channel_ptr);
 185   }
 186 }
 187
 188 #define channel_ptr ((struct channel *)channel)
 189
 190 const char*
 191 channel_get_name(
 192   jack_mixer_channel_t channel)
 193 {
 194   return channel_ptr->name;
 195 }
 196
 197 void
 198 channel_rename(
 199   jack_mixer_channel_t channel,
 200   const char * name)
 201 {
 202   char * new_name;
 203   size_t channel_name_size;
 204   char * port_name;
 205   int ret;
 206
 207   new_name = strdup(name);
 208   if (new_name == NULL)
 209   {
 210     return;
 211   }
 212
 213   if (channel_ptr->name)
 214   {
 215     free(channel_ptr->name);
 216   }
 217
 218   channel_ptr->name = new_name;
 219
 220   if (channel_ptr->stereo)
 221   {
 222     channel_name_size = strlen(name);
 223     port_name = malloc(channel_name_size + 3);
 224     memcpy(port_name, name, channel_name_size);
 225
 226     port_name[channel_name_size] = ' ';
 227     port_name[channel_name_size+1] = 'L';
 228     port_name[channel_name_size+2] = 0;
 229
 230     ret = jack_port_set_name(channel_ptr->port_left, port_name);
 231     if (ret != 0)
 232     {
 233       /* what could we do here? */
 234     }
 235
 236     port_name[channel_name_size+1] = 'R';
 237
 238     ret = jack_port_set_name(channel_ptr->port_right, port_name);
 239     if (ret != 0)
 240     {
 241       /* what could we do here? */
 242     }
 243
 244     free(port_name);
 245   }
 246   else
 247   {
 248     ret = jack_port_set_name(channel_ptr->port_left, name);
 249     if (ret != 0)
 250     {
 251       /* what could we do here? */
 252     }
 253   }
 254 }
 255
 256 bool
 257 channel_is_stereo(
 258   jack_mixer_channel_t channel)
 259 {
 260   return channel_ptr->stereo;
 261 }
 262
 263 unsigned int
 264 channel_get_balance_midi_cc(
 265   jack_mixer_channel_t channel)
 266 {
 267   return channel_ptr->midi_cc_balance_index;
 268 }
 269
 270 unsigned int
 271 channel_set_balance_midi_cc(
 272   jack_mixer_channel_t channel,
 273   unsigned int new_cc)
 274 {
 275   if (new_cc > 127) {
 276     return 2; /* error: over limit CC */
 277   }
 278   if (channel_ptr->midi_cc_balance_index == new_cc) {
 279     /* no change */
 280     return 0;
 281   }
 282   if (new_cc == 0) {
 283     /* 0 is special, it removes the link */
 284     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
 285     channel_ptr->midi_cc_balance_index = 0;
 286   } else {
 287     if (channel_ptr->mixer_ptr->midi_cc_map[new_cc] != NULL) {
 288       return 1; /* error: cc in use */
 289     }
 290     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
 291     channel_ptr->mixer_ptr->midi_cc_map[new_cc] = channel_ptr;
 292     channel_ptr->midi_cc_balance_index = new_cc;
 293   }
 294   return 0;
 295 }
 296
 297 unsigned int
 298 channel_get_volume_midi_cc(
 299   jack_mixer_channel_t channel)
 300 {
 301   return channel_ptr->midi_cc_volume_index;
 302 }
 303
 304 unsigned int
 305 channel_set_volume_midi_cc(
 306   jack_mixer_channel_t channel, unsigned int new_cc)
 307 {
 308   if (new_cc > 127) {
 309     return 2; /* error: over limit CC */
 310   }
 311   if (channel_ptr->midi_cc_volume_index == new_cc) {
 312     /* no change */
 313     return 0;
 314   }
 315   if (new_cc == 0) {
 316     /* 0 is special, it removes the link */
 317     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
 318     channel_ptr->midi_cc_volume_index = 0;
 319   } else {
 320     if (channel_ptr->mixer_ptr->midi_cc_map[new_cc] != NULL) {
 321       return 1; /* error: cc in use */
 322     }
 323     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
 324     channel_ptr->mixer_ptr->midi_cc_map[new_cc] = channel_ptr;
 325     channel_ptr->midi_cc_volume_index = new_cc;
 326   }
 327   return 0;
 328 }
 329
 330 void
 331 channel_autoset_midi_cc(
 332   jack_mixer_channel_t channel)
 333 {
 334   struct jack_mixer *mixer_ptr;
 335   int i;
 336
 337   mixer_ptr = channel_ptr->mixer_ptr;
 338
 339   for (i = 11 ; i < 128 ; i++)
 340   {
 341     if (mixer_ptr->midi_cc_map[i] == NULL)
 342     {
 343       mixer_ptr->midi_cc_map[i] = channel_ptr;
 344       channel_ptr->midi_cc_volume_index = i;
 345
 346       LOG_NOTICE("New channel \"%s\" volume mapped to CC#%i", channel_ptr->name, i);
 347
 348       break;
 349     }
 350   }
 351
 352   for (; i < 128 ; i++)
 353   {
 354     if (mixer_ptr->midi_cc_map[i] == NULL)
 355     {
 356       mixer_ptr->midi_cc_map[i] = channel_ptr;
 357       channel_ptr->midi_cc_balance_index = i;
 358
 359       LOG_NOTICE("New channel \"%s\" balance mapped to CC#%i", channel_ptr->name, i);
 360
 361       break;
 362     }
 363   }
 364 }
 365
 366 void
 367 remove_channel(
 368   jack_mixer_channel_t channel)
 369 {
 370   GSList *list_ptr;
 371
 372   channel_ptr->mixer_ptr->input_channels_list = g_slist_remove(
 373                   channel_ptr->mixer_ptr->input_channels_list, channel_ptr);
 374   free(channel_ptr->name);
 375
 376   /* remove references to input channel from all output channels */
 377   channel_unmute(channel_ptr);
 378   channel_unsolo(channel_ptr);
 379   for (list_ptr = channel_ptr->mixer_ptr->output_channels_list; list_ptr; list_ptr = g_slist_next(list_ptr))
 380   {
 381     struct output_channel *output_channel_ptr = list_ptr->data;
 382     output_channel_set_solo(output_channel_ptr, channel, false);
 383     output_channel_set_muted(output_channel_ptr, channel, false);
 384   }
 385
 386   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
 387   if (channel_ptr->stereo)
 388   {
 389     jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_right);
 390   }
 391
 392   if (channel_ptr->midi_cc_volume_index != 0)
 393   {
 394     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] == channel_ptr);
 395     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
 396   }
 397
 398   if (channel_ptr->midi_cc_balance_index != 0)
 399   {
 400     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] == channel_ptr);
 401     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
 402   }
 403
 404   free(channel_ptr);
 405 }
 406
 407 void
 408 channel_stereo_meter_read(
 409   jack_mixer_channel_t channel,
 410   double * left_ptr,
 411   double * right_ptr)
 412 {
 413   assert(channel_ptr);
 414   *left_ptr = value_to_db(channel_ptr->meter_left);
 415   *right_ptr = value_to_db(channel_ptr->meter_right);
 416 }
 417
 418 void
 419 channel_mono_meter_read(
 420   jack_mixer_channel_t channel,
 421   double * mono_ptr)
 422 {
 423   *mono_ptr = value_to_db(channel_ptr->meter_left);
 424 }
 425
 426 void
 427 channel_volume_write(
 428   jack_mixer_channel_t channel,
 429   double volume)
 430 {
 431   assert(channel_ptr);
 432   channel_ptr->volume = db_to_value(volume);
 433   channel_ptr->midi_out_has_events = true;
 434   calc_channel_volumes(channel_ptr);
 435 }
 436
 437 double
 438 channel_volume_read(
 439   jack_mixer_channel_t channel)
 440 {
 441   assert(channel_ptr);
 442   return value_to_db(channel_ptr->volume);
 443 }
 444
 445 void
 446 channel_balance_write(
 447   jack_mixer_channel_t channel,
 448   double balance)
 449 {
 450   assert(channel_ptr);
 451   channel_ptr->balance = balance;
 452   calc_channel_volumes(channel_ptr);
 453 }
 454
 455 double
 456 channel_balance_read(
 457   jack_mixer_channel_t channel)
 458 {
 459   assert(channel_ptr);
 460   return channel_ptr->balance;
 461 }
 462
 463 double
 464 channel_abspeak_read(
 465   jack_mixer_channel_t channel)
 466 {
 467   assert(channel_ptr);
 468   if (channel_ptr->NaN_detected)
 469   {
 470     return sqrt(-1);
 471   }
 472   else
 473   {
 474     return value_to_db(channel_ptr->abspeak);
 475   }
 476 }
 477
 478 void
 479 channel_abspeak_reset(
 480   jack_mixer_channel_t channel)
 481 {
 482   channel_ptr->abspeak = 0;
 483   channel_ptr->NaN_detected = false;
 484 }
 485
 486 void
 487 channel_mute(
 488   jack_mixer_channel_t channel)
 489 {
 490   output_channel_set_muted(channel_ptr->mixer_ptr->main_mix_channel, channel, true);
 491 }
 492
 493 void
 494 channel_unmute(
 495   jack_mixer_channel_t channel)
 496 {
 497   output_channel_set_muted(channel_ptr->mixer_ptr->main_mix_channel, channel, false);
 498 }
 499
 500 void
 501 channel_solo(
 502   jack_mixer_channel_t channel)
 503 {
 504   output_channel_set_solo(channel_ptr->mixer_ptr->main_mix_channel, channel, true);
 505 }
 506
 507 void
 508 channel_unsolo(
 509   jack_mixer_channel_t channel)
 510 {
 511   output_channel_set_solo(channel_ptr->mixer_ptr->main_mix_channel, channel, false);
 512 }
 513
 514 bool
 515 channel_is_muted(
 516   jack_mixer_channel_t channel)
 517 {
 518   if (g_slist_find(channel_ptr->mixer_ptr->main_mix_channel->muted_channels, channel))
 519     return true;
 520   return false;
 521 }
 522
 523 bool
 524 channel_is_soloed(
 525   jack_mixer_channel_t channel)
 526 {
 527   if (g_slist_find(channel_ptr->mixer_ptr->main_mix_channel->soloed_channels, channel))
 528     return true;
 529   return false;
 530 }
 531
 532 void
 533 channel_set_midi_scale(
 534   jack_mixer_channel_t channel,
 535   jack_mixer_scale_t scale)
 536 {
 537   channel_ptr->midi_scale = scale;
 538 }
 539
 540 void
 541 channel_set_midi_change_callback(
 542   jack_mixer_channel_t channel,
 543   void (*midi_change_callback) (void*),
 544   void *user_data)
 545 {
 546   channel_ptr->midi_change_callback = midi_change_callback;
 547   channel_ptr->midi_change_callback_data = user_data;
 548 }
 549
 550 bool
 551 channel_get_midi_in_got_events(
 552   jack_mixer_channel_t channel)
 553 {
 554   bool t = channel_ptr->midi_in_got_events;
 555   channel_ptr->midi_in_got_events = false;
 556   return t;
 557 }
 558
 559 #undef channel_ptr
 560
 561 /* process input channels and mix them into main mix */
 562 static inline void
 563 mix_one(
 564   struct output_channel *output_mix_channel,
 565   GSList *channels_list,
 566   jack_nframes_t start,         /* index of first sample to process */
 567   jack_nframes_t end)           /* index of sample to stop processing before */
 568 {
 569   jack_nframes_t i;
 570   GSList *node_ptr;
 571   struct channel * channel_ptr;
 572   jack_default_audio_sample_t frame_left;
 573   jack_default_audio_sample_t frame_right;
 574   struct channel *mix_channel = (struct channel*)output_mix_channel;
 575
 576   for (i = start; i < end; i++)
 577   {
 578     mix_channel->left_buffer_ptr[i] = 0.0;
 579     if (mix_channel->stereo)
 580       mix_channel->right_buffer_ptr[i] = 0.0;
 581   }
 582
 583
 584   for (node_ptr = channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 585   {
 586     channel_ptr = node_ptr->data;
 587
 588     if (g_slist_find(output_mix_channel->muted_channels, channel_ptr) != NULL) {
 589       /* skip muted channels */
 590       continue;
 591     }
 592
 593     if (output_mix_channel->soloed_channels &&
 594         g_slist_find(output_mix_channel->soloed_channels, channel_ptr) == NULL) {
 595       /* skip channels that are not soloed, when some are */
 596       continue;
 597     }
 598
 599     for (i = start ; i < end ; i++)
 600     {
 601       if (! output_mix_channel->prefader) {
 602         frame_left = channel_ptr->frames_left[i-start];
 603       } else {
 604         frame_left = channel_ptr->prefader_frames_left[i-start];
 605       }
 606       if (frame_left == NAN)
 607         break;
 608       mix_channel->left_buffer_ptr[i] += frame_left;
 609
 610       if (mix_channel->stereo)
 611       {
 612         if (! output_mix_channel->prefader) {
 613           frame_right = channel_ptr->frames_right[i-start];
 614         } else {
 615           frame_right = channel_ptr->prefader_frames_right[i-start];
 616         }
 617         if (frame_right == NAN)
 618           break;
 619
 620         mix_channel->right_buffer_ptr[i] += frame_right;
 621       }
 622
 623     }
 624
 625   }
 626
 627   /* process main mix channel */
 628   for (i = start ; i < end ; i++)
 629   {
 630     if (! output_mix_channel->prefader) {
 631       mix_channel->left_buffer_ptr[i] *= mix_channel->volume_left;
 632       if (mix_channel->stereo)
 633       {
 634         mix_channel->right_buffer_ptr[i] *= mix_channel->volume_right;
 635       }
 636     }
 637
 638     frame_left = fabsf(mix_channel->left_buffer_ptr[i]);
 639     if (mix_channel->peak_left < frame_left)
 640     {
 641       mix_channel->peak_left = frame_left;
 642
 643       if (frame_left > mix_channel->abspeak)
 644       {
 645         mix_channel->abspeak = frame_left;
 646       }
 647     }
 648
 649     if (mix_channel->stereo)
 650     {
 651       frame_right = fabsf(mix_channel->right_buffer_ptr[i]);
 652       if (mix_channel->peak_right < frame_right)
 653       {
 654         mix_channel->peak_right = frame_right;
 655
 656         if (frame_right > mix_channel->abspeak)
 657         {
 658           mix_channel->abspeak = frame_right;
 659         }
 660       }
 661     }
 662
 663     mix_channel->peak_frames++;
 664     if (mix_channel->peak_frames >= PEAK_FRAMES_CHUNK)
 665     {
 666       mix_channel->meter_left = mix_channel->peak_left;
 667       mix_channel->peak_left = 0.0;
 668
 669       if (mix_channel->stereo)
 670       {
 671         mix_channel->meter_right = mix_channel->peak_right;
 672         mix_channel->peak_right = 0.0;
 673       }
 674
 675       mix_channel->peak_frames = 0;
 676     }
 677   }
 678 }
 679
 680 static inline void
 681 calc_channel_frames(
 682   struct channel *channel_ptr,
 683   jack_nframes_t start,
 684   jack_nframes_t end)
 685 {
 686   jack_nframes_t i;
 687   jack_default_audio_sample_t frame_left;
 688   jack_default_audio_sample_t frame_right;
 689
 690   for (i = start ; i < end ; i++)
 691   {
 692     if (i-start >= MAX_BLOCK_SIZE)
 693     {
 694       fprintf(stderr, "i-start too high: %d - %d\n", i, start);
 695     }
 696     channel_ptr->prefader_frames_left[i-start] = channel_ptr->left_buffer_ptr[i];
 697     if (channel_ptr->stereo)
 698       channel_ptr->prefader_frames_right[i-start] = channel_ptr->right_buffer_ptr[i];
 699
 700     if (!FLOAT_EXISTS(channel_ptr->left_buffer_ptr[i]))
 701     {
 702       channel_ptr->NaN_detected = true;
 703       channel_ptr->frames_left[i-start] = NAN;
 704       break;
 705     }
 706
 707     frame_left = channel_ptr->left_buffer_ptr[i] * channel_ptr->volume_left;
 708
 709     if (channel_ptr->stereo)
 710     {
 711       if (!FLOAT_EXISTS(channel_ptr->right_buffer_ptr[i]))
 712       {
 713         channel_ptr->NaN_detected = true;
 714         channel_ptr->frames_right[i-start] = NAN;
 715         break;
 716       }
 717
 718       frame_right = channel_ptr->right_buffer_ptr[i] * channel_ptr->volume_right;
 719     }
 720     else
 721     {
 722       frame_right = channel_ptr->left_buffer_ptr[i] * channel_ptr->volume_right;
 723     }
 724
 725     channel_ptr->frames_left[i-start] = frame_left;
 726     channel_ptr->frames_right[i-start] = frame_right;
 727
 728     if (channel_ptr->stereo)
 729     {
 730       frame_left = fabsf(frame_left);
 731       frame_right = fabsf(frame_right);
 732
 733       if (channel_ptr->peak_left < frame_left)
 734       {
 735         channel_ptr->peak_left = frame_left;
 736
 737         if (frame_left > channel_ptr->abspeak)
 738         {
 739           channel_ptr->abspeak = frame_left;
 740         }
 741       }
 742
 743       if (channel_ptr->peak_right < frame_right)
 744       {
 745         channel_ptr->peak_right = frame_right;
 746
 747         if (frame_right > channel_ptr->abspeak)
 748         {
 749           channel_ptr->abspeak = frame_right;
 750         }
 751       }
 752     }
 753     else
 754     {
 755       frame_left = (fabsf(frame_left) + fabsf(frame_right)) / 2;
 756
 757       if (channel_ptr->peak_left < frame_left)
 758       {
 759         channel_ptr->peak_left = frame_left;
 760
 761         if (frame_left > channel_ptr->abspeak)
 762         {
 763           channel_ptr->abspeak = frame_left;
 764         }
 765       }
 766     }
 767
 768     channel_ptr->peak_frames++;
 769     if (channel_ptr->peak_frames >= PEAK_FRAMES_CHUNK)
 770     {
 771       channel_ptr->meter_left = channel_ptr->peak_left;
 772       channel_ptr->peak_left = 0.0;
 773
 774       if (channel_ptr->stereo)
 775       {
 776         channel_ptr->meter_right = channel_ptr->peak_right;
 777         channel_ptr->peak_right = 0.0;
 778       }
 779
 780       channel_ptr->peak_frames = 0;
 781     }
 782   }
 783
 784 }
 785
 786 static inline void
 787 mix(
 788   struct jack_mixer * mixer_ptr,
 789   jack_nframes_t start,         /* index of first sample to process */
 790   jack_nframes_t end)           /* index of sample to stop processing before */
 791 {
 792   GSList *node_ptr;
 793   struct output_channel * output_channel_ptr;
 794   struct channel *channel_ptr;
 795
 796   for (node_ptr = mixer_ptr->input_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 797   {
 798     channel_ptr = (struct channel*)node_ptr->data;
 799     calc_channel_frames(channel_ptr, start, end);
 800   }
 801
 802   mix_one((struct output_channel*)mixer_ptr->main_mix_channel, mixer_ptr->input_channels_list, start, end);
 803
 804   for (node_ptr = mixer_ptr->output_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 805   {
 806     output_channel_ptr = node_ptr->data;
 807     channel_ptr = (struct channel*)output_channel_ptr;
 808
 809     if (output_channel_ptr->system)
 810     {
 811       /* Don't bother mixing the channels if we are not connected */
 812       if (channel_ptr->stereo)
 813       {
 814         if (jack_port_connected(channel_ptr->port_left) == 0 &&
 815             jack_port_connected(channel_ptr->port_right) == 0)
 816           continue;
 817       } else {
 818          if (jack_port_connected(channel_ptr->port_left) == 0)
 819            continue;
 820       }
 821     }
 822
 823     mix_one(output_channel_ptr, mixer_ptr->input_channels_list, start, end);
 824   }
 825 }
 826
 827 static inline void
 828 update_channel_buffers(
 829   struct channel * channel_ptr,
 830   jack_nframes_t nframes)
 831 {
 832   channel_ptr->left_buffer_ptr = jack_port_get_buffer(channel_ptr->port_left, nframes);
 833
 834   if (channel_ptr->stereo)
 835   {
 836     channel_ptr->right_buffer_ptr = jack_port_get_buffer(channel_ptr->port_right, nframes);
 837   }
 838 }
 839
 840 #define mixer_ptr ((struct jack_mixer *)context)
 841
 842 static int
 843 process(
 844   jack_nframes_t nframes,
 845   void * context)
 846 {
 847   jack_nframes_t i;
 848   GSList *node_ptr;
 849   struct channel * channel_ptr;
 850 #if defined(HAVE_JACK_MIDI)
 851   jack_nframes_t event_count;
 852   jack_midi_event_t in_event;
 853   unsigned char* midi_out_buffer;
 854   void * midi_buffer;
 855   signed char byte;
 856   unsigned int cc_channel_index;
 857 #endif
 858   jack_nframes_t offset;
 859
 860   for (node_ptr = mixer_ptr->input_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 861   {
 862     channel_ptr = node_ptr->data;
 863     update_channel_buffers(channel_ptr, nframes);
 864   }
 865
 866   // Fill output buffers with the input
 867   update_channel_buffers((struct channel*)mixer_ptr->main_mix_channel, nframes);
 868   for (node_ptr = mixer_ptr->output_channels_list; node_ptr; node_ptr = g_slist_next(node_ptr))
 869   {
 870     channel_ptr = node_ptr->data;
 871     update_channel_buffers(channel_ptr, nframes);
 872   }
 873
 874   offset = 0;
 875
 876 #if defined(HAVE_JACK_MIDI)
 877   midi_buffer = jack_port_get_buffer(mixer_ptr->port_midi_in, nframes);
 878   event_count = jack_midi_get_event_count(midi_buffer);
 879
 880   for (i = 0 ; i < event_count; i++)
 881   {
 882     jack_midi_event_get(&in_event, midi_buffer, i);
 883
 884     if (in_event.size != 3 ||
 885         (in_event.buffer[0] & 0xF0) != 0xB0 ||
 886         in_event.buffer[1] > 127 ||
 887         in_event.buffer[2] > 127)
 888     {
 889       continue;
 890     }
 891
 892     assert(in_event.time < nframes);
 893
 894     LOG_DEBUG(
 895       "%u: CC#%u -> %u",
 896       (unsigned int)(in_event.buffer[0]),
 897       (unsigned int)in_event.buffer[1],
 898       (unsigned int)in_event.buffer[2]);
 899
 900     mixer_ptr->last_midi_channel = (unsigned int)in_event.buffer[1];
 901     channel_ptr = mixer_ptr->midi_cc_map[in_event.buffer[1]];
 902
 903     /* if we have mapping for particular CC and MIDI scale is set for corresponding channel */
 904     if (channel_ptr != NULL && channel_ptr->midi_scale != NULL)
 905     {
 906       assert(in_event.time >= offset);
 907
 908       if (in_event.time > offset)
 909       {
 910         // Perform the mixing of the part between the previous volume change
 911         // (or the start of the block) up until this one.
 912         mix(mixer_ptr, offset, in_event.time);
 913         offset = in_event.time;
 914       }
 915
 916       if (channel_ptr->midi_cc_balance_index == (unsigned int)in_event.buffer[1])
 917       {
 918         byte = in_event.buffer[2];
 919         if (byte == 0)
 920         {
 921           byte = 1;
 922         }
 923         byte -= 64;
 924
 925         channel_ptr->balance = (float)byte / 63;
 926         LOG_DEBUG("\"%s\" balance -> %f", channel_ptr->name, channel_ptr->balance);
 927       }
 928       else
 929       {
 930         channel_ptr->volume = db_to_value(scale_scale_to_db(channel_ptr->midi_scale, (double)in_event.buffer[2] / 127));
 931         LOG_DEBUG("\"%s\" volume -> %f", channel_ptr->name, channel_ptr->volume);
 932       }
 933
 934       calc_channel_volumes(channel_ptr);
 935
 936       channel_ptr->midi_in_got_events = true;
 937       if (channel_ptr->midi_change_callback)
 938         channel_ptr->midi_change_callback(channel_ptr->midi_change_callback_data);
 939
 940     }
 941
 942   }
 943
 944   midi_buffer = jack_port_get_buffer(mixer_ptr->port_midi_out, nframes);
 945   jack_midi_clear_buffer(midi_buffer);
 946
 947   for(i=0; i<nframes; i++)
 948   {
 949     for (cc_channel_index=0; cc_channel_index<128; cc_channel_index++)
 950     {
 951       channel_ptr = mixer_ptr->midi_cc_map[cc_channel_index];
 952       if (channel_ptr == NULL)
 953       {
 954         continue;
 955       }
 956       if (channel_ptr->midi_out_has_events == false)
 957       {
 958         continue;
 959       }
 960       if (channel_ptr->midi_cc_balance_index == (unsigned int)cc_channel_index)
 961       {
 962         continue;
 963       }
 964       midi_out_buffer = jack_midi_event_reserve(midi_buffer, i, 3);
 965       if (midi_out_buffer == NULL)
 966       {
 967         continue;
 968       }
 969       midi_out_buffer[0] = 0xB0; /* control change */
 970       midi_out_buffer[1] = cc_channel_index;
 971       midi_out_buffer[2] = (unsigned char)(127*scale_db_to_scale(channel_ptr->midi_scale, value_to_db(channel_ptr->volume)));
 972
 973       LOG_DEBUG(
 974         "%u: CC#%u <- %u",
 975         (unsigned int)(midi_out_buffer[0]),
 976         (unsigned int)midi_out_buffer[1],
 977         (unsigned int)midi_out_buffer[2]);
 978
 979       channel_ptr->midi_out_has_events = false;
 980     }
 981   }
 982
 983 #endif
 984
 985   mix(mixer_ptr, offset, nframes);
 986
 987   return 0;
 988 }
 989
 990 #undef mixer_ptr
 991
 992 jack_mixer_t
 993 create(
 994   const char * jack_client_name_ptr)
 995 {
 996   int ret;
 997   struct jack_mixer * mixer_ptr;
 998   int i;
 999
1000
1001   mixer_ptr = malloc(sizeof(struct jack_mixer));
1002   if (mixer_ptr == NULL)
1003   {
1004     goto exit;
1005   }
1006
1007   ret = pthread_mutex_init(&mixer_ptr->mutex, NULL);
1008   if (ret != 0)
1009   {
1010     goto exit_free;
1011   }
1012
1013   mixer_ptr->input_channels_list = NULL;
1014   mixer_ptr->output_channels_list = NULL;
1015
1016   mixer_ptr->last_midi_channel = 0;
1017
1018   for (i = 0 ; i < 128 ; i++)
1019   {
1020     mixer_ptr->midi_cc_map[i] = NULL;
1021   }
1022
1023   LOG_DEBUG("Initializing JACK");
1024   mixer_ptr->jack_client = jack_client_open(jack_client_name_ptr, 0, NULL);
1025   if (mixer_ptr->jack_client == NULL)
1026   {
1027     LOG_ERROR("Cannot create JACK client.");
1028     LOG_NOTICE("Please make sure JACK daemon is running.");
1029     goto exit_destroy_mutex;
1030   }
1031
1032   LOG_DEBUG("JACK client created");
1033
1034   LOG_DEBUG("Sample rate: %" PRIu32, jack_get_sample_rate(mixer_ptr->jack_client));
1035
1036   mixer_ptr->main_mix_channel = create_output_channel(mixer_ptr, "MAIN", true, false);
1037   if (mixer_ptr->main_mix_channel == NULL) {
1038     LOG_ERROR("Cannot create main mix channel");
1039     goto close_jack;
1040   }
1041   channel_set_volume_midi_cc(mixer_ptr->main_mix_channel, 7);
1042   channel_set_balance_midi_cc(mixer_ptr->main_mix_channel, 8);
1043
1044   ((struct channel*)(mixer_ptr->main_mix_channel))->mixer_ptr = mixer_ptr;
1045
1046 #if defined(HAVE_JACK_MIDI)
1047   mixer_ptr->port_midi_in = jack_port_register(mixer_ptr->jack_client, "midi in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);
1048   if (mixer_ptr->port_midi_in == NULL)
1049   {
1050     LOG_ERROR("Cannot create JACK MIDI in port");
1051     goto close_jack;
1052   }
1053
1054   mixer_ptr->port_midi_out = jack_port_register(mixer_ptr->jack_client, "midi out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);
1055   if (mixer_ptr->port_midi_out == NULL)
1056   {
1057     LOG_ERROR("Cannot create JACK MIDI out port");
1058     goto close_jack;
1059   }
1060
1061 #endif
1062
1063   calc_channel_volumes((struct channel*)mixer_ptr->main_mix_channel);
1064
1065   ret = jack_set_process_callback(mixer_ptr->jack_client, process, mixer_ptr);
1066   if (ret != 0)
1067   {
1068     LOG_ERROR("Cannot set JACK process callback");
1069     goto close_jack;
1070   }
1071
1072   ret = jack_activate(mixer_ptr->jack_client);
1073   if (ret != 0)
1074   {
1075     LOG_ERROR("Cannot activate JACK client");
1076     goto close_jack;
1077   }
1078
1079   return mixer_ptr;
1080
1081 close_jack:
1082   jack_client_close(mixer_ptr->jack_client); /* this should clear all other resources we obtained through the client handle */
1083
1084 exit_destroy_mutex:
1085   pthread_mutex_destroy(&mixer_ptr->mutex);
1086
1087 exit_free:
1088   free(mixer_ptr);
1089
1090 exit:
1091   return NULL;
1092 }
1093
1094 #define mixer_ctx_ptr ((struct jack_mixer *)mixer)
1095
1096 void
1097 destroy(
1098   jack_mixer_t mixer)
1099 {
1100   LOG_DEBUG("Uninitializing JACK");
1101
1102   assert(mixer_ctx_ptr->jack_client != NULL);
1103
1104   jack_client_close(mixer_ctx_ptr->jack_client);
1105
1106   pthread_mutex_destroy(&mixer_ctx_ptr->mutex);
1107
1108   free(mixer_ctx_ptr->main_mix_channel);
1109   free(mixer_ctx_ptr);
1110 }
1111
1112 jack_mixer_channel_t
1113 get_main_mix_channel(
1114   jack_mixer_t mixer)
1115 {
1116   return (struct channel*)mixer_ctx_ptr->main_mix_channel;
1117 }
1118
1119 unsigned int
1120 get_channels_count(
1121   jack_mixer_t mixer)
1122 {
1123   return g_slist_length(mixer_ctx_ptr->input_channels_list);
1124 }
1125
1126 unsigned int
1127 get_last_midi_channel(
1128   jack_mixer_t mixer)
1129 {
1130   return mixer_ctx_ptr->last_midi_channel;
1131 }
1132
1133 jack_mixer_channel_t
1134 add_channel(
1135   jack_mixer_t mixer,
1136   const char * channel_name,
1137   bool stereo)
1138 {
1139   struct channel * channel_ptr;
1140   char * port_name;
1141   size_t channel_name_size;
1142
1143   channel_ptr = malloc(sizeof(struct channel));
1144   if (channel_ptr == NULL)
1145   {
1146     goto fail;
1147   }
1148
1149   channel_ptr->mixer_ptr = mixer_ctx_ptr;
1150
1151   channel_ptr->name = strdup(channel_name);
1152   if (channel_ptr->name == NULL)
1153   {
1154     goto fail_free_channel;
1155   }
1156
1157   channel_name_size = strlen(channel_name);
1158
1159   if (stereo)
1160   {
1161     port_name = malloc(channel_name_size + 3);
1162     if (port_name == NULL)
1163     {
1164         goto fail_free_channel_name;
1165     }
1166
1167     memcpy(port_name, channel_name, channel_name_size);
1168     port_name[channel_name_size] = ' ';
1169     port_name[channel_name_size+1] = 'L';
1170     port_name[channel_name_size+2] = 0;
1171
1172     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1173     if (channel_ptr->port_left == NULL)
1174     {
1175         goto fail_free_port_name;
1176     }
1177
1178     port_name[channel_name_size+1] = 'R';
1179
1180     channel_ptr->port_right = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1181     if (channel_ptr->port_right == NULL)
1182     {
1183         goto fail_unregister_left_channel;
1184     }
1185   }
1186   else
1187   {
1188     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, channel_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1189     if (channel_ptr->port_left == NULL)
1190     {
1191         goto fail_free_channel_name;
1192     }
1193   }
1194
1195   channel_ptr->stereo = stereo;
1196
1197   channel_ptr->volume = 0.0;
1198   channel_ptr->balance = 0.0;
1199   channel_ptr->meter_left = -1.0;
1200   channel_ptr->meter_right = -1.0;
1201   channel_ptr->abspeak = 0.0;
1202
1203   channel_ptr->peak_left = 0.0;
1204   channel_ptr->peak_right = 0.0;
1205   channel_ptr->peak_frames = 0;
1206
1207   channel_ptr->frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1208   channel_ptr->frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1209   channel_ptr->prefader_frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1210   channel_ptr->prefader_frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1211
1212   channel_ptr->NaN_detected = false;
1213
1214   channel_ptr->midi_cc_volume_index = 0;
1215   channel_ptr->midi_cc_balance_index = 0;
1216   channel_ptr->midi_change_callback = NULL;
1217   channel_ptr->midi_change_callback_data = NULL;
1218   channel_ptr->midi_out_has_events = false;
1219
1220   channel_ptr->midi_scale = NULL;
1221
1222   calc_channel_volumes(channel_ptr);
1223
1224   channel_ptr->mixer_ptr->input_channels_list = g_slist_prepend(
1225                   channel_ptr->mixer_ptr->input_channels_list, channel_ptr);
1226
1227   return channel_ptr;
1228
1229 fail_unregister_left_channel:
1230   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
1231
1232 fail_free_port_name:
1233   free(port_name);
1234
1235 fail_free_channel_name:
1236   free(channel_ptr->name);
1237
1238 fail_free_channel:
1239   free(channel_ptr);
1240   channel_ptr = NULL;
1241
1242 fail:
1243   return NULL;
1244 }
1245
1246 static jack_mixer_output_channel_t
1247 create_output_channel(
1248   jack_mixer_t mixer,
1249   const char * channel_name,
1250   bool stereo,
1251   bool system)
1252 {
1253   struct channel * channel_ptr;
1254   struct output_channel * output_channel_ptr;
1255   char * port_name;
1256   size_t channel_name_size;
1257
1258   output_channel_ptr = malloc(sizeof(struct output_channel));
1259   channel_ptr = (struct channel*)output_channel_ptr;
1260   if (channel_ptr == NULL)
1261   {
1262     goto fail;
1263   }
1264
1265   channel_ptr->mixer_ptr = mixer_ctx_ptr;
1266
1267   channel_ptr->name = strdup(channel_name);
1268   if (channel_ptr->name == NULL)
1269   {
1270     goto fail_free_channel;
1271   }
1272
1273   if (stereo)
1274   {
1275     channel_name_size = strlen(channel_name);
1276
1277     port_name = malloc(channel_name_size + 4);
1278     if (port_name == NULL)
1279     {
1280         goto fail_free_channel_name;
1281     }
1282
1283     memcpy(port_name, channel_name, channel_name_size);
1284     port_name[channel_name_size] = ' ';
1285     port_name[channel_name_size+1] = 'L';
1286     port_name[channel_name_size+2] = 0;
1287
1288     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
1289     if (channel_ptr->port_left == NULL)
1290     {
1291         goto fail_free_port_name;
1292     }
1293
1294     port_name[channel_name_size+1] = 'R';
1295
1296     channel_ptr->port_right = jack_port_register(channel_ptr->mixer_ptr->jack_client, port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
1297     if (channel_ptr->port_right == NULL)
1298     {
1299         goto fail_unregister_left_channel;
1300     }
1301   }
1302   else
1303   {
1304     channel_ptr->port_left = jack_port_register(channel_ptr->mixer_ptr->jack_client, channel_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
1305     if (channel_ptr->port_left == NULL)
1306     {
1307         goto fail_free_channel_name;
1308     }
1309   }
1310
1311   channel_ptr->stereo = stereo;
1312
1313   channel_ptr->volume = 0.0;
1314   channel_ptr->balance = 0.0;
1315   channel_ptr->meter_left = -1.0;
1316   channel_ptr->meter_right = -1.0;
1317   channel_ptr->abspeak = 0.0;
1318
1319   channel_ptr->peak_left = 0.0;
1320   channel_ptr->peak_right = 0.0;
1321   channel_ptr->peak_frames = 0;
1322
1323   channel_ptr->frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1324   channel_ptr->frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1325   channel_ptr->prefader_frames_left = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1326   channel_ptr->prefader_frames_right = calloc(MAX_BLOCK_SIZE, sizeof(jack_default_audio_sample_t));
1327
1328   channel_ptr->NaN_detected = false;
1329
1330   channel_ptr->midi_cc_volume_index = 0;
1331   channel_ptr->midi_cc_balance_index = 0;
1332   channel_ptr->midi_change_callback = NULL;
1333   channel_ptr->midi_change_callback_data = NULL;
1334
1335   channel_ptr->midi_scale = NULL;
1336
1337   output_channel_ptr->soloed_channels = NULL;
1338   output_channel_ptr->muted_channels = NULL;
1339   output_channel_ptr->system = system;
1340   output_channel_ptr->prefader = false;
1341
1342   return output_channel_ptr;
1343
1344 fail_unregister_left_channel:
1345   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
1346
1347 fail_free_port_name:
1348   free(port_name);
1349
1350 fail_free_channel_name:
1351   free(channel_ptr->name);
1352
1353 fail_free_channel:
1354   free(channel_ptr);
1355   channel_ptr = NULL;
1356
1357 fail:
1358   return NULL;
1359 }
1360
1361 jack_mixer_output_channel_t
1362 add_output_channel(
1363   jack_mixer_t mixer,
1364   const char * channel_name,
1365   bool stereo,
1366   bool system)
1367 {
1368   struct output_channel *output_channel_ptr;
1369   struct channel *channel_ptr;
1370
1371   output_channel_ptr = create_output_channel(mixer, channel_name, stereo, system);
1372   if (output_channel_ptr == NULL) {
1373     return NULL;
1374   }
1375   channel_ptr = (struct channel*)output_channel_ptr;
1376
1377   ((struct jack_mixer*)mixer)->output_channels_list = g_slist_prepend(
1378                   ((struct jack_mixer*)mixer)->output_channels_list, channel_ptr);
1379
1380   return output_channel_ptr;
1381 }
1382
1383 void
1384 remove_output_channel(
1385   jack_mixer_output_channel_t output_channel)
1386 {
1387   struct output_channel *output_channel_ptr = output_channel;
1388   struct channel *channel_ptr = output_channel;
1389
1390   channel_ptr->mixer_ptr->output_channels_list = g_slist_remove(
1391                   channel_ptr->mixer_ptr->output_channels_list, channel_ptr);
1392   free(channel_ptr->name);
1393
1394   jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_left);
1395   if (channel_ptr->stereo)
1396   {
1397     jack_port_unregister(channel_ptr->mixer_ptr->jack_client, channel_ptr->port_right);
1398   }
1399
1400   if (channel_ptr->midi_cc_volume_index != 0)
1401   {
1402     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] == channel_ptr);
1403     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_volume_index] = NULL;
1404   }
1405
1406   if (channel_ptr->midi_cc_balance_index != 0)
1407   {
1408     assert(channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] == channel_ptr);
1409     channel_ptr->mixer_ptr->midi_cc_map[channel_ptr->midi_cc_balance_index] = NULL;
1410   }
1411
1412   g_slist_free(output_channel_ptr->soloed_channels);
1413   g_slist_free(output_channel_ptr->muted_channels);
1414
1415   free(channel_ptr);
1416 }
1417
1418 void
1419 output_channel_set_solo(
1420   jack_mixer_output_channel_t output_channel,
1421   jack_mixer_channel_t channel,
1422   bool solo_value)
1423 {
1424   struct output_channel *output_channel_ptr = output_channel;
1425
1426   if (solo_value) {
1427     if (g_slist_find(output_channel_ptr->soloed_channels, channel) != NULL)
1428       return;
1429     output_channel_ptr->soloed_channels = g_slist_prepend(output_channel_ptr->soloed_channels, channel);
1430   } else {
1431     if (g_slist_find(output_channel_ptr->soloed_channels, channel) == NULL)
1432       return;
1433     output_channel_ptr->soloed_channels = g_slist_remove(output_channel_ptr->soloed_channels, channel);
1434   }
1435 }
1436
1437 void
1438 output_channel_set_muted(
1439   jack_mixer_output_channel_t output_channel,
1440   jack_mixer_channel_t channel,
1441   bool muted_value)
1442 {
1443   struct output_channel *output_channel_ptr = output_channel;
1444
1445   if (muted_value) {
1446     if (g_slist_find(output_channel_ptr->muted_channels, channel) != NULL)
1447       return;
1448     output_channel_ptr->muted_channels = g_slist_prepend(output_channel_ptr->muted_channels, channel);
1449   } else {
1450     if (g_slist_find(output_channel_ptr->muted_channels, channel) == NULL)
1451       return;
1452     output_channel_ptr->muted_channels = g_slist_remove(output_channel_ptr->muted_channels, channel);
1453   }
1454 }
1455
1456 bool
1457 output_channel_is_muted(
1458   jack_mixer_output_channel_t output_channel,
1459   jack_mixer_channel_t channel)
1460 {
1461   struct output_channel *output_channel_ptr = output_channel;
1462
1463   if (g_slist_find(output_channel_ptr->muted_channels, channel) != NULL)
1464     return true;
1465   return false;
1466 }
1467
1468 bool
1469 output_channel_is_solo(
1470   jack_mixer_output_channel_t output_channel,
1471   jack_mixer_channel_t channel)
1472 {
1473   struct output_channel *output_channel_ptr = output_channel;
1474
1475   if (g_slist_find(output_channel_ptr->soloed_channels, channel) != NULL)
1476     return true;
1477   return false;
1478 }
1479
1480 void
1481 output_channel_set_prefader(
1482   jack_mixer_output_channel_t output_channel,
1483   bool pfl_value)
1484 {
1485   struct output_channel *output_channel_ptr = output_channel;
1486   output_channel_ptr->prefader = pfl_value;
1487 }
1488
1489 bool
1490 output_channel_is_prefader(
1491   jack_mixer_output_channel_t output_channel)
1492 {
1493   struct output_channel *output_channel_ptr = output_channel;
1494   return output_channel_ptr->prefader;
1495 }