Cleanup

src/logs.py

@@ -411,6 +411,10 @@ if __name__ == '__main__':
 
     # App initialization
     app = QApplication(sys.argv)
+    app.setApplicationName("Cadence-Logs")
+    app.setApplicationVersion(VERSION)
+    app.setOrganizationName("Cadence")
+    app.setWindowIcon(QIcon(":/scalable/cadence.svg"))
 
     # Show GUI
     gui = LogsW(None)

src/render.py

@@ -16,20 +16,29 @@
 #
 # For a full copy of the GNU General Public License see the COPYING file
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Global)
+
 from PyQt4.QtCore import pyqtSlot, QProcess, QTime, QTimer
 from PyQt4.QtGui import QDialog
 from time import sleep
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Custom Stuff)
+
 import ui_render
 from shared import *
 from jacklib_helpers import *
 
-global jack_client
-jack_client = None
+# ------------------------------------------------------------------------------------------------------------
+# Global JACK client (used in standalone mode)
+
+global jackClient
+jackClient = None
 
+# ------------------------------------------------------------------------------------------------------------
 # Render Window
+
 class RenderW(QDialog, ui_render.Ui_RenderW):
     def __init__(self, parent):
         QDialog.__init__(self, parent)
@@ -38,30 +47,28 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         # -------------------------------------------------------------
         # Get JACK client and base information
 
-        global jack_client
-        if jack_client:
-            self.m_jack_client = jack_client
-            self.m_closeClient = False
+        global jackClient
+        if jackClient:
+            self.m_jackClient = jackClient
         else:
-            self.m_jack_client = jacklib.client_open("Render-Dialog", jacklib.JackNoStartServer, None)
-            self.m_closeClient = True
+            self.m_jackClient = jacklib.client_open("Render-Dialog", jacklib.JackNoStartServer, None)
 
-        self.m_buffer_size = int(jacklib.get_buffer_size(self.m_jack_client))
-        self.m_sample_rate = int(jacklib.get_sample_rate(self.m_jack_client))
+        self.m_bufferSize = int(jacklib.get_buffer_size(self.m_jackClient))
+        self.m_sampleRate = int(jacklib.get_sample_rate(self.m_jackClient))
 
         for i in range(self.cb_buffer_size.count()):
-            if int(self.cb_buffer_size.itemText(i)) == self.m_buffer_size:
+            if int(self.cb_buffer_size.itemText(i)) == self.m_bufferSize:
                 self.cb_buffer_size.setCurrentIndex(i)
                 break
         else:
-            self.cb_buffer_size.addItem(str(self.m_buffer_size))
+            self.cb_buffer_size.addItem(str(self.m_bufferSize))
             self.cb_buffer_size.setCurrentIndex(self.cb_buffer_size.count() - 1)
 
         # -------------------------------------------------------------
         # Internal stuff
 
-        self.m_max_time  = 180
-        self.m_last_time = 0
+        self.m_lastTime  = 0
+        self.m_maxTime   = 180
         self.m_freewheel = False
 
         self.m_timer   = QTimer(self)
@@ -74,14 +81,17 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         self.m_process.start("jack_capture", ["-pf"])
         self.m_process.waitForFinished()
 
-        formats = str(self.m_process.readAllStandardOutput(), encoding="utf-8").split(" ")
+        formats     = str(self.m_process.readAllStandardOutput(), encoding="utf-8").split(" ")
         formatsList = []
 
         for i in range(len(formats) - 1):
-            formatsList.append(formats[i])
+            iFormat = formats[i].strip()
+            if iFormat:
+                formatsList.append(iFormat)
 
         formatsList.sort()
 
+        # Put all formats in combo-box, select 'wav' option
         for i in range(len(formatsList)):
             self.cb_format.addItem(formatsList[i])
             if formatsList[i] == "wav":
@@ -127,18 +137,19 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         self.b_stop.setVisible(True)
         self.b_close.setEnabled(False)
 
-        self.m_freewheel = bool(self.cb_render_mode.currentIndex() == 1)
-        new_buffer_size = int(self.cb_buffer_size.currentText())
+        timeStart = self.te_start.time()
+        timeEnd   = self.te_end.time()
+        minTime   = (timeStart.hour() * 3600) + (timeStart.minute() * 60) + (timeStart.second())
+        maxTime   = (timeEnd.hour() * 3600) + (timeEnd.minute() * 60) + (timeEnd.second())
 
-        time_start = self.te_start.time()
-        time_end = self.te_end.time()
-        min_time = (time_start.hour() * 3600) + (time_start.minute() * 60) + (time_start.second())
-        max_time = (time_end.hour() * 3600) + (time_end.minute() * 60) + (time_end.second())
-        self.m_max_time = max_time
+        newBufferSize = int(self.cb_buffer_size.currentText())
 
-        self.progressBar.setMinimum(min_time)
-        self.progressBar.setMaximum(max_time)
-        self.progressBar.setValue(min_time)
+        self.m_maxTime   = maxTime
+        self.m_freewheel = bool(self.cb_render_mode.currentIndex() == 1)
+
+        self.progressBar.setMinimum(minTime)
+        self.progressBar.setMaximum(maxTime)
+        self.progressBar.setValue(minTime)
         self.progressBar.update()
 
         if self.m_freewheel:
@@ -175,14 +186,14 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         # Change current directory
         os.chdir(self.le_folder.text())
 
-        if new_buffer_size != int(jacklib.get_buffer_size(self.m_jack_client)):
+        if newBufferSize != int(jacklib.get_buffer_size(self.m_jackClient)):
             print("NOTICE: buffer size changed before render")
-            jacklib.set_buffer_size(self.m_jack_client, new_buffer_size)
+            jacklib.set_buffer_size(self.m_jackClient, newBufferSize)
 
-        if jacklib.transport_query(self.m_jack_client, None) > jacklib.JackTransportStopped: # > JackTransportStopped is rolling|starting
-            jacklib.transport_stop(self.m_jack_client)
+        if jacklib.transport_query(self.m_jackClient, None) > jacklib.JackTransportStopped: # > JackTransportStopped is rolling|starting
+            jacklib.transport_stop(self.m_jackClient)
 
-        jacklib.transport_locate(self.m_jack_client, min_time * self.m_sample_rate)
+        jacklib.transport_locate(self.m_jackClient, minTime * self.m_sampleRate)
         self.m_last_time = -1
 
         self.m_process.start("jack_capture", arguments)
@@ -191,17 +202,17 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         if self.m_freewheel:
             print("NOTICE: rendering in freewheel mode")
             sleep(1)
-            jacklib.set_freewheel(self.m_jack_client, 1)
+            jacklib.set_freewheel(self.m_jackClient, 1)
 
         self.m_timer.start()
-        jacklib.transport_start(self.m_jack_client)
+        jacklib.transport_start(self.m_jackClient)
 
     @pyqtSlot()
     def slot_renderStop(self):
-        jacklib.transport_stop(self.m_jack_client)
+        jacklib.transport_stop(self.m_jackClient)
 
         if self.m_freewheel:
-            jacklib.set_freewheel(self.m_jack_client, 0)
+            jacklib.set_freewheel(self.m_jackClient, 0)
 
         sleep(1)
 
@@ -221,9 +232,9 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
         self.progressBar.update()
 
         # Restore buffer size
-        new_buffer_size = int(jacklib.get_buffer_size(self.m_jack_client))
-        if new_buffer_size != self.m_buffer_size:
-            jacklib.set_buffer_size(self.m_jack_client, new_buffer_size)
+        newBufferSize = int(jacklib.get_buffer_size(self.m_jackClient))
+        if newBufferSize != self.m_bufferSize:
+            jacklib.set_buffer_size(self.m_jackClient, newBufferSize)
 
     @pyqtSlot()
     def slot_getAndSetPath(self):
@@ -231,7 +242,7 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
 
     @pyqtSlot()
     def slot_setStartNow(self):
-        time = int(jacklib.get_current_transport_frame(self.m_jack_client) / self.m_sample_rate)
+        time = int(jacklib.get_current_transport_frame(self.m_jackClient) / self.m_sampleRate)
         secs = time % 60
         mins = int(time / 60) % 60
         hrs  = int(time / 3600) % 60
@@ -239,7 +250,7 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
 
     @pyqtSlot()
     def slot_setEndNow(self):
-        time = int(jacklib.get_current_transport_frame(self.m_jack_client) / self.m_sample_rate)
+        time = int(jacklib.get_current_transport_frame(self.m_jackClient) / self.m_sampleRate)
         secs = time % 60
         mins = int(time / 60) % 60
         hrs  = int(time / 3600) % 60
@@ -263,31 +274,36 @@ class RenderW(QDialog, ui_render.Ui_RenderW):
 
     @pyqtSlot()
     def slot_updateProgressbar(self):
-        time = int(jacklib.get_current_transport_frame(self.m_jack_client)) / self.m_sample_rate
+        time = int(jacklib.get_current_transport_frame(self.m_jackClient)) / self.m_sampleRate
         self.progressBar.setValue(time)
 
-        if time > self.m_max_time or (self.m_last_time > time and not self.m_freewheel):
+        if time > self.m_maxTime or (self.m_lastTime > time and not self.m_freewheel):
             self.slot_renderStop()
 
         self.m_last_time = time
 
     def closeEvent(self, event):
-        if self.m_closeClient:
-            jacklib.client_close(self.m_jack_client)
+        if self.m_jackClient:
+            jacklib.client_close(self.m_jackClient)
         QDialog.closeEvent(self, event)
 
     def done(self, r):
         QDialog.done(self, r)
         self.close()
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # Allow to use this as a standalone app
+
 if __name__ == '__main__':
     # Additional imports
     from PyQt4.QtGui import QApplication
 
     # App initialization
     app = QApplication(sys.argv)
+    app.setApplicationName("Cadence-Render")
+    app.setApplicationVersion(VERSION)
+    app.setOrganizationName("Cadence")
+    app.setWindowIcon(QIcon(":/scalable/cadence.svg"))
 
     for iPATH in PATH:
         if os.path.exists(os.path.join(iPATH, "jack_capture")):
@@ -298,11 +314,11 @@ if __name__ == '__main__':
             "Is not possible to render without it!"))
         sys.exit(1)
 
-    jack_status = jacklib.jack_status_t(0)
-    jack_client = jacklib.client_open("Render", jacklib.JackNoStartServer, jacklib.pointer(jack_status))
+    jackStatus = jacklib.jack_status_t(0)
+    jackClient = jacklib.client_open("Render", jacklib.JackNoStartServer, jacklib.pointer(jackStatus))
 
-    if not jack_client:
-        errorString = get_jack_status_error_string(jack_status)
+    if not jackClient:
+        errorString = get_jack_status_error_string(jackStatus)
         QMessageBox.critical(None, app.translate("RenderW", "Error"), app.translate("RenderW",
             "Could not connect to JACK, possible reasons:\n"
             "%s" % errorString))
@@ -314,10 +330,4 @@ if __name__ == '__main__':
     gui.show()
 
     # App-Loop
-    ret = app.exec_()
-
-    if jack_client:
-        jacklib.client_close(jack_client)
-
-    # Exit properly
-    sys.exit(ret)
+    sys.exit(app.exec_())

src/shared.py

@@ -58,7 +58,7 @@ else:
     WINDOWS = False
 
 # ------------------------------------------------------------------------------------------------------------
-# Try import Signal
+# Try Import Signal
 
 try:
     from signal import signal, SIGINT, SIGTERM, SIGUSR1, SIGUSR2

src/shared_cadence.py

@@ -1,15 +1,35 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
+# Common/Shared code for Cadence
+# Copyright (C) 2012 Filipe Coelho <falktx@falktx.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# For a full copy of the GNU General Public License see the COPYING file
+
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Global)
-import os
+
 from PyQt4.QtCore import QProcess, QSettings
 from time import sleep
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Custom Stuff)
+
 from shared import *
 
+# ------------------------------------------------------------------------------------------------------------
 # Default Plugin PATHs
+
 DEFAULT_LADSPA_PATH = [
     os.path.join(HOME, ".ladspa"),
     os.path.join("/", "usr", "lib", "ladspa"),
@@ -34,36 +54,52 @@ DEFAULT_VST_PATH = [
     os.path.join("/", "usr", "local", "lib", "vst")
 ]
 
+# ------------------------------------------------------------------------------------------------------------
 # ALSA file-type indexes
+
 iAlsaFileNone  = 0
 iAlsaFileLoop  = 1
 iAlsaFileJACK  = 2
 iAlsaFilePulse = 3
 iAlsaFileMax   = 4
 
+# ------------------------------------------------------------------------------------------------------------
 # Global Settings
+
 GlobalSettings = QSettings("Cadence", "GlobalSettings")
 
+# ------------------------------------------------------------------------------------------------------------
 # Get Process list
-# TODO - Windows support, others
+
 def getProcList():
     retProcs = []
 
-    process = QProcess()
-    process.start("ps", ["-e"])
-    process.waitForFinished()
+    if HAIKU or LINUX or MACOS:
+        process = QProcess()
+        process.start("ps", ["-e"])
+        process.waitForFinished()
+
+        processDump = process.readAllStandardOutput().split("\n")
 
-    processDump = process.readAllStandardOutput().split("\n")
+        for i in range(len(processDump)):
+            if (i == 0): continue
+            dumpTest = str(processDump[i], encoding="utf-8").rsplit(":", 1)[-1].split(" ")
+            if len(dumpTest) > 1 and dumpTest[1]:
+                retProcs.append(dumpTest[1])
 
-    for i in range(len(processDump)):
-        if (i == 0): continue
-        dumpTest = str(processDump[i], encoding="utf-8").rsplit(":", 1)[-1].split(" ")
-        if len(dumpTest) > 1 and dumpTest[1]:
-            retProcs.append(dumpTest[1])
+    else:
+        print("getProcList() - Not supported in this system")
 
     return retProcs
 
+# ------------------------------------------------------------------------------------------------------------
+# Stop all audio processes, used for force-restart
+
 def stopAllAudioProcesses():
+    if not (HAIKU or LINUX or MACOS):
+        print("stopAllAudioProcesses() - Not supported in this system")
+        return
+
     process = QProcess()
 
     procsTerm = ["a2j", "a2jmidid", "artsd", "jackd", "jackdmp", "knotify4", "lash", "ladishd", "ladiappd", "ladiconfd", "jmcore"]

src/shared_carla.py

@@ -16,8 +16,10 @@
 #
 # For a full copy of the GNU General Public License see the COPYING file
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Global)
-import platform, sys
+
+import platform
 from copy import deepcopy
 from decimal import Decimal
 from sip import unwrapinstance
@@ -31,25 +33,12 @@ try:
 except:
     GuiContainer = QWidget
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Custom)
+
 import ui_carla_about, ui_carla_edit, ui_carla_parameter, ui_carla_plugin
 from shared import *
 
-# Carla Host object
-class CarlaHostObject(object):
-    __slots__ = [
-        'host',
-        'gui',
-        'isControl',
-        'processMode',
-        'maxParameters'
-    ]
-
-Carla = CarlaHostObject()
-Carla.host = None
-Carla.gui  = None
-Carla.isControl = False
-
 is64bit = bool(platform.architecture()[0] == "64bit" and sys.maxsize > 2**32)
 
 # ------------------------------------------------------------------------------------------------
@@ -59,7 +48,7 @@ is64bit = bool(platform.architecture()[0] == "64bit" and sys.maxsize > 2**32)
 MAX_PLUGINS    = 99
 MAX_PARAMETERS = 200
 
-# plugin hints
+# group plugin hints
 PLUGIN_IS_BRIDGE          = 0x001
 PLUGIN_IS_SYNTH           = 0x002
 PLUGIN_HAS_GUI            = 0x004
@@ -70,7 +59,7 @@ PLUGIN_CAN_VOLUME         = 0x040
 PLUGIN_CAN_BALANCE        = 0x080
 PLUGIN_CAN_FORCE_STEREO   = 0x100
 
-# parameter hints
+# group parameter hints
 PARAMETER_IS_BOOLEAN       = 0x01
 PARAMETER_IS_INTEGER       = 0x02
 PARAMETER_IS_LOGARITHMIC   = 0x04
@@ -200,13 +189,7 @@ PROCESS_MODE_MULTIPLE_CLIENTS = 1
 PROCESS_MODE_CONTINUOUS_RACK  = 2
 PROCESS_MODE_PATCHBAY         = 3
 
-# ------------------------------------------------------------------------------------------------
-# Carla GUI stuff
-
-Carla.processMode   = PROCESS_MODE_CONTINUOUS_RACK
-Carla.maxParameters = MAX_PARAMETERS
-
-# set native binary type
+# TODO ...
 if HAIKU or LINUX or MACOS:
     BINARY_NATIVE = BINARY_POSIX64 if is64bit else BINARY_POSIX32
 elif WINDOWS:
@@ -214,6 +197,28 @@ elif WINDOWS:
 else:
     BINARY_NATIVE = BINARY_OTHER
 
+# ------------------------------------------------------------------------------------------------------------
+# Carla Host object
+
+class CarlaHostObject(object):
+    __slots__ = [
+        'host',
+        'gui',
+        'isControl',
+        'processMode',
+        'maxParameters'
+    ]
+
+Carla = CarlaHostObject()
+Carla.host = None
+Carla.gui  = None
+Carla.isControl = False
+Carla.processMode   = PROCESS_MODE_CONTINUOUS_RACK
+Carla.maxParameters = MAX_PARAMETERS
+
+# ------------------------------------------------------------------------------------------------------------
+# Carla GUI stuff
+
 ICON_STATE_NULL = 0
 ICON_STATE_WAIT = 1
 ICON_STATE_OFF  = 2
@@ -429,8 +434,8 @@ def xmlSafeString(string, toXml):
     else:
         return string.replace("&amp;", "&").replace("&lt;","<").replace("&gt;",">").replace("&apos;","'").replace("&quot;","\"")
 
-# ------------------------------------------------------------------------------------------------
-# carla_about.cpp
+# ------------------------------------------------------------------------------------------------------------
+# CarlaAbout.cpp
 
 class CarlaAboutW(QDialog, ui_carla_about.Ui_CarlaAboutW):
     def __init__(self, parent):
@@ -508,7 +513,7 @@ class CarlaAboutW(QDialog, ui_carla_about.Ui_CarlaAboutW):
         QDialog.done(self, r)
         self.close()
 
-# ------------------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # PluginParameter.cpp
 
 # Plugin Parameter

src/shared_jack.py

@@ -16,20 +16,28 @@
 #
 # For a full copy of the GNU General Public License see the COPYING file
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Global)
+
 from PyQt4.QtCore import pyqtSlot, QTimer
 from PyQt4.QtGui import QCursor, QFontMetrics, QMenu
 
+# ------------------------------------------------------------------------------------------------------------
 # Imports (Custom Stuff)
+
 import jacksettings, logs, render
 from shared import *
 from jacklib_helpers import *
 
+# ------------------------------------------------------------------------------------------------------------
 # Have JACK2 ?
+
 if jacklib.JACK2 and DEBUG:
     print("Using JACK2, version %s" % cString(jacklib.get_version_string()))
 
+# ------------------------------------------------------------------------------------------------------------
 # Can Render ?
+
 for iPATH in PATH:
     if os.path.exists(os.path.join(iPATH, "jack_capture")):
         canRender = True
@@ -37,7 +45,9 @@ for iPATH in PATH:
 else:
     canRender = False
 
-# Variables
+# ------------------------------------------------------------------------------------------------------------
+# Global Variables
+
 TRANSPORT_VIEW_HMS = 0
 TRANSPORT_VIEW_BBT = 1
 TRANSPORT_VIEW_FRAMES = 2
@@ -45,7 +55,9 @@ TRANSPORT_VIEW_FRAMES = 2
 buffer_sizes = (16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192)
 sample_rates = (22050, 32000, 44100, 48000, 88200, 96000, 192000)
 
-# DBus object
+# ------------------------------------------------------------------------------------------------------------
+# Global DBus object
+
 class DBusObject(object):
     __slots__ = [
         'loop',
@@ -63,16 +75,6 @@ class DBusObject(object):
     ]
 
 DBus = DBusObject()
-
-# Jack object
-class JackObject(object):
-    __slots__ = [
-        'client'
-    ]
-
-jack = JackObject()
-
-# Init objects
 DBus.loop = None
 DBus.bus  = None
 DBus.a2j  = None
@@ -85,9 +87,18 @@ DBus.ladish_app_iface  = None
 DBus.ladish_app_daemon = None
 DBus.patchbay = None
 
+# ------------------------------------------------------------------------------------------------------------
+# Global JACK object
+
+class JackObject(object):
+    __slots__ = [
+        'client'
+    ]
+
+jack = JackObject()
 jack.client = None
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # Property change calls
 
 def jack_buffer_size(self_, buffer_size):
@@ -121,7 +132,7 @@ def slot_jackSampleRate_ComboBox(self_, text):
     if text and text.isdigit():
         jack_sample_rate(self_, int(text))
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # Transport calls
 
 def setTransportView(self_, view):
@@ -194,7 +205,7 @@ def slot_transportViewMenu(self_):
     elif act_selected == act_t_fr:
         setTransportView(self_, TRANSPORT_VIEW_FRAMES)
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # Refresh GUI stuff
 
 def refreshDSPLoad(self_):
@@ -262,7 +273,7 @@ def refreshTransport(self_):
 
     self_.m_last_transport_state = state
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # Set GUI stuff
 
 def setBufferSize(self_, buffer_size, forced=False):
@@ -349,7 +360,7 @@ def setDSPLoad(self_, dsp_load):
 def setXruns(self_, xruns):
     self_.b_xruns.setText("%s Xrun%s" % (str(xruns) if (xruns >= 0) else "--", "" if (xruns == 1) else "s"))
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # External Dialogs
 
 global logsW
@@ -378,7 +389,7 @@ def slot_showRender(self_):
     renderW.exec_()
     del renderW
 
-# -------------------------------------------------------------
+# ------------------------------------------------------------------------------------------------------------
 # Shared Connections
 
 def setJackConnections(self_, modes):