falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 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.
1979 Commits
17 Branches
546MB
Tree: 5ed8a56a99
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5ed8a56a99'
${ noResults }
Carla/source/modules/native-plugins/resources/carla-plugin

783 lines
29KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # Carla plugin host (plugin UI)

  5. # Copyright (C) 2013-2014 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 GPL.txt file

  18. 

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

  20. # Imports (Custom Stuff)

  21. 

  22. from carla_host import *

  23. from externalui import ExternalUI

  24. 

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

  26. # Helper object

  27. 

  28. class PluginStoreInfo(object):

  29.     __slots__ = [

  30.         'pluginInfo',

  31.         'pluginRealName',

  32.         'audioCountInfo',

  33.         'midiCountInfo',

  34.         'parameterCount',

  35.         'parameterCountInfo',

  36.         'parameterInfoS',

  37.         'parameterDataS',

  38.         'parameterRangeS',

  39.         'parameterValueS',

  40.         'parameterValueInt',

  41.         'programCount',

  42.         'programCurrent',

  43.         'programNameS',

  44.         'midiProgramCount',

  45.         'midiProgramCurrent',

  46.         'midiProgramDataS',

  47.         'peaks'

  48.     ]

  49. 

  50. # ------------------------------------------------------------------------------------------------------------

  51. # Host Plugin object

  52. 

  53. class PluginHost(object):

  54.     def __init__(self, sampleRate):

  55.         object.__init__(self)

  56. 

  57.         self.fSupportedFileExts = ""

  58.         self.fBufferSize = 0

  59.         self.fSampleRate = sampleRate

  60.         self.fLastError  = ""

  61.         self.fIsRunning  = True

  62. 

  63.         self.fPluginsInfo = []

  64. 

  65.     def _add(self, pluginId):

  66.         if len(self.fPluginsInfo) != pluginId:

  67.             return

  68. 

  69.         info = PluginStoreInfo()

  70.         info.pluginInfo = PyCarlaPluginInfo

  71.         info.pluginRealName = ""

  72.         info.audioCountInfo = PyCarlaPortCountInfo

  73.         info.midiCountInfo  = PyCarlaPortCountInfo

  74.         info.parameterCount = 0

  75.         info.parameterCountInfo = PyCarlaPortCountInfo

  76.         info.parameterInfoS  = []

  77.         info.parameterDataS  = []

  78.         info.parameterRangeS = []

  79.         info.parameterValueS = []

  80.         info.parameterValueInt = [0.0, 1.0, 1.0, -1.0, 1.0, 0.0, -1.0]

  81.         info.programCount = 0

  82.         info.programCurrent = -1

  83.         info.programNameS = []

  84.         info.midiProgramCount = 0

  85.         info.midiProgramCurrent = -1

  86.         info.midiProgramDataS = []

  87.         info.peaks = [0.0, 0.0, 0.0, 0.0]

  88.         self.fPluginsInfo.append(info)

  89. 

  90.     def _set_pluginInfo(self, pluginId, info):

  91.         self.fPluginsInfo[pluginId].pluginInfo = info

  92. 

  93.     def _set_pluginName(self, pluginId, name):

  94.         self.fPluginsInfo[pluginId].pluginInfo['name'] = name

  95. 

  96.     def _set_pluginRealName(self, pluginId, realName):

  97.         self.fPluginsInfo[pluginId].pluginRealName = realName

  98. 

  99.     def _set_audioCountInfo(self, pluginId, info):

  100.         self.fPluginsInfo[pluginId].audioCountInfo = info

  101. 

  102.     def _set_midiCountInfo(self, pluginId, info):

  103.         self.fPluginsInfo[pluginId].midiCountInfo = info

  104. 

  105.     def _set_parameterCountInfo(self, pluginId, count, info):

  106.         self.fPluginsInfo[pluginId].parameterCount = count

  107.         self.fPluginsInfo[pluginId].parameterCountInfo = info

  108. 

  109.         # clear

  110.         self.fPluginsInfo[pluginId].parameterInfoS  = []

  111.         self.fPluginsInfo[pluginId].parameterDataS  = []

  112.         self.fPluginsInfo[pluginId].parameterRangeS = []

  113.         self.fPluginsInfo[pluginId].parameterValueS = []

  114. 

  115.         # add placeholders

  116.         for x in range(count):

  117.             self.fPluginsInfo[pluginId].parameterInfoS.append(PyCarlaParameterInfo)

  118.             self.fPluginsInfo[pluginId].parameterDataS.append(PyParameterData)

  119.             self.fPluginsInfo[pluginId].parameterRangeS.append(PyParameterRanges)

  120.             self.fPluginsInfo[pluginId].parameterValueS.append(0.0)

  121. 

  122.     def _set_programCount(self, pluginId, count):

  123.         self.fPluginsInfo[pluginId].programCount = count

  124. 

  125.         # clear

  126.         self.fPluginsInfo[pluginId].programNameS = []

  127. 

  128.         # add placeholders

  129.         for x in range(count):

  130.             self.fPluginsInfo[pluginId].programNameS.append("")

  131. 

  132.     def _set_midiProgramCount(self, pluginId, count):

  133.         self.fPluginsInfo[pluginId].midiProgramCount = count

  134. 

  135.         # clear

  136.         self.fPluginsInfo[pluginId].midiProgramDataS = []

  137. 

  138.         # add placeholders

  139.         for x in range(count):

  140.             self.fPluginsInfo[pluginId].midiProgramDataS.append(PyMidiProgramData)

  141. 

  142.     def _set_parameterInfoS(self, pluginId, paramIndex, info):

  143.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  144.             self.fPluginsInfo[pluginId].parameterInfoS[paramIndex] = info

  145. 

  146.     def _set_parameterDataS(self, pluginId, paramIndex, data):

  147.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  148.             self.fPluginsInfo[pluginId].parameterDataS[paramIndex] = data

  149. 

  150.     def _set_parameterRangeS(self, pluginId, paramIndex, ranges):

  151.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  152.             self.fPluginsInfo[pluginId].parameterRangeS[paramIndex] = ranges

  153. 

  154.     def _set_parameterValueS(self, pluginId, paramIndex, value):

  155.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  156.             self.fPluginsInfo[pluginId].parameterValueS[paramIndex] = value

  157. 

  158.     def _set_parameterValueInt(self, pluginId, paramIndex, value):

  159.         if pluginId < len(self.fPluginsInfo) and PARAMETER_NULL > paramIndex > PARAMETER_MAX:

  160.             self.fPluginsInfo[pluginId].parameterValueInt[abs(paramIndex)-2] = float(value)

  161. 

  162.     def _set_parameterDefault(self, pluginId, paramIndex, value):

  163.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  164.             self.fPluginsInfo[pluginId].parameterRangeS[paramIndex]['def'] = value

  165. 

  166.     def _set_parameterMidiChannel(self, pluginId, paramIndex, channel):

  167.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  168.             self.fPluginsInfo[pluginId].parameterDataS[paramIndex]['midiChannel'] = channel

  169. 

  170.     def _set_parameterMidiCC(self, pluginId, paramIndex, cc):

  171.         if pluginId < len(self.fPluginsInfo) and paramIndex < self.fPluginsInfo[pluginId].parameterCount:

  172.             self.fPluginsInfo[pluginId].parameterDataS[paramIndex]['midiCC'] = cc

  173. 

  174.     def _set_currentProgram(self, pluginId, pIndex):

  175.         self.fPluginsInfo[pluginId].programCurrent = pIndex

  176. 

  177.     def _set_currentMidiProgram(self, pluginId, mpIndex):

  178.         self.fPluginsInfo[pluginId].midiProgramCurrent = mpIndex

  179. 

  180.     def _set_programNameS(self, pluginId, pIndex, name):

  181.         if pIndex < self.fPluginsInfo[pluginId].programCount:

  182.             self.fPluginsInfo[pluginId].programNameS[pIndex] = name

  183. 

  184.     def _set_midiProgramDataS(self, pluginId, mpIndex, data):

  185.         if mpIndex < self.fPluginsInfo[pluginId].midiProgramCount:

  186.             self.fPluginsInfo[pluginId].midiProgramDataS[mpIndex] = data

  187. 

  188.     def _set_peaks(self, pluginId, in1, in2, out1, out2):

  189.         self.fPluginsInfo[pluginId].peaks = [in1, in2, out1, out2]

  190. 

  191.     # -------------------------------------------------------------------

  192. 

  193.     def get_complete_license_text(self):

  194.         return ""

  195. 

  196.     def get_supported_file_extensions(self):

  197.         return self.fSupportedFileExts

  198. 

  199.     # -------------------------------------------------------------------

  200. 

  201.     def get_engine_driver_count(self):

  202.         return 1

  203. 

  204.     def get_engine_driver_name(self, index):

  205.         return "Plugin"

  206. 

  207.     def get_engine_driver_device_names(self, index):

  208.         return []

  209. 

  210.     def get_engine_driver_device_info(self, index, name):

  211.         return PyEngineDriverDeviceInfo

  212. 

  213.     # -------------------------------------------------------------------

  214. 

  215.     def get_internal_plugin_count(self):

  216.         return 0

  217. 

  218.     def get_internal_plugin_info(self, index):

  219.         return None

  220. 

  221.     # -------------------------------------------------------------------

  222. 

  223.     def engine_init(self, driverName, clientName):

  224.         return True

  225. 

  226.     def engine_close(self):

  227.         return True

  228. 

  229.     def engine_idle(self):

  230.         if gCarla.gui.idleExternalUI():

  231.             return

  232. 

  233.         self.fIsRunning = False

  234.         gCarla.gui.d_uiQuit()

  235. 

  236.     def is_engine_running(self):

  237.         return self.fIsRunning

  238. 

  239.     def set_engine_about_to_close(self):

  240.         pass

  241. 

  242.     def set_engine_callback(self, func):

  243.         pass

  244. 

  245.     def set_engine_option(self, option, value, valueStr):

  246.         gCarla.gui.send(["set_engine_option", option, value, valueStr])

  247. 

  248.     def set_file_callback(self, func):

  249.         pass

  250. 

  251.     # -------------------------------------------------------------------

  252. 

  253.     def set_file_callback(self, func):

  254.         pass

  255. 

  256.     def load_file(self, filename):

  257.         gCarla.gui.send(["load_file", filename])

  258.         return True

  259. 

  260.     def load_project(self, filename):

  261.         gCarla.gui.send(["load_project", filename])

  262.         return True

  263. 

  264.     def save_project(self, filename):

  265.         gCarla.gui.send(["save_project", filename])

  266.         return True

  267. 

  268.     # -------------------------------------------------------------------

  269. 

  270.     def patchbay_connect(self, groupIdA, portIdA, groupIdB, portIdB):

  271.         gCarla.gui.send(["patchbay_connect", groupIdA, portIdA, groupIdB, portIdB])

  272.         return True

  273. 

  274.     def patchbay_disconnect(self, connectionId):

  275.         gCarla.gui.send(["patchbay_disconnect", connectionId])

  276.         return True

  277. 

  278.     def patchbay_refresh(self):

  279.         gCarla.gui.send(["patchbay_refresh"])

  280.         return True

  281. 

  282.     # -------------------------------------------------------------------

  283. 

  284.     def transport_play(self):

  285.         gCarla.gui.send(["transport_play"])

  286. 

  287.     def transport_pause(self):

  288.         gCarla.gui.send(["transport_pause"])

  289. 

  290.     def transport_relocate(self, frame):

  291.         gCarla.gui.send(["transport_relocate"])

  292. 

  293.     def get_current_transport_frame(self):

  294.         return 0

  295. 

  296.     def get_transport_info(self):

  297.         return PyCarlaTransportInfo

  298. 

  299.     # -------------------------------------------------------------------

  300. 

  301.     def add_plugin(self, btype, ptype, filename, name, label, uniqueId, extraPtr):

  302.         gCarla.gui.send(["add_plugin", btype, ptype, filename, name, label, uniqueId])

  303.         return True

  304. 

  305.     def remove_plugin(self, pluginId):

  306.         gCarla.gui.send(["remove_plugin", pluginId])

  307.         return True

  308. 

  309.     def remove_all_plugins(self):

  310.         gCarla.gui.send(["remove_all_plugins"])

  311.         return True

  312. 

  313.     def rename_plugin(self, pluginId, newName):

  314.         gCarla.gui.send(["rename_plugin", pluginId, newName])

  315.         return newName

  316. 

  317.     def clone_plugin(self, pluginId):

  318.         gCarla.gui.send(["clone_plugin", pluginId])

  319.         return True

  320. 

  321.     def replace_plugin(self, pluginId):

  322.         gCarla.gui.send(["replace_plugin", pluginId])

  323.         return True

  324. 

  325.     def switch_plugins(self, pluginIdA, pluginIdB):

  326.         gCarla.gui.send(["switch_plugins", pluginIdA, pluginIdB])

  327.         return True

  328. 

  329.     # -------------------------------------------------------------------

  330. 

  331.     def load_plugin_state(self, pluginId, filename):

  332.         gCarla.gui.send(["load_plugin_state", pluginId, filename])

  333.         return True

  334. 

  335.     def save_plugin_state(self, pluginId, filename):

  336.         gCarla.gui.send(["save_plugin_state", pluginId, filename])

  337.         return True

  338. 

  339.     # -------------------------------------------------------------------

  340. 

  341.     def get_plugin_info(self, pluginId):

  342.         return self.fPluginsInfo[pluginId].pluginInfo

  343. 

  344.     def get_audio_port_count_info(self, pluginId):

  345.         return self.fPluginsInfo[pluginId].audioCountInfo

  346. 

  347.     def get_midi_port_count_info(self, pluginId):

  348.         return self.fPluginsInfo[pluginId].midiCountInfo

  349. 

  350.     def get_parameter_count_info(self, pluginId):

  351.         return self.fPluginsInfo[pluginId].parameterCountInfo

  352. 

  353.     def get_parameter_info(self, pluginId, parameterId):

  354.         return self.fPluginsInfo[pluginId].parameterInfoS[parameterId]

  355. 

  356.     def get_parameter_scalepoint_info(self, pluginId, parameterId, scalePointId):

  357.         return PyCarlaScalePointInfo

  358. 

  359.     # -------------------------------------------------------------------

  360. 

  361.     def get_parameter_data(self, pluginId, parameterId):

  362.         return self.fPluginsInfo[pluginId].parameterDataS[parameterId]

  363. 

  364.     def get_parameter_ranges(self, pluginId, parameterId):

  365.         return self.fPluginsInfo[pluginId].parameterRangeS[parameterId]

  366. 

  367.     def get_midi_program_data(self, pluginId, midiProgramId):

  368.         return self.fPluginsInfo[pluginId].midiProgramDataS[midiProgramId]

  369. 

  370.     def get_custom_data(self, pluginId, customDataId):

  371.         return PyCustomData

  372. 

  373.     def get_chunk_data(self, pluginId):

  374.         return ""

  375. 

  376.     # -------------------------------------------------------------------

  377. 

  378.     def get_parameter_count(self, pluginId):

  379.         return self.fPluginsInfo[pluginId].parameterCount

  380. 

  381.     def get_program_count(self, pluginId):

  382.         return self.fPluginsInfo[pluginId].programCount

  383. 

  384.     def get_midi_program_count(self, pluginId):

  385.         return self.fPluginsInfo[pluginId].midiProgramCount

  386. 

  387.     def get_custom_data_count(self, pluginId):

  388.         return 0

  389. 

  390.     # -------------------------------------------------------------------

  391. 

  392.     def get_parameter_text(self, pluginId, parameterId):

  393.         return ""

  394. 

  395.     def get_program_name(self, pluginId, programId):

  396.         return self.fPluginsInfo[pluginId].programNameS[programId]

  397. 

  398.     def get_midi_program_name(self, pluginId, midiProgramId):

  399.         return self.fPluginsInfo[pluginId].midiProgramDataS[midiProgramId]['label']

  400. 

  401.     def get_real_plugin_name(self, pluginId):

  402.         return self.fPluginsInfo[pluginId].pluginRealName

  403. 

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

  405. 

  406.     def get_current_program_index(self, pluginId):

  407.         return self.fPluginsInfo[pluginId].programCurrent

  408. 

  409.     def get_current_midi_program_index(self, pluginId):

  410.         return self.fPluginsInfo[pluginId].midiProgramCurrent

  411. 

  412.     def get_default_parameter_value(self, pluginId, parameterId):

  413.         return self.fPluginsInfo[pluginId].parameterRangeS[parameterId]['def']

  414. 

  415.     def get_current_parameter_value(self, pluginId, parameterId):

  416.         return self.fPluginsInfo[pluginId].parameterValueS[parameterId]

  417. 

  418.     def get_internal_parameter_value(self, pluginId, parameterId):

  419.         if parameterId == PARAMETER_NULL or parameterId <= PARAMETER_MAX:

  420.             return 0.0

  421.         if parameterId < 0:

  422.             return self.fPluginsInfo[pluginId].parameterValueInt[abs(parameterId)-2]

  423. 

  424.         return self.fPluginsInfo[pluginId].parameterValueS[parameterId]

  425. 

  426.     def get_input_peak_value(self, pluginId, isLeft):

  427.         return self.fPluginsInfo[pluginId].peaks[0 if isLeft else 1]

  428. 

  429.     def get_output_peak_value(self, pluginId, isLeft):

  430.         return self.fPluginsInfo[pluginId].peaks[2 if isLeft else 3]

  431. 

  432.     # -------------------------------------------------------------------

  433. 

  434.     def set_option(self, pluginId, option, yesNo):

  435.         gCarla.gui.send(["set_option", pluginId, option, yesNo])

  436. 

  437.     def set_active(self, pluginId, onOff):

  438.         gCarla.gui.send(["set_active", pluginId, onOff])

  439. 

  440.     def set_drywet(self, pluginId, value):

  441.         gCarla.gui.send(["set_drywet", pluginId, value])

  442. 

  443.     def set_volume(self, pluginId, value):

  444.         gCarla.gui.send(["set_volume", pluginId, value])

  445. 

  446.     def set_balance_left(self, pluginId, value):

  447.         gCarla.gui.send(["set_balance_left", pluginId, value])

  448. 

  449.     def set_balance_right(self, pluginId, value):

  450.         gCarla.gui.send(["set_balance_right", pluginId, value])

  451. 

  452.     def set_panning(self, pluginId, value):

  453.         gCarla.gui.send(["set_panning", pluginId, value])

  454. 

  455.     def set_ctrl_channel(self, pluginId, channel):

  456.         gCarla.gui.send(["set_ctrl_channel", pluginId, channel])

  457. 

  458.     # -------------------------------------------------------------------

  459. 

  460.     def set_parameter_value(self, pluginId, parameterId, value):

  461.         gCarla.gui.send(["set_parameter_value", pluginId, parameterId, value])

  462. 

  463.     def set_parameter_midi_channel(self, pluginId, parameterId, channel):

  464.         gCarla.gui.send(["set_parameter_midi_channel", pluginId, parameterId, channel])

  465. 

  466.     def set_parameter_midi_cc(self, pluginId, parameterId, cc):

  467.         gCarla.gui.send(["set_parameter_midi_cc", pluginId, parameterId, cc])

  468. 

  469.     def set_program(self, pluginId, programId):

  470.         gCarla.gui.send(["set_program", pluginId, programId])

  471. 

  472.     def set_midi_program(self, pluginId, midiProgramId):

  473.         gCarla.gui.send(["set_midi_program", pluginId, midiProgramId])

  474. 

  475.     def set_custom_data(self, pluginId, type_, key, value):

  476.         gCarla.gui.send(["set_custom_data", pluginId, type_, key, value])

  477. 

  478.     def set_chunk_data(self, pluginId, chunkData):

  479.         gCarla.gui.send(["set_chunk_data", pluginId, chunkData])

  480. 

  481.     # -------------------------------------------------------------------

  482. 

  483.     def prepare_for_save(self, pluginId):

  484.         gCarla.gui.send(["prepare_for_save", pluginId])

  485. 

  486.     def reset_parameters(self, pluginId):

  487.         gCarla.gui.send(["reset_parameters", pluginId])

  488. 

  489.     def randomize_parameters(self, pluginId):

  490.         gCarla.gui.send(["randomize_parameters", pluginId])

  491. 

  492.     def send_midi_note(self, pluginId, channel, note, velocity):

  493.         gCarla.gui.send(["send_midi_note", pluginId, channel, note, velocity])

  494. 

  495.     def show_custom_ui(self, pluginId, yesNo):

  496.         gCarla.gui.send(["show_custom_ui", pluginId, yesNo])

  497. 

  498.     # -------------------------------------------------------------------

  499. 

  500.     def get_buffer_size(self):

  501.         return self.fBufferSize

  502. 

  503.     def get_sample_rate(self):

  504.         return self.fSampleRate

  505. 

  506.     def get_last_error(self):

  507.         return self.fLastError

  508. 

  509.     def get_host_osc_url_tcp(self):

  510.         return ""

  511. 

  512.     def get_host_osc_url_udp(self):

  513.         return ""

  514. 

  515. # ------------------------------------------------------------------------------------------------------------

  516. # Main Window

  517. 

  518. class CarlaMiniW(ExternalUI, HostWindow):

  519.     def __init__(self):

  520.         ExternalUI.__init__(self)

  521.         HostWindow.__init__(self, None)

  522. 

  523.         if False:

  524.             from carla_patchbay import CarlaPatchbayW

  525.             self.fContainer = CarlaPatchbayW(self)

  526.         else:

  527.             from carla_rack import CarlaRackW

  528.             self.fContainer = CarlaRackW(self)

  529. 

  530.         self.setupContainer(False)

  531.         self.setWindowTitle(self.fUiName)

  532. 

  533.         self.showUiIfTesting()

  534. 

  535.     # -------------------------------------------------------------------

  536.     # ExternalUI Callbacks

  537. 

  538.     def d_uiShow(self):

  539.         self.show()

  540. 

  541.     def d_uiHide(self):

  542.         self.hide()

  543. 

  544.     def d_uiQuit(self):

  545.         self.close()

  546.         app.quit()

  547. 

  548.     def d_uiTitleChanged(self, uiTitle):

  549.         self.setWindowTitle(uiTitle)

  550. 

  551.     # -------------------------------------------------------------------

  552.     # Qt events

  553. 

  554.     def closeEvent(self, event):

  555.         self.closeExternalUI()

  556.         HostWindow.closeEvent(self, event)

  557. 

  558.     # -------------------------------------------------------------------

  559.     # Custom idler

  560. 

  561.     def idleExternalUI(self):

  562.         while True:

  563.             if self.fPipeRecv is None:

  564.                 return True

  565. 

  566.             try:

  567.                 msg = self.fPipeRecv.readline().strip()

  568.             except IOError:

  569.                 return False

  570. 

  571.             if not msg:

  572.                 return True

  573. 

  574.             elif msg.startswith("PEAKS_"):

  575.                 pluginId = int(msg.replace("PEAKS_", ""))

  576.                 in1, in2, out1, out2 = [float(i) for i in self.fPipeRecv.readline().strip().split(":")]

  577.                 gCarla.host._set_peaks(pluginId, in1, in2, out1, out2)

  578. 

  579.             elif msg.startswith("PARAMVAL_"):

  580.                 pluginId, paramId = [int(i) for i in msg.replace("PARAMVAL_", "").split(":")]

  581.                 paramValue = float(self.fPipeRecv.readline().strip())

  582.                 gCarla.host._set_parameterValueS(pluginId, paramId, paramValue)

  583. 

  584.             elif msg.startswith("ENGINE_CALLBACK_"):

  585.                 action   = int(msg.replace("ENGINE_CALLBACK_", ""))

  586.                 pluginId = int(self.fPipeRecv.readline().strip())

  587.                 value1   = int(self.fPipeRecv.readline().strip())

  588.                 value2   = int(self.fPipeRecv.readline().strip())

  589.                 value3   = float(self.fPipeRecv.readline().strip())

  590.                 valueStr = self.fPipeRecv.readline().strip().replace("\r", "\n")

  591. 

  592.                 if action == ENGINE_CALLBACK_PLUGIN_RENAMED:

  593.                     gCarla.host._set_pluginName(pluginId, valueStr)

  594.                 elif action == ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED:

  595.                     if value1 < 0:

  596.                         gCarla.host._set_parameterValueInt(pluginId, value1, value3)

  597.                     else:

  598.                         gCarla.host._set_parameterValueS(pluginId, value1, value3)

  599.                 elif action == ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED:

  600.                     gCarla.host._set_parameterDefault(pluginId, value1, value3)

  601.                 elif action == ENGINE_CALLBACK_PARAMETER_MIDI_CC_CHANGED:

  602.                     gCarla.host._set_parameterMidiCC(pluginId, value1, value2)

  603.                 elif action == ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED:

  604.                     gCarla.host._set_parameterMidiChannel(pluginId, value1, value2)

  605.                 elif action == ENGINE_CALLBACK_PROGRAM_CHANGED:

  606.                     gCarla.host._set_currentProgram(pluginId, value1)

  607.                 elif action == ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED:

  608.                     gCarla.host._set_currentMidiProgram(pluginId, value1)

  609. 

  610.                 engineCallback(None, action, pluginId, value1, value2, value3, valueStr)

  611. 

  612.             elif msg.startswith("PLUGIN_INFO_"):

  613.                 pluginId = int(msg.replace("PLUGIN_INFO_", ""))

  614.                 gCarla.host._add(pluginId)

  615. 

  616.                 type_, category, hints, uniqueId, optsAvail, optsEnabled = [int(i) for i in self.fPipeRecv.readline().strip().split(":")]

  617.                 filename  = self.fPipeRecv.readline().strip().replace("\r", "\n")

  618.                 name      = self.fPipeRecv.readline().strip().replace("\r", "\n")

  619.                 iconName  = self.fPipeRecv.readline().strip().replace("\r", "\n")

  620.                 realName  = self.fPipeRecv.readline().strip().replace("\r", "\n")

  621.                 label     = self.fPipeRecv.readline().strip().replace("\r", "\n")

  622.                 maker     = self.fPipeRecv.readline().strip().replace("\r", "\n")

  623.                 copyright = self.fPipeRecv.readline().strip().replace("\r", "\n")

  624. 

  625.                 pinfo = {

  626.                     'type': type_,

  627.                     'category': category,

  628.                     'hints': hints,

  629.                     'optionsAvailable': optsAvail,

  630.                     'optionsEnabled': optsEnabled,

  631.                     'filename': filename,

  632.                     'name':  name,

  633.                     'label': label,

  634.                     'maker': maker,

  635.                     'copyright': copyright,

  636.                     'iconName': iconName,

  637.                     'patchbayClientId': 0,

  638.                     'uniqueId': uniqueId

  639.                 }

  640.                 gCarla.host._set_pluginInfo(pluginId, pinfo)

  641.                 gCarla.host._set_pluginRealName(pluginId, realName)

  642. 

  643.             elif msg.startswith("AUDIO_COUNT_"):

  644.                 pluginId, ins, outs = [int(i) for i in msg.replace("AUDIO_COUNT_", "").split(":")]

  645.                 gCarla.host._set_audioCountInfo(pluginId, {'ins': ins, 'outs': outs})

  646. 

  647.             elif msg.startswith("MIDI_COUNT_"):

  648.                 pluginId, ins, outs = [int(i) for i in msg.replace("MIDI_COUNT_", "").split(":")]

  649.                 gCarla.host._set_midiCountInfo(pluginId, {'ins': ins, 'outs': outs})

  650. 

  651.             elif msg.startswith("PARAMETER_COUNT_"):

  652.                 pluginId, ins, outs, count = [int(i) for i in msg.replace("PARAMETER_COUNT_", "").split(":")]

  653.                 gCarla.host._set_parameterCountInfo(pluginId, count, {'ins': ins, 'outs': outs})

  654. 

  655.             elif msg.startswith("PARAMETER_DATA_"):

  656.                 pluginId, paramId = [int(i) for i in msg.replace("PARAMETER_DATA_", "").split(":")]

  657.                 paramType, paramHints, midiChannel, midiCC = [int(i) for i in self.fPipeRecv.readline().strip().split(":")]

  658.                 paramName = self.fPipeRecv.readline().strip().replace("\r", "\n")

  659.                 paramUnit = self.fPipeRecv.readline().strip().replace("\r", "\n")

  660. 

  661.                 paramInfo = {

  662.                     'name': paramName,

  663.                     'symbol': "",

  664.                     'unit': paramUnit,

  665.                     'scalePointCount': 0,

  666.                 }

  667.                 gCarla.host._set_parameterInfoS(pluginId, paramId, paramInfo)

  668. 

  669.                 paramData = {

  670.                     'type': paramType,

  671.                     'hints': paramHints,

  672.                     'index': paramId,

  673.                     'rindex': -1,

  674.                     'midiCC': midiCC,

  675.                     'midiChannel': midiChannel

  676.                 }

  677.                 gCarla.host._set_parameterDataS(pluginId, paramId, paramData)

  678. 

  679.             elif msg.startswith("PARAMETER_RANGES_"):

  680.                 pluginId, paramId = [int(i) for i in msg.replace("PARAMETER_RANGES_", "").split(":")]

  681.                 def_, min_, max_, step, stepSmall, stepLarge = [float(i) for i in self.fPipeRecv.readline().strip().split(":")]

  682. 

  683.                 paramRanges = {

  684.                     'def': def_,

  685.                     'min': min_,

  686.                     'max': max_,

  687.                     'step': step,

  688.                     'stepSmall': stepSmall,

  689.                     'stepLarge': stepLarge

  690.                 }

  691.                 gCarla.host._set_parameterRangeS(pluginId, paramId, paramRanges)

  692. 

  693.             elif msg.startswith("PROGRAM_COUNT_"):

  694.                 pluginId, count, current = [int(i) for i in msg.replace("PROGRAM_COUNT_", "").split(":")]

  695.                 gCarla.host._set_programCount(pluginId, count)

  696.                 gCarla.host._set_currentProgram(pluginId, current)

  697. 

  698.             elif msg.startswith("PROGRAM_NAME_"):

  699.                 pluginId, progId = [int(i) for i in msg.replace("PROGRAM_NAME_", "").split(":")]

  700.                 progName = self.fPipeRecv.readline().strip().replace("\r", "\n")

  701.                 gCarla.host._set_programNameS(pluginId, progId, progName)

  702. 

  703.             elif msg.startswith("MIDI_PROGRAM_COUNT_"):

  704.                 pluginId, count, current = [int(i) for i in msg.replace("MIDI_PROGRAM_COUNT_", "").split(":")]

  705.                 gCarla.host._set_midiProgramCount(pluginId, count)

  706.                 gCarla.host._set_currentMidiProgram(pluginId, current)

  707. 

  708.             elif msg.startswith("MIDI_PROGRAM_DATA_"):

  709.                 pluginId, midiProgId = [int(i) for i in msg.replace("MIDI_PROGRAM_DATA_", "").split(":")]

  710.                 bank, program = [int(i) for i in self.fPipeRecv.readline().strip().split(":")]

  711.                 name = self.fPipeRecv.readline().strip().replace("\r", "\n")

  712.                 gCarla.host._set_midiProgramDataS(pluginId, midiProgId, {'bank': bank, 'program': program, 'name': name})

  713. 

  714.             elif msg == "error":

  715.                 error = self.fPipeRecv.readline().strip().replace("\r", "\n")

  716.                 engineCallback(None, ENGINE_CALLBACK_ERROR, 0, 0, 0, 0.0, error)

  717. 

  718.             elif msg == "show":

  719.                 self.d_uiShow()

  720. 

  721.             elif msg == "hide":

  722.                 self.d_uiHide()

  723. 

  724.             elif msg == "quit":

  725.                 self.fQuitReceived = True

  726.                 self.d_uiQuit()

  727. 

  728.             elif msg == "uiTitle":

  729.                 uiTitle = self.fPipeRecv.readline().strip().replace("\r", "\n")

  730.                 self.d_uiTitleChanged(uiTitle)

  731. 

  732.             else:

  733.                 print("unknown message: \"" + msg + "\"")

  734. 

  735.         return True

  736. 

  737. # ------------------------------------------------------------------------------------------------------------

  738. # Main

  739. 

  740. if __name__ == '__main__':

  741.     # -------------------------------------------------------------

  742.     # App initialization

  743. 

  744.     app = CarlaApplication("Carla2-Plugin")

  745. 

  746.     # -------------------------------------------------------------

  747.     # Set-up custom signal handling

  748. 

  749.     setUpSignals()

  750. 

  751.     # -------------------------------------------------------------

  752.     # Init plugin host data

  753. 

  754.     gCarla.isControl   = False

  755.     gCarla.isLocal     = True

  756.     gCarla.isPlugin    = True

  757.     gCarla.processMode = ENGINE_PROCESS_MODE_CONTINUOUS_RACK

  758. 

  759.     # -------------------------------------------------------------

  760.     # Create GUI first

  761. 

  762.     gCarla.gui = CarlaMiniW()

  763. 

  764.     # -------------------------------------------------------------

  765.     # Init plugin host now

  766. 

  767.     gCarla.host = PluginHost(gCarla.gui.d_getSampleRate())

  768. 

  769.     initHost("Carla-Plugin")

  770. 

  771.     # simulate an engire started callback

  772.     engineCallback(None, ENGINE_CALLBACK_ENGINE_STARTED, 0, ENGINE_PROCESS_MODE_CONTINUOUS_RACK, ENGINE_TRANSPORT_MODE_PLUGIN, 0.0, "Plugin")

  773. 

  774.     # -------------------------------------------------------------

  775.     # App-Loop

  776. 

  777.     ret = app.exec_()

  778. 

  779.     # disable parenting

  780.     gCarla.host.set_engine_option(ENGINE_OPTION_FRONTEND_WIN_ID, 0, "0")

  781. 

  782.     sys.exit(ret)