ossia-c.h

Go to the documentation of this file.

#ifndef OSSIA_H
#define OSSIA_H
#include <stddef.h>
 
#if defined(_MSC_VER)
#if !defined(WIN32_LEAN_AND_MEAN)
#define WIN32_LEAN_AND_MEAN
#endif
#include <windows.h>
#undef BOOL
#undef INT
#undef FLOAT
#undef CHAR
#endif
 
#include <ossia_export.h>
#if defined(__cplusplus)
extern "C" {
#endif
struct ossia_protocol;
struct ossia_device;
struct ossia_domain;
struct ossia_value;
struct ossia_logger;
 
typedef struct ossia_protocol* ossia_protocol_t;
typedef struct ossia_device* ossia_device_t;
typedef struct ossia_domain* ossia_domain_t;
typedef struct ossia_value* ossia_value_t;
typedef struct ossia_logger* ossia_logger_t;
typedef void* ossia_node_t;
typedef void* ossia_parameter_t;
 
typedef void (*ossia_node_callback_t)(void* ctx, ossia_node_t);
struct ossia_node_callback_index;
typedef struct ossia_node_callback_index* ossia_node_callback_idx_t;
 
typedef void (*ossia_parameter_callback_t)(void* ctx, ossia_parameter_t);
struct ossia_parameter_callback_index;
typedef struct ossia_parameter_callback_index* ossia_parameter_callback_idx_t;
 
typedef void (*ossia_value_callback_t)(void* ctx, ossia_value_t);
struct ossia_value_callback_index;
typedef struct ossia_value_callback_index* ossia_value_callback_idx_t;
 
struct ossia_vec2f
{
  float val[2];
};
struct ossia_vec3f
{
  float val[3];
};
struct ossia_vec4f
{
  float val[4];
};
 
/****************/
/*** Protocol ***/
/****************/
 
OSSIA_EXPORT
ossia_protocol_t ossia_protocol_multiplex_create();
 
OSSIA_EXPORT
void ossia_protocol_multiplex_expose_to(ossia_protocol_t local, ossia_protocol_t other);
 
OSSIA_EXPORT
ossia_protocol_t
ossia_protocol_osc_create(const char* ip, int remote_port, int local_port);
 
OSSIA_EXPORT
ossia_protocol_t ossia_protocol_minuit_create(
    const char* local_name, const char* ip, int remote_port, int local_port);
 
OSSIA_EXPORT
ossia_protocol_t ossia_protocol_oscquery_server_create(int osc_port, int ws_port);
 
OSSIA_EXPORT
ossia_protocol_t ossia_protocol_oscquery_mirror_create(const char* host);
 
OSSIA_EXPORT
void ossia_protocol_free(ossia_protocol_t);
 
/**************/
/*** Device ***/
/**************/
 
OSSIA_EXPORT
ossia_device_t ossia_device_create(ossia_protocol_t protocol, const char* name);
 
OSSIA_EXPORT
void ossia_device_free(ossia_device_t device);
 
OSSIA_EXPORT
void ossia_device_reset_static();
 
OSSIA_EXPORT
int ossia_device_update_namespace(ossia_device_t device);
 
OSSIA_EXPORT
ossia_node_t ossia_device_get_root_node(ossia_device_t device);
 
OSSIA_EXPORT
const char* ossia_device_get_name(ossia_device_t device);
 
OSSIA_EXPORT
ossia_node_callback_idx_t ossia_device_add_node_created_callback(
    ossia_device_t device, ossia_node_callback_t callback, void* ctx);
 
OSSIA_EXPORT
void ossia_device_remove_node_created_callback(
    ossia_device_t device, ossia_node_callback_idx_t index);
 
OSSIA_EXPORT
ossia_node_callback_idx_t ossia_device_add_node_removing_callback(
    ossia_device_t device, ossia_node_callback_t callback, void* ctx);
OSSIA_EXPORT
void ossia_device_remove_node_removing_callback(
    ossia_device_t device, ossia_node_callback_idx_t index);
 
OSSIA_EXPORT
ossia_parameter_callback_idx_t ossia_device_add_parameter_deleting_callback(
    ossia_device_t device, ossia_parameter_callback_t callback, void* ctx);
OSSIA_EXPORT
void ossia_device_remove_parameter_deleting_callback(
    ossia_device_t device, ossia_parameter_callback_idx_t index);
 
/*****************/
/*** Parameter ***/
/*****************/
 
typedef enum
{
  FLOAT_T,
  INT_T,
  VEC2F_T,
  VEC3F_T,
  VEC4F_T,
  IMPULSE_T,
  BOOL_T,
  STRING_T,
  LIST_T,
  CHAR_T
} ossia_type;
 
typedef enum
{
  BI,
  GET,
  SET
} ossia_access_mode;
 
typedef enum
{
  FREE,
  CLIP,
  WRAP,
  FOLD,
  LOW,
  HIGH
} ossia_bounding_mode;
 
OSSIA_EXPORT
ossia_node_t ossia_parameter_get_node(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_access_mode(ossia_parameter_t param, ossia_access_mode am);
OSSIA_EXPORT
ossia_access_mode ossia_parameter_get_access_mode(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_bounding_mode(ossia_parameter_t param, ossia_bounding_mode bm);
OSSIA_EXPORT
ossia_bounding_mode ossia_parameter_get_bounding_mode(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_domain(ossia_parameter_t param, ossia_domain_t domain);
OSSIA_EXPORT
ossia_domain_t ossia_parameter_get_domain(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_unit(ossia_parameter_t param, const char* unit);
OSSIA_EXPORT
const char* ossia_parameter_get_unit(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_muted(ossia_parameter_t param, int muted);
OSSIA_EXPORT
int ossia_parameter_get_muted(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_disabled(ossia_parameter_t param, int disabled);
OSSIA_EXPORT
int ossia_parameter_get_disabled(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_critical(ossia_parameter_t param, int critical);
OSSIA_EXPORT
int ossia_parameter_get_critical(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_repetition_filter(
    ossia_parameter_t param, int repetition_filter);
OSSIA_EXPORT
int ossia_parameter_get_repetition_filter(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_value(ossia_parameter_t param, ossia_value_t value);
OSSIA_EXPORT
ossia_value_t ossia_parameter_get_value(ossia_parameter_t param);
 
OSSIA_EXPORT
int ossia_parameter_to_int(ossia_parameter_t val);
OSSIA_EXPORT
float ossia_parameter_to_float(ossia_parameter_t val);
OSSIA_EXPORT
struct ossia_vec2f ossia_parameter_to_2f(ossia_parameter_t val);
OSSIA_EXPORT
struct ossia_vec3f ossia_parameter_to_3f(ossia_parameter_t val);
OSSIA_EXPORT
struct ossia_vec4f ossia_parameter_to_4f(ossia_parameter_t val);
OSSIA_EXPORT
int ossia_parameter_to_bool(ossia_parameter_t val);
 
OSSIA_EXPORT
void ossia_parameter_to_byte_array(ossia_parameter_t val, char** str, size_t* sz);
OSSIA_EXPORT
const char* ossia_parameter_to_string(ossia_parameter_t val);
OSSIA_EXPORT
void ossia_parameter_to_list(
    ossia_parameter_t val_in, ossia_value_t** out, size_t* size);
 
OSSIA_EXPORT
void ossia_parameter_to_fn(ossia_parameter_t val_in, float** out, size_t* size);
 
OSSIA_EXPORT
void ossia_parameter_to_in(ossia_parameter_t val_in, int** out, size_t* size);
 
OSSIA_EXPORT
void ossia_parameter_push_value(ossia_parameter_t param, ossia_value_t value);
OSSIA_EXPORT
void ossia_parameter_push_impulse(ossia_parameter_t param);
OSSIA_EXPORT
void ossia_parameter_push_i(ossia_parameter_t param, int value);
OSSIA_EXPORT
void ossia_parameter_push_b(ossia_parameter_t param, int b);
OSSIA_EXPORT
void ossia_parameter_push_f(ossia_parameter_t param, float value);
OSSIA_EXPORT
void ossia_parameter_push_2f(ossia_parameter_t param, float v1, float v2);
OSSIA_EXPORT
void ossia_parameter_push_3f(ossia_parameter_t param, float v1, float v2, float v3);
OSSIA_EXPORT
void ossia_parameter_push_4f(
    ossia_parameter_t param, float v1, float v2, float v3, float v4);
OSSIA_EXPORT
void ossia_parameter_push_c(ossia_parameter_t param, char value);
OSSIA_EXPORT
void ossia_parameter_push_s(ossia_parameter_t param, const char* value);
 
OSSIA_EXPORT
void ossia_parameter_push_in(ossia_parameter_t param, const int* value, size_t sz);
 
OSSIA_EXPORT
void ossia_parameter_push_fn(ossia_parameter_t param, const float* value, size_t sz);
 
OSSIA_EXPORT
void ossia_parameter_push_cn(ossia_parameter_t param, const char* value, size_t sz);
 
OSSIA_EXPORT
void ossia_parameter_push_list(
    ossia_parameter_t param, const ossia_value_t* value, size_t sz);
 
OSSIA_EXPORT
ossia_value_t ossia_parameter_fetch_value(ossia_parameter_t param);
 
OSSIA_EXPORT
void ossia_parameter_set_listening(ossia_parameter_t param, int listening);
 
OSSIA_EXPORT
ossia_value_callback_idx_t ossia_parameter_add_callback(
    ossia_parameter_t param, ossia_value_callback_t callback, void* ctx);
 
OSSIA_EXPORT
void ossia_parameter_push_callback(
    ossia_parameter_t param, ossia_value_callback_t callback, void* ctx);
 
OSSIA_EXPORT
void ossia_parameter_remove_callback(
    ossia_parameter_t param, ossia_value_callback_idx_t index);
 
OSSIA_EXPORT
void ossia_parameter_free_callback_idx(ossia_value_callback_idx_t);
 
/************/
/*** Node ***/
/************/
 
OSSIA_EXPORT ossia_node_t ossia_node_find(ossia_node_t root, const char* path);
 
OSSIA_EXPORT void ossia_node_find_pattern(
    ossia_node_t root, const char* pattern, ossia_node_t** data, size_t* size);
 
OSSIA_EXPORT ossia_node_t ossia_node_create(ossia_node_t root, const char* path);
 
OSSIA_EXPORT void ossia_node_create_pattern(
    ossia_node_t root, const char* pattern, ossia_node_t** data, size_t* size);
 
OSSIA_EXPORT void ossia_node_array_free(ossia_node_t*);
 
OSSIA_EXPORT
ossia_node_t ossia_node_add_child(ossia_node_t node, const char* name);
 
OSSIA_EXPORT
void ossia_node_remove_child(ossia_node_t node, ossia_node_t name);
 
OSSIA_EXPORT
const char* ossia_node_get_name(ossia_node_t node);
 
OSSIA_EXPORT
ossia_device_t ossia_node_get_device(ossia_node_t node);
 
OSSIA_EXPORT
int ossia_node_child_size(ossia_node_t node);
 
OSSIA_EXPORT
ossia_node_t ossia_node_get_child(ossia_node_t node, int child_n);
 
OSSIA_EXPORT
ossia_node_t ossia_node_find_child(ossia_node_t node, const char* name);
 
OSSIA_EXPORT
ossia_parameter_t ossia_node_create_parameter(ossia_node_t node, ossia_type type);
 
OSSIA_EXPORT
ossia_parameter_t
ossia_create_parameter(ossia_node_t node, const char* name, const char* type);
 
OSSIA_EXPORT
ossia_parameter_t ossia_node_get_parameter(ossia_node_t node);
 
OSSIA_EXPORT
void ossia_node_remove_parameter(ossia_node_t node);
 
OSSIA_EXPORT
ossia_node_callback_idx_t ossia_node_add_deleting_callback(
    ossia_node_t node, ossia_node_callback_t callback, void* ctx);
OSSIA_EXPORT
void ossia_node_remove_deleting_callback(
    ossia_node_t node, ossia_node_callback_idx_t index);
 
OSSIA_EXPORT
void ossia_node_set_description(ossia_node_t node, const char* description);
OSSIA_EXPORT
const char* ossia_node_get_description(ossia_node_t node);
 
OSSIA_EXPORT
void ossia_node_set_extended_type(ossia_node_t node, const char* extended_type);
OSSIA_EXPORT
const char* ossia_node_get_extended_type(ossia_node_t node);
 
OSSIA_EXPORT
void ossia_node_set_tags(ossia_node_t node, const char** tags, size_t sz);
OSSIA_EXPORT
void ossia_node_get_tags(ossia_node_t node, char*** tags, size_t* sz);
 
OSSIA_EXPORT
void ossia_tags_free(char** tags, size_t sz);
 
OSSIA_EXPORT
void ossia_node_set_hidden(ossia_node_t node, int hidden);
OSSIA_EXPORT
int ossia_node_get_hidden(ossia_node_t node);
 
OSSIA_EXPORT
void ossia_node_set_refresh_rate(ossia_node_t node, int refresh_rate);
OSSIA_EXPORT
void ossia_node_unset_refresh_rate(ossia_node_t node);
OSSIA_EXPORT
int ossia_node_get_refresh_rate(ossia_node_t node, int* ok);
 
OSSIA_EXPORT
void ossia_node_set_priority(ossia_node_t node, float priority);
OSSIA_EXPORT
void ossia_node_unset_priority(ossia_node_t node);
OSSIA_EXPORT
float ossia_node_get_priority(ossia_node_t node, int* ok);
 
OSSIA_EXPORT
void ossia_node_set_value_step_size(ossia_node_t node, double value_step_size);
OSSIA_EXPORT
void ossia_node_unset_value_step_size(ossia_node_t node);
OSSIA_EXPORT
double ossia_node_get_value_step_size(ossia_node_t node, int* ok);
 
OSSIA_EXPORT
void ossia_node_set_instance_bounds(ossia_node_t node, int min, int max);
OSSIA_EXPORT
void ossia_node_unset_instance_bounds(ossia_node_t node);
OSSIA_EXPORT
void ossia_node_get_instance_bounds(ossia_node_t node, int* min, int* max, int* ok);
 
OSSIA_EXPORT
void ossia_node_set_default_value(ossia_node_t node, ossia_value_t default_value);
OSSIA_EXPORT
ossia_value_t ossia_node_get_default_value(ossia_node_t node);
 
/**************/
/*** Domain ***/
/**************/
 
OSSIA_EXPORT
ossia_domain_t ossia_domain_create(void);
 
OSSIA_EXPORT
ossia_domain_t ossia_domain_make_min_max(ossia_value_t min, ossia_value_t max);
 
OSSIA_EXPORT
ossia_value_t ossia_domain_get_min(ossia_domain_t domain);
OSSIA_EXPORT
void ossia_domain_set_min(ossia_domain_t domain, ossia_value_t value);
OSSIA_EXPORT
ossia_value_t ossia_domain_get_max(ossia_domain_t domain);
OSSIA_EXPORT
void ossia_domain_set_max(ossia_domain_t domain, ossia_value_t value);
 
OSSIA_EXPORT
ossia_domain_t ossia_domain_make_string_set(const char** strings, size_t n);
 
OSSIA_EXPORT
ossia_domain_t ossia_domain_make_int_set(const int* values, size_t n);
 
OSSIA_EXPORT
ossia_domain_t ossia_domain_make_float_set(const float* values, size_t n);
 
OSSIA_EXPORT
ossia_domain_t ossia_domain_make_value_set(const ossia_value_t* values, size_t n);
 
OSSIA_EXPORT
void ossia_domain_get_values(ossia_domain_t domain, ossia_value_t** values, size_t* n);
OSSIA_EXPORT
void ossia_domain_set_values(
    ossia_domain_t domain, const ossia_value_t* values, size_t n);
 
OSSIA_EXPORT
void ossia_domain_free(ossia_domain_t domain);
 
/*************/
/*** Value ***/
/*************/
OSSIA_EXPORT
ossia_value_t ossia_value_create_impulse();
OSSIA_EXPORT
ossia_value_t ossia_value_create_int(int value);
OSSIA_EXPORT
ossia_value_t ossia_value_create_float(float value);
OSSIA_EXPORT
ossia_value_t ossia_value_create_2f(float v1, float v2);
OSSIA_EXPORT
ossia_value_t ossia_value_create_3f(float v1, float v2, float v3);
OSSIA_EXPORT
ossia_value_t ossia_value_create_4f(float v1, float v2, float v3, float v4);
OSSIA_EXPORT
ossia_value_t ossia_value_create_bool(int value);
OSSIA_EXPORT
ossia_value_t ossia_value_create_char(char value);
OSSIA_EXPORT
ossia_value_t ossia_value_create_string(const char* value);
OSSIA_EXPORT
ossia_value_t ossia_value_create_byte_array(const char* value, size_t size);
OSSIA_EXPORT
ossia_value_t ossia_value_create_list(const ossia_value_t* values, size_t size);
OSSIA_EXPORT
ossia_value_t ossia_value_create_in(const int* values, size_t size);
OSSIA_EXPORT
ossia_value_t ossia_value_create_fn(const float* values, size_t size);
 
OSSIA_EXPORT
void ossia_value_free(ossia_value_t value);
 
OSSIA_EXPORT
ossia_type ossia_value_get_type(ossia_value_t type);
 
OSSIA_EXPORT
int ossia_value_to_int(ossia_value_t val);
OSSIA_EXPORT
float ossia_value_to_float(ossia_value_t val);
OSSIA_EXPORT
struct ossia_vec2f ossia_value_to_2f(ossia_value_t val);
OSSIA_EXPORT
struct ossia_vec3f ossia_value_to_3f(ossia_value_t val);
OSSIA_EXPORT
struct ossia_vec4f ossia_value_to_4f(ossia_value_t val);
OSSIA_EXPORT
int ossia_value_to_bool(ossia_value_t val);
OSSIA_EXPORT
void ossia_value_to_byte_array(ossia_value_t val, char** str, size_t* sz);
OSSIA_EXPORT
const char* ossia_value_to_string(ossia_value_t val);
OSSIA_EXPORT
void ossia_value_to_list(ossia_value_t val_in, ossia_value_t** out, size_t* size);
OSSIA_EXPORT
void ossia_value_free_list(ossia_value_t* out);
 
OSSIA_EXPORT
void ossia_value_to_fn(ossia_value_t val_in, float** out, size_t* size);
OSSIA_EXPORT
void ossia_value_free_fn(float* out);
 
OSSIA_EXPORT
void ossia_value_to_in(ossia_value_t val_in, int** out, size_t* size);
OSSIA_EXPORT
void ossia_value_free_in(int* out);
 
OSSIA_EXPORT
int ossia_value_convert_int(ossia_value_t val);
OSSIA_EXPORT
float ossia_value_convert_float(ossia_value_t val);
OSSIA_EXPORT
int ossia_value_convert_bool(ossia_value_t val);
OSSIA_EXPORT
char ossia_value_convert_char(ossia_value_t val);
OSSIA_EXPORT
void ossia_value_convert_byte_array(ossia_value_t val, char** str, size_t* sz);
OSSIA_EXPORT
void ossia_value_convert_list(ossia_value_t val_in, ossia_value_t** out, size_t* size);
 
OSSIA_EXPORT
struct ossia_vec2f ossia_value_convert_2f(ossia_value_t val);
 
OSSIA_EXPORT
struct ossia_vec3f ossia_value_convert_3f(ossia_value_t val);
 
OSSIA_EXPORT
struct ossia_vec4f ossia_value_convert_4f(ossia_value_t val);
 
OSSIA_EXPORT
void ossia_string_free(char*);
 
/***************/
/*** Logging ***/
/***************/
enum log_level
{
  trace,
  debug,
  info,
  warn,
  error,
  critical,
  off
};
 
OSSIA_EXPORT
ossia_logger_t ossia_logger_create(const char* host, const char* app);
OSSIA_EXPORT
void ossia_logger_init_heartbeat(ossia_logger_t log, int pid, const char* cmdline);
OSSIA_EXPORT
void ossia_logger_set_level(ossia_logger_t log, enum log_level lvl);
OSSIA_EXPORT
void ossia_log(ossia_logger_t log, enum log_level lvl, const char* message);
 
OSSIA_EXPORT
void ossia_logger_free(ossia_logger_t log);
 
/*************************/
/*** Message-queue API ***/
/*************************/
 
typedef void* ossia_mq_t;
 
OSSIA_EXPORT
ossia_mq_t ossia_mq_create(ossia_device_t);
 
OSSIA_EXPORT
void ossia_mq_register(ossia_mq_t, ossia_parameter_t);
 
OSSIA_EXPORT
void ossia_mq_unregister(ossia_mq_t, ossia_parameter_t);
 
OSSIA_EXPORT
int ossia_mq_pop(ossia_mq_t mq, ossia_parameter_t* param, ossia_value_t* val);
 
OSSIA_EXPORT
void ossia_mq_free(ossia_mq_t);
 
/***************************/
/*** Network context API ***/
/***************************/
 
typedef void* ossia_network_context_t;
OSSIA_EXPORT
ossia_network_context_t ossia_network_context_create();
 
OSSIA_EXPORT
void ossia_network_context_free(ossia_network_context_t);
 
OSSIA_EXPORT
void ossia_network_context_poll(ossia_network_context_t);
 
#if defined(__cplusplus)
}
#endif
 
#endif