?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix crash with clap plugins without MIDI input
[carla.git] / source / backend / plugin / CarlaPluginCLAP.cpp
blob35da2db7929497ed00e2237418a164df4732201a
1 /*
2 * Carla CLAP Plugin
3 * Copyright (C) 2022-2023 Filipe Coelho <falktx@falktx.com>
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of
8 * the License, or any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * For a full copy of the GNU General Public License see the doc/GPL.txt file.
16 */
17
18 #include "CarlaPluginInternal.hpp"
19 #include "CarlaEngine.hpp"
20
21 #include "CarlaBackendUtils.hpp"
22 #include "CarlaClapUtils.hpp"
23 #include "CarlaMathUtils.hpp"
24
25 #include "CarlaPluginUI.hpp"
26
27 #ifdef CARLA_OS_MAC
28 # include "CarlaMacUtils.hpp"
29 # import <Foundation/Foundation.h>
30 #endif
31
32 #include "water/files/File.h"
33 #include "water/misc/Time.h"
34
35 #if defined(CLAP_WINDOW_API_NATIVE) && defined(_POSIX_VERSION)
36 # if defined(CARLA_OS_LINUX)
37 # define CARLA_CLAP_POSIX_EPOLL
38 # include <sys/epoll.h>
39 # else
40 # include <sys/event.h>
41 # include <sys/types.h>
42 # endif
43 #endif
44
45 // FIXME
46 // #ifndef CLAP_WINDOW_API_NATIVE
47 // #define CLAP_WINDOW_API_NATIVE ""
48 // #define HAVE_X11 1
49 // #endif
50
51 CARLA_BACKEND_START_NAMESPACE
52
53 // --------------------------------------------------------------------------------------------------------------------
54
55 struct ClapEventData {
56 uint16_t clapPortIndex;
57 uint32_t supportedDialects;
58 CarlaEngineEventPort* port;
59 };
60
61 struct CarlaPluginClapEventData {
62 uint32_t portCount;
63 ClapEventData* portData;
64 ClapEventData* defaultPort; // either this->portData[x] or pData->portIn/Out
65
66 CarlaPluginClapEventData() noexcept
67 : portCount(0),
68 portData(nullptr),
69 defaultPort(nullptr) {}
70
71 ~CarlaPluginClapEventData() noexcept
72 {
73 CARLA_SAFE_ASSERT_INT(portCount == 0, portCount);
74 CARLA_SAFE_ASSERT(portData == nullptr);
75 CARLA_SAFE_ASSERT(defaultPort == nullptr);
76 }
77
78 void createNew(const uint32_t newCount)
79 {
80 CARLA_SAFE_ASSERT_INT(portCount == 0, portCount);
81 CARLA_SAFE_ASSERT_RETURN(portData == nullptr,);
82 CARLA_SAFE_ASSERT_RETURN(defaultPort == nullptr,);
83 CARLA_SAFE_ASSERT_RETURN(newCount > 0,);
84
85 portData = new ClapEventData[newCount];
86 portCount = newCount;
87
88 defaultPort = nullptr;
89 }
90
91 void clear(CarlaEngineEventPort* const portToIgnore) noexcept
92 {
93 if (portData != nullptr)
94 {
95 for (uint32_t i=0; i < portCount; ++i)
96 {
97 if (portData[i].port != nullptr)
98 {
99 if (portData[i].port != portToIgnore)
100 delete portData[i].port;
101 portData[i].port = nullptr;
102 }
103 }
104
105 delete[] portData;
106 portData = nullptr;
107 }
108
109 portCount = 0;
110
111 defaultPort = nullptr;
112 }
113
114 void initBuffers() const noexcept
115 {
116 for (uint32_t i=0; i < portCount; ++i)
117 {
118 if (portData[i].port != nullptr && (defaultPort == nullptr || portData[i].port != defaultPort->port))
119 portData[i].port->initBuffer();
120 }
121 }
122
123 CARLA_DECLARE_NON_COPYABLE(CarlaPluginClapEventData)
124 };
125
126 #ifdef _POSIX_VERSION
127 // --------------------------------------------------------------------------------------------------------------------
128
129 struct HostPosixFileDescriptorDetails {
130 int hostFd;
131 int pluginFd;
132 clap_posix_fd_flags_t flags;
133 };
134
135 static constexpr const HostPosixFileDescriptorDetails kPosixFileDescriptorFallback = { -1, -1, 0x0 };
136 static /* */ HostPosixFileDescriptorDetails kPosixFileDescriptorFallbackNC = { -1, -1, 0x0 };
137 #endif
138
139 // --------------------------------------------------------------------------------------------------------------------
140
141 struct HostTimerDetails {
142 clap_id clapId;
143 uint32_t periodInMs;
144 uint32_t lastCallTimeInMs;
145 };
146
147 static constexpr const HostTimerDetails kTimerFallback = { CLAP_INVALID_ID, 0, 0 };
148 static /* */ HostTimerDetails kTimerFallbackNC = { CLAP_INVALID_ID, 0, 0 };
149
150 // --------------------------------------------------------------------------------------------------------------------
151
152 struct carla_clap_host : clap_host_t {
153 class Callbacks {
154 public:
155 virtual ~Callbacks() {}
156 virtual void clapRequestRestart() = 0;
157 virtual void clapRequestProcess() = 0;
158 virtual void clapRequestCallback() = 0;
159 virtual void clapMarkDirty() = 0;
160 virtual void clapLatencyChanged() = 0;
161 #ifdef CLAP_WINDOW_API_NATIVE
162 // gui
163 virtual void clapGuiResizeHintsChanged() = 0;
164 virtual bool clapGuiRequestResize(uint width, uint height) = 0;
165 virtual bool clapGuiRequestShow() = 0;
166 virtual bool clapGuiRequestHide() = 0;
167 virtual void clapGuiClosed(bool wasDestroyed) = 0;
168 #ifdef _POSIX_VERSION
169 // posix fd
170 virtual bool clapRegisterPosixFD(int fd, clap_posix_fd_flags_t flags) = 0;
171 virtual bool clapModifyPosixFD(int fd, clap_posix_fd_flags_t flags) = 0;
172 virtual bool clapUnregisterPosixFD(int fd) = 0;
173 #endif
174 // timer
175 virtual bool clapRegisterTimer(uint32_t periodInMs, clap_id* timerId) = 0;
176 virtual bool clapUnregisterTimer(clap_id timerId) = 0;
177 #endif
178 };
179
180 Callbacks* const hostCallbacks;
181
182 clap_host_latency_t latency;
183 clap_host_state_t state;
184 #ifdef CLAP_WINDOW_API_NATIVE
185 clap_host_gui_t gui;
186 #ifdef _POSIX_VERSION
187 clap_host_posix_fd_support_t posixFD;
188 #endif
189 clap_host_timer_support_t timer;
190 #endif
191
192 carla_clap_host(Callbacks* const hostCb)
193 : hostCallbacks(hostCb)
194 {
195 clap_version = CLAP_VERSION;
196 host_data = this;
197 name = "Carla";
198 vendor = "falkTX";
199 url = "https://kx.studio/carla";
200 version = CARLA_VERSION_STRING;
201
202 get_extension = carla_get_extension;
203 request_restart = carla_request_restart;
204 request_process = carla_request_process;
205 request_callback = carla_request_callback;
206
207 latency.changed = carla_latency_changed;
208
209 state.mark_dirty = carla_mark_dirty;
210
211 #ifdef CLAP_WINDOW_API_NATIVE
212 gui.resize_hints_changed = carla_resize_hints_changed;
213 gui.request_resize = carla_request_resize;
214 gui.request_show = carla_request_show;
215 gui.request_hide = carla_request_hide;
216 gui.closed = carla_closed;
217
218 #ifdef _POSIX_VERSION
219 posixFD.register_fd = carla_register_fd;
220 posixFD.modify_fd = carla_modify_fd;
221 posixFD.unregister_fd = carla_unregister_fd;
222 #endif
223
224 timer.register_timer = carla_register_timer;
225 timer.unregister_timer = carla_unregister_timer;
226 #endif
227 }
228
229 static const void* CLAP_ABI carla_get_extension(const clap_host_t* const host, const char* const extension_id)
230 {
231 carla_clap_host* const self = static_cast<carla_clap_host*>(host->host_data);
232
233 if (std::strcmp(extension_id, CLAP_EXT_LATENCY) == 0)
234 return &self->latency;
235 if (std::strcmp(extension_id, CLAP_EXT_STATE) == 0)
236 return &self->state;
237 #ifdef CLAP_WINDOW_API_NATIVE
238 if (std::strcmp(extension_id, CLAP_EXT_GUI) == 0)
239 return &self->gui;
240 #ifdef _POSIX_VERSION
241 if (std::strcmp(extension_id, CLAP_EXT_POSIX_FD_SUPPORT) == 0)
242 return &self->posixFD;
243 #endif
244 if (std::strcmp(extension_id, CLAP_EXT_TIMER_SUPPORT) == 0)
245 return &self->timer;
246 #endif
247
248 carla_stderr("Plugin requested unsupported CLAP extension '%s'", extension_id);
249 return nullptr;
250 }
251
252 static void CLAP_ABI carla_request_restart(const clap_host_t* const host)
253 {
254 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapRequestRestart();
255 }
256
257 static void CLAP_ABI carla_request_process(const clap_host_t* const host)
258 {
259 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapRequestProcess();
260 }
261
262 static void CLAP_ABI carla_request_callback(const clap_host_t* const host)
263 {
264 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapRequestCallback();
265 }
266
267 static void CLAP_ABI carla_latency_changed(const clap_host_t* const host)
268 {
269 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapLatencyChanged();
270 }
271
272 static void CLAP_ABI carla_mark_dirty(const clap_host_t* const host)
273 {
274 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapMarkDirty();
275 }
276
277 #ifdef CLAP_WINDOW_API_NATIVE
278 static void CLAP_ABI carla_resize_hints_changed(const clap_host_t* const host)
279 {
280 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapGuiResizeHintsChanged();
281 }
282
283 static bool CLAP_ABI carla_request_resize(const clap_host_t* const host, const uint32_t width, const uint32_t height)
284 {
285 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapGuiRequestResize(width, height);
286 }
287
288 static bool CLAP_ABI carla_request_show(const clap_host_t* const host)
289 {
290 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapGuiRequestShow();
291 }
292
293 static bool CLAP_ABI carla_request_hide(const clap_host_t* const host)
294 {
295 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapGuiRequestHide();
296 }
297
298 static void CLAP_ABI carla_closed(const clap_host_t* const host, bool was_destroyed)
299 {
300 static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapGuiClosed(was_destroyed);
301 }
302
303 #ifdef _POSIX_VERSION
304 static bool CLAP_ABI carla_register_fd(const clap_host_t* const host, const int fd, const clap_posix_fd_flags_t flags)
305 {
306 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapRegisterPosixFD(fd, flags);
307 }
308
309 static bool CLAP_ABI carla_modify_fd(const clap_host_t* const host, const int fd, const clap_posix_fd_flags_t flags)
310 {
311 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapModifyPosixFD(fd, flags);
312 }
313
314 static bool CLAP_ABI carla_unregister_fd(const clap_host_t* const host, const int fd)
315 {
316 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapUnregisterPosixFD(fd);
317 }
318 #endif
319
320 static bool CLAP_ABI carla_register_timer(const clap_host_t* const host, const uint32_t period_ms, clap_id* const timer_id)
321 {
322 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapRegisterTimer(period_ms, timer_id);
323 }
324
325 static bool CLAP_ABI carla_unregister_timer(const clap_host_t* const host, const clap_id timer_id)
326 {
327 return static_cast<const carla_clap_host*>(host->host_data)->hostCallbacks->clapUnregisterTimer(timer_id);
328 }
329 #endif
330 };
331
332 // --------------------------------------------------------------------------------------------------------------------
333
334 struct carla_clap_input_audio_buffers {
335 clap_audio_buffer_const_t* buffers;
336 clap_audio_buffer_extra_data_t* extra;
337 uint32_t count;
338
339 carla_clap_input_audio_buffers() noexcept
340 : buffers(nullptr),
341 extra(nullptr),
342 count(0) {}
343
344 ~carla_clap_input_audio_buffers()
345 {
346 delete[] buffers;
347 delete[] extra;
348 }
349
350 void realloc(const uint32_t portCount)
351 {
352 delete[] buffers;
353 delete[] extra;
354 count = portCount;
355
356 if (portCount != 0)
357 {
358 buffers = new clap_audio_buffer_const_t[portCount];
359 extra = new clap_audio_buffer_extra_data_t[portCount];
360 carla_zeroStructs(buffers, portCount);
361 carla_zeroStructs(extra, portCount);
362 }
363 else
364 {
365 buffers = nullptr;
366 extra = nullptr;
367 }
368 }
369
370 const clap_audio_buffer_t* cast() const noexcept
371 {
372 return static_cast<const clap_audio_buffer_t*>(static_cast<const void*>(buffers));
373 }
374 };
375
376 struct carla_clap_output_audio_buffers {
377 clap_audio_buffer_t* buffers;
378 clap_audio_buffer_extra_data_t* extra;
379 uint32_t count;
380
381 carla_clap_output_audio_buffers() noexcept
382 : buffers(nullptr),
383 extra(nullptr),
384 count(0) {}
385
386 ~carla_clap_output_audio_buffers()
387 {
388 delete[] buffers;
389 delete[] extra;
390 }
391
392 void realloc(const uint32_t portCount)
393 {
394 delete[] buffers;
395 delete[] extra;
396 count = portCount;
397
398 if (portCount != 0)
399 {
400 buffers = new clap_audio_buffer_t[portCount];
401 extra = new clap_audio_buffer_extra_data_t[portCount];
402 carla_zeroStructs(buffers, portCount);
403 carla_zeroStructs(extra, portCount);
404 }
405 else
406 {
407 buffers = nullptr;
408 extra = nullptr;
409 }
410 }
411 };
412
413 // --------------------------------------------------------------------------------------------------------------------
414
415 struct carla_clap_input_events : clap_input_events_t, CarlaPluginClapEventData {
416 union Event {
417 clap_event_header_t header;
418 clap_event_param_value_t param;
419 clap_event_param_gesture_t gesture;
420 clap_event_midi_t midi;
421 clap_event_note_t note;
422 clap_event_midi_sysex_t sysex;
423 };
424
425 struct ScheduledParameterUpdate {
426 bool updated;
427 double value;
428 clap_id clapId;
429 void* cookie;
430
431 ScheduledParameterUpdate()
432 : updated(false),
433 value(0.f),
434 clapId(0),
435 cookie(0) {}
436 };
437
438 Event* events;
439 ScheduledParameterUpdate* updatedParams;
440
441 uint32_t numEventsAllocated;
442 uint32_t numEventsUsed;
443 uint32_t numParams;
444
445 carla_clap_input_events()
446 : CarlaPluginClapEventData(),
447 events(nullptr),
448 updatedParams(nullptr),
449 numEventsAllocated(0),
450 numEventsUsed(0),
451 numParams(0)
452 {
453 ctx = this;
454 size = carla_size;
455 get = carla_get;
456 }
457
458 ~carla_clap_input_events()
459 {
460 delete[] events;
461 delete[] updatedParams;
462 }
463
464 // called on plugin reload
465 // NOTE: clapId and cookie must be separately set outside this function
466 void realloc(CarlaEngineEventPort* const defPortIn, const uint32_t portCount, const uint32_t paramCount)
467 {
468 numEventsUsed = 0;
469 numParams = paramCount;
470 delete[] events;
471 delete[] updatedParams;
472
473 if (portCount != 0 || paramCount != 0)
474 {
475 static_assert(kPluginMaxMidiEvents > MAX_MIDI_NOTE, "Enough space for input events");
476
477 numEventsAllocated = paramCount * 2 + kPluginMaxMidiEvents * std::max(1u, portCount);
478 events = new Event[numEventsAllocated];
479 updatedParams = new ScheduledParameterUpdate[paramCount];
480 }
481 else
482 {
483 numEventsAllocated = 0;
484 events = nullptr;
485 updatedParams = nullptr;
486 }
487
488 CarlaPluginClapEventData::clear(defPortIn);
489
490 if (portCount != 0)
491 CarlaPluginClapEventData::createNew(portCount);
492 }
493
494 // used for temporary copies (this instance must be empty)
495 void reallocEqualTo(const carla_clap_input_events& other)
496 {
497 numParams = other.numParams;
498 numEventsAllocated = other.numEventsAllocated;
499
500 if (numEventsAllocated != 0)
501 {
502 events = new Event[numEventsAllocated];
503 updatedParams = new ScheduledParameterUpdate[numParams];
504
505 for (uint32_t i=0; i<numParams; ++i)
506 {
507 updatedParams[i].clapId = other.updatedParams[i].clapId;
508 updatedParams[i].cookie = other.updatedParams[i].cookie;
509 }
510 }
511 }
512
513 void swap(carla_clap_input_events& other)
514 {
515 CARLA_SAFE_ASSERT_RETURN(numParams == other.numParams,);
516 CARLA_SAFE_ASSERT_RETURN(numEventsAllocated == other.numEventsAllocated,);
517
518 std::swap(numEventsUsed, other.numEventsUsed);
519 std::swap(updatedParams, other.updatedParams);
520 std::swap(events, other.events);
521 }
522
523 const clap_input_events_t* cast() const noexcept
524 {
525 return static_cast<const clap_input_events_t*>(this);
526 }
527
528 // called just before plugin processing
529 void handleScheduledParameterUpdates()
530 {
531 uint32_t count = 0;
532
533 for (uint32_t i=0; i<numParams; ++i)
534 {
535 if (updatedParams[i].updated)
536 {
537 events[count++].param = {
538 { sizeof(clap_event_param_value_t), 0, 0, CLAP_EVENT_PARAM_VALUE, 0 },
539 updatedParams[i].clapId,
540 updatedParams[i].cookie,
541 -1, -1, -1, -1,
542 updatedParams[i].value
543 };
544
545 updatedParams[i].updated = false;
546 }
547 }
548
549 numEventsUsed = count;
550 }
551
552 // called when a parameter is set from non-rt thread
553 void setParamValue(const uint32_t index, const float value) noexcept
554 {
555 CARLA_SAFE_ASSERT_RETURN(index < numParams,);
556
557 updatedParams[index].value = value;
558 updatedParams[index].updated = true;
559 }
560
561 // called when a parameter is set from rt thread
562 void setParamValueRT(const uint32_t index, const float value, const uint32_t frameOffset) noexcept
563 {
564 CARLA_SAFE_ASSERT_RETURN(index < numParams,);
565
566 if (numEventsUsed == numEventsAllocated)
567 return;
568
569 events[numEventsUsed++].param = {
570 { sizeof(clap_event_param_value_t), frameOffset, 0, CLAP_EVENT_PARAM_VALUE, CLAP_EVENT_IS_LIVE },
571 updatedParams[index].clapId,
572 updatedParams[index].cookie,
573 -1, -1, -1, -1,
574 value
575 };
576 }
577
578 void addSimpleMidiEvent(const bool isLive, const uint16_t port, const uint32_t frameOffset, const uint8_t data[3])
579 {
580 if (numEventsUsed == numEventsAllocated)
581 return;
582
583 events[numEventsUsed++].midi = {
584 { sizeof(clap_event_midi_t), frameOffset, 0, CLAP_EVENT_MIDI, isLive ? (uint32_t)CLAP_EVENT_IS_LIVE : 0u },
585 port,
586 { data[0], data[1], data[2] }
587 };
588 }
589
590 void addSimpleNoteEvent(const bool isLive, const int16_t port, const uint32_t frameOffset,
591 const uint8_t channel, const uint8_t key, const uint8_t velocity)
592 {
593 if (numEventsUsed == numEventsAllocated)
594 return;
595
596 const uint16_t eventType = velocity > 0 ? CLAP_EVENT_NOTE_ON : CLAP_EVENT_NOTE_OFF;
597
598 events[numEventsUsed++].note = {
599 { sizeof(clap_event_note_t), frameOffset, 0, eventType, isLive ? (uint32_t)CLAP_EVENT_IS_LIVE : 0u },
600 -1,
601 port,
602 channel,
603 key,
604 static_cast<double>(velocity) / 127.0
605 };
606 }
607
608 static uint32_t CLAP_ABI carla_size(const clap_input_events_t* const list) noexcept
609 {
610 return static_cast<const carla_clap_input_events*>(list->ctx)->numEventsUsed;
611 }
612
613 static const clap_event_header_t* CLAP_ABI carla_get(const clap_input_events_t* const list, const uint32_t index) noexcept
614 {
615 return &static_cast<const carla_clap_input_events*>(list->ctx)->events[index].header;
616 }
617 };
618
619 // --------------------------------------------------------------------------------------------------------------------
620
621 struct carla_clap_output_events : clap_output_events_t, CarlaPluginClapEventData {
622 union Event {
623 clap_event_header_t header;
624 clap_event_param_value_t param;
625 clap_event_midi_t midi;
626 };
627
628 Event* events;
629 uint32_t numEventsAllocated;
630 uint32_t numEventsUsed;
631
632 carla_clap_output_events()
633 : events(nullptr),
634 numEventsAllocated(0),
635 numEventsUsed(0)
636 {
637 ctx = this;
638 try_push = carla_try_push;
639 }
640
641 ~carla_clap_output_events()
642 {
643 delete[] events;
644 }
645
646 // called on plugin reload
647 void realloc(CarlaEngineEventPort* const defPortOut, const uint32_t portCount, const uint32_t paramCount)
648 {
649 numEventsUsed = 0;
650 delete[] events;
651
652 if (portCount != 0 || paramCount != 0)
653 {
654 numEventsAllocated = paramCount + kPluginMaxMidiEvents * std::max(1u, portCount);
655 events = new Event[numEventsAllocated];
656 }
657 else
658 {
659 numEventsAllocated = 0;
660 events = nullptr;
661 }
662
663 CarlaPluginClapEventData::clear(defPortOut);
664
665 if (portCount != 0)
666 CarlaPluginClapEventData::createNew(portCount);
667 }
668
669 const clap_output_events_t* cast() const noexcept
670 {
671 return static_cast<const clap_output_events_t*>(this);
672 }
673
674 bool tryPush(const clap_event_header_t* const event)
675 {
676 if (numEventsUsed == numEventsAllocated)
677 return false;
678
679 Event e;
680 switch (event->type)
681 {
682 case CLAP_EVENT_PARAM_VALUE:
683 e.param = *static_cast<const clap_event_param_value_t*>(static_cast<const void*>(event));
684 break;
685 case CLAP_EVENT_MIDI:
686 e.midi = *static_cast<const clap_event_midi_t*>(static_cast<const void*>(event));
687 break;
688 default:
689 return false;
690 }
691
692 events[numEventsUsed++] = e;
693 return true;
694 }
695
696 static bool CLAP_ABI carla_try_push(const clap_output_events_t* const list, const clap_event_header_t* const event)
697 {
698 return static_cast<carla_clap_output_events*>(list->ctx)->tryPush(event);
699 }
700 };
701
702 // --------------------------------------------------------------------------------------------------------------------
703
704 class CarlaPluginCLAP : public CarlaPlugin,
705 #ifdef CLAP_WINDOW_API_NATIVE
706 private CarlaPluginUI::Callback,
707 #endif
708 private carla_clap_host::Callbacks
709 {
710 public:
711 CarlaPluginCLAP(CarlaEngine* const engine, const uint id)
712 : CarlaPlugin(engine, id),
713 fPlugin(nullptr),
714 fPluginDescriptor(nullptr),
715 fPluginEntry(nullptr),
716 fHost(this),
717 fExtensions(),
718 fInputAudioBuffers(),
719 fOutputAudioBuffers(),
720 fInputEvents(),
721 fOutputEvents(),
722 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
723 fAudioOutBuffers(nullptr),
724 #endif
725 fLastChunk(nullptr),
726 fLastKnownLatency(0),
727 kEngineHasIdleOnMainThread(engine->hasIdleOnMainThread()),
728 fNeedsParamFlush(false),
729 fNeedsRestart(false),
730 fNeedsProcess(false),
731 fNeedsIdleCallback(false)
732 {
733 carla_debug("CarlaPluginCLAP::CarlaPluginCLAP(%p, %i)", engine, id);
734 }
735
736 ~CarlaPluginCLAP() override
737 {
738 carla_debug("CarlaPluginCLAP::~CarlaPluginCLAP()");
739
740 runIdleCallbacksAsNeeded(false);
741
742 #ifdef CLAP_WINDOW_API_NATIVE
743 // close UI
744 if (fUI.isCreated)
745 showCustomUI(false);
746 #endif
747
748 pData->singleMutex.lock();
749 pData->masterMutex.lock();
750
751 if (pData->client != nullptr && pData->client->isActive())
752 pData->client->deactivate(true);
753
754 if (pData->active)
755 {
756 deactivate();
757 pData->active = false;
758 }
759
760 if (fPlugin != nullptr)
761 {
762 fPlugin->destroy(fPlugin);
763 fPlugin = nullptr;
764 }
765
766 if (fLastChunk != nullptr)
767 {
768 std::free(fLastChunk);
769 fLastChunk = nullptr;
770 }
771
772 clearBuffers();
773
774 if (fPluginEntry != nullptr)
775 {
776 fPluginEntry->deinit();
777 fPluginEntry = nullptr;
778 }
779 }
780
781 // -------------------------------------------------------------------
782 // Information (base)
783
784 PluginType getType() const noexcept override
785 {
786 return PLUGIN_CLAP;
787 }
788
789 PluginCategory getCategory() const noexcept override
790 {
791 CARLA_SAFE_ASSERT_RETURN(fPluginDescriptor != nullptr, PLUGIN_CATEGORY_NONE);
792
793 if (fPluginDescriptor->features == nullptr)
794 return PLUGIN_CATEGORY_NONE;
795
796 return getPluginCategoryFromClapFeatures(fPluginDescriptor->features);
797 }
798
799 uint32_t getLatencyInFrames() const noexcept override
800 {
801 // under clap we can only request plugin latency in main thread,
802 // which is unsuitable for this call
803 return fLastKnownLatency;
804 }
805
806 // -------------------------------------------------------------------
807 // Information (count)
808
809 uint32_t getMidiInCount() const noexcept override
810 {
811 return fInputEvents.portCount;
812 }
813
814 uint32_t getMidiOutCount() const noexcept override
815 {
816 return fOutputEvents.portCount;
817 }
818
819 // -------------------------------------------------------------------
820 // Information (current data)
821
822 uint getAudioPortHints(const bool isOutput, const uint32_t portIndex) const noexcept override
823 {
824 uint hints = 0x0;
825
826 if (isOutput)
827 {
828 for (uint32_t i=0, j=0; i<fOutputAudioBuffers.count; ++i, j+=fOutputAudioBuffers.buffers[i].channel_count)
829 {
830 if (j != portIndex)
831 continue;
832
833 if (!fOutputAudioBuffers.extra[i].isMain)
834 hints |= AUDIO_PORT_IS_SIDECHAIN;
835 }
836 }
837 else
838 {
839 for (uint32_t i=0, j=0; i<fInputAudioBuffers.count; ++i, j+=fInputAudioBuffers.buffers[i].channel_count)
840 {
841 if (j != portIndex)
842 continue;
843
844 if (!fInputAudioBuffers.extra[i].isMain)
845 hints |= AUDIO_PORT_IS_SIDECHAIN;
846 }
847 }
848
849 return hints;
850 }
851
852 std::size_t getChunkData(void** const dataPtr) noexcept override
853 {
854 CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS, 0);
855 CARLA_SAFE_ASSERT_RETURN(fExtensions.state != nullptr, 0);
856 CARLA_SAFE_ASSERT_RETURN(dataPtr != nullptr, 0);
857
858 std::free(fLastChunk);
859
860 clap_ostream_impl stream;
861 if (fExtensions.state->save(fPlugin, &stream))
862 {
863 *dataPtr = fLastChunk = stream.buffer;
864 runIdleCallbacksAsNeeded(false);
865 return stream.size;
866 }
867 else
868 {
869 *dataPtr = fLastChunk = nullptr;
870 runIdleCallbacksAsNeeded(false);
871 return 0;
872 }
873 }
874
875 // -------------------------------------------------------------------
876 // Information (per-plugin data)
877
878 uint getOptionsAvailable() const noexcept override
879 {
880 uint options = 0x0;
881
882 if (fExtensions.state != nullptr)
883 options |= PLUGIN_OPTION_USE_CHUNKS;
884
885 for (uint32_t i=0; i<fInputEvents.portCount; ++i)
886 {
887 if (fInputEvents.portData[i].supportedDialects & CLAP_NOTE_DIALECT_MIDI)
888 {
889 options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
890 options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
891 options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
892 options |= PLUGIN_OPTION_SEND_PITCHBEND;
893 options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
894 options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
895 options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
896 break;
897 }
898 if (fInputEvents.portData[i].supportedDialects & CLAP_NOTE_DIALECT_CLAP)
899 {
900 options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
901 // nobreak, in case another port supports MIDI
902 }
903 }
904
905 return options;
906 }
907
908 double getBestParameterValue(const uint32_t parameterId, const clap_id clapId) const noexcept
909 {
910 if (fInputEvents.updatedParams[parameterId].updated)
911 return fInputEvents.updatedParams[parameterId].value;
912
913 double value;
914 CARLA_SAFE_ASSERT_RETURN(fExtensions.params->get_value(fPlugin, clapId, &value), 0.0);
915
916 return value;
917 }
918
919 float getParameterValue(const uint32_t parameterId) const noexcept override
920 {
921 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr, 0.f);
922 CARLA_SAFE_ASSERT_RETURN(fExtensions.params != nullptr, 0.f);
923
924 return getBestParameterValue(parameterId, pData->param.data[parameterId].rindex);
925 }
926
927 bool getLabel(char* const strBuf) const noexcept override
928 {
929 CARLA_SAFE_ASSERT_RETURN(fPluginDescriptor != nullptr, false);
930
931 std::strncpy(strBuf, fPluginDescriptor->id, STR_MAX);
932 return true;
933 }
934
935 bool getMaker(char* const strBuf) const noexcept override
936 {
937 CARLA_SAFE_ASSERT_RETURN(fPluginDescriptor != nullptr, false);
938
939 std::strncpy(strBuf, fPluginDescriptor->vendor, STR_MAX);
940 return true;
941 }
942
943 bool getCopyright(char* const strBuf) const noexcept override
944 {
945 return getMaker(strBuf);
946 }
947
948 bool getRealName(char* const strBuf) const noexcept override
949 {
950 CARLA_SAFE_ASSERT_RETURN(fPluginDescriptor != nullptr, false);
951
952 std::strncpy(strBuf, fPluginDescriptor->name, STR_MAX);
953 return true;
954 }
955
956 bool getParameterName(const uint32_t parameterId, char* const strBuf) const noexcept override
957 {
958 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr, false);
959 CARLA_SAFE_ASSERT_RETURN(fExtensions.params != nullptr, false);
960 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
961
962 clap_param_info_t paramInfo = {};
963 CARLA_SAFE_ASSERT_RETURN(fExtensions.params->get_info(fPlugin, parameterId, &paramInfo), false);
964
965 std::strncpy(strBuf, paramInfo.name, STR_MAX);
966 strBuf[STR_MAX-1] = '\0';
967 return true;
968 }
969
970 bool getParameterSymbol(const uint32_t parameterId, char* const strBuf) const noexcept override
971 {
972 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
973
974 const clap_id clapId = pData->param.data[parameterId].rindex;
975 std::snprintf(strBuf, STR_MAX, "%u", clapId);
976 return true;
977 }
978
979 bool getParameterText(const uint32_t parameterId, char* const strBuf) noexcept override
980 {
981 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr, false);
982 CARLA_SAFE_ASSERT_RETURN(fExtensions.params != nullptr, false);
983 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
984
985 const clap_id clapId = pData->param.data[parameterId].rindex;
986 const double value = getBestParameterValue(parameterId, clapId);
987
988 return fExtensions.params->value_to_text(fPlugin, clapId, value, strBuf, STR_MAX);
989 }
990
991 bool getParameterGroupName(const uint32_t parameterId, char* const strBuf) const noexcept override
992 {
993 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr, false);
994 CARLA_SAFE_ASSERT_RETURN(fExtensions.params != nullptr, false);
995 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count, false);
996
997 clap_param_info_t paramInfo = {};
998 CARLA_SAFE_ASSERT_RETURN(fExtensions.params->get_info(fPlugin, parameterId, &paramInfo), false);
999
1000 if (paramInfo.module[0] == '\0')
1001 return false;
1002
1003 if (char* const sep = std::strrchr(paramInfo.module, '/'))
1004 {
1005 paramInfo.module[STR_MAX/2-2] = sep[0] = '\0';
1006
1007 char strBuf2[STR_MAX/2];
1008 std::strncpy(strBuf2, paramInfo.module, STR_MAX/2);
1009 strBuf2[STR_MAX/2-1] = '\0';
1010
1011 std::snprintf(strBuf, STR_MAX, "%s:%s", strBuf2, strBuf2);
1012 strBuf[STR_MAX-1] = '\0';
1013 return true;
1014 }
1015
1016 return false;
1017 }
1018
1019 // -------------------------------------------------------------------
1020 // Set data (state)
1021
1022 // nothing
1023
1024 // -------------------------------------------------------------------
1025 // Set data (internal stuff)
1026
1027 #ifdef CLAP_WINDOW_API_NATIVE
1028 void setName(const char* const newName) override
1029 {
1030 CarlaPlugin::setName(newName);
1031
1032 if (fUI.isCreated && pData->uiTitle.isEmpty())
1033 setWindowTitle(nullptr);
1034 }
1035 #endif
1036
1037 // -------------------------------------------------------------------
1038 // Set data (plugin-specific stuff)
1039
1040 void setParameterValue(const uint32_t parameterId, const float value, const bool sendGui, const bool sendOsc, const bool sendCallback) noexcept override
1041 {
1042 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
1043 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
1044
1045 const float fixedValue = pData->param.getFixedValue(parameterId, value);
1046 fInputEvents.setParamValue(parameterId, fixedValue);
1047
1048 if (!pData->active && fExtensions.params->flush != nullptr)
1049 fNeedsParamFlush = true;
1050
1051 CarlaPlugin::setParameterValue(parameterId, fixedValue, sendGui, sendOsc, sendCallback);
1052 }
1053
1054 void setParameterValueRT(const uint32_t parameterId, const float value, const uint32_t frameOffset, const bool sendCallbackLater) noexcept override
1055 {
1056 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
1057 CARLA_SAFE_ASSERT_RETURN(parameterId < pData->param.count,);
1058
1059 const float fixedValue = pData->param.getFixedValue(parameterId, value);
1060 fInputEvents.setParamValueRT(parameterId, fixedValue, frameOffset);
1061
1062 CarlaPlugin::setParameterValueRT(parameterId, fixedValue, frameOffset, sendCallbackLater);
1063 }
1064
1065 void setChunkData(const void* const data, const std::size_t dataSize) override
1066 {
1067 CARLA_SAFE_ASSERT_RETURN(pData->options & PLUGIN_OPTION_USE_CHUNKS,);
1068 CARLA_SAFE_ASSERT_RETURN(fExtensions.state != nullptr,);
1069 CARLA_SAFE_ASSERT_RETURN(data != nullptr,);
1070 CARLA_SAFE_ASSERT_RETURN(dataSize > 0,);
1071
1072 const clap_istream_impl stream(data, dataSize);
1073 if (fExtensions.state->load(fPlugin, &stream))
1074 pData->updateParameterValues(this, true, true, false);
1075
1076 runIdleCallbacksAsNeeded(false);
1077 }
1078
1079 // -------------------------------------------------------------------
1080 // Set ui stuff
1081
1082 #ifdef CLAP_WINDOW_API_NATIVE
1083 void setWindowTitle(const char* const title) noexcept
1084 {
1085 if (!fUI.isCreated)
1086 return;
1087
1088 CarlaString uiTitle;
1089
1090 if (title != nullptr)
1091 {
1092 uiTitle = title;
1093 }
1094 else
1095 {
1096 uiTitle = pData->name;
1097 uiTitle += " (GUI)";
1098 }
1099
1100 if (fUI.isEmbed)
1101 {
1102 if (fUI.window != nullptr)
1103 fUI.window->setTitle(uiTitle.buffer());
1104 }
1105 else
1106 {
1107 fExtensions.gui->suggest_title(fPlugin, uiTitle.buffer());
1108 }
1109 }
1110
1111 void setCustomUITitle(const char* const title) noexcept override
1112 {
1113 setWindowTitle(title);
1114 CarlaPlugin::setCustomUITitle(title);
1115 }
1116
1117 void showCustomUI(const bool yesNo) override
1118 {
1119 CARLA_SAFE_ASSERT_RETURN(fExtensions.gui != nullptr,);
1120
1121 if (fUI.isVisible == yesNo)
1122 return;
1123
1124 if (yesNo)
1125 {
1126 if (fUI.isVisible)
1127 {
1128 fExtensions.gui->show(fPlugin);
1129
1130 if (fUI.isEmbed)
1131 {
1132 CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);
1133 fUI.window->show();
1134 fUI.window->focus();
1135 }
1136
1137 runIdleCallbacksAsNeeded(false);
1138 return;
1139 }
1140
1141 if (!fUI.initalized)
1142 {
1143 fUI.isEmbed = fExtensions.gui->is_api_supported(fPlugin, CLAP_WINDOW_API_NATIVE, false);
1144 fUI.initalized = true;
1145 }
1146
1147 if (!fUI.isCreated)
1148 {
1149 if (!fExtensions.gui->create(fPlugin, CLAP_WINDOW_API_NATIVE, !fUI.isEmbed))
1150 {
1151 pData->engine->callback(true, true,
1152 ENGINE_CALLBACK_UI_STATE_CHANGED,
1153 pData->id,
1154 -1,
1155 0, 0, 0.0f,
1156 "Plugin refused to open its own UI");
1157 return;
1158 }
1159 fUI.isCreated = true;
1160 }
1161
1162 const bool resizable = fExtensions.gui->can_resize(fPlugin);
1163
1164 const EngineOptions& opts(pData->engine->getOptions());
1165
1166 #if defined(CARLA_OS_WIN)
1167 fUI.window = CarlaPluginUI::newWindows(this, opts.frontendWinId, opts.pluginsAreStandalone, resizable);
1168 #elif defined(CARLA_OS_MAC)
1169 fUI.window = CarlaPluginUI::newCocoa(this, opts.frontendWinId, opts.pluginsAreStandalone, resizable);
1170 #elif defined(HAVE_X11)
1171 fUI.window = CarlaPluginUI::newX11(this, opts.frontendWinId, opts.pluginsAreStandalone, resizable, false);
1172 #else
1173 pData->engine->callback(true, true,
1174 ENGINE_CALLBACK_UI_STATE_CHANGED,
1175 pData->id,
1176 -1,
1177 0, 0, 0.0f,
1178 "Unsupported UI type");
1179 return;
1180 #endif
1181
1182 #ifndef CARLA_OS_MAC
1183 if (carla_isNotZero(opts.uiScale))
1184 fExtensions.gui->set_scale(fPlugin, opts.uiScale);
1185 #endif
1186
1187 setWindowTitle(nullptr);
1188
1189 if (fUI.isEmbed)
1190 {
1191 clap_window_t win = { CLAP_WINDOW_API_NATIVE, {} };
1192 win.ptr = fUI.window->getPtr();
1193
1194 fExtensions.gui->set_parent(fPlugin, &win);
1195
1196 uint32_t width, height;
1197 if (fExtensions.gui->get_size(fPlugin, &width, &height))
1198 {
1199 fUI.isResizingFromInit = true;
1200 fUI.width = width;
1201 fUI.height = height;
1202 fUI.window->setSize(width, height, true, true);
1203 }
1204
1205 fExtensions.gui->show(fPlugin);
1206 fUI.window->show();
1207 }
1208 else
1209 {
1210 clap_window_t win = { CLAP_WINDOW_API_NATIVE, {} };
1211 win.uptr = opts.frontendWinId;
1212 fExtensions.gui->set_transient(fPlugin, &win);
1213 fExtensions.gui->show(fPlugin);
1214 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1215 pData->tryTransient();
1216 #endif
1217 }
1218
1219 fUI.isVisible = true;
1220 }
1221 else
1222 {
1223 fUI.isVisible = false;
1224
1225 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1226 pData->transientTryCounter = 0;
1227 #endif
1228
1229 if (fUI.window != nullptr)
1230 fUI.window->hide();
1231
1232 fExtensions.gui->hide(fPlugin);
1233
1234 if (fUI.isCreated)
1235 {
1236 fExtensions.gui->destroy(fPlugin);
1237 fUI.isCreated = false;
1238 }
1239
1240 if (fUI.window != nullptr)
1241 {
1242 delete fUI.window;
1243 fUI.window = nullptr;
1244 }
1245 }
1246
1247 runIdleCallbacksAsNeeded(true);
1248 }
1249
1250 void* embedCustomUI(void* const ptr) override
1251 {
1252 CARLA_SAFE_ASSERT_RETURN(fUI.window == nullptr, nullptr);
1253
1254 if (!fUI.initalized)
1255 {
1256 fUI.isEmbed = fExtensions.gui->is_api_supported(fPlugin, CLAP_WINDOW_API_NATIVE, false);
1257 fUI.initalized = true;
1258 }
1259
1260 if (!fUI.isCreated)
1261 {
1262 if (!fExtensions.gui->create(fPlugin, CLAP_WINDOW_API_NATIVE, false))
1263 {
1264 pData->engine->callback(true, true,
1265 ENGINE_CALLBACK_UI_STATE_CHANGED,
1266 pData->id,
1267 -1,
1268 0, 0, 0.0f,
1269 "Plugin refused to open its own UI");
1270 return nullptr;
1271 }
1272 fUI.isCreated = true;
1273 }
1274
1275 fUI.isVisible = true;
1276
1277 #ifndef CARLA_OS_MAC
1278 const EngineOptions& opts(pData->engine->getOptions());
1279
1280 if (carla_isNotZero(opts.uiScale))
1281 fExtensions.gui->set_scale(fPlugin, opts.uiScale);
1282 #endif
1283
1284 clap_window_t win = { CLAP_WINDOW_API_NATIVE, {} };
1285 win.ptr = ptr;
1286
1287 fExtensions.gui->set_parent(fPlugin, &win);
1288
1289 uint32_t width, height;
1290 if (fExtensions.gui->get_size(fPlugin, &width, &height))
1291 {
1292 fUI.isResizingFromInit = true;
1293 fUI.width = width;
1294 fUI.height = height;
1295 pData->engine->callback(true, true,
1296 ENGINE_CALLBACK_EMBED_UI_RESIZED,
1297 pData->id, width, height,
1298 0, 0.0f, nullptr);
1299 }
1300
1301 fExtensions.gui->show(fPlugin);
1302
1303 return nullptr;
1304 }
1305 #endif
1306
1307 void idle() override
1308 {
1309 if (kEngineHasIdleOnMainThread)
1310 runIdleCallbacksAsNeeded(true);
1311
1312 CarlaPlugin::idle();
1313 }
1314
1315 void uiIdle() override
1316 {
1317 #ifdef CLAP_WINDOW_API_NATIVE
1318 if (fUI.shouldClose)
1319 {
1320 fUI.shouldClose = false;
1321 fUI.isResizingFromHost = fUI.isResizingFromInit = false;
1322 fUI.isResizingFromPlugin = 0;
1323
1324 showCustomUI(false);
1325 pData->engine->callback(true, true,
1326 ENGINE_CALLBACK_UI_STATE_CHANGED,
1327 pData->id,
1328 0,
1329 0, 0, 0.0f, nullptr);
1330 }
1331
1332 if (fUI.isResizingFromHost)
1333 {
1334 fUI.isResizingFromHost = false;
1335
1336 if (fUI.isResizingFromPlugin == 0 && !fUI.isResizingFromInit == false)
1337 {
1338 carla_stdout("Host resize restarted");
1339 fExtensions.gui->set_size(fPlugin, fUI.width, fUI.height);
1340 }
1341 }
1342
1343 if (fUI.window != nullptr)
1344 fUI.window->idle();
1345
1346 if (fUI.isResizingFromPlugin == 2)
1347 {
1348 fUI.isResizingFromPlugin = 1;
1349 }
1350 else if (fUI.isResizingFromPlugin == 1)
1351 {
1352 fUI.isResizingFromPlugin = 0;
1353 carla_stdout("Plugin resize stopped");
1354 }
1355 #endif
1356
1357 if (!kEngineHasIdleOnMainThread)
1358 runIdleCallbacksAsNeeded(true);
1359
1360 CarlaPlugin::uiIdle();
1361 }
1362
1363 // -------------------------------------------------------------------
1364 // Plugin state
1365
1366 void reload() override
1367 {
1368 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr,);
1369 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
1370 carla_debug("CarlaPluginCLAP::reload() - start");
1371
1372 // Safely disable plugin for reload
1373 const ScopedDisabler sd(this);
1374
1375 if (pData->active)
1376 deactivate();
1377
1378 clearBuffers();
1379
1380 const clap_plugin_audio_ports_t* audioPortsExt = static_cast<const clap_plugin_audio_ports_t*>(
1381 fPlugin->get_extension(fPlugin, CLAP_EXT_AUDIO_PORTS));
1382
1383 const clap_plugin_latency_t* latencyExt = static_cast<const clap_plugin_latency_t*>(
1384 fPlugin->get_extension(fPlugin, CLAP_EXT_LATENCY));
1385
1386 const clap_plugin_note_ports_t* notePortsExt = static_cast<const clap_plugin_note_ports_t*>(
1387 fPlugin->get_extension(fPlugin, CLAP_EXT_NOTE_PORTS));
1388
1389 const clap_plugin_params_t* paramsExt = static_cast<const clap_plugin_params_t*>(
1390 fPlugin->get_extension(fPlugin, CLAP_EXT_PARAMS));
1391
1392 const clap_plugin_state_t* stateExt = static_cast<const clap_plugin_state_t*>(
1393 fPlugin->get_extension(fPlugin, CLAP_EXT_STATE));
1394
1395 const clap_plugin_timer_support_t* timerExt = static_cast<const clap_plugin_timer_support_t*>(
1396 fPlugin->get_extension(fPlugin, CLAP_EXT_TIMER_SUPPORT));
1397
1398 if (audioPortsExt != nullptr && (audioPortsExt->count == nullptr || audioPortsExt->get == nullptr))
1399 audioPortsExt = nullptr;
1400
1401 if (latencyExt != nullptr && latencyExt->get == nullptr)
1402 latencyExt = nullptr;
1403
1404 if (notePortsExt != nullptr && (notePortsExt->count == nullptr || notePortsExt->get == nullptr))
1405 notePortsExt = nullptr;
1406
1407 if (paramsExt != nullptr && (paramsExt->count == nullptr || paramsExt->get_info == nullptr))
1408 paramsExt = nullptr;
1409
1410 if (stateExt != nullptr && (stateExt->save == nullptr || stateExt->load == nullptr))
1411 stateExt = nullptr;
1412
1413 if (timerExt != nullptr && timerExt->on_timer == nullptr)
1414 timerExt = nullptr;
1415
1416 fExtensions.latency = latencyExt;
1417 fExtensions.params = paramsExt;
1418 fExtensions.state = stateExt;
1419 fExtensions.timer = timerExt;
1420
1421 #ifdef CLAP_WINDOW_API_NATIVE
1422 const clap_plugin_gui_t* guiExt = static_cast<const clap_plugin_gui_t*>(
1423 fPlugin->get_extension(fPlugin, CLAP_EXT_GUI));
1424
1425 if (guiExt != nullptr && (guiExt->is_api_supported == nullptr
1426 || guiExt->create == nullptr
1427 || guiExt->destroy == nullptr
1428 || guiExt->set_scale == nullptr
1429 || guiExt->get_size == nullptr
1430 || guiExt->can_resize == nullptr
1431 || guiExt->get_resize_hints == nullptr
1432 || guiExt->adjust_size == nullptr
1433 || guiExt->set_size == nullptr
1434 || guiExt->set_parent == nullptr
1435 || guiExt->set_transient == nullptr
1436 || guiExt->suggest_title == nullptr
1437 || guiExt->show == nullptr
1438 || guiExt->hide == nullptr))
1439 guiExt = nullptr;
1440
1441 fExtensions.gui = guiExt;
1442 #endif
1443
1444 #if defined(CLAP_WINDOW_API_NATIVE) && defined(_POSIX_VERSION)
1445 const clap_plugin_posix_fd_support_t* posixFdExt = static_cast<const clap_plugin_posix_fd_support_t*>(
1446 fPlugin->get_extension(fPlugin, CLAP_EXT_POSIX_FD_SUPPORT));
1447
1448 if (posixFdExt != nullptr && posixFdExt->on_fd == nullptr)
1449 posixFdExt = nullptr;
1450
1451 fExtensions.posixFD = posixFdExt;
1452 #endif
1453
1454 const uint32_t numAudioInputPorts = audioPortsExt != nullptr ? audioPortsExt->count(fPlugin, true) : 0;
1455 const uint32_t numAudioOutputPorts = audioPortsExt != nullptr ? audioPortsExt->count(fPlugin, false) : 0;
1456 const uint32_t numNoteInputPorts = notePortsExt != nullptr ? notePortsExt->count(fPlugin, true) : 0;
1457 const uint32_t numNoteOutputPorts = notePortsExt != nullptr ? notePortsExt->count(fPlugin, false) : 0;
1458 const uint32_t numParameters = paramsExt != nullptr ? paramsExt->count(fPlugin) : 0;
1459
1460 uint32_t aIns, aOuts, mIns, mOuts, params;
1461 aIns = aOuts = mIns = mOuts = params = 0;
1462
1463 bool needsCtrlIn, needsCtrlOut;
1464 needsCtrlIn = needsCtrlOut = false;
1465
1466 fInputAudioBuffers.realloc(numAudioInputPorts);
1467 fOutputAudioBuffers.realloc(numAudioOutputPorts);
1468
1469 for (uint32_t i=0; i<numAudioInputPorts; ++i)
1470 {
1471 clap_audio_port_info_t portInfo = {};
1472 CARLA_SAFE_ASSERT_BREAK(audioPortsExt->get(fPlugin, i, true, &portInfo));
1473 CARLA_SAFE_ASSERT(portInfo.channel_count != 0);
1474
1475 fInputAudioBuffers.buffers[i].channel_count = portInfo.channel_count;
1476 fInputAudioBuffers.extra[i].offset = aIns;
1477 fInputAudioBuffers.extra[i].isMain = portInfo.flags & CLAP_AUDIO_PORT_IS_MAIN;
1478
1479 aIns += portInfo.channel_count;
1480 }
1481
1482 for (uint32_t i=0; i<numAudioOutputPorts; ++i)
1483 {
1484 clap_audio_port_info_t portInfo = {};
1485 CARLA_SAFE_ASSERT_BREAK(audioPortsExt->get(fPlugin, i, false, &portInfo));
1486 CARLA_SAFE_ASSERT(portInfo.channel_count != 0);
1487
1488 fOutputAudioBuffers.buffers[i].channel_count = portInfo.channel_count;
1489 fOutputAudioBuffers.extra[i].offset = aOuts;
1490 fOutputAudioBuffers.extra[i].isMain = portInfo.flags & CLAP_AUDIO_PORT_IS_MAIN;
1491 for (uint32_t j=0; j<portInfo.channel_count; ++j)
1492 fOutputAudioBuffers.buffers[i].constant_mask |= (1ULL << j);
1493
1494 aOuts += portInfo.channel_count;
1495 }
1496
1497 for (uint32_t i=0; i<numNoteInputPorts; ++i)
1498 {
1499 clap_note_port_info_t portInfo = {};
1500 CARLA_SAFE_ASSERT_BREAK(notePortsExt->get(fPlugin, i, true, &portInfo));
1501
1502 if (portInfo.supported_dialects & (CLAP_NOTE_DIALECT_CLAP|CLAP_NOTE_DIALECT_MIDI))
1503 ++mIns;
1504 }
1505
1506 for (uint32_t i=0; i<numNoteOutputPorts; ++i)
1507 {
1508 clap_note_port_info_t portInfo = {};
1509 CARLA_SAFE_ASSERT_BREAK(notePortsExt->get(fPlugin, i, false, &portInfo));
1510
1511 if (portInfo.supported_dialects & CLAP_NOTE_DIALECT_MIDI)
1512 ++mOuts;
1513 }
1514
1515 for (uint32_t i=0; i<numParameters; ++i, ++params)
1516 {
1517 clap_param_info_t paramInfo = {};
1518 CARLA_SAFE_ASSERT_BREAK(paramsExt->get_info(fPlugin, i, &paramInfo));
1519 }
1520
1521 if (aIns > 0)
1522 {
1523 pData->audioIn.createNew(aIns);
1524 }
1525
1526 if (aOuts > 0)
1527 {
1528 pData->audioOut.createNew(aOuts);
1529 needsCtrlIn = true;
1530
1531 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1532 fAudioOutBuffers = new float*[aOuts];
1533 for (uint32_t i=0; i < aOuts; ++i)
1534 fAudioOutBuffers[i] = nullptr;
1535 #endif
1536 }
1537
1538 if (mIns == 1)
1539 needsCtrlIn = true;
1540
1541 if (mOuts == 1)
1542 needsCtrlOut = true;
1543
1544 if (params > 0)
1545 {
1546 pData->param.createNew(params, false);
1547 needsCtrlIn = true;
1548 }
1549
1550 fInputEvents.realloc(pData->event.portIn, mIns, params);
1551 fOutputEvents.realloc(pData->event.portOut, mOuts, params);
1552
1553 const EngineProcessMode processMode = pData->engine->getProccessMode();
1554 const uint portNameSize = pData->engine->getMaxPortNameSize();
1555 CarlaString portName;
1556
1557 // Audio Ins
1558 for (uint32_t j=0; j < aIns; ++j)
1559 {
1560 portName.clear();
1561
1562 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1563 {
1564 portName = pData->name;
1565 portName += ":";
1566 }
1567
1568 if (aIns > 1)
1569 {
1570 portName += "input_";
1571 portName += CarlaString(j+1);
1572 }
1573 else
1574 portName += "input";
1575
1576 portName.truncate(portNameSize);
1577
1578 pData->audioIn.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio,
1579 portName, true, j);
1580 pData->audioIn.ports[j].rindex = j;
1581 }
1582
1583 // Audio Outs
1584 for (uint32_t j=0; j < aOuts; ++j)
1585 {
1586 portName.clear();
1587
1588 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1589 {
1590 portName = pData->name;
1591 portName += ":";
1592 }
1593
1594 if (aOuts > 1)
1595 {
1596 portName += "output_";
1597 portName += CarlaString(j+1);
1598 }
1599 else
1600 portName += "output";
1601
1602 portName.truncate(portNameSize);
1603
1604 pData->audioOut.ports[j].port = (CarlaEngineAudioPort*)pData->client->addPort(kEnginePortTypeAudio,
1605 portName, false, j);
1606 pData->audioOut.ports[j].rindex = j;
1607 }
1608
1609 // MIDI Ins
1610 for (uint32_t i=0, j=0; i<numNoteInputPorts; ++i)
1611 {
1612 clap_note_port_info_t portInfo = {};
1613 CARLA_SAFE_ASSERT_BREAK(notePortsExt->get(fPlugin, i, true, &portInfo));
1614
1615 if ((portInfo.supported_dialects & (CLAP_NOTE_DIALECT_CLAP|CLAP_NOTE_DIALECT_MIDI)) == 0x0)
1616 continue;
1617
1618 CARLA_SAFE_ASSERT_UINT2_BREAK(j < mIns, j, mIns);
1619
1620 fInputEvents.portData[j].clapPortIndex = i;
1621 fInputEvents.portData[j].supportedDialects = portInfo.supported_dialects;
1622
1623 if (mIns > 1)
1624 {
1625 portName.clear();
1626
1627 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1628 {
1629 portName = pData->name;
1630 portName += ":";
1631 }
1632
1633 portName += portInfo.name;
1634 portName.truncate(portNameSize);
1635 fInputEvents.portData[j].port = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent,
1636 portName, true, j);
1637 }
1638 else
1639 {
1640 fInputEvents.portData[j].port = nullptr;
1641 fInputEvents.defaultPort = &fInputEvents.portData[0];
1642 }
1643
1644 ++j;
1645 }
1646
1647 // MIDI Outs
1648 for (uint32_t i=0, j=0; i<numNoteOutputPorts; ++i)
1649 {
1650 clap_note_port_info_t portInfo = {};
1651 CARLA_SAFE_ASSERT_BREAK(notePortsExt->get(fPlugin, i, false, &portInfo));
1652
1653 if ((portInfo.supported_dialects & CLAP_NOTE_DIALECT_MIDI) == 0x0)
1654 continue;
1655
1656 CARLA_SAFE_ASSERT_UINT2_BREAK(j < mOuts, j, mOuts);
1657
1658 fOutputEvents.portData[j].clapPortIndex = i;
1659 fOutputEvents.portData[j].supportedDialects = portInfo.supported_dialects;
1660
1661 if (mOuts > 1)
1662 {
1663 portName.clear();
1664
1665 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1666 {
1667 portName = pData->name;
1668 portName += ":";
1669 }
1670
1671 portName += portInfo.name;
1672 portName.truncate(portNameSize);
1673 fOutputEvents.portData[j].port = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent,
1674 portName, false, j);
1675 }
1676 else
1677 {
1678 fOutputEvents.portData[j].port = nullptr;
1679 fOutputEvents.defaultPort = &fOutputEvents.portData[0];
1680 }
1681
1682 ++j;
1683 }
1684
1685 // Parameters
1686 for (uint32_t i=0; i<numParameters; ++i)
1687 {
1688 clap_param_info_t paramInfo = {};
1689 CARLA_SAFE_ASSERT_BREAK(paramsExt->get_info(fPlugin, i, &paramInfo));
1690 CARLA_SAFE_ASSERT_BREAK(i < params);
1691
1692 pData->param.data[i].index = i;
1693 pData->param.data[i].rindex = static_cast<int32_t>(paramInfo.id);
1694
1695 double min, max, def, step, stepSmall, stepLarge;
1696
1697 min = paramInfo.min_value;
1698 max = paramInfo.max_value;
1699 def = paramInfo.default_value;
1700
1701 if (min >= max)
1702 max = min + 0.1;
1703
1704 if (def < min)
1705 def = min;
1706 else if (def > max)
1707 def = max;
1708
1709 if (paramInfo.flags & (CLAP_PARAM_IS_HIDDEN|CLAP_PARAM_IS_BYPASS))
1710 {
1711 pData->param.data[i].type = PARAMETER_UNKNOWN;
1712 }
1713 else if (paramInfo.flags & CLAP_PARAM_IS_READONLY)
1714 {
1715 pData->param.data[i].type = PARAMETER_OUTPUT;
1716 needsCtrlOut = true;
1717 }
1718 else
1719 {
1720 pData->param.data[i].type = PARAMETER_INPUT;
1721 }
1722
1723 if (paramInfo.flags & CLAP_PARAM_IS_STEPPED)
1724 {
1725 if (carla_isEqual(max - min, 1.0))
1726 {
1727 step = stepSmall = stepLarge = 1.0;
1728 pData->param.data[i].hints |= PARAMETER_IS_BOOLEAN;
1729 }
1730 else
1731 {
1732 step = 1.0;
1733 stepSmall = 1.0;
1734 stepLarge = std::min(max - min, 10.0);
1735 }
1736 pData->param.data[i].hints |= PARAMETER_IS_INTEGER;
1737 }
1738 else
1739 {
1740 double range = max - min;
1741 step = range/100.0;
1742 stepSmall = range/1000.0;
1743 stepLarge = range/10.0;
1744 }
1745
1746 if (pData->param.data[i].type != PARAMETER_UNKNOWN)
1747 {
1748 pData->param.data[i].hints |= PARAMETER_IS_ENABLED;
1749 pData->param.data[i].hints |= PARAMETER_USES_CUSTOM_TEXT;
1750
1751 if (paramInfo.flags & CLAP_PARAM_IS_AUTOMATABLE)
1752 {
1753 pData->param.data[i].hints |= PARAMETER_IS_AUTOMATABLE;
1754
1755 if ((paramInfo.flags & CLAP_PARAM_IS_STEPPED) == 0x0)
1756 pData->param.data[i].hints |= PARAMETER_CAN_BE_CV_CONTROLLED;
1757 }
1758 }
1759
1760 pData->param.ranges[i].min = min;
1761 pData->param.ranges[i].max = max;
1762 pData->param.ranges[i].def = def;
1763 pData->param.ranges[i].step = step;
1764 pData->param.ranges[i].stepSmall = stepSmall;
1765 pData->param.ranges[i].stepLarge = stepLarge;
1766
1767 fInputEvents.updatedParams[i].clapId = paramInfo.id;
1768 fInputEvents.updatedParams[i].cookie = paramInfo.cookie;
1769 }
1770
1771 if (needsCtrlIn)
1772 {
1773 portName.clear();
1774
1775 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1776 {
1777 portName = pData->name;
1778 portName += ":";
1779 }
1780
1781 portName += "events-in";
1782 portName.truncate(portNameSize);
1783
1784 pData->event.portIn = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent,
1785 portName, true, 0);
1786 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1787 pData->event.cvSourcePorts = pData->client->createCVSourcePorts();
1788 #endif
1789
1790 if (mIns == 1)
1791 fInputEvents.portData[0].port = pData->event.portIn;
1792 }
1793
1794 if (needsCtrlOut)
1795 {
1796 portName.clear();
1797
1798 if (processMode == ENGINE_PROCESS_MODE_SINGLE_CLIENT)
1799 {
1800 portName = pData->name;
1801 portName += ":";
1802 }
1803
1804 portName += "events-out";
1805 portName.truncate(portNameSize);
1806
1807 pData->event.portOut = (CarlaEngineEventPort*)pData->client->addPort(kEnginePortTypeEvent,
1808 portName, false, 0);
1809
1810 if (mOuts == 1)
1811 fOutputEvents.portData[0].port = pData->event.portOut;
1812 }
1813
1814 // plugin hints
1815 pData->hints = PLUGIN_NEEDS_MAIN_THREAD_IDLE;
1816
1817 if (clapFeaturesContainInstrument(fPluginDescriptor->features))
1818 pData->hints |= PLUGIN_IS_SYNTH;
1819
1820 #ifdef CLAP_WINDOW_API_NATIVE
1821 if (guiExt != nullptr)
1822 {
1823 if (guiExt->is_api_supported(fPlugin, CLAP_WINDOW_API_NATIVE, false))
1824 {
1825 pData->hints |= PLUGIN_HAS_CUSTOM_UI;
1826 pData->hints |= PLUGIN_HAS_CUSTOM_EMBED_UI;
1827 pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;
1828 }
1829 else if (guiExt->is_api_supported(fPlugin, CLAP_WINDOW_API_NATIVE, true))
1830 {
1831 pData->hints |= PLUGIN_HAS_CUSTOM_UI;
1832 pData->hints |= PLUGIN_NEEDS_UI_MAIN_THREAD;
1833 }
1834 }
1835 #endif
1836
1837 if (aOuts > 0 && (aIns == aOuts || aIns == 1))
1838 pData->hints |= PLUGIN_CAN_DRYWET;
1839
1840 if (aOuts > 0)
1841 pData->hints |= PLUGIN_CAN_VOLUME;
1842
1843 if (aOuts >= 2 && aOuts % 2 == 0)
1844 pData->hints |= PLUGIN_CAN_BALANCE;
1845
1846 // extra plugin hints
1847 pData->extraHints = 0x0;
1848
1849 if (const uint32_t latency = fExtensions.latency != nullptr ? fExtensions.latency->get(fPlugin) : 0)
1850 {
1851 fLastKnownLatency = latency;
1852 pData->client->setLatency(latency);
1853 #ifndef BUILD_BRIDGE
1854 pData->latency.recreateBuffers(std::max(aIns, aOuts), latency);
1855 #endif
1856 }
1857 else
1858 {
1859 fLastKnownLatency = 0;
1860 }
1861
1862 bufferSizeChanged(pData->engine->getBufferSize());
1863 reloadPrograms(true);
1864
1865 if (pData->active)
1866 activate();
1867 else
1868 runIdleCallbacksAsNeeded(false);
1869
1870 carla_debug("CarlaPluginCLAP::reload() - end");
1871 }
1872
1873 void reloadPrograms(const bool doInit) override
1874 {
1875 carla_debug("CarlaPluginCLAP::reloadPrograms(%s)", bool2str(doInit));
1876 }
1877
1878 // -------------------------------------------------------------------
1879 // Plugin processing
1880
1881 void activate() noexcept override
1882 {
1883 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
1884
1885 // FIXME check return status
1886 fPlugin->activate(fPlugin, pData->engine->getSampleRate(), 1, pData->engine->getBufferSize());
1887 fPlugin->start_processing(fPlugin);
1888
1889 fNeedsParamFlush = false;
1890 runIdleCallbacksAsNeeded(false);
1891 }
1892
1893 void deactivate() noexcept override
1894 {
1895 CARLA_SAFE_ASSERT_RETURN(fPlugin != nullptr,);
1896
1897 // FIXME check return status
1898 fPlugin->stop_processing(fPlugin);
1899 fPlugin->deactivate(fPlugin);
1900
1901 runIdleCallbacksAsNeeded(false);
1902 }
1903
1904 void process(const float* const* const audioIn,
1905 float** const audioOut,
1906 const float* const* const cvIn,
1907 float** const,
1908 const uint32_t frames) override
1909 {
1910 // --------------------------------------------------------------------------------------------------------
1911 // Check if active
1912
1913 if (! pData->active)
1914 {
1915 // disable any output sound
1916 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1917 carla_zeroFloats(audioOut[i], frames);
1918 return;
1919 }
1920
1921 // --------------------------------------------------------------------------------------------------------
1922 // Check buffers
1923
1924 CARLA_SAFE_ASSERT_RETURN(frames > 0,);
1925
1926 if (pData->audioIn.count > 0)
1927 {
1928 CARLA_SAFE_ASSERT_RETURN(audioIn != nullptr,);
1929 }
1930 if (pData->audioOut.count > 0)
1931 {
1932 CARLA_SAFE_ASSERT_RETURN(audioOut != nullptr,);
1933 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1934 CARLA_SAFE_ASSERT_RETURN(fAudioOutBuffers != nullptr,);
1935 #endif
1936 }
1937
1938 // --------------------------------------------------------------------------------------------------------
1939 // Set audio buffers
1940
1941 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
1942 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1943 carla_zeroFloats(fAudioOutBuffers[i], frames);
1944 #endif
1945
1946 // --------------------------------------------------------------------------------------------------------
1947 // Try lock, silence otherwise
1948
1949 if (pData->engine->isOffline())
1950 {
1951 pData->singleMutex.lock();
1952 }
1953 else if (! pData->singleMutex.tryLock())
1954 {
1955 for (uint32_t i=0; i < pData->audioOut.count; ++i)
1956 carla_zeroFloats(audioOut[i], frames);
1957 return;
1958 }
1959
1960 // --------------------------------------------------------------------------------------------------------
1961
1962 fInputEvents.handleScheduledParameterUpdates();
1963
1964 // --------------------------------------------------------------------------------------------------------
1965 // Check if needs reset
1966
1967 if (pData->needsReset)
1968 {
1969 // TODO alternative if plugin does not support CLAP_NOTE_DIALECT_MIDI
1970
1971 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
1972 {
1973 for (uint32_t p=0; p<fInputEvents.portCount; ++p)
1974 {
1975 const uint16_t port = fInputEvents.portData[p].clapPortIndex;
1976
1977 for (uint8_t i=0, k=fInputEvents.numEventsUsed; i < MAX_MIDI_CHANNELS; ++i)
1978 {
1979 fInputEvents.events[k + i].midi = {
1980 { sizeof(clap_event_midi_t), 0, 0, CLAP_EVENT_MIDI, 0 },
1981 port,
1982 {
1983 uint8_t(MIDI_STATUS_CONTROL_CHANGE | (i & MIDI_CHANNEL_BIT)),
1984 MIDI_CONTROL_ALL_NOTES_OFF, 0
1985 }
1986 };
1987 fInputEvents.events[k + MAX_MIDI_CHANNELS + i].midi = {
1988 { sizeof(clap_event_midi_t), 0, 0, CLAP_EVENT_MIDI, 0 },
1989 port,
1990 {
1991 uint8_t(MIDI_STATUS_CONTROL_CHANGE | (i & MIDI_CHANNEL_BIT)),
1992 MIDI_CONTROL_ALL_SOUND_OFF, 0
1993 }
1994 };
1995 }
1996
1997 fInputEvents.numEventsUsed += MAX_MIDI_CHANNELS * 2;
1998 }
1999 }
2000 else if (pData->ctrlChannel >= 0 && pData->ctrlChannel < MAX_MIDI_CHANNELS)
2001 {
2002 for (uint32_t p=0; p<fInputEvents.portCount; ++p)
2003 {
2004 const uint16_t port = fInputEvents.portData[p].clapPortIndex;
2005
2006 for (uint8_t i=0, k=fInputEvents.numEventsUsed; i < MAX_MIDI_NOTE; ++i)
2007 {
2008 fInputEvents.events[k + i].midi = {
2009 { sizeof(clap_event_midi_t), 0, 0, CLAP_EVENT_MIDI, 0 },
2010 port,
2011 {
2012 uint8_t(MIDI_STATUS_NOTE_OFF | (pData->ctrlChannel & MIDI_CHANNEL_BIT)),
2013 i, 0
2014 }
2015 };
2016 }
2017
2018 fInputEvents.numEventsUsed += MAX_MIDI_NOTE;
2019 }
2020 }
2021
2022 pData->needsReset = false;
2023 }
2024
2025 // --------------------------------------------------------------------------------------------------------
2026 // Set TimeInfo
2027
2028 const EngineTimeInfo timeInfo(pData->engine->getTimeInfo());
2029
2030 const double sampleRate = pData->engine->getSampleRate();
2031
2032 clap_event_transport_t clapTransport = {
2033 { sizeof(clap_event_transport_t), 0, 0, CLAP_EVENT_TRANSPORT, 0 },
2034 0x0, // flags
2035 0, // song_pos_beats, position in beats
2036 0, // song_pos_seconds, position in seconds
2037 0.0, // tempo, in bpm
2038 0.0, // tempo_inc, tempo increment for each samples and until the next time info event
2039 0, // loop_start_beats
2040 0, // loop_end_beats
2041 0, // loop_start_seconds
2042 0, // loop_end_seconds
2043 0, // bar_start, start pos of the current bar
2044 0, // bar_number, bar at song pos 0 has the number 0
2045 0, // tsig_num, time signature numerator
2046 0, // tsig_denom, time signature denominator
2047 };
2048
2049 if (timeInfo.playing)
2050 clapTransport.flags |= CLAP_TRANSPORT_IS_PLAYING;
2051
2052 const double positionSeconds = static_cast<double>(timeInfo.frame) / sampleRate;
2053 clapTransport.song_pos_seconds = std::round(CLAP_SECTIME_FACTOR * positionSeconds);
2054 clapTransport.flags |= CLAP_TRANSPORT_HAS_SECONDS_TIMELINE;
2055
2056 if (timeInfo.bbt.valid)
2057 {
2058 CARLA_SAFE_ASSERT_INT(timeInfo.bbt.bar > 0, timeInfo.bbt.bar);
2059 CARLA_SAFE_ASSERT_INT(timeInfo.bbt.beat > 0, timeInfo.bbt.beat);
2060
2061 const double barStart = static_cast<double>(timeInfo.bbt.beatsPerBar) * (timeInfo.bbt.bar - 1);
2062 const double positionBeats = static_cast<double>(timeInfo.frame)
2063 / (sampleRate * 60 / timeInfo.bbt.beatsPerMinute);
2064
2065 // Bar/Beats
2066 clapTransport.bar_start = std::round(CLAP_BEATTIME_FACTOR * barStart);
2067 clapTransport.bar_number = timeInfo.bbt.bar - 1;
2068 clapTransport.song_pos_beats = std::round(CLAP_BEATTIME_FACTOR * positionBeats);
2069 clapTransport.flags |= CLAP_TRANSPORT_HAS_BEATS_TIMELINE;
2070
2071 // Tempo
2072 clapTransport.tempo = timeInfo.bbt.beatsPerMinute;
2073 clapTransport.flags |= CLAP_TRANSPORT_HAS_TEMPO;
2074
2075 // Time Signature
2076 clapTransport.tsig_num = static_cast<uint16_t>(timeInfo.bbt.beatsPerBar + 0.5f);
2077 clapTransport.tsig_denom = static_cast<uint16_t>(timeInfo.bbt.beatType + 0.5f);
2078 clapTransport.flags |= CLAP_TRANSPORT_HAS_TIME_SIGNATURE;
2079 }
2080 else
2081 {
2082 // Tempo
2083 clapTransport.tempo = 120.0;
2084 clapTransport.flags |= CLAP_TRANSPORT_HAS_TEMPO;
2085
2086 // Time Signature
2087 clapTransport.tsig_num = 4;
2088 clapTransport.tsig_denom = 4;
2089 clapTransport.flags |= CLAP_TRANSPORT_HAS_TIME_SIGNATURE;
2090 }
2091
2092 // --------------------------------------------------------------------------------------------------------
2093 // Event Input (main port)
2094
2095 if (pData->event.portIn != nullptr)
2096 {
2097 // ----------------------------------------------------------------------------------------------------
2098 // MIDI Input (External)
2099
2100 if (pData->extNotes.mutex.tryLock())
2101 {
2102 if (fInputEvents.portCount == 0)
2103 {
2104 // does not handle MIDI
2105 pData->extNotes.data.clear();
2106 }
2107 else
2108 {
2109 ExternalMidiNote note = { -1, 0, 0 };
2110 const uint16_t p = fInputEvents.portData[0].clapPortIndex;
2111
2112 for (; fInputEvents.numEventsUsed < fInputEvents.numEventsAllocated && ! pData->extNotes.data.isEmpty();)
2113 {
2114 note = pData->extNotes.data.getFirst(note, true);
2115
2116 CARLA_SAFE_ASSERT_CONTINUE(note.channel >= 0 && note.channel < MAX_MIDI_CHANNELS);
2117
2118 if (fInputEvents.portData[0].supportedDialects & CLAP_NOTE_DIALECT_MIDI)
2119 {
2120 const uint8_t data[3] = {
2121 uint8_t((note.velo > 0 ? MIDI_STATUS_NOTE_ON : MIDI_STATUS_NOTE_OFF) | (note.channel & MIDI_CHANNEL_BIT)),
2122 note.note,
2123 note.velo
2124 };
2125 fInputEvents.addSimpleMidiEvent(true, p, 0, data);
2126 }
2127 else
2128 {
2129 fInputEvents.addSimpleNoteEvent(true, -1, 0, note.channel, note.note, note.velo);
2130 }
2131 }
2132 }
2133
2134 pData->extNotes.mutex.unlock();
2135
2136 } // End of MIDI Input (External)
2137
2138 // ----------------------------------------------------------------------------------------------------
2139 // Event Input (System)
2140
2141 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2142 bool allNotesOffSent = false;
2143 #endif
2144 uint32_t previousEventTime = 0;
2145 uint32_t nextBankId;
2146
2147 if (pData->midiprog.current >= 0 && pData->midiprog.count > 0)
2148 nextBankId = pData->midiprog.data[pData->midiprog.current].bank;
2149 else
2150 nextBankId = 0;
2151
2152 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2153 if (cvIn != nullptr && pData->event.cvSourcePorts != nullptr)
2154 pData->event.cvSourcePorts->initPortBuffers(cvIn + pData->cvIn.count, frames, true, pData->event.portIn);
2155 #endif
2156
2157 const uint32_t numSysEvents = pData->event.portIn->getEventCount();
2158
2159 for (uint32_t i=0; i < numSysEvents; ++i)
2160 {
2161 EngineEvent& event(pData->event.portIn->getEvent(i));
2162
2163 uint32_t eventTime = event.time;
2164 CARLA_SAFE_ASSERT_UINT2_CONTINUE(eventTime < frames, eventTime, frames);
2165
2166 if (eventTime < previousEventTime)
2167 {
2168 carla_stderr2("Timing error, eventTime:%u < previousEventTime:%u for '%s'",
2169 eventTime, previousEventTime, pData->name);
2170 eventTime = previousEventTime;
2171 }
2172
2173 previousEventTime = eventTime;
2174
2175 switch (event.type)
2176 {
2177 case kEngineEventTypeNull:
2178 break;
2179
2180 case kEngineEventTypeControl: {
2181 EngineControlEvent& ctrlEvent(event.ctrl);
2182
2183 switch (ctrlEvent.type)
2184 {
2185 case kEngineControlEventTypeNull:
2186 break;
2187
2188 case kEngineControlEventTypeParameter: {
2189 float value;
2190
2191 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2192 // non-midi
2193 if (event.channel == kEngineEventNonMidiChannel)
2194 {
2195 const uint32_t k = ctrlEvent.param;
2196 CARLA_SAFE_ASSERT_CONTINUE(k < pData->param.count);
2197
2198 ctrlEvent.handled = true;
2199 value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
2200 setParameterValueRT(k, value, event.time, true);
2201 continue;
2202 }
2203
2204 // Control backend stuff
2205 if (event.channel == pData->ctrlChannel)
2206 {
2207 if (MIDI_IS_CONTROL_BREATH_CONTROLLER(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_DRYWET) != 0)
2208 {
2209 ctrlEvent.handled = true;
2210 value = ctrlEvent.normalizedValue;
2211 setDryWetRT(value, true);
2212 }
2213 else if (MIDI_IS_CONTROL_CHANNEL_VOLUME(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_VOLUME) != 0)
2214 {
2215 ctrlEvent.handled = true;
2216 value = ctrlEvent.normalizedValue*127.0f/100.0f;
2217 setVolumeRT(value, true);
2218 }
2219 else if (MIDI_IS_CONTROL_BALANCE(ctrlEvent.param) && (pData->hints & PLUGIN_CAN_BALANCE) != 0)
2220 {
2221 float left, right;
2222 value = ctrlEvent.normalizedValue/0.5f - 1.0f;
2223
2224 if (value < 0.0f)
2225 {
2226 left = -1.0f;
2227 right = (value*2.0f)+1.0f;
2228 }
2229 else if (value > 0.0f)
2230 {
2231 left = (value*2.0f)-1.0f;
2232 right = 1.0f;
2233 }
2234 else
2235 {
2236 left = -1.0f;
2237 right = 1.0f;
2238 }
2239
2240 ctrlEvent.handled = true;
2241 setBalanceLeftRT(left, true);
2242 setBalanceRightRT(right, true);
2243 }
2244 }
2245 #endif
2246 // Control plugin parameters
2247 uint32_t k;
2248 for (k=0; k < pData->param.count; ++k)
2249 {
2250 if (pData->param.data[k].midiChannel != event.channel)
2251 continue;
2252 if (pData->param.data[k].mappedControlIndex != ctrlEvent.param)
2253 continue;
2254 if (pData->param.data[k].type != PARAMETER_INPUT)
2255 continue;
2256 if ((pData->param.data[k].hints & PARAMETER_IS_AUTOMATABLE) == 0)
2257 continue;
2258
2259 ctrlEvent.handled = true;
2260 value = pData->param.getFinalUnnormalizedValue(k, ctrlEvent.normalizedValue);
2261 setParameterValueRT(k, value, event.time, true);
2262 }
2263
2264 if ((pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) != 0 && ctrlEvent.param < MAX_MIDI_VALUE)
2265 {
2266 uint8_t midiData[3];
2267 midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2268 midiData[1] = uint8_t(ctrlEvent.param);
2269 midiData[2] = uint8_t(ctrlEvent.normalizedValue*127.0f + 0.5f);
2270
2271 fInputEvents.addSimpleMidiEvent(true, 0, eventTime, midiData);
2272 }
2273
2274 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2275 if (! ctrlEvent.handled)
2276 checkForMidiLearn(event);
2277 #endif
2278 break;
2279 } // case kEngineControlEventTypeParameter
2280
2281 case kEngineControlEventTypeMidiBank:
2282 if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
2283 {
2284 if (event.channel == pData->ctrlChannel)
2285 nextBankId = ctrlEvent.param;
2286 }
2287 else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)
2288 {
2289 uint8_t midiData[3];
2290 midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2291 midiData[1] = MIDI_CONTROL_BANK_SELECT;
2292 midiData[2] = uint8_t(ctrlEvent.param);
2293
2294 fInputEvents.addSimpleMidiEvent(true, 0, eventTime, midiData);
2295 }
2296 break;
2297
2298 case kEngineControlEventTypeMidiProgram:
2299 if (pData->options & PLUGIN_OPTION_MAP_PROGRAM_CHANGES)
2300 {
2301 if (event.channel == pData->ctrlChannel)
2302 {
2303 const uint32_t nextProgramId(ctrlEvent.param);
2304
2305 for (uint32_t k=0; k < pData->midiprog.count; ++k)
2306 {
2307 if (pData->midiprog.data[k].bank == nextBankId && pData->midiprog.data[k].program == nextProgramId)
2308 {
2309 setMidiProgramRT(k, true);
2310 break;
2311 }
2312 }
2313 }
2314 }
2315 else if (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES)
2316 {
2317 uint8_t midiData[3];
2318 midiData[0] = uint8_t(MIDI_STATUS_PROGRAM_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2319 midiData[1] = uint8_t(ctrlEvent.param);
2320 midiData[2] = 0;
2321
2322 fInputEvents.addSimpleMidiEvent(true, 0, eventTime, midiData);
2323 }
2324 break;
2325
2326 case kEngineControlEventTypeAllSoundOff:
2327 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
2328 {
2329 uint8_t midiData[3];
2330 midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2331 midiData[1] = MIDI_CONTROL_ALL_SOUND_OFF;
2332 midiData[2] = 0;
2333
2334 fInputEvents.addSimpleMidiEvent(true, 0, eventTime, midiData);
2335 }
2336 break;
2337
2338 case kEngineControlEventTypeAllNotesOff:
2339 if (pData->options & PLUGIN_OPTION_SEND_ALL_SOUND_OFF)
2340 {
2341 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2342 if (event.channel == pData->ctrlChannel && ! allNotesOffSent)
2343 {
2344 allNotesOffSent = true;
2345 postponeRtAllNotesOff();
2346 }
2347 #endif
2348
2349 uint8_t midiData[3];
2350 midiData[0] = uint8_t(MIDI_STATUS_CONTROL_CHANGE | (event.channel & MIDI_CHANNEL_BIT));
2351 midiData[1] = MIDI_CONTROL_ALL_NOTES_OFF;
2352 midiData[2] = 0;
2353
2354 fInputEvents.addSimpleMidiEvent(true, 0, eventTime, midiData);
2355 }
2356 break;
2357 } // switch (ctrlEvent.type)
2358 break;
2359 } // case kEngineEventTypeControl
2360
2361 case kEngineEventTypeMidi: {
2362 const EngineMidiEvent& midiEvent(event.midi);
2363
2364 if (midiEvent.size > 3)
2365 continue;
2366
2367 CARLA_SAFE_ASSERT_BREAK(midiEvent.port < fInputEvents.portCount);
2368
2369 const uint8_t status = uint8_t(MIDI_GET_STATUS_FROM_DATA(midiEvent.data));
2370
2371 if (status == MIDI_STATUS_NOTE_OFF || status == MIDI_STATUS_NOTE_ON)
2372 {
2373 if (pData->options & PLUGIN_OPTION_SKIP_SENDING_NOTES)
2374 continue;
2375
2376 // plugin does not support MIDI, send a simple note instead
2377 if ((fInputEvents.portData[midiEvent.port].supportedDialects & CLAP_NOTE_DIALECT_MIDI) == 0x0)
2378 {
2379 fInputEvents.addSimpleNoteEvent(true, midiEvent.port, event.time,
2380 event.channel, midiEvent.data[1], midiEvent.data[2]);
2381 }
2382 }
2383
2384 if (fInputEvents.portData[midiEvent.port].supportedDialects & CLAP_NOTE_DIALECT_MIDI)
2385 {
2386 if (status == MIDI_STATUS_CHANNEL_PRESSURE && (pData->options & PLUGIN_OPTION_SEND_CHANNEL_PRESSURE) == 0)
2387 continue;
2388 if (status == MIDI_STATUS_CONTROL_CHANGE && (pData->options & PLUGIN_OPTION_SEND_CONTROL_CHANGES) == 0)
2389 continue;
2390 if (status == MIDI_STATUS_POLYPHONIC_AFTERTOUCH && (pData->options & PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH) == 0)
2391 continue;
2392 if (status == MIDI_STATUS_PITCH_WHEEL_CONTROL && (pData->options & PLUGIN_OPTION_SEND_PITCHBEND) == 0)
2393 continue;
2394
2395 // put back channel in data
2396 uint8_t midiData[3] = { uint8_t(status | (event.channel & MIDI_CHANNEL_BIT)), 0, 0 };
2397
2398 switch (midiEvent.size)
2399 {
2400 case 3:
2401 midiData[2] = midiEvent.data[2];
2402 // fall through
2403 case 2:
2404 midiData[1] = midiEvent.data[1];
2405 break;
2406 }
2407
2408 fInputEvents.addSimpleMidiEvent(true, midiEvent.port, eventTime, midiData);
2409 }
2410
2411 switch (status)
2412 {
2413 case MIDI_STATUS_NOTE_ON:
2414 if (midiEvent.data[2] != 0)
2415 {
2416 pData->postponeNoteOnRtEvent(true, event.channel, midiEvent.data[1], midiEvent.data[2]);
2417 break;
2418 }
2419 // fall through
2420 case MIDI_STATUS_NOTE_OFF:
2421 pData->postponeNoteOffRtEvent(true, event.channel, midiEvent.data[1]);
2422 break;
2423 }
2424 } break;
2425 } // switch (event.type)
2426 }
2427
2428 pData->postRtEvents.trySplice();
2429
2430 } // End of Event Input (main port)
2431
2432 // --------------------------------------------------------------------------------------------------------
2433 // Event input (multi MIDI port)
2434
2435 if (fInputEvents.portCount > 1)
2436 {
2437 // TODO
2438 }
2439
2440 // --------------------------------------------------------------------------------------------------------
2441 // Plugin processing
2442
2443 for (uint32_t i=0; i<fInputAudioBuffers.count; ++i)
2444 fInputAudioBuffers.buffers[i].data32 = audioIn + fInputAudioBuffers.extra[i].offset;
2445
2446 for (uint32_t i=0; i<fOutputAudioBuffers.count; ++i)
2447 {
2448 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2449 fOutputAudioBuffers.buffers[i].data32 = fAudioOutBuffers + fOutputAudioBuffers.extra[i].offset;
2450 #else
2451 fOutputAudioBuffers.buffers[i].data32 = audioOut + fOutputAudioBuffers.extra[i].offset;
2452 #endif
2453 }
2454
2455 const clap_process_t process = {
2456 static_cast<int64_t>(timeInfo.frame),
2457 frames,
2458 &clapTransport,
2459 fInputAudioBuffers.cast(),
2460 fOutputAudioBuffers.buffers,
2461 fInputAudioBuffers.count,
2462 fOutputAudioBuffers.count,
2463 fInputEvents.cast(),
2464 fOutputEvents.cast()
2465 };
2466
2467 fPlugin->process(fPlugin, &process);
2468
2469 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2470 // --------------------------------------------------------------------------------------------------------
2471 // Post-processing (dry/wet, volume and balance)
2472
2473 {
2474 const bool doDryWet = (pData->hints & PLUGIN_CAN_DRYWET) != 0 && carla_isNotEqual(pData->postProc.dryWet, 1.0f);
2475 const bool doBalance = (pData->hints & PLUGIN_CAN_BALANCE) != 0 && ! (carla_isEqual(pData->postProc.balanceLeft, -1.0f) && carla_isEqual(pData->postProc.balanceRight, 1.0f));
2476 const bool isMono = (pData->audioIn.count == 1);
2477
2478 bool isPair;
2479 float bufValue;
2480 float* const oldBufLeft = pData->postProc.extraBuffer;
2481
2482 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2483 {
2484 // Dry/Wet
2485 if (doDryWet)
2486 {
2487 const uint32_t c = isMono ? 0 : i;
2488
2489 for (uint32_t k=0; k < frames; ++k)
2490 {
2491 bufValue = audioIn[c][k];
2492 fAudioOutBuffers[i][k] = (fAudioOutBuffers[i][k] * pData->postProc.dryWet) + (bufValue * (1.0f - pData->postProc.dryWet));
2493 }
2494 }
2495
2496 // Balance
2497 if (doBalance)
2498 {
2499 isPair = (i % 2 == 0);
2500
2501 if (isPair)
2502 {
2503 CARLA_ASSERT(i+1 < pData->audioOut.count);
2504 carla_copyFloats(oldBufLeft, fAudioOutBuffers[i], frames);
2505 }
2506
2507 float balRangeL = (pData->postProc.balanceLeft + 1.0f)/2.0f;
2508 float balRangeR = (pData->postProc.balanceRight + 1.0f)/2.0f;
2509
2510 for (uint32_t k=0; k < frames; ++k)
2511 {
2512 if (isPair)
2513 {
2514 // left
2515 fAudioOutBuffers[i][k] = oldBufLeft[k] * (1.0f - balRangeL);
2516 fAudioOutBuffers[i][k] += fAudioOutBuffers[i+1][k] * (1.0f - balRangeR);
2517 }
2518 else
2519 {
2520 // right
2521 fAudioOutBuffers[i][k] = fAudioOutBuffers[i][k] * balRangeR;
2522 fAudioOutBuffers[i][k] += oldBufLeft[k] * balRangeL;
2523 }
2524 }
2525 }
2526
2527 // Volume (and buffer copy)
2528 {
2529 for (uint32_t k=0; k < frames; ++k)
2530 audioOut[i][k] = fAudioOutBuffers[i][k] * pData->postProc.volume;
2531 }
2532 }
2533
2534 } // End of Post-processing
2535 #endif // BUILD_BRIDGE_ALTERNATIVE_ARCH
2536
2537 // --------------------------------------------------------------------------------------------------------
2538
2539 pData->singleMutex.unlock();
2540
2541 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2542 // --------------------------------------------------------------------------------------------------------
2543 // Control Output
2544
2545 if (pData->event.portOut != nullptr && fExtensions.params != nullptr)
2546 {
2547 uint8_t channel;
2548 uint16_t param;
2549 double value;
2550
2551 for (uint32_t k=0; k < pData->param.count; ++k)
2552 {
2553 if (pData->param.data[k].type != PARAMETER_OUTPUT)
2554 continue;
2555 if (pData->param.data[k].mappedControlIndex <= 0)
2556 continue;
2557 if (!fExtensions.params->get_value(fPlugin, pData->param.data[k].rindex, &value))
2558 continue;
2559
2560 channel = pData->param.data[k].midiChannel;
2561 param = static_cast<uint16_t>(pData->param.data[k].mappedControlIndex);
2562 value = pData->param.ranges[k].getNormalizedValue(value);
2563
2564 pData->event.portOut->writeControlEvent(0, channel,
2565 kEngineControlEventTypeParameter, param, -1,
2566 value);
2567 }
2568 } // End of Control Output
2569 #endif
2570
2571 // --------------------------------------------------------------------------------------------------------
2572 // Events/MIDI Output
2573
2574 for (uint32_t i=0; i<fOutputEvents.numEventsUsed; ++i)
2575 {
2576 const carla_clap_output_events::Event& ev(fOutputEvents.events[i]);
2577
2578 switch (ev.header.type)
2579 {
2580 case CLAP_EVENT_PARAM_VALUE:
2581 for (uint32_t j=0; j<pData->param.count; ++j)
2582 {
2583 if (pData->param.data[j].rindex != static_cast<int32_t>(ev.param.param_id))
2584 continue;
2585 pData->postponeParameterChangeRtEvent(true, static_cast<int32_t>(j), ev.param.value);
2586 break;
2587 }
2588 break;
2589 case CLAP_EVENT_MIDI:
2590 for (uint32_t j=0; j<fOutputEvents.portCount; ++j)
2591 {
2592 if (fOutputEvents.portData[j].clapPortIndex != ev.midi.port_index)
2593 continue;
2594 fOutputEvents.portData[j].port->writeMidiEvent(ev.midi.header.time, 3, ev.midi.data);
2595 break;
2596 }
2597 break;
2598 }
2599 }
2600
2601 fOutputEvents.numEventsUsed = 0;
2602
2603 // --------------------------------------------------------------------------------------------------------
2604
2605 #ifdef BUILD_BRIDGE_ALTERNATIVE_ARCH
2606 return;
2607
2608 // unused
2609 (void)cvIn;
2610 #endif
2611 }
2612
2613 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2614 void bufferSizeChanged(const uint32_t newBufferSize) override
2615 {
2616 CARLA_ASSERT_INT(newBufferSize > 0, newBufferSize);
2617 carla_debug("CarlaPluginCLAP::bufferSizeChanged(%i)", newBufferSize);
2618
2619 if (pData->active)
2620 deactivate();
2621
2622 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2623 {
2624 if (fAudioOutBuffers[i] != nullptr)
2625 delete[] fAudioOutBuffers[i];
2626 fAudioOutBuffers[i] = new float[newBufferSize];
2627 }
2628
2629 if (pData->active)
2630 activate();
2631
2632 CarlaPlugin::bufferSizeChanged(newBufferSize);
2633 }
2634 #endif
2635
2636 // -------------------------------------------------------------------
2637 // Plugin buffers
2638
2639 void initBuffers() const noexcept override
2640 {
2641 fInputEvents.initBuffers();
2642 fOutputEvents.initBuffers();
2643
2644 CarlaPlugin::initBuffers();
2645 }
2646
2647 void clearBuffers() noexcept override
2648 {
2649 carla_debug("CarlaPluginCLAP::clearBuffers() - start");
2650
2651 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
2652 if (fAudioOutBuffers != nullptr)
2653 {
2654 for (uint32_t i=0; i < pData->audioOut.count; ++i)
2655 {
2656 if (fAudioOutBuffers[i] != nullptr)
2657 {
2658 delete[] fAudioOutBuffers[i];
2659 fAudioOutBuffers[i] = nullptr;
2660 }
2661 }
2662
2663 delete[] fAudioOutBuffers;
2664 fAudioOutBuffers = nullptr;
2665 }
2666 #endif
2667
2668 fInputEvents.clear(pData->event.portIn);
2669 fOutputEvents.clear(pData->event.portOut);
2670
2671 CarlaPlugin::clearBuffers();
2672
2673 carla_debug("CarlaPluginCLAP::clearBuffers() - end");
2674 }
2675
2676 // -------------------------------------------------------------------
2677 // Post-poned UI Stuff
2678
2679 // nothing
2680
2681 // -------------------------------------------------------------------
2682
2683 protected:
2684 #ifdef CLAP_WINDOW_API_NATIVE
2685 void handlePluginUIClosed() override
2686 {
2687 CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);
2688 carla_stdout("CarlaPluginCLAP::handlePluginUIClosed()");
2689
2690 fUI.shouldClose = true;
2691 }
2692
2693 void handlePluginUIResized(const uint width, const uint height) override
2694 {
2695 CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr,);
2696 carla_stdout("CarlaPluginCLAP::handlePluginUIResized(%u, %u | vs %u %u) %d %s %s",
2697 width, height,
2698 fUI.width, fUI.height,
2699 fUI.isResizingFromPlugin, bool2str(fUI.isResizingFromInit), bool2str(fUI.isResizingFromHost));
2700
2701 if (fExtensions.gui == nullptr)
2702 return;
2703
2704 if (fUI.isResizingFromPlugin != 0)
2705 {
2706 CARLA_SAFE_ASSERT_UINT2_RETURN(fUI.width == width, fUI.width, width,);
2707 CARLA_SAFE_ASSERT_UINT2_RETURN(fUI.height == height, fUI.height, height,);
2708 fUI.isResizingFromPlugin = 2;
2709 return;
2710 }
2711
2712 if (fUI.isResizingFromInit)
2713 {
2714 CARLA_SAFE_ASSERT_UINT2_RETURN(fUI.width == width, fUI.width, width,);
2715 CARLA_SAFE_ASSERT_UINT2_RETURN(fUI.height == height, fUI.height, height,);
2716 fUI.isResizingFromInit = false;
2717 return;
2718 }
2719
2720 if (fUI.isResizingFromHost)
2721 {
2722 CARLA_SAFE_ASSERT_UINT2_RETURN(fUI.width == width, fUI.width, width,);
2723 CARLA_SAFE_ASSERT_UINT2_RETURN(fUI.height == height, fUI.height, height,);
2724 fUI.isResizingFromHost = false;
2725 return;
2726 }
2727
2728 if (fUI.width != width || fUI.height != height)
2729 {
2730 uint width2 = width;
2731 uint height2 = height;
2732
2733 if (fExtensions.gui->adjust_size(fPlugin, &width2, &height2))
2734 {
2735 if (width2 != width || height2 != height)
2736 {
2737 fUI.isResizingFromHost = true;
2738 fUI.width = width2;
2739 fUI.height = height2;
2740 fUI.window->setSize(width2, height2, false, false);
2741 }
2742 else
2743 {
2744 fExtensions.gui->set_size(fPlugin, width2, height2);
2745 }
2746 }
2747 }
2748 }
2749 #endif
2750
2751 // -------------------------------------------------------------------
2752
2753 void clapRequestRestart() override
2754 {
2755 carla_stdout("CarlaPluginCLAP::clapRequestRestart()");
2756
2757 fNeedsRestart = true;
2758 }
2759
2760 void clapRequestProcess() override
2761 {
2762 carla_stdout("CarlaPluginCLAP::clapRequestProcess()");
2763
2764 fNeedsProcess = true;
2765 }
2766
2767 void clapRequestCallback() override
2768 {
2769 carla_stdout("CarlaPluginCLAP::clapRequestCallback()");
2770
2771 if (fPlugin->on_main_thread != nullptr)
2772 fNeedsIdleCallback = true;
2773 }
2774
2775 // -------------------------------------------------------------------
2776
2777 void clapLatencyChanged() override
2778 {
2779 carla_stdout("CarlaPluginCLAP::clapLatencyChanged()");
2780 CARLA_SAFE_ASSERT_RETURN(fExtensions.latency != nullptr,);
2781
2782 fLastKnownLatency = fExtensions.latency->get(fPlugin);
2783 }
2784
2785 // -------------------------------------------------------------------
2786
2787 void clapMarkDirty() override
2788 {
2789 carla_stdout("CarlaPluginCLAP::clapMarkDirty()");
2790 }
2791
2792 // -------------------------------------------------------------------
2793
2794 #ifdef CLAP_WINDOW_API_NATIVE
2795 void clapGuiResizeHintsChanged() override
2796 {
2797 carla_stdout("CarlaPluginCLAP::clapGuiResizeHintsChanged()");
2798 }
2799
2800 bool clapGuiRequestResize(const uint width, const uint height) override
2801 {
2802 CARLA_SAFE_ASSERT_RETURN(fUI.window != nullptr, false);
2803 carla_stdout("CarlaPluginCLAP::hostRequestResize(%u, %u)", width, height);
2804
2805 fUI.isResizingFromPlugin = 3;
2806 fUI.width = width;
2807 fUI.height = height;
2808 fUI.window->setSize(width, height, true, false);
2809 return true;
2810 }
2811
2812 bool clapGuiRequestShow() override
2813 {
2814 carla_stdout("CarlaPluginCLAP::clapGuiRequestShow()");
2815 return false;
2816 }
2817
2818 bool clapGuiRequestHide() override
2819 {
2820 carla_stdout("CarlaPluginCLAP::clapGuiRequestHide()");
2821 return false;
2822 }
2823
2824 void clapGuiClosed(const bool wasDestroyed) override
2825 {
2826 carla_stdout("CarlaPluginCLAP::clapGuiClosed(%s)", bool2str(wasDestroyed));
2827 CARLA_SAFE_ASSERT_RETURN(!fUI.isEmbed,);
2828 CARLA_SAFE_ASSERT_RETURN(fUI.isVisible,);
2829
2830 fUI.isVisible = false;
2831
2832 if (wasDestroyed)
2833 {
2834 CARLA_SAFE_ASSERT_RETURN(fUI.isCreated,);
2835 fExtensions.gui->destroy(fPlugin);
2836 fUI.isCreated = false;
2837 }
2838
2839 pData->engine->callback(true, true,
2840 ENGINE_CALLBACK_UI_STATE_CHANGED,
2841 pData->id,
2842 0,
2843 0, 0, 0.0f, nullptr);
2844 }
2845
2846 // -------------------------------------------------------------------
2847
2848 #ifdef _POSIX_VERSION
2849 bool clapRegisterPosixFD(const int fd, const clap_posix_fd_flags_t flags) override
2850 {
2851 carla_stdout("CarlaPluginCLAP::clapRegisterPosixFD(%i, %x)", fd, flags);
2852
2853 // NOTE some plugins wont have their posix fd extension ready when first loaded, so try again here
2854 if (fExtensions.posixFD == nullptr)
2855 {
2856 const clap_plugin_posix_fd_support_t* const posixFdExt = static_cast<const clap_plugin_posix_fd_support_t*>(
2857 fPlugin->get_extension(fPlugin, CLAP_EXT_POSIX_FD_SUPPORT));
2858
2859 if (posixFdExt != nullptr && posixFdExt->on_fd != nullptr)
2860 fExtensions.posixFD = posixFdExt;
2861 }
2862
2863 CARLA_SAFE_ASSERT_RETURN(fExtensions.posixFD != nullptr, false);
2864
2865 // FIXME events only driven as long as UI is open
2866 // CARLA_SAFE_ASSERT_RETURN(fUI.isCreated, false);
2867
2868 if (flags & (CLAP_POSIX_FD_READ|CLAP_POSIX_FD_WRITE))
2869 {
2870 #ifdef CARLA_CLAP_POSIX_EPOLL
2871 const int hostFd = ::epoll_create1(0);
2872 #else
2873 const int hostFd = ::kqueue();
2874 #endif
2875 CARLA_SAFE_ASSERT_RETURN(hostFd >= 0, false);
2876
2877 #ifdef CARLA_CLAP_POSIX_EPOLL
2878 struct ::epoll_event ev = {};
2879 if (flags & CLAP_POSIX_FD_READ)
2880 ev.events |= EPOLLIN;
2881 if (flags & CLAP_POSIX_FD_WRITE)
2882 ev.events |= EPOLLOUT;
2883 ev.data.fd = fd;
2884
2885 if (::epoll_ctl(hostFd, EPOLL_CTL_ADD, fd, &ev) < 0)
2886 {
2887 ::close(hostFd);
2888 return false;
2889 }
2890 #endif
2891
2892 const HostPosixFileDescriptorDetails posixFD = {
2893 hostFd,
2894 fd,
2895 flags,
2896 };
2897 fPosixFileDescriptors.append(posixFD);
2898
2899 return true;
2900 }
2901
2902 return false;
2903 }
2904
2905 bool clapModifyPosixFD(const int fd, const clap_posix_fd_flags_t flags) override
2906 {
2907 carla_stdout("CarlaPluginCLAP::clapTimerUnregister(%i, %x)", fd, flags);
2908 for (LinkedList<HostPosixFileDescriptorDetails>::Itenerator it = fPosixFileDescriptors.begin2(); it.valid(); it.next())
2909 {
2910 HostPosixFileDescriptorDetails& posixFD(it.getValue(kPosixFileDescriptorFallbackNC));
2911
2912 if (posixFD.pluginFd == fd)
2913 {
2914 if (posixFD.flags == flags)
2915 return true;
2916
2917 #ifdef CARLA_CLAP_POSIX_EPOLL
2918 struct ::epoll_event ev = {};
2919 if (flags & CLAP_POSIX_FD_READ)
2920 ev.events |= EPOLLIN;
2921 if (flags & CLAP_POSIX_FD_WRITE)
2922 ev.events |= EPOLLOUT;
2923 ev.data.fd = fd;
2924
2925 if (::epoll_ctl(posixFD.hostFd, EPOLL_CTL_MOD, fd, &ev) < 0)
2926 return false;
2927 #endif
2928
2929 posixFD.flags = flags;
2930 return true;
2931 }
2932 }
2933
2934 return false;
2935 }
2936
2937 bool clapUnregisterPosixFD(const int fd) override
2938 {
2939 carla_stdout("CarlaPluginCLAP::clapTimerUnregister(%i)", fd);
2940 for (LinkedList<HostPosixFileDescriptorDetails>::Itenerator it = fPosixFileDescriptors.begin2(); it.valid(); it.next())
2941 {
2942 const HostPosixFileDescriptorDetails& posixFD(it.getValue(kPosixFileDescriptorFallback));
2943
2944 if (posixFD.pluginFd == fd)
2945 {
2946 #ifdef CARLA_CLAP_POSIX_EPOLL
2947 ::epoll_ctl(posixFD.hostFd, EPOLL_CTL_DEL, fd, nullptr);
2948 #endif
2949 ::close(posixFD.hostFd);
2950 fPosixFileDescriptors.remove(it);
2951 return true;
2952 }
2953 }
2954
2955 return false;
2956 }
2957 #endif // _POSIX_VERSION
2958
2959 // -------------------------------------------------------------------
2960
2961 bool clapRegisterTimer(const uint32_t periodInMs, clap_id* const timerId) override
2962 {
2963 carla_stdout("CarlaPluginCLAP::clapTimerRegister(%u, %p)", periodInMs, timerId);
2964
2965 // NOTE some plugins wont have their timer extension ready when first loaded, so try again here
2966 if (fExtensions.timer == nullptr)
2967 {
2968 const clap_plugin_timer_support_t* const timerExt = static_cast<const clap_plugin_timer_support_t*>(
2969 fPlugin->get_extension(fPlugin, CLAP_EXT_TIMER_SUPPORT));
2970
2971 if (timerExt != nullptr && timerExt->on_timer != nullptr)
2972 fExtensions.timer = timerExt;
2973 }
2974
2975 CARLA_SAFE_ASSERT_RETURN(fExtensions.timer != nullptr, false);
2976
2977 // FIXME events only driven as long as UI is open
2978 // CARLA_SAFE_ASSERT_RETURN(fUI.isCreated, false);
2979
2980 const HostTimerDetails timer = {
2981 fTimers.isNotEmpty() ? fTimers.getLast(kTimerFallback).clapId + 1 : 1,
2982 periodInMs,
2983 0
2984 };
2985 fTimers.append(timer);
2986
2987 *timerId = timer.clapId;
2988 return true;
2989 }
2990
2991 bool clapUnregisterTimer(const clap_id timerId) override
2992 {
2993 carla_stdout("CarlaPluginCLAP::clapTimerUnregister(%u)", timerId);
2994 for (LinkedList<HostTimerDetails>::Itenerator it = fTimers.begin2(); it.valid(); it.next())
2995 {
2996 const HostTimerDetails& timer(it.getValue(kTimerFallback));
2997
2998 if (timer.clapId == timerId)
2999 {
3000 fTimers.remove(it);
3001 return true;
3002 }
3003 }
3004
3005 return false;
3006 }
3007 #endif // CLAP_WINDOW_API_NATIVE
3008
3009 // -------------------------------------------------------------------
3010
3011 public:
3012 bool init(const CarlaPluginPtr plugin,
3013 const char* const filename, const char* const name, const char* const id, const uint options)
3014 {
3015 CARLA_SAFE_ASSERT_RETURN(pData->engine != nullptr, false);
3016
3017 // ---------------------------------------------------------------
3018 // first checks
3019
3020 if (pData->client != nullptr)
3021 {
3022 pData->engine->setLastError("Plugin client is already registered");
3023 return false;
3024 }
3025
3026 if (filename == nullptr || filename[0] == '\0')
3027 {
3028 pData->engine->setLastError("null filename");
3029 return false;
3030 }
3031
3032 // ---------------------------------------------------------------
3033
3034 const clap_plugin_entry_t* entry;
3035
3036 #ifdef CARLA_OS_MAC
3037 if (!water::File(filename).existsAsFile())
3038 {
3039 if (! fBundleLoader.load(filename))
3040 {
3041 pData->engine->setLastError("Failed to load CLAP bundle executable");
3042 return false;
3043 }
3044
3045 entry = fBundleLoader.getSymbol<const clap_plugin_entry_t*>(CFSTR("clap_entry"));
3046 }
3047 else
3048 #endif
3049 {
3050 if (! pData->libOpen(filename))
3051 {
3052 pData->engine->setLastError(pData->libError(filename));
3053 return false;
3054 }
3055
3056 entry = pData->libSymbol<const clap_plugin_entry_t*>("clap_entry");
3057 }
3058
3059 if (entry == nullptr)
3060 {
3061 pData->engine->setLastError("Could not find the CLAP entry in the plugin library");
3062 return false;
3063 }
3064
3065 if (entry->init == nullptr || entry->deinit == nullptr || entry->get_factory == nullptr)
3066 {
3067 pData->engine->setLastError("CLAP factory entries are null");
3068 return false;
3069 }
3070
3071 if (!clap_version_is_compatible(entry->clap_version))
3072 {
3073 pData->engine->setLastError("Incompatible CLAP plugin");
3074 return false;
3075 }
3076
3077 // ---------------------------------------------------------------
3078
3079 const water::String pluginPath(water::File(filename).getParentDirectory().getFullPathName());
3080
3081 if (!entry->init(pluginPath.toRawUTF8()))
3082 {
3083 pData->engine->setLastError("Plugin entry failed to initialize");
3084 return false;
3085 }
3086
3087 fPluginEntry = entry;
3088
3089 // ---------------------------------------------------------------
3090
3091 const clap_plugin_factory_t* const factory = static_cast<const clap_plugin_factory_t*>(
3092 entry->get_factory(CLAP_PLUGIN_FACTORY_ID));
3093
3094 if (factory == nullptr
3095 || factory->get_plugin_count == nullptr
3096 || factory->get_plugin_descriptor == nullptr
3097 || factory->create_plugin == nullptr)
3098 {
3099 pData->engine->setLastError("Plugin is missing factory methods");
3100 return false;
3101 }
3102
3103 // ---------------------------------------------------------------
3104
3105 if (const uint32_t count = factory->get_plugin_count(factory))
3106 {
3107 // null id requested, use first available plugin
3108 if (id == nullptr || id[0] == '\0')
3109 {
3110 fPluginDescriptor = factory->get_plugin_descriptor(factory, 0);
3111
3112 if (fPluginDescriptor == nullptr)
3113 {
3114 pData->engine->setLastError("Plugin library does not contain a valid first plugin");
3115 return false;
3116 }
3117 }
3118 else
3119 {
3120 for (uint32_t i=0; i<count; ++i)
3121 {
3122 const clap_plugin_descriptor_t* const desc = factory->get_plugin_descriptor(factory, i);
3123 CARLA_SAFE_ASSERT_CONTINUE(desc != nullptr);
3124 CARLA_SAFE_ASSERT_CONTINUE(desc->id != nullptr);
3125
3126 if (std::strcmp(desc->id, id) == 0)
3127 {
3128 fPluginDescriptor = desc;
3129 break;
3130 }
3131 }
3132
3133 if (fPluginDescriptor == nullptr)
3134 {
3135 pData->engine->setLastError("Plugin library does not contain the requested plugin");
3136 return false;
3137 }
3138 }
3139 }
3140 else
3141 {
3142 pData->engine->setLastError("Plugin library contains no plugins");
3143 return false;
3144 }
3145
3146 // ---------------------------------------------------------------
3147
3148 fPlugin = factory->create_plugin(factory, &fHost, fPluginDescriptor->id);
3149
3150 if (fPlugin == nullptr)
3151 {
3152 pData->engine->setLastError("Failed to create CLAP plugin instance");
3153 return false;
3154 }
3155
3156 if (!fPlugin->init(fPlugin))
3157 {
3158 pData->engine->setLastError("Failed to initialize CLAP plugin instance");
3159 return false;
3160 }
3161
3162 // ---------------------------------------------------------------
3163 // get info
3164
3165 pData->name = pData->engine->getUniquePluginName(name != nullptr && name[0] != '\0' ? name
3166 : fPluginDescriptor->name);
3167 pData->filename = carla_strdup(filename);
3168
3169 // ---------------------------------------------------------------
3170 // register client
3171
3172 pData->client = pData->engine->addClient(plugin);
3173
3174 if (pData->client == nullptr || ! pData->client->isOk())
3175 {
3176 pData->engine->setLastError("Failed to register plugin client");
3177 return false;
3178 }
3179
3180 // ---------------------------------------------------------------
3181 // set default options
3182
3183 pData->options = PLUGIN_OPTION_FIXED_BUFFERS;
3184
3185 if (const clap_plugin_state_t* const stateExt =
3186 static_cast<const clap_plugin_state_t*>(fPlugin->get_extension(fPlugin, CLAP_EXT_STATE)))
3187 {
3188 if (stateExt->save != nullptr && stateExt->load != nullptr)
3189 if (isPluginOptionEnabled(options, PLUGIN_OPTION_USE_CHUNKS))
3190 pData->options |= PLUGIN_OPTION_USE_CHUNKS;
3191 }
3192
3193 if (const clap_plugin_note_ports_t* const notePortsExt =
3194 static_cast<const clap_plugin_note_ports_t*>(fPlugin->get_extension(fPlugin, CLAP_EXT_NOTE_PORTS)))
3195 {
3196 const uint32_t numNoteInputPorts = notePortsExt->count != nullptr && notePortsExt->get != nullptr
3197 ? notePortsExt->count(fPlugin, true) : 0;
3198
3199 for (uint32_t i=0; i<numNoteInputPorts; ++i)
3200 {
3201 clap_note_port_info_t portInfo = {};
3202 CARLA_SAFE_ASSERT_BREAK(notePortsExt->get(fPlugin, i, true, &portInfo));
3203
3204 if (portInfo.supported_dialects & CLAP_NOTE_DIALECT_MIDI)
3205 {
3206 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CONTROL_CHANGES))
3207 pData->options |= PLUGIN_OPTION_SEND_CONTROL_CHANGES;
3208 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_CHANNEL_PRESSURE))
3209 pData->options |= PLUGIN_OPTION_SEND_CHANNEL_PRESSURE;
3210 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH))
3211 pData->options |= PLUGIN_OPTION_SEND_NOTE_AFTERTOUCH;
3212 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PITCHBEND))
3213 pData->options |= PLUGIN_OPTION_SEND_PITCHBEND;
3214 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_ALL_SOUND_OFF))
3215 pData->options |= PLUGIN_OPTION_SEND_ALL_SOUND_OFF;
3216 if (isPluginOptionEnabled(options, PLUGIN_OPTION_SEND_PROGRAM_CHANGES))
3217 pData->options |= PLUGIN_OPTION_SEND_PROGRAM_CHANGES;
3218 if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))
3219 pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
3220 break;
3221 }
3222 if (portInfo.supported_dialects & CLAP_NOTE_DIALECT_CLAP)
3223 {
3224 if (isPluginOptionInverseEnabled(options, PLUGIN_OPTION_SKIP_SENDING_NOTES))
3225 pData->options |= PLUGIN_OPTION_SKIP_SENDING_NOTES;
3226 // nobreak, in case another port supports MIDI
3227 }
3228 }
3229 }
3230
3231 // if (fEffect->numPrograms > 1 && (pData->options & PLUGIN_OPTION_SEND_PROGRAM_CHANGES) == 0)
3232 // if (isPluginOptionEnabled(options, PLUGIN_OPTION_MAP_PROGRAM_CHANGES))
3233 // pData->options |= PLUGIN_OPTION_MAP_PROGRAM_CHANGES;
3234
3235 return true;
3236 }
3237
3238 private:
3239 const clap_plugin_t* fPlugin;
3240 const clap_plugin_descriptor_t* fPluginDescriptor;
3241 const clap_plugin_entry_t* fPluginEntry;
3242 const carla_clap_host fHost;
3243
3244 struct Extensions {
3245 const clap_plugin_latency_t* latency;
3246 const clap_plugin_params_t* params;
3247 const clap_plugin_state_t* state;
3248 const clap_plugin_timer_support_t* timer;
3249 #ifdef CLAP_WINDOW_API_NATIVE
3250 const clap_plugin_gui_t* gui;
3251 #ifdef _POSIX_VERSION
3252 const clap_plugin_posix_fd_support_t* posixFD;
3253 #endif
3254 #endif
3255
3256 Extensions()
3257 : latency(nullptr),
3258 params(nullptr),
3259 state(nullptr),
3260 timer(nullptr)
3261 #ifdef CLAP_WINDOW_API_NATIVE
3262 , gui(nullptr)
3263 #ifdef _POSIX_VERSION
3264 , posixFD(nullptr)
3265 #endif
3266 #endif
3267 {
3268 }
3269
3270 CARLA_DECLARE_NON_COPYABLE(Extensions)
3271 } fExtensions;
3272
3273 #ifdef CLAP_WINDOW_API_NATIVE
3274 struct UI {
3275 bool initalized;
3276 bool isCreated;
3277 bool isEmbed;
3278 bool isVisible;
3279 bool isResizingFromHost;
3280 bool isResizingFromInit;
3281 int isResizingFromPlugin;
3282 bool shouldClose;
3283 uint32_t width, height;
3284 CarlaPluginUI* window;
3285
3286 UI()
3287 : initalized(false),
3288 isCreated(false),
3289 isEmbed(false),
3290 isVisible(false),
3291 isResizingFromHost(false),
3292 isResizingFromInit(false),
3293 isResizingFromPlugin(0),
3294 shouldClose(false),
3295 width(0),
3296 height(0),
3297 window(nullptr) {}
3298
3299 ~UI()
3300 {
3301 CARLA_SAFE_ASSERT(window == nullptr);
3302 }
3303
3304 CARLA_DECLARE_NON_COPYABLE(UI)
3305 } fUI;
3306
3307 #ifdef _POSIX_VERSION
3308 LinkedList<HostPosixFileDescriptorDetails> fPosixFileDescriptors;
3309 #endif
3310 LinkedList<HostTimerDetails> fTimers;
3311 #endif
3312
3313 carla_clap_input_audio_buffers fInputAudioBuffers;
3314 carla_clap_output_audio_buffers fOutputAudioBuffers;
3315 carla_clap_input_events fInputEvents;
3316 carla_clap_output_events fOutputEvents;
3317 #ifndef BUILD_BRIDGE_ALTERNATIVE_ARCH
3318 float** fAudioOutBuffers;
3319 #endif
3320 void* fLastChunk;
3321 uint32_t fLastKnownLatency;
3322 const bool kEngineHasIdleOnMainThread;
3323 bool fNeedsParamFlush;
3324 bool fNeedsRestart;
3325 bool fNeedsProcess;
3326 bool fNeedsIdleCallback;
3327
3328 #ifdef CARLA_OS_MAC
3329 BundleLoader fBundleLoader;
3330 #endif
3331
3332 void runIdleCallbacksAsNeeded(const bool isIdleCallback)
3333 {
3334 if (isIdleCallback && (fNeedsRestart || fNeedsProcess))
3335 {
3336 carla_stdout("runIdleCallbacksAsNeeded %d %d", fNeedsRestart, fNeedsProcess);
3337 const bool needsRestart = fNeedsRestart;
3338
3339 if (needsRestart)
3340 {
3341 fNeedsRestart = false;
3342 setActive(false, true, true);
3343 }
3344
3345 if (fNeedsProcess)
3346 {
3347 fNeedsProcess = false;
3348 setEnabled(true);
3349 setActive(true, true, true);
3350 }
3351 else if (needsRestart)
3352 {
3353 setActive(true, true, true);
3354 }
3355 }
3356
3357 if (fNeedsParamFlush)
3358 {
3359 fNeedsParamFlush = false;
3360
3361 carla_clap_input_events copy;
3362 copy.reallocEqualTo(fInputEvents);
3363
3364 {
3365 const ScopedSingleProcessLocker sspl(this, true);
3366 fInputEvents.handleScheduledParameterUpdates();
3367 fInputEvents.swap(copy);
3368 }
3369
3370 fExtensions.params->flush(fPlugin, copy.cast(), nullptr);
3371 }
3372
3373 if (fNeedsIdleCallback)
3374 {
3375 fNeedsIdleCallback = false;
3376 fPlugin->on_main_thread(fPlugin);
3377 }
3378
3379 #ifdef CLAP_WINDOW_API_NATIVE
3380 #ifdef _POSIX_VERSION
3381 for (LinkedList<HostPosixFileDescriptorDetails>::Itenerator it = fPosixFileDescriptors.begin2(); it.valid(); it.next())
3382 {
3383 const HostPosixFileDescriptorDetails& posixFD(it.getValue(kPosixFileDescriptorFallback));
3384
3385 #ifdef CARLA_CLAP_POSIX_EPOLL
3386 struct ::epoll_event event;
3387 #else
3388 const int16_t filter = posixFD.flags & CLAP_POSIX_FD_WRITE ? EVFILT_WRITE : EVFILT_READ;
3389 struct ::kevent kev = {}, event;
3390 struct ::timespec timeout = {};
3391 EV_SET(&kev, posixFD.pluginFd, filter, EV_ADD|EV_ENABLE, 0, 0, nullptr);
3392 #endif
3393
3394 for (int i=0; i<50; ++i)
3395 {
3396 #ifdef CARLA_CLAP_POSIX_EPOLL
3397 switch (::epoll_wait(posixFD.hostFd, &event, 1, 0))
3398 #else
3399 switch (::kevent(posixFD.hostFd, &kev, 1, &event, 1, &timeout))
3400 #endif
3401 {
3402 case 1:
3403 fExtensions.posixFD->on_fd(fPlugin, posixFD.pluginFd, posixFD.flags);
3404 break;
3405 case -1:
3406 fExtensions.posixFD->on_fd(fPlugin, posixFD.pluginFd, posixFD.flags | CLAP_POSIX_FD_ERROR);
3407 // fall through
3408 case 0:
3409 i = 50;
3410 break;
3411 default:
3412 carla_safe_exception("posix fd received abnormal value", __FILE__, __LINE__);
3413 i = 50;
3414 break;
3415 }
3416 }
3417 }
3418 #endif // _POSIX_VERSION
3419
3420 for (LinkedList<HostTimerDetails>::Itenerator it = fTimers.begin2(); it.valid(); it.next())
3421 {
3422 const uint32_t currentTimeInMs = water::Time::getMillisecondCounter();
3423 HostTimerDetails& timer(it.getValue(kTimerFallbackNC));
3424
3425 if (currentTimeInMs > timer.lastCallTimeInMs + timer.periodInMs)
3426 {
3427 timer.lastCallTimeInMs = currentTimeInMs;
3428 fExtensions.timer->on_timer(fPlugin, timer.clapId);
3429 }
3430 }
3431 #endif // CLAP_WINDOW_API_NATIVE
3432 }
3433 };
3434
3435 // --------------------------------------------------------------------------------------------------------------------
3436
3437 CarlaPluginPtr CarlaPlugin::newCLAP(const Initializer& init)
3438 {
3439 carla_debug("CarlaPlugin::newCLAP({%p, \"%s\", \"%s\", \"%s\"})",
3440 init.engine, init.filename, init.name, init.label);
3441
3442 std::shared_ptr<CarlaPluginCLAP> plugin(new CarlaPluginCLAP(init.engine, init.id));
3443
3444 if (! plugin->init(plugin, init.filename, init.name, init.label, init.options))
3445 return nullptr;
3446
3447 return plugin;
3448 }
3449
3450 // -------------------------------------------------------------------------------------------------------------------
3451
3452 CARLA_BACKEND_END_NAMESPACE