Sampled Instrument Player with static and monolithic design. All instruments are built-in.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

373 lines
12 KiB

/*
Calf Box, an open source musical instrument.
Copyright (C) 2012 Krzysztof Foltman
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "cmd.h"
#include "errors.h"
#include "dom.h"
#include <assert.h>
#include <glib.h>
#include <malloc.h>
#include <string.h>
static GHashTable *class_name_hash = NULL;
struct cbox_class_per_document
{
GList *instances;
};
struct cbox_document
{
GHashTable *classes_per_document;
GHashTable *services_per_document;
GHashTable *uuids_per_document;
struct cbox_command_target cmd_target;
int item_ctr;
uint64_t generation_ctr;
};
////////////////////////////////////////////////////////////////////////////////////////
void cbox_dom_init()
{
class_name_hash = g_hash_table_new(g_str_hash, g_str_equal);
}
void cbox_dom_close()
{
g_hash_table_destroy(class_name_hash);
}
////////////////////////////////////////////////////////////////////////////////////////
struct cbox_class *cbox_class_find_by_name(const char *name)
{
assert(class_name_hash != NULL);
return g_hash_table_lookup(class_name_hash, name);
}
void cbox_class_register(struct cbox_class *class_ptr)
{
assert(class_name_hash != NULL);
g_hash_table_insert(class_name_hash, (gpointer)class_ptr->name, class_ptr);
}
static struct cbox_class_per_document *get_cpd_for_class(struct cbox_document *doc, struct cbox_class *class_ptr)
{
struct cbox_class_per_document *p = g_hash_table_lookup(doc->classes_per_document, class_ptr);
if (p != NULL)
return p;
p = malloc(sizeof(struct cbox_class_per_document));
p->instances = NULL;
g_hash_table_insert(doc->classes_per_document, class_ptr, p);
return p;
}
////////////////////////////////////////////////////////////////////////////////////////
void cbox_uuid_clear(struct cbox_uuid *uuid)
{
uuid_clear(uuid->uuid);
}
guint cbox_uuid_hash(gconstpointer v)
{
char buf[40];
uuid_unparse_lower(((struct cbox_uuid *)v)->uuid, buf);
return g_str_hash(buf);
}
gboolean cbox_uuid_equal(gconstpointer v1, gconstpointer v2)
{
const struct cbox_uuid *p1 = v1;
const struct cbox_uuid *p2 = v2;
return !uuid_compare(p1->uuid, p2->uuid);
}
void cbox_uuid_copy(struct cbox_uuid *vto, const struct cbox_uuid *vfrom)
{
uuid_copy(vto->uuid, vfrom->uuid);
}
gboolean cbox_uuid_report_as(struct cbox_uuid *uuid, const char *cmd, struct cbox_command_target *fb, GError **error)
{
if (!fb)
return TRUE;
return cbox_execute_on(fb, NULL, cmd, "u", error, uuid->uuid);
}
gboolean cbox_uuid_report(struct cbox_uuid *uuid, struct cbox_command_target *fb, GError **error)
{
return cbox_uuid_report_as(uuid, "/uuid", fb, error);
}
gboolean cbox_uuid_fromstring(struct cbox_uuid *uuid, const char *str, GError **error)
{
if (uuid_parse(str, uuid->uuid))
{
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Malformed UUID: '%s'", str);
return FALSE;
}
return TRUE;
}
void cbox_uuid_tostring(struct cbox_uuid *uuid, char str[40])
{
uuid_unparse(uuid->uuid, str);
}
void cbox_uuid_generate(struct cbox_uuid *uuid)
{
uuid_generate(uuid->uuid);
}
////////////////////////////////////////////////////////////////////////////////////////
void cbox_object_register_instance(struct cbox_document *doc, struct cbox_objhdr *obj)
{
assert(obj != NULL);
struct cbox_class_per_document *cpd = get_cpd_for_class(doc, obj->class_ptr);
cpd->instances = g_list_prepend(cpd->instances, obj);
obj->owner = doc;
obj->link_in_document = cpd->instances;
g_hash_table_insert(obj->owner->uuids_per_document, &obj->instance_uuid, obj);
}
struct cbox_command_target *cbox_object_get_cmd_target(struct cbox_objhdr *hdr_ptr)
{
if (!hdr_ptr->class_ptr->getcmdtargetfunc)
return NULL;
return hdr_ptr->class_ptr->getcmdtargetfunc(hdr_ptr);
}
gboolean cbox_object_try_default_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, const char *subcmd, gboolean *result, GError **error)
{
// XXXKF this assumes objhdr ptr == object ptr - needs to add the header offset in cmd target?
struct cbox_objhdr *obj = ct->user_data;
if (!strcmp(subcmd, "/status") && !strcmp(cmd->arg_types, ""))
{
if (!cbox_object_default_status(obj, fb, error))
{
*result = FALSE;
return TRUE;
}
return FALSE;
}
if (!strcmp(subcmd, "/delete") && !strcmp(cmd->arg_types, ""))
{
cbox_object_destroy(obj);
*result = TRUE;
return TRUE;
}
if (!strcmp(subcmd, "/get_uuid") && !strcmp(cmd->arg_types, ""))
{
if (!cbox_check_fb_channel(fb, cmd->command, error))
{
*result = FALSE;
return TRUE;
}
*result = cbox_uuid_report(&obj->instance_uuid, fb, error);
return TRUE;
}
if (!strcmp(subcmd, "/get_class_name") && !strcmp(cmd->arg_types, ""))
{
if (!cbox_check_fb_channel(fb, cmd->command, error))
{
*result = FALSE;
return TRUE;
}
*result = cbox_execute_on(fb, NULL, "/class_name", "s", error, obj->class_ptr->name);
return TRUE;
}
return FALSE;
}
gboolean cbox_object_default_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
{
gboolean result = FALSE;
if (cbox_object_try_default_process_cmd(ct, fb, cmd, cmd->command, &result, error))
return result;
struct cbox_objhdr *obj = ct->user_data;
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unknown combination of target path and argument: '%s', '%s' for object class '%s'", cmd->command, cmd->arg_types, obj->class_ptr->name);
return FALSE;
}
gboolean cbox_object_default_status(struct cbox_objhdr *objhdr, struct cbox_command_target *fb, GError **error)
{
char buf[40];
uuid_unparse(objhdr->instance_uuid.uuid, buf);
return cbox_execute_on(fb, NULL, "/uuid", "s", error, buf);
}
void cbox_object_destroy(struct cbox_objhdr *hdr_ptr)
{
struct cbox_class_per_document *cpd = get_cpd_for_class(hdr_ptr->owner, hdr_ptr->class_ptr);
cpd->instances = g_list_delete_link(cpd->instances, hdr_ptr->link_in_document);
hdr_ptr->link_in_document = NULL;
g_hash_table_remove(hdr_ptr->owner->uuids_per_document, &hdr_ptr->instance_uuid);
hdr_ptr->class_ptr->destroyfunc(hdr_ptr);
}
////////////////////////////////////////////////////////////////////////////////////////
static gboolean document_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
{
char *uuid;
const char *subcommand;
if (!strcmp(cmd->command, "/dump") && !strcmp(cmd->arg_types, ""))
{
struct cbox_document *doc = ct->user_data;
cbox_document_dump(doc);
return TRUE;
}
if (cbox_parse_path_part_str(cmd, "/uuid/", &subcommand, &uuid, error))
{
struct cbox_document *doc = ct->user_data;
if (!subcommand)
return FALSE;
struct cbox_objhdr *obj = cbox_document_get_object_by_text_uuid(doc, uuid, NULL, error);
g_free(uuid);
if (!obj)
return FALSE;
struct cbox_command_target *ct2 = cbox_object_get_cmd_target(obj);
return cbox_execute_sub(ct2, fb, cmd, subcommand, error);
}
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unknown combination of target path and argument: '%s', '%s'", cmd->command, cmd->arg_types);
return FALSE;
}
struct cbox_document *cbox_document_new()
{
struct cbox_document *res = malloc(sizeof(struct cbox_document));
res->classes_per_document = g_hash_table_new_full(NULL, NULL, NULL, g_free);
res->services_per_document = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
res->uuids_per_document = g_hash_table_new(cbox_uuid_hash, cbox_uuid_equal);
res->cmd_target.process_cmd = document_process_cmd;
res->cmd_target.user_data = res;
res->item_ctr = 0;
res->generation_ctr = 1000; // start with non-zero value just to spot invalid values more easily
return res;
}
struct cbox_command_target *cbox_document_get_cmd_target(struct cbox_document *doc)
{
return &doc->cmd_target;
}
struct cbox_objhdr *cbox_document_get_service(struct cbox_document *document, const char *name)
{
return g_hash_table_lookup(document->services_per_document, name);
}
void cbox_document_set_service(struct cbox_document *document, const char *name, struct cbox_objhdr *obj)
{
g_hash_table_insert(document->services_per_document, g_strdup(name), obj);
}
struct cbox_objhdr *cbox_document_get_object_by_uuid(struct cbox_document *doc, const struct cbox_uuid *uuid)
{
return g_hash_table_lookup(doc->uuids_per_document, uuid);
}
struct cbox_objhdr *cbox_document_get_object_by_text_uuid(struct cbox_document *doc, const char *uuid, const struct cbox_class *class_ptr, GError **error)
{
struct cbox_uuid uuidv;
if (!cbox_uuid_fromstring(&uuidv, uuid, error))
return NULL;
struct cbox_objhdr *obj = cbox_document_get_object_by_uuid(doc, &uuidv);
if (!obj)
{
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "UUID not found: '%s'", uuid);
return NULL;
}
if (class_ptr && !cbox_class_is_a(obj->class_ptr, class_ptr))
{
g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unexpected object type '%s' for UUID '%s' (expected '%s')", obj->class_ptr->name, uuid, class_ptr->name);
return NULL;
}
return obj;
}
static void iter_func(gpointer key, gpointer value, gpointer doc_)
{
#ifndef NDEBUG
struct cbox_document *doc = (struct cbox_document *)doc_;
#endif
struct cbox_class *class_ptr = key;
struct cbox_class_per_document *cpd = value;
int first = 1;
printf("Class %s: ", class_ptr->name);
GList *l = cpd->instances;
while(l) {
if (!first)
printf(", ");
printf("%p", l->data);
fflush(stdout);
struct cbox_objhdr *hdr = (struct cbox_objhdr *)l->data;
char buf[40];
uuid_unparse(hdr->instance_uuid.uuid, buf);
printf("[%s]", buf);
fflush(stdout);
assert(cbox_document_get_object_by_uuid(doc, &hdr->instance_uuid));
l = l->next;
first = 0;
}
if (first)
printf("<no instances>");
printf("\n");
}
static void iter_func2(gpointer key, gpointer value, gpointer document)
{
struct cbox_objhdr *oh = value;
char buf[40];
uuid_unparse(oh->instance_uuid.uuid, buf);
printf("Service %s: %p", (const char *)key, value);
fflush(stdout);
printf("[%s]", buf);
fflush(stdout);
printf(" (%s)\n", oh->class_ptr->name);
}
void cbox_document_dump(struct cbox_document *document)
{
g_hash_table_foreach(document->classes_per_document, iter_func, document);
g_hash_table_foreach(document->services_per_document, iter_func2, document);
}
uint64_t cbox_document_get_next_stamp(struct cbox_document *document)
{
return document->generation_ctr;
}
void cbox_document_destroy(struct cbox_document *document)
{
g_hash_table_destroy(document->classes_per_document);
g_hash_table_destroy(document->services_per_document);
g_hash_table_destroy(document->uuids_per_document);
free(document);
}