/* * Copyright (c) 2015 Hanspeter Portner (dev@open-music-kontrollers.ch) * * This is free software: you can redistribute it and/or modify * it under the terms of the Artistic License 2.0 as published by * The Perl Foundation. * * This source is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * Artistic License 2.0 for more details. * * You should have received a copy of the Artistic License 2.0 * along the source as a COPYING file. If not, obtain it from * http://www.perlfoundation.org/artistic_license_2_0. */ #include #include #include #include #include #define MAX_NPROPS 0 typedef struct _plugstate_t plugstate_t; typedef struct _plughandle_t plughandle_t; struct _plugstate_t { // nohting }; struct _plughandle_t { LV2_URID_Map *map; LV2_Atom_Forge forge; LV2_Atom_Forge_Ref ref; PROPS_T(props, MAX_NPROPS); const LV2_Atom_Sequence *control; LV2_Atom_Sequence *notify; plugstate_t state; plugstate_t stash; }; static const props_def_t defs [MAX_NPROPS] = { // nothing }; static LV2_Handle instantiate(const LV2_Descriptor* descriptor, double rate, const char *bundle_path, const LV2_Feature *const *features) { plughandle_t *handle = calloc(1, sizeof(plughandle_t)); if(!handle) return NULL; for(unsigned i=0; features[i]; i++) { if(!strcmp(features[i]->URI, LV2_URID__map)) handle->map = features[i]->data; } if(!handle->map) { fprintf(stderr, "%s: Host does not support urid:map\n", descriptor->URI); free(handle); return NULL; } lv2_atom_forge_init(&handle->forge, handle->map); if(!props_init(&handle->props, descriptor->URI, defs, MAX_NPROPS, &handle->state, &handle->stash, handle->map, handle)) { fprintf(stderr, "failed to allocate property structure\n"); free(handle); return NULL; } return handle; } static void connect_port(LV2_Handle instance, uint32_t port, void *data) { plughandle_t *handle = instance; if(port == 0) handle->control = (const LV2_Atom_Sequence *)data; else if(port == 1) handle->notify = (LV2_Atom_Sequence *)data; } __realtime static void run(LV2_Handle instance, uint32_t nsamples) { plughandle_t *handle = instance; const uint32_t capacity = handle->notify->atom.size; LV2_Atom_Forge *forge = &handle->forge; lv2_atom_forge_set_buffer(forge, (uint8_t *)handle->notify, capacity); LV2_Atom_Forge_Frame frame; handle->ref = lv2_atom_forge_sequence_head(forge, &frame, 0); props_idle(&handle->props, &handle->forge, 0, &handle->ref); LV2_ATOM_SEQUENCE_FOREACH(handle->control, ev) { const LV2_Atom_Object *obj = (const LV2_Atom_Object *)&ev->body; const LV2_Atom *atom = (const LV2_Atom *)&ev->body; const int64_t frames = ev->time.frames; props_advance(&handle->props, forge, frames, obj, &handle->ref); } if(handle->ref) lv2_atom_forge_pop(forge, &frame); else lv2_atom_sequence_clear(handle->notify); } static void cleanup(LV2_Handle instance) { plughandle_t *handle = instance; if(handle) free(handle); } static LV2_State_Status _state_save(LV2_Handle instance, LV2_State_Store_Function store, LV2_State_Handle state, uint32_t flags, const LV2_Feature *const *features) { plughandle_t *handle = instance; return props_save(&handle->props, store, state, flags, features); } static LV2_State_Status _state_restore(LV2_Handle instance, LV2_State_Retrieve_Function retrieve, LV2_State_Handle state, uint32_t flags, const LV2_Feature *const *features) { plughandle_t *handle = instance; return props_restore(&handle->props, retrieve, state, flags, features); } static const LV2_State_Interface state_iface = { .save = _state_save, .restore = _state_restore }; static const void * extension_data(const char *uri) { if(!strcmp(uri, LV2_STATE__interface)) return &state_iface; return NULL; } const LV2_Descriptor synthpod_placeholder = { .URI = SYNTHPOD_PLACEHOLDER_URI, .instantiate = instantiate, .connect_port = connect_port, .activate = NULL, .run = run, .deactivate = NULL, .cleanup = cleanup, .extension_data = extension_data };