falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5366 Commits
16 Branches
14GB
Tree: 894d838664
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '894d838664'
${ noResults }
Carla/source/frontend/carla_utils.py

405 lines
14KB
Raw Blame History 

  1. #!/usr/bin/env python3

  2. # -*- coding: utf-8 -*-

  3. 

  4. # Carla Backend utils

  5. # Copyright (C) 2011-2018 Filipe Coelho <falktx@falktx.com>

  6. #

  7. # This program is free software; you can redistribute it and/or

  8. # modify it under the terms of the GNU General Public License as

  9. # published by the Free Software Foundation; either version 2 of

  10. # the License, or any later version.

  11. #

  12. # This program is distributed in the hope that it will be useful,

  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of

  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  15. # GNU General Public License for more details.

  16. #

  17. # For a full copy of the GNU General Public License see the doc/GPL.txt file.

  18. 

  19. # ------------------------------------------------------------------------------------------------------------

  20. # Imports (Global)

  21. 

  22. from os import environ

  23. from sys import argv

  24. 

  25. # ------------------------------------------------------------------------------------------------------------

  26. # Imports (Custom)

  27. 

  28. from carla_backend import *

  29. 

  30. # ------------------------------------------------------------------------------------------------------------

  31. 

  32. def getPluginTypeAsString(ptype):

  33.     if ptype == PLUGIN_NONE:

  34.         return "NONE"

  35.     if ptype == PLUGIN_INTERNAL:

  36.         return "Internal"

  37.     if ptype == PLUGIN_LADSPA:

  38.         return "LADSPA"

  39.     if ptype == PLUGIN_DSSI:

  40.         return "DSSI"

  41.     if ptype == PLUGIN_LV2:

  42.         return "LV2"

  43.     if ptype == PLUGIN_VST2:

  44.         return "VST2"

  45.     if ptype == PLUGIN_VST3:

  46.         return "VST3"

  47.     if ptype == PLUGIN_AU:

  48.         return "AU"

  49.     if ptype == PLUGIN_SF2:

  50.         return "SF2"

  51.     if ptype == PLUGIN_SFZ:

  52.         return "SFZ"

  53.     if ptype == PLUGIN_JACK:

  54.         return "JACK"

  55. 

  56.     print("getPluginTypeAsString(%i) - invalid type" % ptype);

  57.     return "Unknown"

  58. 

  59. def getPluginTypeFromString(stype):

  60.     if not stype:

  61.         return PLUGIN_NONE

  62. 

  63.     stype = stype.lower()

  64. 

  65.     if stype == "none":

  66.         return PLUGIN_NONE

  67.     if stype in ("internal", "native"):

  68.         return PLUGIN_INTERNAL

  69.     if stype == "ladspa":

  70.         return PLUGIN_LADSPA

  71.     if stype == "dssi":

  72.         return PLUGIN_DSSI

  73.     if stype == "lv2":

  74.         return PLUGIN_LV2

  75.     if stype in ("vst2", "vst"):

  76.         return PLUGIN_VST2

  77.     if stype == "vst3":

  78.         return PLUGIN_VST3

  79.     if stype in ("au", "audiounit"):

  80.         return PLUGIN_AU

  81.     if stype == "sf2":

  82.         return PLUGIN_SF2

  83.     if stype == "sfz":

  84.         return PLUGIN_SFZ

  85.     if stype == "jack":

  86.         return PLUGIN_JACK

  87. 

  88.     print("getPluginTypeFromString(\"%s\") - invalid string type" % stype)

  89.     return PLUGIN_NONE

  90. 

  91. # ------------------------------------------------------------------------------------------------------------

  92. # Carla Utils API (C stuff)

  93. 

  94. CarlaPipeClientHandle = c_void_p

  95. CarlaPipeCallbackFunc = CFUNCTYPE(None, c_void_p, c_char_p)

  96. 

  97. # Information about an internal Carla plugin.

  98. # @see carla_get_cached_plugin_info()

  99. class CarlaCachedPluginInfo(Structure):

  100.     _fields_ = [

  101.         # Wherever the data in this struct is valid.

  102.         # For performance reasons, plugins are only checked on request,

  103.         #  and as such, the count vs number of really valid plugins might not match.

  104.         # Use this field to skip on plugins which cannot be loaded in Carla.

  105.         ("valid", c_bool),

  106. 

  107.         # Plugin category.

  108.         ("category", c_enum),

  109. 

  110.         # Plugin hints.

  111.         # @see PluginHints

  112.         ("hints", c_uint),

  113. 

  114.         # Number of audio inputs.

  115.         ("audioIns", c_uint32),

  116. 

  117.         # Number of audio outputs.

  118.         ("audioOuts", c_uint32),

  119. 

  120.         # Number of CV inputs.

  121.         ("cvIns", c_uint32),

  122. 

  123.         # Number of CV outputs.

  124.         ("cvOuts", c_uint32),

  125. 

  126.         # Number of MIDI inputs.

  127.         ("midiIns", c_uint32),

  128. 

  129.         # Number of MIDI outputs.

  130.         ("midiOuts", c_uint32),

  131. 

  132.         # Number of input parameters.

  133.         ("parameterIns", c_uint32),

  134. 

  135.         # Number of output parameters.

  136.         ("parameterOuts", c_uint32),

  137. 

  138.         # Plugin name.

  139.         ("name", c_char_p),

  140. 

  141.         # Plugin label.

  142.         ("label", c_char_p),

  143. 

  144.         # Plugin author/maker.

  145.         ("maker", c_char_p),

  146. 

  147.         # Plugin copyright/license.

  148.         ("copyright", c_char_p)

  149.     ]

  150. 

  151. # ------------------------------------------------------------------------------------------------------------

  152. # Carla Utils API (Python compatible stuff)

  153. 

  154. # @see CarlaCachedPluginInfo

  155. PyCarlaCachedPluginInfo = {

  156.     'valid': False,

  157.     'category': PLUGIN_CATEGORY_NONE,

  158.     'hints': 0x0,

  159.     'audioIns': 0,

  160.     'audioOuts': 0,

  161.     'cvIns': 0,

  162.     'cvOuts': 0,

  163.     'midiIns': 0,

  164.     'midiOuts': 0,

  165.     'parameterIns': 0,

  166.     'parameterOuts': 0,

  167.     'name':  "",

  168.     'label': "",

  169.     'maker': "",

  170.     'copyright': ""

  171. }

  172. 

  173. # ------------------------------------------------------------------------------------------------------------

  174. # Carla Utils object using a DLL

  175. 

  176. class CarlaUtils(object):

  177.     def __init__(self, filename):

  178.         object.__init__(self)

  179. 

  180.         self.lib = cdll.LoadLibrary(filename)

  181.         #self.lib = CDLL(filename, RTLD_GLOBAL)

  182. 

  183.         self.lib.carla_get_complete_license_text.argtypes = None

  184.         self.lib.carla_get_complete_license_text.restype = c_char_p

  185. 

  186.         self.lib.carla_get_juce_version.argtypes = None

  187.         self.lib.carla_get_juce_version.restype = c_char_p

  188. 

  189.         self.lib.carla_get_supported_file_extensions.argtypes = None

  190.         self.lib.carla_get_supported_file_extensions.restype = POINTER(c_char_p)

  191. 

  192.         self.lib.carla_get_supported_features.argtypes = None

  193.         self.lib.carla_get_supported_features.restype = POINTER(c_char_p)

  194. 

  195.         self.lib.carla_get_cached_plugin_count.argtypes = [c_enum, c_char_p]

  196.         self.lib.carla_get_cached_plugin_count.restype = c_uint

  197. 

  198.         self.lib.carla_get_cached_plugin_info.argtypes = [c_enum, c_uint]

  199.         self.lib.carla_get_cached_plugin_info.restype = POINTER(CarlaCachedPluginInfo)

  200. 

  201.         self.lib.carla_fflush.argtypes = [c_bool]

  202.         self.lib.carla_fflush.restype = None

  203. 

  204.         self.lib.carla_fputs.argtypes = [c_bool, c_char_p]

  205.         self.lib.carla_fputs.restype = None

  206. 

  207.         self.lib.carla_set_process_name.argtypes = [c_char_p]

  208.         self.lib.carla_set_process_name.restype = None

  209. 

  210.         self.lib.carla_pipe_client_new.argtypes = [POINTER(c_char_p), CarlaPipeCallbackFunc, c_void_p]

  211.         self.lib.carla_pipe_client_new.restype = CarlaPipeClientHandle

  212. 

  213.         self.lib.carla_pipe_client_idle.argtypes = [CarlaPipeClientHandle]

  214.         self.lib.carla_pipe_client_idle.restype = c_char_p

  215. 

  216.         self.lib.carla_pipe_client_is_running.argtypes = [CarlaPipeClientHandle]

  217.         self.lib.carla_pipe_client_is_running.restype = c_bool

  218. 

  219.         self.lib.carla_pipe_client_lock.argtypes = [CarlaPipeClientHandle]

  220.         self.lib.carla_pipe_client_lock.restype = None

  221. 

  222.         self.lib.carla_pipe_client_unlock.argtypes = [CarlaPipeClientHandle]

  223.         self.lib.carla_pipe_client_unlock.restype = None

  224. 

  225.         self.lib.carla_pipe_client_readlineblock.argtypes = [CarlaPipeClientHandle, c_uint]

  226.         self.lib.carla_pipe_client_readlineblock.restype = c_char_p

  227. 

  228.         self.lib.carla_pipe_client_readlineblock_bool.argtypes = [CarlaPipeClientHandle, c_uint]

  229.         self.lib.carla_pipe_client_readlineblock_bool.restype = c_bool

  230. 

  231.         self.lib.carla_pipe_client_readlineblock_int.argtypes = [CarlaPipeClientHandle, c_uint]

  232.         self.lib.carla_pipe_client_readlineblock_int.restype = c_int

  233. 

  234.         self.lib.carla_pipe_client_readlineblock_float.argtypes = [CarlaPipeClientHandle, c_uint]

  235.         self.lib.carla_pipe_client_readlineblock_float.restype = c_double

  236. 

  237.         self.lib.carla_pipe_client_write_msg.argtypes = [CarlaPipeClientHandle, c_char_p]

  238.         self.lib.carla_pipe_client_write_msg.restype = c_bool

  239. 

  240.         self.lib.carla_pipe_client_write_and_fix_msg.argtypes = [CarlaPipeClientHandle, c_char_p]

  241.         self.lib.carla_pipe_client_write_and_fix_msg.restype = c_bool

  242. 

  243.         self.lib.carla_pipe_client_flush.argtypes = [CarlaPipeClientHandle]

  244.         self.lib.carla_pipe_client_flush.restype = c_bool

  245. 

  246.         self.lib.carla_pipe_client_flush_and_unlock.argtypes = [CarlaPipeClientHandle]

  247.         self.lib.carla_pipe_client_flush_and_unlock.restype = c_bool

  248. 

  249.         self.lib.carla_pipe_client_destroy.argtypes = [CarlaPipeClientHandle]

  250.         self.lib.carla_pipe_client_destroy.restype = None

  251. 

  252.         self.lib.carla_cocoa_get_window.argtypes = [c_uintptr]

  253.         self.lib.carla_cocoa_get_window.restype = c_int

  254. 

  255.         self.lib.carla_x11_reparent_window.argtypes = [c_uintptr, c_uintptr]

  256.         self.lib.carla_x11_reparent_window.restype = None

  257. 

  258.         self.lib.carla_x11_move_window.argtypes = [c_uintptr, c_int, c_int]

  259.         self.lib.carla_x11_move_window.restype = None

  260. 

  261.         self.lib.carla_x11_get_window_pos.argtypes = [c_uintptr]

  262.         self.lib.carla_x11_get_window_pos.restype = POINTER(c_int)

  263. 

  264.         # use _putenv on windows

  265.         if not WINDOWS:

  266.             self.msvcrt = None

  267.             return

  268. 

  269.         self.msvcrt = cdll.msvcrt

  270.         self.msvcrt._putenv.argtypes = [c_char_p]

  271.         self.msvcrt._putenv.restype = None

  272. 

  273.     # --------------------------------------------------------------------------------------------------------

  274. 

  275.     # set environment variable

  276.     def setenv(self, key, value):

  277.         environ[key] = value

  278. 

  279.         if WINDOWS:

  280.             keyvalue = "%s=%s" % (key, value)

  281.             self.msvcrt._putenv(keyvalue.encode("utf-8"))

  282. 

  283.     # unset environment variable

  284.     def unsetenv(self, key):

  285.         if environ.get(key) is not None:

  286.             environ.pop(key)

  287. 

  288.         if WINDOWS:

  289.             keyrm = "%s=" % key

  290.             self.msvcrt._putenv(keyrm.encode("utf-8"))

  291. 

  292.     # --------------------------------------------------------------------------------------------------------

  293. 

  294.     # Get the complete license text of used third-party code and features.

  295.     # Returned string is in basic html format.

  296.     def get_complete_license_text(self):

  297.         return charPtrToString(self.lib.carla_get_complete_license_text())

  298. 

  299.     # Get the juce version used in the current Carla build.

  300.     def get_juce_version(self):

  301.         return charPtrToString(self.lib.carla_get_juce_version())

  302. 

  303.     # Get the list of supported file extensions in carla_load_file().

  304.     def get_supported_file_extensions(self):

  305.         return charPtrPtrToStringList(self.lib.carla_get_supported_file_extensions())

  306. 

  307.     # Get the list of supported features in the current Carla build.

  308.     def get_supported_features(self):

  309.         return charPtrPtrToStringList(self.lib.carla_get_supported_features())

  310. 

  311.     # Get how many internal plugins are available.

  312.     # Internal and LV2 plugin formats are cached and need to be discovered via this function.

  313.     # Do not call this for any other plugin formats.

  314.     def get_cached_plugin_count(self, ptype, pluginPath):

  315.         return int(self.lib.carla_get_cached_plugin_count(ptype, pluginPath.encode("utf-8")))

  316. 

  317.     # Get information about a cached plugin.

  318.     def get_cached_plugin_info(self, ptype, index):

  319.         return structToDict(self.lib.carla_get_cached_plugin_info(ptype, index).contents)

  320. 

  321.     def fflush(self, err):

  322.         self.lib.carla_fflush(err)

  323. 

  324.     def fputs(self, err, string):

  325.         self.lib.carla_fputs(err, string.encode("utf-8"))

  326. 

  327.     def set_process_name(self, name):

  328.         self.lib.carla_set_process_name(name.encode("utf-8"))

  329. 

  330.     def pipe_client_new(self, func):

  331.         argc      = len(argv)

  332.         cagrvtype = c_char_p * argc

  333.         cargv     = cagrvtype()

  334. 

  335.         for i in range(argc):

  336.             cargv[i] = c_char_p(argv[i].encode("utf-8"))

  337. 

  338.         self._pipeClientFunc = func

  339.         self._pipeClientCallback = CarlaPipeCallbackFunc(func)

  340.         return self.lib.carla_pipe_client_new(cargv, self._pipeClientCallback, None)

  341. 

  342.     def pipe_client_idle(self, handle):

  343.         while True:

  344.             try:

  345.                 msg = self.lib.carla_pipe_client_idle(handle)

  346.             except OSError as e:

  347.                 print("pipe_client_idle", e)

  348.                 return

  349. 

  350.             if not msg:

  351.                 break

  352. 

  353.             self._pipeClientFunc(None, msg.decode("utf-8", errors="ignore"))

  354. 

  355.     def pipe_client_is_running(self, handle):

  356.         return bool(self.lib.carla_pipe_client_is_running(handle))

  357. 

  358.     def pipe_client_lock(self, handle):

  359.         self.lib.carla_pipe_client_lock(handle)

  360. 

  361.     def pipe_client_unlock(self, handle):

  362.         self.lib.carla_pipe_client_unlock(handle)

  363. 

  364.     def pipe_client_readlineblock(self, handle, timeout):

  365.         return charPtrToString(self.lib.carla_pipe_client_readlineblock(handle, timeout))

  366. 

  367.     def pipe_client_readlineblock_bool(self, handle, timeout):

  368.         return bool(self.lib.carla_pipe_client_readlineblock_bool(handle, timeout))

  369. 

  370.     def pipe_client_readlineblock_int(self, handle, timeout):

  371.         return int(self.lib.carla_pipe_client_readlineblock_int(handle, timeout))

  372. 

  373.     def pipe_client_readlineblock_float(self, handle, timeout):

  374.         return float(self.lib.carla_pipe_client_readlineblock_float(handle, timeout))

  375. 

  376.     def pipe_client_write_msg(self, handle, msg):

  377.         return bool(self.lib.carla_pipe_client_write_msg(handle, msg.encode("utf-8")))

  378. 

  379.     def pipe_client_write_and_fix_msg(self, handle, msg):

  380.         return bool(self.lib.carla_pipe_client_write_and_fix_msg(handle, msg.encode("utf-8")))

  381. 

  382.     def pipe_client_flush(self, handle):

  383.         return bool(self.lib.carla_pipe_client_flush(handle))

  384. 

  385.     def pipe_client_flush_and_unlock(self, handle):

  386.         return bool(self.lib.carla_pipe_client_flush_and_unlock(handle))

  387. 

  388.     def pipe_client_destroy(self, handle):

  389.         self.lib.carla_pipe_client_destroy(handle)

  390. 

  391.     def cocoa_get_window(self, winId):

  392.         return self.lib.carla_cocoa_get_window(winId)

  393. 

  394.     def x11_reparent_window(self, winId1, winId2):

  395.         self.lib.carla_x11_reparent_window(winId1, winId2)

  396. 

  397.     def x11_move_window(self, winId, x, y):

  398.         self.lib.carla_x11_move_window(winId, x, y)

  399. 

  400.     def x11_get_window_pos(self, winId):

  401.         data = self.lib.carla_x11_get_window_pos(winId)

  402.         return tuple(int(data[i]) for i in range(4))

  403. 

  404. # ------------------------------------------------------------------------------------------------------------