1 /*
2 * Copyright (C) 2019-2021 Alexandros Theodotou <alex at zrythm dot org>
3 *
4 * This file is part of Zrythm
5 *
6 * Zrythm is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU Affero General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * Zrythm is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Affero General Public License for more details.
15 *
16 * You should have received a copy of the GNU Affero General Public License
17 * along with Zrythm. If not, see <https://www.gnu.org/licenses/>.
18 */
19
20 #include "actions/tracklist_selections.h"
21 #include "audio/balance_control.h"
22 #include "audio/channel.h"
23 #include "audio/control_port.h"
24 #include "audio/control_room.h"
25 #include "audio/engine.h"
26 #include "audio/fader.h"
27 #include "audio/group_target_track.h"
28 #include "audio/master_track.h"
29 #include "audio/midi_event.h"
30 #include "audio/track.h"
31 #include "gui/backend/event.h"
32 #include "gui/backend/event_manager.h"
33 #include "project.h"
34 #include "settings/settings.h"
35 #include "utils/dsp.h"
36 #include "utils/error.h"
37 #include "utils/flags.h"
38 #include "utils/math.h"
39 #include "utils/objects.h"
40 #include "zrythm.h"
41 #include "zrythm_app.h"
42
43 #include <glib/gi18n.h>
44
45 /**
46 * Inits fader after a project is loaded.
47 */
48 void
49 fader_init_loaded (
50 Fader * self,
51 Track * track,
52 ControlRoom * control_room,
53 SampleProcessor * sample_processor)
54 {
55 self->magic = FADER_MAGIC;
56 self->track = track;
57 self->control_room = control_room;
58 self->sample_processor = sample_processor;
59
60 GPtrArray * ports = g_ptr_array_new ();
61 fader_append_ports (self, ports);
62 for (size_t i = 0; i < ports->len; i++)
63 {
exporter_stringize_audio_format(AudioFormat format,bool extension)64 Port * port = g_ptr_array_index (ports, i);
65 port_init_loaded (port, self);
66 }
67 g_ptr_array_unref (ports);
68
69 fader_set_amp (
70 (void *) self, self->amp->control);
71 }
72
73 /**
74 * Appends the ports owned by fader to the given
75 * array.
76 */
77 void
78 fader_append_ports (
79 const Fader * self,
80 GPtrArray * ports)
81 {
82 #define ADD_PORT(x) \
83 if (self->x) \
84 g_ptr_array_add (ports, self->x)
85
86 ADD_PORT (amp);
87 ADD_PORT (balance);
88 ADD_PORT (mute);
89 ADD_PORT (solo);
90 ADD_PORT (listen);
91 ADD_PORT (mono_compat_enabled);
92 if (self->stereo_in)
93 {
94 ADD_PORT (stereo_in->l);
95 ADD_PORT (stereo_in->r);
96 }
97 if (self->stereo_out)
98 {
99 ADD_PORT (stereo_out->l);
100 ADD_PORT (stereo_out->r);
101 }
102 ADD_PORT (midi_in);
103 ADD_PORT (midi_out);
104
105 #undef ADD_PORT
export_audio(ExportSettings * info)106 }
107
108 /**
109 * Creates a new fader.
110 *
111 * This assumes that the channel has no plugins.
112 *
113 * @param type The FaderType.
114 * @param ch Channel, if this is a channel Fader.
115 */
116 Fader *
117 fader_new (
118 FaderType type,
119 bool passthrough,
120 Track * track,
121 ControlRoom * control_room,
122 SampleProcessor * sample_processor)
123 {
124 Fader * self = object_new (Fader);
125 self->schema_version = FADER_SCHEMA_VERSION;
126 self->magic = FADER_MAGIC;
127 self->track = track;
128 self->control_room = control_room;
129 self->sample_processor = sample_processor;
130 self->type = type;
131 self->passthrough = passthrough;
132 self->midi_mode = MIDI_FADER_MODE_VEL_MULTIPLIER;
133
134 /* set volume */
135 self->volume = 0.0f;
136 float amp = 1.f;
137 self->amp =
138 port_new_with_type_and_owner (
139 TYPE_CONTROL, FLOW_INPUT,
140 passthrough ?
141 _("Prefader Volume") : _("Fader Volume"),
142 PORT_OWNER_TYPE_FADER, self);
143 self->amp->deff = amp;
144 self->amp->minf = 0.f;
145 self->amp->maxf = 2.f;
146 port_set_control_value (
147 self->amp, amp, F_NOT_NORMALIZED,
148 F_NO_PUBLISH_EVENTS);
149 self->fader_val =
150 math_get_fader_val_from_amp (amp);
151 self->amp->id.flags |=
152 PORT_FLAG_AMPLITUDE;
153 if ((type == FADER_TYPE_AUDIO_CHANNEL ||
154 type == FADER_TYPE_MIDI_CHANNEL) &&
155 !passthrough)
156 {
157 self->amp->id.flags |=
158 PORT_FLAG_AUTOMATABLE;
159 self->amp->id.flags |=
160 PORT_FLAG_CHANNEL_FADER;
161 }
162
163 /* set phase */
164 self->phase = 0.0f;
165
166 /* set pan */
167 float balance = 0.5f;
168 self->balance =
169 port_new_with_type_and_owner (
170 TYPE_CONTROL, FLOW_INPUT,
171 passthrough ?
172 _("Prefader Balance") : _("Fader Balance"),
173 PORT_OWNER_TYPE_FADER, self);
174 port_set_control_value (
175 self->balance, balance, 0, 0);
176 self->balance->id.flags |=
177 PORT_FLAG_STEREO_BALANCE;
178 if ((type == FADER_TYPE_AUDIO_CHANNEL ||
179 type == FADER_TYPE_MIDI_CHANNEL) &&
180 !passthrough)
181 {
182 self->balance->id.flags |=
183 PORT_FLAG_AUTOMATABLE;
184 }
185
186 /* set mute */
187 self->mute =
188 port_new_with_type_and_owner (
189 TYPE_CONTROL, FLOW_INPUT,
190 passthrough ?
191 _("Prefader Mute") : _("Fader Mute"),
192 PORT_OWNER_TYPE_FADER, self);
193 control_port_set_toggled (
194 self->mute, F_NO_TOGGLE, F_NO_PUBLISH_EVENTS);
195 self->mute->id.flags |=
196 PORT_FLAG_FADER_MUTE;
197 self->mute->id.flags |=
198 PORT_FLAG_TOGGLE;
199 if ((type == FADER_TYPE_AUDIO_CHANNEL ||
200 type == FADER_TYPE_MIDI_CHANNEL) &&
201 !passthrough)
202 {
203 self->mute->id.flags |=
204 PORT_FLAG_AUTOMATABLE;
205 }
206
207 /* set solo */
208 self->solo =
209 port_new_with_type_and_owner (
210 TYPE_CONTROL, FLOW_INPUT,
211 passthrough ?
212 _("Prefader Solo") : _("Fader Solo"),
213 PORT_OWNER_TYPE_FADER, self);
214 control_port_set_toggled (
215 self->solo, F_NO_TOGGLE, F_NO_PUBLISH_EVENTS);
216 self->solo->id.flags2 |=
217 PORT_FLAG2_FADER_SOLO;
218 self->solo->id.flags |=
219 PORT_FLAG_TOGGLE;
220
221 /* set listen */
222 self->listen =
223 port_new_with_type_and_owner (
224 TYPE_CONTROL, FLOW_INPUT,
225 passthrough ?
226 _("Prefader Listen") : _("Fader Listen"),
227 PORT_OWNER_TYPE_FADER, self);
228 control_port_set_toggled (
229 self->listen, F_NO_TOGGLE, F_NO_PUBLISH_EVENTS);
230 self->listen->id.flags2 |=
231 PORT_FLAG2_FADER_LISTEN;
232 self->listen->id.flags |=
233 PORT_FLAG_TOGGLE;
234
235 /* set mono compat */
236 self->mono_compat_enabled =
237 port_new_with_type_and_owner (
238 TYPE_CONTROL, FLOW_INPUT,
239 passthrough ?
240 _("Prefader Mono Compat") :
241 _("Fader Mono Compat"),
242 PORT_OWNER_TYPE_FADER, self);
243 control_port_set_toggled (
244 self->mono_compat_enabled, F_NO_TOGGLE,
245 F_NO_PUBLISH_EVENTS);
246 self->mono_compat_enabled->id.flags2 |=
247 PORT_FLAG2_FADER_MONO_COMPAT;
248 self->mono_compat_enabled->id.flags |=
249 PORT_FLAG_TOGGLE;
250
251 if (type == FADER_TYPE_AUDIO_CHANNEL ||
252 type == FADER_TYPE_MONITOR ||
253 type == FADER_TYPE_SAMPLE_PROCESSOR)
254 {
255 const char * name = NULL;
256 if (type == FADER_TYPE_AUDIO_CHANNEL)
257 {
258 if (passthrough)
259 {
260 name = _("Ch Pre-Fader in");
261 }
262 else
263 {
264 name = _("Ch Fader in");
265 }
266 }
267 else if (type == FADER_TYPE_SAMPLE_PROCESSOR)
268 {
269 name = _("Sample Processor Fader in");
270 }
271 else
272 {
273 name = _("Monitor Fader in");
274 }
275
276 /* stereo in */
277 self->stereo_in =
278 stereo_ports_new_generic (
279 F_INPUT, name, PORT_OWNER_TYPE_FADER, self);
280
281 /* set proper owner */
282 port_set_owner (
283 self->stereo_in->l,
284 PORT_OWNER_TYPE_FADER, self);
285 port_set_owner (
286 self->stereo_in->r,
287 PORT_OWNER_TYPE_FADER, self);
288
289 if (type == FADER_TYPE_AUDIO_CHANNEL)
290 {
291 if (passthrough)
292 {
293 name = _("Ch Pre-Fader out");
294 }
295 else
296 {
297 name = _("Ch Fader out");
298 }
299 }
300 else if (type == FADER_TYPE_SAMPLE_PROCESSOR)
301 {
302 name = _("Sample Processor Fader out");
303 }
304 else
305 {
306 name = _("Monitor Fader out");
307 }
308
309 /* stereo out */
310 self->stereo_out =
311 stereo_ports_new_generic (
312 F_NOT_INPUT, name, PORT_OWNER_TYPE_FADER,
313 self);
314
315 /* set proper owner */
316 port_set_owner (
317 self->stereo_out->l,
318 PORT_OWNER_TYPE_FADER, self);
319 port_set_owner (
320 self->stereo_out->r,
321 PORT_OWNER_TYPE_FADER, self);
322 }
323
324 if (type == FADER_TYPE_MIDI_CHANNEL)
325 {
326 /* MIDI in */
327 const char * name = NULL;
328 if (passthrough)
329 {
330 name = _("Ch MIDI Pre-Fader in");
331 }
332 else
333 {
334 name = _("Ch MIDI Fader in");
335 }
336 self->midi_in =
337 port_new_with_type_and_owner (
338 TYPE_EVENT, FLOW_INPUT, name,
339 PORT_OWNER_TYPE_FADER, self);
340 self->midi_in->midi_events =
341 midi_events_new ();
342
343 /* MIDI out */
344 if (passthrough)
345 {
346 name = _("Ch MIDI Pre-Fader out");
347 }
348 else
349 {
350 name = _("Ch MIDI Fader out");
351 }
352 self->midi_out =
353 port_new_with_type_and_owner (
354 TYPE_EVENT, FLOW_OUTPUT, name,
355 PORT_OWNER_TYPE_FADER, self);
356 self->midi_out->midi_events =
357 midi_events_new ();
358 }
359
360 return self;
361 }
362
363 Fader *
364 fader_find_from_port_identifier (
365 const PortIdentifier * id)
366 {
367 PortFlags2 flag2 = id->flags2;
368 Track * tr =
369 tracklist_find_track_by_name_hash (
370 TRACKLIST, id->track_name_hash);
371 if (!tr
372 &&
373 flag2 & PORT_FLAG2_SAMPLE_PROCESSOR_TRACK)
374 {
375 tr =
376 tracklist_find_track_by_name_hash (
377 SAMPLE_PROCESSOR->tracklist,
378 id->track_name_hash);
379 }
380 if (flag2 & PORT_FLAG2_MONITOR_FADER)
381 return MONITOR_FADER;
382 else if (flag2 &
383 PORT_FLAG2_SAMPLE_PROCESSOR_FADER)
384 return SAMPLE_PROCESSOR->fader;
385 else if (flag2 & PORT_FLAG2_PREFADER)
386 {
387 g_return_val_if_fail (tr, NULL);
388 g_return_val_if_fail (tr->channel, NULL);
389 return tr->channel->prefader;
390 }
391 else if (flag2 & PORT_FLAG2_POSTFADER)
392 {
393 g_return_val_if_fail (tr, NULL);
394 g_return_val_if_fail (tr->channel, NULL);
395 return tr->channel->fader;
396 }
397
398 g_return_val_if_reached (NULL);
399 }
400
401 /**
402 * Sets track muted and optionally adds the action
403 * to the undo stack.
404 */
405 void
406 fader_set_muted (
407 Fader * self,
408 bool mute,
409 bool fire_events)
410 {
411 Track * track = fader_get_track (self);
412 g_return_if_fail (track);
413
414 control_port_set_toggled (
415 self->mute, mute, fire_events);
416
417 if (fire_events)
418 {
419 EVENTS_PUSH (
420 ET_TRACK_STATE_CHANGED, track);
421 }
422 }
423
424 /**
425 * Returns if the fader is muted.
426 */
427 bool
428 fader_get_muted (
429 const Fader * const self)
430 {
431 return control_port_is_toggled (self->mute);
432 }
433
434 /**
435 * Returns if the track is soloed.
436 */
437 bool
438 fader_get_soloed (
439 const Fader * const self)
440 {
441 return control_port_is_toggled (self->solo);
442 }
443
444 /**
445 * Returns whether the fader is not soloed on its
446 * own but its direct out (or its direct out's direct
447 * out, etc.) or its child (or its children's child,
448 * etc.) is soloed.
449 */
450 bool
451 fader_get_implied_soloed (
452 Fader * self)
453 {
454 /* only check channel faders */
455 if ((self->type != FADER_TYPE_AUDIO_CHANNEL &&
456 self->type != FADER_TYPE_MIDI_CHANNEL) ||
457 self->passthrough ||
458 control_port_is_toggled (self->solo))
459 {
460 return false;
461 }
462
463 Track * track = fader_get_track (self);
464 g_return_val_if_fail (track, false);
465
466 /* check parents */
467 Track * out_track = track;
468 do
469 {
470 if (track_type_has_channel (out_track->type))
471 {
472 out_track =
473 channel_get_output_track (
474 out_track->channel);
475 if (out_track &&
476 track_get_soloed (out_track))
477 {
478 return true;
479 }
480 }
481 else
482 {
483 out_track = NULL;
484 }
485 } while (out_track);
486
487 /* check children */
488 if (TRACK_CAN_BE_GROUP_TARGET (track))
489 {
490 for (int i = 0; i < track->num_children; i++)
491 {
492 Track * child_track =
493 tracklist_find_track_by_name_hash (
494 TRACKLIST, track->children[i]);
495 if (child_track &&
496 (track_get_soloed (child_track) ||
497 track_get_implied_soloed (
498 child_track)))
499 {
500 return true;
501 }
502 }
503 }
504
505 return false;
506 }
507
508 /**
509 * Sets track soloed and optionally adds the action
510 * to the undo stack.
511 */
512 void
513 fader_set_soloed (
514 Fader * self,
515 bool solo,
516 bool fire_events)
517 {
518 Track * track = fader_get_track (self);
519 g_return_if_fail (track);
520
521 control_port_set_toggled (
522 self->solo, solo, fire_events);
523
524 if (fire_events)
525 {
526 EVENTS_PUSH (
527 ET_TRACK_STATE_CHANGED, track);
528 }
529 }
530
531 /**
532 * Sets fader listen and optionally adds the action
533 * to the undo stack.
534 */
535 void
536 fader_set_listened (
537 Fader * self,
538 bool listen,
539 bool fire_events)
540 {
541 Track * track = fader_get_track (self);
542 g_return_if_fail (track);
543
544 control_port_set_toggled (
545 self->listen, listen, fire_events);
546
547 if (fire_events)
548 {
549 EVENTS_PUSH (
550 ET_TRACK_STATE_CHANGED, track);
551 }
552 }
553
554 void
555 fader_update_volume_and_fader_val (
export_midi(ExportSettings * info)556 Fader * self)
557 {
558 /* calculate volume */
559 self->volume =
560 math_amp_to_dbfs (self->amp->control);
561
562 self->fader_val =
563 math_get_fader_val_from_amp (self->amp->control);
564 }
565
566 /**
567 * Sets the amplitude of the fader. (0.0 to 2.0)
568 */
569 void
570 fader_set_amp (void * _fader, float amp)
571 {
572 Fader * self = (Fader *) _fader;
573 g_return_if_fail (IS_FADER (self));
574
575 port_set_control_value (
576 self->amp, amp, F_NOT_NORMALIZED,
577 F_NO_PUBLISH_EVENTS);
578
579 fader_update_volume_and_fader_val (self);
580 }
581
582 /**
583 * Sets the amp value with an undoable action.
584 *
585 * @param skip_if_equal Whether to skip the action
586 * if the amp hasn't changed.
587 */
588 void
589 fader_set_amp_with_action (
590 Fader * self,
591 float amp_from,
592 float amp_to,
593 bool skip_if_equal)
594 {
595 Track * track = fader_get_track (self);
596 bool is_equal =
597 math_floats_equal_epsilon (
598 amp_from, amp_to,
599 0.0001f);
600 if (!skip_if_equal || !is_equal)
601 {
602 GError * err = NULL;
603 bool ret =
604 tracklist_selections_action_perform_edit_single_float (
605 EDIT_TRACK_ACTION_TYPE_VOLUME,
606 track, amp_from, amp_to, true, &err);
607 if (!ret)
608 {
609 HANDLE_ERROR (
610 err, "%s",
611 _("Failed to change volume"));
612 }
export_settings_default()613 }
614 }
615
616 /**
617 * Adds (or subtracts if negative) to the amplitude
618 * of the fader (clamped at 0.0 to 2.0).
619 */
620 void
621 fader_add_amp (
622 void * _self,
623 sample_t amp)
624 {
625 Fader * self = (Fader *) _self;
626
627 float fader_amp = fader_get_amp (self);
628 fader_amp =
629 CLAMP (
630 fader_amp + amp, self->amp->minf,
631 self->amp->maxf);
632 fader_set_amp (self, fader_amp);
633
634 fader_update_volume_and_fader_val (self);
635 }
636
637 float
638 fader_get_amp (void * _self)
639 {
640 Fader * self = (Fader *) _self;
641 return self->amp->control;
642 }
643
644 void
645 fader_set_midi_mode (
646 Fader * self,
647 MidiFaderMode mode,
648 bool with_action,
649 bool fire_events)
650 {
651 if (with_action)
652 {
653 Track * track = fader_get_track (self);
654 g_return_if_fail (
655 IS_TRACK_AND_NONNULL (track));
656
657 GError * err = NULL;
658 bool ret =
659 tracklist_selections_action_perform_edit_single_int (
660 EDIT_TRACK_ACTION_TYPE_MIDI_FADER_MODE,
661 track, mode, F_NOT_ALREADY_EDITED, &err);
662 if (!ret)
663 {
664 HANDLE_ERROR (
665 err, "%s",
666 _("Failed to set MIDI mode"));
667 }
668 }
669 else
670 {
671 self->midi_mode = mode;
672 }
673
674 if (fire_events)
675 {
676 /* TODO */
677 }
678 }
679
680 /**
681 * Gets whether mono compatibility is enabled.
682 */
683 bool
684 fader_get_mono_compat_enabled (
685 Fader * self)
686 {
687 return
688 control_port_is_toggled (
689 self->mono_compat_enabled);
690 }
691
692 /**
693 * Sets whether mono compatibility is enabled.
694 */
695 void
696 fader_set_mono_compat_enabled (
697 Fader * self,
698 bool enabled,
699 bool fire_events)
700 {
701 control_port_set_toggled (
702 self->mono_compat_enabled, enabled,
703 fire_events);
704
705 if (self->type == FADER_TYPE_AUDIO_CHANNEL ||
706 self->type == FADER_TYPE_MIDI_CHANNEL)
707 {
708 Track * track = fader_get_track (self);
709 g_return_if_fail (track);
710 if (fire_events)
711 {
712 EVENTS_PUSH (
713 ET_TRACK_STATE_CHANGED, track);
714 }
715 }
716 }
717
718 float
719 fader_get_fader_val (
720 void * self)
721 {
722 return ((Fader *) self)->fader_val;
723 }
724
725 float
exporter_generic_export_thread(void * data)726 fader_get_default_fader_val (
727 void * self)
728 {
729 Fader * fader = (Fader *) self;
730 return
731 math_get_fader_val_from_amp (
732 fader->amp->deff);
733 }
734
735 void
736 fader_db_string_getter (
737 void * obj,
export_settings_free_members(ExportSettings * self)738 char * buf)
739 {
740 Fader * fader = (Fader *) obj;
741
742 sprintf (
743 buf, "%.1f",
744 math_amp_to_dbfs (fader->amp->control));
745 }
746
747 /**
export_settings_free(ExportSettings * self)748 * Sets the fader levels from a normalized value
749 * 0.0-1.0 (such as in widgets).
750 */
751 void
752 fader_set_fader_val (
753 Fader * self,
754 float fader_val)
755 {
756 self->fader_val = fader_val;
757 float fader_amp =
758 math_get_amp_val_from_fader (fader_val);
759 fader_amp =
760 CLAMP (
761 fader_amp, self->amp->minf, self->amp->maxf);
762 fader_set_amp (self, fader_amp);
763 self->volume = math_amp_to_dbfs (fader_amp);
764
765 if (self == MONITOR_FADER)
766 {
767 g_settings_set_double (
768 S_MONITOR, "monitor-vol",
769 (double) fader_amp);
770 }
771 else if (self == CONTROL_ROOM->mute_fader)
772 {
773 g_settings_set_double (
774 S_MONITOR, "mute-vol",
775 (double) fader_amp);
776 }
777 else if (self == CONTROL_ROOM->listen_fader)
778 {
779 g_settings_set_double (
780 S_MONITOR, "listen-vol",
781 (double) fader_amp);
782 }
783 else if (self == CONTROL_ROOM->dim_fader)
784 {
785 g_settings_set_double (
786 S_MONITOR, "dim-vol",
787 (double) fader_amp);
788 }
789 }
790
791 Channel *
792 fader_get_channel (
793 Fader * self)
794 {
795 Track * track = fader_get_track (self);
796 g_return_val_if_fail (
797 IS_TRACK_AND_NONNULL (track), NULL);
798
799 Channel * ch =
800 track_get_channel (track);
801 g_return_val_if_fail (
802 IS_CHANNEL_AND_NONNULL (ch), NULL);
803
804 return ch;
805 }
806
807 Track *
808 fader_get_track (
809 Fader * self)
810 {
811 g_return_val_if_fail (
812 IS_TRACK (self->track), NULL);
813
814 return self->track;
815 }
816
817 /**
818 * Clears all buffers.
819 */
820 void
821 fader_clear_buffers (
822 Fader * self)
823 {
824 switch (self->type)
825 {
826 case FADER_TYPE_AUDIO_CHANNEL:
827 case FADER_TYPE_MONITOR:
828 case FADER_TYPE_SAMPLE_PROCESSOR:
829 port_clear_buffer (self->stereo_in->l);
830 port_clear_buffer (self->stereo_in->r);
831 port_clear_buffer (self->stereo_out->l);
832 port_clear_buffer (self->stereo_out->r);
833 break;
834 case FADER_TYPE_MIDI_CHANNEL:
835 port_clear_buffer (self->midi_in);
836 port_clear_buffer (self->midi_out);
837 break;
838 default:
839 break;
exporter_export(ExportSettings * info)840 }
841 }
842
843 /**
844 * Disconnects all ports connected to the fader.
845 */
846 void
847 fader_disconnect_all (
848 Fader * self)
849 {
850 switch (self->type)
851 {
852 case FADER_TYPE_AUDIO_CHANNEL:
853 case FADER_TYPE_MONITOR:
854 case FADER_TYPE_SAMPLE_PROCESSOR:
855 port_disconnect_all (self->stereo_in->l);
856 port_disconnect_all (self->stereo_in->r);
857 port_disconnect_all (self->stereo_out->l);
858 port_disconnect_all (self->stereo_out->r);
859 break;
860 case FADER_TYPE_MIDI_CHANNEL:
861 port_disconnect_all (self->midi_in);
862 port_disconnect_all (self->midi_out);
863 break;
864 default:
865 break;
866 }
867
868 port_disconnect_all (self->amp);
869 port_disconnect_all (self->balance);
870 port_disconnect_all (self->mute);
871 port_disconnect_all (self->solo);
872 port_disconnect_all (self->listen);
873 port_disconnect_all (self->mono_compat_enabled);
874 }
875
876 /**
877 * Copy the fader values from source to dest.
878 *
879 * Used when cloning channels.
880 */
881 void
882 fader_copy_values (
883 Fader * src,
884 Fader * dest)
885 {
886 dest->volume = src->volume;
887 dest->phase = src->phase;
888 dest->fader_val = src->fader_val;
889 dest->amp->control = src->amp->control;
890 dest->balance->control = src->balance->control;
891 dest->mute->control = src->mute->control;
892 dest->solo->control = src->solo->control;
893 dest->listen->control = src->listen->control;
894 dest->mono_compat_enabled->control =
895 src->mono_compat_enabled->control;
896 }
897
898 #if 0
899 /**
900 * Updates the track pos of the fader.
901 */
902 void
903 fader_update_track_pos (
904 Fader * self,
905 int pos)
906 {
907 self->track_pos = pos;
908
909 if (self->amp)
910 {
911 port_update_track_pos (self->amp, NULL, pos);
912 }
913 if (self->balance)
914 {
915 port_update_track_pos (
916 self->balance, NULL, pos);
917 }
918 if (self->mute)
919 {
920 port_update_track_pos (self->mute, NULL, pos);
921 }
922 if (self->solo)
923 {
924 port_update_track_pos (self->solo, NULL, pos);
925 }
926 if (self->listen)
927 {
928 port_update_track_pos (
929 self->listen, NULL, pos);
930 }
931 if (self->mono_compat_enabled)
932 {
933 port_update_track_pos (
934 self->mono_compat_enabled, NULL, pos);
935 }
936 if (self->stereo_in)
937 {
938 port_update_track_pos (
939 self->stereo_in->l, NULL, pos);
940 port_update_track_pos (
941 self->stereo_in->r, NULL, pos);
942 }
943 if (self->stereo_out)
944 {
945 port_update_track_pos (
946 self->stereo_out->l, NULL, pos);
947 port_update_track_pos (
948 self->stereo_out->r, NULL, pos);
949 }
950 if (self->midi_in)
951 {
952 port_update_track_pos (
953 self->midi_in, NULL, pos);
954 }
955 if (self->midi_out)
956 {
957 port_update_track_pos (
958 self->midi_out, NULL, pos);
959 }
960 }
961 #endif
962
963 /**
964 * Process the Fader.
965 *
966 * @param g_start_frames Global frames.
967 * @param start_frame The local offset in this
968 * cycle.
969 * @param nframes The number of frames to process.
970 */
971 void
972 fader_process (
973 Fader * self,
974 long g_start_frames,
975 nframes_t start_frame,
976 const nframes_t nframes)
977 {
978 if (ZRYTHM_TESTING)
979 {
980 #if 0
981 g_debug (
982 "%s: g_start %ld, start frame %u, nframes "
983 "%u",
984 __func__, g_start_frames, start_frame,
985 nframes);
986 #endif
987 }
988
989 float pan =
990 port_get_control_value (self->balance, 0);
991 float amp =
992 port_get_control_value (self->amp, 0);
993
994 Track * track = NULL;
995 if (self->type == FADER_TYPE_AUDIO_CHANNEL)
996 {
997 track = fader_get_track (self);
998 g_return_if_fail (
999 IS_TRACK_AND_NONNULL (track));
1000 }
1001
1002 bool effectively_muted = false;
1003 if (!self->passthrough)
1004 {
1005 /* muted if any of the following is true:
1006 * 1. muted
1007 * 2. other track(s) is soloed and this
1008 * isn't
1009 * 3. bounce mode and the track is set
1010 * to BOUNCE_OFF */
1011 effectively_muted =
1012 fader_get_muted (self)
1013 ||
1014 ((self->type == FADER_TYPE_AUDIO_CHANNEL
1015 ||
1016 self->type == FADER_TYPE_MIDI_CHANNEL)
1017 && tracklist_has_soloed (TRACKLIST)
1018 && !fader_get_soloed (self)
1019 && !fader_get_implied_soloed (self)
1020 && track != P_MASTER_TRACK)
1021 ||
1022 (AUDIO_ENGINE->bounce_mode == BOUNCE_ON
1023 &&
1024 (self->type == FADER_TYPE_AUDIO_CHANNEL
1025 || self->type == FADER_TYPE_MIDI_CHANNEL)
1026 && track
1027 /*track->out_signal_type == TYPE_AUDIO &&*/
1028 && track->type != TRACK_TYPE_MASTER
1029 && !track->bounce);
1030
1031 #if 0
1032 if (ZRYTHM_TESTING && track &&
1033 (self->type == FADER_TYPE_AUDIO_CHANNEL ||
1034 self->type == FADER_TYPE_MIDI_CHANNEL))
1035 {
1036 g_message ("%s soloed %d implied soloed %d effectively muted %d",
1037 track->name, fader_get_soloed (self),
1038 fader_get_implied_soloed (self),
1039 effectively_muted);
1040 }
1041 #endif
1042 }
1043
1044 if (self->type == FADER_TYPE_AUDIO_CHANNEL ||
1045 self->type == FADER_TYPE_MONITOR ||
1046 self->type == FADER_TYPE_SAMPLE_PROCESSOR)
1047 {
1048 /* copy the input to output */
1049 dsp_copy (
1050 &self->stereo_out->l->buf[start_frame],
1051 &self->stereo_in->l->buf[start_frame],
1052 nframes);
1053 dsp_copy (
1054 &self->stereo_out->r->buf[start_frame],
1055 &self->stereo_in->r->buf[start_frame],
1056 nframes);
1057
1058 /* if prefader */
1059 if (self->passthrough)
1060 {
1061
1062 /* if track frozen and transport is
1063 * rolling */
1064 if (track && track->frozen &&
1065 TRANSPORT_IS_ROLLING)
1066 {
1067 /* get audio from clip */
1068 AudioClip * clip =
1069 audio_pool_get_clip (
1070 AUDIO_POOL, track->pool_id);
1071 stereo_ports_fill_from_clip (
1072 self->stereo_out, clip,
1073 g_start_frames, start_frame,
1074 nframes);
1075 }
1076 }
1077 else /* not prefader */
1078 {
1079 /* if monitor */
1080 if (self->type == FADER_TYPE_MONITOR)
1081 {
1082 float dim_amp =
1083 fader_get_amp (
1084 CONTROL_ROOM->dim_fader);
1085
1086 /* if have listened tracks */
1087 if (tracklist_has_listened (
1088 TRACKLIST))
1089 {
1090 /* dim signal */
1091 dsp_mul_k2 (
1092 &self->stereo_out->l->buf[
1093 start_frame],
1094 dim_amp, nframes);
1095 dsp_mul_k2 (
1096 &self->stereo_out->r->buf[
1097 start_frame],
1098 dim_amp, nframes);
1099
1100 /* add listened signal */
1101 /* TODO add "listen" buffer
1102 * on fader struct and add
1103 * listened tracks to it during
1104 * processing instead of looping
1105 * here */
1106 float listen_amp =
1107 fader_get_amp (
1108 CONTROL_ROOM->listen_fader);
1109 for (int i = 0;
1110 i < TRACKLIST->num_tracks;
1111 i++)
1112 {
1113 Track * t =
1114 TRACKLIST->tracks[i];
1115
1116 if (track_type_has_channel (
1117 t->type) &&
1118 t->out_signal_type ==
1119 TYPE_AUDIO &&
1120 track_get_listened (t))
1121 {
1122 Fader * f =
1123 track_get_fader (
1124 t, true);
1125 dsp_mix2 (
1126 &self->stereo_out->l->buf[
1127 start_frame],
1128 &f->stereo_out->l->buf[
1129 start_frame],
1130 1.f, listen_amp,
1131 nframes);
1132 dsp_mix2 (
1133 &self->stereo_out->r->buf[
1134 start_frame],
1135 &f->stereo_out->r->buf[
1136 start_frame],
1137 1.f, listen_amp,
1138 nframes);
1139 }
1140 }
1141 }
1142
1143 /* apply dim if enabled */
1144 if (CONTROL_ROOM->dim_output)
1145 {
1146 dsp_mul_k2 (
1147 &self->stereo_out->l->buf[
1148 start_frame],
1149 dim_amp, nframes);
1150 dsp_mul_k2 (
1151 &self->stereo_out->r->buf[
1152 start_frame],
1153 dim_amp, nframes);
1154 }
1155 }
1156
1157 float calc_l, calc_r;
1158 balance_control_get_calc_lr (
1159 BALANCE_CONTROL_ALGORITHM_LINEAR,
1160 pan, &calc_l, &calc_r);
1161
1162 /* apply fader and pan */
1163 dsp_mul_k2 (
1164 &self->stereo_out->l->buf[
1165 start_frame],
1166 amp * calc_l, nframes);
1167 dsp_mul_k2 (
1168 &self->stereo_out->r->buf[
1169 start_frame],
1170 amp * calc_r, nframes);
1171
1172 /* make mono if mono compat
1173 * enabled. equal amplitude is
1174 * more suitable for mono
1175 * compatibility checking */
1176 /* for reference:
1177 * equal power sum =
1178 * (L+R) * 0.7079 (-3dB)
1179 * equal amplitude sum =
1180 * (L+R) /2 (-6.02dB) */
1181 if (control_port_is_toggled (
1182 self->mono_compat_enabled))
1183 {
1184 dsp_make_mono (
1185 &self->stereo_out->l->buf[
1186 start_frame],
1187 &self->stereo_out->r->buf[
1188 start_frame], nframes,
1189 false);
1190 }
1191
1192 if (effectively_muted)
1193 {
1194 /* apply mute level */
1195 float mute_amp =
1196 fader_get_amp (
1197 CONTROL_ROOM->mute_fader);
1198 if (mute_amp < 0.00001f)
1199 {
1200 dsp_fill (
1201 &self->stereo_out->l->buf[
1202 start_frame],
1203 AUDIO_ENGINE->
1204 denormal_prevention_val,
1205 nframes);
1206 dsp_fill (
1207 &self->stereo_out->r->buf[
1208 start_frame],
1209 AUDIO_ENGINE->
1210 denormal_prevention_val,
1211 nframes);
1212 }
1213 else
1214 {
1215 dsp_mul_k2 (
1216 &self->stereo_out->l->buf[
1217 start_frame],
1218 mute_amp, nframes);
1219 dsp_mul_k2 (
1220 &self->stereo_out->r->buf[
1221 start_frame],
1222 mute_amp, nframes);
1223 }
1224 }
1225
1226 /* if master or monitor or sample
1227 * processor, hard limit the output */
1228 if ((self->type ==
1229 FADER_TYPE_AUDIO_CHANNEL &&
1230 track &&
1231 track->type == TRACK_TYPE_MASTER) ||
1232 self->type == FADER_TYPE_MONITOR ||
1233 self->type ==
1234 FADER_TYPE_SAMPLE_PROCESSOR)
1235 {
1236 dsp_limit1 (
1237 &self->stereo_out->l->buf[
1238 start_frame],
1239 - 2.f, 2.f, nframes);
1240 dsp_limit1 (
1241 &self->stereo_out->r->buf[
1242 start_frame],
1243 - 2.f, 2.f, nframes);
1244 }
1245 } /* fi not prefader */
1246 } /* fi monitor/audio fader */
1247 else if (self->type == FADER_TYPE_MIDI_CHANNEL)
1248 {
1249 if (!effectively_muted)
1250 {
1251 midi_events_append (
1252 self->midi_in->midi_events,
1253 self->midi_out->midi_events,
1254 start_frame, nframes, F_NOT_QUEUED);
1255
1256 /* if not prefader, also apply volume
1257 * changes */
1258 if (!self->passthrough)
1259 {
1260 int num_events =
1261 self->midi_out->midi_events->
1262 num_events;
1263 for (int i = 0; i < num_events; i++)
1264 {
1265 MidiEvent * ev =
1266 &self->midi_out->midi_events->
1267 events[i];
1268
1269 if (self->midi_mode ==
1270 MIDI_FADER_MODE_VEL_MULTIPLIER &&
1271 ev->type ==
1272 MIDI_EVENT_TYPE_NOTE_ON)
1273 {
1274 int new_vel =
1275 (int)
1276 ((float) ev->velocity *
1277 self->amp->control);
1278 midi_event_set_velocity (
1279 ev,
1280 (midi_byte_t)
1281 CLAMP (new_vel, 0, 127));
1282 }
1283 }
1284
1285 if (self->midi_mode ==
1286 MIDI_FADER_MODE_CC_VOLUME &&
1287 !math_floats_equal (
1288 self->last_cc_volume,
1289 self->amp->control))
1290 {
1291 /* TODO add volume event on each
1292 * channel */
1293 }
1294 }
1295 }
1296 }
1297
1298 if (ZRYTHM_TESTING)
1299 {
1300 #if 0
1301 g_debug ("%s: done", __func__);
1302 #endif
1303 }
1304 }
1305
1306 Fader *
1307 fader_clone (
1308 const Fader * src)
1309 {
1310 Fader * self = object_new (Fader);
1311 self->schema_version = FADER_SCHEMA_VERSION;
1312
1313 self->type = src->type;
1314 self->volume = src->volume;
1315 self->amp = port_clone (src->amp);
1316 self->phase = src->phase;
1317 self->balance = port_clone (src->balance);
1318 self->mute = port_clone (src->mute);
1319 self->solo = port_clone (src->solo);
1320 self->listen = port_clone (src->listen);
1321 self->mono_compat_enabled =
1322 port_clone (src->mono_compat_enabled);
1323 if (src->midi_in)
1324 self->midi_in = port_clone (src->midi_in);
1325 if (src->midi_out)
1326 self->midi_out = port_clone (src->midi_out);
1327 if (src->stereo_in)
1328 self->stereo_in =
1329 stereo_ports_clone (src->stereo_in);
1330 if (src->stereo_out)
1331 self->stereo_out =
1332 stereo_ports_clone (src->stereo_out);
1333 self->midi_mode = src->midi_mode;
1334 self->passthrough = src->passthrough;
1335
1336 return self;
1337 }
1338
1339 /**
1340 * Frees the fader members.
1341 */
1342 void
1343 fader_free (
1344 Fader * self)
1345 {
1346 #define DISCONNECT_AND_FREE(x) \
1347 object_free_w_func_and_null ( \
1348 port_free, x)
1349
1350 DISCONNECT_AND_FREE (self->amp);
1351 DISCONNECT_AND_FREE (self->balance);
1352 DISCONNECT_AND_FREE (self->mute);
1353 DISCONNECT_AND_FREE (self->solo);
1354 DISCONNECT_AND_FREE (self->listen);
1355 DISCONNECT_AND_FREE (self->mono_compat_enabled);
1356
1357 #define DISCONNECT_AND_FREE_STEREO(x) \
1358 object_free_w_func_and_null ( \
1359 stereo_ports_free, x)
1360
1361 DISCONNECT_AND_FREE_STEREO (self->stereo_in);
1362 DISCONNECT_AND_FREE_STEREO (self->stereo_out);
1363
1364 DISCONNECT_AND_FREE (self->midi_in);
1365 DISCONNECT_AND_FREE (self->midi_out);
1366
1367 #undef DISCONNECT_AND_FREE
1368 #undef DISCONNECT_AND_FREE_STEREO
1369
1370 object_zero_and_free (self);
1371 }
1372