]> git.0d.be Git - jack_mixer.git/blob - jack_mixer.c
Initialize threshold before using it
[jack_mixer.git] / 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 }