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.
4379 Commits
16 Branches
14GB
Tree: a1dcc50346
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a1dcc50346'
${ noResults }
Carla/source/carla_utils.py

356 lines
12KB
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_SF2:

  46.         return "SF2"

  47.     if ptype == PLUGIN_SFZ:

  48.         return "SFZ"

  49.     if ptype == PLUGIN_JACK:

  50.         return "JACK"

  51. 

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

  53.     return "Unknown"

  54. 

  55. def getPluginTypeFromString(stype):

  56.     if not stype:

  57.         return PLUGIN_NONE

  58. 

  59.     stype = stype.lower()

  60. 

  61.     if stype == "none":

  62.         return PLUGIN_NONE

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

  64.         return PLUGIN_INTERNAL

  65.     if stype == "ladspa":

  66.         return PLUGIN_LADSPA

  67.     if stype == "dssi":

  68.         return PLUGIN_DSSI

  69.     if stype == "lv2":

  70.         return PLUGIN_LV2

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

  72.         return PLUGIN_VST2

  73.     if stype == "sf2":

  74.         return PLUGIN_SF2

  75.     if stype == "sfz":

  76.         return PLUGIN_SFZ

  77.     if stype == "jack":

  78.         return PLUGIN_JACK

  79. 

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

  81.     return PLUGIN_NONE

  82. 

  83. # ------------------------------------------------------------------------------------------------------------

  84. # Carla Utils API (C stuff)

  85. 

  86. CarlaPipeClientHandle = c_void_p

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

  88. 

  89. # Information about an internal Carla plugin.

  90. # @see carla_get_cached_plugin_info()

  91. class CarlaCachedPluginInfo(Structure):

  92.     _fields_ = [

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

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

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

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

  97.         ("valid", c_bool),

  98. 

  99.         # Plugin category.

  100.         ("category", c_enum),

  101. 

  102.         # Plugin hints.

  103.         # @see PluginHints

  104.         ("hints", c_uint),

  105. 

  106.         # Number of audio inputs.

  107.         ("audioIns", c_uint32),

  108. 

  109.         # Number of audio outputs.

  110.         ("audioOuts", c_uint32),

  111. 

  112.         # Number of MIDI inputs.

  113.         ("midiIns", c_uint32),

  114. 

  115.         # Number of MIDI outputs.

  116.         ("midiOuts", c_uint32),

  117. 

  118.         # Number of input parameters.

  119.         ("parameterIns", c_uint32),

  120. 

  121.         # Number of output parameters.

  122.         ("parameterOuts", c_uint32),

  123. 

  124.         # Plugin name.

  125.         ("name", c_char_p),

  126. 

  127.         # Plugin label.

  128.         ("label", c_char_p),

  129. 

  130.         # Plugin author/maker.

  131.         ("maker", c_char_p),

  132. 

  133.         # Plugin copyright/license.

  134.         ("copyright", c_char_p)

  135.     ]

  136. 

  137. # ------------------------------------------------------------------------------------------------------------

  138. # Carla Utils API (Python compatible stuff)

  139. 

  140. # @see CarlaCachedPluginInfo

  141. PyCarlaCachedPluginInfo = {

  142.     'valid': False,

  143.     'category': PLUGIN_CATEGORY_NONE,

  144.     'hints': 0x0,

  145.     'audioIns': 0,

  146.     'audioOuts': 0,

  147.     'midiIns': 0,

  148.     'midiOuts': 0,

  149.     'parameterIns': 0,

  150.     'parameterOuts': 0,

  151.     'name':  "",

  152.     'label': "",

  153.     'maker': "",

  154.     'copyright': ""

  155. }

  156. 

  157. # ------------------------------------------------------------------------------------------------------------

  158. # Carla Utils object using a DLL

  159. 

  160. class CarlaUtils(object):

  161.     def __init__(self, filename):

  162.         object.__init__(self)

  163. 

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

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

  166. 

  167.         self.lib.carla_get_complete_license_text.argtypes = None

  168.         self.lib.carla_get_complete_license_text.restype = c_char_p

  169. 

  170.         self.lib.carla_get_supported_file_extensions.argtypes = None

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

  172. 

  173.         self.lib.carla_get_supported_features.argtypes = None

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

  175. 

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

  177.         self.lib.carla_get_cached_plugin_count.restype = c_uint

  178. 

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

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

  181. 

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

  183.         self.lib.carla_fflush.restype = None

  184. 

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

  186.         self.lib.carla_fputs.restype = None

  187. 

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

  189.         self.lib.carla_set_process_name.restype = None

  190. 

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

  192.         self.lib.carla_pipe_client_new.restype = CarlaPipeClientHandle

  193. 

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

  195.         self.lib.carla_pipe_client_idle.restype = None

  196. 

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

  198.         self.lib.carla_pipe_client_is_running.restype = c_bool

  199. 

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

  201.         self.lib.carla_pipe_client_lock.restype = None

  202. 

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

  204.         self.lib.carla_pipe_client_unlock.restype = None

  205. 

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

  207.         self.lib.carla_pipe_client_readlineblock.restype = c_char_p

  208. 

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

  210.         self.lib.carla_pipe_client_write_msg.restype = c_bool

  211. 

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

  213.         self.lib.carla_pipe_client_write_and_fix_msg.restype = c_bool

  214. 

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

  216.         self.lib.carla_pipe_client_flush.restype = c_bool

  217. 

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

  219.         self.lib.carla_pipe_client_flush_and_unlock.restype = c_bool

  220. 

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

  222.         self.lib.carla_pipe_client_destroy.restype = None

  223. 

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

  225.         self.lib.carla_x11_reparent_window.restype = None

  226. 

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

  228.         self.lib.carla_x11_move_window.restype = None

  229. 

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

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

  232. 

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

  234.         self.lib.carla_cocoa_get_window.restype = c_int

  235. 

  236.         # use _putenv on windows

  237.         if not WINDOWS:

  238.             self.msvcrt = None

  239.             return

  240. 

  241.         self.msvcrt = cdll.msvcrt

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

  243.         self.msvcrt._putenv.restype = None

  244. 

  245.     # --------------------------------------------------------------------------------------------------------

  246. 

  247.     # set environment variable

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

  249.         environ[key] = value

  250. 

  251.         if WINDOWS:

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

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

  254. 

  255.     # unset environment variable

  256.     def unsetenv(self, key):

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

  258.             environ.pop(key)

  259. 

  260.         if WINDOWS:

  261.             keyrm = "%s=" % key

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

  263. 

  264.     # --------------------------------------------------------------------------------------------------------

  265. 

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

  267.     # Returned string is in basic html format.

  268.     def get_complete_license_text(self):

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

  270. 

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

  272.     def get_supported_file_extensions(self):

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

  274. 

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

  276.     def get_supported_features(self):

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

  278. 

  279.     # Get how many internal plugins are available.

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

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

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

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

  284. 

  285.     # Get information about a cached plugin.

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

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

  288. 

  289.     def fflush(self, err):

  290.         self.lib.carla_fflush(err)

  291. 

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

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

  294. 

  295.     def set_process_name(self, name):

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

  297. 

  298.     def pipe_client_new(self, func):

  299.         argc      = len(argv)

  300.         cagrvtype = c_char_p * argc

  301.         cargv     = cagrvtype()

  302. 

  303.         for i in range(argc):

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

  305. 

  306.         self._pipeClientCallback = CarlaPipeCallbackFunc(func)

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

  308. 

  309.     def pipe_client_idle(self, handle):

  310.         try:

  311.             self.lib.carla_pipe_client_idle(handle)

  312.         except OSError as e:

  313.             print("pipe_client_idle", e)

  314. 

  315.     def pipe_client_is_running(self, handle):

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

  317. 

  318.     def pipe_client_lock(self, handle):

  319.         self.lib.carla_pipe_client_lock(handle)

  320. 

  321.     def pipe_client_unlock(self, handle):

  322.         self.lib.carla_pipe_client_unlock(handle)

  323. 

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

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

  326. 

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

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

  329. 

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

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

  332. 

  333.     def pipe_client_flush(self, handle):

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

  335. 

  336.     def pipe_client_flush_and_unlock(self, handle):

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

  338. 

  339.     def pipe_client_destroy(self, handle):

  340.         self.lib.carla_pipe_client_destroy(handle)

  341. 

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

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

  344. 

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

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

  347. 

  348.     def x11_get_window_pos(self, winId):

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

  350.         return (int(data[0]), int(data[1]))

  351. 

  352.     def cocoa_get_window(self, winId):

  353.         return self.lib.carla_cocoa_get_window(winId)

  354. 

  355. # ------------------------------------------------------------------------------------------------------------