libwing 0.5.0

A library for communicationg with the Behringer Wing Digital Mixer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

#ifndef LIBWING_H
#define LIBWING_H

#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

// Opaque handle types
typedef struct WingDiscoveryInfo WingDiscoveryInfo;
typedef struct WingConsole WingConsole;
typedef struct Response Response;

// Enums
typedef enum {
    WING_RESPONSE_END = 0,
    WING_RESPONSE_NODE_DEFINITION = 1,
    WING_RESPONSE_NODE_DATA = 2
} WingResponseType;

typedef enum {
    WING_NODE_TYPE_NODE = 0,
    WING_NODE_TYPE_LINEAR_FLOAT = 1,
    WING_NODE_TYPE_LOGARITHMIC_FLOAT = 2,
    WING_NODE_TYPE_FADER_LEVEL = 3,
    WING_NODE_TYPE_INTEGER = 4,
    WING_NODE_TYPE_STRING_ENUM = 5,
    WING_NODE_TYPE_FLOAT_ENUM = 6,
    WING_NODE_TYPE_STRING = 7
} WingNodeType;

typedef enum {
    WING_NODE_UNIT_NONE = 0,
    WING_NODE_UNIT_DB = 1,
    WING_NODE_UNIT_PERCENT = 2,
    WING_NODE_UNIT_MILLISECONDS = 3,
    WING_NODE_UNIT_HERTZ = 4,
    WING_NODE_UNIT_METERS = 5,
    WING_NODE_UNIT_SECONDS = 6,
    WING_NODE_UNIT_OCTAVES = 7
} WingNodeUnit;

// Discovery functions
WingDiscoveryInfo* wing_discover_scan                             (int stop_on_first);
void               wing_discover_destroy                          (WingDiscoveryInfo* handle);
int                wing_discover_count                            (const WingDiscoveryInfo* handle);
const char*        wing_discover_get_ip                           (const WingDiscoveryInfo* handle, int index);
const char*        wing_discover_get_name                         (const WingDiscoveryInfo* handle, int index);
const char*        wing_discover_get_model                        (const WingDiscoveryInfo* handle, int index);
const char*        wing_discover_get_serial                       (const WingDiscoveryInfo* handle, int index);
const char*        wing_discover_get_firmware                     (const WingDiscoveryInfo* handle, int index);

// Console functions
WingConsole*       wing_console_connect                           (const char* ip);
void               wing_console_destroy                           (WingConsole* handle);
Response*          wing_console_read                              (WingConsole* handle);
int                wing_console_set_string                        (WingConsole* handle, int32_t id, const char* value);
int                wing_console_set_float                         (WingConsole* handle, int32_t id, float value);
int                wing_console_set_int                           (WingConsole* handle, int32_t id, int value);
int                wing_console_request_node_definition           (WingConsole* handle, int32_t id);
int                wing_console_request_node_data                 (WingConsole* handle, int32_t id);

// Response functions
void               wing_response_destroy                          (Response* handle);
WingResponseType   wing_response_get_type                         (const Response* handle);

// Node data functions
const char*        wing_node_data_get_string                      (const Response* handle);
float              wing_node_data_get_float                       (const Response* handle);
int                wing_node_data_get_int                         (const Response* handle);
int                wing_node_data_has_string                      (const Response* handle);
int                wing_node_data_has_float                       (const Response* handle);
int                wing_node_data_has_int                         (const Response* handle);

// Node definition functions
int32_t            wing_node_definition_get_parent_id             (const Response* handle);
int32_t            wing_node_definition_get_id                    (const Response* handle);
uint16_t           wing_node_definition_get_index                 (const Response* handle);
WingNodeType       wing_node_definition_get_type                  (const Response* handle);
WingNodeUnit       wing_node_definition_get_unit                  (const Response* handle);
const char*        wing_node_definition_get_name                  (const Response* handle);
const char*        wing_node_definition_get_long_name             (const Response* handle);
int                wing_node_definition_is_read_only              (const Response* handle);
int                wing_node_definition_get_min_float             (const Response* handle, float* ret);
int                wing_node_definition_get_max_float             (const Response* handle, float* ret);
int                wing_node_definition_get_steps                 (const Response* handle, int* ret);
int                wing_node_definition_get_min_int               (const Response* handle, int* ret);
int                wing_node_definition_get_max_int               (const Response* handle, int* ret);
int                wing_node_definition_get_max_string_len        (const Response* handle, int* ret);
int                wing_node_definition_get_string_enum_count     (const Response* handle);
int                wing_node_definition_get_float_enum_count      (const Response* handle);
int                wing_node_definition_get_float_enum_item       (const Response* handle, int index, float* ret);
int                wing_node_definition_get_float_enum_long_item  (const Response* handle, int index, const char** ret);
int                wing_node_definition_get_string_enum_item      (const Response* handle, int index, const char** ret);
int                wing_node_definition_get_string_enum_long_item (const Response* handle, int index, const char** ret);

// Utility functions
int                wing_name_to_id                                (const char* name, int32_t* out_id);
const char*        wing_id_to_name                                (int32_t id);
int                wing_id_to_parent                              (int32_t id, int32_t* out_parent);
WingNodeType       wing_id_to_type                                (int32_t id);
int                wing_parse_id                                  (const char* name, const char** out_name, int32_t* out_id);

    // you must call this to free the memory of any string returned by the library
void               wing_string_destroy                            (const char* handle);

#ifdef __cplusplus
}
#endif

#endif /* LIBWING_H */