1 /* Simple Plugin API 2 * 3 * Copyright © 2018 Wim Taymans 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24 25 #ifndef SPA_POD_H 26 #define SPA_POD_H 27 28 #ifdef __cplusplus 29 extern "C" { 30 #endif 31 32 #include <spa/utils/defs.h> 33 #include <spa/utils/type.h> 34 35 /** 36 * \addtogroup spa_pod 37 * \{ 38 */ 39 40 #define SPA_POD_BODY_SIZE(pod) (((struct spa_pod*)(pod))->size) 41 #define SPA_POD_TYPE(pod) (((struct spa_pod*)(pod))->type) 42 #define SPA_POD_SIZE(pod) (sizeof(struct spa_pod) + SPA_POD_BODY_SIZE(pod)) 43 #define SPA_POD_CONTENTS_SIZE(type,pod) (SPA_POD_SIZE(pod)-sizeof(type)) 44 45 #define SPA_POD_CONTENTS(type,pod) SPA_PTROFF((pod),sizeof(type),void) 46 #define SPA_POD_CONTENTS_CONST(type,pod) SPA_PTROFF((pod),sizeof(type),const void) 47 #define SPA_POD_BODY(pod) SPA_PTROFF((pod),sizeof(struct spa_pod),void) 48 #define SPA_POD_BODY_CONST(pod) SPA_PTROFF((pod),sizeof(struct spa_pod),const void) 49 50 struct spa_pod { 51 uint32_t size; /* size of the body */ 52 uint32_t type; /* a basic id of enum spa_type */ 53 }; 54 55 #define SPA_POD_VALUE(type,pod) (((type*)pod)->value) 56 57 struct spa_pod_bool { 58 struct spa_pod pod; 59 int32_t value; 60 int32_t _padding; 61 }; 62 63 struct spa_pod_id { 64 struct spa_pod pod; 65 uint32_t value; 66 int32_t _padding; 67 }; 68 69 struct spa_pod_int { 70 struct spa_pod pod; 71 int32_t value; 72 int32_t _padding; 73 }; 74 75 struct spa_pod_long { 76 struct spa_pod pod; 77 int64_t value; 78 }; 79 80 struct spa_pod_float { 81 struct spa_pod pod; 82 float value; 83 int32_t _padding; 84 }; 85 86 struct spa_pod_double { 87 struct spa_pod pod; 88 double value; 89 }; 90 91 struct spa_pod_string { 92 struct spa_pod pod; 93 /* value here */ 94 }; 95 96 struct spa_pod_bytes { 97 struct spa_pod pod; 98 /* value here */ 99 }; 100 101 struct spa_pod_rectangle { 102 struct spa_pod pod; 103 struct spa_rectangle value; 104 }; 105 106 struct spa_pod_fraction { 107 struct spa_pod pod; 108 struct spa_fraction value; 109 }; 110 111 struct spa_pod_bitmap { 112 struct spa_pod pod; 113 /* array of uint8_t follows with the bitmap */ 114 }; 115 116 #define SPA_POD_ARRAY_CHILD(arr) (&((struct spa_pod_array*)(arr))->body.child) 117 #define SPA_POD_ARRAY_VALUE_TYPE(arr) (SPA_POD_TYPE(SPA_POD_ARRAY_CHILD(arr))) 118 #define SPA_POD_ARRAY_VALUE_SIZE(arr) (SPA_POD_BODY_SIZE(SPA_POD_ARRAY_CHILD(arr))) 119 #define SPA_POD_ARRAY_N_VALUES(arr) (SPA_POD_ARRAY_VALUE_SIZE(arr) ? ((SPA_POD_BODY_SIZE(arr) - sizeof(struct spa_pod_array_body)) / SPA_POD_ARRAY_VALUE_SIZE(arr)) : 0) 120 #define SPA_POD_ARRAY_VALUES(arr) SPA_POD_CONTENTS(struct spa_pod_array, arr) 121 122 struct spa_pod_array_body { 123 struct spa_pod child; 124 /* array with elements of child.size follows */ 125 }; 126 127 struct spa_pod_array { 128 struct spa_pod pod; 129 struct spa_pod_array_body body; 130 }; 131 132 #define SPA_POD_CHOICE_CHILD(choice) (&((struct spa_pod_choice*)(choice))->body.child) 133 #define SPA_POD_CHOICE_TYPE(choice) (((struct spa_pod_choice*)(choice))->body.type) 134 #define SPA_POD_CHOICE_FLAGS(choice) (((struct spa_pod_choice*)(choice))->body.flags) 135 #define SPA_POD_CHOICE_VALUE_TYPE(choice) (SPA_POD_TYPE(SPA_POD_CHOICE_CHILD(choice))) 136 #define SPA_POD_CHOICE_VALUE_SIZE(choice) (SPA_POD_BODY_SIZE(SPA_POD_CHOICE_CHILD(choice))) 137 #define SPA_POD_CHOICE_N_VALUES(choice) (SPA_POD_CHOICE_VALUE_SIZE(choice) ? ((SPA_POD_BODY_SIZE(choice) - sizeof(struct spa_pod_choice_body)) / SPA_POD_CHOICE_VALUE_SIZE(choice)) : 0) 138 #define SPA_POD_CHOICE_VALUES(choice) (SPA_POD_CONTENTS(struct spa_pod_choice, choice)) 139 140 enum spa_choice_type { 141 SPA_CHOICE_None, /**< no choice, first value is current */ 142 SPA_CHOICE_Range, /**< range: default, min, max */ 143 SPA_CHOICE_Step, /**< range with step: default, min, max, step */ 144 SPA_CHOICE_Enum, /**< list: default, alternative,... */ 145 SPA_CHOICE_Flags, /**< flags: default, possible flags,... */ 146 }; 147 148 struct spa_pod_choice_body { 149 uint32_t type; /**< type of choice, one of enum spa_choice_type */ 150 uint32_t flags; /**< extra flags */ 151 struct spa_pod child; 152 /* array with elements of child.size follows. Note that there might be more 153 * elements than required by \a type, which should be ignored. */ 154 }; 155 156 struct spa_pod_choice { 157 struct spa_pod pod; 158 struct spa_pod_choice_body body; 159 }; 160 161 struct spa_pod_struct { 162 struct spa_pod pod; 163 /* one or more spa_pod follow */ 164 }; 165 166 #define SPA_POD_OBJECT_TYPE(obj) (((struct spa_pod_object*)(obj))->body.type) 167 #define SPA_POD_OBJECT_ID(obj) (((struct spa_pod_object*)(obj))->body.id) 168 169 struct spa_pod_object_body { 170 uint32_t type; /**< one of enum spa_type */ 171 uint32_t id; /**< id of the object, depends on the object type */ 172 /* contents follow, series of spa_pod_prop */ 173 }; 174 175 struct spa_pod_object { 176 struct spa_pod pod; 177 struct spa_pod_object_body body; 178 }; 179 180 struct spa_pod_pointer_body { 181 uint32_t type; /**< pointer id, one of enum spa_type */ 182 uint32_t _padding; 183 const void *value; 184 }; 185 186 struct spa_pod_pointer { 187 struct spa_pod pod; 188 struct spa_pod_pointer_body body; 189 }; 190 191 struct spa_pod_fd { 192 struct spa_pod pod; 193 int64_t value; 194 }; 195 196 #define SPA_POD_PROP_SIZE(prop) (sizeof(struct spa_pod_prop) + (prop)->value.size) 197 198 /* props can be inside an object */ 199 struct spa_pod_prop { 200 uint32_t key; /**< key of property, list of valid keys depends on the 201 * object type */ 202 #define SPA_POD_PROP_FLAG_READONLY (1u<<0) /**< is read-only */ 203 #define SPA_POD_PROP_FLAG_HARDWARE (1u<<1) /**< some sort of hardware parameter */ 204 #define SPA_POD_PROP_FLAG_HINT_DICT (1u<<2) /**< contains a dictionary struct as 205 * (Struct( 206 * Int : n_items, 207 * (String : key, 208 * String : value)*)) */ 209 #define SPA_POD_PROP_FLAG_MANDATORY (1u<<3) /**< is mandatory */ 210 #define SPA_POD_PROP_FLAG_DONT_FIXATE (1u<<4) /**< choices need no fixation */ 211 uint32_t flags; /**< flags for property */ 212 struct spa_pod value; 213 /* value follows */ 214 }; 215 216 #define SPA_POD_CONTROL_SIZE(ev) (sizeof(struct spa_pod_control) + (ev)->value.size) 217 218 /* controls can be inside a sequence and mark timed values */ 219 struct spa_pod_control { 220 uint32_t offset; /**< media offset */ 221 uint32_t type; /**< type of control, enum spa_control_type */ 222 struct spa_pod value; /**< control value, depends on type */ 223 /* value contents follow */ 224 }; 225 226 struct spa_pod_sequence_body { 227 uint32_t unit; 228 uint32_t pad; 229 /* series of struct spa_pod_control follows */ 230 }; 231 232 /** a sequence of timed controls */ 233 struct spa_pod_sequence { 234 struct spa_pod pod; 235 struct spa_pod_sequence_body body; 236 }; 237 238 /** 239 * \} 240 */ 241 242 #ifdef __cplusplus 243 } /* extern "C" */ 244 #endif 245 246 #endif /* SPA_POD_H */ 247