1224 lines
48 KiB
C++
1224 lines
48 KiB
C++
/*
|
|
* Carla REST API Server
|
|
* Copyright (C) 2018 Filipe Coelho <falktx@falktx.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* For a full copy of the GNU General Public License see the doc/GPL.txt file.
|
|
*/
|
|
|
|
#include "common.hpp"
|
|
|
|
#include "CarlaHost.h"
|
|
#include "CarlaBackendUtils.hpp"
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
static bool gEngineRunning = false;
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
static void EngineCallback(void* ptr, EngineCallbackOpcode action, uint pluginId, int value1, int value2, float value3, const char* valueStr)
|
|
{
|
|
carla_debug("EngineCallback(%p, %u:%s, %u, %i, %i, %f, %s)",
|
|
ptr, (uint)action, EngineCallbackOpcode2Str(action), pluginId, value1, value2, value3, valueStr);
|
|
|
|
char msgBuf[1024];
|
|
std::snprintf(msgBuf, 1023, "Carla: %u %u %i %i %f %s", action, pluginId, value1, value2, value3, valueStr);
|
|
msgBuf[1023] = '\0';
|
|
|
|
switch (action)
|
|
{
|
|
case ENGINE_CALLBACK_ENGINE_STARTED:
|
|
gEngineRunning = true;
|
|
break;
|
|
case ENGINE_CALLBACK_ENGINE_STOPPED:
|
|
case ENGINE_CALLBACK_QUIT:
|
|
gEngineRunning = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return send_server_side_message(msgBuf);
|
|
|
|
// maybe unused
|
|
(void)ptr;
|
|
}
|
|
|
|
static const char* FileCallback(void* ptr, FileCallbackOpcode action, bool isDir, const char* title, const char* filter)
|
|
{
|
|
carla_stdout("FileCallback(%p, %u:%s, %s, %s, %s)",
|
|
ptr, (uint)action, FileCallbackOpcode(action), bool2str(isDir), title, filter);
|
|
|
|
char msgBuf[1024];
|
|
std::snprintf(msgBuf, 1023, "fc %u %i \"%s\" \"%s\"", action, isDir, title, filter);
|
|
msgBuf[1023] = '\0';
|
|
|
|
send_server_side_message(msgBuf);
|
|
|
|
// FIXME, need to wait for response!
|
|
return nullptr;
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_get_engine_driver_count(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_uint(carla_get_engine_driver_count());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_engine_driver_name(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int index = std::atoi(request->get_query_parameter("index").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(index >= 0 /*&& index < INT_MAX*/,)
|
|
|
|
const char* const buf = str_buf_string(carla_get_engine_driver_name(index));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_engine_driver_device_names(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int index = std::atoi(request->get_query_parameter("index").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(index >= 0 /*&& index < INT_MAX*/,)
|
|
|
|
const char* const buf = str_buf_string_array(carla_get_engine_driver_device_names(index));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_engine_driver_device_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int index = std::atoi(request->get_query_parameter("index").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(index >= 0 /*&& index < INT_MAX*/,)
|
|
|
|
const std::string name = request->get_query_parameter("name");
|
|
|
|
const EngineDriverDeviceInfo* const info = carla_get_engine_driver_device_info(index, name.c_str());
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "hints", info->hints);
|
|
jsonBuf = json_buf_add_uint_array(jsonBuf, "bufferSizes", info->bufferSizes);
|
|
jsonBuf = json_buf_add_float_array(jsonBuf, "sampleRates", info->sampleRates);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_engine_init(const std::shared_ptr<Session> session)
|
|
{
|
|
// setup callbacks
|
|
carla_set_engine_callback(EngineCallback, nullptr);
|
|
carla_set_file_callback(FileCallback, nullptr);
|
|
|
|
// handle request now
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const std::string driverName = request->get_query_parameter("driverName");
|
|
const std::string clientName = request->get_query_parameter("clientName");
|
|
|
|
const char* const buf = str_buf_bool(carla_engine_init(driverName.c_str(), clientName.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_engine_close(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_bool(carla_engine_close());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_is_engine_running(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_bool(carla_is_engine_running());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_set_engine_about_to_close(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_bool(carla_set_engine_about_to_close());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_set_engine_option(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int option = std::atol(request->get_query_parameter("option").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(option >= ENGINE_OPTION_DEBUG && option < ENGINE_OPTION_DEBUG_CONSOLE_OUTPUT,)
|
|
|
|
const int value = std::atol(request->get_query_parameter("value").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(value >= 0,)
|
|
|
|
const std::string valueStr = request->get_query_parameter("valueStr");
|
|
|
|
carla_set_engine_option(static_cast<EngineOption>(option), value, valueStr.c_str());
|
|
session->close(OK);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_load_file(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const std::string filename = request->get_query_parameter("filename");
|
|
|
|
const char* const buf = str_buf_bool(carla_load_file(filename.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_load_project(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const std::string filename = request->get_query_parameter("filename");
|
|
|
|
const char* const buf = str_buf_bool(carla_load_project(filename.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_save_project(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const std::string filename = request->get_query_parameter("filename");
|
|
|
|
const char* const buf = str_buf_bool(carla_save_project(filename.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_patchbay_connect(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int groupIdA = std::atoi(request->get_query_parameter("groupIdA").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(groupIdA >= 0,)
|
|
|
|
const int portIdA = std::atoi(request->get_query_parameter("portIdA").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(portIdA >= 0,)
|
|
|
|
const int groupIdB = std::atoi(request->get_query_parameter("groupIdB").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(groupIdB >= 0,)
|
|
|
|
const int portIdB = std::atoi(request->get_query_parameter("portIdB").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(portIdB >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_patchbay_connect(groupIdA, portIdA, groupIdB, portIdB));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_patchbay_disconnect(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int connectionId = std::atoi(request->get_query_parameter("connectionId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(connectionId >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_patchbay_disconnect(connectionId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_patchbay_refresh(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int external = std::atoi(request->get_query_parameter("external").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(external == 0 || external == 1,)
|
|
|
|
const char* const buf = str_buf_bool(carla_patchbay_refresh(external));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_transport_play(const std::shared_ptr<Session> session)
|
|
{
|
|
carla_transport_play();
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_transport_pause(const std::shared_ptr<Session> session)
|
|
{
|
|
carla_transport_pause();
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_transport_bpm(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const double bpm = std::atof(request->get_query_parameter("bpm").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(bpm > 0.0, session->close(OK)) // FIXME
|
|
|
|
carla_transport_bpm(bpm);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_transport_relocate(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const long int frame = std::atol(request->get_query_parameter("frame").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(frame >= 0,)
|
|
|
|
carla_transport_relocate(frame);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_get_current_transport_frame(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_uint64(carla_get_current_transport_frame());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_transport_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const CarlaTransportInfo* const info = carla_get_transport_info();
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_bool(jsonBuf, "playing", info->playing);
|
|
jsonBuf = json_buf_add_uint64(jsonBuf, "frame", info->frame);
|
|
jsonBuf = json_buf_add_int(jsonBuf, "bar", info->bar);
|
|
jsonBuf = json_buf_add_int(jsonBuf, "beat", info->beat);
|
|
jsonBuf = json_buf_add_int(jsonBuf, "tick", info->tick);
|
|
jsonBuf = json_buf_add_float(jsonBuf, "bpm", info->bpm);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_get_current_plugin_count(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_uint(carla_get_current_plugin_count());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_max_plugin_number(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_uint(carla_get_max_plugin_number());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_add_plugin(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const long int btype = std::atoi(request->get_query_parameter("btype").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(btype >= BINARY_NONE && btype <= BINARY_OTHER,)
|
|
|
|
const long int ptype = std::atoi(request->get_query_parameter("ptype").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(ptype >= PLUGIN_NONE && ptype <= PLUGIN_JACK,)
|
|
|
|
const std::string filename = request->get_query_parameter("filename");
|
|
const std::string name = request->get_query_parameter("name");
|
|
const std::string label = request->get_query_parameter("label");
|
|
|
|
const long int uniqueId = std::atol(request->get_query_parameter("uniqueId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(uniqueId >= 0,)
|
|
|
|
const int options = std::atoi(request->get_query_parameter("options").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(options >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_add_plugin(static_cast<BinaryType>(btype),
|
|
static_cast<PluginType>(ptype),
|
|
filename.c_str(),
|
|
name.c_str(),
|
|
label.c_str(),
|
|
uniqueId,
|
|
nullptr,
|
|
options));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_remove_plugin(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_remove_plugin(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_remove_all_plugins(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_bool(carla_remove_all_plugins());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_rename_plugin(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string newName = request->get_query_parameter("newName");
|
|
|
|
const char* const buf = carla_rename_plugin(pluginId, newName.c_str());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_clone_plugin(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_clone_plugin(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_replace_plugin(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_replace_plugin(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_switch_plugins(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginIdA = std::atol(request->get_query_parameter("pluginIdA").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginIdA >= 0,)
|
|
|
|
const int pluginIdB = std::atol(request->get_query_parameter("pluginIdB").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginIdB >= 0,)
|
|
|
|
const char* const buf = str_buf_bool(carla_switch_plugins(pluginIdA, pluginIdB));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_load_plugin_state(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string filename = request->get_query_parameter("filename");
|
|
|
|
const char* const buf = str_buf_bool(carla_load_plugin_state(pluginId, filename.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_save_plugin_state(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string filename = request->get_query_parameter("filename");
|
|
|
|
const char* const buf = str_buf_bool(carla_save_plugin_state(pluginId, filename.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_export_plugin_lv2(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string lv2path = request->get_query_parameter("lv2path");
|
|
|
|
const char* const buf = str_buf_bool(carla_export_plugin_lv2(pluginId, lv2path.c_str()));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_get_plugin_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const CarlaPluginInfo* const info = carla_get_plugin_info(pluginId);
|
|
|
|
// running remotely, so we cannot show custom UI or inline display
|
|
const uint hints = info->hints & ~(PLUGIN_HAS_CUSTOM_UI|PLUGIN_HAS_INLINE_DISPLAY);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "type", info->type);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "category", info->category);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "hints", hints);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "optionsAvailable", info->optionsAvailable);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "optionsEnabled", info->optionsEnabled);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "filename", info->filename);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "name", info->name);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "label", info->label);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "maker", info->maker);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "copyright", info->copyright);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "iconName", info->iconName);
|
|
jsonBuf = json_buf_add_int64(jsonBuf, "uniqueId", info->uniqueId);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_audio_port_count_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const CarlaPortCountInfo* const info = carla_get_audio_port_count_info(pluginId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "ins", info->ins);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "outs", info->outs);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_midi_port_count_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const CarlaPortCountInfo* const info = carla_get_midi_port_count_info(pluginId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "ins", info->ins);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "outs", info->outs);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_parameter_count_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const CarlaPortCountInfo* const info = carla_get_parameter_count_info(pluginId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "ins", info->ins);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "outs", info->outs);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_parameter_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const CarlaParameterInfo* const info = carla_get_parameter_info(pluginId, parameterId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_string(jsonBuf, "name", info->name);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "symbol", info->symbol);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "unit", info->unit);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "scalePointCount", info->scalePointCount);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_parameter_scalepoint_info(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const int scalePointId = std::atoi(request->get_query_parameter("scalePointId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(scalePointId >= 0,)
|
|
|
|
const CarlaScalePointInfo* const info = carla_get_parameter_scalepoint_info(pluginId, parameterId, scalePointId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_float(jsonBuf, "value", info->value);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "label", info->label);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_parameter_data(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const ParameterData* const info = carla_get_parameter_data(pluginId, parameterId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "type", info->type);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "hints", info->hints);
|
|
jsonBuf = json_buf_add_int(jsonBuf, "index", info->index);
|
|
jsonBuf = json_buf_add_int(jsonBuf, "rindex", info->rindex);
|
|
jsonBuf = json_buf_add_int(jsonBuf, "midiCC", info->midiCC);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "midiChannel", info->midiChannel);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_parameter_ranges(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const ParameterRanges* const info = carla_get_parameter_ranges(pluginId, parameterId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_float(jsonBuf, "def", info->def);
|
|
jsonBuf = json_buf_add_float(jsonBuf, "min", info->min);
|
|
jsonBuf = json_buf_add_float(jsonBuf, "max", info->max);
|
|
jsonBuf = json_buf_add_float(jsonBuf, "step", info->step);
|
|
jsonBuf = json_buf_add_float(jsonBuf, "stepSmall", info->stepSmall);
|
|
jsonBuf = json_buf_add_float(jsonBuf, "stepLarge", info->stepLarge);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_midi_program_data(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int midiProgramId = std::atoi(request->get_query_parameter("midiProgramId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(midiProgramId >= 0,)
|
|
|
|
const MidiProgramData* const info = carla_get_midi_program_data(pluginId, midiProgramId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "bank", info->bank);
|
|
jsonBuf = json_buf_add_uint(jsonBuf, "program", info->program);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "name", info->name);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_custom_data(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int customDataId = std::atoi(request->get_query_parameter("customDataId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(customDataId >= 0,)
|
|
|
|
const CustomData* const info = carla_get_custom_data(pluginId, customDataId);
|
|
|
|
char* jsonBuf;
|
|
jsonBuf = json_buf_start();
|
|
jsonBuf = json_buf_add_string(jsonBuf, "type", info->type);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "key", info->key);
|
|
jsonBuf = json_buf_add_string(jsonBuf, "value", info->value);
|
|
|
|
const char* const buf = json_buf_end(jsonBuf);
|
|
puts(buf);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_custom_data_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string type = request->get_query_parameter("type");
|
|
const std::string key = request->get_query_parameter("key");
|
|
|
|
const char* const buf = carla_get_custom_data_value(pluginId, type.c_str(), key.c_str());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_chunk_data(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = carla_get_chunk_data(pluginId);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_get_parameter_count(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_uint(carla_get_parameter_count(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_program_count(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_uint(carla_get_program_count(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_midi_program_count(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_uint(carla_get_midi_program_count(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_custom_data_count(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_uint(carla_get_custom_data_count(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_parameter_text(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const char* const buf = carla_get_parameter_text(pluginId, parameterId);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_program_name(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int programId = std::atoi(request->get_query_parameter("programId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(programId >= 0,)
|
|
|
|
const char* const buf = carla_get_program_name(pluginId, programId);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_midi_program_name(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int midiProgramId = std::atoi(request->get_query_parameter("midiProgramId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(midiProgramId >= 0,)
|
|
|
|
const char* const buf = carla_get_midi_program_name(pluginId, midiProgramId);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_real_plugin_name(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = carla_get_real_plugin_name(pluginId);
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_current_program_index(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_uint(carla_get_current_program_index(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_current_midi_program_index(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const char* const buf = str_buf_uint(carla_get_current_midi_program_index(pluginId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_default_parameter_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const char* const buf = str_buf_float(carla_get_default_parameter_value(pluginId, parameterId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_current_parameter_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const char* const buf = str_buf_float(carla_get_current_parameter_value(pluginId, parameterId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_internal_parameter_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId > PARAMETER_MAX,);
|
|
|
|
const char* const buf = str_buf_float(carla_get_internal_parameter_value(pluginId, parameterId));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_input_peak_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int isLeft = std::atoi(request->get_query_parameter("isLeft").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(isLeft == 0 || isLeft == 1,)
|
|
|
|
const char* const buf = str_buf_float(carla_get_input_peak_value(pluginId, isLeft));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_output_peak_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int isLeft = std::atoi(request->get_query_parameter("isLeft").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(isLeft == 0 || isLeft == 1,)
|
|
|
|
const char* const buf = str_buf_float(carla_get_output_peak_value(pluginId, isLeft));
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_set_active(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int onOff = std::atoi(request->get_query_parameter("onOff").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(onOff == 0 || onOff == 1,)
|
|
|
|
carla_set_active(pluginId, onOff);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_drywet(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const double value = std::atof(request->get_query_parameter("value").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(value >= 0.0 && value <= 1.0,)
|
|
|
|
carla_set_drywet(pluginId, value);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_volume(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const double value = std::atof(request->get_query_parameter("value").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(value >= 0.0 && value <= 1.27,)
|
|
|
|
carla_set_volume(pluginId, value);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_balance_left(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const double value = std::atof(request->get_query_parameter("value").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(value >= -1.0 && value <= 1.0,)
|
|
|
|
carla_set_balance_left(pluginId, value);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_balance_right(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const double value = std::atof(request->get_query_parameter("value").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(value >= -1.0 && value <= 1.0,)
|
|
|
|
carla_set_balance_right(pluginId, value);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_panning(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const double value = std::atof(request->get_query_parameter("value").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(value >= -1.0 && value <= 1.0,)
|
|
|
|
carla_set_panning(pluginId, value);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_ctrl_channel(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int channel = std::atoi(request->get_query_parameter("channel").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(channel < 16,)
|
|
|
|
carla_set_ctrl_channel(pluginId, channel);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_option(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int option = std::atoi(request->get_query_parameter("option").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(option >= 0,)
|
|
|
|
const int yesNo = std::atoi(request->get_query_parameter("yesNo").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(yesNo == 0 || yesNo == 1,)
|
|
|
|
carla_set_option(pluginId, option, yesNo);
|
|
session->close(OK);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_set_parameter_value(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const double value = std::atof(request->get_query_parameter("value").c_str());
|
|
|
|
carla_set_parameter_value(pluginId, parameterId, value);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_parameter_midi_channel(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const int channel = std::atoi(request->get_query_parameter("channel").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < 16,)
|
|
|
|
carla_set_parameter_midi_channel(pluginId, parameterId, channel);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_parameter_midi_cc(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int parameterId = std::atoi(request->get_query_parameter("parameterId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(parameterId >= 0,)
|
|
|
|
const int cc = std::atoi(request->get_query_parameter("channel").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(cc >= -1 && cc < INT16_MAX,);
|
|
|
|
carla_set_parameter_midi_cc(pluginId, parameterId, cc);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_program(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int programId = std::atoi(request->get_query_parameter("programId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(programId >= 0,)
|
|
|
|
carla_set_program(pluginId, programId);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_midi_program(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int midiProgramId = std::atoi(request->get_query_parameter("midiProgramId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(midiProgramId >= 0,)
|
|
|
|
carla_set_midi_program(pluginId, midiProgramId);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_custom_data(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string type = request->get_query_parameter("type");
|
|
const std::string key = request->get_query_parameter("key");
|
|
const std::string value = request->get_query_parameter("value");
|
|
|
|
carla_set_custom_data(pluginId, type.c_str(), key.c_str(), value.c_str());
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_set_chunk_data(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const std::string chunkData = request->get_query_parameter("chunkData");
|
|
|
|
carla_set_chunk_data(pluginId, chunkData.c_str());
|
|
session->close(OK);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_prepare_for_save(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
carla_prepare_for_save(pluginId);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_reset_parameters(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
carla_reset_parameters(pluginId);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_randomize_parameters(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
carla_randomize_parameters(pluginId);
|
|
session->close(OK);
|
|
}
|
|
|
|
void handle_carla_send_midi_note(const std::shared_ptr<Session> session)
|
|
{
|
|
const std::shared_ptr<const Request> request = session->get_request();
|
|
|
|
const int pluginId = std::atoi(request->get_query_parameter("pluginId").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(pluginId >= 0,)
|
|
|
|
const int channel = std::atoi(request->get_query_parameter("channel").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(channel >= 0 && channel < 16,)
|
|
|
|
const int note = std::atoi(request->get_query_parameter("note").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(note >= 0 && note < 128,)
|
|
|
|
const int velocity = std::atoi(request->get_query_parameter("velocity").c_str());
|
|
CARLA_SAFE_ASSERT_RETURN(velocity >= 0 && velocity < 128,)
|
|
|
|
carla_send_midi_note(pluginId, channel, note, velocity);
|
|
session->close(OK);
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|
|
|
|
void handle_carla_get_buffer_size(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_uint(carla_get_buffer_size());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_sample_rate(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = str_buf_float(carla_get_sample_rate());
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_last_error(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = carla_get_last_error();
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_host_osc_url_tcp(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = carla_get_host_osc_url_tcp();
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
void handle_carla_get_host_osc_url_udp(const std::shared_ptr<Session> session)
|
|
{
|
|
const char* const buf = carla_get_host_osc_url_udp();
|
|
session->close(OK, buf, { { "Content-Length", size_buf(buf) } } );
|
|
}
|
|
|
|
// -------------------------------------------------------------------------------------------------------------------
|