source/libjack/libjack_port-searching.cpp

   1 /*
   2  * Carla JACK API for external applications
   3  * Copyright (C) 2016-2022 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 "libjack.hpp"
  19
  20 #include "CarlaStringList.hpp"
  21
  22 CARLA_BACKEND_USE_NAMESPACE
  23
  24 // --------------------------------------------------------------------------------------------------------------------
  25
  26 static const char* allocate_port_name(const char* const prefixOrFullName, const uint num = UINT32_MAX)
  27 {
  28     static CarlaStringList portList;
  29
  30     char portName[STR_MAX];
  31     carla_zeroChars(portName, STR_MAX);
  32
  33     if (num == UINT32_MAX)
  34         std::strncpy(portName, prefixOrFullName, STR_MAX-1);
  35     else
  36         std::snprintf(portName, STR_MAX-1, "%s%u", prefixOrFullName, num+1);
  37
  38     if (const char* const storedPortName = portList.containsAndReturnString(portName))
  39         return storedPortName;
  40
  41     CARLA_SAFE_ASSERT_RETURN(portList.append(portName), nullptr);
  42
  43     return portList.getLast();
  44 }
  45
  46 // --------------------------------------------------------------------------------------------------------------------
  47
  48 CARLA_PLUGIN_EXPORT
  49 const char** jack_get_ports(jack_client_t* const client,
  50                             const char* const port_name,
  51                             const char* const port_type,
  52                             const unsigned long flags)
  53 {
  54     carla_stdout("%s(%p, %s, %s, 0x%lx)", __FUNCTION__, client, port_name, port_type, flags);
  55
  56     JackClientState* const jclient = (JackClientState*)client;
  57     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);
  58
  59     const JackServerState& jserver(jclient->server);
  60
  61     const uint numIns  = static_cast<uint>(jclient->audioIns.count() +
  62                                            jclient->midiIns.count() +
  63                                            jserver.numAudioIns +
  64                                            jserver.numMidiIns);
  65     const uint numOuts = static_cast<uint>(jclient->audioOuts.count() +
  66                                            jclient->midiOuts.count() +
  67                                            jserver.numAudioOuts +
  68                                            jserver.numMidiOuts);
  69
  70     const bool wantsAudio = port_type == nullptr || port_type[0] == '\0' || std::strstr(port_type, "audio") != nullptr;
  71     const bool wantsMIDI  = port_type == nullptr || port_type[0] == '\0' || std::strstr(port_type, "midi") != nullptr;
  72
  73     if (flags == 0x0 || (flags & (JackPortIsInput|JackPortIsOutput)) == (JackPortIsInput|JackPortIsOutput))
  74     {
  75         if (const char** const ret = (const char**)calloc(numIns+numOuts+1, sizeof(const char*)))
  76         {
  77             uint i=0;
  78
  79             if (wantsAudio)
  80             {
  81                 for (uint j=0; j<jserver.numAudioIns; ++i, ++j)
  82                     ret[i] = allocate_port_name("system:capture_", j);
  83                 for (uint j=0; j<jserver.numAudioOuts; ++i, ++j)
  84                     ret[i] = allocate_port_name("system:playback_", j);
  85             }
  86             if (wantsMIDI)
  87             {
  88                 for (uint j=0; j<jserver.numMidiIns; ++i, ++j)
  89                     ret[i] = allocate_port_name("system:midi_capture_", j);
  90                 for (uint j=0; j<jserver.numMidiOuts; ++i, ++j)
  91                     ret[i] = allocate_port_name("system:midi_playback_", j);
  92             }
  93
  94             if ((flags & (JackPortIsPhysical|JackPortIsTerminal)) == 0x0)
  95             {
  96                 if (wantsAudio)
  97                 {
  98                     for (LinkedList<JackPortState*>::Itenerator it = jclient->audioIns.begin2(); it.valid(); it.next())
  99                     {
 100                         JackPortState* const jport = it.getValue(nullptr);
 101                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 102                         ret[i++] = allocate_port_name(jport->fullname);
 103                     }
 104
 105                     for (LinkedList<JackPortState*>::Itenerator it = jclient->audioOuts.begin2(); it.valid(); it.next())
 106                     {
 107                         JackPortState* const jport = it.getValue(nullptr);
 108                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 109                         ret[i++] = allocate_port_name(jport->fullname);
 110                     }
 111                 }
 112
 113                 if (wantsMIDI)
 114                 {
 115                     for (LinkedList<JackPortState*>::Itenerator it = jclient->midiIns.begin2(); it.valid(); it.next())
 116                     {
 117                         JackPortState* const jport = it.getValue(nullptr);
 118                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 119                         ret[i++] = allocate_port_name(jport->fullname);
 120                     }
 121
 122                     for (LinkedList<JackPortState*>::Itenerator it = jclient->midiOuts.begin2(); it.valid(); it.next())
 123                     {
 124                         JackPortState* const jport = it.getValue(nullptr);
 125                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 126                         ret[i++] = allocate_port_name(jport->fullname);
 127                     }
 128                 }
 129             }
 130
 131             ret[i] = nullptr;
 132
 133             return ret;
 134         }
 135
 136         return nullptr;
 137     }
 138
 139     if (flags & JackPortIsInput)
 140     {
 141         if (const char** const ret = (const char**)calloc(numIns+1, sizeof(const char*)))
 142         {
 143             uint i=0;
 144             if (wantsAudio)
 145             {
 146                 for (uint j=0; j<jserver.numAudioOuts; ++i, ++j)
 147                     ret[i] = allocate_port_name("system:playback_", j);
 148             }
 149             if (wantsMIDI)
 150             {
 151                 for (uint j=0; j<jserver.numMidiOuts; ++i, ++j)
 152                     ret[i] = allocate_port_name("system:midi_playback_", j);
 153             }
 154
 155             if ((flags & (JackPortIsPhysical|JackPortIsTerminal)) == 0x0)
 156             {
 157                 if (wantsAudio)
 158                 {
 159                     for (LinkedList<JackPortState*>::Itenerator it = jclient->audioIns.begin2(); it.valid(); it.next())
 160                     {
 161                         JackPortState* const jport = it.getValue(nullptr);
 162                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 163                         ret[i++] = allocate_port_name(jport->fullname);
 164                     }
 165                 }
 166                 if (wantsMIDI)
 167                 {
 168                     for (LinkedList<JackPortState*>::Itenerator it = jclient->midiIns.begin2(); it.valid(); it.next())
 169                     {
 170                         JackPortState* const jport = it.getValue(nullptr);
 171                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 172                         ret[i++] = allocate_port_name(jport->fullname);
 173                     }
 174                 }
 175             }
 176
 177             ret[i] = nullptr;
 178
 179             return ret;
 180         }
 181
 182         return nullptr;
 183     }
 184
 185     if (flags & JackPortIsOutput)
 186     {
 187         if (const char** const ret = (const char**)calloc(numOuts+1, sizeof(const char*)))
 188         {
 189             uint i=0;
 190
 191             if (wantsAudio)
 192             {
 193                 for (uint j=0; j<jserver.numAudioIns; ++i, ++j)
 194                     ret[i] = allocate_port_name("system:capture_", j);
 195             }
 196             if (wantsMIDI)
 197             {
 198                 for (uint j=0; j<jserver.numMidiIns; ++i, ++j)
 199                     ret[i] = allocate_port_name("system:midi_capture_", j);
 200             }
 201
 202             if ((flags & (JackPortIsPhysical|JackPortIsTerminal)) == 0x0)
 203             {
 204                 if (wantsAudio)
 205                 {
 206                     for (LinkedList<JackPortState*>::Itenerator it = jclient->audioOuts.begin2(); it.valid(); it.next())
 207                     {
 208                         JackPortState* const jport = it.getValue(nullptr);
 209                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 210                         ret[i++] = allocate_port_name(jport->fullname);
 211                     }
 212                 }
 213                 if (wantsMIDI)
 214                 {
 215                     for (LinkedList<JackPortState*>::Itenerator it = jclient->midiOuts.begin2(); it.valid(); it.next())
 216                     {
 217                         JackPortState* const jport = it.getValue(nullptr);
 218                         CARLA_SAFE_ASSERT_CONTINUE(jport != nullptr);
 219                         ret[i++] = allocate_port_name(jport->fullname);
 220                     }
 221                 }
 222             }
 223
 224             ret[i] = nullptr;
 225
 226             return ret;
 227         }
 228
 229         return nullptr;
 230     }
 231
 232     return nullptr;
 233 }
 234
 235 CARLA_PLUGIN_EXPORT
 236 jack_port_t* jack_port_by_name(jack_client_t* client, const char* name)
 237 {
 238     carla_debug("%s(%p, %s)", __FUNCTION__, client, name);
 239
 240     JackClientState* const jclient = (JackClientState*)client;
 241     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);
 242
 243     if (std::strncmp(name, "system:", 7) == 0)
 244     {
 245         static std::map<uint, JackPortState*> systemPortIdMapping;
 246
 247         const JackServerState& jserver(jclient->server);
 248         const int commonFlags = JackPortIsPhysical|JackPortIsTerminal;
 249
 250         uint rindex, gid;
 251         int flags;
 252         bool isMidi, isConnected;
 253
 254         const char* const fullname = name;
 255         const char* const portname = name + 7;
 256         name += 7;
 257
 258         /**/ if (std::strncmp(name, "capture_", 8) == 0)
 259         {
 260             name += 8;
 261
 262             const int index = std::atoi(name)-1;
 263             CARLA_SAFE_ASSERT_RETURN(index >= 0 && index < jserver.numAudioIns, nullptr);
 264
 265             rindex = static_cast<uint>(index);
 266             flags  = commonFlags|JackPortIsOutput;
 267             gid    = JackPortState::kPortIdOffsetAudioIn + rindex;
 268             isMidi = false;
 269             isConnected = jserver.numAudioIns > rindex;
 270         }
 271         else if (std::strncmp(name, "playback_", 9) == 0)
 272         {
 273             name += 9;
 274
 275             const int index = std::atoi(name)-1;
 276             CARLA_SAFE_ASSERT_RETURN(index >= 0 && index < jserver.numAudioOuts, nullptr);
 277
 278             rindex = static_cast<uint>(jserver.numAudioIns + index);
 279             flags  = commonFlags|JackPortIsInput;
 280             gid    = JackPortState::kPortIdOffsetAudioOut + rindex;
 281             isMidi = false;
 282             isConnected = jserver.numAudioOuts > rindex;
 283         }
 284         else if (std::strncmp(name, "midi_capture_", 13) == 0)
 285         {
 286             name += 13;
 287
 288             const int index = std::atoi(name)-1;
 289             CARLA_SAFE_ASSERT_RETURN(index >= 0 && index < jserver.numMidiIns, nullptr);
 290
 291             rindex = static_cast<uint>(index);
 292             flags  = commonFlags|JackPortIsOutput;
 293             gid    = JackPortState::kPortIdOffsetMidiIn + rindex;
 294             isMidi = true;
 295             isConnected = jserver.numMidiIns > rindex;
 296         }
 297         else if (std::strncmp(name, "midi_playback_", 14) == 0)
 298         {
 299             name += 14;
 300
 301             const int index = std::atoi(name)-1;
 302             CARLA_SAFE_ASSERT_RETURN(index >= 0 && index < jserver.numMidiOuts, nullptr);
 303
 304             rindex = static_cast<uint>(jserver.numMidiIns + index);
 305             flags  = commonFlags|JackPortIsInput;
 306             gid    = JackPortState::kPortIdOffsetMidiOut + rindex;
 307             isMidi = true;
 308             isConnected = jserver.numMidiOuts > rindex;
 309         }
 310         else
 311         {
 312             carla_stderr2("jack_port_by_name: invalid port short name '%s'", name);
 313             return nullptr;
 314         }
 315
 316         if (JackPortState* const port = systemPortIdMapping[gid])
 317             return (jack_port_t*)port;
 318
 319         JackPortState* const port = new JackPortState(fullname,
 320                                                       portname,
 321                                                       rindex, flags, gid,
 322                                                       isMidi, isConnected);
 323         systemPortIdMapping[gid] = port;
 324
 325         return (jack_port_t*)port;
 326     }
 327     else
 328     {
 329         if (JackPortState* const port = jclient->portNameMapping[name])
 330             return (jack_port_t*)port;
 331     }
 332
 333     carla_stderr2("jack_port_by_name: invalid port name '%s'", name);
 334     return nullptr;
 335 }
 336
 337 CARLA_PLUGIN_EXPORT
 338 jack_port_t* jack_port_by_id(jack_client_t* client, jack_port_id_t port_id)
 339 {
 340     carla_debug("%s(%p, %u)", __FUNCTION__, client, port_id);
 341
 342     CARLA_SAFE_ASSERT_UINT_RETURN(port_id >= JackPortState::kPortIdOffsetUser, port_id, nullptr);
 343
 344     JackClientState* const jclient = (JackClientState*)client;
 345     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);
 346
 347     if (JackPortState* const port = jclient->portIdMapping[port_id])
 348         return (jack_port_t*)port;
 349
 350     carla_stderr2("jack_port_by_id: invalid port id %u", port_id);
 351     return nullptr;
 352 }
 353
 354 // --------------------------------------------------------------------------------------------------------------------
 355
 356 CARLA_PLUGIN_EXPORT
 357 const char** jack_port_get_connections(const jack_port_t* port)
 358 {
 359     carla_stderr2("%s(%p)", __FUNCTION__, port);
 360
 361     const JackPortState* const jport = (const JackPortState*)port;
 362     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, nullptr);
 363     CARLA_SAFE_ASSERT_RETURN(! jport->isSystem, nullptr);
 364
 365     if (! jport->isConnected)
 366         return nullptr;
 367
 368     return nullptr;
 369 }
 370
 371 CARLA_PLUGIN_EXPORT
 372 const char** jack_port_get_all_connections(const jack_client_t* client, const jack_port_t* port)
 373 {
 374     carla_stdout("%s(%p, %p) WIP", __FUNCTION__, client, port);
 375
 376     const JackClientState* const jclient = (const JackClientState*)client;
 377     CARLA_SAFE_ASSERT_RETURN(jclient != nullptr, nullptr);
 378
 379     const JackPortState* const jport = (const JackPortState*)port;
 380     CARLA_SAFE_ASSERT_RETURN(jport != nullptr, nullptr);
 381     CARLA_SAFE_ASSERT_UINT_RETURN(jport->gid >= JackPortState::kPortIdOffsetAudioIn, jport->gid, nullptr);
 382
 383     if (! jport->isConnected)
 384         return nullptr;
 385
 386     if (jport->isSystem)
 387     {
 388         const JackPortState* connectedPort;
 389
 390         /**/ if (jport->gid >= JackPortState::kPortIdOffsetMidiOut)
 391             connectedPort = jclient->midiOuts.getAt(jport->gid - JackPortState::kPortIdOffsetMidiOut, nullptr);
 392         else if (jport->gid >= JackPortState::kPortIdOffsetAudioOut)
 393             connectedPort = jclient->audioOuts.getAt(jport->gid - JackPortState::kPortIdOffsetAudioOut, nullptr);
 394         else if (jport->gid >= JackPortState::kPortIdOffsetMidiIn)
 395             connectedPort = jclient->midiIns.getAt(jport->gid - JackPortState::kPortIdOffsetMidiIn, nullptr);
 396         else
 397             connectedPort = jclient->audioIns.getAt(jport->gid - JackPortState::kPortIdOffsetAudioIn, nullptr);
 398
 399         if (connectedPort == nullptr)
 400         {
 401             carla_debug("port %s has no connections?", jport->fullname);
 402             return nullptr;
 403         }
 404
 405         if (const char** const ret = static_cast<const char**>(malloc(sizeof(const char*)*2)))
 406         {
 407             carla_debug("port %s is connected to %s", jport->fullname, connectedPort->fullname);
 408             ret[0] = connectedPort->fullname;
 409             ret[1] = nullptr;
 410             return ret;
 411         }
 412     }
 413     else
 414     {
 415         const JackServerState& jserver(jclient->server);
 416         const char* connectedPortName = nullptr;
 417
 418         if (jport->isMidi)
 419         {
 420             if (jport->flags & JackPortIsOutput)
 421             {
 422                 if (jport->index < jserver.numMidiOuts)
 423                      connectedPortName = allocate_port_name("system:midi_playback_", jport->index);
 424             }
 425             else
 426             {
 427                 if (jport->index < jserver.numMidiIns)
 428                      connectedPortName = allocate_port_name("system:midi_capture_", jport->index);
 429             }
 430         }
 431         else
 432         {
 433             if (jport->flags & JackPortIsOutput)
 434             {
 435                 if (jport->index < jserver.numAudioOuts)
 436                     connectedPortName = allocate_port_name("system:playback_", jport->index);
 437             }
 438             else
 439             {
 440                 if (jport->index < jserver.numAudioIns)
 441                     connectedPortName = allocate_port_name("system:capture_", jport->index);
 442             }
 443         }
 444
 445         if (connectedPortName != nullptr)
 446         {
 447             if (const char** const ret = static_cast<const char**>(malloc(sizeof(const char*)*2)))
 448             {
 449                 carla_debug("port %s is connected to %s", jport->fullname, connectedPortName);
 450                 ret[0] = connectedPortName;
 451                 ret[1] = nullptr;
 452                 return ret;
 453             }
 454         }
 455     }
 456
 457     return nullptr;
 458 }
 459
 460 // --------------------------------------------------------------------------------------------------------------------