falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Browse Source

Misc Carla-Backend fixing, add Makefile.dbg

tags/v0.9.0
falkTX 13 years ago
parent
025d017988
commit
c86bc64579
12 changed files with 396 additions and 203 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +18
    -10
      src/carla-backend/Makefile
  2. +96
    -0
      src/carla-backend/Makefile.dbg
  3. +115
    -117
      src/carla-backend/carla_backend_standalone.cpp
  4. +2
    -1
      src/carla-backend/carla_engine.h
  5. +0
    -1
      src/carla-backend/carla_engine_jack.cpp
  6. +123
    -47
      src/carla-backend/carla_engine_rtaudio.cpp
  7. +1
    -1
      src/carla-backend/dssi.cpp
  8. +5
    -1
      src/carla-backend/lv2.cpp
  9. +16
    -13
      src/carla-backend/qtcreator/carla-backend.pro
  10. +2
    -2
      src/carla-backend/vst.cpp
  11. +9
    -3
      src/carla-includes/carla_lv2_includes.h
  12. +9
    -7
      src/carla.py

+ 18
- 10
src/carla-backend/Makefile View File

@@ -9,10 +9,11 @@ CXX ?= g++

BASE_FLAGS = -O2 -ffast-math -fomit-frame-pointer -fPIC -mtune=generic -msse -Wall -I. -I../carla-includes

HAVE_ALSA = $(shell pkg-config --exists alsa && echo true)
HAVE_JACK = $(shell pkg-config --exists jack && echo true)
HAVE_RTAUDIO = $(shell pkg-config --exists rtaudio && echo true) # FIXME - needs proper check
HAVE_PULSEAUDIO = $(shell pkg-config --exists libpulse-simple && echo true)
HAVE_FLUIDSYNTH = $(shell pkg-config --exists fluidsynth && echo true)
HAVE_LINUXSAMPLER = $(shell pkg-config --exists linuxsamplerXXX && echo true)
HAVE_LINUXSAMPLER = $(shell pkg-config --exists linuxsampler && echo true)
HAVE_SUIL = $(shell pkg-config --exists suil-0 && echo true)

CARLA_C_FLAGS = $(BASE_FLAGS) $(CFLAGS)
@@ -25,14 +26,21 @@ CARLA_CXX_FLAGS += -DVESTIGE_HEADER -I../carla-includes/vestige # Comment this
CARLA_LD_FLAGS = -shared -ldl -lm -fPIC $(LDFLAGS)
CARLA_LD_FLAGS += $(shell pkg-config --libs liblo QtCore QtGui)

ifeq ($(HAVE_ALSA),true)
WANT_RTAUDIO = true
CARLA_CXX_FLAGS += $(shell pkg-config --cflags alsa) -D__LINUX_ALSA__ -D__LINUX_ALSASEQ__
CARLA_LD_FLAGS += $(shell pkg-config --libs alsa)
endif

ifeq ($(HAVE_JACK),true)
CARLA_CXX_FLAGS += $(shell pkg-config --cflags jack) -DCARLA_ENGINE_JACK
CARLA_LD_FLAGS += $(shell pkg-config --libs jack)
endif

ifeq ($(HAVE_RTAUDIO),true)
CARLA_CXX_FLAGS += $(shell rtaudio-config --cppflags) -DCARLA_ENGINE_RTAUDIO
CARLA_LD_FLAGS += $(shell rtaudio-config --libs)
ifeq ($(HAVE_PULSEAUDIO),true)
WANT_RTAUDIO = true
CARLA_CXX_FLAGS += $(shell pkg-config --cflags libpulse-simple) -D__LINUX_PULSEAUDIO__
CARLA_LD_FLAGS += $(shell pkg-config --libs libpulse-simple)
endif

ifeq ($(HAVE_FLUIDSYNTH),true)
@@ -63,11 +71,11 @@ OBJS = \
lv2-rtmempool/rtmempool.o \
../carla-lilv/carla_lilv.a

# ifeq ($(driver),RtAudio)
# OBJS += rtaudio/rtaudio-4.0.11/RtAudio.o
# CARLA_CXX_FLAGS += $(shell pkg-config --cflags alsa libpulse-simple) -Irtaudio/rtaudio-4.0.11
# CARLA_LD_FLAGS += $(shell pkg-config --libs alsa libpulse-simple)
# endif
ifeq ($(WANT_RTAUDIO),true)
CARLA_CXX_FLAGS += -Irtaudio-4.0.11 -Irtmidi-4.0.11 -DCARLA_ENGINE_RTAUDIO -D_FORTIFY_SOURCE=2 -DHAVE_GETTIMEOFDAY
OBJS += rtaudio-4.0.11/RtAudio.o
OBJS += rtmidi-2.0.0/RtMidi.o
endif

# --------------------------------------------------------------



+ 96
- 0
src/carla-backend/Makefile.dbg View File

@@ -0,0 +1,96 @@
#!/usr/bin/make -f
# Makefile for carla-backend #
# ------------------------------------- #
# Created by falkTX
#

CC ?= gcc
CXX ?= g++

BASE_FLAGS = -O0 -g -fPIC -Wall -I. -I../carla-includes

HAVE_ALSA = $(shell pkg-config --exists alsa && echo true)
HAVE_JACK = $(shell pkg-config --exists jack && echo true)
HAVE_PULSEAUDIO = $(shell pkg-config --exists libpulse-simple && echo true)
HAVE_FLUIDSYNTH = $(shell pkg-config --exists fluidsynth && echo true)
HAVE_LINUXSAMPLER = $(shell pkg-config --exists linuxsampler && echo true)
HAVE_SUIL = $(shell pkg-config --exists suil-0 && echo true)

CARLA_C_FLAGS = $(BASE_FLAGS) $(CFLAGS)

CARLA_CXX_FLAGS = $(BASE_FLAGS) -std=c++0x $(CXXFLAGS)
CARLA_CXX_FLAGS += $(shell pkg-config --cflags liblo QtCore QtGui)
CARLA_CXX_FLAGS += -DDEBUG
CARLA_CXX_FLAGS += -DVESTIGE_HEADER -I../carla-includes/vestige # Comment this line to not use vestige header

CARLA_LD_FLAGS = -shared -ldl -lm -fPIC $(LDFLAGS)
CARLA_LD_FLAGS += $(shell pkg-config --libs liblo QtCore QtGui)

ifeq ($(HAVE_ALSA),true)
WANT_RTAUDIO = true
CARLA_CXX_FLAGS += $(shell pkg-config --cflags alsa) -D__LINUX_ALSA__ -D__LINUX_ALSASEQ__
CARLA_LD_FLAGS += $(shell pkg-config --libs alsa)
endif

ifeq ($(HAVE_JACK),true)
CARLA_CXX_FLAGS += $(shell pkg-config --cflags jack) -DCARLA_ENGINE_JACK
CARLA_LD_FLAGS += $(shell pkg-config --libs jack)
endif

ifeq ($(HAVE_PULSEAUDIO),true)
WANT_RTAUDIO = true
CARLA_CXX_FLAGS += $(shell pkg-config --cflags libpulse-simple) -D__LINUX_PULSEAUDIO__
CARLA_LD_FLAGS += $(shell pkg-config --libs libpulse-simple)
endif

ifeq ($(HAVE_FLUIDSYNTH),true)
CARLA_CXX_FLAGS += $(shell pkg-config --cflags fluidsynth) -DWANT_FLUIDSYNTH
CARLA_LD_FLAGS += $(shell pkg-config --libs fluidsynth)
endif

ifeq ($(HAVE_LINUXSAMPLER),true)
CARLA_CXX_FLAGS += $(shell pkg-config --cflags linuxsampler) -DWANT_LINUXSAMPLER
CARLA_LD_FLAGS += $(shell pkg-config --libs linuxsampler)
endif

ifeq ($(HAVE_SUIL),true)
CARLA_CXX_FLAGS += $(shell pkg-config --cflags suil-0) -DHAVE_SUIL
CARLA_LD_FLAGS += $(shell pkg-config --libs suil-0)
endif

OBJS = \
carla_backend_standalone.o \
carla_bridge.o \
carla_engine.o \
carla_engine_jack.o \
carla_engine_rtaudio.o \
carla_osc.o \
carla_shared.o \
carla_threads.o \
ladspa.o dssi.o lv2.o vst.o fluidsynth.o linuxsampler.o \
lv2-rtmempool/rtmempool.o \
../carla-lilv/carla_lilv.a

ifeq ($(WANT_RTAUDIO),true)
CARLA_CXX_FLAGS += -Irtaudio-4.0.11 -Irtmidi-4.0.11 -DCARLA_ENGINE_RTAUDIO -DHAVE_GETTIMEOFDAY
OBJS += rtaudio-4.0.11/RtAudio.o
OBJS += rtmidi-2.0.0/RtMidi.o
endif

# --------------------------------------------------------------

all: carla_backend.so

carla_backend.so: $(OBJS)
$(CXX) $^ $(CARLA_LD_FLAGS) -o $@ && strip $@

# --------------------------------------------------------------

.c.o:
$(CC) -c $< $(CARLA_C_FLAGS) -o $@

.cpp.o:
$(CXX) -c $< $(CARLA_CXX_FLAGS) -o $@

clean:
rm -f *.o lv2-rtmempool/*.o *.so *.dll

+ 115
- 117
src/carla-backend/carla_backend_standalone.cpp View File

@@ -25,7 +25,7 @@ static CarlaBackend::CarlaEngine* carla_engine = nullptr;

unsigned int get_engine_driver_count()
{
qDebug("get_engine_driver_count()");
qDebug("CarlaBackendStandalone::get_engine_driver_count()");

unsigned int count = 0;
#ifdef CARLA_ENGINE_JACK
@@ -41,7 +41,7 @@ unsigned int get_engine_driver_count()

const char* get_engine_driver_name(unsigned int index)
{
qDebug("get_engine_driver_name(%i)", index);
qDebug("CarlaBackendStandalone::get_engine_driver_name(%i)", index);

#ifdef CARLA_ENGINE_JACK
if (index == 0)
@@ -81,7 +81,7 @@ const char* get_engine_driver_name(unsigned int index)
}
#endif

qDebug("get_engine_driver_name(%i) - invalid index", index);
qDebug("CarlaBackendStandalone::get_engine_driver_name(%i) - invalid index", index);
return nullptr;
}

@@ -89,7 +89,7 @@ const char* get_engine_driver_name(unsigned int index)

bool engine_init(const char* driver_name, const char* client_name)
{
qDebug("engine_init(%s, %s)", driver_name, client_name);
qDebug("CarlaBackendStandalone::engine_init(%s, %s)", driver_name, client_name);

#ifdef CARLA_ENGINE_JACK
if (strcmp(driver_name, "JACK") == 0)
@@ -139,7 +139,7 @@ bool engine_init(const char* driver_name, const char* client_name)

bool engine_close()
{
qDebug("engine_close()");
qDebug("CarlaBackendStandalone::engine_close()");

if (! carla_engine)
{
@@ -171,7 +171,7 @@ bool engine_close()

bool is_engine_running()
{
qDebug("is_engine_running()");
qDebug("CarlaBackendStandalone::is_engine_running()");

return carla_engine && carla_engine->isRunning();
}
@@ -180,14 +180,14 @@ bool is_engine_running()

short add_plugin(CarlaBackend::BinaryType btype, CarlaBackend::PluginType ptype, const char* filename, const char* const name, const char* label, void* extra_stuff)
{
qDebug("add_plugin(%s, %s, %s, %s, %s, %p)", CarlaBackend::BinaryType2str(btype), CarlaBackend::PluginType2str(ptype), filename, name, label, extra_stuff);
qDebug("CarlaBackendStandalone::add_plugin(%s, %s, %s, %s, %s, %p)", CarlaBackend::BinaryType2str(btype), CarlaBackend::PluginType2str(ptype), filename, name, label, extra_stuff);

return carla_engine->addPlugin(btype, ptype, filename, name, label, extra_stuff);
}

bool remove_plugin(unsigned short plugin_id)
{
qDebug("remove_plugin(%i)", plugin_id);
qDebug("CarlaBackendStandalone::remove_plugin(%i)", plugin_id);

return carla_engine->removePlugin(plugin_id);
}
@@ -196,7 +196,7 @@ bool remove_plugin(unsigned short plugin_id)

const PluginInfo* get_plugin_info(unsigned short plugin_id)
{
qDebug("get_plugin_info(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_plugin_info(%i)", plugin_id);

static PluginInfo info;

@@ -244,14 +244,14 @@ const PluginInfo* get_plugin_info(unsigned short plugin_id)
}

if (carla_engine->isRunning())
qCritical("get_plugin_info(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_plugin_info(%i) - could not find plugin", plugin_id);

return &info;
}

const PortCountInfo* get_audio_port_count_info(unsigned short plugin_id)
{
qDebug("get_audio_port_count_info(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_audio_port_count_info(%i)", plugin_id);

static PortCountInfo info;

@@ -265,13 +265,13 @@ const PortCountInfo* get_audio_port_count_info(unsigned short plugin_id)
return &info;
}

qCritical("get_audio_port_count_info(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_audio_port_count_info(%i) - could not find plugin", plugin_id);
return &info;
}

const PortCountInfo* get_midi_port_count_info(unsigned short plugin_id)
{
qDebug("get_midi_port_count_info(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_midi_port_count_info(%i)", plugin_id);

static PortCountInfo info;

@@ -285,13 +285,13 @@ const PortCountInfo* get_midi_port_count_info(unsigned short plugin_id)
return &info;
}

qCritical("get_midi_port_count_info(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_midi_port_count_info(%i) - could not find plugin", plugin_id);
return &info;
}

const PortCountInfo* get_parameter_count_info(unsigned short plugin_id)
{
qDebug("get_parameter_port_count_info(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_parameter_port_count_info(%i)", plugin_id);

static PortCountInfo info;

@@ -303,13 +303,13 @@ const PortCountInfo* get_parameter_count_info(unsigned short plugin_id)
return &info;
}

qCritical("get_parameter_port_count_info(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_parameter_port_count_info(%i) - could not find plugin", plugin_id);
return &info;
}

const ParameterInfo* get_parameter_info(unsigned short plugin_id, quint32 parameter_id)
{
qDebug("get_parameter_info(%i, %i)", plugin_id, parameter_id);
qDebug("CarlaBackendStandalone::get_parameter_info(%i, %i)", plugin_id, parameter_id);

static ParameterInfo info;

@@ -351,20 +351,20 @@ const ParameterInfo* get_parameter_info(unsigned short plugin_id, quint32 parame
info.unit = strdup(buf_str);
}
else
qCritical("get_parameter_info(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_info(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);

return &info;
}

if (carla_engine->isRunning())
qCritical("get_parameter_info(%i, %i) - could not find plugin", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_info(%i, %i) - could not find plugin", plugin_id, parameter_id);

return &info;
}

const ScalePointInfo* get_parameter_scalepoint_info(unsigned short plugin_id, quint32 parameter_id, quint32 scalepoint_id)
{
qDebug("get_parameter_scalepoint_info(%i, %i, %i)", plugin_id, parameter_id, scalepoint_id);
qDebug("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i)", plugin_id, parameter_id, scalepoint_id);

static ScalePointInfo info;

@@ -390,23 +390,23 @@ const ScalePointInfo* get_parameter_scalepoint_info(unsigned short plugin_id, qu
info.label = strdup(buf_str);
}
else
qCritical("get_parameter_scalepoint_info(%i, %i, %i) - scalepoint_id out of bounds", plugin_id, parameter_id, scalepoint_id);
qCritical("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i) - scalepoint_id out of bounds", plugin_id, parameter_id, scalepoint_id);
}
else
qCritical("get_parameter_scalepoint_info(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, parameter_id);

return &info;
}

if (carla_engine->isRunning())
qCritical("get_parameter_scalepoint_info(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, scalepoint_id);
qCritical("CarlaBackendStandalone::get_parameter_scalepoint_info(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, scalepoint_id);

return &info;
}

const GuiInfo* get_gui_info(unsigned short plugin_id)
{
qDebug("get_gui_info(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_gui_info(%i)", plugin_id);

static GuiInfo info;

@@ -418,7 +418,7 @@ const GuiInfo* get_gui_info(unsigned short plugin_id)
return &info;
}

qCritical("get_gui_info(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_gui_info(%i) - could not find plugin", plugin_id);
return &info;
}

@@ -426,7 +426,7 @@ const GuiInfo* get_gui_info(unsigned short plugin_id)

const CarlaBackend::ParameterData* get_parameter_data(unsigned short plugin_id, quint32 parameter_id)
{
qDebug("get_parameter_data(%i, %i)", plugin_id, parameter_id);
qDebug("CarlaBackendStandalone::get_parameter_data(%i, %i)", plugin_id, parameter_id);

static CarlaBackend::ParameterData data;

@@ -437,17 +437,17 @@ const CarlaBackend::ParameterData* get_parameter_data(unsigned short plugin_id,
if (parameter_id < plugin->parameterCount())
return plugin->parameterData(parameter_id);

qCritical("get_parameter_data(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_data(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
return &data;
}

qCritical("get_parameter_data(%i, %i) - could not find plugin", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_data(%i, %i) - could not find plugin", plugin_id, parameter_id);
return &data;
}

const CarlaBackend::ParameterRanges* get_parameter_ranges(unsigned short plugin_id, quint32 parameter_id)
{
qDebug("get_parameter_ranges(%i, %i)", plugin_id, parameter_id);
qDebug("CarlaBackendStandalone::get_parameter_ranges(%i, %i)", plugin_id, parameter_id);

static CarlaBackend::ParameterRanges ranges;

@@ -458,17 +458,17 @@ const CarlaBackend::ParameterRanges* get_parameter_ranges(unsigned short plugin_
if (parameter_id < plugin->parameterCount())
return plugin->parameterRanges(parameter_id);

qCritical("get_parameter_ranges(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_ranges(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
return &ranges;
}

qCritical("get_parameter_ranges(%i, %i) - could not find plugin", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_ranges(%i, %i) - could not find plugin", plugin_id, parameter_id);
return &ranges;
}

const CarlaBackend::midi_program_t* get_midi_program_data(unsigned short plugin_id, quint32 midi_program_id)
{
qDebug("get_midi_program_data(%i, %i)", plugin_id, midi_program_id);
qDebug("CarlaBackendStandalone::get_midi_program_data(%i, %i)", plugin_id, midi_program_id);

static CarlaBackend::midi_program_t data;

@@ -479,17 +479,17 @@ const CarlaBackend::midi_program_t* get_midi_program_data(unsigned short plugin_
if (midi_program_id < plugin->midiProgramCount())
return plugin->midiProgramData(midi_program_id);

qCritical("get_midi_program_data(%i, %i) - midi_program_id out of bounds", plugin_id, midi_program_id);
qCritical("CarlaBackendStandalone::get_midi_program_data(%i, %i) - midi_program_id out of bounds", plugin_id, midi_program_id);
return &data;
}

qCritical("get_midi_program_data(%i, %i) - could not find plugin", plugin_id, midi_program_id);
qCritical("CarlaBackendStandalone::get_midi_program_data(%i, %i) - could not find plugin", plugin_id, midi_program_id);
return &data;
}

const CarlaBackend::CustomData* get_custom_data(unsigned short plugin_id, quint32 custom_data_id)
{
qDebug("get_custom_data(%i, %i)", plugin_id, custom_data_id);
qDebug("CarlaBackendStandalone::get_custom_data(%i, %i)", plugin_id, custom_data_id);

static CarlaBackend::CustomData data;

@@ -500,17 +500,17 @@ const CarlaBackend::CustomData* get_custom_data(unsigned short plugin_id, quint3
if (custom_data_id < plugin->customDataCount())
return plugin->customData(custom_data_id);

qCritical("get_custom_data(%i, %i) - custom_data_id out of bounds", plugin_id, custom_data_id);
qCritical("CarlaBackendStandalone::get_custom_data(%i, %i) - custom_data_id out of bounds", plugin_id, custom_data_id);
return &data;
}

qCritical("get_custom_data(%i, %i) - could not find plugin", plugin_id, custom_data_id);
qCritical("CarlaBackendStandalone::get_custom_data(%i, %i) - could not find plugin", plugin_id, custom_data_id);
return &data;
}

const char* get_chunk_data(unsigned short plugin_id)
{
qDebug("get_chunk_data(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_chunk_data(%i)", plugin_id);

static const char* chunk_data = nullptr;

@@ -535,16 +535,16 @@ const char* get_chunk_data(unsigned short plugin_id)
chunk_data = strdup(chunk.toBase64().data());
}
else
qCritical("get_chunk_data(%i) - got invalid chunk data", plugin_id);
qCritical("CarlaBackendStandalone::get_chunk_data(%i) - got invalid chunk data", plugin_id);
}
else
qCritical("get_chunk_data(%i) - plugin does not support chunks", plugin_id);
qCritical("CarlaBackendStandalone::get_chunk_data(%i) - plugin does not support chunks", plugin_id);

return chunk_data;
}

if (carla_engine->isRunning())
qCritical("get_chunk_data(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_chunk_data(%i) - could not find plugin", plugin_id);

return nullptr;
}
@@ -553,53 +553,53 @@ const char* get_chunk_data(unsigned short plugin_id)

uint32_t get_parameter_count(unsigned short plugin_id)
{
qDebug("get_parameter_count(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_parameter_count(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->parameterCount();

qCritical("get_parameter_count(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_parameter_count(%i) - could not find plugin", plugin_id);
return 0;
}

uint32_t get_program_count(unsigned short plugin_id)
{
qDebug("get_program_count(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_program_count(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->programCount();

qCritical("get_program_count(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_program_count(%i) - could not find plugin", plugin_id);
return 0;
}

uint32_t get_midi_program_count(unsigned short plugin_id)
{
qDebug("get_midi_program_count(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_midi_program_count(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->midiProgramCount();

qCritical("get_midi_program_count(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_midi_program_count(%i) - could not find plugin", plugin_id);
return 0;
}

uint32_t get_custom_data_count(unsigned short plugin_id)
{
qDebug("get_custom_data_count(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_custom_data_count(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->customDataCount();

qCritical("get_custom_data_count(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_custom_data_count(%i) - could not find plugin", plugin_id);
return 0;
}

@@ -607,7 +607,7 @@ uint32_t get_custom_data_count(unsigned short plugin_id)

const char* get_parameter_text(unsigned short plugin_id, quint32 parameter_id)
{
qDebug("get_parameter_text(%i, %i)", plugin_id, parameter_id);
qDebug("CarlaBackendStandalone::get_parameter_text(%i, %i)", plugin_id, parameter_id);

static char buf_text[STR_MAX] = { 0 };
memset(buf_text, 0, sizeof(char)*STR_MAX);
@@ -622,19 +622,19 @@ const char* get_parameter_text(unsigned short plugin_id, quint32 parameter_id)
return buf_text;
}

qCritical("get_parameter_text(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_text(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
return nullptr;
}

if (carla_engine->isRunning())
qCritical("get_parameter_text(%i, %i) - could not find plugin", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_parameter_text(%i, %i) - could not find plugin", plugin_id, parameter_id);

return nullptr;
}

const char* get_program_name(unsigned short plugin_id, quint32 program_id)
{
qDebug("get_program_name(%i, %i)", plugin_id, program_id);
qDebug("CarlaBackendStandalone::get_program_name(%i, %i)", plugin_id, program_id);

static const char* program_name = nullptr;

@@ -658,19 +658,19 @@ const char* get_program_name(unsigned short plugin_id, quint32 program_id)
return program_name;
}

qCritical("get_program_name(%i, %i) - program_id out of bounds", plugin_id, program_id);
qCritical("CarlaBackendStandalone::get_program_name(%i, %i) - program_id out of bounds", plugin_id, program_id);
return nullptr;
}

if (carla_engine->isRunning())
qCritical("get_program_name(%i, %i) - could not find plugin", plugin_id, program_id);
qCritical("CarlaBackendStandalone::get_program_name(%i, %i) - could not find plugin", plugin_id, program_id);

return nullptr;
}

const char* get_midi_program_name(unsigned short plugin_id, quint32 midi_program_id)
{
qDebug("get_midi_program_name(%i, %i)", plugin_id, midi_program_id);
qDebug("CarlaBackendStandalone::get_midi_program_name(%i, %i)", plugin_id, midi_program_id);

static const char* midi_program_name = nullptr;

@@ -693,19 +693,19 @@ const char* get_midi_program_name(unsigned short plugin_id, quint32 midi_program
return midi_program_name;
}

qCritical("get_midi_program_name(%i, %i) - program_id out of bounds", plugin_id, midi_program_id);
qCritical("CarlaBackendStandalone::get_midi_program_name(%i, %i) - program_id out of bounds", plugin_id, midi_program_id);
return nullptr;
}

if (carla_engine->isRunning())
qCritical("get_midi_program_name(%i, %i) - could not find plugin", plugin_id, midi_program_id);
qCritical("CarlaBackendStandalone::get_midi_program_name(%i, %i) - could not find plugin", plugin_id, midi_program_id);

return nullptr;
}

const char* get_real_plugin_name(unsigned short plugin_id)
{
qDebug("get_real_plugin_name(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_real_plugin_name(%i)", plugin_id);

static const char* real_plugin_name = nullptr;

@@ -728,7 +728,7 @@ const char* get_real_plugin_name(unsigned short plugin_id)
}

if (carla_engine->isRunning())
qCritical("get_real_plugin_name(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_real_plugin_name(%i) - could not find plugin", plugin_id);

return real_plugin_name;
}
@@ -737,27 +737,27 @@ const char* get_real_plugin_name(unsigned short plugin_id)

qint32 get_current_program_index(unsigned short plugin_id)
{
qDebug("get_current_program_index(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_current_program_index(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->currentProgram();

qCritical("get_current_program_index(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_current_program_index(%i) - could not find plugin", plugin_id);
return -1;
}

qint32 get_current_midi_program_index(unsigned short plugin_id)
{
qDebug("get_current_midi_program_index(%i)", plugin_id);
qDebug("CarlaBackendStandalone::get_current_midi_program_index(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->currentMidiProgram();

qCritical("get_current_midi_program_index(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::get_current_midi_program_index(%i) - could not find plugin", plugin_id);
return -1;
}

@@ -765,7 +765,7 @@ qint32 get_current_midi_program_index(unsigned short plugin_id)

double get_default_parameter_value(unsigned short plugin_id, quint32 parameter_id)
{
qDebug("get_default_parameter_value(%i, %i)", plugin_id, parameter_id);
qDebug("CarlaBackendStandalone::get_default_parameter_value(%i, %i)", plugin_id, parameter_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

@@ -774,17 +774,17 @@ double get_default_parameter_value(unsigned short plugin_id, quint32 parameter_i
if (parameter_id < plugin->parameterCount())
return plugin->parameterRanges(parameter_id)->def;

qCritical("get_default_parameter_value(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_default_parameter_value(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
return 0.0;
}

qCritical("get_default_parameter_value(%i, %i) - could not find plugin", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_default_parameter_value(%i, %i) - could not find plugin", plugin_id, parameter_id);
return 0.0;
}

double get_current_parameter_value(unsigned short plugin_id, quint32 parameter_id)
{
qDebug("get_current_parameter_value(%i, %i)", plugin_id, parameter_id);
qDebug("CarlaBackendStandalone::get_current_parameter_value(%i, %i)", plugin_id, parameter_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

@@ -793,11 +793,11 @@ double get_current_parameter_value(unsigned short plugin_id, quint32 parameter_i
if (parameter_id < plugin->parameterCount())
return plugin->getParameterValue(parameter_id);

qCritical("get_current_parameter_value(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_current_parameter_value(%i, %i) - parameter_id out of bounds", plugin_id, parameter_id);
return 0.0;
}

qCritical("get_current_parameter_value(%i, %i) - could not find plugin", plugin_id, parameter_id);
qCritical("CarlaBackendStandalone::get_current_parameter_value(%i, %i) - could not find plugin", plugin_id, parameter_id);
return 0.0;
}

@@ -821,69 +821,69 @@ double get_output_peak_value(unsigned short plugin_id, unsigned short port_id)

void set_active(unsigned short plugin_id, bool onoff)
{
qDebug("set_active(%i, %s)", plugin_id, bool2str(onoff));
qDebug("CarlaBackendStandalone::set_active(%i, %s)", plugin_id, bool2str(onoff));

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->setActive(onoff, true, false);

qCritical("set_active(%i, %s) - could not find plugin", plugin_id, bool2str(onoff));
qCritical("CarlaBackendStandalone::set_active(%i, %s) - could not find plugin", plugin_id, bool2str(onoff));
}

void set_drywet(unsigned short plugin_id, double value)
{
qDebug("set_drywet(%i, %f)", plugin_id, value);
qDebug("CarlaBackendStandalone::set_drywet(%i, %f)", plugin_id, value);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->setDryWet(value, true, false);

qCritical("set_drywet(%i, %f) - could not find plugin", plugin_id, value);
qCritical("CarlaBackendStandalone::set_drywet(%i, %f) - could not find plugin", plugin_id, value);
}

void set_volume(unsigned short plugin_id, double value)
{
qDebug("set_vol(%i, %f)", plugin_id, value);
qDebug("CarlaBackendStandalone::set_vol(%i, %f)", plugin_id, value);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->setVolume(value, true, false);

qCritical("set_vol(%i, %f) - could not find plugin", plugin_id, value);
qCritical("CarlaBackendStandalone::set_vol(%i, %f) - could not find plugin", plugin_id, value);
}

void set_balance_left(unsigned short plugin_id, double value)
{
qDebug("set_balance_left(%i, %f)", plugin_id, value);
qDebug("CarlaBackendStandalone::set_balance_left(%i, %f)", plugin_id, value);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->setBalanceLeft(value, true, false);

qCritical("set_balance_left(%i, %f) - could not find plugin", plugin_id, value);
qCritical("CarlaBackendStandalone::set_balance_left(%i, %f) - could not find plugin", plugin_id, value);
}

void set_balance_right(unsigned short plugin_id, double value)
{
qDebug("set_balance_right(%i, %f)", plugin_id, value);
qDebug("CarlaBackendStandalone::set_balance_right(%i, %f)", plugin_id, value);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->setBalanceRight(value, true, false);

qCritical("set_balance_right(%i, %f) - could not find plugin", plugin_id, value);
qCritical("CarlaBackendStandalone::set_balance_right(%i, %f) - could not find plugin", plugin_id, value);
}

// -------------------------------------------------------------------------------------------------------------------

void set_parameter_value(unsigned short plugin_id, quint32 parameter_id, double value)
{
qDebug("set_parameter_value(%i, %i, %f)", plugin_id, parameter_id, value);
qDebug("CarlaBackendStandalone::set_parameter_value(%i, %i, %f)", plugin_id, parameter_id, value);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

@@ -892,20 +892,20 @@ void set_parameter_value(unsigned short plugin_id, quint32 parameter_id, double
if (parameter_id < plugin->parameterCount())
return plugin->setParameterValue(parameter_id, value, true, true, false);

qCritical("set_parameter_value(%i, %i, %f) - parameter_id out of bounds", plugin_id, parameter_id, value);
qCritical("CarlaBackendStandalone::set_parameter_value(%i, %i, %f) - parameter_id out of bounds", plugin_id, parameter_id, value);
return;
}

qCritical("set_parameter_value(%i, %i, %f) - could not find plugin", plugin_id, parameter_id, value);
qCritical("CarlaBackendStandalone::set_parameter_value(%i, %i, %f) - could not find plugin", plugin_id, parameter_id, value);
}

void set_parameter_midi_channel(unsigned short plugin_id, quint32 parameter_id, quint8 channel)
{
qDebug("set_parameter_midi_channel(%i, %i, %i)", plugin_id, parameter_id, channel);
qDebug("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i)", plugin_id, parameter_id, channel);

if (channel > 15)
{
qCritical("set_parameter_midi_channel(%i, %i, %i) - invalid channel number", plugin_id, parameter_id, channel);
qCritical("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i) - invalid channel number", plugin_id, parameter_id, channel);
return;
}

@@ -916,16 +916,16 @@ void set_parameter_midi_channel(unsigned short plugin_id, quint32 parameter_id,
if (parameter_id < plugin->parameterCount())
return plugin->setParameterMidiChannel(parameter_id, channel);

qCritical("set_parameter_midi_channel(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, channel);
qCritical("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, channel);
return;
}

qCritical("set_parameter_midi_channel(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, channel);
qCritical("CarlaBackendStandalone::set_parameter_midi_channel(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, channel);
}

void set_parameter_midi_cc(unsigned short plugin_id, quint32 parameter_id, int16_t midi_cc)
{
qDebug("set_parameter_midi_cc(%i, %i, %i)", plugin_id, parameter_id, midi_cc);
qDebug("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i)", plugin_id, parameter_id, midi_cc);

if (midi_cc < -1)
{
@@ -933,7 +933,7 @@ void set_parameter_midi_cc(unsigned short plugin_id, quint32 parameter_id, int16
}
else if (midi_cc > 0x5F) // 95
{
qCritical("set_parameter_midi_cc(%i, %i, %i) - invalid midi_cc number", plugin_id, parameter_id, midi_cc);
qCritical("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i) - invalid midi_cc number", plugin_id, parameter_id, midi_cc);
return;
}

@@ -944,16 +944,16 @@ void set_parameter_midi_cc(unsigned short plugin_id, quint32 parameter_id, int16
if (parameter_id < plugin->parameterCount())
return plugin->setParameterMidiCC(parameter_id, midi_cc);

qCritical("set_parameter_midi_cc(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, midi_cc);
qCritical("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i) - parameter_id out of bounds", plugin_id, parameter_id, midi_cc);
return;
}

qCritical("set_parameter_midi_cc(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, midi_cc);
qCritical("CarlaBackendStandalone::set_parameter_midi_cc(%i, %i, %i) - could not find plugin", plugin_id, parameter_id, midi_cc);
}

void set_program(unsigned short plugin_id, quint32 program_id)
{
qDebug("set_program(%i, %i)", plugin_id, program_id);
qDebug("CarlaBackendStandalone::set_program(%i, %i)", plugin_id, program_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

@@ -962,48 +962,48 @@ void set_program(unsigned short plugin_id, quint32 program_id)
if (program_id < plugin->programCount())
return plugin->setProgram(program_id, true, true, false, true);

qCritical("set_program(%i, %i) - program_id out of bounds", plugin_id, program_id);
qCritical("CarlaBackendStandalone::set_program(%i, %i) - program_id out of bounds", plugin_id, program_id);
return;
}

qCritical("set_program(%i, %i) - could not find plugin", plugin_id, program_id);
qCritical("CarlaBackendStandalone::set_program(%i, %i) - could not find plugin", plugin_id, program_id);
}

void set_midi_program(unsigned short plugin_id, quint32 midi_program_id)
{
qDebug("set_midi_program(%i, %i)", plugin_id, midi_program_id);
qDebug("CarlaBackendStandalone::set_midi_program(%i, %i)", plugin_id, midi_program_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
{
if (midi_program_id < plugin->midiProgramCount())
plugin->setMidiProgram(midi_program_id, true, true, false, true);
return plugin->setMidiProgram(midi_program_id, true, true, false, true);

qCritical("set_midi_program(%i, %i) - program_id out of bounds", plugin_id, midi_program_id);
qCritical("CarlaBackendStandalone::set_midi_program(%i, %i) - program_id out of bounds", plugin_id, midi_program_id);
return;
}

qCritical("set_midi_program(%i, %i) - could not find plugin", plugin_id, midi_program_id);
qCritical("CarlaBackendStandalone::set_midi_program(%i, %i) - could not find plugin", plugin_id, midi_program_id);
}

// -------------------------------------------------------------------------------------------------------------------

void set_custom_data(unsigned short plugin_id, CarlaBackend::CustomDataType type, const char* key, const char* value)
{
qDebug("set_custom_data(%i, %i, %s, %s)", plugin_id, type, key, value);
qDebug("CarlaBackendStandalone::set_custom_data(%i, %i, %s, %s)", plugin_id, type, key, value);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->setCustomData(type, key, value, true);

qCritical("set_custom_data(%i, %i, %s, %s) - could not find plugin", plugin_id, type, key, value);
qCritical("CarlaBackendStandalone::set_custom_data(%i, %i, %s, %s) - could not find plugin", plugin_id, type, key, value);
}

void set_chunk_data(unsigned short plugin_id, const char* chunk_data)
{
qDebug("set_chunk_data(%i, %s)", plugin_id, chunk_data);
qDebug("CarlaBackendStandalone::set_chunk_data(%i, %s)", plugin_id, chunk_data);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

@@ -1012,16 +1012,16 @@ void set_chunk_data(unsigned short plugin_id, const char* chunk_data)
if (plugin->hints() & CarlaBackend::PLUGIN_USES_CHUNKS)
return plugin->setChunkData(chunk_data);

qCritical("set_chunk_data(%i, %s) - plugin does not support chunks", plugin_id, chunk_data);
qCritical("CarlaBackendStandalone::set_chunk_data(%i, %s) - plugin does not support chunks", plugin_id, chunk_data);
return;
}

qCritical("set_chunk_data(%i, %s) - could not find plugin", plugin_id, chunk_data);
qCritical("CarlaBackendStandalone::set_chunk_data(%i, %s) - could not find plugin", plugin_id, chunk_data);
}

void set_gui_data(unsigned short plugin_id, int data, quintptr gui_addr)
{
qDebug("set_gui_data(%i, %i, " P_UINTPTR ")", plugin_id, data, gui_addr);
qDebug("CarlaBackendStandalone::set_gui_data(%i, %i, " P_UINTPTR ")", plugin_id, data, gui_addr);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

@@ -1035,21 +1035,21 @@ void set_gui_data(unsigned short plugin_id, int data, quintptr gui_addr)
return;
}

qCritical("set_gui_data(%i, %i, " P_UINTPTR ") - could not find plugin", plugin_id, data, gui_addr);
qCritical("CarlaBackendStandalone::set_gui_data(%i, %i, " P_UINTPTR ") - could not find plugin", plugin_id, data, gui_addr);
}

// -------------------------------------------------------------------------------------------------------------------

void show_gui(unsigned short plugin_id, bool yesno)
{
qDebug("show_gui(%i, %s)", plugin_id, bool2str(yesno));
qDebug("CarlaBackendStandalone::show_gui(%i, %s)", plugin_id, bool2str(yesno));

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->showGui(yesno);

qCritical("show_gui(%i, %s) - could not find plugin", plugin_id, bool2str(yesno));
qCritical("CarlaBackendStandalone::show_gui(%i, %s) - could not find plugin", plugin_id, bool2str(yesno));
}

void idle_guis()
@@ -1061,40 +1061,40 @@ void idle_guis()

void send_midi_note(unsigned short plugin_id, quint8 note, quint8 velocity)
{
qDebug("send_midi_note(%i, %i, %i)", plugin_id, note, velocity);
qDebug("CarlaBackendStandalone::send_midi_note(%i, %i, %i)", plugin_id, note, velocity);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->sendMidiSingleNote(0, note, velocity, true, true, false); // FIXME

qCritical("send_midi_note(%i, %i, %i) - could not find plugin", plugin_id, note, velocity);
qCritical("CarlaBackendStandalone::send_midi_note(%i, %i, %i) - could not find plugin", plugin_id, note, velocity);
}

void prepare_for_save(unsigned short plugin_id)
{
qDebug("prepare_for_save(%i)", plugin_id);
qDebug("CarlaBackendStandalone::prepare_for_save(%i)", plugin_id);

CarlaBackend::CarlaPlugin* const plugin = carla_engine->getPlugin(plugin_id);

if (plugin)
return plugin->prepareForSave();

qCritical("prepare_for_save(%i) - could not find plugin", plugin_id);
qCritical("CarlaBackendStandalone::prepare_for_save(%i) - could not find plugin", plugin_id);
}

// -------------------------------------------------------------------------------------------------------------------

quint32 get_buffer_size()
{
qDebug("get_buffer_size()");
qDebug("CarlaBackendStandalone::get_buffer_size()");

return carla_engine->getBufferSize();
}

double get_sample_rate()
{
qDebug("get_sample_rate()");
qDebug("CarlaBackendStandalone::get_sample_rate()");

return carla_engine->getSampleRate();
}
@@ -1108,7 +1108,7 @@ const char* get_last_error()

const char* get_host_osc_url()
{
qDebug("get_host_osc_url()");
qDebug("CarlaBackendStandalone::get_host_osc_url()");

return carla_engine->getOscServerPath();
}
@@ -1117,7 +1117,7 @@ const char* get_host_osc_url()

void set_callback_function(CarlaBackend::CallbackFunc func)
{
qDebug("set_callback_function(%p)", func);
qDebug("CarlaBackendStandalone::set_callback_function(%p)", func);

carla_engine->setCallback(func);
}
@@ -1174,8 +1174,6 @@ int main(int argc, char* argv[])

if (id >= 0)
{
qDebug("Main Initiated, id = %u", id);

const GuiInfo* const guiInfo = get_gui_info(id);

if (guiInfo->type == CarlaBackend::GUI_INTERNAL_QT4 || guiInfo->type == CarlaBackend::GUI_INTERNAL_X11)


+ 2
- 1
src/carla-backend/carla_engine.h View File

@@ -32,7 +32,7 @@

#ifdef CARLA_ENGINE_RTAUDIO
#include "RtAudio.h"
//#include "RtMidi.h"
#include "RtMidi.h"
#endif

CARLA_BACKEND_START_NAMESPACE
@@ -564,6 +564,7 @@ public:

private:
RtAudio adac;
QThread* procThread;
};
#endif



+ 0
- 1
src/carla-backend/carla_engine_jack.cpp View File

@@ -21,7 +21,6 @@
#include "carla_plugin.h"

#include <iostream>
#include <QtCore/QThread>

CARLA_BACKEND_START_NAMESPACE



+ 123
- 47
src/carla-backend/carla_engine_rtaudio.cpp View File

@@ -20,8 +20,6 @@
#include "carla_engine.h"
#include "carla_plugin.h"

#include <QtCore/QThread>

CARLA_BACKEND_START_NAMESPACE

#if 0
@@ -45,22 +43,30 @@ CarlaEngineRtAudio::CarlaEngineRtAudio(RtAudio::Api api)
: CarlaEngine(),
adac(api)
{
qDebug("CarlaEngineRtAudio::CarlaEngineRtAudio()");

procThread = nullptr;
}

CarlaEngineRtAudio::~CarlaEngineRtAudio()
{
qDebug("CarlaEngineRtAudio::~CarlaEngineRtAudio()");
}

bool CarlaEngineRtAudio::init(const char* name_)
bool CarlaEngineRtAudio::init(const char* const clientName)
{
qDebug("CarlaEngineRtAudio::init(%s)", clientName);

procThread = nullptr;

if (adac.getDeviceCount() < 1)
{
set_last_error("No audio devices available");
setLastError("No audio devices available");
return false;
}

sampleRate = 48000;
unsigned int bufferFrames = 512;
unsigned int rtBufferFrames = 512;

RtAudio::StreamParameters iParams, oParams;
//iParams.deviceId = 3;
@@ -69,45 +75,46 @@ bool CarlaEngineRtAudio::init(const char* name_)
oParams.nChannels = 2;
RtAudio::StreamOptions options;
options.flags = /*RTAUDIO_NONINTERLEAVED |*/ RTAUDIO_MINIMIZE_LATENCY /*| RTAUDIO_HOG_DEVICE*/ | RTAUDIO_SCHEDULE_REALTIME | RTAUDIO_ALSA_USE_DEFAULT;
options.streamName = name_;
options.streamName = clientName;
options.priority = 85;

try {
adac.openStream(&oParams, &iParams, RTAUDIO_FLOAT32, sampleRate, &bufferFrames, carla_rtaudio_process_callback, this, &options);
adac.openStream(&oParams, &iParams, RTAUDIO_FLOAT32, sampleRate, &rtBufferFrames, carla_rtaudio_process_callback, this, &options);
}
catch (RtError& e)
{
set_last_error(e.what());
setLastError(e.what());
return false;
}

bufferSize = bufferFrames;
name = strdup(name_);

oscInit();
bufferSize = rtBufferFrames;
name = strdup(clientName);

try {
adac.startStream();
}
catch (RtError& e)
{
set_last_error(e.what());
setLastError(e.what());
return false;
}

CarlaEngine::init(name);

return true;
}

bool CarlaEngineRtAudio::close()
{
qDebug("CarlaEngineRtAudio::close()");
CarlaEngine::close();

if (name)
{
free((void*)name);
name = nullptr;
}

oscClose();

if (adac.isStreamRunning())
adac.stopStream();

@@ -119,9 +126,7 @@ bool CarlaEngineRtAudio::close()

bool CarlaEngineRtAudio::isOnAudioThread()
{
// FIXME ?
//return (QThread::currentThread() == procThread);
return true;
return (QThread::currentThread() == procThread);
}

bool CarlaEngineRtAudio::isOffline()
@@ -150,24 +155,18 @@ CarlaEngineClient* CarlaEngineRtAudio::addClient(CarlaPlugin* const plugin)

void CarlaEngineRtAudio::handleProcessCallback(void* outputBuffer, void* inputBuffer, unsigned int nframes, double streamTime, RtAudioStreamStatus status)
{
Q_UNUSED(outputBuffer);
Q_UNUSED(inputBuffer);
Q_UNUSED(nframes);
Q_UNUSED(streamTime);
Q_UNUSED(status);

#if 0
if (carla_proc_thread == nullptr)
carla_proc_thread = QThread::currentThread();
if (procThread == nullptr)
procThread = QThread::currentThread();

// get buffers from RtAudio
float* insPtr = (float*)inputBuffer;
float* outsPtr = (float*)outputBuffer;

//float* in1 = insPtr + 0*nframes;
//float* in2 = insPtr + 1*nframes;
//float* out1 = outsPtr + 0*nframes;
//float* out2 = outsPtr + 1*nframes;
// assert buffers
assert(insPtr);
assert(outsPtr);

// create temporary audio buffers
float ains_tmp_buf1[nframes];
float ains_tmp_buf2[nframes];
float aouts_tmp_buf1[nframes];
@@ -176,6 +175,7 @@ void CarlaEngineRtAudio::handleProcessCallback(void* outputBuffer, void* inputBu
float* ains_tmp[2] = { ains_tmp_buf1, ains_tmp_buf2 };
float* aouts_tmp[2] = { aouts_tmp_buf1, aouts_tmp_buf2 };

// initialize audio input
for (unsigned int i=0; i < nframes*2; i++)
{
if (i % 2)
@@ -184,28 +184,95 @@ void CarlaEngineRtAudio::handleProcessCallback(void* outputBuffer, void* inputBu
ains_tmp_buf1[i/2] = insPtr[i];
}

//memcpy(ains_tmp_buf1, in1, sizeof(float)*nframes);
//memcpy(ains_tmp_buf2, in2, sizeof(float)*nframes);
// initialize control input
memset(rackControlEventsIn, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);
{
// TODO
}

// initialize midi input
memset(rackMidiEventsIn, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
{
// TODO
}

// initialize outputs (zero)
memset(aouts_tmp_buf1, 0, sizeof(float)*nframes);
memset(aouts_tmp_buf2, 0, sizeof(float)*nframes);
memset(rackControlEventsOut, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);
memset(rackMidiEventsOut, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);

bool processed = false;

for (unsigned short i=0; i<MAX_PLUGINS; i++)
// process plugins
for (unsigned short i=0; i < MAX_PLUGINS; i++)
{
CarlaPlugin* const plugin = CarlaPlugins[i];
CarlaPlugin* const plugin = getPlugin(i);

if (plugin && plugin->enabled())
{
memset(aouts_tmp_buf1, 0, sizeof(float)*nframes);
memset(aouts_tmp_buf2, 0, sizeof(float)*nframes);

carla_proc_lock();
plugin->process(ains_tmp, aouts_tmp, nframes);
carla_proc_unlock();

memcpy(ains_tmp_buf1, aouts_tmp_buf1, sizeof(float)*nframes);
memcpy(ains_tmp_buf2, aouts_tmp_buf2, sizeof(float)*nframes);
if (processed)
{
// initialize inputs (from previous outputs)
memcpy(ains_tmp_buf1, aouts_tmp_buf1, sizeof(float)*nframes);
memcpy(ains_tmp_buf2, aouts_tmp_buf2, sizeof(float)*nframes);
memcpy(rackMidiEventsIn, rackMidiEventsOut, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);

// initialize outputs (zero)
memset(aouts_tmp_buf1, 0, sizeof(float)*nframes);
memset(aouts_tmp_buf2, 0, sizeof(float)*nframes);
memset(rackMidiEventsOut, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
}

// process
plugin->engineProcessLock();

plugin->initBuffers();

if (carlaOptions.proccess_hq)
{
float* ains_buffer2[2];
float* aouts_buffer2[2];

for (uint32_t j=0; j < nframes; j += 8)
{
ains_buffer2[0] = ains_tmp_buf1 + j;
ains_buffer2[1] = ains_tmp_buf2 + j;

aouts_buffer2[0] = aouts_tmp_buf1 + j;
aouts_buffer2[1] = aouts_tmp_buf2 + j;

plugin->process(ains_buffer2, aouts_buffer2, 8, j);
}
}
else
plugin->process(ains_tmp, aouts_tmp, nframes);

plugin->engineProcessUnlock();

// if plugin has no audio inputs, add previous buffers
if (plugin->audioInCount() == 0)
{
for (uint32_t j=0; j < nframes; j++)
{
aouts_tmp_buf1[j] += ains_tmp_buf1[j];
aouts_tmp_buf2[j] += ains_tmp_buf2[j];
}
}

processed = true;
}
}

// if no plugins in the rack, copy inputs over outputs
if (! processed)
{
memcpy(aouts_tmp_buf1, ains_tmp_buf1, sizeof(float)*nframes);
memcpy(aouts_tmp_buf2, ains_tmp_buf2, sizeof(float)*nframes);
memcpy(rackMidiEventsOut, rackMidiEventsIn, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);
}

// output audio
for (unsigned int i=0; i < nframes*2; i++)
{
if (i % 2)
@@ -214,9 +281,18 @@ void CarlaEngineRtAudio::handleProcessCallback(void* outputBuffer, void* inputBu
outsPtr[i] = aouts_tmp_buf1[i/2];
}

//memcpy(out1, aouts_tmp_buf1, sizeof(float)*nframes);
//memcpy(out2, aouts_tmp_buf2, sizeof(float)*nframes);
#endif
// output control
{
// TODO
}

// output midi
{
// TODO
}

Q_UNUSED(streamTime);
Q_UNUSED(status);
}

CARLA_BACKEND_END_NAMESPACE


+ 1
- 1
src/carla-backend/dssi.cpp View File

@@ -1001,7 +1001,7 @@ public:
memset(midiEvent, 0, sizeof(snd_seq_event_t));

midiEvent->type = extMidiNotes[i].velo ? SND_SEQ_EVENT_NOTEON : SND_SEQ_EVENT_NOTEOFF;
midiEvent->time.tick = framesOffset; // FIXME - other types may also need time-check here
midiEvent->time.tick = framesOffset;
midiEvent->data.note.channel = cin_channel;
midiEvent->data.note.note = extMidiNotes[i].note;
midiEvent->data.note.velocity = extMidiNotes[i].velo;


+ 5
- 1
src/carla-backend/lv2.cpp View File

@@ -1228,6 +1228,7 @@ public:
else if (LV2_IS_PORT_CONTROL(PortType))
{
const LV2_Property PortProps = rdf_descriptor->Ports[i].Properties;
const LV2_Property PortDesignation = rdf_descriptor->Ports[i].Designation;
const LV2_RDF_PortPoints PortPoints = rdf_descriptor->Ports[i].Points;

j = param.count++;
@@ -1339,7 +1340,7 @@ public:
}
else if (LV2_IS_PORT_OUTPUT(PortType))
{
if (LV2_IS_PORT_LATENCY(PortProps))
if (LV2_IS_PORT_LATENCY(PortDesignation))
{
min = 0.0;
max = sampleRate;
@@ -3761,6 +3762,9 @@ int CarlaOsc::handle_lv2_atom_transfer(CARLA_OSC_HANDLE_ARGS2)
lv2plugin->handleAtomTransfer();

return 0;
Q_UNUSED(argc);
Q_UNUSED(argv);
Q_UNUSED(types);
}

int CarlaOsc::handle_lv2_event_transfer(CARLA_OSC_HANDLE_ARGS2)


+ 16
- 13
src/carla-backend/qtcreator/carla-backend.pro View File

@@ -2,9 +2,12 @@

QT = core gui

CONFIG = debug link_pkgconfig qt warn_on plugin shared
PKGCONFIG = jack liblo fluidsynth linuxsampler alsa libpulse-simple
# suil-0
CONFIG = debug link_pkgconfig qt warn_on #plugin shared
PKGCONFIG = liblo
PKGCONFIG += jack
PKGCONFIG += alsa libpulse-simple
PKGCONFIG += fluidsynth linuxsampler
PKGCONFIG += suil-0

TARGET = carla_backend
TEMPLATE = app
@@ -12,10 +15,10 @@ VERSION = 0.5.0

SOURCES = \
../carla_backend_standalone.cpp \
../carla_bridge.cpp \
../carla_engine.cpp \
../carla_engine_jack.cpp \
../carla_engine_rtaudio.cpp \
../carla_bridge.cpp \
../carla_osc.cpp \
../carla_shared.cpp \
../carla_threads.cpp \
@@ -50,17 +53,17 @@ INCLUDEPATH = .. \
../../carla-includes \
../../carla-includes/vst

#DEFINES += HAVE_SUIL
DEFINES += WANT_FLUIDSYNTH
DEFINES += WANT_LINUXSAMPLER
DEFINES += DEBUG
DEFINES += CARLA_ENGINE_JACK
#DEFINES += CARLA_ENGINE_RTAUDIO
DEFINES += CARLA_ENGINE_RTAUDIO HAVE_GETTIMEOFDAY __LINUX_ALSA__ __LINUX_ALSASEQ__ __LINUX_PULSE__ __RTAUDIO_DEBUG__ __RTMIDI_DEBUG__
DEFINES += WANT_FLUIDSYNTH WANT_LINUXSAMPLER
DEFINES += HAVE_SUIL
DEFINES += QTCREATOR_TEST
LIBS = ../../carla-lilv/carla_lilv.a -ldl

QMAKE_CXXFLAGS *= -fPIC -std=c++0x
INCLUDEPATH += ../rtaudio-4.0.11
INCLUDEPATH += ../rtmidi-2.0.0
SOURCES += ../rtaudio-4.0.11/RtAudio.cpp
SOURCES += ../rtmidi-2.0.0/RtMidi.cpp

#INCLUDEPATH += ../rtaudio/rtaudio-4.0.11
#SOURCES += ../rtaudio/rtaudio-4.0.11/RtAudio.cpp
#DEFINES += _FORTIFY_SOURCE=2
#DEFINES += HAVE_GETTIMEOFDAY __UNIX_JACK__ __LINUX_ALSA__ __LINUX_PULSE__ __RTAUDIO_DUMMY__
QMAKE_CXXFLAGS *= -fPIC -std=c++0x

+ 2
- 2
src/carla-backend/vst.cpp View File

@@ -1193,7 +1193,7 @@ public:
static intptr_t VstHostCallback(AEffect* effect, int32_t opcode, int32_t index, intptr_t value, void* ptr, float opt)
{
#ifdef DEBUG
qDebug("VstHostCallback(%p, opcode: %s, index: %i, value: " P_INTPTR ", opt: %f", effect, VstOpcode2str(opcode), index, value, opt);
qDebug("VstHostCallback(%p, opcode: %s, index: %i, value: " P_INTPTR ", opt: %f", effect, VstMasterOpcode2str(opcode), index, value, opt);
#endif

// Check if 'resvd1' points to this plugin
@@ -1593,7 +1593,7 @@ public:

default:
#ifdef DEBUG
qDebug("VstHostCallback(%p, opcode: %s, index: %i, value: " P_INTPTR ", opt: %f", effect, VstOpcode2str(opcode), index, value, opt);
qDebug("VstHostCallback(%p, opcode: %s, index: %i, value: " P_INTPTR ", opt: %f", effect, VstMasterOpcode2str(opcode), index, value, opt);
#endif
break;
}


+ 9
- 3
src/carla-includes/carla_lv2_includes.h View File

@@ -77,7 +77,7 @@ public:
symbol (new_uri(LV2_CORE__symbol)),
designation (new_uri(LV2_CORE__designation)),
freewheeling (new_uri(LV2_CORE__freeWheeling)),
latency (new_uri(LV2_CORE__latency)),
reportsLatency (new_uri(LV2_CORE__reportsLatency)),

class_allpass (new_uri(LV2_CORE__AllpassPlugin)),
class_amplifier (new_uri(LV2_CORE__AmplifierPlugin)),
@@ -209,7 +209,7 @@ public:
Lilv::Node symbol;
Lilv::Node designation;
Lilv::Node freewheeling;
Lilv::Node latency;
Lilv::Node reportsLatency;

// Plugin Types
Lilv::Node class_allpass;
@@ -595,8 +595,11 @@ const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI URI)
if (Port.has_property(Lv2World.pprop_trigger))
RDF_Port->Properties = LV2_PORT_TRIGGER;

if (Port.has_property(Lv2World.latency))
if (Port.has_property(Lv2World.reportsLatency))
{
qWarning("Port Prop Latency!");
RDF_Port->Designation = LV2_PORT_LATENCY;
}
}

// --------------------------------------
@@ -604,9 +607,12 @@ const LV2_RDF_Descriptor* lv2_rdf_new(const LV2_URI URI)
{
Lilv::Nodes DesignationNodes(Port.get_value(Lv2World.designation));

qWarning("Design = %i", DesignationNodes.size());

if (DesignationNodes.size() > 0)
{
const char* const designation = Lilv::Node(lilv_nodes_get(DesignationNodes, DesignationNodes.begin())).as_string();
qWarning("Design -> %s", designation);

if (strcmp(designation, LV2_TIME__bar) == 0)
RDF_Port->Designation = LV2_PORT_TIME_BAR;


+ 9
- 7
src/carla.py View File

@@ -2798,7 +2798,7 @@ class CarlaMainW(QMainWindow, ui_carla.Ui_CarlaMainW):
# -------------------------------------------------------------
# Internal stuff

self.m_bridge_info = None
self.m_engine_started = False
self.m_project_filename = None

self.m_plugin_list = []
@@ -3430,7 +3430,7 @@ class CarlaMainW(QMainWindow, ui_carla.Ui_CarlaMainW):
if event.timerId() == self.TIMER_GUI_STUFF:
for pwidget in self.m_plugin_list:
if pwidget: pwidget.check_gui_stuff()
if CarlaHost.is_engine_running():
if self.m_engine_started:
CarlaHost.idle_guis()
elif event.timerId() == self.TIMER_GUI_STUFF2:
for pwidget in self.m_plugin_list:
@@ -3516,19 +3516,21 @@ if __name__ == '__main__':
CarlaHost.set_option(OPTION_PATH_BRIDGE_VST_X11, 0, carla_bridge_vst_x11)

# TEST
#count = CarlaHost.get_engine_driver_count()
#print(count)
#for i in range(0, count):
#dname = cString(CarlaHost.get_engine_driver_name(i))
#print("%i - %s" % (i, dname))
count = CarlaHost.get_engine_driver_count()
print(count)
for i in range(0, count):
dname = cString(CarlaHost.get_engine_driver_name(i))
print("%i - %s" % (i, dname))

if not CarlaHost.engine_init("JACK", "Carla"):
#if not CarlaHost.engine_init("PulseAudio", "Carla"):
CustomMessageBox(None, QMessageBox.Critical, "Error", "Could not connect to Audio backend, possible reasons:",
cString(CarlaHost.get_last_error()), QMessageBox.Ok, QMessageBox.Ok)
sys.exit(1)

# Set callback after engine started
CarlaHost.set_callback_function(gui.callback_function)
gui.m_engine_started = True

# Set-up custom signal handling
set_up_signals(gui)


Write Preview
Loading…
Cancel
Save