?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Cleanup
[carla.git] / source / backend / plugin / CarlaPlugin.cpp
blob6854395b5bd6e0ffc59b1479ccae9478f1871e54
1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
2 // SPDX-License-Identifier: GPL-2.0-or-later
3
4 #include "CarlaPluginInternal.hpp"
5 #include "CarlaEngine.hpp"
6
7 #include "CarlaBackendUtils.hpp"
8 #include "CarlaBase64Utils.hpp"
9 #include "CarlaMathUtils.hpp"
10 #include "CarlaMIDI.h"
11 #include "CarlaPluginUI.hpp"
12 #include "CarlaScopeUtils.hpp"
13 #include "CarlaStringList.hpp"
14
15 #include <ctime>
16
17 #include "water/files/File.h"
18 #include "water/streams/MemoryOutputStream.h"
19 #include "water/xml/XmlDocument.h"
20 #include "water/xml/XmlElement.h"
21
22 using water::CharPointer_UTF8;
23 using water::File;
24 using water::MemoryOutputStream;
25 using water::Result;
26 using water::String;
27 using water::XmlDocument;
28 using water::XmlElement;
29
30 CARLA_BACKEND_START_NAMESPACE
31
32 // -------------------------------------------------------------------------------------------------------------------
33 // Fallback data
34
35 static const ParameterData kParameterDataNull = { PARAMETER_UNKNOWN, 0x0, PARAMETER_NULL, -1, 0, CONTROL_INDEX_NONE, 0.0f, 1.0f, 0x0 };
36 static const ParameterRanges kParameterRangesNull = { 0.0f, 0.0f, 1.0f, 0.01f, 0.0001f, 0.1f };
37 static const MidiProgramData kMidiProgramDataNull = { 0, 0, nullptr };
38
39 static const CustomData kCustomDataFallback = { nullptr, nullptr, nullptr };
40 static /* */ CustomData kCustomDataFallbackNC = { nullptr, nullptr, nullptr };
41 static const PluginPostRtEvent kPluginPostRtEventFallback = { kPluginPostRtEventNull, false, {} };
42
43 // -------------------------------------------------------------------------------------------------------------------
44 // ParamSymbol struct, needed for CarlaPlugin::loadStateSave()
45
46 struct ParamSymbol {
47 int32_t index;
48 const char* symbol;
49
50 ParamSymbol(const uint32_t i, const char* const s)
51 : index(static_cast<int32_t>(i)),
52 symbol(carla_strdup(s)) {}
53
54 ~ParamSymbol() noexcept
55 {
56 CARLA_SAFE_ASSERT_RETURN(symbol != nullptr,)
57
58 delete[] symbol;
59 symbol = nullptr;
60 }
61
62 #ifdef CARLA_PROPER_CPP11_SUPPORT
63 ParamSymbol() = delete;
64 CARLA_DECLARE_NON_COPYABLE(ParamSymbol)
65 #endif
66 };
67
68 // -------------------------------------------------------------------------------------------------------------------
69 // Constructor and destructor
70
71 CarlaPlugin::CarlaPlugin(CarlaEngine* const engine, const uint id)
72 : pData(new ProtectedData(engine, id))
73 {
74 CARLA_SAFE_ASSERT_RETURN(engine != nullptr,);
75 CARLA_SAFE_ASSERT(id < engine->getMaxPluginNumber());
76 carla_debug("CarlaPlugin::CarlaPlugin(%p, %i)", engine, id);
77
78 switch (engine->getProccessMode())
79 {
80 case ENGINE_PROCESS_MODE_SINGLE_CLIENT:
81 case ENGINE_PROCESS_MODE_MULTIPLE_CLIENTS:
82 CARLA_SAFE_ASSERT(id < MAX_DEFAULT_PLUGINS);
83 break;
84
85 case ENGINE_PROCESS_MODE_CONTINUOUS_RACK:
86 CARLA_SAFE_ASSERT(id < MAX_RACK_PLUGINS);
87 break;
88
89 case ENGINE_PROCESS_MODE_PATCHBAY:
90 CARLA_SAFE_ASSERT(id < MAX_PATCHBAY_PLUGINS);
91 break;
92
93 case ENGINE_PROCESS_MODE_BRIDGE:
94 CARLA_SAFE_ASSERT(id == 0);
95 break;
96 }
97 }
98
99 CarlaPlugin::~CarlaPlugin()
100 {
101 carla_debug("CarlaPlugin::~CarlaPlugin()");
102
103 delete pData;
104 }
105
106 // -------------------------------------------------------------------
107 // Information (base)
108
109 uint CarlaPlugin::getId() const noexcept
110 {
111 return pData->id;
112 }
113
114 uint CarlaPlugin::getHints() const noexcept
115 {
116 return pData->hints;
117 }
118
119 uint CarlaPlugin::getOptionsEnabled() const noexcept
120 {
121 return pData->options;
122 }
123
124 bool CarlaPlugin::isEnabled() const noexcept
125 {
126 return pData->enabled;
127 }
128
129 const char* CarlaPlugin::getName() const noexcept
130 {
131 return pData->name;
132 }
133
134 const char* CarlaPlugin::getFilename() const noexcept
135 {
136 return pData->filename;
137 }
138
139 const char* CarlaPlugin::getIconName() const noexcept
140 {
141 return pData->iconName;
142 }
143
144 PluginCategory CarlaPlugin::getCategory() const noexcept
145 {
146 return getPluginCategoryFromName(pData->name);
147 }
148
149 int64_t CarlaPlugin::getUniqueId() const noexcept
150 {
151 return 0;
152 }
153
154 uint32_t CarlaPlugin::getLatencyInFrames() const noexcept
155 {
156 return 0;
157 }
158
159 // -------------------------------------------------------------------
160 // Information (count)
161
162 uint32_t CarlaPlugin::getAudioInCount() const noexcept
163 {
164 return pData->audioIn.count;
165 }
166
167 uint32_t CarlaPlugin::getAudioOutCount() const noexcept
168 {
169 return pData->audioOut.count;
170 }
171
172 uint32_t CarlaPlugin::getCVInCount() const noexcept
173 {
174 return pData->cvIn.count;
175 }
176
177 uint32_t CarlaPlugin::getCVOutCount() const noexcept
178 {
179 return pData->cvOut.count;
180 }
181
182 uint32_t CarlaPlugin::getMidiInCount() const noexcept
183 {
184 return (pData->extraHints & PLUGIN_EXTRA_HINT_HAS_MIDI_IN) ? 1 : 0;
185 }
186
187 uint32_t CarlaPlugin::getMidiOutCount() const noexcept
188 {
189 return (pData->extraHints & PLUGIN_EXTRA_HINT_HAS_MIDI_OUT) ? 1 : 0;
190 }
191
192 uint32_t CarlaPlugin::getParameterCount() const noexcept
193 {
194 return pData->param.count;
195 }
196
197 uint32_t CarlaPlugin::getParameterScalePointCount(const uint32_t parameterId) const noexcept
198 {
199 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, 0);
200 return 0;
201 }
202
203 uint32_t CarlaPlugin::getProgramCount() const noexcept
204 {
205 return pData->prog.count;
206 }
207
208 uint32_t CarlaPlugin::getMidiProgramCount() const noexcept
209 {
210 return pData->midiprog.count;
211 }
212
213 uint32_t CarlaPlugin::getCustomDataCount() const noexcept
214 {
215 return static_cast<uint32_t>(pData->custom.count());
216 }
217
218 // -------------------------------------------------------------------
219 // Information (current data)
220
221 int32_t CarlaPlugin::getCurrentProgram() const noexcept
222 {
223 return pData->prog.current;
224 }
225
226 int32_t CarlaPlugin::getCurrentMidiProgram() const noexcept
227 {
228 return pData->midiprog.current;
229 }
230
231 uint CarlaPlugin::getAudioPortHints(bool, uint32_t) const noexcept
232 {
233 return 0x0;
234 }
235
236 const ParameterData& CarlaPlugin::getParameterData(const uint32_t parameterId) const noexcept
237 {
238 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, kParameterDataNull);
239 return pData->param.data[parameterId];
240 }
241
242 const ParameterRanges& CarlaPlugin::getParameterRanges(const uint32_t parameterId) const noexcept
243 {
244 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, kParameterRangesNull);
245 return pData->param.ranges[parameterId];
246 }
247
248 bool CarlaPlugin::isParameterOutput(const uint32_t parameterId) const noexcept
249 {
250 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
251 return (pData->param.data[parameterId].type == PARAMETER_OUTPUT);
252 }
253
254 const MidiProgramData& CarlaPlugin::getMidiProgramData(const uint32_t index) const noexcept
255 {
256 CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count, kMidiProgramDataNull);
257 return pData->midiprog.data[index];
258 }
259
260 const CustomData& CarlaPlugin::getCustomData(const uint32_t index) const noexcept
261 {
262 return pData->custom.getAt(index, kCustomDataFallback);
263 }
264
265 std::size_t CarlaPlugin::getChunkData(void** const dataPtr) noexcept
266 {
267 CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);
268 CARLA_SAFE_ASSERT(false); // this should never happen
269 return 0;
270 }
271
272 // -------------------------------------------------------------------
273 // Information (per-plugin data)
274
275 uint CarlaPlugin::getOptionsAvailable() const noexcept
276 {
277 CARLA_SAFE_ASSERT(false); // this should never happen
278 return 0x0;
279 }
280
281 float CarlaPlugin::getParameterValue(const uint32_t parameterId) const noexcept
282 {
283 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), 0.0f);
284 CARLA_SAFE_ASSERT(false); // this should never happen
285 return 0.0f;
286 }
287
288 float CarlaPlugin::getParameterScalePointValue(const uint32_t parameterId, const uint32_t scalePointId) const noexcept
289 {
290 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), 0.0f);
291 CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId), 0.0f);
292 CARLA_SAFE_ASSERT(false); // this should never happen
293 return 0.0f;
294 }
295
296 bool CarlaPlugin::getLabel(char* const strBuf) const noexcept
297 {
298 strBuf[0] = '\0';
299 return false;
300 }
301
302 bool CarlaPlugin::getMaker(char* const strBuf) const noexcept
303 {
304 strBuf[0] = '\0';
305 return false;
306 }
307
308 bool CarlaPlugin::getCopyright(char* const strBuf) const noexcept
309 {
310 strBuf[0] = '\0';
311 return false;
312 }
313
314 bool CarlaPlugin::getRealName(char* const strBuf) const noexcept
315 {
316 strBuf[0] = '\0';
317 return false;
318 }
319
320 bool CarlaPlugin::getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept
321 {
322 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
323 CARLA_SAFE_ASSERT(false); // this should never happen
324 strBuf[0] = '\0';
325 return false;
326 }
327
328 bool CarlaPlugin::getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept
329 {
330 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
331 strBuf[0] = '\0';
332 return false;
333 }
334
335 bool CarlaPlugin::getParameterText(const uint32_t parameterId, char* const strBuf) noexcept
336 {
337 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
338 CARLA_SAFE_ASSERT(false); // this should never happen
339 strBuf[0] = '\0';
340 return false;
341 }
342
343 bool CarlaPlugin::getParameterUnit(const uint32_t parameterId, char* const strBuf) const noexcept
344 {
345 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
346 strBuf[0] = '\0';
347 return false;
348 }
349
350 bool CarlaPlugin::getParameterComment(const uint32_t parameterId, char* const strBuf) const noexcept
351 {
352 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
353 strBuf[0] = '\0';
354 return false;
355 }
356
357 bool CarlaPlugin::getParameterGroupName(const uint32_t parameterId, char* const strBuf) const noexcept
358 {
359 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
360 strBuf[0] = '\0';
361 return false;
362 }
363
364 bool CarlaPlugin::getParameterScalePointLabel(const uint32_t parameterId, const uint32_t scalePointId, char* const strBuf) const noexcept
365 {
366 CARLA_SAFE_ASSERT_RETURN(parameterId < getParameterCount(), false);
367 CARLA_SAFE_ASSERT_RETURN(scalePointId < getParameterScalePointCount(parameterId), false);
368 CARLA_SAFE_ASSERT(false); // this should never happen
369 strBuf[0] = '\0';
370 return false;
371 }
372
373 float CarlaPlugin::getInternalParameterValue(const int32_t parameterId) const noexcept
374 {
375 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
376 CARLA_SAFE_ASSERT_RETURN(parameterId != PARAMETER_NULL && parameterId > PARAMETER_MAX, 0.0f);
377
378 switch (parameterId)
379 {
380 case PARAMETER_ACTIVE:
381 return pData->active;
382 case PARAMETER_CTRL_CHANNEL:
383 return pData->ctrlChannel;
384 case PARAMETER_DRYWET:
385 return pData->postProc.dryWet;
386 case PARAMETER_VOLUME:
387 return pData->postProc.volume;
388 case PARAMETER_BALANCE_LEFT:
389 return pData->postProc.balanceLeft;
390 case PARAMETER_BALANCE_RIGHT:
391 return pData->postProc.balanceRight;
392 case PARAMETER_PANNING:
393 return pData->postProc.panning;
394 };
395 #endif
396 CARLA_SAFE_ASSERT_RETURN(parameterId >= 0, 0.0f);
397
398 return getParameterValue(static_cast<uint32_t>(parameterId));
399 }
400
401 bool CarlaPlugin::getProgramName(const uint32_t index, char* const strBuf) const noexcept
402 {
403 CARLA_SAFE_ASSERT_RETURN(index < pData->prog.count, false);
404 CARLA_SAFE_ASSERT_RETURN(pData->prog.names[index] != nullptr, false);
405 std::strncpy(strBuf, pData->prog.names[index], STR_MAX);
406 return true;
407 }
408
409 bool CarlaPlugin::getMidiProgramName(const uint32_t index, char* const strBuf) const noexcept
410 {
411 CARLA_SAFE_ASSERT_RETURN(index < pData->midiprog.count, false);
412 CARLA_SAFE_ASSERT_RETURN(pData->midiprog.data[index].name != nullptr, false);
413 std::strncpy(strBuf, pData->midiprog.data[index].name, STR_MAX);
414 return true;
415 }
416
417 void CarlaPlugin::getParameterCountInfo(uint32_t& ins, uint32_t& outs) const noexcept
418 {
419 ins = 0;
420 outs = 0;
421
422 for (uint32_t i=0; i < pData->param.count; ++i)
423 {
424 if (pData->param.data[i].type == PARAMETER_INPUT)
425 ++ins;
426 else if (pData->param.data[i].type == PARAMETER_OUTPUT)
427 ++outs;
428 }
429 }
430
431 // -------------------------------------------------------------------
432 // Set data (state)
433
434 void CarlaPlugin::prepareForSave(bool)
435 {
436 }
437
438 void CarlaPlugin::resetParameters() noexcept
439 {
440 for (uint i=0; i < pData->param.count; ++i)
441 {
442 const ParameterData& paramData(pData->param.data[i]);
443 const ParameterRanges& paramRanges(pData->param.ranges[i]);
444
445 if (paramData.type != PARAMETER_INPUT)
446 continue;
447 if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)
448 continue;
449
450 setParameterValue(i, paramRanges.def, true, true, true);
451 }
452 }
453
454 void CarlaPlugin::randomizeParameters() noexcept
455 {
456 float value, random;
457
458 char strBuf[STR_MAX+1];
459 strBuf[STR_MAX] = '\0';
460
461 std::srand(static_cast<uint>(std::time(nullptr)));
462
463 for (uint i=0; i < pData->param.count; ++i)
464 {
465 const ParameterData& paramData(pData->param.data[i]);
466
467 if (paramData.type != PARAMETER_INPUT)
468 continue;
469 if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)
470 continue;
471
472 if (! getParameterName(i, strBuf))
473 strBuf[0] = '\0';
474
475 if (std::strstr(strBuf, "olume") != nullptr)
476 continue;
477 if (std::strstr(strBuf, "Master") != nullptr)
478 continue;
479
480 const ParameterRanges& paramRanges(pData->param.ranges[i]);
481
482 if (paramData.hints & PARAMETER_IS_BOOLEAN)
483 {
484 random = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);
485 value = random > 0.5f ? paramRanges.max : paramRanges.min;
486 }
487 else
488 {
489 random = static_cast<float>(std::rand()) / static_cast<float>(RAND_MAX);
490 value = random * (paramRanges.max - paramRanges.min) + paramRanges.min;
491
492 if (paramData.hints & PARAMETER_IS_INTEGER)
493 value = std::rint(value);
494 }
495
496 setParameterValue(i, value, true, true, true);
497 }
498 }
499
500 const CarlaStateSave& CarlaPlugin::getStateSave(const bool callPrepareForSave)
501 {
502 pData->stateSave.clear();
503
504 if (callPrepareForSave)
505 {
506 pData->stateSave.temporary = true;
507 prepareForSave(true);
508 }
509
510 const PluginType pluginType = getType();
511
512 char strBuf[STR_MAX+1];
513 carla_zeroChars(strBuf, STR_MAX+1);
514
515 // ---------------------------------------------------------------
516 // Basic info
517
518 if (! getLabel(strBuf))
519 strBuf[0] = '\0';
520
521 pData->stateSave.type = carla_strdup(getPluginTypeAsString(pluginType));
522 pData->stateSave.name = carla_strdup(pData->name);
523 pData->stateSave.label = carla_strdup(strBuf);
524 pData->stateSave.uniqueId = getUniqueId();
525 // #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
526 pData->stateSave.options = pData->options;
527 // #endif
528
529 if (pData->filename != nullptr)
530 pData->stateSave.binary = carla_strdup(pData->filename);
531
532 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
533 // ---------------------------------------------------------------
534 // Internals
535
536 pData->stateSave.active = pData->active;
537 pData->stateSave.dryWet = pData->postProc.dryWet;
538 pData->stateSave.volume = pData->postProc.volume;
539 pData->stateSave.balanceLeft = pData->postProc.balanceLeft;
540 pData->stateSave.balanceRight = pData->postProc.balanceRight;
541 pData->stateSave.panning = pData->postProc.panning;
542 pData->stateSave.ctrlChannel = pData->ctrlChannel;
543 #endif
544
545 if (pData->hints & PLUGIN_IS_BRIDGE)
546 waitForBridgeSaveSignal();
547
548 // ---------------------------------------------------------------
549 // Chunk
550
551 bool usingChunk = false;
552
553 if (pData->options & PLUGIN_OPTION_USE_CHUNKS)
554 {
555 void* data = nullptr;
556 const std::size_t dataSize = getChunkData(&data);
557
558 if (data != nullptr && dataSize > 0)
559 {
560 pData->stateSave.chunk = CarlaString::asBase64(data, dataSize).dup();
561
562 if (pluginType != PLUGIN_INTERNAL && pluginType != PLUGIN_JSFX)
563 usingChunk = true;
564 }
565 }
566
567 // ---------------------------------------------------------------
568 // Current Program
569
570 if (pData->prog.current >= 0 && pluginType != PLUGIN_LV2)
571 {
572 pData->stateSave.currentProgramIndex = pData->prog.current;
573 pData->stateSave.currentProgramName = carla_strdup(pData->prog.names[pData->prog.current]);
574 }
575
576 // ---------------------------------------------------------------
577 // Current MIDI Program
578
579 if (pData->midiprog.current >= 0 && pluginType != PLUGIN_LV2 && pluginType != PLUGIN_SF2)
580 {
581 const MidiProgramData& mpData(pData->midiprog.getCurrent());
582
583 pData->stateSave.currentMidiBank = static_cast<int32_t>(mpData.bank);
584 pData->stateSave.currentMidiProgram = static_cast<int32_t>(mpData.program);
585 }
586
587 // ---------------------------------------------------------------
588 // Parameters
589
590 const float sampleRate = static_cast<float>(pData->engine->getSampleRate());
591
592 for (uint32_t i=0; i < pData->param.count; ++i)
593 {
594 const ParameterData& paramData(pData->param.data[i]);
595
596 if ((paramData.hints & PARAMETER_IS_ENABLED) == 0)
597 continue;
598 if (paramData.hints & PARAMETER_IS_NOT_SAVED)
599 continue;
600
601 const bool dummy = paramData.type != PARAMETER_INPUT || usingChunk;
602
603 if (dummy && paramData.mappedControlIndex <= CONTROL_INDEX_NONE)
604 continue;
605
606 CarlaStateSave::Parameter* const stateParameter(new CarlaStateSave::Parameter());
607
608 stateParameter->dummy = dummy;
609 stateParameter->index = paramData.index;
610 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
611 if (paramData.mappedControlIndex != CONTROL_INDEX_MIDI_LEARN)
612 {
613 stateParameter->mappedControlIndex = paramData.mappedControlIndex;
614 stateParameter->midiChannel = paramData.midiChannel;
615
616 if (paramData.hints & PARAMETER_MAPPED_RANGES_SET)
617 {
618 stateParameter->mappedMinimum = paramData.mappedMinimum;
619 stateParameter->mappedMaximum = paramData.mappedMaximum;
620 stateParameter->mappedRangeValid = true;
621
622 if (paramData.hints & PARAMETER_USES_SAMPLERATE)
623 {
624 stateParameter->mappedMinimum /= sampleRate;
625 stateParameter->mappedMaximum /= sampleRate;
626 }
627 }
628 }
629 #endif
630
631 if (! getParameterName(i, strBuf))
632 strBuf[0] = '\0';
633 stateParameter->name = carla_strdup(strBuf);
634
635 if (! getParameterSymbol(i, strBuf))
636 strBuf[0] = '\0';
637 stateParameter->symbol = carla_strdup(strBuf);;
638
639 if (! dummy)
640 {
641 stateParameter->value = getParameterValue(i);
642
643 if (paramData.hints & PARAMETER_USES_SAMPLERATE)
644 stateParameter->value /= sampleRate;
645 }
646
647 pData->stateSave.parameters.append(stateParameter);
648 }
649
650 // ---------------------------------------------------------------
651 // Custom Data
652
653 for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())
654 {
655 const CustomData& cData(it.getValue(kCustomDataFallback));
656 CARLA_SAFE_ASSERT_CONTINUE(cData.isValid());
657
658 CarlaStateSave::CustomData* stateCustomData(new CarlaStateSave::CustomData());
659
660 stateCustomData->type = carla_strdup(cData.type);
661 stateCustomData->key = carla_strdup(cData.key);
662 stateCustomData->value = carla_strdup(cData.value);
663
664 pData->stateSave.customData.append(stateCustomData);
665 }
666
667 return pData->stateSave;
668 }
669
670 void CarlaPlugin::loadStateSave(const CarlaStateSave& stateSave)
671 {
672 const bool usesMultiProgs = pData->hints & PLUGIN_USES_MULTI_PROGS;
673 const PluginType pluginType = getType();
674
675 char strBuf[STR_MAX+1];
676 carla_zeroChars(strBuf, STR_MAX+1);
677
678 // ---------------------------------------------------------------
679 // Part 1 - PRE-set custom data (only those which reload programs)
680
681 for (CarlaStateSave::CustomDataItenerator it = stateSave.customData.begin2(); it.valid(); it.next())
682 {
683 const CarlaStateSave::CustomData* const stateCustomData(it.getValue(nullptr));
684 CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);
685 CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->isValid());
686
687 const char* const key(stateCustomData->key);
688
689 /**/ if (pluginType == PLUGIN_DSSI && (std::strcmp (key, "reloadprograms") == 0 ||
690 std::strcmp (key, "load" ) == 0 ||
691 std::strncmp(key, "patches", 7) == 0 ))
692 pass();
693 else if (usesMultiProgs && std::strcmp(key, "midiPrograms") == 0)
694 pass();
695 else
696 continue;
697
698 setCustomData(stateCustomData->type, key, stateCustomData->value, true);
699 }
700
701 // ---------------------------------------------------------------
702 // Part 2 - set program
703
704 if (stateSave.currentProgramIndex >= 0 && stateSave.currentProgramName != nullptr)
705 {
706 int32_t programId = -1;
707
708 // index < count
709 if (stateSave.currentProgramIndex < static_cast<int32_t>(pData->prog.count))
710 {
711 programId = stateSave.currentProgramIndex;
712 }
713 // index not valid, try to find by name
714 else
715 {
716 for (uint32_t i=0; i < pData->prog.count; ++i)
717 {
718 if (getProgramName(i, strBuf) && std::strcmp(stateSave.currentProgramName, strBuf) == 0)
719 {
720 programId = static_cast<int32_t>(i);
721 break;
722 }
723 }
724 }
725
726 // set program now, if valid
727 if (programId >= 0)
728 setProgram(programId, true, true, true);
729 }
730
731 // ---------------------------------------------------------------
732 // Part 3 - set midi program
733
734 if (stateSave.currentMidiBank >= 0 && stateSave.currentMidiProgram >= 0 && ! usesMultiProgs)
735 setMidiProgramById(static_cast<uint32_t>(stateSave.currentMidiBank), static_cast<uint32_t>(stateSave.currentMidiProgram), true, true, true);
736
737 // ---------------------------------------------------------------
738 // Part 4a - get plugin parameter symbols
739
740 LinkedList<ParamSymbol*> paramSymbols;
741
742 if (pluginType == PLUGIN_LADSPA || pluginType == PLUGIN_LV2 || pluginType == PLUGIN_CLAP)
743 {
744 for (uint32_t i=0; i < pData->param.count; ++i)
745 {
746 if (pData->param.data[i].hints & PARAMETER_IS_NOT_SAVED)
747 continue;
748
749 if (getParameterSymbol(i, strBuf))
750 {
751 ParamSymbol* const paramSymbol(new ParamSymbol(i, strBuf));
752 paramSymbols.append(paramSymbol);
753 }
754 }
755 }
756
757 // ---------------------------------------------------------------
758 // Part 4b - set parameter values (carefully)
759
760 const float sampleRate = static_cast<float>(pData->engine->getSampleRate());
761
762 for (CarlaStateSave::ParameterItenerator it = stateSave.parameters.begin2(); it.valid(); it.next())
763 {
764 CarlaStateSave::Parameter* const stateParameter(it.getValue(nullptr));
765 CARLA_SAFE_ASSERT_CONTINUE(stateParameter != nullptr);
766
767 int32_t index = -1;
768
769 if (pluginType == PLUGIN_LADSPA)
770 {
771 // Try to set by symbol, otherwise use index
772 if (stateParameter->symbol != nullptr && stateParameter->symbol[0] != '\0')
773 {
774 for (LinkedList<ParamSymbol*>::Itenerator it2 = paramSymbols.begin2(); it2.valid(); it2.next())
775 {
776 ParamSymbol* const paramSymbol(it2.getValue(nullptr));
777 CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);
778 CARLA_SAFE_ASSERT_CONTINUE(paramSymbol->symbol != nullptr);
779
780 if (std::strcmp(stateParameter->symbol, paramSymbol->symbol) == 0)
781 {
782 index = paramSymbol->index;
783 break;
784 }
785 }
786 if (index == -1)
787 index = stateParameter->index;
788 }
789 else
790 {
791 index = stateParameter->index;
792 }
793 }
794 else if (pluginType == PLUGIN_LV2 || pluginType == PLUGIN_CLAP)
795 {
796 // Symbol only
797 if (stateParameter->symbol != nullptr && stateParameter->symbol[0] != '\0')
798 {
799 for (LinkedList<ParamSymbol*>::Itenerator it2 = paramSymbols.begin2(); it2.valid(); it2.next())
800 {
801 ParamSymbol* const paramSymbol(it2.getValue(nullptr));
802 CARLA_SAFE_ASSERT_CONTINUE(paramSymbol != nullptr);
803 CARLA_SAFE_ASSERT_CONTINUE(paramSymbol->symbol != nullptr);
804
805 if (std::strcmp(stateParameter->symbol, paramSymbol->symbol) == 0)
806 {
807 index = paramSymbol->index;
808 break;
809 }
810 }
811 if (index == -1)
812 {
813 if (pluginType == PLUGIN_LV2)
814 carla_stderr("Failed to find LV2 parameter symbol '%s' for '%s'",
815 stateParameter->symbol, pData->name);
816 else
817 carla_stderr("Failed to find CLAP parameter id '%s' for '%s'",
818 stateParameter->symbol, pData->name);
819 }
820 }
821 else
822 {
823 if (pluginType == PLUGIN_LV2)
824 carla_stderr("LV2 Plugin parameter '%s' has no symbol", stateParameter->name);
825 else
826 carla_stderr("CLAP Plugin parameter '%s' has no id", stateParameter->name);
827 }
828 }
829 else
830 {
831 // Index only
832 index = stateParameter->index;
833 }
834
835 // Now set parameter
836 if (index >= 0 && index < static_cast<int32_t>(pData->param.count))
837 {
838 //CARLA_SAFE_ASSERT(stateParameter->isInput == (pData
839
840 if (! stateParameter->dummy)
841 {
842 if (pData->param.data[index].hints & PARAMETER_USES_SAMPLERATE)
843 stateParameter->value *= sampleRate;
844
845 setParameterValue(static_cast<uint32_t>(index), stateParameter->value, true, true, true);
846 }
847
848 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
849 if (stateParameter->mappedRangeValid)
850 {
851 if (pData->param.data[index].hints & PARAMETER_USES_SAMPLERATE)
852 {
853 stateParameter->mappedMinimum *= sampleRate;
854 stateParameter->mappedMaximum *= sampleRate;
855 }
856
857 setParameterMappedRange(static_cast<uint32_t>(index),
858 stateParameter->mappedMinimum,
859 stateParameter->mappedMaximum, true, true);
860 }
861
862 setParameterMappedControlIndex(static_cast<uint32_t>(index),
863 stateParameter->mappedControlIndex, true, true, false);
864 setParameterMidiChannel(static_cast<uint32_t>(index), stateParameter->midiChannel, true, true);
865 #endif
866 }
867 else
868 carla_stderr("Could not set parameter '%s' value for '%s'",
869 stateParameter->name, pData->name);
870 }
871
872 // ---------------------------------------------------------------
873 // Part 4c - clear
874
875 for (LinkedList<ParamSymbol*>::Itenerator it = paramSymbols.begin2(); it.valid(); it.next())
876 {
877 ParamSymbol* const paramSymbol(it.getValue(nullptr));
878 delete paramSymbol;
879 }
880
881 paramSymbols.clear();
882
883 // ---------------------------------------------------------------
884 // Part 5 - set custom data
885
886 for (CarlaStateSave::CustomDataItenerator it = stateSave.customData.begin2(); it.valid(); it.next())
887 {
888 const CarlaStateSave::CustomData* const stateCustomData(it.getValue(nullptr));
889 CARLA_SAFE_ASSERT_CONTINUE(stateCustomData != nullptr);
890 CARLA_SAFE_ASSERT_CONTINUE(stateCustomData->isValid());
891
892 const char* const key(stateCustomData->key);
893
894 if (pluginType == PLUGIN_DSSI && (std::strcmp (key, "reloadprograms") == 0 ||
895 std::strcmp (key, "load" ) == 0 ||
896 std::strncmp(key, "patches", 7) == 0 ))
897 continue;
898 if (usesMultiProgs && std::strcmp(key, "midiPrograms") == 0)
899 continue;
900
901 setCustomData(stateCustomData->type, key, stateCustomData->value, true);
902 }
903
904 // ---------------------------------------------------------------
905 // Part 5x - set lv2 state
906
907 if (pluginType == PLUGIN_LV2)
908 {
909 for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())
910 {
911 const CustomData& customData(it.getValue(kCustomDataFallback));
912 CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());
913
914 if (std::strcmp(customData.type, CUSTOM_DATA_TYPE_PROPERTY) == 0)
915 continue;
916
917 restoreLV2State(stateSave.temporary);
918 break;
919 }
920 }
921
922 // ---------------------------------------------------------------
923 // Part 6 - set chunk
924
925 if (stateSave.chunk != nullptr && (pData->options & PLUGIN_OPTION_USE_CHUNKS) != 0)
926 {
927 std::vector<uint8_t> chunk(carla_getChunkFromBase64String(stateSave.chunk));
928 #ifdef CARLA_PROPER_CPP11_SUPPORT
929 setChunkData(chunk.data(), chunk.size());
930 #else
931 setChunkData(&chunk.front(), chunk.size());
932 #endif
933 }
934
935 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
936 // ---------------------------------------------------------------
937 // Part 6 - set internal stuff
938
939 const uint availOptions = getOptionsAvailable();
940
941 for (uint i=0; i<10; ++i) // FIXME - get this value somehow...
942 {
943 const uint option(1u << i);
944
945 if (availOptions & option)
946 setOption(option, (stateSave.options & option) != 0, true);
947 }
948
949 setDryWet(stateSave.dryWet, true, true);
950 setVolume(stateSave.volume, true, true);
951 setBalanceLeft(stateSave.balanceLeft, true, true);
952 setBalanceRight(stateSave.balanceRight, true, true);
953 setPanning(stateSave.panning, true, true);
954 setCtrlChannel(stateSave.ctrlChannel, true, true);
955 setActive(stateSave.active, true, true);
956
957 if (! pData->engine->isLoadingProject())
958 pData->engine->callback(true, true, ENGINE_CALLBACK_UPDATE, pData->id, 0, 0, 0, 0.0f, nullptr);
959 #endif
960 }
961
962 bool CarlaPlugin::saveStateToFile(const char* const filename)
963 {
964 CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);
965 carla_debug("CarlaPlugin::saveStateToFile(\"%s\")", filename);
966
967 MemoryOutputStream out, streamState;
968 getStateSave().dumpToMemoryStream(streamState);
969
970 out << "<?xml version='1.0' encoding='UTF-8'?>\n";
971 out << "<!DOCTYPE CARLA-PRESET>\n";
972 out << "<CARLA-PRESET VERSION='2.0'>\n";
973 out << streamState;
974 out << "</CARLA-PRESET>\n";
975
976 File file(filename);
977
978 if (file.replaceWithData(out.getData(), out.getDataSize()))
979 return true;
980
981 pData->engine->setLastError("Failed to write file");
982 return false;
983 }
984
985 bool CarlaPlugin::loadStateFromFile(const char* const filename)
986 {
987 // TODO set errors
988
989 CARLA_SAFE_ASSERT_RETURN(filename != nullptr && filename[0] != '\0', false);
990 carla_debug("CarlaPlugin::loadStateFromFile(\"%s\")", filename);
991
992 File file(filename);
993 CARLA_SAFE_ASSERT_RETURN(file.existsAsFile(), false);
994
995 XmlDocument xml(file);
996 CarlaScopedPointer<XmlElement> xmlElement(xml.getDocumentElement(true));
997 CARLA_SAFE_ASSERT_RETURN(xmlElement != nullptr, false);
998 CARLA_SAFE_ASSERT_RETURN(xmlElement->getTagName().equalsIgnoreCase("carla-preset"), false);
999
1000 // completely load file
1001 xmlElement = xml.getDocumentElement(false);
1002 CARLA_SAFE_ASSERT_RETURN(xmlElement != nullptr, false);
1003
1004 if (pData->stateSave.fillFromXmlElement(xmlElement))
1005 {
1006 loadStateSave(pData->stateSave);
1007 return true;
1008 }
1009
1010 return false;
1011 }
1012
1013 #ifndef CARLA_PLUGIN_ONLY_BRIDGE
1014 bool CarlaPlugin::exportAsLV2(const char* const lv2path)
1015 {
1016 CARLA_SAFE_ASSERT_RETURN(lv2path != nullptr && lv2path[0] != '\0', false);
1017 carla_debug("CarlaPlugin::exportAsLV2(\"%s\")", lv2path);
1018
1019 CarlaString bundlepath(lv2path);
1020
1021 if (! bundlepath.endsWith(".lv2"))
1022 bundlepath += ".lv2";
1023
1024 const File bundlefolder(bundlepath.buffer());
1025
1026 if (bundlefolder.existsAsFile())
1027 {
1028 pData->engine->setLastError("Requested filename already exists as file, use a folder instead");
1029 return false;
1030 }
1031
1032 if (! bundlefolder.exists())
1033 {
1034 const Result res(bundlefolder.createDirectory());
1035
1036 if (res.failed())
1037 {
1038 pData->engine->setLastError(res.getErrorMessage().c_str());
1039 return false;
1040 }
1041 }
1042
1043 CarlaString symbol(pData->name);
1044 symbol.toBasic();
1045
1046 {
1047 const CarlaString pluginFilename(bundlepath + CARLA_OS_SEP_STR + symbol + ".xml");
1048
1049 if (! saveStateToFile(pluginFilename))
1050 return false;
1051 }
1052
1053 {
1054 MemoryOutputStream manifestStream;
1055
1056 manifestStream << "@prefix lv2: <http://lv2plug.in/ns/lv2core#> .\n";
1057 manifestStream << "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";
1058 manifestStream << "@prefix ui: <http://lv2plug.in/ns/extensions/ui#> .\n";
1059 manifestStream << "\n";
1060 manifestStream << "<" << symbol.buffer() << ".ttl>\n";
1061 manifestStream << " a lv2:Plugin ;\n";
1062 manifestStream << " lv2:binary <" << symbol.buffer() << CARLA_LIB_EXT "> ;\n";
1063 manifestStream << " rdfs:seeAlso <" << symbol.buffer() << ".ttl> .\n";
1064 manifestStream << "\n";
1065 manifestStream << "<ext-ui>\n";
1066 manifestStream << " a <http://kxstudio.sf.net/ns/lv2ext/external-ui#Widget> ;\n";
1067 manifestStream << " ui:binary <" << symbol.buffer() << CARLA_LIB_EXT "> ;\n";
1068 manifestStream << " lv2:extensionData <http://lv2plug.in/ns/extensions/ui#idleInterface> ,\n";
1069 manifestStream << " <http://lv2plug.in/ns/extensions/ui#showInterface> ;\n";
1070 manifestStream << " lv2:requiredFeature <http://lv2plug.in/ns/ext/instance-access> .\n";
1071 manifestStream << "\n";
1072
1073 const CarlaString manifestFilename(bundlepath + CARLA_OS_SEP_STR "manifest.ttl");
1074 const File manifestFile(manifestFilename.buffer());
1075
1076 if (! manifestFile.replaceWithData(manifestStream.getData(), manifestStream.getDataSize()))
1077 {
1078 pData->engine->setLastError("Failed to write manifest.ttl file");
1079 return false;
1080 }
1081 }
1082
1083 {
1084 MemoryOutputStream mainStream;
1085
1086 mainStream << "@prefix atom: <http://lv2plug.in/ns/ext/atom#> .\n";
1087 mainStream << "@prefix doap: <http://usefulinc.com/ns/doap#> .\n";
1088 mainStream << "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n";
1089 mainStream << "@prefix lv2: <http://lv2plug.in/ns/lv2core#> .\n";
1090 mainStream << "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n";
1091 mainStream << "@prefix ui: <http://lv2plug.in/ns/extensions/ui#> .\n";
1092 mainStream << "\n";
1093 mainStream << "<>\n";
1094 mainStream << " a lv2:Plugin ;\n";
1095 mainStream << "\n";
1096 mainStream << " lv2:requiredFeature <http://lv2plug.in/ns/ext/buf-size#boundedBlockLength> ,\n";
1097 mainStream << " <http://lv2plug.in/ns/ext/options#options> ,\n";
1098 mainStream << " <http://lv2plug.in/ns/ext/urid#map> ;\n";
1099 mainStream << "\n";
1100
1101 if (pData->hints & PLUGIN_HAS_CUSTOM_UI)
1102 {
1103 mainStream << " ui:ui <ext-ui> ;\n";
1104 mainStream << "\n";
1105 }
1106
1107 const uint32_t midiIns = getMidiInCount();
1108 const uint32_t midiOuts = getMidiOutCount();
1109
1110 int portIndex = 0;
1111
1112 if (midiIns > 0)
1113 {
1114 mainStream << " lv2:port [\n";
1115 mainStream << " a lv2:InputPort, atom:AtomPort ;\n";
1116 mainStream << " lv2:index 0 ;\n";
1117 mainStream << " lv2:symbol \"clv2_events_in\" ;\n";
1118 mainStream << " lv2:name \"Events Input\" ;\n";
1119 mainStream << " atom:bufferType atom:Sequence ;\n";
1120 mainStream << " atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ,\n";
1121 mainStream << " <http://lv2plug.in/ns/ext/time#Position> ;\n";
1122 mainStream << " ] ;\n";
1123 ++portIndex;
1124
1125 for (uint32_t i=1; i<midiIns; ++i)
1126 {
1127 const String portIndexNum(portIndex++);
1128 const String portIndexLabel(portIndex);
1129
1130 mainStream << " lv2:port [\n";
1131 mainStream << " a lv2:InputPort, atom:AtomPort ;\n";
1132 mainStream << " lv2:index " << portIndexNum << " ;\n";
1133 mainStream << " lv2:symbol \"clv2_midi_in_" << portIndexLabel << "\" ;\n";
1134 mainStream << " lv2:name \"MIDI Input " << portIndexLabel << "\" ;\n";
1135 mainStream << " ] ;\n";
1136 }
1137 }
1138 else
1139 {
1140 mainStream << " lv2:port [\n";
1141 mainStream << " a lv2:InputPort, atom:AtomPort ;\n";
1142 mainStream << " lv2:index 0 ;\n";
1143 mainStream << " lv2:symbol \"clv2_time_info\" ;\n";
1144 mainStream << " lv2:name \"Time Info\" ;\n";
1145 mainStream << " atom:bufferType atom:Sequence ;\n";
1146 mainStream << " atom:supports <http://lv2plug.in/ns/ext/time#Position> ;\n";
1147 mainStream << " ] ;\n";
1148 ++portIndex;
1149 }
1150
1151 for (uint32_t i=0; i<midiOuts; ++i)
1152 {
1153 const String portIndexNum(portIndex++);
1154 const String portIndexLabel(portIndex);
1155
1156 mainStream << " lv2:port [\n";
1157 mainStream << " a lv2:InputPort, atom:AtomPort ;\n";
1158 mainStream << " lv2:index " << portIndexNum << " ;\n";
1159 mainStream << " lv2:symbol \"clv2_midi_out_" << portIndexLabel << "\" ;\n";
1160 mainStream << " lv2:name \"MIDI Output " << portIndexLabel << "\" ;\n";
1161 mainStream << " atom:bufferType atom:Sequence ;\n";
1162 mainStream << " atom:supports <http://lv2plug.in/ns/ext/midi#MidiEvent> ;\n";
1163 mainStream << " ] ;\n";
1164 }
1165
1166 mainStream << " lv2:port [\n";
1167 mainStream << " a lv2:InputPort, lv2:ControlPort ;\n";
1168 mainStream << " lv2:index " << String(portIndex++) << " ;\n";
1169 mainStream << " lv2:name \"freewheel\" ;\n";
1170 mainStream << " lv2:symbol \"clv2_freewheel\" ;\n";
1171 mainStream << " lv2:default 0 ;\n";
1172 mainStream << " lv2:minimum 0 ;\n";
1173 mainStream << " lv2:maximum 1 ;\n";
1174 mainStream << " lv2:designation lv2:freeWheeling ;\n";
1175 mainStream << " lv2:portProperty lv2:toggled , lv2:integer ;\n";
1176 mainStream << " lv2:portProperty <http://lv2plug.in/ns/ext/port-props#notOnGUI> ;\n";
1177 mainStream << " ] ;\n";
1178
1179 for (uint32_t i=0; i<pData->audioIn.count; ++i)
1180 {
1181 const String portIndexNum(portIndex++);
1182 const String portIndexLabel(i+1);
1183
1184 mainStream << " lv2:port [\n";
1185 mainStream << " a lv2:InputPort, lv2:AudioPort ;\n";
1186 mainStream << " lv2:index " << portIndexNum << " ;\n";
1187 mainStream << " lv2:symbol \"clv2_audio_in_" << portIndexLabel << "\" ;\n";
1188 mainStream << " lv2:name \"Audio Input " << portIndexLabel << "\" ;\n";
1189 mainStream << " ] ;\n";
1190 }
1191
1192 for (uint32_t i=0; i<pData->audioOut.count; ++i)
1193 {
1194 const String portIndexNum(portIndex++);
1195 const String portIndexLabel(i+1);
1196
1197 mainStream << " lv2:port [\n";
1198 mainStream << " a lv2:OutputPort, lv2:AudioPort ;\n";
1199 mainStream << " lv2:index " << portIndexNum << " ;\n";
1200 mainStream << " lv2:symbol \"clv2_audio_out_" << portIndexLabel << "\" ;\n";
1201 mainStream << " lv2:name \"Audio Output " << portIndexLabel << "\" ;\n";
1202 mainStream << " ] ;\n";
1203 }
1204
1205 CarlaStringList uniqueSymbolNames;
1206
1207 char strBufName[STR_MAX+1];
1208 char strBufSymbol[STR_MAX+1];
1209 carla_zeroChars(strBufName, STR_MAX+1);
1210 carla_zeroChars(strBufSymbol, STR_MAX+1);
1211
1212 for (uint32_t i=0; i<pData->param.count; ++i)
1213 {
1214 const ParameterData& paramData(pData->param.data[i]);
1215 const ParameterRanges& paramRanges(pData->param.ranges[i]);
1216
1217 const String portIndexNum(portIndex++);
1218
1219 mainStream << " lv2:port [\n";
1220
1221 if (paramData.type == PARAMETER_INPUT)
1222 mainStream << " a lv2:InputPort, lv2:ControlPort ;\n";
1223 else
1224 mainStream << " a lv2:OutputPort, lv2:ControlPort ;\n";
1225
1226 if (paramData.hints & PARAMETER_IS_BOOLEAN)
1227 mainStream << " lv2:portProperty lv2:toggled ;\n";
1228
1229 if (paramData.hints & PARAMETER_IS_INTEGER)
1230 mainStream << " lv2:portProperty lv2:integer ;\n";
1231
1232 // TODO logarithmic, enabled (not on gui), automatable, samplerate, scalepoints
1233
1234 if (! getParameterName(i, strBufName))
1235 strBufName[0] = '\0';
1236 if (! getParameterSymbol(i, strBufSymbol))
1237 strBufSymbol[0] = '\0';
1238
1239 if (strBufSymbol[0] == '\0')
1240 {
1241 CarlaString s(strBufName);
1242 s.toBasic();
1243 std::memcpy(strBufSymbol, s.buffer(), s.length()+1);
1244
1245 if (strBufSymbol[0] >= '0' && strBufSymbol[0] <= '9')
1246 {
1247 const size_t len(std::strlen(strBufSymbol));
1248 std::memmove(strBufSymbol+1, strBufSymbol, len);
1249 strBufSymbol[0] = '_';
1250 strBufSymbol[len+1] = '\0';
1251 }
1252 }
1253
1254 if (uniqueSymbolNames.contains(strBufSymbol))
1255 std::snprintf(strBufSymbol, STR_MAX, "clv2_param_%d", i+1);
1256
1257 mainStream << " lv2:index " << portIndexNum << " ;\n";
1258 mainStream << " lv2:symbol \"" << strBufSymbol << "\" ;\n";
1259 mainStream << " lv2:name \"\"\"" << strBufName << "\"\"\" ;\n";
1260 mainStream << " lv2:default " << String(paramRanges.def) << " ;\n";
1261 mainStream << " lv2:minimum " << String(paramRanges.min) << " ;\n";
1262 mainStream << " lv2:maximum " << String(paramRanges.max) << " ;\n";
1263
1264 // TODO midiCC, midiChannel
1265
1266 mainStream << " ] ;\n";
1267 }
1268
1269 char strBuf[STR_MAX+1];
1270 carla_zeroChars(strBuf, STR_MAX+1);
1271
1272 if (! getMaker(strBuf))
1273 strBuf[0] = '\0';
1274
1275 mainStream << " rdfs:comment \"Plugin generated using Carla LV2 export.\" ;\n";
1276 mainStream << " doap:name \"\"\"" << getName() << "\"\"\" ;\n";
1277 mainStream << " doap:maintainer [ foaf:name \"\"\"" << strBuf << "\"\"\" ] .\n";
1278 mainStream << "\n";
1279
1280 const CarlaString mainFilename(bundlepath + CARLA_OS_SEP_STR + symbol + ".ttl");
1281 const File mainFile(mainFilename.buffer());
1282
1283 if (! mainFile.replaceWithData(mainStream.getData(), mainStream.getDataSize()))
1284 {
1285 pData->engine->setLastError("Failed to write main plugin ttl file");
1286 return false;
1287 }
1288 }
1289
1290 const CarlaString binaryFilename(bundlepath + CARLA_OS_SEP_STR + symbol + CARLA_LIB_EXT);
1291
1292 const File binaryFileSource(File::getSpecialLocation(File::currentExecutableFile).getSiblingFile("carla-bridge-lv2" CARLA_LIB_EXT));
1293 const File binaryFileTarget(binaryFilename.buffer());
1294
1295 const EngineOptions& opts(pData->engine->getOptions());
1296
1297 const CarlaString binFolderTarget(bundlepath + CARLA_OS_SEP_STR + "bin");
1298 const CarlaString resFolderTarget(bundlepath + CARLA_OS_SEP_STR + "res");
1299
1300 if (! binaryFileSource.copyFileTo(binaryFileTarget))
1301 {
1302 pData->engine->setLastError("Failed to copy plugin binary");
1303 return false;
1304 }
1305
1306 #ifdef CARLA_OS_WIN
1307 File(opts.resourceDir).copyDirectoryTo(File(resFolderTarget.buffer()));
1308
1309 // Copying all the binaries is pointless, just go through the expected needed bits
1310 const File binFolder1(opts.binaryDir);
1311 const File binFolder2(binFolderTarget.buffer());
1312 binFolder2.createDirectory();
1313
1314 static const char* files[] = {
1315 "carla-bridge-native.exe",
1316 "carla-bridge-win32.exe",
1317 "carla-discovery-win32.exe",
1318 "carla-discovery-win64.exe",
1319 "libcarla_utils.dll"
1320 };
1321
1322 for (int i=0; i<5; ++i)
1323 binFolder1.getChildFile(files[i]).copyFileTo(binFolder2.getChildFile(files[i]));;
1324 #else
1325 File(opts.binaryDir).createSymbolicLink(File(binFolderTarget.buffer()), true);
1326 File(opts.resourceDir).createSymbolicLink(File(resFolderTarget.buffer()), true);
1327 #endif
1328
1329 return true;
1330 }
1331 #endif
1332
1333 // -------------------------------------------------------------------
1334 // Set data (internal stuff)
1335
1336 void CarlaPlugin::setId(const uint newId) noexcept
1337 {
1338 pData->id = newId;
1339 }
1340
1341 void CarlaPlugin::setName(const char* const newName)
1342 {
1343 CARLA_SAFE_ASSERT_RETURN(newName != nullptr && newName[0] != '\0',);
1344
1345 if (pData->name != nullptr)
1346 delete[] pData->name;
1347
1348 pData->name = carla_strdup(newName);
1349 }
1350
1351 void CarlaPlugin::setOption(const uint option, const bool yesNo, const bool sendCallback)
1352 {
1353 CARLA_SAFE_ASSERT_UINT2_RETURN(getOptionsAvailable() & option, getOptionsAvailable(), option,);
1354
1355 if (yesNo)
1356 pData->options |= option;
1357 else
1358 pData->options &= ~option;
1359
1360 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1361 if (sendCallback)
1362 pData->engine->callback(true, true,
1363 ENGINE_CALLBACK_OPTION_CHANGED,
1364 pData->id,
1365 static_cast<int>(option),
1366 yesNo ? 1 : 0,
1367 0, 0.0f, nullptr);
1368 #else
1369 // unused
1370 return; (void)sendCallback;
1371 #endif
1372 }
1373
1374 void CarlaPlugin::setEnabled(const bool yesNo) noexcept
1375 {
1376 if (pData->enabled == yesNo)
1377 return;
1378
1379 pData->masterMutex.lock();
1380 pData->enabled = yesNo;
1381
1382 if (yesNo && ! pData->client->isActive())
1383 pData->client->activate();
1384
1385 pData->masterMutex.unlock();
1386 }
1387
1388 void CarlaPlugin::setActive(const bool active, const bool sendOsc, const bool sendCallback) noexcept
1389 {
1390 if (pData->engineBridged) {
1391 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1392 } else if (pData->enginePlugin) {
1393 // nothing here
1394 } else {
1395 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1396 }
1397
1398 if (pData->active == active)
1399 return;
1400
1401 {
1402 const ScopedSingleProcessLocker spl(this, true);
1403
1404 if (active)
1405 activate();
1406 else
1407 deactivate();
1408 }
1409
1410 pData->active = active;
1411
1412 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1413 const float value = active ? 1.0f : 0.0f;
1414
1415 pData->engine->callback(sendCallback, sendOsc,
1416 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1417 pData->id,
1418 PARAMETER_ACTIVE,
1419 0, 0,
1420 value,
1421 nullptr);
1422 #endif
1423 }
1424
1425 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1426 void CarlaPlugin::setDryWet(const float value, const bool sendOsc, const bool sendCallback) noexcept
1427 {
1428 if (pData->engineBridged) {
1429 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1430 } else {
1431 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1432 }
1433 CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);
1434
1435 const float fixedValue(carla_fixedValue<float>(0.0f, 1.0f, value));
1436
1437 if (carla_isEqual(pData->postProc.dryWet, fixedValue))
1438 return;
1439
1440 pData->postProc.dryWet = fixedValue;
1441
1442 pData->engine->callback(sendCallback, sendOsc,
1443 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1444 pData->id,
1445 PARAMETER_DRYWET,
1446 0, 0,
1447 fixedValue,
1448 nullptr);
1449 }
1450
1451 void CarlaPlugin::setVolume(const float value, const bool sendOsc, const bool sendCallback) noexcept
1452 {
1453 if (pData->engineBridged) {
1454 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1455 } else {
1456 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1457 }
1458 CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.27f);
1459
1460 const float fixedValue(carla_fixedValue<float>(0.0f, 1.27f, value));
1461
1462 if (carla_isEqual(pData->postProc.volume, fixedValue))
1463 return;
1464
1465 pData->postProc.volume = fixedValue;
1466
1467 pData->engine->callback(sendCallback, sendOsc,
1468 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1469 pData->id,
1470 PARAMETER_VOLUME,
1471 0, 0,
1472 fixedValue,
1473 nullptr);
1474 }
1475
1476 void CarlaPlugin::setBalanceLeft(const float value, const bool sendOsc, const bool sendCallback) noexcept
1477 {
1478 if (pData->engineBridged) {
1479 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1480 } else {
1481 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1482 }
1483 CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);
1484
1485 const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));
1486
1487 if (carla_isEqual(pData->postProc.balanceLeft, fixedValue))
1488 return;
1489
1490 pData->postProc.balanceLeft = fixedValue;
1491
1492 pData->engine->callback(sendCallback, sendOsc,
1493 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1494 pData->id,
1495 PARAMETER_BALANCE_LEFT,
1496 0, 0,
1497 fixedValue,
1498 nullptr);
1499 }
1500
1501 void CarlaPlugin::setBalanceRight(const float value, const bool sendOsc, const bool sendCallback) noexcept
1502 {
1503 if (pData->engineBridged) {
1504 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1505 } else {
1506 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1507 }
1508 CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);
1509
1510 const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));
1511
1512 if (carla_isEqual(pData->postProc.balanceRight, fixedValue))
1513 return;
1514
1515 pData->postProc.balanceRight = fixedValue;
1516
1517 pData->engine->callback(sendCallback, sendOsc,
1518 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1519 pData->id,
1520 PARAMETER_BALANCE_RIGHT,
1521 0, 0,
1522 fixedValue,
1523 nullptr);
1524 }
1525
1526 void CarlaPlugin::setPanning(const float value, const bool sendOsc, const bool sendCallback) noexcept
1527 {
1528 if (pData->engineBridged) {
1529 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1530 } else {
1531 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1532 }
1533 CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);
1534
1535 const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));
1536
1537 if (carla_isEqual(pData->postProc.panning, fixedValue))
1538 return;
1539
1540 pData->postProc.panning = fixedValue;
1541
1542 pData->engine->callback(sendCallback, sendOsc,
1543 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1544 pData->id,
1545 PARAMETER_PANNING,
1546 0, 0,
1547 fixedValue,
1548 nullptr);
1549 }
1550
1551 void CarlaPlugin::setDryWetRT(const float value, const bool sendCallbackLater) noexcept
1552 {
1553 CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.0f);
1554
1555 const float fixedValue(carla_fixedValue<float>(0.0f, 1.0f, value));
1556
1557 if (carla_isEqual(pData->postProc.dryWet, fixedValue))
1558 return;
1559
1560 pData->postProc.dryWet = fixedValue;
1561 pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_DRYWET, fixedValue);
1562 }
1563
1564 void CarlaPlugin::setVolumeRT(const float value, const bool sendCallbackLater) noexcept
1565 {
1566 CARLA_SAFE_ASSERT(value >= 0.0f && value <= 1.27f);
1567
1568 const float fixedValue(carla_fixedValue<float>(0.0f, 1.27f, value));
1569
1570 if (carla_isEqual(pData->postProc.volume, fixedValue))
1571 return;
1572
1573 pData->postProc.volume = fixedValue;
1574 pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_VOLUME, fixedValue);
1575 }
1576
1577 void CarlaPlugin::setBalanceLeftRT(const float value, const bool sendCallbackLater) noexcept
1578 {
1579 CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);
1580
1581 const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));
1582
1583 if (carla_isEqual(pData->postProc.balanceLeft, fixedValue))
1584 return;
1585
1586 pData->postProc.balanceLeft = fixedValue;
1587 pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_BALANCE_LEFT, fixedValue);
1588 }
1589
1590 void CarlaPlugin::setBalanceRightRT(const float value, const bool sendCallbackLater) noexcept
1591 {
1592 CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);
1593
1594 const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));
1595
1596 if (carla_isEqual(pData->postProc.balanceRight, fixedValue))
1597 return;
1598
1599 pData->postProc.balanceRight = fixedValue;
1600 pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_BALANCE_RIGHT, fixedValue);
1601 }
1602
1603 void CarlaPlugin::setPanningRT(const float value, const bool sendCallbackLater) noexcept
1604 {
1605 CARLA_SAFE_ASSERT(value >= -1.0f && value <= 1.0f);
1606
1607 const float fixedValue(carla_fixedValue<float>(-1.0f, 1.0f, value));
1608
1609 if (carla_isEqual(pData->postProc.panning, fixedValue))
1610 return;
1611
1612 pData->postProc.panning = fixedValue;
1613 pData->postponeParameterChangeRtEvent(sendCallbackLater, PARAMETER_PANNING, fixedValue);
1614 }
1615 #endif // ! BUILD_BRIDGE_ALTERNATIVE_ARCH
1616
1617 void CarlaPlugin::setCtrlChannel(const int8_t channel, const bool sendOsc, const bool sendCallback) noexcept
1618 {
1619 if (pData->engineBridged) {
1620 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1621 } else {
1622 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1623 }
1624 CARLA_SAFE_ASSERT_RETURN(channel >= -1 && channel < MAX_MIDI_CHANNELS,);
1625
1626 if (pData->ctrlChannel == channel)
1627 return;
1628
1629 pData->ctrlChannel = channel;
1630
1631 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1632 const float channelf = static_cast<float>(channel);
1633
1634 pData->engine->callback(sendCallback, sendOsc,
1635 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1636 pData->id,
1637 PARAMETER_CTRL_CHANNEL,
1638 0, 0,
1639 channelf, nullptr);
1640 #endif
1641 }
1642
1643 // -------------------------------------------------------------------
1644 // Set data (plugin-specific stuff)
1645
1646 void CarlaPlugin::setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept
1647 {
1648 if (pData->engineBridged) {
1649 // NOTE: some LV2 plugins feedback messages to UI on purpose
1650 CARLA_SAFE_ASSERT_RETURN(getType() == PLUGIN_LV2 || !sendGui,);
1651 } else if (pData->enginePlugin) {
1652 // nothing here
1653 } else {
1654 CARLA_SAFE_ASSERT_RETURN(sendGui || sendOsc || sendCallback,); // never call this from RT
1655 }
1656 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
1657
1658 if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)
1659 uiParameterChange(parameterId, value);
1660
1661 pData->engine->callback(sendCallback, sendOsc,
1662 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
1663 pData->id,
1664 static_cast<int>(parameterId),
1665 0, 0,
1666 value,
1667 nullptr);
1668 }
1669
1670 void CarlaPlugin::setParameterValueRT(const uint32_t parameterId, const float value, uint32_t, const bool sendCallbackLater) noexcept
1671 {
1672 pData->postponeParameterChangeRtEvent(sendCallbackLater, static_cast<int32_t>(parameterId), value);
1673 }
1674
1675 void CarlaPlugin::setParameterValueByRealIndex(const int32_t rindex, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept
1676 {
1677 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1678 CARLA_SAFE_ASSERT_RETURN(rindex > PARAMETER_MAX && rindex != PARAMETER_NULL,);
1679
1680 switch (rindex)
1681 {
1682 case PARAMETER_ACTIVE:
1683 return setActive((value > 0.0f), sendOsc, sendCallback);
1684 case PARAMETER_CTRL_CHANNEL:
1685 return setCtrlChannel(int8_t(value), sendOsc, sendCallback);
1686 case PARAMETER_DRYWET:
1687 return setDryWet(value, sendOsc, sendCallback);
1688 case PARAMETER_VOLUME:
1689 return setVolume(value, sendOsc, sendCallback);
1690 case PARAMETER_BALANCE_LEFT:
1691 return setBalanceLeft(value, sendOsc, sendCallback);
1692 case PARAMETER_BALANCE_RIGHT:
1693 return setBalanceRight(value, sendOsc, sendCallback);
1694 case PARAMETER_PANNING:
1695 return setPanning(value, sendOsc, sendCallback);
1696 }
1697 #endif
1698 CARLA_SAFE_ASSERT_RETURN(rindex >= 0,);
1699
1700 for (uint32_t i=0; i < pData->param.count; ++i)
1701 {
1702 if (pData->param.data[i].rindex == rindex)
1703 {
1704 //if (carla_isNotEqual(getParameterValue(i), value))
1705 setParameterValue(i, value, sendGui, sendOsc, sendCallback);
1706 break;
1707 }
1708 }
1709 }
1710
1711 void CarlaPlugin::setParameterMidiChannel(const uint32_t parameterId, const uint8_t channel, const bool sendOsc, const bool sendCallback) noexcept
1712 {
1713 if (pData->engineBridged) {
1714 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1715 } else {
1716 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1717 }
1718 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
1719 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
1720
1721 if (pData->param.data[parameterId].midiChannel == channel)
1722 return;
1723
1724 pData->param.data[parameterId].midiChannel = channel;
1725
1726 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1727 pData->engine->callback(sendCallback, sendOsc,
1728 ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,
1729 pData->id,
1730 static_cast<int>(parameterId),
1731 channel,
1732 0, 0.0f, nullptr);
1733 #endif
1734 }
1735
1736 void CarlaPlugin::setParameterMappedControlIndex(const uint32_t parameterId, const int16_t index,
1737 const bool sendOsc, const bool sendCallback,
1738 const bool reconfigureNow) noexcept
1739 {
1740 if (pData->engineBridged) {
1741 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1742 } else {
1743 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1744 }
1745 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
1746 CARLA_SAFE_ASSERT_RETURN(index >= CONTROL_INDEX_NONE && index <= CONTROL_INDEX_MAX_ALLOWED,);
1747
1748 ParameterData& paramData(pData->param.data[parameterId]);
1749
1750 if (paramData.mappedControlIndex == index)
1751 return;
1752
1753 const ParameterRanges& paramRanges(pData->param.ranges[parameterId]);
1754
1755 if ((paramData.hints & PARAMETER_MAPPED_RANGES_SET) == 0x0)
1756 setParameterMappedRange(parameterId, paramRanges.min, paramRanges.max, true, true);
1757
1758 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1759 char strBuf[STR_MAX+1];
1760 carla_zeroChars(strBuf, STR_MAX+1);
1761 if (! getParameterName(parameterId, strBuf))
1762 std::snprintf(strBuf, STR_MAX, "Param %u", parameterId);
1763
1764 const uint portNameSize = pData->engine->getMaxPortNameSize();
1765 if (portNameSize < STR_MAX)
1766 strBuf[portNameSize] = '\0';
1767
1768 // was learning something else before, stop that first
1769 if (pData->midiLearnParameterIndex >= 0 && pData->midiLearnParameterIndex != static_cast<int32_t>(parameterId))
1770 {
1771 const int32_t oldParameterId = pData->midiLearnParameterIndex;
1772 pData->midiLearnParameterIndex = -1;
1773
1774 CARLA_SAFE_ASSERT_RETURN(oldParameterId < static_cast<int32_t>(pData->param.count),);
1775
1776 pData->param.data[oldParameterId].mappedControlIndex = CONTROL_INDEX_NONE;
1777 pData->engine->callback(true, true,
1778 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,
1779 pData->id,
1780 oldParameterId,
1781 CONTROL_INDEX_NONE,
1782 0, 0.0f, nullptr);
1783 }
1784
1785 // mapping new parameter to CV
1786 if (index == CONTROL_INDEX_CV)
1787 {
1788 CARLA_SAFE_ASSERT_RETURN(pData->event.cvSourcePorts != nullptr,);
1789 CARLA_SAFE_ASSERT_RETURN(paramData.type == PARAMETER_INPUT,);
1790 CARLA_SAFE_ASSERT_RETURN(paramData.hints & PARAMETER_CAN_BE_CV_CONTROLLED,);
1791
1792 CarlaEngineCVPort* const cvPort =
1793 (CarlaEngineCVPort*)pData->client->addPort(kEnginePortTypeCV, strBuf, true, parameterId);
1794 cvPort->setRange(paramData.mappedMinimum, paramData.mappedMaximum);
1795 pData->event.cvSourcePorts->addCVSource(cvPort, parameterId, reconfigureNow);
1796 }
1797 // unmapping from CV
1798 else if (paramData.mappedControlIndex == CONTROL_INDEX_CV)
1799 {
1800 CARLA_SAFE_ASSERT_RETURN(pData->event.cvSourcePorts != nullptr,);
1801
1802 CARLA_SAFE_ASSERT(pData->client->removePort(kEnginePortTypeCV, strBuf, true));
1803 CARLA_SAFE_ASSERT(pData->event.cvSourcePorts->removeCVSource(parameterId));
1804 }
1805 // mapping to something new
1806 else if (paramData.mappedControlIndex == CONTROL_INDEX_NONE)
1807 {
1808 // when doing MIDI CC mapping, ensure ranges are within bounds
1809 if (paramData.mappedMinimum < paramRanges.min || paramData.mappedMaximum > paramRanges.max)
1810 setParameterMappedRange(parameterId,
1811 std::max(paramData.mappedMinimum, paramRanges.min),
1812 std::min(paramData.mappedMaximum, paramRanges.max),
1813 true, true);
1814 }
1815 #endif
1816
1817 paramData.mappedControlIndex = index;
1818
1819 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1820 if (index == CONTROL_INDEX_MIDI_LEARN)
1821 pData->midiLearnParameterIndex = static_cast<int32_t>(parameterId);
1822 else
1823 pData->midiLearnParameterIndex = -1;
1824
1825 pData->engine->callback(sendCallback, sendOsc,
1826 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,
1827 pData->id,
1828 static_cast<int>(parameterId),
1829 index,
1830 0, 0.0f, nullptr);
1831 #else
1832 return;
1833 // unused
1834 (void)reconfigureNow;
1835 #endif
1836 }
1837
1838 void CarlaPlugin::setParameterMappedRange(const uint32_t parameterId, const float minimum, const float maximum,
1839 const bool sendOsc, const bool sendCallback) noexcept
1840 {
1841 if (pData->engineBridged) {
1842 CARLA_SAFE_ASSERT_RETURN(!sendOsc && !sendCallback,);
1843 } else {
1844 CARLA_SAFE_ASSERT_RETURN(sendOsc || sendCallback,); // never call this from RT
1845 }
1846 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
1847
1848 ParameterData& paramData(pData->param.data[parameterId]);
1849
1850 if (carla_isEqual(paramData.mappedMinimum, minimum) &&
1851 carla_isEqual(paramData.mappedMaximum, maximum) &&
1852 (paramData.hints & PARAMETER_MAPPED_RANGES_SET) != 0x0)
1853 return;
1854
1855 if (paramData.mappedControlIndex != CONTROL_INDEX_NONE && paramData.mappedControlIndex != CONTROL_INDEX_CV)
1856 {
1857 const ParameterRanges& paramRanges(pData->param.ranges[parameterId]);
1858 CARLA_SAFE_ASSERT_RETURN(minimum >= paramRanges.min,);
1859 CARLA_SAFE_ASSERT_RETURN(maximum <= paramRanges.max,);
1860 }
1861
1862 paramData.hints |= PARAMETER_MAPPED_RANGES_SET;
1863 paramData.mappedMinimum = minimum;
1864 paramData.mappedMaximum = maximum;
1865
1866 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1867 if (pData->event.cvSourcePorts != nullptr && paramData.mappedControlIndex == CONTROL_INDEX_CV)
1868 pData->event.cvSourcePorts->setCVSourceRange(parameterId, minimum, maximum);
1869
1870 char strBuf[STR_MAX+1];
1871 carla_zeroChars(strBuf, STR_MAX+1);
1872 std::snprintf(strBuf, STR_MAX, "%.12g:%.12g", static_cast<double>(minimum), static_cast<double>(maximum));
1873
1874 pData->engine->callback(sendCallback, sendOsc,
1875 ENGINE_CALLBACK_PARAMETER_MAPPED_RANGE_CHANGED,
1876 pData->id,
1877 static_cast<int>(parameterId),
1878 0, 0, 0.0f,
1879 strBuf);
1880 #endif
1881 }
1882
1883 void CarlaPlugin::setCustomData(const char* const type, const char* const key, const char* const value, const bool)
1884 {
1885 CARLA_SAFE_ASSERT_RETURN(type != nullptr && type[0] != '\0',);
1886 CARLA_SAFE_ASSERT_RETURN(key != nullptr && key[0] != '\0',);
1887 CARLA_SAFE_ASSERT_RETURN(value != nullptr,);
1888
1889 // Ignore some keys
1890 if (std::strcmp(type, CUSTOM_DATA_TYPE_STRING) == 0)
1891 {
1892 const PluginType ptype = getType();
1893
1894 if ((ptype == PLUGIN_INTERNAL && std::strncmp(key, "CarlaAlternateFile", 18) == 0) ||
1895 (ptype == PLUGIN_DSSI && std::strcmp (key, "guiVisible") == 0) ||
1896 (ptype == PLUGIN_LV2 && std::strncmp(key, "OSC:", 4) == 0))
1897 return;
1898 }
1899
1900 // Check if we already have this key
1901 for (LinkedList<CustomData>::Itenerator it = pData->custom.begin2(); it.valid(); it.next())
1902 {
1903 CustomData& customData(it.getValue(kCustomDataFallbackNC));
1904 CARLA_SAFE_ASSERT_CONTINUE(customData.isValid());
1905
1906 if (std::strcmp(customData.key, key) == 0)
1907 {
1908 if (customData.value != nullptr)
1909 delete[] customData.value;
1910
1911 customData.value = carla_strdup(value);
1912 return;
1913 }
1914 }
1915
1916 // Otherwise store it
1917 CustomData customData;
1918 customData.type = carla_strdup(type);
1919 customData.key = carla_strdup(key);
1920 customData.value = carla_strdup(value);
1921 pData->custom.append(customData);
1922 }
1923
1924 void CarlaPlugin::setChunkData(const void* const data, const std::size_t dataSize)
1925 {
1926 CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
1927 CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);
1928 CARLA_SAFE_ASSERT(false); // this should never happen
1929 }
1930
1931 void CarlaPlugin::setProgram(const int32_t index,
1932 const bool sendGui, const bool sendOsc, const bool sendCallback, const bool) noexcept
1933 {
1934 CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->prog.count),);
1935
1936 pData->prog.current = index;
1937
1938 pData->engine->callback(sendCallback, sendOsc,
1939 ENGINE_CALLBACK_PROGRAM_CHANGED,
1940 pData->id,
1941 index,
1942 0, 0, 0.0f, nullptr);
1943
1944 // Change default parameter values
1945 if (index >= 0)
1946 {
1947 if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)
1948 uiProgramChange(static_cast<uint32_t>(index));
1949
1950 switch (getType())
1951 {
1952 case PLUGIN_SF2:
1953 case PLUGIN_SFZ:
1954 break;
1955
1956 default:
1957 pData->updateParameterValues(this, sendCallback, sendOsc, true);
1958 break;
1959 }
1960 }
1961 }
1962
1963 void CarlaPlugin::setMidiProgram(const int32_t index,
1964 const bool sendGui, const bool sendOsc, const bool sendCallback, const bool) noexcept
1965 {
1966 CARLA_SAFE_ASSERT_RETURN(index >= -1 && index < static_cast<int32_t>(pData->midiprog.count),);
1967
1968 pData->midiprog.current = index;
1969
1970 pData->engine->callback(sendCallback, sendOsc,
1971 ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,
1972 pData->id,
1973 index,
1974 0, 0, 0.0f, nullptr);
1975
1976 // Change default parameter values
1977 if (index >= 0)
1978 {
1979 if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)
1980 uiMidiProgramChange(static_cast<uint32_t>(index));
1981
1982 switch (getType())
1983 {
1984 case PLUGIN_SF2:
1985 case PLUGIN_SFZ:
1986 break;
1987
1988 default:
1989 pData->updateParameterValues(this, sendCallback, sendOsc, true);
1990 break;
1991 }
1992 }
1993 }
1994
1995 void CarlaPlugin::setMidiProgramById(const uint32_t bank, const uint32_t program, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept
1996 {
1997 for (uint32_t i=0; i < pData->midiprog.count; ++i)
1998 {
1999 if (pData->midiprog.data[i].bank == bank && pData->midiprog.data[i].program == program)
2000 return setMidiProgram(static_cast<int32_t>(i), sendGui, sendOsc, sendCallback);
2001 }
2002 }
2003
2004 void CarlaPlugin::setProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept
2005 {
2006 CARLA_SAFE_ASSERT_RETURN(uindex < pData->prog.count,);
2007
2008 const int32_t index = static_cast<int32_t>(uindex);
2009 pData->prog.current = index;
2010
2011 // Change default parameter values
2012 switch (getType())
2013 {
2014 case PLUGIN_SF2:
2015 case PLUGIN_SFZ:
2016 break;
2017
2018 default:
2019 pData->updateDefaultParameterValues(this);
2020 break;
2021 }
2022
2023 pData->postponeProgramChangeRtEvent(sendCallbackLater, uindex);
2024 }
2025
2026 void CarlaPlugin::setMidiProgramRT(const uint32_t uindex, const bool sendCallbackLater) noexcept
2027 {
2028 CARLA_SAFE_ASSERT_RETURN(uindex < pData->midiprog.count,);
2029
2030 const int32_t index = static_cast<int32_t>(uindex);
2031 pData->midiprog.current = index;
2032
2033 // Change default parameter values
2034 switch (getType())
2035 {
2036 case PLUGIN_SF2:
2037 case PLUGIN_SFZ:
2038 break;
2039
2040 default:
2041 pData->updateDefaultParameterValues(this);
2042 break;
2043 }
2044
2045 pData->postponeMidiProgramChangeRtEvent(sendCallbackLater, uindex);
2046 }
2047
2048 // -------------------------------------------------------------------
2049 // Plugin state
2050
2051 void CarlaPlugin::reloadPrograms(const bool)
2052 {
2053 }
2054
2055 // -------------------------------------------------------------------
2056 // Plugin processing
2057
2058 void CarlaPlugin::activate() noexcept
2059 {
2060 CARLA_SAFE_ASSERT(! pData->active);
2061 }
2062
2063 void CarlaPlugin::deactivate() noexcept
2064 {
2065 CARLA_SAFE_ASSERT(pData->active);
2066 }
2067
2068 void CarlaPlugin::bufferSizeChanged(const uint32_t newBufferSize)
2069 {
2070 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2071 delete[] pData->postProc.extraBuffer;
2072 pData->postProc.extraBuffer = new float[newBufferSize];
2073 #else
2074 // unused
2075 (void)newBufferSize;
2076 #endif
2077 }
2078
2079 void CarlaPlugin::sampleRateChanged(const double)
2080 {
2081 }
2082
2083 void CarlaPlugin::offlineModeChanged(const bool)
2084 {
2085 }
2086
2087 // -------------------------------------------------------------------
2088 // Misc
2089
2090 void CarlaPlugin::idle()
2091 {
2092 if (! pData->enabled)
2093 return;
2094
2095 const bool hasUI = pData->hints & PLUGIN_HAS_CUSTOM_UI;
2096 const bool needsUiMainThread = pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD;
2097 const uint32_t latency = getLatencyInFrames();
2098
2099 if (pData->latency.frames != latency)
2100 {
2101 carla_stdout("latency changed to %i samples", latency);
2102
2103 const ScopedSingleProcessLocker sspl(this, true);
2104
2105 pData->client->setLatency(latency);
2106 #ifndef BUILD_BRIDGE
2107 pData->latency.recreateBuffers(pData->latency.channels, latency);
2108 #else
2109 pData->latency.frames = latency;
2110 #endif
2111 }
2112
2113 ProtectedData::PostRtEvents::Access rtEvents(pData->postRtEvents);
2114
2115 if (rtEvents.isEmpty())
2116 return;
2117
2118 for (RtLinkedList<PluginPostRtEvent>::Itenerator it = rtEvents.getDataIterator(); it.valid(); it.next())
2119 {
2120 const PluginPostRtEvent& event(it.getValue(kPluginPostRtEventFallback));
2121 CARLA_SAFE_ASSERT_CONTINUE(event.type != kPluginPostRtEventNull);
2122
2123 switch (event.type)
2124 {
2125 case kPluginPostRtEventNull: {
2126 } break;
2127
2128 case kPluginPostRtEventParameterChange: {
2129 // Update UI
2130 if (event.parameter.index >= 0 && hasUI)
2131 {
2132 if (needsUiMainThread)
2133 pData->postUiEvents.append(event);
2134 else
2135 uiParameterChange(static_cast<uint32_t>(event.parameter.index), event.parameter.value);
2136 }
2137
2138 if (event.sendCallback)
2139 {
2140 // Update Host
2141 pData->engine->callback(true, true,
2142 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
2143 pData->id,
2144 event.parameter.index,
2145 0, 0,
2146 event.parameter.value,
2147 nullptr);
2148 }
2149 } break;
2150
2151 case kPluginPostRtEventProgramChange: {
2152 // Update UI
2153 if (hasUI)
2154 {
2155 if (needsUiMainThread)
2156 pData->postUiEvents.append(event);
2157 else
2158 uiProgramChange(event.program.index);
2159 }
2160
2161 // Update param values
2162 for (uint32_t j=0; j < pData->param.count; ++j)
2163 {
2164 const float paramDefault(pData->param.ranges[j].def);
2165 const float paramValue(getParameterValue(j));
2166
2167 pData->engine->callback(true, true,
2168 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
2169 pData->id,
2170 static_cast<int>(j),
2171 0, 0,
2172 paramValue,
2173 nullptr);
2174 pData->engine->callback(true, true,
2175 ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,
2176 pData->id,
2177 static_cast<int>(j),
2178 0, 0,
2179 paramDefault,
2180 nullptr);
2181 }
2182
2183 if (event.sendCallback)
2184 {
2185 // Update Host
2186 pData->engine->callback(true, true,
2187 ENGINE_CALLBACK_PROGRAM_CHANGED,
2188 pData->id,
2189 static_cast<int>(event.program.index),
2190 0, 0, 0.0f, nullptr);
2191 }
2192 } break;
2193
2194 case kPluginPostRtEventMidiProgramChange: {
2195 // Update UI
2196 if (hasUI)
2197 {
2198 if (needsUiMainThread)
2199 pData->postUiEvents.append(event);
2200 else
2201 uiMidiProgramChange(event.program.index);
2202 }
2203
2204 // Update param values
2205 for (uint32_t j=0; j < pData->param.count; ++j)
2206 {
2207 const float paramDefault(pData->param.ranges[j].def);
2208 const float paramValue(getParameterValue(j));
2209
2210 pData->engine->callback(true, true,
2211 ENGINE_CALLBACK_PARAMETER_VALUE_CHANGED,
2212 pData->id,
2213 static_cast<int>(j),
2214 0, 0,
2215 paramValue,
2216 nullptr);
2217 pData->engine->callback(true, true,
2218 ENGINE_CALLBACK_PARAMETER_DEFAULT_CHANGED,
2219 pData->id,
2220 static_cast<int>(j),
2221 0, 0,
2222 paramDefault,
2223 nullptr);
2224 }
2225
2226 if (event.sendCallback)
2227 {
2228 // Update Host
2229 pData->engine->callback(true, true,
2230 ENGINE_CALLBACK_MIDI_PROGRAM_CHANGED,
2231 pData->id,
2232 static_cast<int>(event.program.index),
2233 0, 0, 0.0f, nullptr);
2234 }
2235 } break;
2236
2237 case kPluginPostRtEventNoteOn: {
2238 CARLA_SAFE_ASSERT_BREAK(event.note.channel < MAX_MIDI_CHANNELS);
2239 CARLA_SAFE_ASSERT_BREAK(event.note.note < MAX_MIDI_NOTE);
2240 CARLA_SAFE_ASSERT_BREAK(event.note.velocity < MAX_MIDI_VALUE);
2241
2242 // Update UI
2243 if (hasUI)
2244 {
2245 if (needsUiMainThread)
2246 pData->postUiEvents.append(event);
2247 else
2248 uiNoteOn(event.note.channel, event.note.note, event.note.velocity);
2249 }
2250
2251 if (event.sendCallback)
2252 {
2253 // Update Host
2254 pData->engine->callback(true, true,
2255 ENGINE_CALLBACK_NOTE_ON,
2256 pData->id,
2257 static_cast<int>(event.note.channel),
2258 static_cast<int>(event.note.note),
2259 static_cast<int>(event.note.velocity),
2260 0.0f, nullptr);
2261 }
2262 } break;
2263
2264 case kPluginPostRtEventNoteOff: {
2265 CARLA_SAFE_ASSERT_BREAK(event.note.channel < MAX_MIDI_CHANNELS);
2266 CARLA_SAFE_ASSERT_BREAK(event.note.note < MAX_MIDI_NOTE);
2267
2268 // Update UI
2269 if (hasUI)
2270 {
2271 if (needsUiMainThread)
2272 pData->postUiEvents.append(event);
2273 else
2274 uiNoteOff(event.note.channel, event.note.note);
2275 }
2276
2277 if (event.sendCallback)
2278 {
2279 // Update Host
2280 pData->engine->callback(true, true,
2281 ENGINE_CALLBACK_NOTE_OFF,
2282 pData->id,
2283 static_cast<int>(event.note.channel),
2284 static_cast<int>(event.note.note),
2285 0, 0.0f, nullptr);
2286 }
2287 } break;
2288
2289 case kPluginPostRtEventMidiLearn: {
2290 CARLA_SAFE_ASSERT_BREAK(event.midiLearn.cc < MAX_MIDI_VALUE);
2291 CARLA_SAFE_ASSERT_BREAK(event.midiLearn.channel < MAX_MIDI_CHANNELS);
2292
2293 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2294 if (event.sendCallback)
2295 {
2296 pData->engine->callback(true, true,
2297 ENGINE_CALLBACK_PARAMETER_MAPPED_CONTROL_INDEX_CHANGED,
2298 pData->id,
2299 static_cast<int>(event.midiLearn.parameter),
2300 static_cast<int>(event.midiLearn.cc),
2301 0, 0.0f, nullptr);
2302
2303 pData->engine->callback(true, true,
2304 ENGINE_CALLBACK_PARAMETER_MIDI_CHANNEL_CHANGED,
2305 pData->id,
2306 static_cast<int>(event.midiLearn.parameter),
2307 static_cast<int>(event.midiLearn.channel),
2308 0, 0.0f, nullptr);
2309 }
2310 #endif
2311 } break;
2312 }
2313 }
2314 }
2315
2316 bool CarlaPlugin::tryLock(const bool forcedOffline) noexcept
2317 {
2318 if (forcedOffline)
2319 {
2320 #ifndef STOAT_TEST_BUILD
2321 pData->masterMutex.lock();
2322 return true;
2323 #endif
2324 }
2325
2326 return pData->masterMutex.tryLock();
2327 }
2328
2329 void CarlaPlugin::unlock() noexcept
2330 {
2331 pData->masterMutex.unlock();
2332 }
2333
2334 // -------------------------------------------------------------------
2335 // Plugin buffers
2336
2337 void CarlaPlugin::initBuffers() const noexcept
2338 {
2339 pData->audioIn.initBuffers();
2340 pData->audioOut.initBuffers();
2341 pData->cvIn.initBuffers();
2342 pData->cvOut.initBuffers();
2343 pData->event.initBuffers();
2344 }
2345
2346 void CarlaPlugin::clearBuffers() noexcept
2347 {
2348 pData->clearBuffers();
2349 }
2350
2351 // -------------------------------------------------------------------
2352 // OSC stuff
2353
2354 // FIXME
2355 void CarlaPlugin::handleOscMessage(const char*, int, const void*, const char*, void*)
2356 {
2357 // do nothing
2358 }
2359
2360 // -------------------------------------------------------------------
2361 // MIDI events
2362
2363 void CarlaPlugin::sendMidiSingleNote(const uint8_t channel, const uint8_t note, const uint8_t velo, const bool sendGui, const bool sendOsc, const bool sendCallback)
2364 {
2365 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2366 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2367 CARLA_SAFE_ASSERT_RETURN(velo < MAX_MIDI_VALUE,);
2368
2369 if (! pData->active)
2370 return;
2371
2372 ExternalMidiNote extNote;
2373 extNote.channel = static_cast<int8_t>(channel);
2374 extNote.note = note;
2375 extNote.velo = velo;
2376
2377 pData->extNotes.appendNonRT(extNote);
2378
2379 if (sendGui && (pData->hints & PLUGIN_HAS_CUSTOM_UI) != 0)
2380 {
2381 if (velo > 0)
2382 uiNoteOn(channel, note, velo);
2383 else
2384 uiNoteOff(channel, note);
2385 }
2386
2387 pData->engine->callback(sendCallback, sendOsc,
2388 (velo > 0) ? ENGINE_CALLBACK_NOTE_ON : ENGINE_CALLBACK_NOTE_OFF,
2389 pData->id,
2390 channel,
2391 note,
2392 velo,
2393 0.0f, nullptr);
2394 }
2395
2396 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2397 void CarlaPlugin::postponeRtAllNotesOff()
2398 {
2399 if (pData->ctrlChannel < 0 || pData->ctrlChannel >= MAX_MIDI_CHANNELS)
2400 return;
2401
2402 PluginPostRtEvent postEvent = { kPluginPostRtEventNoteOff, true, {} };
2403 postEvent.note.channel = static_cast<uint8_t>(pData->ctrlChannel);
2404
2405 for (uint8_t i=0; i < MAX_MIDI_NOTE; ++i)
2406 {
2407 postEvent.note.note = i;
2408 pData->postRtEvents.appendRT(postEvent);
2409 }
2410 }
2411 #endif
2412
2413 // -------------------------------------------------------------------
2414 // UI Stuff
2415
2416 void CarlaPlugin::setCustomUITitle(const char* const title) noexcept
2417 {
2418 pData->uiTitle = title;
2419 }
2420
2421 void CarlaPlugin::showCustomUI(const bool yesNo)
2422 {
2423 if (yesNo) {
2424 CARLA_SAFE_ASSERT(false);
2425 }
2426 }
2427
2428 void* CarlaPlugin::embedCustomUI(void*)
2429 {
2430 return nullptr;
2431 }
2432
2433 void CarlaPlugin::uiIdle()
2434 {
2435 if (pData->hints & PLUGIN_NEEDS_UI_MAIN_THREAD)
2436 {
2437 // Update parameter outputs
2438 for (uint32_t i=0; i < pData->param.count; ++i)
2439 {
2440 if (pData->param.data[i].type == PARAMETER_OUTPUT)
2441 uiParameterChange(i, getParameterValue(i));
2442 }
2443
2444 const CarlaMutexLocker sl(pData->postUiEvents.mutex);
2445
2446 for (LinkedList<PluginPostRtEvent>::Itenerator it = pData->postUiEvents.data.begin2(); it.valid(); it.next())
2447 {
2448 const PluginPostRtEvent& event(it.getValue(kPluginPostRtEventFallback));
2449 CARLA_SAFE_ASSERT_CONTINUE(event.type != kPluginPostRtEventNull);
2450
2451 switch (event.type)
2452 {
2453 case kPluginPostRtEventNull:
2454 case kPluginPostRtEventMidiLearn:
2455 break;
2456
2457 case kPluginPostRtEventParameterChange:
2458 uiParameterChange(static_cast<uint32_t>(event.parameter.index), event.parameter.value);
2459 break;
2460
2461 case kPluginPostRtEventProgramChange:
2462 uiProgramChange(event.program.index);
2463 break;
2464
2465 case kPluginPostRtEventMidiProgramChange:
2466 uiMidiProgramChange(event.program.index);
2467 break;
2468
2469 case kPluginPostRtEventNoteOn:
2470 uiNoteOn(event.note.channel, event.note.note, event.note.velocity);
2471 break;
2472
2473 case kPluginPostRtEventNoteOff:
2474 uiNoteOff(event.note.channel, event.note.note);
2475 break;
2476 }
2477 }
2478
2479 pData->postUiEvents.data.clear();
2480 }
2481
2482 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2483 if (pData->transientTryCounter == 0)
2484 return;
2485 if (++pData->transientTryCounter % 10 != 0)
2486 return;
2487 if (pData->transientTryCounter >= 200)
2488 return;
2489
2490 carla_stdout("Trying to get window...");
2491
2492 CarlaString uiTitle;
2493
2494 if (pData->uiTitle.isNotEmpty())
2495 {
2496 uiTitle = pData->uiTitle;
2497 }
2498 else
2499 {
2500 uiTitle = pData->name;
2501 uiTitle += " (GUI)";
2502 }
2503
2504 if (CarlaPluginUI::tryTransientWinIdMatch(getUiBridgeProcessId(), uiTitle,
2505 pData->engine->getOptions().frontendWinId, pData->transientFirstTry))
2506 {
2507 pData->transientTryCounter = 0;
2508 pData->transientFirstTry = false;
2509 }
2510 #endif
2511 }
2512
2513 void CarlaPlugin::uiParameterChange(const uint32_t index, const float value) noexcept
2514 {
2515 CARLA_SAFE_ASSERT_RETURN(index < getParameterCount(),);
2516 return;
2517
2518 // unused
2519 (void)value;
2520 }
2521
2522 void CarlaPlugin::uiProgramChange(const uint32_t index) noexcept
2523 {
2524 CARLA_SAFE_ASSERT_RETURN(index < getProgramCount(),);
2525 }
2526
2527 void CarlaPlugin::uiMidiProgramChange(const uint32_t index) noexcept
2528 {
2529 CARLA_SAFE_ASSERT_RETURN(index < getMidiProgramCount(),);
2530 }
2531
2532 void CarlaPlugin::uiNoteOn(const uint8_t channel, const uint8_t note, const uint8_t velo) noexcept
2533 {
2534 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2535 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2536 CARLA_SAFE_ASSERT_RETURN(velo > 0 && velo < MAX_MIDI_VALUE,);
2537 }
2538
2539 void CarlaPlugin::uiNoteOff(const uint8_t channel, const uint8_t note) noexcept
2540 {
2541 CARLA_SAFE_ASSERT_RETURN(channel < MAX_MIDI_CHANNELS,);
2542 CARLA_SAFE_ASSERT_RETURN(note < MAX_MIDI_NOTE,);
2543 }
2544
2545 CarlaEngine* CarlaPlugin::getEngine() const noexcept
2546 {
2547 return pData->engine;
2548 }
2549
2550 CarlaEngineClient* CarlaPlugin::getEngineClient() const noexcept
2551 {
2552 return pData->client;
2553 }
2554
2555 CarlaEngineAudioPort* CarlaPlugin::getAudioInPort(const uint32_t index) const noexcept
2556 {
2557 return pData->audioIn.ports[index].port;
2558 }
2559
2560 CarlaEngineAudioPort* CarlaPlugin::getAudioOutPort(const uint32_t index) const noexcept
2561 {
2562 return pData->audioOut.ports[index].port;
2563 }
2564
2565 CarlaEngineCVPort* CarlaPlugin::getCVInPort(const uint32_t index) const noexcept
2566 {
2567 return pData->cvIn.ports[index].port;
2568 }
2569
2570 CarlaEngineCVPort* CarlaPlugin::getCVOutPort(const uint32_t index) const noexcept
2571 {
2572 return pData->cvOut.ports[index].port;
2573 }
2574
2575 CarlaEngineEventPort* CarlaPlugin::getDefaultEventInPort() const noexcept
2576 {
2577 return pData->event.portIn;
2578 }
2579
2580 CarlaEngineEventPort* CarlaPlugin::getDefaultEventOutPort() const noexcept
2581 {
2582 return pData->event.portOut;
2583 }
2584
2585 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2586 void CarlaPlugin::checkForMidiLearn(EngineEvent& event) noexcept
2587 {
2588 if (pData->midiLearnParameterIndex < 0)
2589 return;
2590 if (event.ctrl.param == MIDI_CONTROL_BANK_SELECT || event.ctrl.param == MIDI_CONTROL_BANK_SELECT__LSB)
2591 return;
2592 if (event.ctrl.param >= MAX_MIDI_CONTROL)
2593 return;
2594
2595 const uint32_t parameterId = static_cast<uint32_t>(pData->midiLearnParameterIndex);
2596 CARLA_SAFE_ASSERT_UINT2_RETURN(parameterId < pData->param.count, parameterId, pData->param.count,);
2597
2598 ParameterData& paramData(pData->param.data[parameterId]);
2599 CARLA_SAFE_ASSERT_INT_RETURN(paramData.mappedControlIndex == CONTROL_INDEX_MIDI_LEARN,
2600 paramData.mappedControlIndex,);
2601
2602 event.ctrl.handled = true;
2603 paramData.mappedControlIndex = static_cast<int16_t>(event.ctrl.param);
2604 paramData.midiChannel = event.channel;
2605
2606 pData->postponeMidiLearnRtEvent(true, parameterId, static_cast<uint8_t>(event.ctrl.param), event.channel);
2607 pData->midiLearnParameterIndex = -1;
2608 }
2609 #endif
2610
2611 void* CarlaPlugin::getNativeHandle() const noexcept
2612 {
2613 return nullptr;
2614 }
2615
2616 const void* CarlaPlugin::getNativeDescriptor() const noexcept
2617 {
2618 return nullptr;
2619 }
2620
2621 uintptr_t CarlaPlugin::getUiBridgeProcessId() const noexcept
2622 {
2623 return 0;
2624 }
2625
2626 // -------------------------------------------------------------------
2627
2628 uint32_t CarlaPlugin::getPatchbayNodeId() const noexcept
2629 {
2630 return pData->nodeId;
2631 }
2632
2633 void CarlaPlugin::setPatchbayNodeId(const uint32_t nodeId) noexcept
2634 {
2635 pData->nodeId = nodeId;
2636 }
2637
2638 // -------------------------------------------------------------------
2639
2640 void CarlaPlugin::cloneLV2Files(const CarlaPlugin&)
2641 {
2642 carla_stderr2("Warning: cloneLV2Files() called for non-implemented type");
2643 }
2644
2645 void CarlaPlugin::restoreLV2State(const bool temporary) noexcept
2646 {
2647 carla_stderr2("Warning: restoreLV2State(%s) called for non-implemented type", bool2str(temporary));
2648 }
2649
2650 void CarlaPlugin::prepareForDeletion() noexcept
2651 {
2652 carla_debug("CarlaPlugin::prepareForDeletion");
2653
2654 const CarlaMutexLocker cml(pData->masterMutex);
2655
2656 pData->client->deactivate(true);
2657 }
2658
2659 void CarlaPlugin::waitForBridgeSaveSignal() noexcept
2660 {
2661 }
2662
2663 // -------------------------------------------------------------------
2664 // Scoped Disabler
2665
2666 CarlaPlugin::ScopedDisabler::ScopedDisabler(CarlaPlugin* const plugin) noexcept
2667 : fPlugin(plugin),
2668 fWasEnabled(false)
2669 {
2670 CARLA_SAFE_ASSERT_RETURN(plugin != nullptr,);
2671 CARLA_SAFE_ASSERT_RETURN(plugin->pData != nullptr,);
2672 CARLA_SAFE_ASSERT_RETURN(plugin->pData->client != nullptr,);
2673 carla_debug("CarlaPlugin::ScopedDisabler(%p)", plugin);
2674
2675 plugin->pData->masterMutex.lock();
2676
2677 if (plugin->pData->enabled)
2678 {
2679 fWasEnabled = true;
2680 plugin->pData->enabled = false;
2681
2682 if (plugin->pData->client->isActive())
2683 plugin->pData->client->deactivate(false);
2684 }
2685 }
2686
2687 CarlaPlugin::ScopedDisabler::~ScopedDisabler() noexcept
2688 {
2689 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
2690 CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);
2691 CARLA_SAFE_ASSERT_RETURN(fPlugin->pData->client != nullptr,);
2692 carla_debug("CarlaPlugin::~ScopedDisabler()");
2693
2694 if (fWasEnabled)
2695 {
2696 fPlugin->pData->enabled = true;
2697 fPlugin->pData->client->activate();
2698 }
2699
2700 fPlugin->pData->masterMutex.unlock();
2701 }
2702
2703 // -------------------------------------------------------------------
2704 // Scoped Process Locker
2705
2706 CarlaPlugin::ScopedSingleProcessLocker::ScopedSingleProcessLocker(CarlaPlugin* const plugin, const bool block) noexcept
2707 : fPlugin(plugin),
2708 fBlock(block)
2709 {
2710 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
2711 CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);
2712 carla_debug("CarlaPlugin::ScopedSingleProcessLocker(%p, %s)", plugin, bool2str(block));
2713
2714 if (! fBlock)
2715 return;
2716
2717 plugin->pData->singleMutex.lock();
2718 }
2719
2720 CarlaPlugin::ScopedSingleProcessLocker::~ScopedSingleProcessLocker() noexcept
2721 {
2722 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
2723 CARLA_SAFE_ASSERT_RETURN(fPlugin->pData != nullptr,);
2724 carla_debug("CarlaPlugin::~ScopedSingleProcessLocker()");
2725
2726 if (! fBlock)
2727 return;
2728
2729 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2730 if (fPlugin->pData->singleMutex.wasTryLockCalled())
2731 fPlugin->pData->needsReset = true;
2732 #endif
2733
2734 fPlugin->pData->singleMutex.unlock();
2735 }
2736
2737 // -------------------------------------------------------------------
2738
2739 CARLA_BACKEND_END_NAMESPACE