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.
4292 Commits
16 Branches
141MB
Tree: 29bb7fc38a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '29bb7fc38a'
${ noResults }
Carla/source/carla_backend_qtweb.py

411 lines
17KB
Raw Blame History 

  1. #!/usr/bin/env python3

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

  3. 

  4. # Carla Backend code (Web stuff)

  5. # Copyright (C) 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. import requests

  23. 

  24. # ---------------------------------------------------------------------------------------------------------------------

  25. # Imports (Custom)

  26. 

  27. from carla_backend_qt import *

  28. 

  29. import os

  30. from time import sleep

  31. 

  32. # ---------------------------------------------------------------------------------------------------------------------

  33. # Iterates over the content of a file-like object line-by-line.

  34. # Based on code by Lars Kellogg-Stedman, see https://github.com/requests/requests/issues/2433

  35. 

  36. def iterate_stream_nonblock(stream, chunk_size=128):

  37.     pending = None

  38. 

  39.     while True:

  40.         try:

  41.             chunk = os.read(stream.raw.fileno(), chunk_size)

  42.         except BlockingIOError:

  43.             break

  44.         if not chunk:

  45.             break

  46. 

  47.         if pending is not None:

  48.             chunk = pending + chunk

  49.             pending = None

  50. 

  51.         lines = chunk.splitlines()

  52. 

  53.         if lines and lines[-1]:

  54.             pending = lines.pop()

  55. 

  56.         for line in lines:

  57.             yield line

  58. 

  59.         if not pending:

  60.             break

  61. 

  62.     if pending:

  63.         yield pending

  64. 

  65. # ---------------------------------------------------------------------------------------------------------------------

  66. 

  67. def create_stream(baseurl):

  68.     stream = requests.get("{}/stream".format(baseurl), stream=True, timeout=0.1)

  69. 

  70.     if stream.encoding is None:

  71.         stream.encoding = 'utf-8'

  72. 

  73.     return stream

  74. 

  75. # ---------------------------------------------------------------------------------------------------------------------

  76. # Carla Host object for connecting to the REST API backend

  77. 

  78. class CarlaHostQtWeb(CarlaHostQtNull):

  79.     def __init__(self):

  80.         CarlaHostQtNull.__init__(self)

  81. 

  82.         self.baseurl = "http://localhost:2228"

  83.         self.stream  = create_stream(self.baseurl)

  84. 

  85.     def get_engine_driver_count(self):

  86.         # FIXME

  87.         return int(requests.get("{}/get_engine_driver_count".format(self.baseurl)).text) - 1

  88. 

  89.     def get_engine_driver_name(self, index):

  90.         return requests.get("{}/get_engine_driver_name/{}".format(self.baseurl, index)).text

  91. 

  92.     def get_engine_driver_device_names(self, index):

  93.         return requests.get("{}/get_engine_driver_device_names/{}".format(self.baseurl, index)).text.split("\n")

  94. 

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

  96.         return requests.get("{}/get_engine_driver_device_info/{}/{}".format(self.baseurl, index, name)).json()

  97. 

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

  99.         return requests.get("{}/engine_init/{}/{}".format(self.baseurl, driverName, clientName)).status_code == 200

  100. 

  101.     def engine_close(self):

  102.         return requests.get("{}/engine_close".format(self.baseurl)).status_code == 200

  103. 

  104.     def engine_idle(self):

  105.         closed = False

  106.         stream = self.stream

  107. 

  108.         for line in iterate_stream_nonblock(stream):

  109.             line = line.decode('utf-8', errors='ignore')

  110. 

  111.             if line.startswith("Carla: "):

  112.                 if self.fEngineCallback is None:

  113.                     continue

  114. 

  115.                 # split values from line

  116.                 action, pluginId, value1, value2, value3, valueStr = line[7:].split(" ",5)

  117. 

  118.                 # convert to proper types

  119.                 action   = int(action)

  120.                 pluginId = int(pluginId)

  121.                 value1   = int(value1)

  122.                 value2   = int(value2)

  123.                 value3   = float(value3)

  124. 

  125.                 # pass to callback

  126.                 self.fEngineCallback(None, action, pluginId, value1, value2, value3, valueStr)

  127. 

  128.             elif line == "Connection: close":

  129.                 if not closed:

  130.                     self.stream = create_stream(self.baseurl)

  131.                     closed = True

  132. 

  133.         if closed:

  134.             stream.close()

  135. 

  136.     def is_engine_running(self):

  137.         try:

  138.             return requests.get("{}/is_engine_running".format(self.baseurl)).status_code == 200

  139.         except requests.exceptions.ConnectionError:

  140.             if self.fEngineCallback is None:

  141.                 self.fEngineCallback(None, ENGINE_CALLBACK_QUIT, 0, 0, 0, 0.0, "")

  142. 

  143.     def set_engine_about_to_close(self):

  144.         return requests.get("{}/set_engine_about_to_close".format(self.baseurl)).status_code == 200

  145. 

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

  147.         requests.get("{}/set_engine_option/{}/{}/{}".format(self.baseurl, option, value, valueStr))

  148. 

  149.     def load_file(self, filename):

  150.         return requests.get("{}/load_file/{}".format(self.baseurl, filename)).status_code == 200

  151. 

  152.     def load_project(self, filename):

  153.         return requests.get("{}/load_project/{}".format(self.baseurl, filename)).status_code == 200

  154. 

  155.     def save_project(self, filename):

  156.         return requests.get("{}/save_project/{}".format(self.baseurl, filename)).status_code == 200

  157. 

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

  159.         return requests.get("{}/patchbay_connect/{}/{}/{}/{}".format(self.baseurl, groupIdA, portIdA, groupIdB, portIdB)).status_code == 200

  160. 

  161.     def patchbay_disconnect(self, connectionId):

  162.         return requests.get("{}/patchbay_disconnect/{}".format(self.baseurl, connectionId)).status_code == 200

  163. 

  164.     def patchbay_refresh(self, external):

  165.         return requests.get("{}/patchbay_refresh/{}".format(self.baseurl, external)).status_code == 200

  166. 

  167.     def transport_play(self):

  168.         requests.get("{}/transport_play".format(self.baseurl))

  169. 

  170.     def transport_pause(self):

  171.         requests.get("{}/transport_pause".format(self.baseurl))

  172. 

  173.     def transport_bpm(self, bpm):

  174.         requests.get("{}/transport_bpm/{}".format(self.baseurl, bpm))

  175. 

  176.     def transport_relocate(self, frame):

  177.         requests.get("{}/transport_relocate/{}".format(self.baseurl, frame))

  178. 

  179.     def get_current_transport_frame(self):

  180.         return int(requests.get("{}/get_current_transport_frame".format(self.baseurl)).text)

  181. 

  182.     def get_transport_info(self):

  183.         return requests.get("{}/get_transport_info".format(self.baseurl)).json()

  184. 

  185.     def get_current_plugin_count(self):

  186.         return int(requests.get("{}/get_current_plugin_count".format(self.baseurl)).text)

  187. 

  188.     def get_max_plugin_number(self):

  189.         return int(requests.get("{}/get_max_plugin_number".format(self.baseurl)).text)

  190. 

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

  192.         return requests.get("{}/add_plugin/{}/{}/{}/{}/{}/{}/{}/{}".format(self.baseurl, btype, ptype, filename, name, label, uniqueId, extraPtr, options)).status_code == 200

  193. 

  194.     def remove_plugin(self, pluginId):

  195.         return requests.get("{}/remove_plugin/{}".format(self.baseurl, pluginId)).status_code == 200

  196. 

  197.     def remove_all_plugins(self):

  198.         return requests.get("{}/remove_all_plugins".format(self.baseurl)).status_code == 200

  199. 

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

  201.         return requests.get("{}/rename_plugin/{}/{}".format(self.baseurl, pluginId, newName)).text

  202. 

  203.     def clone_plugin(self, pluginId):

  204.         return requests.get("{}/clone_plugin/{}".format(self.baseurl, pluginId)).status_code == 200

  205. 

  206.     def replace_plugin(self, pluginId):

  207.         return requests.get("{}/replace_plugin/{}".format(self.baseurl, pluginId)).status_code == 200

  208. 

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

  210.         return requests.get("{}/switch_plugins/{}/{}".format(self.baseurl, pluginIdA, pluginIdB)).status_code == 200

  211. 

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

  213.         return requests.get("{}/load_plugin_state/{}/{}".format(self.baseurl, pluginId, filename)).status_code == 200

  214. 

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

  216.         return requests.get("{}/save_plugin_state/{}/{}".format(self.baseurl, pluginId, filename)).status_code == 200

  217. 

  218.     def export_plugin_lv2(self, pluginId, lv2path):

  219.         return requests.get("{}/export_plugin_lv2/{}/{}".format(self.baseurl, pluginId, lv2path)).status_code == 200

  220. 

  221.     def get_plugin_info(self, pluginId):

  222.         return requests.get("{}/get_plugin_info/{}".format(self.baseurl, pluginId)).json()

  223. 

  224.     def get_audio_port_count_info(self, pluginId):

  225.         return requests.get("{}/get_audio_port_count_info/{}".format(self.baseurl, pluginId)).json()

  226. 

  227.     def get_midi_port_count_info(self, pluginId):

  228.         return requests.get("{}/get_midi_port_count_info/{}".format(self.baseurl, pluginId)).json()

  229. 

  230.     def get_parameter_count_info(self, pluginId):

  231.         return requests.get("{}/get_parameter_count_info/{}".format(self.baseurl, pluginId)).json()

  232. 

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

  234.         return requests.get("{}/get_parameter_info/{}/{}".format(self.baseurl, pluginId, parameterId)).json()

  235. 

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

  237.         return requests.get("{}/get_parameter_scalepoint_info/{}/{}/{}".format(self.baseurl, pluginId, parameterId, scalePointId)).json()

  238. 

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

  240.         return requests.get("{}/get_parameter_data/{}/{}".format(self.baseurl, pluginId, parameterId)).json()

  241. 

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

  243.         return requests.get("{}/get_parameter_ranges/{}/{}".format(self.baseurl, pluginId, parameterId)).json()

  244. 

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

  246.         return requests.get("{}/get_midi_program_data/{}/{}".format(self.baseurl, pluginId, midiProgramId)).json()

  247. 

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

  249.         return requests.get("{}/get_custom_data/{}/{}".format(self.baseurl, pluginId, customDataId)).json()

  250. 

  251.     def get_chunk_data(self, pluginId):

  252.         return requests.get("{}/get_chunk_data/{}".format(self.baseurl, pluginId)).text

  253. 

  254.     def get_parameter_count(self, pluginId):

  255.         return int(requests.get("{}/get_parameter_count/{}".format(self.baseurl, pluginId)).text)

  256. 

  257.     def get_program_count(self, pluginId):

  258.         return int(requests.get("{}/get_program_count/{}".format(self.baseurl, pluginId)).text)

  259. 

  260.     def get_midi_program_count(self, pluginId):

  261.         return int(requests.get("{}/get_midi_program_count/{}".format(self.baseurl, pluginId)).text)

  262. 

  263.     def get_custom_data_count(self, pluginId):

  264.         return int(requests.get("{}/get_custom_data_count/{}".format(self.baseurl, pluginId)).text)

  265. 

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

  267.         return requests.get("{}/get_parameter_text/{}/{}".format(self.baseurl, pluginId, parameterId)).text

  268. 

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

  270.         return requests.get("{}/get_program_name/{}/{}".format(self.baseurl, pluginId, programId)).text

  271. 

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

  273.         return requests.get("{}/get_midi_program_name/{}/{}".format(self.baseurl, pluginId, midiProgramId)).text

  274. 

  275.     def get_real_plugin_name(self, pluginId):

  276.         return requests.get("{}/get_real_plugin_name/{}".format(self.baseurl, pluginId)).text

  277. 

  278.     def get_current_program_index(self, pluginId):

  279.         return int(requests.get("{}/get_custom_data_count/{}".format(self.baseurl, pluginId)).text)

  280. 

  281.     def get_current_midi_program_index(self, pluginId):

  282.         return int(requests.get("{}/get_custom_data_count/{}".format(self.baseurl, pluginId)).text)

  283. 

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

  285.         return float(requests.get("{}/get_default_parameter_value/{}/{}".format(self.baseurl, pluginId, parameterId)).text)

  286. 

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

  288.         return float(requests.get("{}/get_current_parameter_value/{}/{}".format(self.baseurl, pluginId, parameterId)).text)

  289. 

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

  291.         return float(requests.get("{}/get_internal_parameter_value/{}/{}".format(self.baseurl, pluginId, parameterId)).text)

  292. 

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

  294.         return float(requests.get("{}/get_input_peak_value/{}/{}".format(self.baseurl, pluginId, isLeft)).text)

  295. 

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

  297.         return float(requests.get("{}/get_output_peak_value/{}/{}".format(self.baseurl, pluginId, isLeft)).text)

  298. 

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

  300.         requests.get("{}/set_option/{}/{}/{}".format(self.baseurl, pluginId, option, yesNo))

  301. 

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

  303.         requests.get("{}/set_active/{}/{}".format(self.baseurl, pluginId, onOff))

  304. 

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

  306.         requests.get("{}/set_drywet/{}/{}".format(self.baseurl, pluginId, value))

  307. 

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

  309.         requests.get("{}/set_volume/{}/{}".format(self.baseurl, pluginId, value))

  310. 

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

  312.         requests.get("{}/set_balance_left/{}/{}".format(self.baseurl, pluginId, value))

  313. 

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

  315.         requests.get("{}/set_balance_right/{}/{}".format(self.baseurl, pluginId, value))

  316. 

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

  318.         requests.get("{}/set_panning/{}/{}".format(self.baseurl, pluginId, value))

  319. 

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

  321.         requests.get("{}/set_ctrl_channel/{}/{}".format(self.baseurl, pluginId, channel))

  322. 

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

  324.         requests.get("{}/set_parameter_value/{}/{}/{}".format(self.baseurl, pluginId, parameterId, value))

  325. 

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

  327.         requests.get("{}/set_parameter_midi_channel/{}/{}/{}".format(self.baseurl, pluginId, parameterId, channel))

  328. 

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

  330.         requests.get("{}/set_parameter_midi_cc/{}/{}/{}".format(self.baseurl, pluginId, parameterId, cc))

  331. 

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

  333.         requests.get("{}/set_program/{}/{}".format(self.baseurl, pluginId, programId))

  334. 

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

  336.         requests.get("{}/set_midi_program/{}/{}".format(self.baseurl, pluginId, midiProgramId))

  337. 

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

  339.         requests.get("{}/set_custom_data/{}/{}/{}/{}".format(self.baseurl, pluginId, type_, key, value))

  340. 

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

  342.         requests.get("{}/set_chunk_data/{}/{}".format(self.baseurl, pluginId, chunkData))

  343. 

  344.     def prepare_for_save(self, pluginId):

  345.         requests.get("{}/prepare_for_save/{}".format(self.baseurl, pluginId))

  346. 

  347.     def reset_parameters(self, pluginId):

  348.         requests.get("{}/reset_parameters/{}".format(self.baseurl, pluginId))

  349. 

  350.     def randomize_parameters(self, pluginId):

  351.         requests.get("{}/randomize_parameters/{}".format(self.baseurl, pluginId))

  352. 

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

  354.         requests.get("{}/send_midi_note/{}/{}/{}/{}".format(self.baseurl, pluginId, channel, note, velocity))

  355. 

  356.     def get_buffer_size(self):

  357.         return int(requests.get("{}/get_buffer_size".format(self.baseurl)).text)

  358. 

  359.     def get_sample_rate(self):

  360.         return float(requests.get("{}/get_sample_rate".format(self.baseurl)).text)

  361. 

  362.     def get_last_error(self):

  363.         return requests.get("{}/get_last_error".format(self.baseurl)).text

  364. 

  365.     def get_host_osc_url_tcp(self):

  366.         return requests.get("{}/get_host_osc_url_tcp".format(self.baseurl)).text

  367. 

  368.     def get_host_osc_url_udp(self):

  369.         return requests.get("{}/get_host_osc_url_udp".format(self.baseurl)).text

  370. 

  371. # ---------------------------------------------------------------------------------------------------------------------

  372. # TESTING

  373. 

  374. if __name__ == '__main__':

  375. 

  376.     baseurl = "http://localhost:2228"

  377. 

  378.     #driver_count = int(requests.get("{}/get_engine_driver_count".format(baseurl)).text)

  379. 

  380.     ## FIXME

  381.     #driver_count -= 1

  382. 

  383.     #print("Driver names:")

  384.     #for index in range(driver_count):

  385.         #print("\t -", requests.get("{}/get_engine_driver_name/{}".format(baseurl, index)).text)

  386. 

  387.     #print("Driver device names:")

  388.     #for index in range(driver_count):

  389.         #for name in requests.get("{}/get_engine_driver_device_names/{}".format(baseurl, index)).text.split("\n"):

  390.             #print("\t {}:".format(name), requests.get("{}/get_engine_driver_device_info/{}/{}".format(baseurl, index, name)).json())

  391. 

  392.     requests.get("{}/engine_close".format(baseurl)).status_code

  393. 

  394.     if requests.get("{}/engine_init/{}/{}".format(baseurl, "JACK", "test")).status_code == 200:

  395.         stream = requests.get("{}/stream".format(baseurl), stream=True, timeout=0.25)

  396.         #stream.add_done_callback(cb)

  397.         #print(stream, dir(stream))

  398. 

  399.         #for line in stream.iter_lines():

  400.             #print("line", stream, line)

  401. 

  402.         while True:

  403.             print("idle")

  404.             for line in iterate_stream_nonblock(stream):

  405.                 print("line", line)

  406.             sleep(0.5)

  407. 

  408.         requests.get("{}/engine_close".format(baseurl)).status_code

  409. 

  410. # ---------------------------------------------------------------------------------------------------------------------