Signed-off-by: falkTX <falktx@falktx.com>tags/v2.4.3
@@ -92,9 +92,6 @@ endif | |||
_CARLA_APP_FILES = \ | |||
Carla$(APP_EXT) \ | |||
libcarla_host-plugin$(LIB_EXT) \ | |||
libcarla_native-plugin$(LIB_EXT) \ | |||
libcarla_standalone2$(LIB_EXT) \ | |||
$(_CARLA_HOST_FILES) \ | |||
$(_PYTHON_FILES) \ | |||
$(_QT5_DLLS) \ | |||
@@ -102,6 +99,12 @@ _CARLA_APP_FILES = \ | |||
$(_THEME_FILES) \ | |||
resources/lib | |||
ifneq ($(EMBED_TARGET),true) | |||
_CARLA_APP_FILES += \ | |||
libcarla_host-plugin$(LIB_EXT) \ | |||
libcarla_native-plugin$(LIB_EXT) \ | |||
libcarla_standalone2$(LIB_EXT) | |||
_CARLA_CONTROL_APP_FILES = \ | |||
Carla-Control$(APP_EXT) \ | |||
libcarla_utils$(LIB_EXT) \ | |||
@@ -147,6 +150,7 @@ _CARLA_VST2_PLUGIN_FILES = \ | |||
$(_QT5_PLUGINS:%=carla.vst/resources/%) \ | |||
$(_THEME_FILES:%=carla.vst/resources/%) | |||
endif | |||
endif # EMBED_TARGET | |||
ifeq ($(MACOS),true) | |||
CARLA_APP_FILES = $(_CARLA_APP_FILES:%=build/Carla.app/Contents/MacOS/%) | |||
@@ -218,6 +222,7 @@ endef | |||
define GENERATE_FINAL_ZIP | |||
endef | |||
endif | |||
# --------------------------------------------------------------------------------------------------------------------- | |||
# macOS plist files | |||
@@ -359,26 +359,26 @@ typedef struct _CarlaHostHandle* CarlaHostHandle; | |||
/*! | |||
* Get how many engine drivers are available. | |||
*/ | |||
CARLA_EXPORT uint carla_get_engine_driver_count(void); | |||
CARLA_API_EXPORT uint carla_get_engine_driver_count(void); | |||
/*! | |||
* Get an engine driver name. | |||
* @param index Driver index | |||
*/ | |||
CARLA_EXPORT const char* carla_get_engine_driver_name(uint index); | |||
CARLA_API_EXPORT const char* carla_get_engine_driver_name(uint index); | |||
/*! | |||
* Get the device names of an engine driver. | |||
* @param index Driver index | |||
*/ | |||
CARLA_EXPORT const char* const* carla_get_engine_driver_device_names(uint index); | |||
CARLA_API_EXPORT const char* const* carla_get_engine_driver_device_names(uint index); | |||
/*! | |||
* Get information about a device driver. | |||
* @param index Driver index | |||
* @param name Device name | |||
*/ | |||
CARLA_EXPORT const EngineDriverDeviceInfo* carla_get_engine_driver_device_info(uint index, const char* name); | |||
CARLA_API_EXPORT const EngineDriverDeviceInfo* carla_get_engine_driver_device_info(uint index, const char* name); | |||
/*! | |||
* Show a device custom control panel. | |||
@@ -386,19 +386,19 @@ CARLA_EXPORT const EngineDriverDeviceInfo* carla_get_engine_driver_device_info(u | |||
* @param index Driver index | |||
* @param name Device name | |||
*/ | |||
CARLA_EXPORT bool carla_show_engine_driver_device_control_panel(uint index, const char* name); | |||
CARLA_API_EXPORT bool carla_show_engine_driver_device_control_panel(uint index, const char* name); | |||
/*! | |||
* Create a global host handle for standalone application usage. | |||
*/ | |||
CARLA_EXPORT CarlaHostHandle carla_standalone_host_init(void); | |||
CARLA_API_EXPORT CarlaHostHandle carla_standalone_host_init(void); | |||
#ifdef __cplusplus | |||
/*! | |||
* Get the currently used engine, may be NULL. | |||
* @note C++ only | |||
*/ | |||
CARLA_EXPORT CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle); | |||
CARLA_API_EXPORT CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle); | |||
#endif | |||
/*! | |||
@@ -407,13 +407,13 @@ CARLA_EXPORT CarlaEngine* carla_get_engine_from_handle(CarlaHostHandle handle); | |||
* @param driverName Driver to use | |||
* @param clientName Engine master client name | |||
*/ | |||
CARLA_EXPORT bool carla_engine_init(CarlaHostHandle handle, const char* driverName, const char* clientName); | |||
CARLA_API_EXPORT bool carla_engine_init(CarlaHostHandle handle, const char* driverName, const char* clientName); | |||
#ifdef BUILD_BRIDGE | |||
/*! | |||
* Initialize the engine in bridged mode. | |||
*/ | |||
CARLA_EXPORT bool carla_engine_init_bridge(CarlaHostHandle handle, | |||
CARLA_API_EXPORT bool carla_engine_init_bridge(CarlaHostHandle handle, | |||
const char audioBaseName[6+1], | |||
const char rtClientBaseName[6+1], | |||
const char nonRtClientBaseName[6+1], | |||
@@ -426,68 +426,68 @@ CARLA_EXPORT bool carla_engine_init_bridge(CarlaHostHandle handle, | |||
* This function always closes the engine even if it returns false. | |||
* In other words, even when something goes wrong when closing the engine it still be closed nonetheless. | |||
*/ | |||
CARLA_EXPORT bool carla_engine_close(CarlaHostHandle handle); | |||
CARLA_API_EXPORT bool carla_engine_close(CarlaHostHandle handle); | |||
/*! | |||
* Idle the engine. | |||
* Do not call this if the engine is not running. | |||
*/ | |||
CARLA_EXPORT void carla_engine_idle(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_engine_idle(CarlaHostHandle handle); | |||
/*! | |||
* Check if the engine is running. | |||
*/ | |||
CARLA_EXPORT bool carla_is_engine_running(CarlaHostHandle handle); | |||
CARLA_API_EXPORT bool carla_is_engine_running(CarlaHostHandle handle); | |||
/*! | |||
* Get information about the currently running engine. | |||
*/ | |||
CARLA_EXPORT const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const CarlaRuntimeEngineInfo* carla_get_runtime_engine_info(CarlaHostHandle handle); | |||
#ifndef BUILD_BRIDGE | |||
/*! | |||
* Get information about the currently running engine driver device. | |||
*/ | |||
CARLA_EXPORT const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const CarlaRuntimeEngineDriverDeviceInfo* carla_get_runtime_engine_driver_device_info(CarlaHostHandle handle); | |||
/*! | |||
* Dynamically change buffer size and/or sample rate while engine is running. | |||
* @see ENGINE_DRIVER_DEVICE_VARIABLE_BUFFER_SIZE | |||
* @see ENGINE_DRIVER_DEVICE_VARIABLE_SAMPLE_RATE | |||
*/ | |||
CARLA_EXPORT bool carla_set_engine_buffer_size_and_sample_rate(CarlaHostHandle handle, uint bufferSize, double sampleRate); | |||
CARLA_API_EXPORT bool carla_set_engine_buffer_size_and_sample_rate(CarlaHostHandle handle, uint bufferSize, double sampleRate); | |||
/*! | |||
* Show the custom control panel for the current engine device. | |||
* @see ENGINE_DRIVER_DEVICE_HAS_CONTROL_PANEL | |||
*/ | |||
CARLA_EXPORT bool carla_show_engine_device_control_panel(CarlaHostHandle handle); | |||
CARLA_API_EXPORT bool carla_show_engine_device_control_panel(CarlaHostHandle handle); | |||
#endif | |||
/*! | |||
* Clear the xrun count on the engine, so that the next time carla_get_runtime_engine_info() is called, it returns 0. | |||
*/ | |||
CARLA_EXPORT void carla_clear_engine_xruns(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_clear_engine_xruns(CarlaHostHandle handle); | |||
/*! | |||
* Tell the engine to stop the current cancelable action. | |||
* @see ENGINE_CALLBACK_CANCELABLE_ACTION | |||
*/ | |||
CARLA_EXPORT void carla_cancel_engine_action(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_cancel_engine_action(CarlaHostHandle handle); | |||
/*! | |||
* Tell the engine it's about to close. | |||
* This is used to prevent the engine thread(s) from reactivating. | |||
* Returns true if there's no pending engine events. | |||
*/ | |||
CARLA_EXPORT bool carla_set_engine_about_to_close(CarlaHostHandle handle); | |||
CARLA_API_EXPORT bool carla_set_engine_about_to_close(CarlaHostHandle handle); | |||
/*! | |||
* Set the engine callback function. | |||
* @param func Callback function | |||
* @param ptr Callback pointer | |||
*/ | |||
CARLA_EXPORT void carla_set_engine_callback(CarlaHostHandle handle, EngineCallbackFunc func, void* ptr); | |||
CARLA_API_EXPORT void carla_set_engine_callback(CarlaHostHandle handle, EngineCallbackFunc func, void* ptr); | |||
/*! | |||
* Set an engine option. | |||
@@ -495,14 +495,14 @@ CARLA_EXPORT void carla_set_engine_callback(CarlaHostHandle handle, EngineCallba | |||
* @param value Value as number | |||
* @param valueStr Value as string | |||
*/ | |||
CARLA_EXPORT void carla_set_engine_option(CarlaHostHandle handle, EngineOption option, int value, const char* valueStr); | |||
CARLA_API_EXPORT void carla_set_engine_option(CarlaHostHandle handle, EngineOption option, int value, const char* valueStr); | |||
/*! | |||
* Set the file callback function. | |||
* @param func Callback function | |||
* @param ptr Callback pointer | |||
*/ | |||
CARLA_EXPORT void carla_set_file_callback(CarlaHostHandle handle, FileCallbackFunc func, void* ptr); | |||
CARLA_API_EXPORT void carla_set_file_callback(CarlaHostHandle handle, FileCallbackFunc func, void* ptr); | |||
/*! | |||
* Load a file of any type. | |||
@@ -510,36 +510,36 @@ CARLA_EXPORT void carla_set_file_callback(CarlaHostHandle handle, FileCallbackFu | |||
* either by direct handling (SF2 and SFZ) or by using an internal plugin (like Audio and MIDI). | |||
* @see carla_get_supported_file_extensions() | |||
*/ | |||
CARLA_EXPORT bool carla_load_file(CarlaHostHandle handle, const char* filename); | |||
CARLA_API_EXPORT bool carla_load_file(CarlaHostHandle handle, const char* filename); | |||
/*! | |||
* Load a Carla project file. | |||
* @note Currently loaded plugins are not removed; call carla_remove_all_plugins() first if needed. | |||
*/ | |||
CARLA_EXPORT bool carla_load_project(CarlaHostHandle handle, const char* filename); | |||
CARLA_API_EXPORT bool carla_load_project(CarlaHostHandle handle, const char* filename); | |||
/*! | |||
* Save current project to a file. | |||
*/ | |||
CARLA_EXPORT bool carla_save_project(CarlaHostHandle handle, const char* filename); | |||
CARLA_API_EXPORT bool carla_save_project(CarlaHostHandle handle, const char* filename); | |||
#ifndef BUILD_BRIDGE | |||
/*! | |||
* Get the currently set project folder. | |||
* @note Valid for both standalone and plugin versions. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_current_project_folder(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const char* carla_get_current_project_folder(CarlaHostHandle handle); | |||
/*! | |||
* Get the currently set project filename. | |||
* @note Valid only for both standalone version. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_current_project_filename(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const char* carla_get_current_project_filename(CarlaHostHandle handle); | |||
/*! | |||
* Clear the currently set project filename. | |||
*/ | |||
CARLA_EXPORT void carla_clear_project_filename(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_clear_project_filename(CarlaHostHandle handle); | |||
/*! | |||
* Connect two patchbay ports. | |||
@@ -551,14 +551,14 @@ CARLA_EXPORT void carla_clear_project_filename(CarlaHostHandle handle); | |||
* for ENGINE_CALLBACK_PATCHBAY_PORT_ADDED. | |||
* @see ENGINE_CALLBACK_PATCHBAY_CONNECTION_ADDED | |||
*/ | |||
CARLA_EXPORT bool carla_patchbay_connect(CarlaHostHandle handle, bool external, uint groupIdA, uint portIdA, uint groupIdB, uint portIdB); | |||
CARLA_API_EXPORT bool carla_patchbay_connect(CarlaHostHandle handle, bool external, uint groupIdA, uint portIdA, uint groupIdB, uint portIdB); | |||
/*! | |||
* Disconnect two patchbay ports. | |||
* @param connectionId Connection Id | |||
* @see ENGINE_CALLBACK_PATCHBAY_CONNECTION_REMOVED | |||
*/ | |||
CARLA_EXPORT bool carla_patchbay_disconnect(CarlaHostHandle handle, bool external, uint connectionId); | |||
CARLA_API_EXPORT bool carla_patchbay_disconnect(CarlaHostHandle handle, bool external, uint connectionId); | |||
/*! | |||
* Set the position of a group. | |||
@@ -566,7 +566,7 @@ CARLA_EXPORT bool carla_patchbay_disconnect(CarlaHostHandle handle, bool externa | |||
* When loading a project, callbacks are used to inform of the previously saved positions. | |||
* @see ENGINE_CALLBACK_PATCHBAY_CLIENT_POSITION_CHANGED | |||
*/ | |||
CARLA_EXPORT bool carla_patchbay_set_group_pos(CarlaHostHandle handle, bool external, | |||
CARLA_API_EXPORT bool carla_patchbay_set_group_pos(CarlaHostHandle handle, bool external, | |||
uint groupId, int x1, int y1, int x2, int y2); | |||
/*! | |||
@@ -574,49 +574,49 @@ CARLA_EXPORT bool carla_patchbay_set_group_pos(CarlaHostHandle handle, bool exte | |||
* @param external Wherever to show external/hardware ports instead of internal ones. | |||
* Only valid in patchbay engine mode, other modes will ignore this. | |||
*/ | |||
CARLA_EXPORT bool carla_patchbay_refresh(CarlaHostHandle handle, bool external); | |||
CARLA_API_EXPORT bool carla_patchbay_refresh(CarlaHostHandle handle, bool external); | |||
/*! | |||
* Start playback of the engine transport. | |||
*/ | |||
CARLA_EXPORT void carla_transport_play(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_transport_play(CarlaHostHandle handle); | |||
/*! | |||
* Pause the engine transport. | |||
*/ | |||
CARLA_EXPORT void carla_transport_pause(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_transport_pause(CarlaHostHandle handle); | |||
/*! | |||
* Set the engine transport bpm. | |||
*/ | |||
CARLA_EXPORT void carla_transport_bpm(CarlaHostHandle handle, double bpm); | |||
CARLA_API_EXPORT void carla_transport_bpm(CarlaHostHandle handle, double bpm); | |||
/*! | |||
* Relocate the engine transport to a specific frame. | |||
*/ | |||
CARLA_EXPORT void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame); | |||
CARLA_API_EXPORT void carla_transport_relocate(CarlaHostHandle handle, uint64_t frame); | |||
/*! | |||
* Get the current transport frame. | |||
*/ | |||
CARLA_EXPORT uint64_t carla_get_current_transport_frame(CarlaHostHandle handle); | |||
CARLA_API_EXPORT uint64_t carla_get_current_transport_frame(CarlaHostHandle handle); | |||
/*! | |||
* Get the engine transport information. | |||
*/ | |||
CARLA_EXPORT const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const CarlaTransportInfo* carla_get_transport_info(CarlaHostHandle handle); | |||
#endif | |||
/*! | |||
* Current number of plugins loaded. | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_current_plugin_count(CarlaHostHandle handle); | |||
CARLA_API_EXPORT uint32_t carla_get_current_plugin_count(CarlaHostHandle handle); | |||
/*! | |||
* Maximum number of loadable plugins allowed. | |||
* Returns 0 if engine is not started. | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_max_plugin_number(CarlaHostHandle handle); | |||
CARLA_API_EXPORT uint32_t carla_get_max_plugin_number(CarlaHostHandle handle); | |||
/*! | |||
* Add a new plugin. | |||
@@ -630,7 +630,7 @@ CARLA_EXPORT uint32_t carla_get_max_plugin_number(CarlaHostHandle handle); | |||
* @param extraPtr Extra pointer, defined per plugin type | |||
* @param options Initial plugin options | |||
*/ | |||
CARLA_EXPORT bool carla_add_plugin(CarlaHostHandle handle, | |||
CARLA_API_EXPORT bool carla_add_plugin(CarlaHostHandle handle, | |||
BinaryType btype, PluginType ptype, | |||
const char* filename, const char* name, const char* label, int64_t uniqueId, | |||
const void* extraPtr, uint options); | |||
@@ -639,12 +639,12 @@ CARLA_EXPORT bool carla_add_plugin(CarlaHostHandle handle, | |||
* Remove one plugin. | |||
* @param pluginId Plugin to remove. | |||
*/ | |||
CARLA_EXPORT bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT bool carla_remove_plugin(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Remove all plugins. | |||
*/ | |||
CARLA_EXPORT bool carla_remove_all_plugins(CarlaHostHandle handle); | |||
CARLA_API_EXPORT bool carla_remove_all_plugins(CarlaHostHandle handle); | |||
#ifndef BUILD_BRIDGE | |||
/*! | |||
@@ -653,13 +653,13 @@ CARLA_EXPORT bool carla_remove_all_plugins(CarlaHostHandle handle); | |||
* @param pluginId Plugin to rename | |||
* @param newName New plugin name | |||
*/ | |||
CARLA_EXPORT bool carla_rename_plugin(CarlaHostHandle handle, uint pluginId, const char* newName); | |||
CARLA_API_EXPORT bool carla_rename_plugin(CarlaHostHandle handle, uint pluginId, const char* newName); | |||
/*! | |||
* Clone a plugin. | |||
* @param pluginId Plugin to clone | |||
*/ | |||
CARLA_EXPORT bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Prepare replace of a plugin. | |||
@@ -667,14 +667,14 @@ CARLA_EXPORT bool carla_clone_plugin(CarlaHostHandle handle, uint pluginId); | |||
* @param pluginId Plugin to replace | |||
* @note This function requires carla_add_plugin() to be called afterwards *as soon as possible*. | |||
*/ | |||
CARLA_EXPORT bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT bool carla_replace_plugin(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Switch two plugins positions. | |||
* @param pluginIdA Plugin A | |||
* @param pluginIdB Plugin B | |||
*/ | |||
CARLA_EXPORT bool carla_switch_plugins(CarlaHostHandle handle, uint pluginIdA, uint pluginIdB); | |||
CARLA_API_EXPORT bool carla_switch_plugins(CarlaHostHandle handle, uint pluginIdA, uint pluginIdB); | |||
#endif | |||
/*! | |||
@@ -683,7 +683,7 @@ CARLA_EXPORT bool carla_switch_plugins(CarlaHostHandle handle, uint pluginIdA, u | |||
* @param filename Path to plugin state | |||
* @see carla_save_plugin_state() | |||
*/ | |||
CARLA_EXPORT bool carla_load_plugin_state(CarlaHostHandle handle, uint pluginId, const char* filename); | |||
CARLA_API_EXPORT bool carla_load_plugin_state(CarlaHostHandle handle, uint pluginId, const char* filename); | |||
/*! | |||
* Save a plugin state. | |||
@@ -691,38 +691,38 @@ CARLA_EXPORT bool carla_load_plugin_state(CarlaHostHandle handle, uint pluginId, | |||
* @param filename Path to plugin state | |||
* @see carla_load_plugin_state() | |||
*/ | |||
CARLA_EXPORT bool carla_save_plugin_state(CarlaHostHandle handle, uint pluginId, const char* filename); | |||
CARLA_API_EXPORT bool carla_save_plugin_state(CarlaHostHandle handle, uint pluginId, const char* filename); | |||
/*! | |||
* Export plugin as LV2. | |||
* @param pluginId Plugin | |||
* @param lv2path Path to lv2 plugin folder | |||
*/ | |||
CARLA_EXPORT bool carla_export_plugin_lv2(CarlaHostHandle handle, uint pluginId, const char* lv2path); | |||
CARLA_API_EXPORT bool carla_export_plugin_lv2(CarlaHostHandle handle, uint pluginId, const char* lv2path); | |||
/*! | |||
* Get information from a plugin. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const CarlaPluginInfo* carla_get_plugin_info(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const CarlaPluginInfo* carla_get_plugin_info(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get audio port count information from a plugin. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const CarlaPortCountInfo* carla_get_audio_port_count_info(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const CarlaPortCountInfo* carla_get_audio_port_count_info(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get MIDI port count information from a plugin. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const CarlaPortCountInfo* carla_get_midi_port_count_info(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const CarlaPortCountInfo* carla_get_midi_port_count_info(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get parameter count information from a plugin. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const CarlaPortCountInfo* carla_get_parameter_count_info(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const CarlaPortCountInfo* carla_get_parameter_count_info(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get hints about an audio port. | |||
@@ -730,7 +730,7 @@ CARLA_EXPORT const CarlaPortCountInfo* carla_get_parameter_count_info(CarlaHostH | |||
* @param isOutput Whether port is output, input otherwise | |||
* @param portIndex Port index, related to input or output | |||
*/ | |||
CARLA_EXPORT uint carla_get_audio_port_hints(CarlaHostHandle handle, uint pluginId, bool isOutput, uint32_t portIndex); | |||
CARLA_API_EXPORT uint carla_get_audio_port_hints(CarlaHostHandle handle, uint pluginId, bool isOutput, uint32_t portIndex); | |||
/*! | |||
* Get parameter information from a plugin. | |||
@@ -738,7 +738,7 @@ CARLA_EXPORT uint carla_get_audio_port_hints(CarlaHostHandle handle, uint plugin | |||
* @param parameterId Parameter index | |||
* @see carla_get_parameter_count() | |||
*/ | |||
CARLA_EXPORT const CarlaParameterInfo* carla_get_parameter_info(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const CarlaParameterInfo* carla_get_parameter_info(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId); | |||
@@ -749,7 +749,7 @@ CARLA_EXPORT const CarlaParameterInfo* carla_get_parameter_info(CarlaHostHandle | |||
* @param scalePointId Parameter scale-point index | |||
* @see CarlaParameterInfo::scalePointCount | |||
*/ | |||
CARLA_EXPORT const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId, | |||
uint32_t scalePointId); | |||
@@ -760,7 +760,7 @@ CARLA_EXPORT const CarlaScalePointInfo* carla_get_parameter_scalepoint_info(Carl | |||
* @param parameterId Parameter index | |||
* @see carla_get_parameter_count() | |||
*/ | |||
CARLA_EXPORT const ParameterData* carla_get_parameter_data(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const ParameterData* carla_get_parameter_data(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId); | |||
@@ -770,7 +770,7 @@ CARLA_EXPORT const ParameterData* carla_get_parameter_data(CarlaHostHandle handl | |||
* @param parameterId Parameter index | |||
* @see carla_get_parameter_count() | |||
*/ | |||
CARLA_EXPORT const ParameterRanges* carla_get_parameter_ranges(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const ParameterRanges* carla_get_parameter_ranges(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId); | |||
@@ -780,7 +780,7 @@ CARLA_EXPORT const ParameterRanges* carla_get_parameter_ranges(CarlaHostHandle h | |||
* @param midiProgramId MIDI Program index | |||
* @see carla_get_midi_program_count() | |||
*/ | |||
CARLA_EXPORT const MidiProgramData* carla_get_midi_program_data(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const MidiProgramData* carla_get_midi_program_data(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t midiProgramId); | |||
@@ -790,7 +790,7 @@ CARLA_EXPORT const MidiProgramData* carla_get_midi_program_data(CarlaHostHandle | |||
* @param customDataId Custom data index | |||
* @see carla_get_custom_data_count() | |||
*/ | |||
CARLA_EXPORT const CustomData* carla_get_custom_data(CarlaHostHandle handle, uint pluginId, uint32_t customDataId); | |||
CARLA_API_EXPORT const CustomData* carla_get_custom_data(CarlaHostHandle handle, uint pluginId, uint32_t customDataId); | |||
/*! | |||
* Get a plugin's custom data value, using type and key. | |||
@@ -799,7 +799,7 @@ CARLA_EXPORT const CustomData* carla_get_custom_data(CarlaHostHandle handle, uin | |||
* @param key Custom data key | |||
* @see carla_get_custom_data_count() | |||
*/ | |||
CARLA_EXPORT const char* carla_get_custom_data_value(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const char* carla_get_custom_data_value(CarlaHostHandle handle, | |||
uint pluginId, | |||
const char* type, | |||
const char* key); | |||
@@ -809,34 +809,34 @@ CARLA_EXPORT const char* carla_get_custom_data_value(CarlaHostHandle handle, | |||
* @param pluginId Plugin | |||
* @see PLUGIN_OPTION_USE_CHUNKS and carla_set_chunk_data() | |||
*/ | |||
CARLA_EXPORT const char* carla_get_chunk_data(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const char* carla_get_chunk_data(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get how many parameters a plugin has. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT uint32_t carla_get_parameter_count(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get how many programs a plugin has. | |||
* @param pluginId Plugin | |||
* @see carla_get_program_name() | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT uint32_t carla_get_program_count(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get how many MIDI programs a plugin has. | |||
* @param pluginId Plugin | |||
* @see carla_get_midi_program_name() and carla_get_midi_program_data() | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT uint32_t carla_get_midi_program_count(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get how many custom data sets a plugin has. | |||
* @param pluginId Plugin | |||
* @see carla_get_custom_data() | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get a plugin's parameter text (custom display of internal values). | |||
@@ -844,7 +844,7 @@ CARLA_EXPORT uint32_t carla_get_custom_data_count(CarlaHostHandle handle, uint p | |||
* @param parameterId Parameter index | |||
* @see PARAMETER_USES_CUSTOM_TEXT | |||
*/ | |||
CARLA_EXPORT const char* carla_get_parameter_text(CarlaHostHandle handle, uint pluginId, uint32_t parameterId); | |||
CARLA_API_EXPORT const char* carla_get_parameter_text(CarlaHostHandle handle, uint pluginId, uint32_t parameterId); | |||
/*! | |||
* Get a plugin's program name. | |||
@@ -852,7 +852,7 @@ CARLA_EXPORT const char* carla_get_parameter_text(CarlaHostHandle handle, uint p | |||
* @param programId Program index | |||
* @see carla_get_program_count() | |||
*/ | |||
CARLA_EXPORT const char* carla_get_program_name(CarlaHostHandle handle, uint pluginId, uint32_t programId); | |||
CARLA_API_EXPORT const char* carla_get_program_name(CarlaHostHandle handle, uint pluginId, uint32_t programId); | |||
/*! | |||
* Get a plugin's MIDI program name. | |||
@@ -860,40 +860,40 @@ CARLA_EXPORT const char* carla_get_program_name(CarlaHostHandle handle, uint plu | |||
* @param midiProgramId MIDI Program index | |||
* @see carla_get_midi_program_count() | |||
*/ | |||
CARLA_EXPORT const char* carla_get_midi_program_name(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId); | |||
CARLA_API_EXPORT const char* carla_get_midi_program_name(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId); | |||
/*! | |||
* Get a plugin's real name. | |||
* This is the name the plugin uses to identify itself; may not be unique. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const char* carla_get_real_plugin_name(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const char* carla_get_real_plugin_name(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get a plugin's program index. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT int32_t carla_get_current_program_index(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get a plugin's midi program index. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT int32_t carla_get_current_midi_program_index(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get a plugin's default parameter value. | |||
* @param pluginId Plugin | |||
* @param parameterId Parameter index | |||
*/ | |||
CARLA_EXPORT float carla_get_default_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId); | |||
CARLA_API_EXPORT float carla_get_default_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId); | |||
/*! | |||
* Get a plugin's current parameter value. | |||
* @param pluginId Plugin | |||
* @param parameterId Parameter index | |||
*/ | |||
CARLA_EXPORT float carla_get_current_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId); | |||
CARLA_API_EXPORT float carla_get_current_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId); | |||
/*! | |||
* Get a plugin's internal parameter value. | |||
@@ -901,40 +901,40 @@ CARLA_EXPORT float carla_get_current_parameter_value(CarlaHostHandle handle, uin | |||
* @param parameterId Parameter index, maybe be negative | |||
* @see InternalParameterIndex | |||
*/ | |||
CARLA_EXPORT float carla_get_internal_parameter_value(CarlaHostHandle handle, uint pluginId, int32_t parameterId); | |||
CARLA_API_EXPORT float carla_get_internal_parameter_value(CarlaHostHandle handle, uint pluginId, int32_t parameterId); | |||
/*! | |||
* Get a plugin's internal latency, in samples. | |||
* @param pluginId Plugin | |||
* @see InternalParameterIndex | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_plugin_latency(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT uint32_t carla_get_plugin_latency(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get a plugin's peak values. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const float* carla_get_peak_values(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT const float* carla_get_peak_values(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Get a plugin's input peak value. | |||
* @param pluginId Plugin | |||
* @param isLeft Wherever to get the left/mono value, otherwise right. | |||
*/ | |||
CARLA_EXPORT float carla_get_input_peak_value(CarlaHostHandle handle, uint pluginId, bool isLeft); | |||
CARLA_API_EXPORT float carla_get_input_peak_value(CarlaHostHandle handle, uint pluginId, bool isLeft); | |||
/*! | |||
* Get a plugin's output peak value. | |||
* @param pluginId Plugin | |||
* @param isLeft Wherever to get the left/mono value, otherwise right. | |||
*/ | |||
CARLA_EXPORT float carla_get_output_peak_value(CarlaHostHandle handle, uint pluginId, bool isLeft); | |||
CARLA_API_EXPORT float carla_get_output_peak_value(CarlaHostHandle handle, uint pluginId, bool isLeft); | |||
/*! | |||
* Render a plugin's inline display. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle, | |||
CARLA_API_EXPORT const CarlaInlineDisplayImageSurface* carla_render_inline_display(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t width, | |||
uint32_t height); | |||
@@ -944,7 +944,7 @@ CARLA_EXPORT const CarlaInlineDisplayImageSurface* carla_render_inline_display(C | |||
* @param pluginId Plugin | |||
* @param onOff New active state | |||
*/ | |||
CARLA_EXPORT void carla_set_active(CarlaHostHandle handle, uint pluginId, bool onOff); | |||
CARLA_API_EXPORT void carla_set_active(CarlaHostHandle handle, uint pluginId, bool onOff); | |||
#ifndef BUILD_BRIDGE | |||
/*! | |||
@@ -952,42 +952,42 @@ CARLA_EXPORT void carla_set_active(CarlaHostHandle handle, uint pluginId, bool o | |||
* @param pluginId Plugin | |||
* @param value New dry/wet value | |||
*/ | |||
CARLA_EXPORT void carla_set_drywet(CarlaHostHandle handle, uint pluginId, float value); | |||
CARLA_API_EXPORT void carla_set_drywet(CarlaHostHandle handle, uint pluginId, float value); | |||
/*! | |||
* Change a plugin's internal volume. | |||
* @param pluginId Plugin | |||
* @param value New volume | |||
*/ | |||
CARLA_EXPORT void carla_set_volume(CarlaHostHandle handle, uint pluginId, float value); | |||
CARLA_API_EXPORT void carla_set_volume(CarlaHostHandle handle, uint pluginId, float value); | |||
/*! | |||
* Change a plugin's internal stereo balance, left channel. | |||
* @param pluginId Plugin | |||
* @param value New value | |||
*/ | |||
CARLA_EXPORT void carla_set_balance_left(CarlaHostHandle handle, uint pluginId, float value); | |||
CARLA_API_EXPORT void carla_set_balance_left(CarlaHostHandle handle, uint pluginId, float value); | |||
/*! | |||
* Change a plugin's internal stereo balance, right channel. | |||
* @param pluginId Plugin | |||
* @param value New value | |||
*/ | |||
CARLA_EXPORT void carla_set_balance_right(CarlaHostHandle handle, uint pluginId, float value); | |||
CARLA_API_EXPORT void carla_set_balance_right(CarlaHostHandle handle, uint pluginId, float value); | |||
/*! | |||
* Change a plugin's internal mono panning value. | |||
* @param pluginId Plugin | |||
* @param value New value | |||
*/ | |||
CARLA_EXPORT void carla_set_panning(CarlaHostHandle handle, uint pluginId, float value); | |||
CARLA_API_EXPORT void carla_set_panning(CarlaHostHandle handle, uint pluginId, float value); | |||
/*! | |||
* Change a plugin's internal control channel. | |||
* @param pluginId Plugin | |||
* @param channel New channel | |||
*/ | |||
CARLA_EXPORT void carla_set_ctrl_channel(CarlaHostHandle handle, uint pluginId, int8_t channel); | |||
CARLA_API_EXPORT void carla_set_ctrl_channel(CarlaHostHandle handle, uint pluginId, int8_t channel); | |||
#endif | |||
/*! | |||
@@ -996,7 +996,7 @@ CARLA_EXPORT void carla_set_ctrl_channel(CarlaHostHandle handle, uint pluginId, | |||
* @param option An option from PluginOptions | |||
* @param yesNo New enabled state | |||
*/ | |||
CARLA_EXPORT void carla_set_option(CarlaHostHandle handle, uint pluginId, uint option, bool yesNo); | |||
CARLA_API_EXPORT void carla_set_option(CarlaHostHandle handle, uint pluginId, uint option, bool yesNo); | |||
/*! | |||
* Change a plugin's parameter value. | |||
@@ -1004,7 +1004,7 @@ CARLA_EXPORT void carla_set_option(CarlaHostHandle handle, uint pluginId, uint o | |||
* @param parameterId Parameter index | |||
* @param value New value | |||
*/ | |||
CARLA_EXPORT void carla_set_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, float value); | |||
CARLA_API_EXPORT void carla_set_parameter_value(CarlaHostHandle handle, uint pluginId, uint32_t parameterId, float value); | |||
#ifndef BUILD_BRIDGE | |||
/*! | |||
@@ -1013,7 +1013,7 @@ CARLA_EXPORT void carla_set_parameter_value(CarlaHostHandle handle, uint pluginI | |||
* @param parameterId Parameter index | |||
* @param channel New MIDI channel | |||
*/ | |||
CARLA_EXPORT void carla_set_parameter_midi_channel(CarlaHostHandle handle, | |||
CARLA_API_EXPORT void carla_set_parameter_midi_channel(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId, | |||
uint8_t channel); | |||
@@ -1024,7 +1024,7 @@ CARLA_EXPORT void carla_set_parameter_midi_channel(CarlaHostHandle handle, | |||
* @param parameterId Parameter index | |||
* @param cc New control index | |||
*/ | |||
CARLA_EXPORT void carla_set_parameter_mapped_control_index(CarlaHostHandle handle, | |||
CARLA_API_EXPORT void carla_set_parameter_mapped_control_index(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId, | |||
int16_t index); | |||
@@ -1036,7 +1036,7 @@ CARLA_EXPORT void carla_set_parameter_mapped_control_index(CarlaHostHandle handl | |||
* @param minimum New mapped minimum | |||
* @param maximum New mapped maximum | |||
*/ | |||
CARLA_EXPORT void carla_set_parameter_mapped_range(CarlaHostHandle handle, | |||
CARLA_API_EXPORT void carla_set_parameter_mapped_range(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId, | |||
float minimum, float maximum); | |||
@@ -1048,7 +1048,7 @@ CARLA_EXPORT void carla_set_parameter_mapped_range(CarlaHostHandle handle, | |||
* @param parameterId Parameter index | |||
* @param touch New state | |||
*/ | |||
CARLA_EXPORT void carla_set_parameter_touch(CarlaHostHandle handle, | |||
CARLA_API_EXPORT void carla_set_parameter_touch(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint32_t parameterId, | |||
bool touch); | |||
@@ -1059,14 +1059,14 @@ CARLA_EXPORT void carla_set_parameter_touch(CarlaHostHandle handle, | |||
* @param pluginId Plugin | |||
* @param programId New program | |||
*/ | |||
CARLA_EXPORT void carla_set_program(CarlaHostHandle handle, uint pluginId, uint32_t programId); | |||
CARLA_API_EXPORT void carla_set_program(CarlaHostHandle handle, uint pluginId, uint32_t programId); | |||
/*! | |||
* Change a plugin's current MIDI program. | |||
* @param pluginId Plugin | |||
* @param midiProgramId New value | |||
*/ | |||
CARLA_EXPORT void carla_set_midi_program(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId); | |||
CARLA_API_EXPORT void carla_set_midi_program(CarlaHostHandle handle, uint pluginId, uint32_t midiProgramId); | |||
/*! | |||
* Set a plugin's custom data set. | |||
@@ -1076,7 +1076,7 @@ CARLA_EXPORT void carla_set_midi_program(CarlaHostHandle handle, uint pluginId, | |||
* @param value New value | |||
* @see CustomDataTypes and CustomDataKeys | |||
*/ | |||
CARLA_EXPORT void carla_set_custom_data(CarlaHostHandle handle, | |||
CARLA_API_EXPORT void carla_set_custom_data(CarlaHostHandle handle, | |||
uint pluginId, | |||
const char* type, const char* key, const char* value); | |||
@@ -1086,26 +1086,26 @@ CARLA_EXPORT void carla_set_custom_data(CarlaHostHandle handle, | |||
* @param chunkData New chunk data | |||
* @see PLUGIN_OPTION_USE_CHUNKS and carla_get_chunk_data() | |||
*/ | |||
CARLA_EXPORT void carla_set_chunk_data(CarlaHostHandle handle, uint pluginId, const char* chunkData); | |||
CARLA_API_EXPORT void carla_set_chunk_data(CarlaHostHandle handle, uint pluginId, const char* chunkData); | |||
/*! | |||
* Tell a plugin to prepare for save. | |||
* This should be called before saving custom data sets. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT void carla_prepare_for_save(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Reset all plugin's parameters. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT void carla_reset_parameters(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT void carla_reset_parameters(CarlaHostHandle handle, uint pluginId); | |||
/*! | |||
* Randomize all plugin's parameters. | |||
* @param pluginId Plugin | |||
*/ | |||
CARLA_EXPORT void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId); | |||
CARLA_API_EXPORT void carla_randomize_parameters(CarlaHostHandle handle, uint pluginId); | |||
#ifndef BUILD_BRIDGE | |||
/*! | |||
@@ -1116,7 +1116,7 @@ CARLA_EXPORT void carla_randomize_parameters(CarlaHostHandle handle, uint plugin | |||
* @param note Note pitch | |||
* @param velocity Note velocity | |||
*/ | |||
CARLA_EXPORT void carla_send_midi_note(CarlaHostHandle handle, | |||
CARLA_API_EXPORT void carla_send_midi_note(CarlaHostHandle handle, | |||
uint pluginId, | |||
uint8_t channel, uint8_t note, uint8_t velocity); | |||
#endif | |||
@@ -1124,7 +1124,7 @@ CARLA_EXPORT void carla_send_midi_note(CarlaHostHandle handle, | |||
/*! | |||
* Set a custom title for the plugin UI window created by Carla. | |||
*/ | |||
CARLA_EXPORT void carla_set_custom_ui_title(CarlaHostHandle handle, uint pluginId, const char* title); | |||
CARLA_API_EXPORT void carla_set_custom_ui_title(CarlaHostHandle handle, uint pluginId, const char* title); | |||
/*! | |||
* Tell a plugin to show its own custom UI. | |||
@@ -1132,83 +1132,83 @@ CARLA_EXPORT void carla_set_custom_ui_title(CarlaHostHandle handle, uint pluginI | |||
* @param yesNo New UI state, visible or not | |||
* @see PLUGIN_HAS_CUSTOM_UI | |||
*/ | |||
CARLA_EXPORT void carla_show_custom_ui(CarlaHostHandle handle, uint pluginId, bool yesNo); | |||
CARLA_API_EXPORT void carla_show_custom_ui(CarlaHostHandle handle, uint pluginId, bool yesNo); | |||
/*! | |||
* Embed the plugin's custom UI to the system pointer @a ptr. | |||
* This function is always called from the main thread. | |||
* @note This is very experimental and subject to change at this point | |||
*/ | |||
CARLA_EXPORT void* carla_embed_custom_ui(CarlaHostHandle handle, uint pluginId, void* ptr); | |||
CARLA_API_EXPORT void* carla_embed_custom_ui(CarlaHostHandle handle, uint pluginId, void* ptr); | |||
/*! | |||
* Get the current engine buffer size. | |||
*/ | |||
CARLA_EXPORT uint32_t carla_get_buffer_size(CarlaHostHandle handle); | |||
CARLA_API_EXPORT uint32_t carla_get_buffer_size(CarlaHostHandle handle); | |||
/*! | |||
* Get the current engine sample rate. | |||
*/ | |||
CARLA_EXPORT double carla_get_sample_rate(CarlaHostHandle handle); | |||
CARLA_API_EXPORT double carla_get_sample_rate(CarlaHostHandle handle); | |||
/*! | |||
* Get the last error. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_last_error(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const char* carla_get_last_error(CarlaHostHandle handle); | |||
/*! | |||
* Get the current engine OSC URL (TCP). | |||
*/ | |||
CARLA_EXPORT const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const char* carla_get_host_osc_url_tcp(CarlaHostHandle handle); | |||
/*! | |||
* Get the current engine OSC URL (UDP). | |||
*/ | |||
CARLA_EXPORT const char* carla_get_host_osc_url_udp(CarlaHostHandle handle); | |||
CARLA_API_EXPORT const char* carla_get_host_osc_url_udp(CarlaHostHandle handle); | |||
/*! | |||
* Initialize NSM (that is, announce ourselves to it). | |||
* Must be called as early as possible in the program's lifecycle. | |||
* Returns true if NSM is available and initialized correctly. | |||
*/ | |||
CARLA_EXPORT bool carla_nsm_init(CarlaHostHandle handle, uint64_t pid, const char* executableName); | |||
CARLA_API_EXPORT bool carla_nsm_init(CarlaHostHandle handle, uint64_t pid, const char* executableName); | |||
/*! | |||
* Respond to an NSM callback. | |||
*/ | |||
CARLA_EXPORT void carla_nsm_ready(CarlaHostHandle handle, NsmCallbackOpcode opcode); | |||
CARLA_API_EXPORT void carla_nsm_ready(CarlaHostHandle handle, NsmCallbackOpcode opcode); | |||
#ifndef CARLA_UTILS_H_INCLUDED | |||
/*! | |||
* Get the complete license text of used third-party code and features. | |||
* Returned string is in basic html format. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_complete_license_text(void); | |||
CARLA_API_EXPORT const char* carla_get_complete_license_text(void); | |||
/*! | |||
* Get the juce version used in the current Carla build. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_juce_version(void); | |||
CARLA_API_EXPORT const char* carla_get_juce_version(void); | |||
/*! | |||
* Get the list of supported file extensions in carla_load_file(). | |||
*/ | |||
CARLA_EXPORT const char* const* carla_get_supported_file_extensions(void); | |||
CARLA_API_EXPORT const char* const* carla_get_supported_file_extensions(void); | |||
/*! | |||
* Get the list of supported features in the current Carla build. | |||
*/ | |||
CARLA_EXPORT const char* const* carla_get_supported_features(void); | |||
CARLA_API_EXPORT const char* const* carla_get_supported_features(void); | |||
/*! | |||
* Get the absolute filename of this carla library. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_library_filename(void); | |||
CARLA_API_EXPORT const char* carla_get_library_filename(void); | |||
/*! | |||
* Get the folder where this carla library resides. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_library_folder(void); | |||
CARLA_API_EXPORT const char* carla_get_library_folder(void); | |||
#endif | |||
/** @} */ | |||
@@ -2403,7 +2403,7 @@ const char* carla_get_host_osc_url_udp(CarlaHostHandle handle) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
#ifndef CARLA_PLUGIN_EXPORT | |||
#ifndef CARLA_PLUGIN_BUILD | |||
# define CARLA_PLUGIN_UI_CLASS_PREFIX Standalone | |||
# include "CarlaPluginUI.cpp" | |||
# undef CARLA_PLUGIN_UI_CLASS_PREFIX | |||
@@ -2415,6 +2415,6 @@ const char* carla_get_host_osc_url_udp(CarlaHostHandle handle) | |||
# include "CarlaStateUtils.cpp" | |||
# include "utils/Information.cpp" | |||
# include "utils/Windows.cpp" | |||
#endif /* CARLA_PLUGIN_EXPORT */ | |||
#endif /* CARLA_PLUGIN_BUILD */ | |||
// -------------------------------------------------------------------------------------------------------------------- |
@@ -149,7 +149,7 @@ typedef struct _CarlaCachedPluginInfo { | |||
* @note if this carla build uses JUCE, then you must call carla_juce_init beforehand | |||
* @note for AU plugins, you cannot call this outside the main thread | |||
*/ | |||
CARLA_EXPORT uint carla_get_cached_plugin_count(PluginType ptype, const char* pluginPath); | |||
CARLA_PLUGIN_EXPORT uint carla_get_cached_plugin_count(PluginType ptype, const char* pluginPath); | |||
/*! | |||
* Get information about a cached plugin. | |||
@@ -157,7 +157,7 @@ CARLA_EXPORT uint carla_get_cached_plugin_count(PluginType ptype, const char* pl | |||
* @note if this carla build uses JUCE, then you must call carla_juce_init beforehand | |||
* @note for AU plugins, you cannot call this outside the main thread | |||
*/ | |||
CARLA_EXPORT const CarlaCachedPluginInfo* carla_get_cached_plugin_info(PluginType ptype, uint index); | |||
CARLA_PLUGIN_EXPORT const CarlaCachedPluginInfo* carla_get_cached_plugin_info(PluginType ptype, uint index); | |||
#ifndef CARLA_HOST_H_INCLUDED | |||
/* -------------------------------------------------------------------------------------------------------------------- | |||
@@ -167,32 +167,32 @@ CARLA_EXPORT const CarlaCachedPluginInfo* carla_get_cached_plugin_info(PluginTyp | |||
* Get the complete license text of used third-party code and features. | |||
* Returned string is in basic html format. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_complete_license_text(void); | |||
CARLA_PLUGIN_EXPORT const char* carla_get_complete_license_text(void); | |||
/*! | |||
* Get the juce version used in the current Carla build. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_juce_version(void); | |||
CARLA_PLUGIN_EXPORT const char* carla_get_juce_version(void); | |||
/*! | |||
* Get the list of supported file extensions in carla_load_file(). | |||
*/ | |||
CARLA_EXPORT const char* const* carla_get_supported_file_extensions(void); | |||
CARLA_PLUGIN_EXPORT const char* const* carla_get_supported_file_extensions(void); | |||
/*! | |||
* Get the list of supported features in the current Carla build. | |||
*/ | |||
CARLA_EXPORT const char* const* carla_get_supported_features(void); | |||
CARLA_PLUGIN_EXPORT const char* const* carla_get_supported_features(void); | |||
/*! | |||
* Get the absolute filename of this carla library. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_library_filename(void); | |||
CARLA_PLUGIN_EXPORT const char* carla_get_library_filename(void); | |||
/*! | |||
* Get the folder where this carla library resides. | |||
*/ | |||
CARLA_EXPORT const char* carla_get_library_folder(void); | |||
CARLA_PLUGIN_EXPORT const char* carla_get_library_folder(void); | |||
#endif | |||
/* -------------------------------------------------------------------------------------------------------------------- | |||
@@ -206,18 +206,18 @@ CARLA_EXPORT const char* carla_get_library_folder(void); | |||
* | |||
* Make sure to call carla_juce_cleanup after you are done with APIs that need JUCE. | |||
*/ | |||
CARLA_EXPORT void carla_juce_init(void); | |||
CARLA_PLUGIN_EXPORT void carla_juce_init(void); | |||
/*! | |||
* Give idle time to JUCE stuff. | |||
* Currently only used for Linux. | |||
*/ | |||
CARLA_EXPORT void carla_juce_idle(void); | |||
CARLA_PLUGIN_EXPORT void carla_juce_idle(void); | |||
/*! | |||
* Cleanup the JUCE stuff that was initialized by carla_juce_init. | |||
*/ | |||
CARLA_EXPORT void carla_juce_cleanup(void); | |||
CARLA_PLUGIN_EXPORT void carla_juce_cleanup(void); | |||
/* -------------------------------------------------------------------------------------------------------------------- | |||
* pipes */ | |||
@@ -225,65 +225,65 @@ CARLA_EXPORT void carla_juce_cleanup(void); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT CarlaPipeClientHandle carla_pipe_client_new(const char* argv[], CarlaPipeCallbackFunc callbackFunc, void* callbackPtr); | |||
CARLA_PLUGIN_EXPORT CarlaPipeClientHandle carla_pipe_client_new(const char* argv[], CarlaPipeCallbackFunc callbackFunc, void* callbackPtr); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT void carla_pipe_client_idle(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT void carla_pipe_client_idle(CarlaPipeClientHandle handle); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT bool carla_pipe_client_is_running(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT bool carla_pipe_client_is_running(CarlaPipeClientHandle handle); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT void carla_pipe_client_lock(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT void carla_pipe_client_lock(CarlaPipeClientHandle handle); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT void carla_pipe_client_unlock(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT void carla_pipe_client_unlock(CarlaPipeClientHandle handle); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT const char* carla_pipe_client_readlineblock(CarlaPipeClientHandle handle, uint timeout); | |||
CARLA_PLUGIN_EXPORT const char* carla_pipe_client_readlineblock(CarlaPipeClientHandle handle, uint timeout); | |||
/*! | |||
* Extras. | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT bool carla_pipe_client_readlineblock_bool(CarlaPipeClientHandle handle, uint timeout); | |||
CARLA_EXPORT int carla_pipe_client_readlineblock_int(CarlaPipeClientHandle handle, uint timeout); | |||
CARLA_EXPORT double carla_pipe_client_readlineblock_float(CarlaPipeClientHandle handle, uint timeout); | |||
CARLA_PLUGIN_EXPORT bool carla_pipe_client_readlineblock_bool(CarlaPipeClientHandle handle, uint timeout); | |||
CARLA_PLUGIN_EXPORT int carla_pipe_client_readlineblock_int(CarlaPipeClientHandle handle, uint timeout); | |||
CARLA_PLUGIN_EXPORT double carla_pipe_client_readlineblock_float(CarlaPipeClientHandle handle, uint timeout); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT bool carla_pipe_client_write_msg(CarlaPipeClientHandle handle, const char* msg); | |||
CARLA_PLUGIN_EXPORT bool carla_pipe_client_write_msg(CarlaPipeClientHandle handle, const char* msg); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT bool carla_pipe_client_write_and_fix_msg(CarlaPipeClientHandle handle, const char* msg); | |||
CARLA_PLUGIN_EXPORT bool carla_pipe_client_write_and_fix_msg(CarlaPipeClientHandle handle, const char* msg); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT bool carla_pipe_client_flush(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT bool carla_pipe_client_flush(CarlaPipeClientHandle handle); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT bool carla_pipe_client_flush_and_unlock(CarlaPipeClientHandle handle); | |||
/*! | |||
* TODO. | |||
*/ | |||
CARLA_EXPORT void carla_pipe_client_destroy(CarlaPipeClientHandle handle); | |||
CARLA_PLUGIN_EXPORT void carla_pipe_client_destroy(CarlaPipeClientHandle handle); | |||
/* -------------------------------------------------------------------------------------------------------------------- | |||
* system stuff */ | |||
@@ -291,17 +291,17 @@ CARLA_EXPORT void carla_pipe_client_destroy(CarlaPipeClientHandle handle); | |||
/*! | |||
* Flush stdout or stderr. | |||
*/ | |||
CARLA_EXPORT void carla_fflush(bool err); | |||
CARLA_PLUGIN_EXPORT void carla_fflush(bool err); | |||
/*! | |||
* Print the string @a string to stdout or stderr. | |||
*/ | |||
CARLA_EXPORT void carla_fputs(bool err, const char* string); | |||
CARLA_PLUGIN_EXPORT void carla_fputs(bool err, const char* string); | |||
/*! | |||
* Set the current process name to @a name. | |||
*/ | |||
CARLA_EXPORT void carla_set_process_name(const char* name); | |||
CARLA_PLUGIN_EXPORT void carla_set_process_name(const char* name); | |||
/* -------------------------------------------------------------------------------------------------------------------- | |||
* window control */ | |||
@@ -309,16 +309,16 @@ CARLA_EXPORT void carla_set_process_name(const char* name); | |||
/*! | |||
* Get the global/desktop scale factor. | |||
*/ | |||
CARLA_EXPORT double carla_get_desktop_scale_factor(void); | |||
CARLA_PLUGIN_EXPORT double carla_get_desktop_scale_factor(void); | |||
CARLA_EXPORT int carla_cocoa_get_window(void* nsViewPtr); | |||
CARLA_EXPORT void carla_cocoa_set_transient_window_for(void* nsViewChild, void* nsViewParent); | |||
CARLA_PLUGIN_EXPORT int carla_cocoa_get_window(void* nsViewPtr); | |||
CARLA_PLUGIN_EXPORT void carla_cocoa_set_transient_window_for(void* nsViewChild, void* nsViewParent); | |||
CARLA_EXPORT void carla_x11_reparent_window(uintptr_t winId1, uintptr_t winId2); | |||
CARLA_PLUGIN_EXPORT void carla_x11_reparent_window(uintptr_t winId1, uintptr_t winId2); | |||
CARLA_EXPORT void carla_x11_move_window(uintptr_t winId, int x, int y); | |||
CARLA_PLUGIN_EXPORT void carla_x11_move_window(uintptr_t winId, int x, int y); | |||
CARLA_EXPORT int* carla_x11_get_window_pos(uintptr_t winId); | |||
CARLA_PLUGIN_EXPORT int* carla_x11_get_window_pos(uintptr_t winId); | |||
/* ----------------------------------------------------------------------------------------------------------------- */ | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Plugin Host | |||
* Copyright (C) 2011-2021 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2011-2022 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 | |||
@@ -4603,10 +4603,10 @@ CARLA_BACKEND_END_NAMESPACE | |||
// ----------------------------------------------------------------------- | |||
// internal jack client | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_initialize(jack_client_t *client, const char *load_init); | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_finish(void *arg); | |||
#ifdef CARLA_OS_UNIX | |||
@@ -4615,7 +4615,7 @@ void jack_finish(void *arg); | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_initialize(jack_client_t* const client, const char* const load_init) | |||
{ | |||
CARLA_BACKEND_USE_NAMESPACE | |||
@@ -4665,7 +4665,7 @@ int jack_initialize(jack_client_t* const client, const char* const load_init) | |||
return 1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_finish(void *arg) | |||
{ | |||
CARLA_BACKEND_USE_NAMESPACE | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Plugin Host | |||
* Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2011-2022 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 | |||
@@ -2925,7 +2925,7 @@ CARLA_BACKEND_END_NAMESPACE | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_carla(); | |||
void carla_register_native_plugin_carla() | |||
@@ -2994,7 +2994,7 @@ const NativePluginDescriptor* carla_get_native_patchbay_cv32_plugin() | |||
// ----------------------------------------------------------------------- | |||
// Extra stuff for linking purposes | |||
#ifdef CARLA_PLUGIN_EXPORT | |||
#ifdef CARLA_PLUGIN_BUILD | |||
CARLA_BACKEND_START_NAMESPACE | |||
@@ -3033,6 +3033,6 @@ CARLA_BACKEND_END_NAMESPACE | |||
#include "CarlaProcessUtils.cpp" | |||
#include "CarlaStateUtils.cpp" | |||
#endif /* CARLA_PLUGIN_EXPORT */ | |||
#endif /* CARLA_PLUGIN_BUILD */ | |||
// ----------------------------------------------------------------------- |
@@ -93,12 +93,12 @@ ifeq ($(MACOS),true) | |||
$(OBJDIR)/CarlaEngineNative.cpp.exp.o: CarlaEngineNative.cpp | |||
-@mkdir -p $(OBJDIR) | |||
@echo "Compiling CarlaEngineNative.cpp (plugin)" | |||
$(SILENT)$(CXX) $< $(BUILD_CXX_FLAGS) -DCARLA_PLUGIN_EXPORT -ObjC++ -c -o $@ | |||
$(SILENT)$(CXX) $< $(BUILD_CXX_FLAGS) -DCARLA_PLUGIN_BUILD -ObjC++ -c -o $@ | |||
else | |||
$(OBJDIR)/CarlaEngineNative.cpp.exp.o: CarlaEngineNative.cpp | |||
-@mkdir -p $(OBJDIR) | |||
@echo "Compiling CarlaEngineNative.cpp (plugin)" | |||
$(SILENT)$(CXX) $< $(BUILD_CXX_FLAGS) -DCARLA_PLUGIN_EXPORT -c -o $@ | |||
$(SILENT)$(CXX) $< $(BUILD_CXX_FLAGS) -DCARLA_PLUGIN_BUILD -c -o $@ | |||
endif | |||
ifeq ($(JACKBRIDGE_DIRECT),true) | |||
@@ -713,7 +713,7 @@ const CarlaCachedPluginInfo* carla_get_cached_plugin_info(CB::PluginType ptype, | |||
// ------------------------------------------------------------------------------------------------------------------- | |||
#ifndef CARLA_PLUGIN_EXPORT | |||
#ifndef CARLA_PLUGIN_BUILD | |||
# include "../native-plugins/_data.cpp" | |||
#endif | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Plugin Host | |||
* Copyright (C) 2011-2021 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2011-2022 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 | |||
@@ -15,9 +15,7 @@ | |||
* For a full copy of the GNU General Public License see the doc/GPL.txt file. | |||
*/ | |||
#include "CarlaHost.h" | |||
#include "CarlaUtils.h" | |||
#include "CarlaString.hpp" | |||
#if defined(HAVE_FLUIDSYNTH) && !defined(BUILD_BRIDGE_ALTERNATIVE_ARCH) | |||
@@ -209,7 +209,7 @@ void carla_pipe_client_destroy(CarlaPipeClientHandle handle) | |||
// ------------------------------------------------------------------------------------------------------------------- | |||
#ifndef CARLA_PLUGIN_EXPORT | |||
#ifndef CARLA_PLUGIN_BUILD | |||
# include "CarlaPipeUtils.cpp" | |||
#endif | |||
@@ -19,7 +19,7 @@ | |||
#include "CarlaMathUtils.hpp" | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_EXPORT) | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_BUILD) | |||
# import <Cocoa/Cocoa.h> | |||
#endif | |||
@@ -41,7 +41,7 @@ double carla_get_desktop_scale_factor() | |||
if (const char* const scale = getenv("QT_SCALE_FACTOR")) | |||
return std::max(1.0, std::atof(scale)); | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_EXPORT) | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_BUILD) | |||
return [NSScreen mainScreen].backingScaleFactor; | |||
#endif | |||
#ifdef HAVE_X11 | |||
@@ -79,7 +79,7 @@ int carla_cocoa_get_window(void* nsViewPtr) | |||
{ | |||
CARLA_SAFE_ASSERT_RETURN(nsViewPtr != nullptr, 0); | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_EXPORT) | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_BUILD) | |||
NSView* const nsView = (NSView*)nsViewPtr; | |||
return [[nsView window] windowNumber]; | |||
#else | |||
@@ -92,7 +92,7 @@ void carla_cocoa_set_transient_window_for(void* nsViewChildPtr, void* nsViewPare | |||
CARLA_SAFE_ASSERT_RETURN(nsViewChildPtr != nullptr,); | |||
CARLA_SAFE_ASSERT_RETURN(nsViewParentPtr != nullptr,); | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_EXPORT) | |||
#if defined(CARLA_OS_MAC) && !defined(CARLA_PLUGIN_BUILD) | |||
NSView* const nsViewChild = (NSView*)nsViewChildPtr; | |||
NSView* const nsViewParent = (NSView*)nsViewParentPtr; | |||
[[nsViewParent window] addChildWindow:[nsViewChild window] | |||
@@ -707,7 +707,7 @@ static const void* lv2ui_extension_data(const char* uri) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
// Startup code | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const LV2_Descriptor* lv2_descriptor(uint32_t index) | |||
{ | |||
carla_debug("lv2_descriptor(%i)", index); | |||
@@ -745,7 +745,7 @@ const LV2_Descriptor* lv2_descriptor(uint32_t index) | |||
return &desc; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index) | |||
{ | |||
carla_debug("lv2ui_descriptor(%i)", index); | |||
@@ -269,19 +269,22 @@ private: \ | |||
static void* operator new(std::size_t); | |||
#endif | |||
/* CARLA_VISIBLE_SYMBOL */ | |||
#if defined(CARLA_OS_WIN) && ! defined(__WINE__) | |||
# ifdef BUILDING_CARLA | |||
# define CARLA_VISIBLE_SYMBOL __declspec (dllexport) | |||
# else | |||
# define CARLA_VISIBLE_SYMBOL __declspec (dllimport) | |||
# endif | |||
#else | |||
# define CARLA_VISIBLE_SYMBOL __attribute__ ((visibility("default"))) | |||
#endif | |||
/* Define CARLA_API */ | |||
#if defined(BUILD_BRIDGE) || defined(STATIC_PLUGIN_TARGET) | |||
# define CARLA_API | |||
#else | |||
# if defined(CARLA_OS_WIN) && ! defined(__WINE__) | |||
# ifdef BUILDING_CARLA | |||
# define CARLA_API __declspec (dllexport) | |||
# else | |||
# define CARLA_API __declspec (dllimport) | |||
# endif | |||
# else | |||
# define CARLA_API __attribute__ ((visibility("default"))) | |||
# endif | |||
# define CARLA_API CARLA_VISIBLE_SYMBOL | |||
#endif | |||
/* Define CARLA_EXTERN_C */ | |||
@@ -291,15 +294,13 @@ private: \ | |||
# define CARLA_EXTERN_C | |||
#endif | |||
/* Define CARLA_EXPORT */ | |||
/* Define CARLA_*_EXPORT */ | |||
#ifdef BUILD_BRIDGE | |||
# define CARLA_EXPORT CARLA_EXTERN_C | |||
# define CARLA_API_EXPORT CARLA_EXTERN_C | |||
# define CARLA_PLUGIN_EXPORT CARLA_EXTERN_C | |||
#else | |||
# if defined(CARLA_OS_WIN) && ! defined(__WINE__) | |||
# define CARLA_EXPORT CARLA_EXTERN_C CARLA_API | |||
# else | |||
# define CARLA_EXPORT CARLA_EXTERN_C CARLA_API | |||
# endif | |||
# define CARLA_API_EXPORT CARLA_EXTERN_C CARLA_API | |||
# define CARLA_PLUGIN_EXPORT CARLA_EXTERN_C CARLA_VISIBLE_SYMBOL | |||
#endif | |||
/* Define CARLA_OS_SEP */ | |||
@@ -318,7 +318,7 @@ extern void carla_register_native_plugin(const NativePluginDescriptor* desc); | |||
void carla_register_all_native_plugins(void); | |||
/** Get meta-data only */ | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
const NativePluginDescriptor* carla_get_native_plugins_data(uint32_t* count); | |||
/* ------------------------------------------------------------------------------------------------------------ */ | |||
@@ -18,6 +18,13 @@ | |||
#ifndef CARLA_NATIVE_PLUGIN_H_INCLUDED | |||
#define CARLA_NATIVE_PLUGIN_H_INCLUDED | |||
#include "CarlaDefines.h" | |||
#ifdef STATIC_PLUGIN_TARGET | |||
# undef CARLA_PLUGIN_EXPORT | |||
# define CARLA_PLUGIN_EXPORT CARLA_API_EXPORT | |||
#endif | |||
#include "CarlaNative.h" | |||
#include "CarlaHost.h" | |||
#include "CarlaUtils.h" | |||
@@ -25,62 +32,62 @@ | |||
/*! | |||
* Get the native plugin descriptor for the carla-rack plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_rack_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_rack_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay16 plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay16_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay16_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay32 plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay32_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay32_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay64 plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay64_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay64_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay-cv plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_cv_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_cv_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay-cv8 plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_cv8_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_cv8_plugin(void); | |||
/*! | |||
* Get the native plugin descriptor for the carla-patchbay-cv32 plugin. | |||
*/ | |||
CARLA_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_cv32_plugin(void); | |||
CARLA_API_EXPORT const NativePluginDescriptor* carla_get_native_patchbay_cv32_plugin(void); | |||
/*! | |||
* Create a CarlaHostHandle suitable for CarlaHost API calls. | |||
* Returned value must be freed by the caller when no longer needed. | |||
*/ | |||
CARLA_EXPORT CarlaHostHandle carla_create_native_plugin_host_handle(const NativePluginDescriptor* desc, | |||
NativePluginHandle handle); | |||
CARLA_API_EXPORT CarlaHostHandle carla_create_native_plugin_host_handle(const NativePluginDescriptor* desc, | |||
NativePluginHandle handle); | |||
/*! | |||
* Free memory created during carla_create_native_plugin_host_handle. | |||
*/ | |||
CARLA_EXPORT void carla_host_handle_free(CarlaHostHandle handle); | |||
CARLA_API_EXPORT void carla_host_handle_free(CarlaHostHandle handle); | |||
#ifdef __cplusplus | |||
/*! | |||
* Get the internal CarlaEngine instance. | |||
* @deprecated Please use carla_create_native_plugin_host_handle instead | |||
*/ | |||
CARLA_EXPORT CARLA_BACKEND_NAMESPACE::CarlaEngine* carla_get_native_plugin_engine(const NativePluginDescriptor* desc, | |||
NativePluginHandle handle); | |||
CARLA_API_EXPORT CARLA_BACKEND_NAMESPACE::CarlaEngine* carla_get_native_plugin_engine(const NativePluginDescriptor* desc, | |||
NativePluginHandle handle); | |||
#endif | |||
#endif /* CARLA_NATIVE_PLUGIN_H_INCLUDED */ |
@@ -343,42 +343,42 @@ static int carlaWindowUnmap(Display* const display, const Window window, const W | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
// Our custom X11 functions | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XMapWindow(Display* display, Window window) | |||
{ | |||
carla_debug("XMapWindow(%p, %lu)", display, window); | |||
return carlaWindowMap(display, window, WindowMapNormal); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XMapRaised(Display* display, Window window) | |||
{ | |||
carla_debug("XMapRaised(%p, %lu)", display, window); | |||
return carlaWindowMap(display, window, WindowMapRaised); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XMapSubwindows(Display* display, Window window) | |||
{ | |||
carla_debug("XMapSubwindows(%p, %lu)", display, window); | |||
return carlaWindowMap(display, window, WindowMapSubwindows); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XUnmapWindow(Display* display, Window window) | |||
{ | |||
carla_debug("XUnmapWindow(%p, %lu)", display, window); | |||
return carlaWindowUnmap(display, window, WindowUnmapNormal); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XDestroyWindow(Display* display, Window window) | |||
{ | |||
carla_debug("XDestroyWindow(%p, %lu)", display, window); | |||
return carlaWindowUnmap(display, window, WindowUnmapDestroy); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XNextEvent(Display* display, XEvent* event) | |||
{ | |||
const int ret = real_XNextEvent(display, event); | |||
@@ -421,7 +421,7 @@ int XNextEvent(Display* display, XEvent* event) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
// Full control helper | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_carla_interposed_action(uint action, uint value, void* ptr) | |||
{ | |||
carla_debug("jack_carla_interposed_action(%i, %i, %p)", action, value, ptr); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Interposer for unsafe backend functions | |||
* Copyright (C) 2014-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2014-2022 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 | |||
@@ -27,14 +27,14 @@ | |||
// ----------------------------------------------------------------------- | |||
// Gtk stuff | |||
CARLA_EXPORT void gtk_init(int*, char***); | |||
CARLA_EXPORT int gtk_init_check(int*, char***); | |||
CARLA_EXPORT int gtk_init_with_args(int*, char***, const char*, void*, const char*, void**); | |||
CARLA_PLUGIN_EXPORT void gtk_init(int*, char***); | |||
CARLA_PLUGIN_EXPORT int gtk_init_check(int*, char***); | |||
CARLA_PLUGIN_EXPORT int gtk_init_with_args(int*, char***, const char*, void*, const char*, void**); | |||
// ----------------------------------------------------------------------- | |||
// Our custom functions | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
pid_t fork() | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
@@ -42,7 +42,7 @@ pid_t fork() | |||
return -1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int clone(int (*)(void*), void*, int, void*, ...) | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
@@ -50,14 +50,14 @@ int clone(int (*)(void*), void*, int, void*, ...) | |||
return -1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int posix_spawn(pid_t*, const char*, const posix_spawn_file_actions_t*, const posix_spawnattr_t*, char* const[], char* const[]) | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int posix_spawnp(pid_t*, const char*, const posix_spawn_file_actions_t*, const posix_spawnattr_t*, char* const[], char* const[]) | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
@@ -66,7 +66,7 @@ int posix_spawnp(pid_t*, const char*, const posix_spawn_file_actions_t*, const p | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void exit(int status) | |||
{ | |||
carla_stderr2("Carla prevented a plugin from calling 'exit', redirecting to '_exit' instead, bad plugin!"); | |||
@@ -75,20 +75,20 @@ void exit(int status) | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void gtk_init(int*, char***) | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int gtk_init_check(int*, char***) | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int gtk_init_with_args(int*, char***, const char*, void*, const char*, void**) | |||
{ | |||
PREVENTED_FUNC_MSG; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Interposer for X11 Window Mapping | |||
* Copyright (C) 2014-2018 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2014-2022 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 | |||
@@ -99,28 +99,28 @@ static int carlaWindowMap(Display* const display, const Window window, const int | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
// Our custom X11 functions | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XMapWindow(Display* display, Window window) | |||
{ | |||
carla_debug("XMapWindow(%p, %lu)", display, window); | |||
return carlaWindowMap(display, window, 1); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XMapRaised(Display* display, Window window) | |||
{ | |||
carla_debug("XMapRaised(%p, %lu)", display, window); | |||
return carlaWindowMap(display, window, 2); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XMapSubwindows(Display* display, Window window) | |||
{ | |||
carla_debug("XMapSubwindows(%p, %lu)", display, window); | |||
return carlaWindowMap(display, window, 3); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int XUnmapWindow(Display* display, Window window) | |||
{ | |||
carla_debug("XUnmapWindow(%p, %lu)", display, window); | |||
@@ -1460,7 +1460,7 @@ CARLA_BACKEND_END_NAMESPACE | |||
// --------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_client_t* jack_client_open(const char* client_name, jack_options_t options, jack_status_t* status, ...) | |||
{ | |||
carla_debug("%s(%s, 0x%x, %p)", __FUNCTION__, client_name, options, status); | |||
@@ -1482,13 +1482,13 @@ jack_client_t* jack_client_open(const char* client_name, jack_options_t options, | |||
(void)options; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_client_t* jack_client_new(const char* client_name) | |||
{ | |||
return jack_client_open(client_name, JackNullOption, nullptr); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_client_close(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -1500,7 +1500,7 @@ int jack_client_close(jack_client_t* client) | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_activate(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -1511,7 +1511,7 @@ int jack_activate(jack_client_t* client) | |||
return gClient.activateClient(jclient) ? 0 : 1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_deactivate(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -1524,7 +1524,7 @@ int jack_deactivate(jack_client_t* client) | |||
// --------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
char* jack_get_client_name_by_uuid(jack_client_t* const client, const char* const uuidstr) | |||
{ | |||
carla_debug("%s(%p, %s)", __FUNCTION__, client, uuidstr); | |||
@@ -1557,7 +1557,7 @@ char* jack_get_client_name_by_uuid(jack_client_t* const client, const char* cons | |||
return strdup(clientName); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
char* jack_get_uuid_for_client_name(jack_client_t* client, const char* name) | |||
{ | |||
carla_debug("%s(%p, %s)", __FUNCTION__, client, name); | |||
@@ -1591,7 +1591,7 @@ char* jack_get_uuid_for_client_name(jack_client_t* client, const char* name) | |||
// --------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
pthread_t jack_client_thread_id(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -1615,7 +1615,7 @@ pthread_t jack_client_thread_id(jack_client_t* client) | |||
CARLA_BACKEND_USE_NAMESPACE | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_client_real_time_priority(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -1638,7 +1638,7 @@ int jack_client_create_thread(jack_client_t* client, pthread_t* thread, int prio | |||
typedef void (*JackSessionCallback)(jack_session_event_t*, void*); | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_session_callback(jack_client_t* client, JackSessionCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -19,7 +19,7 @@ | |||
// --------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_carla_interposed_action(uint, uint, void*) | |||
{ | |||
static bool printWarning = true; | |||
@@ -40,7 +40,7 @@ int jack_carla_interposed_action(uint, uint, void*) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto_ptr) | |||
{ | |||
carla_debug("%s(%p, %p, %p, %p)", __FUNCTION__, major_ptr, minor_ptr, micro_ptr, proto_ptr); | |||
@@ -51,7 +51,7 @@ void jack_get_version(int* major_ptr, int* minor_ptr, int* micro_ptr, int* proto | |||
*proto_ptr = 9; // FIXME | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* jack_get_version_string(void) | |||
{ | |||
carla_debug("%s()", __FUNCTION__); | |||
@@ -62,7 +62,7 @@ const char* jack_get_version_string(void) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_is_realtime(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -74,7 +74,7 @@ int jack_is_realtime(jack_client_t* client) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_free(void* ptr) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, ptr); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,7 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -36,7 +36,7 @@ int jack_set_thread_init_callback(jack_client_t* client, JackThreadInitCallback | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_on_shutdown(jack_client_t* client, JackShutdownCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -50,7 +50,7 @@ void jack_on_shutdown(jack_client_t* client, JackShutdownCallback callback, void | |||
jclient->shutdownCbPtr = arg; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -64,7 +64,7 @@ void jack_on_info_shutdown(jack_client_t* client, JackInfoShutdownCallback callb | |||
jclient->infoShutdownCbPtr = arg; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_process_callback(jack_client_t* client, JackProcessCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -79,7 +79,7 @@ int jack_set_process_callback(jack_client_t* client, JackProcessCallback callbac | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -94,7 +94,7 @@ int jack_set_freewheel_callback(jack_client_t* client, JackFreewheelCallback cal | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -109,7 +109,7 @@ int jack_set_buffer_size_callback(jack_client_t* client, JackBufferSizeCallback | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -124,42 +124,42 @@ int jack_set_sample_rate_callback(jack_client_t* client, JackSampleRateCallback | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_client_registration_callback(jack_client_t* client, JackClientRegistrationCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_port_registration_callback(jack_client_t* client, JackPortRegistrationCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_port_connect_callback(jack_client_t* client, JackPortConnectCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_port_rename_callback(jack_client_t* client, JackPortRenameCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_graph_order_callback(jack_client_t* client, JackGraphOrderCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_xrun_callback(jack_client_t* client, JackXRunCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2018 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,7 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_client_name_size(void) | |||
{ | |||
carla_debug("%s()", __FUNCTION__); | |||
@@ -29,7 +29,7 @@ int jack_client_name_size(void) | |||
return STR_MAX; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
char* jack_get_client_name(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -42,20 +42,20 @@ char* jack_get_client_name(jack_client_t* client) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_internal_client_new(const char*, const char*, const char*) | |||
{ | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_internal_client_close(const char*) | |||
{ | |||
} | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_get_client_pid(const char*) | |||
{ | |||
return 0; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -23,7 +23,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
//extern void (*jack_error_callback)(const char *msg) JACK_OPTIONAL_WEAK_EXPORT; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_set_error_function(void (*func)(const char *)) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, func); | |||
@@ -31,7 +31,7 @@ void jack_set_error_function(void (*func)(const char *)) | |||
//extern void (*jack_info_callback)(const char *msg) JACK_OPTIONAL_WEAK_EXPORT; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_set_info_function(void (*func)(const char *)) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, func); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2018 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,6 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_latency_callback(jack_client_t* client, JackLatencyCallback callback, void* arg) | |||
{ | |||
carla_stderr2("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -29,7 +30,7 @@ int jack_set_latency_callback(jack_client_t* client, JackLatencyCallback callbac | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range) | |||
{ | |||
carla_debug("%s(%p, %u, %p)", __FUNCTION__, port, mode, range); | |||
@@ -42,7 +43,7 @@ void jack_port_get_latency_range(jack_port_t* port, jack_latency_callback_mode_t | |||
(void)mode; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t mode, jack_latency_range_t* range) | |||
{ | |||
carla_stderr2("%s(%p, %u, %p)", __FUNCTION__, port, mode, range); | |||
@@ -50,14 +51,14 @@ void jack_port_set_latency_range(jack_port_t* port, jack_latency_callback_mode_t | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_recompute_total_latencies(jack_client_t* client) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, client); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_port_get_latency(jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -80,7 +81,7 @@ jack_nframes_t jack_port_get_latency(jack_port_t* port) | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_port_get_total_latency(jack_client_t* client, jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p, %p)", __FUNCTION__, client, port); | |||
@@ -119,13 +120,13 @@ jack_nframes_t jack_port_get_total_latency(jack_client_t* client, jack_port_t* p | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
// deprecated calls | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_port_set_latency(jack_port_t* port, jack_nframes_t nframes) | |||
{ | |||
carla_stderr2("%s(%p, %u)", __FUNCTION__, port, nframes); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_recompute_total_latency(jack_client_t* client, jack_port_t* port) | |||
{ | |||
carla_stderr2("%s(%p, %p)", __FUNCTION__, client, port); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,27 +21,27 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* JACK_METADATA_PRETTY_NAME; | |||
const char* JACK_METADATA_PRETTY_NAME = "http://jackaudio.org/metadata/pretty-name"; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* JACK_METADATA_HARDWARE; | |||
const char* JACK_METADATA_HARDWARE = "http://jackaudio.org/metadata/hardware"; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* JACK_METADATA_CONNECTED; | |||
const char* JACK_METADATA_CONNECTED = "http://jackaudio.org/metadata/connected"; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* JACK_METADATA_PORT_GROUP; | |||
const char* JACK_METADATA_PORT_GROUP = "http://jackaudio.org/metadata/port-group"; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* JACK_METADATA_ICON_SMALL; | |||
const char* JACK_METADATA_ICON_SMALL = "http://jackaudio.org/metadata/icon-small"; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* JACK_METADATA_ICON_LARGE; | |||
const char* JACK_METADATA_ICON_LARGE = "http://jackaudio.org/metadata/icon-large"; | |||
@@ -63,7 +63,7 @@ static Metadata sMetadata; | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_property(jack_client_t*, jack_uuid_t uuid, const char* key, const char* value, const char* type) | |||
{ | |||
CARLA_SAFE_ASSERT_RETURN(uuid != JACK_UUID_EMPTY_INITIALIZER, -1); | |||
@@ -77,7 +77,7 @@ int jack_set_property(jack_client_t*, jack_uuid_t uuid, const char* key, const c | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_get_property(jack_uuid_t uuid, const char* key, char** value, char** type) | |||
{ | |||
CARLA_SAFE_ASSERT_RETURN(uuid != JACK_UUID_EMPTY_INITIALIZER, -1); | |||
@@ -105,24 +105,24 @@ int jack_get_property(jack_uuid_t uuid, const char* key, char** value, char** ty | |||
(void)type; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_free_description(jack_description_t*, int) | |||
{ | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_get_properties(jack_uuid_t, jack_description_t*) | |||
{ | |||
return -1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_get_all_properties(jack_description_t**) | |||
{ | |||
return -1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_remove_property(jack_client_t*, jack_uuid_t uuid, const char* key) | |||
{ | |||
// const MetadataKey mkey = { uuid, key }; | |||
@@ -134,7 +134,7 @@ int jack_remove_property(jack_client_t*, jack_uuid_t uuid, const char* key) | |||
(void)key; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_remove_properties(jack_client_t*, jack_uuid_t uuid) | |||
{ | |||
int count = 0; | |||
@@ -155,14 +155,14 @@ int jack_remove_properties(jack_client_t*, jack_uuid_t uuid) | |||
(void)uuid; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_remove_all_properties(jack_client_t*) | |||
{ | |||
// sMetadata = {}; | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_property_change_callback(jack_client_t*, JackPropertyChangeCallback, void*) | |||
{ | |||
return -1; | |||
@@ -170,7 +170,7 @@ int jack_set_property_change_callback(jack_client_t*, JackPropertyChangeCallback | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_uuid_t jack_client_uuid_generate() | |||
{ | |||
static uint32_t uuid_cnt = 0; | |||
@@ -179,7 +179,7 @@ jack_uuid_t jack_client_uuid_generate() | |||
return uuid; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_uuid_t jack_port_uuid_generate(uint32_t port_id) | |||
{ | |||
jack_uuid_t uuid = 0x1; /* JackUUIDPort */ | |||
@@ -187,13 +187,13 @@ jack_uuid_t jack_port_uuid_generate(uint32_t port_id) | |||
return uuid; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
uint32_t jack_uuid_to_index(jack_uuid_t u) | |||
{ | |||
return static_cast<uint32_t>(u & 0xffff) - 1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_uuid_compare(jack_uuid_t a, jack_uuid_t b) | |||
{ | |||
if (a == b) { | |||
@@ -207,19 +207,19 @@ int jack_uuid_compare(jack_uuid_t a, jack_uuid_t b) | |||
return 1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_uuid_copy(jack_uuid_t* dst, jack_uuid_t src) | |||
{ | |||
*dst = src; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_uuid_clear(jack_uuid_t* uuid) | |||
{ | |||
*uuid = JACK_UUID_EMPTY_INITIALIZER; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_uuid_parse(const char* b, jack_uuid_t* u) | |||
{ | |||
if (std::sscanf(b, P_UINT64, u) != 1) | |||
@@ -233,13 +233,13 @@ int jack_uuid_parse(const char* b, jack_uuid_t* u) | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_uuid_unparse(jack_uuid_t u, char buf[JACK_UUID_STRING_SIZE]) | |||
{ | |||
std::snprintf(buf, JACK_UUID_STRING_SIZE, P_UINT64, u); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_uuid_empty(jack_uuid_t u) | |||
{ | |||
return u == JACK_UUID_EMPTY_INITIALIZER; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,7 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_midi_get_event_count(void* buf) | |||
{ | |||
const JackMidiPortBufferBase* const jbasebuf((const JackMidiPortBufferBase*)buf); | |||
@@ -36,7 +36,7 @@ jack_nframes_t jack_midi_get_event_count(void* buf) | |||
return jmidibuf->count; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_midi_event_get(jack_midi_event_t* ev, void* buf, uint32_t index) | |||
{ | |||
const JackMidiPortBufferBase* const jbasebuf((const JackMidiPortBufferBase*)buf); | |||
@@ -53,7 +53,7 @@ int jack_midi_event_get(jack_midi_event_t* ev, void* buf, uint32_t index) | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_midi_clear_buffer(void* buf) | |||
{ | |||
JackMidiPortBufferBase* const jbasebuf((JackMidiPortBufferBase*)buf); | |||
@@ -70,19 +70,19 @@ void jack_midi_clear_buffer(void* buf) | |||
std::memset(jmidibuf->bufferPool, 0, JackMidiPortBufferBase::kBufferPoolSize); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_midi_reset_buffer(void* buf) | |||
{ | |||
jack_midi_clear_buffer(buf); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
size_t jack_midi_max_event_size(void*) | |||
{ | |||
return JackMidiPortBufferBase::kMaxEventSize; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_midi_data_t* jack_midi_event_reserve(void* buf, jack_nframes_t frame, size_t size) | |||
{ | |||
JackMidiPortBufferBase* const jbasebuf((JackMidiPortBufferBase*)buf); | |||
@@ -112,7 +112,7 @@ jack_midi_data_t* jack_midi_event_reserve(void* buf, jack_nframes_t frame, size_ | |||
return jmdata; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_midi_event_write(void* buf, jack_nframes_t frame, const jack_midi_data_t* data, size_t size) | |||
{ | |||
JackMidiPortBufferBase* const jbasebuf((JackMidiPortBufferBase*)buf); | |||
@@ -142,7 +142,7 @@ int jack_midi_event_write(void* buf, jack_nframes_t frame, const jack_midi_data_ | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
uint32_t jack_midi_get_lost_event_count(void*) | |||
{ | |||
return 0; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -23,24 +23,24 @@ typedef void *(*JackThreadCallback)(void* arg); | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_thread_wait(jack_client_t*, int) | |||
{ | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_cycle_wait(jack_client_t*) | |||
{ | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_cycle_signal(jack_client_t*, int) | |||
{ | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_process_thread(jack_client_t*, JackThreadCallback, void*) | |||
{ | |||
return ENOSYS; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -45,7 +45,7 @@ static const char* allocate_port_name(const char* const prefixOrFullName, const | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char** jack_get_ports(jack_client_t* const client, | |||
const char* const port_name, | |||
const char* const port_type, | |||
@@ -232,7 +232,7 @@ const char** jack_get_ports(jack_client_t* const client, | |||
return nullptr; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_port_t* jack_port_by_name(jack_client_t* client, const char* name) | |||
{ | |||
carla_debug("%s(%p, %s)", __FUNCTION__, client, name); | |||
@@ -334,7 +334,7 @@ jack_port_t* jack_port_by_name(jack_client_t* client, const char* name) | |||
return nullptr; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_port_t* jack_port_by_id(jack_client_t* client, jack_port_id_t port_id) | |||
{ | |||
carla_debug("%s(%p, %u)", __FUNCTION__, client, port_id); | |||
@@ -353,7 +353,7 @@ jack_port_t* jack_port_by_id(jack_client_t* client, jack_port_id_t port_id) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char** jack_port_get_connections(const jack_port_t* port) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, port); | |||
@@ -368,7 +368,7 @@ const char** jack_port_get_connections(const jack_port_t* port) | |||
return nullptr; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char** jack_port_get_all_connections(const jack_client_t* client, const jack_port_t* port) | |||
{ | |||
carla_stdout("%s(%p, %p) WIP", __FUNCTION__, client, port); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -23,7 +23,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
static uint32_t gPortId = JackPortState::kPortIdOffsetUser; | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_port_t* jack_port_register(jack_client_t* client, const char* port_name, const char* port_type, | |||
unsigned long flags, unsigned long buffer_size) | |||
{ | |||
@@ -136,7 +136,7 @@ jack_port_t* jack_port_register(jack_client_t* client, const char* port_name, co | |||
(void)buffer_size; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_unregister(jack_client_t* client, jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p, %p)", __FUNCTION__, client, port); | |||
@@ -193,7 +193,7 @@ int jack_port_unregister(jack_client_t* client, jack_port_t* port) | |||
return EINVAL; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t) | |||
{ | |||
JackPortState* const jport = (JackPortState*)port; | |||
@@ -204,7 +204,7 @@ void* jack_port_get_buffer(jack_port_t* port, jack_nframes_t) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_uuid_t jack_port_uuid(const jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -215,7 +215,7 @@ jack_uuid_t jack_port_uuid(const jack_port_t* port) | |||
return jport->uuid; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* jack_port_name(const jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -226,7 +226,7 @@ const char* jack_port_name(const jack_port_t* port) | |||
return jport->fullname; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* jack_port_short_name(const jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -237,7 +237,7 @@ const char* jack_port_short_name(const jack_port_t* port) | |||
return jport->name; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_flags(const jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -248,7 +248,7 @@ int jack_port_flags(const jack_port_t* port) | |||
return jport->flags; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const char* jack_port_type(const jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -262,7 +262,7 @@ const char* jack_port_type(const jack_port_t* port) | |||
return jport->isMidi ? kMidiType : kAudioType; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
uint32_t jack_port_type_id(const jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -275,7 +275,7 @@ uint32_t jack_port_type_id(const jack_port_t* port) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_is_mine(const jack_client_t*, const jack_port_t* port) | |||
{ | |||
const JackPortState* const jport = (const JackPortState*)port; | |||
@@ -284,7 +284,7 @@ int jack_port_is_mine(const jack_client_t*, const jack_port_t* port) | |||
return jport->isSystem ? 0 : 1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_connected(const jack_port_t* port) | |||
{ | |||
const JackPortState* const jport = (const JackPortState*)port; | |||
@@ -293,7 +293,7 @@ int jack_port_connected(const jack_port_t* port) | |||
return jport->isConnected ? 1 : 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_connected_to(const jack_port_t* port, const char* port_name) | |||
{ | |||
carla_stderr2("%s(%p, %s) WIP", __FUNCTION__, port, port_name); | |||
@@ -310,7 +310,7 @@ int jack_port_connected_to(const jack_port_t* port, const char* port_name) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_tie(jack_port_t* src, jack_port_t* dst) | |||
{ | |||
carla_debug("%s(%p, %p)", __FUNCTION__, src, dst); | |||
@@ -321,7 +321,7 @@ int jack_port_tie(jack_port_t* src, jack_port_t* dst) | |||
(void)dst; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_untie(jack_port_t* port) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, port); | |||
@@ -333,14 +333,14 @@ int jack_port_untie(jack_port_t* port) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_set_name(jack_port_t *port, const char *port_name) | |||
{ | |||
carla_stderr2("%s(%p, %s)", __FUNCTION__, port, port_name); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_rename(jack_client_t* client, jack_port_t *port, const char *port_name) | |||
{ | |||
carla_stderr2("%s(%p, %p, %s) WIP", __FUNCTION__, client, port, port_name); | |||
@@ -376,21 +376,21 @@ int jack_port_rename(jack_client_t* client, jack_port_t *port, const char *port_ | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_set_alias(jack_port_t* port, const char* alias) | |||
{ | |||
carla_stderr2("%s(%p, %s)", __FUNCTION__, port, alias); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_unset_alias(jack_port_t* port, const char* alias) | |||
{ | |||
carla_stderr2("%s(%p, %s)", __FUNCTION__, port, alias); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_get_aliases(const jack_port_t*, char* const aliases[2]) | |||
{ | |||
*aliases[0] = '\0'; | |||
@@ -400,28 +400,28 @@ int jack_port_get_aliases(const jack_port_t*, char* const aliases[2]) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_request_monitor(jack_port_t* port, int onoff) | |||
{ | |||
carla_stderr2("%s(%p, %i)", __FUNCTION__, port, onoff); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_request_monitor_by_name(jack_client_t* client, const char* port_name, int onoff) | |||
{ | |||
carla_stderr2("%s(%p, %s, %i)", __FUNCTION__, client, port_name, onoff); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_ensure_monitor(jack_port_t* port, int onoff) | |||
{ | |||
carla_stderr2("%s(%p, %i)", __FUNCTION__, port, onoff); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_monitoring_input(jack_port_t* port) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, port); | |||
@@ -430,21 +430,21 @@ int jack_port_monitoring_input(jack_port_t* port) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_connect(jack_client_t* client, const char* a, const char* b) | |||
{ | |||
carla_stderr2("%s(%p, %s. %s)", __FUNCTION__, client, a, b); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_disconnect(jack_client_t* client, const char* a, const char* b) | |||
{ | |||
carla_stderr2("%s(%p, %s. %s)", __FUNCTION__, client, a, b); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_disconnect(jack_client_t* client, jack_port_t* port) | |||
{ | |||
carla_stderr2("%s(%p, %p)", __FUNCTION__, client, port); | |||
@@ -453,19 +453,19 @@ int jack_port_disconnect(jack_client_t* client, jack_port_t* port) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_name_size(void) | |||
{ | |||
return STR_MAX; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_port_type_size(void) | |||
{ | |||
return STR_MAX; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
size_t jack_port_type_get_buffer_size(jack_client_t* client, const char* port_type) | |||
{ | |||
carla_debug("%s(%p, %s)", __FUNCTION__, client, port_type); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2018 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,7 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_freewheel(jack_client_t* client, int freewheel) | |||
{ | |||
carla_debug("%s(%p, %i)", __FUNCTION__, client, freewheel); | |||
@@ -32,7 +32,7 @@ int jack_set_freewheel(jack_client_t* client, int freewheel) | |||
(void)freewheel; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_buffer_size(jack_client_t* client, jack_nframes_t nframes) | |||
{ | |||
carla_debug("%s(%p, %u)", __FUNCTION__, client, nframes); | |||
@@ -43,7 +43,7 @@ int jack_set_buffer_size(jack_client_t* client, jack_nframes_t nframes) | |||
return (jclient->server.bufferSize == nframes) ? 0 : 1; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_get_sample_rate(jack_client_t* client) | |||
{ | |||
JackClientState* const jclient = (JackClientState*)client; | |||
@@ -52,7 +52,7 @@ jack_nframes_t jack_get_sample_rate(jack_client_t* client) | |||
return static_cast<jack_nframes_t>(jclient->server.sampleRate); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_get_buffer_size(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -63,7 +63,7 @@ jack_nframes_t jack_get_buffer_size(jack_client_t* client) | |||
return jclient->server.bufferSize; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
float jack_cpu_load(jack_client_t*) | |||
{ | |||
// TODO | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,21 +21,21 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
float jack_get_max_delayed_usecs(jack_client_t*) | |||
{ | |||
// TODO | |||
return 0.0f; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
float jack_get_xrun_delayed_usecs(jack_client_t*) | |||
{ | |||
// TODO | |||
return 0.0f; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_reset_max_delayed_usecs(jack_client_t*) | |||
{ | |||
// TODO | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2018 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,7 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* client) | |||
{ | |||
const JackClientState* const jclient = (const JackClientState*)client; | |||
@@ -31,7 +31,7 @@ jack_nframes_t jack_frames_since_cycle_start(const jack_client_t* client) | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_frame_time(const jack_client_t* client) | |||
{ | |||
const JackClientState* const jclient = (const JackClientState*)client; | |||
@@ -41,7 +41,7 @@ jack_nframes_t jack_frame_time(const jack_client_t* client) | |||
return static_cast<jack_nframes_t>(jclient->server.position.usecs); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_last_frame_time(const jack_client_t* client) | |||
{ | |||
const JackClientState* const jclient = (const JackClientState*)client; | |||
@@ -50,7 +50,7 @@ jack_nframes_t jack_last_frame_time(const jack_client_t* client) | |||
return static_cast<jack_nframes_t>(jclient->server.monotonic_frame); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_get_cycle_times(const jack_client_t *client, | |||
jack_nframes_t *current_frames, | |||
jack_time_t *current_usecs, | |||
@@ -76,7 +76,7 @@ int jack_get_cycle_times(const jack_client_t *client, | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_time_t jack_frames_to_time(const jack_client_t* client, jack_nframes_t frames) | |||
{ | |||
const JackClientState* const jclient = (const JackClientState*)client; | |||
@@ -85,7 +85,7 @@ jack_time_t jack_frames_to_time(const jack_client_t* client, jack_nframes_t fram | |||
return static_cast<jack_time_t>(static_cast<double>(frames) / jclient->server.sampleRate * 1000000.0); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_time_to_frames(const jack_client_t* client, jack_time_t time) | |||
{ | |||
const JackClientState* const jclient = (const JackClientState*)client; | |||
@@ -94,7 +94,7 @@ jack_nframes_t jack_time_to_frames(const jack_client_t* client, jack_time_t time | |||
return static_cast<jack_nframes_t>(static_cast<double>(time) / 1000000.0 * jclient->server.sampleRate); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_time_t jack_get_time(void) | |||
{ | |||
timespec t; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla JACK API for external applications | |||
* Copyright (C) 2016-2017 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2016-2022 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 | |||
@@ -21,7 +21,7 @@ CARLA_BACKEND_USE_NAMESPACE | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_engine_takeover_timebase(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -33,7 +33,7 @@ int jack_engine_takeover_timebase(jack_client_t* client) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_release_timebase(jack_client_t* client) | |||
{ | |||
carla_debug("%s(%p)", __FUNCTION__, client); | |||
@@ -43,7 +43,7 @@ int jack_release_timebase(jack_client_t* client) | |||
(void)client; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_sync_callback(jack_client_t* client, JackSyncCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %p, %p)", __FUNCTION__, client, callback, arg); | |||
@@ -58,14 +58,14 @@ int jack_set_sync_callback(jack_client_t* client, JackSyncCallback callback, voi | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_sync_timeout(jack_client_t* client, jack_time_t timeout) | |||
{ | |||
carla_stderr2("%s(%p, " P_UINT64 ")", __FUNCTION__, client, timeout); | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_set_timebase_callback(jack_client_t* client, int conditional, JackTimebaseCallback callback, void* arg) | |||
{ | |||
carla_debug("%s(%p, %i, %p, %p)", __FUNCTION__, client, conditional, callback, arg); | |||
@@ -77,14 +77,14 @@ int jack_set_timebase_callback(jack_client_t* client, int conditional, JackTimeb | |||
(void)arg; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_transport_locate(jack_client_t* client, jack_nframes_t frame) | |||
{ | |||
carla_stderr2("%s(%p, %u)", __FUNCTION__, client, frame); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_transport_state_t jack_transport_query(const jack_client_t* client, jack_position_t* pos) | |||
{ | |||
if (const JackClientState* const jclient = (const JackClientState*)client) | |||
@@ -103,7 +103,7 @@ jack_transport_state_t jack_transport_query(const jack_client_t* client, jack_po | |||
return JackTransportStopped; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
jack_nframes_t jack_get_current_transport_frame(const jack_client_t* client) | |||
{ | |||
if (const JackClientState* const jclient = (const JackClientState*)client) | |||
@@ -112,20 +112,20 @@ jack_nframes_t jack_get_current_transport_frame(const jack_client_t* client) | |||
return 0; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
int jack_transport_reposition(jack_client_t* client, const jack_position_t* pos) | |||
{ | |||
carla_stderr2("%s(%p, %p)", __FUNCTION__, client, pos); | |||
return ENOSYS; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_transport_start(jack_client_t* client) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, client); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_transport_stop(jack_client_t* client) | |||
{ | |||
carla_stderr2("%s(%p)", __FUNCTION__, client); | |||
@@ -133,13 +133,13 @@ void jack_transport_stop(jack_client_t* client) | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_get_transport_info(jack_client_t* client, void* tinfo) | |||
{ | |||
carla_stderr2("%s(%p, %p)", __FUNCTION__, client, tinfo); | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
void jack_set_transport_info(jack_client_t* client, void* tinfo) | |||
{ | |||
carla_stderr2("%s(%p, %p)", __FUNCTION__, client, tinfo); | |||
@@ -45,28 +45,25 @@ typedef struct { | |||
} | |||
jack_ringbuffer_t ; | |||
CARLA_EXPORT jack_ringbuffer_t *jack_ringbuffer_create(size_t sz); | |||
CARLA_EXPORT void jack_ringbuffer_free(jack_ringbuffer_t *rb); | |||
CARLA_EXPORT void jack_ringbuffer_get_read_vector(const jack_ringbuffer_t *rb, | |||
jack_ringbuffer_data_t *vec); | |||
CARLA_EXPORT void jack_ringbuffer_get_write_vector(const jack_ringbuffer_t *rb, | |||
jack_ringbuffer_data_t *vec); | |||
CARLA_EXPORT size_t jack_ringbuffer_read(jack_ringbuffer_t *rb, char *dest, size_t cnt); | |||
CARLA_EXPORT size_t jack_ringbuffer_peek(jack_ringbuffer_t *rb, char *dest, size_t cnt); | |||
CARLA_EXPORT void jack_ringbuffer_read_advance(jack_ringbuffer_t *rb, size_t cnt); | |||
CARLA_EXPORT size_t jack_ringbuffer_read_space(const jack_ringbuffer_t *rb); | |||
CARLA_EXPORT int jack_ringbuffer_mlock(jack_ringbuffer_t *rb); | |||
CARLA_EXPORT void jack_ringbuffer_reset(jack_ringbuffer_t *rb); | |||
CARLA_EXPORT void jack_ringbuffer_reset_size (jack_ringbuffer_t * rb, size_t sz); | |||
CARLA_EXPORT size_t jack_ringbuffer_write(jack_ringbuffer_t *rb, const char *src, | |||
size_t cnt); | |||
void jack_ringbuffer_write_advance(jack_ringbuffer_t *rb, size_t cnt); | |||
size_t jack_ringbuffer_write_space(const jack_ringbuffer_t *rb); | |||
CARLA_PLUGIN_EXPORT jack_ringbuffer_t *jack_ringbuffer_create(size_t sz); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_free(jack_ringbuffer_t *rb); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_get_read_vector(const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_get_write_vector(const jack_ringbuffer_t *rb, jack_ringbuffer_data_t *vec); | |||
CARLA_PLUGIN_EXPORT size_t jack_ringbuffer_read(jack_ringbuffer_t *rb, char *dest, size_t cnt); | |||
CARLA_PLUGIN_EXPORT size_t jack_ringbuffer_peek(jack_ringbuffer_t *rb, char *dest, size_t cnt); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_read_advance(jack_ringbuffer_t *rb, size_t cnt); | |||
CARLA_PLUGIN_EXPORT size_t jack_ringbuffer_read_space(const jack_ringbuffer_t *rb); | |||
CARLA_PLUGIN_EXPORT int jack_ringbuffer_mlock(jack_ringbuffer_t *rb); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_reset(jack_ringbuffer_t *rb); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_reset_size (jack_ringbuffer_t * rb, size_t sz); | |||
CARLA_PLUGIN_EXPORT size_t jack_ringbuffer_write(jack_ringbuffer_t *rb, const char *src, size_t cnt); | |||
CARLA_PLUGIN_EXPORT void jack_ringbuffer_write_advance(jack_ringbuffer_t *rb, size_t cnt); | |||
CARLA_PLUGIN_EXPORT size_t jack_ringbuffer_write_space(const jack_ringbuffer_t *rb); | |||
/* Create a new ringbuffer to hold at least `sz' bytes of data. The | |||
actual buffer size is rounded up to the next power of two. */ | |||
CARLA_EXPORT jack_ringbuffer_t * | |||
CARLA_PLUGIN_EXPORT jack_ringbuffer_t * | |||
jack_ringbuffer_create (size_t sz) | |||
{ | |||
unsigned int power_of_two; | |||
@@ -94,7 +91,7 @@ jack_ringbuffer_create (size_t sz) | |||
/* Free all data associated with the ringbuffer `rb'. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_free (jack_ringbuffer_t * rb) | |||
{ | |||
#ifdef USE_MLOCK | |||
@@ -108,7 +105,7 @@ jack_ringbuffer_free (jack_ringbuffer_t * rb) | |||
/* Lock the data block of `rb' using the system call 'mlock'. */ | |||
CARLA_EXPORT int | |||
CARLA_PLUGIN_EXPORT int | |||
jack_ringbuffer_mlock (jack_ringbuffer_t * rb) | |||
{ | |||
#ifdef USE_MLOCK | |||
@@ -123,7 +120,7 @@ jack_ringbuffer_mlock (jack_ringbuffer_t * rb) | |||
/* Reset the read and write pointers to zero. This is not thread | |||
safe. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_reset (jack_ringbuffer_t * rb) | |||
{ | |||
rb->read_ptr = 0; | |||
@@ -134,7 +131,7 @@ jack_ringbuffer_reset (jack_ringbuffer_t * rb) | |||
/* Reset the read and write pointers to zero. This is not thread | |||
safe. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_reset_size (jack_ringbuffer_t * rb, size_t sz) | |||
{ | |||
rb->size = sz; | |||
@@ -148,7 +145,7 @@ jack_ringbuffer_reset_size (jack_ringbuffer_t * rb, size_t sz) | |||
number of bytes in front of the read pointer and behind the write | |||
pointer. */ | |||
CARLA_EXPORT size_t | |||
CARLA_PLUGIN_EXPORT size_t | |||
jack_ringbuffer_read_space (const jack_ringbuffer_t * rb) | |||
{ | |||
size_t w, r; | |||
@@ -167,7 +164,7 @@ jack_ringbuffer_read_space (const jack_ringbuffer_t * rb) | |||
number of bytes in front of the write pointer and behind the read | |||
pointer. */ | |||
CARLA_EXPORT size_t | |||
CARLA_PLUGIN_EXPORT size_t | |||
jack_ringbuffer_write_space (const jack_ringbuffer_t * rb) | |||
{ | |||
size_t w, r; | |||
@@ -187,7 +184,7 @@ jack_ringbuffer_write_space (const jack_ringbuffer_t * rb) | |||
/* The copying data reader. Copy at most `cnt' bytes from `rb' to | |||
`dest'. Returns the actual number of bytes copied. */ | |||
CARLA_EXPORT size_t | |||
CARLA_PLUGIN_EXPORT size_t | |||
jack_ringbuffer_read (jack_ringbuffer_t * rb, char *dest, size_t cnt) | |||
{ | |||
size_t free_cnt; | |||
@@ -226,7 +223,7 @@ jack_ringbuffer_read (jack_ringbuffer_t * rb, char *dest, size_t cnt) | |||
`cnt' bytes from `rb' to `dest'. Returns the actual number of bytes | |||
copied. */ | |||
CARLA_EXPORT size_t | |||
CARLA_PLUGIN_EXPORT size_t | |||
jack_ringbuffer_peek (jack_ringbuffer_t * rb, char *dest, size_t cnt) | |||
{ | |||
size_t free_cnt; | |||
@@ -266,7 +263,7 @@ jack_ringbuffer_peek (jack_ringbuffer_t * rb, char *dest, size_t cnt) | |||
/* The copying data writer. Copy at most `cnt' bytes to `rb' from | |||
`src'. Returns the actual number of bytes copied. */ | |||
CARLA_EXPORT size_t | |||
CARLA_PLUGIN_EXPORT size_t | |||
jack_ringbuffer_write (jack_ringbuffer_t * rb, const char *src, size_t cnt) | |||
{ | |||
size_t free_cnt; | |||
@@ -303,7 +300,7 @@ jack_ringbuffer_write (jack_ringbuffer_t * rb, const char *src, size_t cnt) | |||
/* Advance the read pointer `cnt' places. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_read_advance (jack_ringbuffer_t * rb, size_t cnt) | |||
{ | |||
size_t tmp = (rb->read_ptr + cnt) & rb->size_mask; | |||
@@ -312,7 +309,7 @@ jack_ringbuffer_read_advance (jack_ringbuffer_t * rb, size_t cnt) | |||
/* Advance the write pointer `cnt' places. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_write_advance (jack_ringbuffer_t * rb, size_t cnt) | |||
{ | |||
size_t tmp = (rb->write_ptr + cnt) & rb->size_mask; | |||
@@ -324,7 +321,7 @@ jack_ringbuffer_write_advance (jack_ringbuffer_t * rb, size_t cnt) | |||
the readable data is in one segment the second segment has zero | |||
length. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_get_read_vector (const jack_ringbuffer_t * rb, | |||
jack_ringbuffer_data_t * vec) | |||
{ | |||
@@ -368,7 +365,7 @@ jack_ringbuffer_get_read_vector (const jack_ringbuffer_t * rb, | |||
the writeable data is in one segment the second segment has zero | |||
length. */ | |||
CARLA_EXPORT void | |||
CARLA_PLUGIN_EXPORT void | |||
jack_ringbuffer_get_write_vector (const jack_ringbuffer_t * rb, | |||
jack_ringbuffer_data_t * vec) | |||
{ | |||
@@ -1,7 +1,7 @@ | |||
/* | |||
* Cross-platform C++ library for Carla, based on Juce v4 | |||
* Copyright (C) 2015-2016 ROLI Ltd. | |||
* Copyright (C) 2017-2018 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2017-2022 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 | |||
@@ -34,7 +34,7 @@ HINSTANCE getCurrentModuleInstanceHandle() noexcept | |||
} | |||
# ifndef STATIC_PLUGIN_TARGET | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
BOOL WINAPI DllMain(HINSTANCE hInst, DWORD, LPVOID) | |||
{ | |||
currentModuleHandle = hInst; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2013-2021 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2013-2022 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 | |||
@@ -835,10 +835,10 @@ static const NativePluginDescriptor audiofileDesc = { | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_audiofile(); | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_audiofile() | |||
{ | |||
carla_register_native_plugin(&audiofileDesc); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2012-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2012-2022 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 | |||
@@ -351,10 +351,10 @@ static const NativePluginDescriptor bigmeterDesc = { | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_bigmeter(); | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_bigmeter() | |||
{ | |||
carla_register_native_plugin(&bigmeterDesc); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2012-2022 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 | |||
@@ -451,10 +451,10 @@ static const NativePluginDescriptor midifileDesc = { | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_midifile(); | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_midifile() | |||
{ | |||
carla_register_native_plugin(&midifileDesc); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2012-2022 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 | |||
@@ -569,10 +569,10 @@ static const NativePluginDescriptor midipatternDesc = { | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_midipattern(); | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_midipattern() | |||
{ | |||
carla_register_native_plugin(&midipatternDesc); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2012-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2012-2022 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 | |||
@@ -116,10 +116,10 @@ static const NativePluginDescriptor notesDesc = { | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_notes(); | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_notes() | |||
{ | |||
carla_register_native_plugin(¬esDesc); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* XY Controller UI, taken from Cadence | |||
* Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2011-2022 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 | |||
@@ -275,10 +275,10 @@ static const NativePluginDescriptor notesDesc = { | |||
// ----------------------------------------------------------------------- | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_xycontroller(); | |||
CARLA_EXPORT | |||
CARLA_API_EXPORT | |||
void carla_register_native_plugin_xycontroller() | |||
{ | |||
carla_register_native_plugin(¬esDesc); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Plugin Host | |||
* Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2011-2022 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 | |||
@@ -17,7 +17,7 @@ | |||
#include "CarlaNativePlugin.h" | |||
#define CARLA_PLUGIN_EXPORT | |||
#define CARLA_PLUGIN_BUILD | |||
#include "carla-native-plugin.cpp" | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2013-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2013-2022 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 | |||
@@ -426,7 +426,7 @@ static const void* lv2ui_extension_data(const char* uri) | |||
// ----------------------------------------------------------------------- | |||
// Startup code | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index) | |||
{ | |||
carla_debug("lv2ui_descriptor(%i)", index); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2013-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2013-2022 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 | |||
@@ -1494,7 +1494,7 @@ static const void* lv2ui_extension_data(const char* uri) | |||
// ----------------------------------------------------------------------- | |||
// Startup code | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const LV2_Descriptor* lv2_descriptor(uint32_t index) | |||
{ | |||
carla_debug("lv2_descriptor(%i)", index); | |||
@@ -1545,7 +1545,7 @@ const LV2_Descriptor* lv2_descriptor(uint32_t index) | |||
} | |||
#ifdef HAVE_PYQT | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
const LV2UI_Descriptor* lv2ui_descriptor(uint32_t index) | |||
{ | |||
carla_debug("lv2ui_descriptor(%i)", index); | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Plugin Host | |||
* Copyright (C) 2011-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2011-2022 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 | |||
@@ -26,7 +26,7 @@ | |||
// -------------------------------------------------------------------------------------------------------------------- | |||
// Expose info functions as needed | |||
#ifndef CARLA_PLUGIN_EXPORT | |||
#ifndef CARLA_PLUGIN_BUILD | |||
# include "utils/Information.cpp" | |||
#endif | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2013-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2013-2022 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 | |||
@@ -40,14 +40,14 @@ static HINSTANCE getCurrentModuleInstanceHandle() noexcept | |||
return currentModuleHandle; | |||
} | |||
CARLA_EXPORT | |||
CARLA_PLUGIN_EXPORT | |||
BOOL WINAPI DllMain(HINSTANCE hInst, DWORD, LPVOID) | |||
{ | |||
currentModuleHandle = hInst; | |||
return 1; | |||
} | |||
CARLA_EXPORT __cdecl | |||
CARLA_PLUGIN_EXPORT __cdecl | |||
const AEffect* VSTPluginMain(audioMasterCallback audioMaster) | |||
{ | |||
static MainCallback sCallback = nullptr; | |||
@@ -1,6 +1,6 @@ | |||
/* | |||
* Carla Native Plugins | |||
* Copyright (C) 2013-2020 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2013-2022 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 | |||
@@ -67,10 +67,10 @@ static struct CarlaVSTCleanup { | |||
} | |||
} gCarlaVSTCleanup; | |||
CARLA_EXPORT __cdecl | |||
CARLA_PLUGIN_EXPORT __cdecl | |||
const AEffect* VSTPluginMain(audioMasterCallback audioMaster); | |||
CARLA_EXPORT __cdecl | |||
CARLA_PLUGIN_EXPORT __cdecl | |||
const AEffect* VSTPluginMain(audioMasterCallback audioMaster) | |||
{ | |||
// old version | |||
@@ -112,10 +112,10 @@ const AEffect* VSTPluginMain(audioMasterCallback audioMaster) | |||
} | |||
#if ! (defined(CARLA_OS_MAC) || defined(CARLA_OS_WIN)) | |||
CARLA_EXPORT __cdecl | |||
CARLA_PLUGIN_EXPORT __cdecl | |||
const AEffect* VSTPluginMain_asm(audioMasterCallback audioMaster) asm ("main"); | |||
CARLA_EXPORT __cdecl | |||
CARLA_PLUGIN_EXPORT __cdecl | |||
const AEffect* VSTPluginMain_asm(audioMasterCallback audioMaster) | |||
{ | |||
return VSTPluginMain(audioMaster); | |||
@@ -1,7 +1,7 @@ | |||
/* | |||
* Carla Style, based on Qt5 fusion style | |||
* Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies) | |||
* Copyright (C) 2013-2019 Filipe Coelho <falktx@falktx.com> | |||
* Copyright (C) 2013-2022 Filipe Coelho <falktx@falktx.com> | |||
* | |||
* This program is free software; you can redistribute it and/or | |||
* modify it under the terms of the GNU Lesser General Public | |||
@@ -40,7 +40,7 @@ Q_EXPORT_PLUGIN2(Carla, CarlaStylePlugin) | |||
#endif | |||
#ifdef CARLA_OS_WIN | |||
CARLA_EXPORT void set_qt_app_style() | |||
CARLA_PLUGIN_EXPORT void set_qt_app_style() | |||
{ | |||
qApp->setStyle(new CarlaStyle()); | |||
} | |||