Debian Codegraph @

modules/lsp-runtime-lib/src/main/fmt/Hydrogen.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 11 июл. 2020 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/common/debug.h>
23 #include <lsp-plug.in/fmt/xml/PullParser.h>
24 #include <lsp-plug.in/fmt/Hydrogen.h>
25 #include <lsp-plug.in/io/InStringSequence.h>
26 #include <lsp-plug.in/expr/Tokenizer.h>
27
28 namespace lsp
29 {
30 namespace hydrogen
31 {
32 //---------------------------------------------------------------------
33 layer_t::layer_t()
34 {
35 min = 0.0f;
36 max = 1.0f;
37 gain = 1.0f;
38 pitch = 0.0f;
39 }
40
41 layer_t::~layer_t()
42 {
43 }
44
45 //---------------------------------------------------------------------
46 instrument_t::instrument_t()
47 {
48 id = -1;
49 volume = 1.0f;
50 muted = false;
51 locked = false;
52 pan_left = 1.0f;
53 pan_right = 1.0f;
54 random_pitch_factor = 0.0f;
55 gain = 1.0f;
56 filter_active = false;
57 filter_cutoff = 1.0f;
58 filter_resonance = 0.0f;
59 attack = 0.0f;
60 decay = 0.0f;
61 sustain = 0.0f;
62 release = 0.0f;
63 mute_group = -1;
64 stop_note = false;
65 midi_out_channel = -1;
66 midi_out_note = -1;
67 midi_in_channel = -1;
68 midi_in_note = -1;
69 fx1_level = 0.0f;
70 fx2_level = 0.0f;
71 fx3_level = 0.0f;
72 fx4_level = 0.0f;
73 }
74
75 instrument_t::~instrument_t()
76 {
77 for (size_t i=0, n=layers.size(); i<n; ++i)
78 {
79 layer_t *layer = layers.uget(i);
80 if (layer != NULL)
81 delete layer;
82 }
83 layers.flush();
84 }
85
86 //---------------------------------------------------------------------
87 drumkit_t::drumkit_t()
88 {
89 }
90
91 drumkit_t::~drumkit_t()
92 {
93 for (size_t i=0, n=instruments.size(); i<n; ++i)
94 {
95 instrument_t *instr = instruments.uget(i);
96 if (instr != NULL)
97 delete instr;
98 }
99 instruments.flush();
100 }
101
102 void drumkit_t::swap(drumkit_t *dst)
103 {
104 name.swap(&dst->name);
105 author.swap(&dst->author);
106 info.swap(&dst->info);
107 license.swap(&dst->license);
108 instruments.swap(&dst->instruments);
109 }
110
111 //---------------------------------------------------------------------
112 status_t read_string(xml::PullParser *p, LSPString *dst)
113 {
114 LSPString tmp;
115 status_t item, res = STATUS_OK;
116
117 do
118 {
119 if ((item = p->read_next()) < 0)
120 return -item;
121
122 switch (item)
123 {
124 case xml::XT_COMMENT:
125 break;
126
127 case xml::XT_CHARACTERS:
128 case xml::XT_CDATA:
129 res = (tmp.append(p->value())) ? STATUS_OK : STATUS_NO_MEM;
130 break;
131
132 case xml::XT_END_ELEMENT:
133 {
134 tmp.swap(dst);
135 return STATUS_OK;
136 }
137
138 default:
139 return STATUS_BAD_FORMAT;
140 }
141 } while (res == STATUS_OK);
142
143 return res;
144 }
145
146 status_t read_int(xml::PullParser *p, ssize_t *value)
147 {
148 LSPString tmp;
149 status_t res = read_string(p, &tmp);
150 if (res != STATUS_OK)
151 return res;
152
153 io::InStringSequence sq(&tmp);
154 expr::Tokenizer tok(&sq);
155 expr::token_t t = tok.get_token(expr::TF_GET);
156 if (t != expr::TT_IVALUE)
157 return STATUS_BAD_FORMAT;
158
159 *value = tok.int_value();
160 t = tok.get_token(expr::TF_GET);
161 return (t == expr::TT_EOF) ? STATUS_OK : STATUS_BAD_FORMAT;
162 }
163
164 status_t read_float(xml::PullParser *p, float *value)
165 {
166 LSPString tmp;
167 status_t res = read_string(p, &tmp);
168 if (res != STATUS_OK)
169 return res;
170
171 io::InStringSequence sq(&tmp);
172 expr::Tokenizer tok(&sq);
173 expr::token_t t = tok.get_token(expr::TF_GET);
174 if ((t != expr::TT_IVALUE) && (t != expr::TT_FVALUE))
175 return STATUS_BAD_FORMAT;
176
177 *value = (t == expr::TT_IVALUE) ? tok.int_value() : tok.float_value();
178 t = tok.get_token(expr::TF_GET);
179 return (t == expr::TT_EOF) ? STATUS_OK : STATUS_BAD_FORMAT;
180 }
181
182 status_t read_bool(xml::PullParser *p, bool *value)
183 {
184 LSPString tmp;
185 status_t res = read_string(p, &tmp);
186 if (res != STATUS_OK)
187 return res;
188
189 io::InStringSequence sq(&tmp);
190 expr::Tokenizer tok(&sq);
191 expr::token_t t = tok.get_token(expr::TF_GET);
192 if ((t != expr::TT_TRUE) && (t != expr::TT_FALSE))
193 return STATUS_BAD_FORMAT;
194
195 *value = (t == expr::TT_TRUE);
196 t = tok.get_token(expr::TF_GET);
197 return (t == expr::TT_EOF) ? STATUS_OK : STATUS_BAD_FORMAT;
198 }
199
200 status_t skip_tags(xml::PullParser *p)
201 {
202 size_t counter = 1;
203 status_t item, res = STATUS_OK;
204
205 do
206 {
207 if ((item = p->read_next()) < 0)
208 return -item;
209
210 switch (item)
211 {
212 case xml::XT_CHARACTERS:
213 case xml::XT_CDATA:
214 case xml::XT_COMMENT:
215 case xml::XT_ATTRIBUTE:
216 break;
217
218 case xml::XT_START_ELEMENT:
219 ++counter;
220 break;
221
222 case xml::XT_END_ELEMENT:
223 if ((--counter) <= 0)
224 return res;
225 break;
226
227 default:
228 return STATUS_CORRUPTED;
229 }
230 } while (res == STATUS_OK);
231
232 return res;
233 }
234
235 status_t read_layer(xml::PullParser *p, layer_t *layer)
236 {
237 status_t item, res = STATUS_OK;
238
239 do
240 {
241 if ((item = p->read_next()) < 0)
242 return -item;
243
244 switch (item)
245 {
246 case xml::XT_CHARACTERS:
247 case xml::XT_CDATA:
248 case xml::XT_COMMENT:
249 break;
250
251 case xml::XT_START_ELEMENT:
252 {
253 const LSPString *name = p->name();
254
255 if (name->equals_ascii("filename"))
256 res = read_string(p, &layer->file_name);
257 else if (name->equals_ascii("min"))
258 res = read_float(p, &layer->min);
259 else if (name->equals_ascii("max"))
260 res = read_float(p, &layer->max);
261 else if (name->equals_ascii("gain"))
262 res = read_float(p, &layer->gain);
263 else if (name->equals_ascii("pitch"))
264 res = read_float(p, &layer->pitch);
265 else
266 res = skip_tags(p);
267 break;
268 }
269
270 case xml::XT_END_ELEMENT:
271 return res;
272
273 default:
274 return STATUS_CORRUPTED;
275 }
276 } while (res == STATUS_OK);
277
278 return res;
279 }
280
281 status_t read_instrument_component(xml::PullParser *p, instrument_t *inst)
282 {
283 status_t item, res = STATUS_OK;
284
285 do
286 {
287 if ((item = p->read_next()) < 0)
288 return -item;
289
290 switch (item)
291 {
292 case xml::XT_CHARACTERS:
293 case xml::XT_CDATA:
294 case xml::XT_COMMENT:
295 break;
296
297 case xml::XT_START_ELEMENT:
298 {
299 const LSPString *name = p->name();
300 if (name->equals_ascii("layer"))
301 {
302 layer_t *layer = new layer_t();
303 if (layer == NULL)
304 return STATUS_NO_MEM;
305 if (!inst->layers.add(layer))
306 {
307 delete layer;
308 return STATUS_NO_MEM;
309 }
310 res = read_layer(p, layer);
311 }
312 else
313 res = skip_tags(p);
314 break;
315 }
316
317 case xml::XT_END_ELEMENT:
318 return res;
319
320 default:
321 return STATUS_CORRUPTED;
322 }
323 } while (res == STATUS_OK);
324
325 return res;
326 }
327
328 status_t read_instrument(xml::PullParser *p, instrument_t *inst)
329 {
330 status_t item, res = STATUS_OK;
331
332 do
333 {
334 if ((item = p->read_next()) < 0)
335 return -item;
336
337 switch (item)
338 {
339 case xml::XT_CHARACTERS:
340 case xml::XT_CDATA:
341 case xml::XT_COMMENT:
342 break;
343
344 case xml::XT_START_ELEMENT:
345 {
346 const LSPString *name = p->name();
347
348 if (name->equals_ascii("id"))
349 res = read_int(p, &inst->id);
350 else if (name->equals_ascii("filename"))
351 res = read_string(p, &inst->file_name);
352 else if (name->equals_ascii("name"))
353 res = read_string(p, &inst->name);
354 else if (name->equals_ascii("volume"))
355 res = read_float(p, &inst->volume);
356 else if (name->equals_ascii("isMuted"))
357 res = read_bool(p, &inst->muted);
358 else if (name->equals_ascii("isLocked"))
359 res = read_bool(p, &inst->locked);
360 else if (name->equals_ascii("pan_L"))
361 res = read_float(p, &inst->pan_left);
362 else if (name->equals_ascii("pan_R"))
363 res = read_float(p, &inst->pan_right);
364 else if (name->equals_ascii("randomPitchFactor"))
365 res = read_float(p, &inst->random_pitch_factor);
366 else if (name->equals_ascii("gain"))
367 res = read_float(p, &inst->gain);
368 else if (name->equals_ascii("filterActive"))
369 res = read_bool(p, &inst->filter_active);
370 else if (name->equals_ascii("filterCutoff"))
371 res = read_float(p, &inst->filter_cutoff);
372 else if (name->equals_ascii("filterResonance"))
373 res = read_float(p, &inst->filter_resonance);
374 else if (name->equals_ascii("Attack"))
375 res = read_float(p, &inst->attack);
376 else if (name->equals_ascii("Decay"))
377 res = read_float(p, &inst->decay);
378 else if (name->equals_ascii("Sustain"))
379 res = read_float(p, &inst->sustain);
380 else if (name->equals_ascii("Release"))
381 res = read_float(p, &inst->release);
382 else if (name->equals_ascii("muteGroup"))
383 res = read_int(p, &inst->mute_group);
384 else if (name->equals_ascii("isStopNote"))
385 res = read_bool(p, &inst->stop_note);
386 else if (name->equals_ascii("midiOutChannel"))
387 res = read_int(p, &inst->midi_out_channel);
388 else if (name->equals_ascii("midiOutNote"))
389 res = read_int(p, &inst->midi_out_note);
390 else if (name->equals_ascii("midiInChannel"))
391 res = read_int(p, &inst->midi_in_channel);
392 else if (name->equals_ascii("midiInNote"))
393 res = read_int(p, &inst->midi_in_note);
394 else if (name->equals_ascii("FX1Level"))
395 res = read_float(p, &inst->fx1_level);
396 else if (name->equals_ascii("FX2Level"))
397 res = read_float(p, &inst->fx2_level);
398 else if (name->equals_ascii("FX3Level"))
399 res = read_float(p, &inst->fx3_level);
400 else if (name->equals_ascii("FX4Level"))
401 res = read_float(p, &inst->fx4_level);
402 else if (name->equals_ascii("exclude"))
403 {
404 LSPString tmp;
405 res = read_string(p, &tmp);
406 }
407 else if (name->equals_ascii("layer"))
408 {
409 layer_t *layer = new layer_t();
410 if (layer == NULL)
411 return STATUS_NO_MEM;
412 if (!inst->layers.add(layer))
413 {
414 delete layer;
415 return STATUS_NO_MEM;
416 }
417 res = read_layer(p, layer);
418 }
419 else if (name->equals_ascii("instrumentComponent"))
420 res = read_instrument_component(p, inst);
421 else
422 res = skip_tags(p);
423 break;
424 }
425
426 case xml::XT_END_ELEMENT:
427 return res;
428
429 default:
430 return STATUS_CORRUPTED;
431 }
432 } while (res == STATUS_OK);
433
434 return res;
435 }
436
437 status_t read_instruments(xml::PullParser *p, lltl::parray<instrument_t> *list)
438 {
439 status_t item, res = STATUS_OK;
440
441 do
442 {
443 if ((item = p->read_next()) < 0)
444 return -item;
445
446 switch (item)
447 {
448 case xml::XT_CHARACTERS:
449 case xml::XT_CDATA:
450 case xml::XT_COMMENT:
451 break;
452
453 case xml::XT_START_ELEMENT:
454 {
455 const LSPString *name = p->name();
456 if (name->equals_ascii("instrument"))
457 {
458 instrument_t *inst = new instrument_t();
459 if (inst == NULL)
460 return STATUS_NO_MEM;
461 if (!list->add(inst))
462 {
463 delete inst;
464 return STATUS_NO_MEM;
465 }
466
467 res = read_instrument(p, inst);
468 }
469 else
470 res = skip_tags(p);
471 break;
472 }
473
474 case xml::XT_END_ELEMENT:
475 return res;
476
477 default:
478 return STATUS_CORRUPTED;
479 }
480 } while (res == STATUS_OK);
481
482 return res;
483 }
484
485 status_t read_drumkit(xml::PullParser *p, drumkit_t *dst)
486 {
487 status_t item, res = STATUS_OK;
488
489 do
490 {
491 if ((item = p->read_next()) < 0)
492 return -item;
493
494 switch (item)
495 {
496 case xml::XT_CHARACTERS:
497 case xml::XT_CDATA:
498 case xml::XT_COMMENT:
499 case xml::XT_ATTRIBUTE:
500 break;
501
502 case xml::XT_START_ELEMENT:
503 {
504 const LSPString *name = p->name();
505 if (name->equals_ascii("name"))
506 res = read_string(p, &dst->name);
507 else if (name->equals_ascii("author"))
508 res = read_string(p, &dst->author);
509 else if (name->equals_ascii("info"))
510 res = read_string(p, &dst->info);
511 else if (name->equals_ascii("license"))
512 res = read_string(p, &dst->license);
513 else if (name->equals_ascii("instrumentList"))
514 res = read_instruments(p, &dst->instruments);
515 else
516 res = skip_tags(p);
517 break;
518 }
519
520 case xml::XT_END_ELEMENT:
521 return res;
522
523 default:
524 return STATUS_CORRUPTED;
525 }
526 } while (res == STATUS_OK);
527
528 return res;
529 }
530
531 status_t read_document(xml::PullParser *p, drumkit_t *dst)
532 {
533 status_t item, res = STATUS_OK;
534 bool read = false;
535
536 while (true)
537 {
538 if ((item = p->read_next()) < 0)
539 return -item;
540
541 if (item == xml::XT_END_DOCUMENT)
542 return (read) ? STATUS_OK : STATUS_BAD_FORMAT;
543
544 switch (item)
545 {
546 case xml::XT_END_DOCUMENT:
547 break;
548
549 case xml::XT_CHARACTERS:
550 case xml::XT_CDATA:
551 case xml::XT_COMMENT:
552 case xml::XT_DTD:
553 case xml::XT_START_DOCUMENT:
554 break;
555
556 case xml::XT_START_ELEMENT:
557 if ((read) || (p->name() == NULL) || (!p->name()->equals_ascii("drumkit_info")))
558 return STATUS_BAD_FORMAT;
559
560 if ((res = read_drumkit(p, dst)) != STATUS_OK)
561 return res;
562
563 read = true;
564 break;
565
566 default:
567 return STATUS_BAD_FORMAT;
568 }
569 }
570 }
571
572 status_t load_document(xml::PullParser *p, drumkit_t *dst)
573 {
574 // Load drumkit
575 drumkit_t tmp;
576 status_t res = read_document(p, &tmp);
577
578 // Close document
579 status_t res2 = p->close();
580 if (res == STATUS_OK)
581 res = res2;
582
583 // Update drumkit data on success
584 if (res == STATUS_OK)
585 tmp.swap(dst);
586
587 return res;
588 }
589
590 //---------------------------------------------------------------------
591 status_t load(const char *path, drumkit_t *dst)
592 {
593 if ((path == NULL) || (dst == NULL))
594 return STATUS_BAD_ARGUMENTS;
595
596 xml::PullParser p;
597 status_t res = p.open(path);
598 return (res == STATUS_OK) ? load_document(&p, dst) : res;
599 }
600
601 status_t load(const LSPString *path, drumkit_t *dst)
602 {
603 if ((path == NULL) || (dst == NULL))
604 return STATUS_BAD_ARGUMENTS;
605
606 xml::PullParser p;
607 status_t res = p.open(path);
608 return (res == STATUS_OK) ? load_document(&p, dst) : res;
609 }
610
611 status_t load(const io::Path *path, drumkit_t *dst)
612 {
613 if ((path == NULL) || (dst == NULL))
614 return STATUS_BAD_ARGUMENTS;
615
616 xml::PullParser p;
617 status_t res = p.open(path);
618 return (res == STATUS_OK) ? load_document(&p, dst) : res;
619 }
620
621 status_t load(io::IInStream *is, drumkit_t *dst)
622 {
623 if ((is == NULL) || (dst == NULL))
624 return STATUS_BAD_ARGUMENTS;
625
626 xml::PullParser p;
627 status_t res = p.wrap(is, WRAP_NONE);
628 return (res == STATUS_OK) ? load_document(&p, dst) : res;
629 }
630
631 status_t load(io::IInSequence *is, drumkit_t *dst)
632 {
633 if ((is == NULL) || (dst == NULL))
634 return STATUS_BAD_ARGUMENTS;
635
636 xml::PullParser p;
637 status_t res = p.wrap(is, WRAP_NONE);
638 return (res == STATUS_OK) ? load_document(&p, dst) : res;
639 }
640
641 } /* namespace hydrogen */
642 } /* namespace lsp */
643