common/JackLoopbackDriver.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2006 Grame
   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 (at your option) 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 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #ifdef WIN32
  22 #pragma warning (disable : 4786)
  23 #endif
  24
  25 #include "JackLoopbackDriver.h"
  26 #include "JackEngineControl.h"
  27 #include "JackGraphManager.h"
  28 #include <iostream>
  29 #include <assert.h>
  30
  31 namespace Jack
  32 {
  33
  34 int JackLoopbackDriver::Process()
  35 {
  36     assert(fCaptureChannels == fPlaybackChannels);
  37
  38     // Loopback copy
  39     for (int i = 0; i < fCaptureChannels; i++) {
  40         memcpy(GetInputBuffer(i), GetOutputBuffer(i), sizeof(float) * fEngineControl->fBufferSize);
  41         }
  42
  43     fGraphManager->ResumeRefNum(fClientControl, fSynchroTable); // Signal all clients
  44     if (fEngineControl->fSyncMode) {
  45         if (fGraphManager->SuspendRefNum(fClientControl, fSynchroTable, fEngineControl->fTimeOutUsecs) < 0) {
  46             jack_error("JackLoopbackDriver::ProcessSync SuspendRefNum error");
  47                         return -1;
  48                 }
  49     }
  50     return 0;
  51 }
  52
  53 void JackLoopbackDriver::PrintState()
  54 {
  55     int i;
  56     jack_port_id_t port_index;
  57
  58     std::cout << "JackLoopbackDriver state" << std::endl;
  59     std::cout << "Input ports" << std::endl;
  60
  61     for (i = 0; i < fPlaybackChannels; i++) {
  62         port_index = fCapturePortList[i];
  63         JackPort* port = fGraphManager->GetPort(port_index);
  64         std::cout << port->GetName() << std::endl;
  65         if (fGraphManager->GetConnectionsNum(port_index)) {}
  66     }
  67
  68     std::cout << "Output ports" << std::endl;
  69
  70     for (i = 0; i < fCaptureChannels; i++) {
  71         port_index = fPlaybackPortList[i];
  72         JackPort* port = fGraphManager->GetPort(port_index);
  73         std::cout << port->GetName() << std::endl;
  74         if (fGraphManager->GetConnectionsNum(port_index)) {}
  75     }
  76 }
  77
  78 } // end of namespace
  79
  80 /*
  81 #ifdef __cplusplus
  82 extern "C" {
  83 #endif
  84
  85 jack_driver_desc_t * driver_get_descriptor ()
  86 {
  87         jack_driver_desc_t * desc;
  88         jack_driver_param_desc_t * params;
  89         unsigned int i;
  90
  91         desc = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
  92         strcpy (desc->name, "dummy");
  93         desc->nparams = 5;
  94
  95         params = (jack_driver_param_desc_t*)calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
  96
  97         i = 0;
  98         strcpy (params[i].name, "capture");
  99         params[i].character  = 'C';
 100         params[i].type       = JackDriverParamUInt;
 101         params[i].value.ui   = 2U;
 102         strcpy (params[i].short_desc, "Number of capture ports");
 103         strcpy (params[i].long_desc, params[i].short_desc);
 104
 105         i++;
 106         strcpy (params[i].name, "playback");
 107         params[i].character  = 'P';
 108         params[i].type       = JackDriverParamUInt;
 109         params[1].value.ui   = 2U;
 110         strcpy (params[i].short_desc, "Number of playback ports");
 111         strcpy (params[i].long_desc, params[i].short_desc);
 112
 113         i++;
 114         strcpy (params[i].name, "rate");
 115         params[i].character  = 'r';
 116         params[i].type       = JackDriverParamUInt;
 117         params[i].value.ui   = 48000U;
 118         strcpy (params[i].short_desc, "Sample rate");
 119         strcpy (params[i].long_desc, params[i].short_desc);
 120
 121         i++;
 122         strcpy (params[i].name, "period");
 123         params[i].character  = 'p';
 124         params[i].type       = JackDriverParamUInt;
 125         params[i].value.ui   = 1024U;
 126         strcpy (params[i].short_desc, "Frames per period");
 127         strcpy (params[i].long_desc, params[i].short_desc);
 128
 129         i++;
 130         strcpy (params[i].name, "wait");
 131         params[i].character  = 'w';
 132         params[i].type       = JackDriverParamUInt;
 133         params[i].value.ui   = 21333U;
 134         strcpy (params[i].short_desc,
 135                 "Number of usecs to wait between engine processes");
 136         strcpy (params[i].long_desc, params[i].short_desc);
 137
 138         desc->params = params;
 139
 140         return desc;
 141 }
 142
 143 Jack::JackDriverClientInterface* driver_initialize(Jack::JackEngine* engine, Jack::JackSynchro** table, const JSList* params)
 144 {
 145         jack_nframes_t sample_rate = 48000;
 146         jack_nframes_t period_size = 1024;
 147         unsigned int capture_ports = 2;
 148         unsigned int playback_ports = 2;
 149         const JSList * node;
 150         const jack_driver_param_t * param;
 151
 152         for (node = params; node; node = jack_slist_next (node)) {
 153                 param = (const jack_driver_param_t *) node->data;
 154
 155                 switch (param->character) {
 156
 157                 case 'C':
 158                   capture_ports = param->value.ui;
 159                   break;
 160
 161                 case 'P':
 162                   playback_ports = param->value.ui;
 163                   break;
 164
 165                 case 'r':
 166                   sample_rate = param->value.ui;
 167                   break;
 168
 169                 case 'p':
 170                   period_size = param->value.ui;
 171                   break;
 172
 173                 }
 174         }
 175         Jack::JackDriverClientInterface* driver = new Jack::JackLoopbackDriver("loopback", engine, table);
 176         if (driver->Open(period_size, sample_rate, 1, 1, capture_ports, playback_ports, "loopback") == 0) {
 177                 return driver;
 178         } else {
 179                 delete driver;
 180                 return NULL;
 181         }
 182 }
 183
 184 #ifdef __cplusplus
 185 }
 186 #endif
 187 */
 188