Refactor one client patching

jack_client_patching.py

@@ -12,32 +12,30 @@ def __init__(self, jackClient, dry_run):
         self.connections = []
         self.dry_run = dry_run
 
-    def disconnect_all(self, my_port):
-        """disconnect everything from a port"""
-        if self.dry_run:
-            print("Disconnect all ports (except jack_capture) from", my_port)
-            return
-        send_ports = self.jackClient.get_all_connections(my_port)
-        for send_port in send_ports:
-            # do not disconnect from jack_capture ports
-            # they do auto-reconnect, but the disconnection is not reliable
-            if send_port.name.startswith("jack_capture"):
-                continue
-            print("disconnect", my_port.name, "from", send_port.name)
-            try:
-                self.jackClient.disconnect(my_port, send_port)
-            except Exception as e:
-                print("error disconnecting, trying the other way round!", e)
-                print("disconnect", send_port.name, "from", my_port.name)
-                self.jackClient.disconnect(send_port, my_port)
+    def _jacktrip_receive(self, port):
+        return port + ":receive_.*"
 
-    def connect_ports(self, receive, send):
+    def _jacktrip_send(self, port):
+        return port + ":send_.*"
+
+    def _ladspa_receive(self, port):
+        return port + ":Output.*"
+
+    def _ladspa_send(self, port):
+        return port + ":Input.*"
+
+    def _darkice_send(self, port):
+        return port + ".*"
+
+    def _mpg123_send(self, port):
+        return port + ".*"
+
+    def _connect_ports(self, receive, send):
+        """connect the jack ports of stereo or mono clients"""
 
         receive_ports = self.jackClient.get_ports(receive)
         send_ports = self.jackClient.get_ports(send)
 
-        print("Connecting", receive_ports, "to", send_ports)
-
         if (len(receive_ports) == 0) or (len(send_ports) == 0):
             print("Not connecting, both clients must have valid ports")
             return
@@ -47,138 +45,171 @@ def connect_ports(self, receive, send):
 
         try:
             # we always connect receive_port[0] to send_port[0]
+            print("Connecting", receive_ports[0].name, "to", send_ports[0].name)
             self.jackClient.connect(receive_ports[0], send_ports[0])
             if receive_stereo and send_stereo:
-                print("Connecting Stereo receive to Stereo send")
+                print("Connecting", receive_ports[1].name, "to", send_ports[1].name)
                 self.jackClient.connect(receive_ports[1], send_ports[1])
             elif receive_stereo and not send_stereo:
-                print("Connecting Stereo receive to Mono send")
+                print("Connecting", receive_ports[1].name, "to", send_ports[0].name)
                 self.jackClient.connect(receive_ports[1], send_ports[0])
             elif not receive_stereo and send_stereo:
-                print("Connecting Mono receive to Stereo send")
+                print("Connecting", receive_ports[0].name, "to", send_ports[1].name)
                 self.jackClient.connect(receive_ports[0], send_ports[1])
-            else:
-                print("Connecting Mono receive to Mono send")
+
         except Exception as e:
             print("Error connecting ports:", e)
 
-    def jacktrip_receive(self, port):
-        return port + ":receive_.*"
+    def _set_darkice_connections_one_client(self, jacktrip_ports, darkice):
 
-    def jacktrip_send(self, port):
-        return port + ":send_.*"
+        jacktrip_receive = self._jacktrip_receive(jacktrip_ports[0])
+        darkice_send = self._darkice_send(darkice)
 
-    def ladspa_receive(self, port):
-        return port + ":Output.*"
+        self.connections.append((jacktrip_receive, darkice_send))
 
-    def ladspa_send(self, port):
-        return port + ":Input.*"
+    def _set_lounge_music_connections_one_client(
+        self, jacktrip_ports, darkice, lounge_music
+    ):
+        lounge_music = self._mpg123_send(lounge_music)
+        darkice_send = self._darkice_send(darkice)
+        jacktrip_send = self._jacktrip_send(jacktrip_ports[0])
 
-    def darkice_send(self, port):
-        return port + ".*"
+        self.connections.append((lounge_music, darkice_send))
+        self.connections.append((lounge_music, jacktrip_send))
 
-    def set_darkice_connections(self, ladspa_ports, darkice):
-        """append darkice connections to connections list"""
-        for ladspa in ladspa_ports:
-            self.connections.append(
-                (self.ladspa_receive(ladspa), self.darkice_send(darkice))
-            )
+    def _set_connections_one_client(self, jacktrip_ports):
+
+        jacktrip_receive = self._jacktrip_receive(jacktrip_ports[0])
+        jacktrip_send = self._jacktrip_send(jacktrip_ports[0])
 
-    def set_connections_2_clients(self, jacktrip_ports, ladspa_ports):
+        self.connections.append((jacktrip_receive, jacktrip_send))
 
-        jacktrip_receive_1 = self.jacktrip_receive(jacktrip_ports[0])
-        jacktrip_receive_2 = self.jacktrip_receive(jacktrip_ports[1])
-        jacktrip_send_1 = self.jacktrip_send(jacktrip_ports[0])
-        jacktrip_send_2 = self.jacktrip_send(jacktrip_ports[1])
+    def _set_connections_two_clients(self, jacktrip_ports, ladspa_ports):
+
+        jacktrip_receive_1 = self._jacktrip_receive(jacktrip_ports[0])
+        jacktrip_receive_2 = self._jacktrip_receive(jacktrip_ports[1])
+        jacktrip_send_1 = self._jacktrip_send(jacktrip_ports[0])
+        jacktrip_send_2 = self._jacktrip_send(jacktrip_ports[1])
 
         self.connections.append((jacktrip_receive_1, jacktrip_send_2))
         self.connections.append((jacktrip_receive_2, jacktrip_send_1))
-        self.connections.append((jacktrip_receive_1, self.ladspa_send(ladspa_ports[0])))
-        self.connections.append((jacktrip_receive_2, self.ladspa_send(ladspa_ports[1])))
+        self.connections.append(
+            (jacktrip_receive_1, self._ladspa_send(ladspa_ports[0]))
+        )
+        self.connections.append(
+            (jacktrip_receive_2, self._ladspa_send(ladspa_ports[1]))
+        )
+
+    def _set_connections_three_clients(self, jacktrip_ports, ladspa_ports):
+
+        jacktrip_receive_1 = self._jacktrip_receive(jacktrip_ports[0])
+        jacktrip_receive_2 = self._jacktrip_receive(jacktrip_ports[1])
+        jacktrip_receive_3 = self._jacktrip_receive(jacktrip_ports[2])
+        jacktrip_send_1 = self._jacktrip_send(jacktrip_ports[0])
+        jacktrip_send_2 = self._jacktrip_send(jacktrip_ports[1])
+        jacktrip_send_3 = self._jacktrip_send(jacktrip_ports[2])
 
-    def set_connections_3_clients(self, jacktrip_ports, ladspa_ports):
+        for ladspa_port in ladspa_ports[0:3]:
+            self.connections.append(
+                (jacktrip_receive_1, self._ladspa_send(ladspa_port))
+            )
 
-        jacktrip_receive_1 = self.jacktrip_receive(jacktrip_ports[0])
-        jacktrip_receive_2 = self.jacktrip_receive(jacktrip_ports[1])
-        jacktrip_receive_3 = self.jacktrip_receive(jacktrip_ports[2])
-        jacktrip_send_1 = self.jacktrip_send(jacktrip_ports[0])
-        jacktrip_send_2 = self.jacktrip_send(jacktrip_ports[1])
-        jacktrip_send_3 = self.jacktrip_send(jacktrip_ports[2])
+        self.connections.append(
+            (jacktrip_receive_2, self._ladspa_send(ladspa_ports[3]))
+        )
+        self.connections.append(
+            (jacktrip_receive_3, self._ladspa_send(ladspa_ports[4]))
+        )
+
+        self.connections.append(
+            (self._ladspa_receive(ladspa_ports[3]), jacktrip_send_1)
+        )
+        self.connections.append(
+            (self._ladspa_receive(ladspa_ports[4]), jacktrip_send_1)
+        )
+
+        self.connections.append(
+            (self._ladspa_receive(ladspa_ports[1]), jacktrip_send_2)
+        )
+        self.connections.append(
+            (self._ladspa_receive(ladspa_ports[4]), jacktrip_send_2)
+        )
+
+        self.connections.append(
+            (self._ladspa_receive(ladspa_ports[3]), jacktrip_send_3)
+        )
+        self.connections.append(
+            (self._ladspa_receive(ladspa_ports[2]), jacktrip_send_3)
+        )
 
-        for ladspa_port in ladspa_ports[0:3]:
-            self.connections.append((jacktrip_receive_1, self.ladspa_send(ladspa_port)))
+    def disconnect_all(self, my_port):
+        """disconnect everything from a port"""
+        if self.dry_run:
+            print("Disconnect all ports (except jack_capture) from", my_port)
+            return
+        send_ports = self.jackClient.get_all_connections(my_port)
+        for send_port in send_ports:
+            # do not disconnect from jack_capture ports
+            # they do auto-reconnect, but the disconnection is not reliable
+            if send_port.name.startswith("jack_capture"):
+                continue
+            print("disconnect", my_port.name, "from", send_port.name)
+            try:
+                self.jackClient.disconnect(my_port, send_port)
+            except Exception as e:
+                print("error disconnecting, trying the other way round!", e)
+                print("disconnect", send_port.name, "from", my_port.name)
+                self.jackClient.disconnect(send_port, my_port)
+
+    def set_lounge_music_connections(self, jacktrip_ports, darkice, lounge_music):
+
+        if len(jacktrip_ports) == 1:
+            self._set_lounge_music_connections_one_client(
+                jacktrip_ports, darkice, lounge_music
+            )
+            return
 
-        self.connections.append((jacktrip_receive_2, self.ladspa_send(ladspa_ports[3])))
-        self.connections.append((jacktrip_receive_3, self.ladspa_send(ladspa_ports[4])))
+    def set_darkice_connections(self, ladspa_ports, darkice, jacktrip_ports=[]):
 
-        self.connections.append((self.ladspa_receive(ladspa_ports[3]), jacktrip_send_1))
-        self.connections.append((self.ladspa_receive(ladspa_ports[4]), jacktrip_send_1))
+        if len(jacktrip_ports) == 1:
+            self._set_darkice_connections_one_client(jacktrip_ports, darkice)
+            return
 
-        self.connections.append((self.ladspa_receive(ladspa_ports[1]), jacktrip_send_2))
-        self.connections.append((self.ladspa_receive(ladspa_ports[4]), jacktrip_send_2))
+        for ladspa in ladspa_ports:
+            self.connections.append(
+                (self._ladspa_receive(ladspa), self._darkice_send(darkice))
+            )
 
-        self.connections.append((self.ladspa_receive(ladspa_ports[3]), jacktrip_send_3))
-        self.connections.append((self.ladspa_receive(ladspa_ports[2]), jacktrip_send_3))
+    def set_client_connections(self, jacktrip_ports, ladspa_ports):
+        """set all connections between JackTrip clients & ladspa ports"""
 
-    def set_all_connections(self, jacktrip_ports, ladspa_ports):
-        """append all connections between JackTrip clients & ladspa ports"""
+        if len(jacktrip_ports) == 1:
+            self._set_connections_one_client(jacktrip_ports)
 
         if len(jacktrip_ports) == 2:
-            self.set_connections_2_clients(jacktrip_ports, ladspa_ports)
+            self._set_connections_two_clients(jacktrip_ports, ladspa_ports)
 
         if len(jacktrip_ports) == 3:
-            self.set_connections_3_clients(jacktrip_ports, ladspa_ports)
+            self._set_connections_three_clients(jacktrip_ports, ladspa_ports)
 
         if len(jacktrip_ports) > 3:
             for i, ladspa in enumerate(ladspa_ports):
-                jacktrip_receive = self.jacktrip_receive(jacktrip_ports[i])
-                ladspa_send = self.ladspa_send(ladspa)
+                jacktrip_receive = self._jacktrip_receive(jacktrip_ports[i])
+                ladspa_send = self._ladspa_send(ladspa)
                 self.connections.append((jacktrip_receive, ladspa_send))
                 for jacktrip_port in jacktrip_ports:
                     if jacktrip_port == jacktrip_ports[i]:
                         continue
-                    ladspa_receive = self.ladspa_receive(ladspa)
-                    jacktrip_send = self.jacktrip_send(jacktrip_port)
+                    ladspa_receive = self._ladspa_receive(ladspa)
+                    jacktrip_send = self._jacktrip_send(jacktrip_port)
                     self.connections.append((ladspa_receive, jacktrip_send))
 
-    def make_all_connections(self):
+    def make_connections(self):
+        """make all connections"""
+
         if self.dry_run:
             print("Make all connections")
             print(self.connections)
             return
 
-        [self.connect_ports(c[0], c[1]) for c in self.connections]
-
-    def connect_to_centre(self, receive, send):
-        """connect receive port/s to centre send"""
-        if self.dry_run:
-            print("Connect centre", receive, "to", send)
-            return
-
-        self.connect_ports(receive + ":receive_.*", send + ":send_.*")
-
-    def connect_mpg123_to_centre(self, mpg123, send):
-        """connect an instance of mpg123-jack to a jacktrip client"""
-        if self.dry_run:
-            print("Connect mpg123 centre", mpg123, "to", send)
-            return
-
-        self.connect_ports(mpg123 + ":.*", send + ":send_.*")
-
-    def connect_darkice_to_centre(self, receive, send):
-        if self.dry_run:
-            print("Connect centre", receive, "to", send)
-            return
-
-        self.connect_ports(receive + ":receive_.*", send + ".*")
-
-    def connect_mpg123_to_darkice(self, mpg123, send):
-        """connect an instance of mpg123-jack to a darkice client"""
-        if self.dry_run:
-            print("Connect mpg123 centre", mpg123, "to", send)
-            return
-        try:
-            self.connect_ports(mpg123 + ".*", send + ".*")
-        except jack.JackErrorCode as e:
-            print("Could not find mpg123, not patching ", send)
-            return
+        [self._connect_ports(c[0], c[1]) for c in self.connections]

jacktrip_pypatcher.py

@@ -89,34 +89,35 @@ def autopatch(jackClient, dry_run, jacktrip_clients):
     darkice_port = darkice.get_port()
     print("darkice port:", darkice_port)
 
-    print("=== Disconnecting existing connections ===")
-    disconnect(jackClient, dry_run, lounge_music.port)
-
     print("=== Lounge Music ===")
     if len(jacktrip_clients) != 1:
         lounge_music.kill_the_music()
     else:
         lounge_music.start_the_music_with_retries()
 
-    if len(jacktrip_clients) == 1:
-        print("=== Patch", len(jacktrip_clients), "client ===")
-        jcp.connect_mpg123_to_centre(lounge_music.port, jacktrip_clients[0])
-        jcp.connect_to_centre(jacktrip_clients[0], jacktrip_clients[0])
-        jcp.connect_mpg123_to_darkice(lounge_music.port, darkice_port)
-        jcp.connect_darkice_to_centre(jacktrip_clients[0], darkice_port)
-
-    if len(jacktrip_clients) >= 2 and len(jacktrip_clients) <= 11:
-        print("=== Start LADSPA plugins ===")
-        ladspa_ports = ladspa.get_ports(len(jacktrip_clients), all_ladspa_ports)
-        darkice_ladspa_ports = ladspa_ports
-
+    if len(jacktrip_clients) >= 1 and len(jacktrip_clients) <= 11:
+        ladspa_ports = []
+        darkice_ladspa_ports = []
+        if len(jacktrip_clients) > 1:
+            print("=== Start LADSPA plugins ===")
+            ladspa_ports = ladspa.get_ports(len(jacktrip_clients), all_ladspa_ports)
+            darkice_ladspa_ports = ladspa_ports
         if len(jacktrip_clients) == 3:
             darkice_ladspa_ports = [ladspa_ports[0]] + ladspa_ports[3:]
 
-        jcp.set_all_connections(jacktrip_clients, ladspa_ports)
-        jcp.set_darkice_connections(darkice_ladspa_ports, darkice_port)
-        print("=== Patch", len(jacktrip_clients), "client ===")
-        jcp.make_all_connections()
+        jcp.set_lounge_music_connections(
+            jacktrip_clients, darkice_port, lounge_music.port
+        )
+        jcp.set_client_connections(jacktrip_clients, ladspa_ports)
+        jcp.set_darkice_connections(
+            darkice_ladspa_ports, darkice_port, jacktrip_clients
+        )
+
+    print("=== Disconnecting existing connections ===")
+    disconnect(jackClient, dry_run, lounge_music.port)
+
+    print("=== Patch", len(jacktrip_clients), "client ===")
+    jcp.make_connections()
 
     print("=== Recording ===")
     if len(jacktrip_clients) > 0:

ladspa_plugins.py

@@ -57,6 +57,9 @@ def get_port(self, panning_position, all_ladspa_ports):
         return port_name
 
     def get_ports(self, no_of_clients, all_ladspa_ports):
+        if no_of_clients == 1:
+            return []
+
         panning_positions = self.get_panning_positions(no_of_clients)
         ladspa_ports = [
             self.get_port(position, all_ladspa_ports) for position in panning_positions