falkTX
/
Cadence
mirror of https://github.com/falkTX/Cadence
1
0
Fork 0
Code Releases 3 Activity
Collection of tools useful for audio production
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
651 Commits
2 Branches
20MB
Tree: d701ba2182
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd701ba2182'
${ noResults }
Cadence/c++/carla-engine/carla_engine_jack.cpp

695 lines
24KB
Raw Blame History 

  1. /*

  2.  * Carla Backend

  3.  * Copyright (C) 2011-2012 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or modify

  6.  * it under the terms of the GNU General Public License as published by

  7.  * the Free Software Foundation; either version 2 of the License, or

  8.  * 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 COPYING file

  16.  */

  17. 

  18. #ifdef CARLA_ENGINE_JACK

  19. 

  20. #include "carla_engine.hpp"

  21. #include "carla_plugin.hpp"

  22. 

  23. CARLA_BACKEND_START_NAMESPACE

  24. 

  25. // -----------------------------------------

  26. 

  27. class CarlaEngineJack : public CarlaEngine

  28. {

  29. public:

  30.     CarlaEngineJack()

  31.         : CarlaEngine()

  32. #ifndef BUILD_BRIDGE

  33. #  ifdef Q_COMPILER_INITIALIZER_LISTS

  34.         , rackJackPorts{nullptr}

  35. #  endif

  36. #endif

  37.     {

  38.         qDebug("CarlaEngineJack::CarlaEngineJack()");

  39. 

  40.         type = CarlaEngineTypeJack;

  41. 

  42.         client = nullptr;

  43.         state  = JackTransportStopped;

  44.         freewheel = false;

  45. 

  46.         memset(&pos, 0, sizeof(jack_position_t));

  47. 

  48. #ifndef BUILD_BRIDGE

  49. #  ifndef Q_COMPILER_INITIALIZER_LISTS

  50.         for (unsigned short i=0; i < rackPortCount; i++)

  51.             rackJackPorts[i] = nullptr;

  52. #  endif

  53. #endif

  54.     }

  55. 

  56.     ~CarlaEngineJack()

  57.     {

  58.         qDebug("CarlaEngineJack::~CarlaEngineJack()");

  59.     }

  60. 

  61.     // -------------------------------------

  62. 

  63.     bool init(const char* const clientName)

  64.     {

  65.         qDebug("CarlaEngineJack::init(\"%s\")", clientName);

  66. 

  67.         freewheel = false;

  68.         state = JackTransportStopped;

  69. 

  70. #ifndef BUILD_BRIDGE

  71.         client = jackbridge_client_open(clientName, JackNullOption, nullptr);

  72. 

  73.         if (client)

  74.         {

  75.             sampleRate = jackbridge_get_sample_rate(client);

  76.             bufferSize = jackbridge_get_buffer_size(client);

  77. 

  78.             jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  79.             jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  80.             jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  81.             jackbridge_set_process_callback(client, carla_jack_process_callback, this);

  82.             jackbridge_set_latency_callback(client, carla_jack_latency_callback, this);

  83.             jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  84. 

  85.             if (processMode == PROCESS_MODE_CONTINUOUS_RACK)

  86.             {

  87.                 rackJackPorts[rackPortAudioIn1]   = jackbridge_port_register(client, "in1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);

  88.                 rackJackPorts[rackPortAudioIn2]   = jackbridge_port_register(client, "in2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);

  89.                 rackJackPorts[rackPortAudioOut1]  = jackbridge_port_register(client, "out1", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);

  90.                 rackJackPorts[rackPortAudioOut2]  = jackbridge_port_register(client, "out2", JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);

  91.                 rackJackPorts[rackPortControlIn]  = jackbridge_port_register(client, "control-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);

  92.                 rackJackPorts[rackPortControlOut] = jackbridge_port_register(client, "control-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);

  93.                 rackJackPorts[rackPortMidiIn]     = jackbridge_port_register(client, "midi-in", JACK_DEFAULT_MIDI_TYPE, JackPortIsInput, 0);

  94.                 rackJackPorts[rackPortMidiOut]    = jackbridge_port_register(client, "midi-out", JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0);

  95.             }

  96. 

  97.             if (jackbridge_activate(client) == 0)

  98.             {

  99.                 name = getFixedClientName(jackbridge_get_client_name(client));

  100.                 CarlaEngine::init(name);

  101.                 return true;

  102.             }

  103.             else

  104.             {

  105.                 setLastError("Failed to activate the JACK client");

  106.                 client = nullptr;

  107.             }

  108.         }

  109.         else

  110.             setLastError("Failed to create new JACK client");

  111. 

  112.         return false;

  113. #else

  114.         name = getFixedClientName(clientName);

  115.         CarlaEngine::init(name);

  116.         return true;

  117. #endif

  118.     }

  119. 

  120.     bool close()

  121.     {

  122.         qDebug("CarlaEngineJack::close()");

  123.         CarlaEngine::close();

  124. 

  125.         if (name)

  126.         {

  127.             free((void*)name);

  128.             name = nullptr;

  129.         }

  130. 

  131. #ifdef BUILD_BRIDGE

  132.         client = nullptr;

  133.         return true;

  134. #else

  135.         if (jackbridge_deactivate(client) == 0)

  136.         {

  137.             if (processMode == PROCESS_MODE_CONTINUOUS_RACK)

  138.             {

  139.                 jackbridge_port_unregister(client, rackJackPorts[rackPortAudioIn1]);

  140.                 jackbridge_port_unregister(client, rackJackPorts[rackPortAudioIn2]);

  141.                 jackbridge_port_unregister(client, rackJackPorts[rackPortAudioOut1]);

  142.                 jackbridge_port_unregister(client, rackJackPorts[rackPortAudioOut2]);

  143.                 jackbridge_port_unregister(client, rackJackPorts[rackPortControlIn]);

  144.                 jackbridge_port_unregister(client, rackJackPorts[rackPortControlOut]);

  145.                 jackbridge_port_unregister(client, rackJackPorts[rackPortMidiIn]);

  146.                 jackbridge_port_unregister(client, rackJackPorts[rackPortMidiOut]);

  147.             }

  148. 

  149.             if (jackbridge_client_close(client) == 0)

  150.             {

  151.                 client = nullptr;

  152.                 return true;

  153.             }

  154.             else

  155.                 setLastError("Failed to close the JACK client");

  156.         }

  157.         else

  158.             setLastError("Failed to deactivate the JACK client");

  159. 

  160.         client = nullptr;

  161. #endif

  162.         return false;

  163.     }

  164. 

  165.     bool isOffline()

  166.     {

  167.         return freewheel;

  168.     }

  169. 

  170.     bool isRunning()

  171.     {

  172.         return bool(client);

  173.     }

  174. 

  175.     CarlaEngineClient* addClient(CarlaPlugin* const plugin)

  176.     {

  177.         CarlaEngineClientNativeHandle handle;

  178.         handle.type = CarlaEngineTypeJack;

  179. 

  180. #ifdef BUILD_BRIDGE

  181.         client = handle.jackClient = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);

  182. 

  183.         sampleRate = jackbridge_get_sample_rate(client);

  184.         bufferSize = jackbridge_get_buffer_size(client);

  185. 

  186.         jackbridge_set_sample_rate_callback(client, carla_jack_srate_callback, this);

  187.         jackbridge_set_buffer_size_callback(client, carla_jack_bufsize_callback, this);

  188.         jackbridge_set_freewheel_callback(client, carla_jack_freewheel_callback, this);

  189.         jackbridge_set_process_callback(handle.jackClient, carla_jack_process_callback, this);

  190.         jackbridge_set_latency_callback(handle.jackClient, carla_jack_latency_callback, this);

  191.         jackbridge_on_shutdown(client, carla_jack_shutdown_callback, this);

  192. #else

  193.         if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  194.         {

  195.             handle.jackClient = client;

  196.         }

  197.         else if (processMode == PROCESS_MODE_MULTIPLE_CLIENTS)

  198.         {

  199.             handle.jackClient = jackbridge_client_open(plugin->name(), JackNullOption, nullptr);

  200.             jackbridge_set_process_callback(handle.jackClient, carla_jack_process_callback_plugin, plugin);

  201.             jackbridge_set_latency_callback(handle.jackClient, carla_jack_latency_callback_plugin, plugin);

  202.         }

  203. #endif

  204. 

  205.         return new CarlaEngineClient(handle);

  206.     }

  207. 

  208.     // -------------------------------------

  209. 

  210. protected:

  211.     void handleSampleRateCallback(double newSampleRate)

  212.     {

  213.         sampleRate = newSampleRate;

  214.     }

  215. 

  216.     void handleBufferSizeCallback(uint32_t newBufferSize)

  217.     {

  218. #ifndef BUILD_BRIDGE

  219.         if (options.processHighPrecision)

  220.             return;

  221. #endif

  222. 

  223.         bufferSizeChanged(newBufferSize);

  224.     }

  225. 

  226.     void handleFreewheelCallback(bool isFreewheel)

  227.     {

  228.         freewheel = isFreewheel;

  229.     }

  230. 

  231.     void handleProcessCallback(uint32_t nframes)

  232.     {

  233. #ifndef BUILD_BRIDGE

  234.         if (maxPluginNumber() == 0)

  235.             return;

  236. #endif

  237.         state = jackbridge_transport_query(client, &pos);

  238. 

  239.         timeInfo.playing = (state != JackTransportStopped);

  240. 

  241.         if (pos.unique_1 == pos.unique_2)

  242.         {

  243.             timeInfo.frame = pos.frame;

  244.             timeInfo.time  = pos.usecs;

  245. 

  246.             if (pos.valid & JackPositionBBT)

  247.             {

  248.                 timeInfo.valid = CarlaEngineTimeBBT;

  249.                 timeInfo.bbt.bar  = pos.bar;

  250.                 timeInfo.bbt.beat = pos.beat;

  251.                 timeInfo.bbt.tick = pos.tick;

  252.                 timeInfo.bbt.bar_start_tick = pos.bar_start_tick;

  253.                 timeInfo.bbt.beats_per_bar  = pos.beats_per_bar;

  254.                 timeInfo.bbt.beat_type      = pos.beat_type;

  255.                 timeInfo.bbt.ticks_per_beat = pos.ticks_per_beat;

  256.                 timeInfo.bbt.beats_per_minute = pos.beats_per_minute;

  257.             }

  258.             else

  259.                 timeInfo.valid = 0;

  260.         }

  261.         else

  262.         {

  263.             timeInfo.frame = 0;

  264.             timeInfo.valid = 0;

  265.         }

  266. 

  267. #ifndef BUILD_BRIDGE

  268.         if (processMode == PROCESS_MODE_SINGLE_CLIENT)

  269.         {

  270.             for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)

  271.             {

  272.                 CarlaPlugin* const plugin = getPluginUnchecked(i);

  273. 

  274.                 if (! plugin)

  275.                     continue;

  276. 

  277.                 plugin->engineProcessLock();

  278. 

  279.                 if (plugin->enabled())

  280.                 {

  281.                     plugin->initBuffers();

  282.                     processPlugin(plugin, nframes);

  283.                 }

  284.                 else

  285.                     processPluginNOT(plugin, nframes);

  286. 

  287.                 plugin->engineProcessUnlock();

  288.             }

  289.         }

  290.         else if (processMode == PROCESS_MODE_CONTINUOUS_RACK)

  291.         {

  292.             // get buffers from jack

  293.             float* audioIn1  = (float*)jackbridge_port_get_buffer(rackJackPorts[rackPortAudioIn1], nframes);

  294.             float* audioIn2  = (float*)jackbridge_port_get_buffer(rackJackPorts[rackPortAudioIn2], nframes);

  295.             float* audioOut1 = (float*)jackbridge_port_get_buffer(rackJackPorts[rackPortAudioOut1], nframes);

  296.             float* audioOut2 = (float*)jackbridge_port_get_buffer(rackJackPorts[rackPortAudioOut2], nframes);

  297.             void* controlIn  = jackbridge_port_get_buffer(rackJackPorts[rackPortControlIn], nframes);

  298.             void* controlOut = jackbridge_port_get_buffer(rackJackPorts[rackPortControlOut], nframes);

  299.             void* midiIn     = jackbridge_port_get_buffer(rackJackPorts[rackPortMidiIn], nframes);

  300.             void* midiOut    = jackbridge_port_get_buffer(rackJackPorts[rackPortMidiOut], nframes);

  301. 

  302.             // assert buffers

  303.             CARLA_ASSERT(audioIn1);

  304.             CARLA_ASSERT(audioIn2);

  305.             CARLA_ASSERT(audioOut1);

  306.             CARLA_ASSERT(audioOut2);

  307.             CARLA_ASSERT(controlIn);

  308.             CARLA_ASSERT(controlOut);

  309.             CARLA_ASSERT(midiIn);

  310.             CARLA_ASSERT(midiOut);

  311. 

  312.             // create audio buffers

  313.             float* inBuf[2]  = { audioIn1, audioIn2 };

  314.             float* outBuf[2] = { audioOut1, audioOut2 };

  315. 

  316.             // initialize control input

  317.             memset(rackControlEventsIn, 0, sizeof(CarlaEngineControlEvent)*MAX_ENGINE_CONTROL_EVENTS);

  318.             {

  319.                 jackbridge_midi_event_t jackEvent;

  320.                 const uint32_t jackEventCount = jackbridge_midi_get_event_count(controlIn);

  321. 

  322.                 uint32_t carlaEventIndex = 0;

  323. 

  324.                 for (uint32_t jackEventIndex=0; jackEventIndex < jackEventCount; jackEventIndex++)

  325.                 {

  326.                     if (jackbridge_midi_event_get(&jackEvent, controlIn, jackEventIndex) != 0)

  327.                         continue;

  328. 

  329.                     CarlaEngineControlEvent* const carlaEvent = &rackControlEventsIn[carlaEventIndex++];

  330. 

  331.                     uint8_t midiStatus  = jackEvent.buffer[0];

  332.                     uint8_t midiChannel = midiStatus & 0x0F;

  333. 

  334.                     carlaEvent->time    = jackEvent.time;

  335.                     carlaEvent->channel = midiChannel;

  336. 

  337.                     if (MIDI_IS_STATUS_CONTROL_CHANGE(midiStatus))

  338.                     {

  339.                         uint8_t midiControl = jackEvent.buffer[1];

  340. 

  341.                         if (MIDI_IS_CONTROL_BANK_SELECT(midiControl))

  342.                         {

  343.                             uint8_t midiBank = jackEvent.buffer[2];

  344.                             carlaEvent->type  = CarlaEngineEventMidiBankChange;

  345.                             carlaEvent->value = midiBank;

  346.                         }

  347.                         else if (midiControl == MIDI_CONTROL_ALL_SOUND_OFF)

  348.                         {

  349.                             carlaEvent->type = CarlaEngineEventAllSoundOff;

  350.                         }

  351.                         else if (midiControl == MIDI_CONTROL_ALL_NOTES_OFF)

  352.                         {

  353.                             carlaEvent->type = CarlaEngineEventAllNotesOff;

  354.                         }

  355.                         else

  356.                         {

  357.                             uint8_t midiValue     = jackEvent.buffer[2];

  358.                             carlaEvent->type       = CarlaEngineEventControlChange;

  359.                             carlaEvent->controller = midiControl;

  360.                             carlaEvent->value      = double(midiValue)/127;

  361.                         }

  362.                     }

  363.                     else if (MIDI_IS_STATUS_PROGRAM_CHANGE(midiStatus))

  364.                     {

  365.                         uint8_t midiProgram = jackEvent.buffer[1];

  366.                         carlaEvent->type  = CarlaEngineEventMidiProgramChange;

  367.                         carlaEvent->value = midiProgram;

  368.                     }

  369.                 }

  370.             }

  371. 

  372.             // initialize midi input

  373.             memset(rackMidiEventsIn, 0, sizeof(CarlaEngineMidiEvent)*MAX_ENGINE_MIDI_EVENTS);

  374.             {

  375.                 uint32_t i = 0, j = 0;

  376.                 jackbridge_midi_event_t jackEvent;

  377. 

  378.                 while (jackbridge_midi_event_get(&jackEvent, midiIn, j++) == 0)

  379.                 {

  380.                     if (i == MAX_ENGINE_MIDI_EVENTS)

  381.                         break;

  382. 

  383.                     if (jackEvent.size < 4)

  384.                     {

  385.                         rackMidiEventsIn[i].time = jackEvent.time;

  386.                         rackMidiEventsIn[i].size = jackEvent.size;

  387.                         memcpy(rackMidiEventsIn[i].data, jackEvent.buffer, jackEvent.size);

  388.                         i += 1;

  389.                     }

  390.                 }

  391.             }

  392. 

  393.             // process rack

  394.             processRack(inBuf, outBuf, nframes);

  395. 

  396.             // output control

  397.             {

  398.                 jackbridge_midi_clear_buffer(controlOut);

  399. 

  400.                 for (unsigned short i=0; i < MAX_ENGINE_CONTROL_EVENTS; i++)

  401.                 {

  402.                     CarlaEngineControlEvent* const event = &rackControlEventsOut[i];

  403. 

  404.                     if (event->type == CarlaEngineEventControlChange && MIDI_IS_CONTROL_BANK_SELECT(event->controller))

  405.                         event->type = CarlaEngineEventMidiBankChange;

  406. 

  407.                     uint8_t data[4] = { 0 };

  408. 

  409.                     switch (event->type)

  410.                     {

  411.                     case CarlaEngineEventNull:

  412.                         break;

  413.                     case CarlaEngineEventControlChange:

  414.                         data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;

  415.                         data[1] = event->controller;

  416.                         data[2] = event->value * 127;

  417.                         jackbridge_midi_event_write(controlOut, event->time, data, 3);

  418.                         break;

  419.                     case CarlaEngineEventMidiBankChange:

  420.                         data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;

  421.                         data[1] = MIDI_CONTROL_BANK_SELECT;

  422.                         data[2] = event->value;

  423.                         jackbridge_midi_event_write(controlOut, event->time, data, 3);

  424.                         break;

  425.                     case CarlaEngineEventMidiProgramChange:

  426.                         data[0] = MIDI_STATUS_PROGRAM_CHANGE + event->channel;

  427.                         data[1] = event->value;

  428.                         jackbridge_midi_event_write(controlOut, event->time, data, 2);

  429.                         break;

  430.                     case CarlaEngineEventAllSoundOff:

  431.                         data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;

  432.                         data[1] = MIDI_CONTROL_ALL_SOUND_OFF;

  433.                         jackbridge_midi_event_write(controlOut, event->time, data, 2);

  434.                         break;

  435.                     case CarlaEngineEventAllNotesOff:

  436.                         data[0] = MIDI_STATUS_CONTROL_CHANGE + event->channel;

  437.                         data[1] = MIDI_CONTROL_ALL_NOTES_OFF;

  438.                         jackbridge_midi_event_write(controlOut, event->time, data, 2);

  439.                         break;

  440.                     }

  441.                 }

  442.             }

  443. 

  444.             // output midi

  445.             {

  446.                 jackbridge_midi_clear_buffer(midiOut);

  447. 

  448.                 for (unsigned short i=0; i < MAX_ENGINE_MIDI_EVENTS; i++)

  449.                 {

  450.                     if (rackMidiEventsOut[i].size == 0)

  451.                         break;

  452. 

  453.                     jackbridge_midi_event_write(midiOut, rackMidiEventsOut[i].time, rackMidiEventsOut[i].data, rackMidiEventsOut[i].size);

  454.                 }

  455.             }

  456.         }

  457. #else

  458.         CarlaPlugin* const plugin = getPluginUnchecked(0);

  459. 

  460.         if (! plugin)

  461.             return;

  462. 

  463.         plugin->engineProcessLock();

  464. 

  465.         if (plugin->enabled())

  466.         {

  467.             plugin->initBuffers();

  468.             processPlugin(plugin, nframes);

  469.         }

  470.         else

  471.             processPluginNOT(plugin, nframes);

  472. 

  473.         plugin->engineProcessUnlock();

  474. #endif

  475.     }

  476. 

  477.     void handleLatencyCallback(jack_latency_callback_mode_t mode)

  478.     {

  479. #ifndef BUILD_BRIDGE

  480.         if (processMode != PROCESS_MODE_SINGLE_CLIENT)

  481.             return;

  482. #endif

  483. 

  484.         for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)

  485.         {

  486.             CarlaPlugin* const plugin = getPluginUnchecked(i);

  487. 

  488.             if (plugin && plugin->enabled())

  489.                 latencyPlugin(plugin, mode);

  490.         }

  491.     }

  492. 

  493.     void handleShutdownCallback()

  494.     {

  495.         for (unsigned short i=0, max=maxPluginNumber(); i < max; i++)

  496.         {

  497.             CarlaPlugin* const plugin = getPluginUnchecked(i);

  498. 

  499.             if (plugin)

  500.                 plugin->x_client = nullptr;

  501.         }

  502. 

  503.         client = nullptr;

  504.         callback(CALLBACK_QUIT, 0, 0, 0, 0.0);

  505.     }

  506. 

  507.     // -------------------------------------

  508. 

  509. private:

  510.     jack_client_t* client;

  511.     jack_transport_state_t state;

  512.     jack_position_t pos;

  513.     bool freewheel;

  514. 

  515.     // -------------------------------------

  516. 

  517. #ifndef BUILD_BRIDGE

  518.     enum RackPorts {

  519.         rackPortAudioIn1   = 0,

  520.         rackPortAudioIn2   = 1,

  521.         rackPortAudioOut1  = 2,

  522.         rackPortAudioOut2  = 3,

  523.         rackPortControlIn  = 4,

  524.         rackPortControlOut = 5,

  525.         rackPortMidiIn     = 6,

  526.         rackPortMidiOut    = 7,

  527.         rackPortCount      = 8

  528.     };

  529. 

  530.     jack_port_t* rackJackPorts[rackPortCount];

  531. #endif

  532. 

  533.     static void processPlugin(CarlaPlugin* const p, const uint32_t nframes)

  534.     {

  535.         float* inBuffer[p->aIn.count];

  536.         float* outBuffer[p->aOut.count];

  537. 

  538.         for (uint32_t i=0; i < p->aIn.count; i++)

  539.             inBuffer[i] = p->aIn.ports[i]->getJackAudioBuffer(nframes);

  540. 

  541.         for (uint32_t i=0; i < p->aOut.count; i++)

  542.             outBuffer[i] = p->aOut.ports[i]->getJackAudioBuffer(nframes);

  543. 

  544. #ifndef BUILD_BRIDGE

  545.         if (/*options.processHighPrecision*/ 0)

  546.         {

  547.             float* inBuffer2[p->aIn.count];

  548.             float* outBuffer2[p->aOut.count];

  549. 

  550.             for (uint32_t i=0, j; i < nframes; i += 8)

  551.             {

  552.                 for (j=0; j < p->aIn.count; j++)

  553.                     inBuffer2[j] = inBuffer[j] + i;

  554. 

  555.                 for (j=0; j < p->aOut.count; j++)

  556.                     outBuffer2[j] = outBuffer[j] + i;

  557. 

  558.                 p->process(inBuffer2, outBuffer2, 8, i);

  559.             }

  560.         }

  561.         else

  562. #endif

  563.             p->process(inBuffer, outBuffer, nframes);

  564.     }

  565. 

  566.     static void processPluginNOT(CarlaPlugin* const p, const uint32_t nframes)

  567.     {

  568.         for (uint32_t i=0; i < p->aIn.count; i++)

  569.             carla_zeroF(p->aIn.ports[i]->getJackAudioBuffer(nframes), nframes);

  570. 

  571.         for (uint32_t i=0; i < p->aOut.count; i++)

  572.             carla_zeroF(p->aOut.ports[i]->getJackAudioBuffer(nframes), nframes);

  573.     }

  574. 

  575.     static void latencyPlugin(CarlaPlugin* const p, jack_latency_callback_mode_t mode)

  576.     {

  577.         jack_latency_range_t range;

  578.         uint32_t pluginLatency = p->x_client->getLatency();

  579. 

  580.         if (pluginLatency == 0)

  581.             return;

  582. 

  583.         if (mode == JackCaptureLatency)

  584.         {

  585.             for (uint32_t i=0; i < p->aIn.count; i++)

  586.             {

  587.                 uint aOutI = (i >= p->aOut.count) ? p->aOut.count : i;

  588.                 jack_port_t* const portIn  = p->aIn.ports[i]->getHandle().jackPort;

  589.                 jack_port_t* const portOut = p->aOut.ports[aOutI]->getHandle().jackPort;

  590. 

  591.                 jackbridge_port_get_latency_range(portIn, mode, &range);

  592.                 range.min += pluginLatency;

  593.                 range.max += pluginLatency;

  594.                 jackbridge_port_set_latency_range(portOut, mode, &range);

  595.             }

  596.         }

  597.         else

  598.         {

  599.             for (uint32_t i=0; i < p->aOut.count; i++)

  600.             {

  601.                 uint aInI = (i >= p->aIn.count) ? p->aIn.count : i;

  602.                 jack_port_t* const portIn  = p->aIn.ports[aInI]->getHandle().jackPort;

  603.                 jack_port_t* const portOut = p->aOut.ports[i]->getHandle().jackPort;

  604. 

  605.                 jackbridge_port_get_latency_range(portOut, mode, &range);

  606.                 range.min += pluginLatency;

  607.                 range.max += pluginLatency;

  608.                 jackbridge_port_set_latency_range(portIn, mode, &range);

  609.             }

  610.         }

  611.     }

  612. 

  613.     static int carla_jack_srate_callback(jack_nframes_t newSampleRate, void* arg)

  614.     {

  615.         CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;

  616.         _this_->handleSampleRateCallback(newSampleRate);

  617.         return 0;

  618.     }

  619. 

  620.     static int carla_jack_bufsize_callback(jack_nframes_t newBufferSize, void* arg)

  621.     {

  622.         CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;

  623.         _this_->handleBufferSizeCallback(newBufferSize);

  624.         return 0;

  625.     }

  626. 

  627.     static void carla_jack_freewheel_callback(int starting, void* arg)

  628.     {

  629.         CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;

  630.         _this_->handleFreewheelCallback(bool(starting));

  631.     }

  632. 

  633.     static int carla_jack_process_callback(jack_nframes_t nframes, void* arg)

  634.     {

  635.         CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;

  636.         _this_->handleProcessCallback(nframes);

  637.         return 0;

  638.     }

  639. 

  640.     static int carla_jack_process_callback_plugin(jack_nframes_t nframes, void* arg)

  641.     {

  642.         CarlaPlugin* const plugin = (CarlaPlugin*)arg;

  643. 

  644.         if (! plugin)

  645.             return 0;

  646. 

  647.         plugin->engineProcessLock();

  648. 

  649.         if (plugin->enabled())

  650.         {

  651.             plugin->initBuffers();

  652.             processPlugin(plugin, nframes);

  653.         }

  654.         else

  655.             processPluginNOT(plugin, nframes);

  656. 

  657.         plugin->engineProcessUnlock();

  658. 

  659.         return 0;

  660.     }

  661. 

  662.     static void carla_jack_latency_callback(jack_latency_callback_mode_t mode, void* arg)

  663.     {

  664.         CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;

  665.         _this_->handleLatencyCallback(mode);

  666.     }

  667. 

  668.     static void carla_jack_latency_callback_plugin(jack_latency_callback_mode_t mode, void* arg)

  669.     {

  670.         CarlaPlugin* const plugin = (CarlaPlugin*)arg;

  671. 

  672.         if (plugin && plugin->enabled())

  673.             latencyPlugin(plugin, mode);

  674.     }

  675. 

  676.     static void carla_jack_shutdown_callback(void* arg)

  677.     {

  678.         CarlaEngineJack* const _this_ = (CarlaEngineJack*)arg;

  679.         _this_->handleShutdownCallback();

  680.     }

  681. };

  682. 

  683. // -----------------------------------------

  684. 

  685. CarlaEngine* CarlaEngine::newJack()

  686. {

  687.     return new CarlaEngineJack();

  688. }

  689. 

  690. // -----------------------------------------

  691. 

  692. CARLA_BACKEND_END_NAMESPACE

  693. 

  694. #endif // CARLA_ENGINE_JACK