Phase 32: add MIDI track CLAP, VST2 and VST3 instruments
This commit is contained in:
parent
9e0e4562d7
commit
fe484537f9
41 changed files with 1138 additions and 65 deletions
100
tests/plugins/clap_synth_fixture.c
Normal file
100
tests/plugins/clap_synth_fixture.c
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
#include <clap/clap.h>
|
||||
#include <clap/ext/thread-check.h>
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
static int loaded, count;
|
||||
static const char *features[] = {CLAP_PLUGIN_FEATURE_INSTRUMENT,NULL};
|
||||
static const clap_plugin_descriptor_t descriptors[] = {
|
||||
{CLAP_VERSION,"xtc.fixture.gain","CLAP gain","xtc","","","","1","",features},
|
||||
{CLAP_VERSION,"xtc.fixture.stereo","Stereo","xtc","","","","1","",features},
|
||||
{CLAP_VERSION,"xtc.fixture.init","Init failure","xtc","","","","1","",features},
|
||||
{CLAP_VERSION,"xtc.fixture.activate","Activate failure","xtc","","","","1","",features},
|
||||
{CLAP_VERSION,"xtc.fixture.start","Start failure","xtc","","","","1","",features},
|
||||
{CLAP_VERSION,"xtc.fixture.process","Process failure","xtc","","","","1","",features},
|
||||
{CLAP_VERSION,"xtc.fixture.restart","Restart request","xtc","","","","1","",features}
|
||||
};
|
||||
typedef struct { clap_plugin_t plugin; const clap_host_t *host; unsigned int index; int active, started; float level; } instance;
|
||||
static bool init(const clap_plugin_t *plugin)
|
||||
{ instance *p = plugin->plugin_data; assert(loaded); return p->index != 2; }
|
||||
static void destroy(const clap_plugin_t *plugin)
|
||||
{ instance *p = plugin->plugin_data; assert(!p->active && !p->started); --count; free(p); }
|
||||
static bool activate(const clap_plugin_t *plugin, double rate, uint32_t min, uint32_t max)
|
||||
{ instance *p = plugin->plugin_data; assert(rate > 0 && min && max >= min && !p->active); if (p->index == 3) return false; p->active = 1; return true; }
|
||||
static void deactivate(const clap_plugin_t *plugin)
|
||||
{ instance *p = plugin->plugin_data; assert(p->active && !p->started); p->active = 0; }
|
||||
static bool start(const clap_plugin_t *plugin)
|
||||
{
|
||||
instance *p = plugin->plugin_data;
|
||||
const clap_host_thread_check_t *check = p->host->get_extension(p->host,CLAP_EXT_THREAD_CHECK);
|
||||
assert(p->active && !p->started && check->is_audio_thread(p->host));
|
||||
if (p->index == 4) return false;
|
||||
p->started = 1; return true;
|
||||
}
|
||||
static void stop(const clap_plugin_t *plugin)
|
||||
{ instance *p = plugin->plugin_data; assert(p->started); p->started = 0; }
|
||||
static void reset(const clap_plugin_t *plugin) { (void)plugin; }
|
||||
static clap_process_status process(const clap_plugin_t *plugin, const clap_process_t *block)
|
||||
{
|
||||
instance *p = plugin->plugin_data; uint32_t i;
|
||||
uint32_t j = 0, event_total = block->in_events->size(block->in_events);
|
||||
assert(p->started && block->audio_inputs_count == 0 && block->audio_outputs_count == 1);
|
||||
if (p->index == 5) return CLAP_PROCESS_ERROR;
|
||||
for (i = 0; i < block->frames_count; ++i) {
|
||||
while (j < event_total) {
|
||||
const clap_event_header_t *h = block->in_events->get(block->in_events,j);
|
||||
const clap_event_midi_t *m = (const clap_event_midi_t *)h;
|
||||
if (h->time != i) break;
|
||||
++j;
|
||||
if (h->type != CLAP_EVENT_MIDI) {
|
||||
const clap_event_note_t *note = (const clap_event_note_t *)h;
|
||||
assert(h->type == CLAP_EVENT_NOTE_ON || h->type == CLAP_EVENT_NOTE_OFF || h->type == CLAP_EVENT_NOTE_CHOKE);
|
||||
p->level = h->type == CLAP_EVENT_NOTE_ON ? (float)note->velocity : 0;
|
||||
continue;
|
||||
}
|
||||
if ((m->data[0]&240) == 144) p->level = (float)m->data[2]/127;
|
||||
else if ((m->data[0]&240) == 128 || ((m->data[0]&240) == 176 && m->data[1] == 120)) p->level = 0;
|
||||
}
|
||||
block->audio_outputs[0].data32[0][i] = p->level;
|
||||
}
|
||||
p->host->request_callback(p->host);
|
||||
if (p->index == 6) p->host->request_restart(p->host);
|
||||
return CLAP_PROCESS_CONTINUE;
|
||||
}
|
||||
static uint32_t port_count(const clap_plugin_t *plugin, bool input) { (void)plugin; return input ? 0 : 1; }
|
||||
static bool port_get(const clap_plugin_t *plugin, uint32_t index, bool input, clap_audio_port_info_t *info)
|
||||
{ instance *p = plugin->plugin_data; (void)input; if (index) return false; memset(info,0,sizeof(*info)); info->channel_count = p->index == 1 ? 2 : 1; return true; }
|
||||
static uint32_t latency(const clap_plugin_t *plugin)
|
||||
{ instance *p = plugin->plugin_data; assert(p->active); return 0; }
|
||||
static uint32_t note_count(const clap_plugin_t *p, bool input) { (void)p; return input ? 1 : 0; }
|
||||
static bool note_get(const clap_plugin_t *p, uint32_t index, bool input, clap_note_port_info_t *info)
|
||||
{ (void)p; if (index || !input) return false; memset(info,0,sizeof(*info)); info->supported_dialects = info->preferred_dialect = getenv("XTC_TEST_NATIVE_NOTES") ? CLAP_NOTE_DIALECT_CLAP : CLAP_NOTE_DIALECT_MIDI; return true; }
|
||||
static const void *extension(const clap_plugin_t *plugin, const char *id)
|
||||
{
|
||||
static const clap_plugin_audio_ports_t ports = {port_count,port_get};
|
||||
static const clap_plugin_latency_t delay = {latency}; (void)plugin;
|
||||
static const clap_plugin_note_ports_t notes = {note_count,note_get};
|
||||
if (!strcmp(id,CLAP_EXT_NOTE_PORTS)) return ¬es;
|
||||
if (!strcmp(id,CLAP_EXT_AUDIO_PORTS)) return &ports;
|
||||
return !strcmp(id,CLAP_EXT_LATENCY) ? &delay : NULL;
|
||||
}
|
||||
static void on_main(const clap_plugin_t *plugin)
|
||||
{ instance *p = plugin->plugin_data; const clap_host_thread_check_t *check = p->host->get_extension(p->host,CLAP_EXT_THREAD_CHECK); assert(check->is_main_thread(p->host)); }
|
||||
static uint32_t plugin_count(const clap_plugin_factory_t *factory) { (void)factory; return 7; }
|
||||
static const clap_plugin_descriptor_t *descriptor(const clap_plugin_factory_t *factory, uint32_t index)
|
||||
{ (void)factory; return index < 7 ? descriptors+index : NULL; }
|
||||
static const clap_plugin_t *create(const clap_plugin_factory_t *factory, const clap_host_t *host, const char *id)
|
||||
{
|
||||
unsigned int i; instance *p; (void)factory;
|
||||
for (i = 0; i < 7 && strcmp(id,descriptors[i].id); ++i) {}
|
||||
if (i == 7) return NULL;
|
||||
p = calloc(1,sizeof(*p)); if (!p) return NULL;
|
||||
p->host = host; p->index = i;
|
||||
p->plugin = (clap_plugin_t){descriptors+i,p,init,destroy,activate,deactivate,start,stop,reset,process,extension,on_main};
|
||||
++count; return &p->plugin;
|
||||
}
|
||||
static bool entry_init(const char *path) { (void)path; assert(!loaded); loaded = 1; return true; }
|
||||
static void entry_exit(void) { assert(loaded && !count); loaded = 0; }
|
||||
static const void *factory(const char *id)
|
||||
{ static const clap_plugin_factory_t f = {plugin_count,descriptor,create}; return !strcmp(id,CLAP_PLUGIN_FACTORY_ID) ? &f : NULL; }
|
||||
CLAP_EXPORT const clap_plugin_entry_t clap_entry = {CLAP_VERSION,entry_init,entry_exit,factory};
|
||||
45
tests/plugins/vst2_synth_fixture.c
Normal file
45
tests/plugins/vst2_synth_fixture.c
Normal file
|
|
@ -0,0 +1,45 @@
|
|||
/* Original MIT ABI fixture; not built from or linked to a proprietary SDK. */
|
||||
#include "../../src/plugin/vst2_abi.h"
|
||||
#include <assert.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
typedef struct { xtc_v2_effect effect; int open, active, started; float level; xtc_v2_midi events[256]; int count; } instance;
|
||||
static intptr_t dispatch(xtc_v2_effect *e, int32_t op, int32_t index, intptr_t value, void *ptr, float option)
|
||||
{
|
||||
instance *p = (instance *)e; (void)index; (void)option;
|
||||
switch (op) {
|
||||
case 0: assert(!p->open); p->open = 1; break;
|
||||
case 1: assert(p->open && !p->active && !p->started); free(p); break;
|
||||
case 12: p->active = value != 0; break;
|
||||
case 25: { xtc_v2_events *events = ptr; int i; assert(events->count <= 256); p->count = events->count; for (i = 0; i < p->count; ++i) p->events[i] = *events->events[i]; break; }
|
||||
case 45: strcpy(ptr,"VST2 gain"); return 1;
|
||||
case 71: assert(p->active); p->started = 1; break;
|
||||
case 72: p->started = 0; break;
|
||||
default: break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
static void process(xtc_v2_effect *e, float **input, float **output, int32_t frames)
|
||||
{ instance *p = (instance *)e; int32_t i, j = 0; assert(p->started && !input);
|
||||
for (i = 0; i < frames; ++i) {
|
||||
while (j < p->count && p->events[j].offset == i) {
|
||||
unsigned char *m = p->events[j++].data;
|
||||
if ((m[0]&240) == 144) p->level = (float)m[2]/127;
|
||||
else if ((m[0]&240) == 128 || ((m[0]&240) == 176 && m[1] == 120)) p->level = 0;
|
||||
}
|
||||
output[0][i] = p->level;
|
||||
} p->count = 0;
|
||||
}
|
||||
|
||||
xtc_v2_effect *VSTPluginMain(xtc_v2_host host);
|
||||
xtc_v2_effect *VSTPluginMain(xtc_v2_host host)
|
||||
{
|
||||
instance *p; assert(host(NULL,1,0,0,NULL,0) == 2400);
|
||||
p = calloc(1,sizeof(*p)); if (!p) return NULL;
|
||||
p->effect.magic = XTC_V2_MAGIC; p->effect.dispatch = dispatch;
|
||||
p->effect.inputs = 0; p->effect.outputs = 1;
|
||||
if (getenv("XTC_VST2_FIXTURE_LAYOUT")) p->effect.inputs = 2;
|
||||
p->effect.flags = 16|256;
|
||||
p->effect.unique_id = 0x58544332; p->effect.replace = process;
|
||||
return &p->effect;
|
||||
}
|
||||
88
tests/plugins/vst3_synth_fixture.c
Normal file
88
tests/plugins/vst3_synth_fixture.c
Normal file
|
|
@ -0,0 +1,88 @@
|
|||
#include <stdbool.h>
|
||||
#include <vst3_c_api.h>
|
||||
#include <assert.h>
|
||||
#include <stddef.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
static int loaded, instances;
|
||||
static const Steinberg_TUID cid = SMTG_INLINE_UID(0x58544333,0x12345678,0x12345678,0x12345678);
|
||||
typedef struct { Steinberg_Vst_IComponent component; Steinberg_Vst_IAudioProcessor processor; unsigned int refs; int initialized, active, started; float level; } instance;
|
||||
static instance *from_processor(void *p) { return (instance *)((char *)p - offsetof(instance,processor)); }
|
||||
static Steinberg_tresult cq(void *self, const Steinberg_TUID iid, void **out)
|
||||
{
|
||||
instance *p = self; *out = NULL;
|
||||
if (!memcmp(iid,Steinberg_Vst_IAudioProcessor_iid,16)) *out = &p->processor;
|
||||
else if (!memcmp(iid,Steinberg_Vst_IComponent_iid,16) || !memcmp(iid,Steinberg_FUnknown_iid,16)) *out = &p->component;
|
||||
if (!*out) return -1;
|
||||
++p->refs; return 0;
|
||||
}
|
||||
static Steinberg_uint32 add(void *self) { return ++((instance *)self)->refs; }
|
||||
static Steinberg_uint32 release(void *self)
|
||||
{ instance *p = self; unsigned int refs = --p->refs; if (!refs) { assert(!p->initialized); --instances; free(p); } return refs; }
|
||||
static Steinberg_tresult pq(void *self, const Steinberg_TUID iid, void **out) { return cq(from_processor(self),iid,out); }
|
||||
static Steinberg_uint32 pa(void *self) { return add(from_processor(self)); }
|
||||
static Steinberg_uint32 pr(void *self) { return release(from_processor(self)); }
|
||||
static Steinberg_tresult init(void *self, Steinberg_FUnknown *host)
|
||||
{ instance *p = self; assert(loaded && host && !p->initialized); if (getenv("XTC_VST3_FIXTURE_INIT")) return -1; p->initialized = 1; return 0; }
|
||||
static Steinberg_tresult terminate(void *self) { instance *p = self; assert(p->initialized && !p->active); p->initialized = 0; return 0; }
|
||||
static Steinberg_tresult controller(void *self, Steinberg_TUID id) { (void)self; (void)id; return -1; }
|
||||
static Steinberg_tresult mode(void *self, Steinberg_Vst_IoMode m) { (void)self; (void)m; return 0; }
|
||||
static Steinberg_int32 buses(void *self, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir) { (void)self; (void)dir; return type == 0 ? (dir == 1 ? 1 : 0) : (dir == 0 ? 1 : 0); }
|
||||
static Steinberg_tresult bus_info(void *self, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, struct Steinberg_Vst_BusInfo *info)
|
||||
{ (void)self; (void)dir; assert(type == 0 && index == 0); memset(info,0,sizeof(*info)); info->channelCount = 1; return 0; }
|
||||
static Steinberg_tresult routing(void *self, struct Steinberg_Vst_RoutingInfo *in, struct Steinberg_Vst_RoutingInfo *out)
|
||||
{ (void)self; (void)in; (void)out; return -1; }
|
||||
static Steinberg_tresult activate_bus(void *self, Steinberg_Vst_MediaType type, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, Steinberg_TBool state)
|
||||
{ (void)self; (void)type; (void)dir; (void)index; (void)state; return 0; }
|
||||
static Steinberg_tresult active(void *self, Steinberg_TBool state) { instance *p = self; assert(!p->started); p->active = state; return 0; }
|
||||
static Steinberg_tresult state(void *self, Steinberg_IBStream *stream) { (void)self; (void)stream; return -1; }
|
||||
static Steinberg_tresult arrangements(void *self, Steinberg_Vst_SpeakerArrangement *in, Steinberg_int32 ni, Steinberg_Vst_SpeakerArrangement *out, Steinberg_int32 no)
|
||||
{ (void)self; return ni == 0 && !in && no == 1 && out[0] == Steinberg_Vst_SpeakerArr_kMono ? 0 : -1; }
|
||||
static Steinberg_tresult arrangement(void *self, Steinberg_Vst_BusDirection dir, Steinberg_int32 index, Steinberg_Vst_SpeakerArrangement *out)
|
||||
{ (void)self; (void)dir; (void)index; *out = Steinberg_Vst_SpeakerArr_kMono; return 0; }
|
||||
static Steinberg_tresult sample_size(void *self, Steinberg_int32 size) { (void)self; return size == 0 ? 0 : -1; }
|
||||
static Steinberg_uint32 latency(void *self) { (void)self; return 0; }
|
||||
static Steinberg_tresult setup(void *self, struct Steinberg_Vst_ProcessSetup *data) { (void)self; return data->maxSamplesPerBlock > 0 && data->sampleRate > 0 ? 0 : -1; }
|
||||
static Steinberg_tresult processing(void *self, Steinberg_TBool value) { instance *p = from_processor(self); assert(p->active); p->started = value; return 0; }
|
||||
static Steinberg_tresult process(void *self, struct Steinberg_Vst_ProcessData *data)
|
||||
{ instance *p = from_processor(self); int32_t i, j = 0;
|
||||
Steinberg_Vst_IEventList *events = data->inputEvents;
|
||||
int32_t count = events->lpVtbl->getEventCount(events);
|
||||
assert(p->started && data->numInputs == 0);
|
||||
for (i = 0; i < data->numSamples; ++i) {
|
||||
while (j < count) {
|
||||
struct Steinberg_Vst_Event event;
|
||||
assert(events->lpVtbl->getEvent(events,j,&event) == 0);
|
||||
if (event.sampleOffset != i) break;
|
||||
++j;
|
||||
if (event.type == 0) p->level = event.Steinberg_Vst_Event_noteOn.velocity;
|
||||
else if (event.type == 1) p->level = 0;
|
||||
}
|
||||
data->outputs[0].Steinberg_Vst_AudioBusBuffers_channelBuffers32[0][i] = p->level;
|
||||
} return 0;
|
||||
}
|
||||
|
||||
static Steinberg_Vst_IComponentVtbl component_vtable = {cq,add,release,init,terminate,controller,mode,buses,bus_info,routing,activate_bus,active,state,state};
|
||||
static Steinberg_Vst_IAudioProcessorVtbl processor_vtable = {pq,pa,pr,arrangements,arrangement,sample_size,latency,setup,processing,process,latency};
|
||||
static Steinberg_tresult fq(void *self, const Steinberg_TUID iid, void **out) { (void)iid; *out = self; return 0; }
|
||||
static Steinberg_uint32 fr(void *self) { (void)self; return 1; }
|
||||
static Steinberg_tresult factory_info(void *self, struct Steinberg_PFactoryInfo *info) { (void)self; memset(info,0,sizeof(*info)); return 0; }
|
||||
static Steinberg_int32 classes(void *self) { (void)self; return 1; }
|
||||
static Steinberg_tresult class_info(void *self, Steinberg_int32 index, struct Steinberg_PClassInfo *info)
|
||||
{ (void)self; if (index) return -1; memset(info,0,sizeof(*info)); memcpy(info->cid,cid,16); strcpy(info->category,"Audio Module Class"); strcpy(info->name,"VST3 gain"); return 0; }
|
||||
static Steinberg_tresult create(void *self, Steinberg_FIDString id, Steinberg_FIDString iid, void **out)
|
||||
{
|
||||
instance *p; (void)self; *out = NULL;
|
||||
if (memcmp(id,cid,16) || memcmp(iid,Steinberg_Vst_IComponent_iid,16)) return -1;
|
||||
p = calloc(1,sizeof(*p)); if (!p) return -1;
|
||||
p->component.lpVtbl = &component_vtable; p->processor.lpVtbl = &processor_vtable; p->refs = 1;
|
||||
++instances; *out = p; return 0;
|
||||
}
|
||||
static Steinberg_IPluginFactoryVtbl factory_vtable = {fq,fr,fr,factory_info,classes,class_info,create};
|
||||
static Steinberg_IPluginFactory factory = {&factory_vtable};
|
||||
bool ModuleEntry(void *handle);
|
||||
bool ModuleExit(void);
|
||||
Steinberg_IPluginFactory *GetPluginFactory(void);
|
||||
bool ModuleEntry(void *handle) { assert(handle && !loaded); loaded = 1; return true; }
|
||||
bool ModuleExit(void) { assert(loaded && !instances); loaded = 0; return true; }
|
||||
Steinberg_IPluginFactory *GetPluginFactory(void) { assert(loaded); return &factory; }
|
||||
Loading…
Add table
Add a link
Reference in a new issue