falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
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.
413 Commits
2 Branches
236MB
Tree: 656c0559ae
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '656c0559ae'
${ noResults }
Cadence/c++/carla-bridge/carla_bridge_osc.cpp

502 lines
14KB
Raw Blame History 

  1. /*

  2.  * Carla Plugin bridge code

  3.  * Copyright (C) 2012 Filipe Coelho <falktx@gmail.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the COPYING file

  16.  */

  17. 

  18. #include "carla_bridge_osc.h"

  19. #include "carla_bridge_client.h"

  20. #include "carla_midi.h"

  21. 

  22. #include <QtCore/QString>

  23. #include <QtCore/QStringList>

  24. 

  25. CARLA_BRIDGE_START_NAMESPACE

  26. 

  27. unsigned int uintMin(unsigned int value1, unsigned int value2)

  28. {

  29.     return value1 < value2 ? value1 : value2;

  30. }

  31. 

  32. void osc_error_handler(const int num, const char* const msg, const char* const path)

  33. {

  34.     qCritical("osc_error_handler(%i, \"%s\", \"%s\")", num, msg, path);

  35. }

  36. 

  37. // -----------------------------------------------------------------------

  38. 

  39. CarlaOsc::CarlaOsc(CarlaClient* const client_, const char* const name)

  40.     : client(client_)

  41. {

  42.     qDebug("CarlaOsc::CarlaOsc(%p, \"%s\")", client, name);

  43.     Q_ASSERT(client);

  44.     Q_ASSERT(name);

  45. 

  46.     m_serverPath = nullptr;

  47.     m_serverThread = nullptr;

  48.     m_controlData.path = nullptr;

  49.     m_controlData.source = nullptr; // unused

  50.     m_controlData.target = nullptr;

  51. 

  52.     m_name = strdup(name ? name : "");

  53.     m_nameSize = strlen(m_name);

  54. }

  55. 

  56. CarlaOsc::~CarlaOsc()

  57. {

  58.     qDebug("CarlaOsc::~CarlaOsc()");

  59. 

  60.     if (m_name)

  61.         free(m_name);

  62. }

  63. 

  64. bool CarlaOsc::init(const char* const url)

  65. {

  66.     qDebug("CarlaOsc::init(\"%s\")", url);

  67.     Q_ASSERT(! m_serverPath);

  68.     Q_ASSERT(! m_serverThread);

  69.     Q_ASSERT(url);

  70. 

  71.     char* host = lo_url_get_hostname(url);

  72.     char* port = lo_url_get_port(url);

  73. 

  74.     m_controlData.path   = lo_url_get_path(url);

  75.     m_controlData.target = lo_address_new(host, port);

  76. 

  77.     free(host);

  78.     free(port);

  79. 

  80.     if (! m_controlData.path)

  81.     {

  82.         qCritical("CarlaOsc::init(\"%s\") - failed to init OSC", url);

  83.         return false;

  84.     }

  85. 

  86.     // create new OSC thread

  87.     m_serverThread = lo_server_thread_new(nullptr, osc_error_handler);

  88. 

  89.     // get our full OSC server path

  90.     char* const threadPath = lo_server_thread_get_url(m_serverThread);

  91.     m_serverPath = strdup(QString("%1%2").arg(threadPath).arg(m_name).toUtf8().constData());

  92.     free(threadPath);

  93. 

  94.     // register message handler and start OSC thread

  95.     lo_server_thread_add_method(m_serverThread, nullptr, nullptr, osc_message_handler, this);

  96.     lo_server_thread_start(m_serverThread);

  97. 

  98.     return true;

  99. }

  100. 

  101. void CarlaOsc::close()

  102. {

  103.     qDebug("CarlaOsc::close()");

  104.     Q_ASSERT(m_serverPath);

  105.     Q_ASSERT(m_serverThread);

  106. 

  107.     osc_clear_data(&m_controlData);

  108. 

  109.     lo_server_thread_stop(m_serverThread);

  110.     lo_server_thread_del_method(m_serverThread, nullptr, nullptr);

  111.     lo_server_thread_free(m_serverThread);

  112. 

  113.     free((void*)m_serverPath);

  114.     m_serverPath = nullptr;

  115. }

  116. 

  117. // -----------------------------------------------------------------------

  118. 

  119. int CarlaOsc::handleMessage(const char* const path, const int argc, const lo_arg* const* const argv, const char* const types, const lo_message msg)

  120. {

  121.     qDebug("CarlaOsc::handleMessage(\"%s\", %i, %p, \"%s\", %p)", path, argc, argv, types, msg);

  122.     Q_ASSERT(m_serverPath);

  123.     Q_ASSERT(m_serverThread);

  124.     Q_ASSERT(path);

  125. 

  126.     // Check if message is for this client

  127.     if ((! path) || strlen(path) <= m_nameSize || strncmp(path+1, m_name, m_nameSize) != 0)

  128.     {

  129.         qWarning("CarlaOsc::handleMessage() - message not for this client: '%s' != '/%s/'", path, m_name);

  130.         return 1;

  131.     }

  132. 

  133.     char method[32] = { 0 };

  134.     memcpy(method, path + (m_nameSize + 1), uintMin(strlen(path), 32));

  135. 

  136.     if (method[0] == 0)

  137.         return 1;

  138. 

  139.     // Common OSC methods

  140.     if (strcmp(method, "/configure") == 0)

  141.         return handleMsgConfigure(argc, argv, types);

  142.     if (strcmp(method, "/control") == 0)

  143.         return handleMsgControl(argc, argv, types);

  144.     if (strcmp(method, "/program") == 0)

  145.         return handleMsgProgram(argc, argv, types);

  146.     if (strcmp(method, "/midi_program") == 0)

  147.         return handleMsgMidiProgram(argc, argv, types);

  148.     if (strcmp(method, "/midi") == 0)

  149.         return handleMsgMidi(argc, argv, types);

  150.     if (strcmp(method, "/show") == 0)

  151.         return handleMsgShow();

  152.     if (strcmp(method, "/hide") == 0)

  153.         return handleMsgHide();

  154.     if (strcmp(method, "/quit") == 0)

  155.         return handleMsgQuit();

  156. 

  157. #ifdef BRIDGE_LV2

  158.     if (strcmp(method, "/lv2_atom_transfer") == 0)

  159.         return handleMsgLv2TransferAtom(argc, argv, types);

  160.     if (strcmp(method, "/lv2_event_transfer") == 0)

  161.         return handleMsgLv2TransferEvent(argc, argv, types);

  162. #endif

  163. 

  164. #if 0

  165.     else if (strcmp(method, "set_parameter_midi_channel") == 0)

  166.         return osc_set_parameter_midi_channel_handler(argv);

  167.     else if (strcmp(method, "set_parameter_midi_cc") == 0)

  168.         return osc_set_parameter_midi_channel_handler(argv);

  169. #endif

  170. 

  171.     qWarning("CarlaOsc::handleMessage(\"%s\", ...) - got unsupported OSC method '%s'", path, method);

  172.     return 1;

  173. }

  174. 

  175. int CarlaOsc::handleMsgConfigure(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  176. {

  177.     qDebug("CarlaOsc::handleMsgConfigure()");

  178.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(2, "ss");

  179. 

  180.     if (! client)

  181.         return 1;

  182. 

  183. #ifdef BUILD_BRIDGE_PLUGIN

  184.     const char* const key   = (const char*)&argv[0]->s;

  185.     const char* const value = (const char*)&argv[1]->s;

  186. 

  187.     if (strcmp(key, CarlaBackend::CARLA_BRIDGE_MSG_SAVE_NOW) == 0)

  188.     {

  189.         client->quequeMessage(MESSAGE_SAVE_NOW, 0, 0, 0.0);

  190.     }

  191.     else if (strcmp(key, CarlaBackend::CARLA_BRIDGE_MSG_SET_CHUNK) == 0)

  192.     {

  193.         client->setChunkData(value);

  194.     }

  195.     else if (strcmp(key, CarlaBackend::CARLA_BRIDGE_MSG_SET_CUSTOM) == 0)

  196.     {

  197.         QStringList vList = QString(value).split("ยท", QString::KeepEmptyParts);

  198. 

  199.         if (vList.size() == 3)

  200.         {

  201.             const char* const cType  = vList.at(0).toUtf8().constData();

  202.             const char* const cKey   = vList.at(1).toUtf8().constData();

  203.             const char* const cValue = vList.at(2).toUtf8().constData();

  204. 

  205.             client->setCustomData(cType, cKey, cValue);

  206.         }

  207.     }

  208. #else

  209.     Q_UNUSED(argv);

  210. #endif

  211. 

  212.     return 0;

  213. }

  214. 

  215. int CarlaOsc::handleMsgControl(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  216. {

  217.     qDebug("CarlaOsc::handleMsgControl()");

  218.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(2, "if");

  219. 

  220.     if (! client)

  221.         return 1;

  222. 

  223.     const int32_t index = argv[0]->i;

  224.     const float   value = argv[1]->f;

  225.     client->quequeMessage(MESSAGE_PARAMETER, index, 0, value);

  226. 

  227.     return 0;

  228. }

  229. 

  230. int CarlaOsc::handleMsgProgram(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  231. {

  232.     qDebug("CarlaOsc::handleMsgProgram()");

  233.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(1, "i");

  234. 

  235.     if (! client)

  236.         return 1;

  237. 

  238.     const int32_t index = argv[0]->i;

  239.     client->quequeMessage(MESSAGE_PROGRAM, index, 0, 0.0);

  240. 

  241.     return 0;

  242. }

  243. 

  244. int CarlaOsc::handleMsgMidiProgram(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  245. {

  246.     qDebug("CarlaOsc::handleMsgMidiProgram()");

  247.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(2, "ii");

  248. 

  249.     if (! client)

  250.         return 1;

  251. 

  252.     const int32_t bank    = argv[0]->i;

  253.     const int32_t program = argv[1]->i;

  254.     client->quequeMessage(MESSAGE_MIDI_PROGRAM, bank, program, 0.0);

  255. 

  256.     return 0;

  257. }

  258. 

  259. int CarlaOsc::handleMsgMidi(CARLA_BRIDGE_OSC_HANDLE_ARGS)

  260. {

  261.     qDebug("CarlaOsc::handleMsgMidi()");

  262.     CARLA_BRIDGE_OSC_CHECK_OSC_TYPES(1, "m");

  263. 

  264.     if (! client)

  265.         return 1;

  266. 

  267.     const uint8_t* const mdata    = argv[0]->m;

  268.     const uint8_t         data[4] = { mdata[0], mdata[1], mdata[2], mdata[3] };

  269. 

  270.     uint8_t status  = data[1];

  271.     uint8_t channel = status & 0x0F;

  272. 

  273.     // Fix bad note-off

  274.     if (MIDI_IS_STATUS_NOTE_ON(status) && data[3] == 0)

  275.         status -= 0x10;

  276. 

  277.     if (MIDI_IS_STATUS_NOTE_OFF(status))

  278.     {

  279.         uint8_t note = data[2];

  280.         client->quequeMessage(MESSAGE_NOTE_OFF, channel, note, 0);

  281.     }

  282.     else if (MIDI_IS_STATUS_NOTE_ON(status))

  283.     {

  284.         uint8_t note = data[2];

  285.         uint8_t velo = data[3];

  286.         client->quequeMessage(MESSAGE_NOTE_ON, channel, note, velo);

  287.     }

  288. 

  289.     return 0;

  290. }

  291. 

  292. int CarlaOsc::handleMsgShow()

  293. {

  294.     if (! client)

  295.         return 1;

  296. 

  297.     client->quequeMessage(MESSAGE_SHOW_GUI, 1, 0, 0.0);

  298. 

  299.     return 0;

  300. }

  301. 

  302. int CarlaOsc::handleMsgHide()

  303. {

  304.     if (! client)

  305.         return 1;

  306. 

  307.     client->quequeMessage(MESSAGE_SHOW_GUI, 0, 0, 0.0);

  308. 

  309.     return 0;

  310. }

  311. 

  312. int CarlaOsc::handleMsgQuit()

  313. {

  314.     if (! client)

  315.         return 1;

  316. 

  317.     client->quequeMessage(MESSAGE_QUIT, 0, 0, 0.0);

  318. 

  319.     return 0;

  320. }

  321. 

  322. #if 0 //def BUILD_BRIDGE_PLUGIN

  323. void osc_send_bridge_ains_peak(int index, double value)

  324. {

  325.     if (global_osc_data.target)

  326.     {

  327.         char target_path[strlen(global_osc_data.path)+18];

  328.         strcpy(target_path, global_osc_data.path);

  329.         strcat(target_path, "/bridge_ains_peak");

  330.         lo_send(global_osc_data.target, target_path, "if", index, value);

  331.     }

  332. }

  333. 

  334. void osc_send_bridge_aouts_peak(int index, double value)

  335. {

  336.     if (global_osc_data.target)

  337.     {

  338.         char target_path[strlen(global_osc_data.path)+19];

  339.         strcpy(target_path, global_osc_data.path);

  340.         strcat(target_path, "/bridge_aouts_peak");

  341.         lo_send(global_osc_data.target, target_path, "if", index, value);

  342.     }

  343. }

  344. 

  345. void osc_send_bridge_audio_count(int ins, int outs, int total)

  346. {

  347.     if (global_osc_data.target)

  348.     {

  349.         char target_path[strlen(global_osc_data.path)+20];

  350.         strcpy(target_path, global_osc_data.path);

  351.         strcat(target_path, "/bridge_audio_count");

  352.         lo_send(global_osc_data.target, target_path, "iii", ins, outs, total);

  353.     }

  354. }

  355. 

  356. void osc_send_bridge_midi_count(int ins, int outs, int total)

  357. {

  358.     if (global_osc_data.target)

  359.     {

  360.         char target_path[strlen(global_osc_data.path)+19];

  361.         strcpy(target_path, global_osc_data.path);

  362.         strcat(target_path, "/bridge_midi_count");

  363.         lo_send(global_osc_data.target, target_path, "iii", ins, outs, total);

  364.     }

  365. }

  366. 

  367. void osc_send_bridge_param_count(int ins, int outs, int total)

  368. {

  369.     if (global_osc_data.target)

  370.     {

  371.         char target_path[strlen(global_osc_data.path)+20];

  372.         strcpy(target_path, global_osc_data.path);

  373.         strcat(target_path, "/bridge_param_count");

  374.         lo_send(global_osc_data.target, target_path, "iii", ins, outs, total);

  375.     }

  376. }

  377. 

  378. void osc_send_bridge_program_count(int count)

  379. {

  380.     if (global_osc_data.target)

  381.     {

  382.         char target_path[strlen(global_osc_data.path)+22];

  383.         strcpy(target_path, global_osc_data.path);

  384.         strcat(target_path, "/bridge_program_count");

  385.         lo_send(global_osc_data.target, target_path, "i", count);

  386.     }

  387. }

  388. 

  389. void osc_send_bridge_midi_program_count(int count)

  390. {

  391.     if (global_osc_data.target)

  392.     {

  393.         char target_path[strlen(global_osc_data.path)+27];

  394.         strcpy(target_path, global_osc_data.path);

  395.         strcat(target_path, "/bridge_midi_program_count");

  396.         lo_send(global_osc_data.target, target_path, "i", count);

  397.     }

  398. }

  399. 

  400. void osc_send_bridge_plugin_info(int category, int hints, const char* name, const char* label, const char* maker, const char* copyright, long uniqueId)

  401. {

  402.     if (global_osc_data.target)

  403.     {

  404.         char target_path[strlen(global_osc_data.path)+20];

  405.         strcpy(target_path, global_osc_data.path);

  406.         strcat(target_path, "/bridge_plugin_info");

  407.         lo_send(global_osc_data.target, target_path, "iissssi", category, hints, name, label, maker, copyright, uniqueId);

  408.         // FIXME - should be long type

  409.     }

  410. }

  411. 

  412. void osc_send_bridge_param_info(int index, const char* name, const char* unit)

  413. {

  414.     if (global_osc_data.target)

  415.     {

  416.         char target_path[strlen(global_osc_data.path)+19];

  417.         strcpy(target_path, global_osc_data.path);

  418.         strcat(target_path, "/bridge_param_info");

  419.         lo_send(global_osc_data.target, target_path, "iss", index, name, unit);

  420.     }

  421. }

  422. 

  423. void osc_send_bridge_param_data(int index, int type, int rindex, int hints, int midi_channel, int midi_cc)

  424. {

  425.     if (global_osc_data.target)

  426.     {

  427.         char target_path[strlen(global_osc_data.path)+19];

  428.         strcpy(target_path, global_osc_data.path);

  429.         strcat(target_path, "/bridge_param_data");

  430.         lo_send(global_osc_data.target, target_path, "iiiiii", index, type, rindex, hints, midi_channel, midi_cc);

  431.     }

  432. }

  433. 

  434. void osc_send_bridge_param_ranges(int index, double def, double min, double max, double step, double step_small, double step_large)

  435. {

  436.     if (global_osc_data.target)

  437.     {

  438.         char target_path[strlen(global_osc_data.path)+21];

  439.         strcpy(target_path, global_osc_data.path);

  440.         strcat(target_path, "/bridge_param_ranges");

  441.         lo_send(global_osc_data.target, target_path, "iffffff", index, def, min, max, step, step_small, step_large);

  442.     }

  443. }

  444. 

  445. void osc_send_bridge_program_info(int index, const char* name)

  446. {

  447.     if (global_osc_data.target)

  448.     {

  449.         char target_path[strlen(global_osc_data.path)+21];

  450.         strcpy(target_path, global_osc_data.path);

  451.         strcat(target_path, "/bridge_program_info");

  452.         lo_send(global_osc_data.target, target_path, "is", index, name);

  453.     }

  454. }

  455. 

  456. void osc_send_bridge_midi_program_info(int index, int bank, int program, const char* label)

  457. {

  458.     if (global_osc_data.target)

  459.     {

  460.         char target_path[strlen(global_osc_data.path)+26];

  461.         strcpy(target_path, global_osc_data.path);

  462.         strcat(target_path, "/bridge_midi_program_info");

  463.         lo_send(global_osc_data.target, target_path, "iiis", index, bank, program, label);

  464.     }

  465. }

  466. 

  467. void osc_send_bridge_custom_data(const char* stype, const char* key, const char* value)

  468. {

  469.     if (global_osc_data.target)

  470.     {

  471.         char target_path[strlen(global_osc_data.path)+20];

  472.         strcpy(target_path, global_osc_data.path);

  473.         strcat(target_path, "/bridge_custom_data");

  474.         lo_send(global_osc_data.target, target_path, "sss", stype, key, value);

  475.     }

  476. }

  477. 

  478. void osc_send_bridge_chunk_data(const char* string_data)

  479. {

  480.     if (global_osc_data.target)

  481.     {

  482.         char target_path[strlen(global_osc_data.path)+19];

  483.         strcpy(target_path, global_osc_data.path);

  484.         strcat(target_path, "/bridge_chunk_data");

  485.         lo_send(global_osc_data.target, target_path, "s", string_data);

  486.     }

  487. }

  488. 

  489. void osc_send_bridge_update()

  490. {

  491.     if (global_osc_data.target)

  492.     {

  493.         char target_path[strlen(global_osc_data.path)+15];

  494.         strcpy(target_path, global_osc_data.path);

  495.         strcat(target_path, "/bridge_update");

  496.         lo_send(global_osc_data.target, target_path, "");

  497.     }

  498. }

  499. #endif

  500. 

  501. CARLA_BRIDGE_END_NAMESPACE