Jack2 1.9.7
JackDummyDriver.cpp
00001 /*
00002 Copyright (C) 2001 Paul Davis
00003 Copyright (C) 2004-2008 Grame
00004 
00005 This program is free software; you can redistribute it and/or modify
00006 it under the terms of the GNU General Public License as published by
00007 the Free Software Foundation; either version 2 of the License, or
00008 (at your option) any later version.
00009 
00010 This program is distributed in the hope that it will be useful,
00011 but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 GNU General Public License for more details.
00014 
00015 You should have received a copy of the GNU General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00018 
00019 */
00020 
00021 #include "JackDummyDriver.h"
00022 #include "JackEngineControl.h"
00023 #include "JackGraphManager.h"
00024 #include "JackDriverLoader.h"
00025 #include "JackThreadedDriver.h"
00026 #include "JackCompilerDeps.h"
00027 #include <iostream>
00028 #include <unistd.h>
00029 
00030 namespace Jack
00031 {
00032 
00033 int JackDummyDriver::Open(jack_nframes_t buffer_size,
00034                           jack_nframes_t samplerate,
00035                           bool capturing,
00036                           bool playing,
00037                           int inchannels,
00038                           int outchannels,
00039                           bool monitor,
00040                           const char* capture_driver_name,
00041                           const char* playback_driver_name,
00042                           jack_nframes_t capture_latency,
00043                           jack_nframes_t playback_latency)
00044 {
00045     if (JackAudioDriver::Open(buffer_size,
00046                             samplerate,
00047                             capturing,
00048                             playing,
00049                             inchannels,
00050                             outchannels,
00051                             monitor,
00052                             capture_driver_name,
00053                             playback_driver_name,
00054                             capture_latency,
00055                             playback_latency) == 0) {
00056         fEngineControl->fPeriod = 0;
00057         fEngineControl->fComputation = 500 * 1000;
00058         fEngineControl->fConstraint = 500 * 1000;
00059         int buffer_size = int((fWaitTime * fEngineControl->fSampleRate) / 1000000.0f);
00060         if (buffer_size > BUFFER_SIZE_MAX) {
00061             buffer_size = BUFFER_SIZE_MAX;
00062             jack_error("Buffer size set to %d ", BUFFER_SIZE_MAX);
00063         }
00064         SetBufferSize(buffer_size);
00065         return 0;
00066     } else {
00067         return -1;
00068     }
00069 }
00070 
00071 int JackDummyDriver::Process()
00072 {
00073     JackDriver::CycleTakeBeginTime();
00074     JackAudioDriver::Process();
00075     JackSleep(std::max(0L, long(fWaitTime - (GetMicroSeconds() - fBeginDateUst))));
00076     return 0;
00077 }
00078 
00079 int JackDummyDriver::SetBufferSize(jack_nframes_t buffer_size)
00080 {
00081     JackAudioDriver::SetBufferSize(buffer_size);
00082     fWaitTime = (unsigned long)((((float)buffer_size) / ((float)fEngineControl->fSampleRate)) * 1000000.0f);
00083     return 0;
00084 }
00085 
00086 } // end of namespace
00087 
00088 #ifdef __cplusplus
00089 extern "C"
00090 {
00091 #endif
00092 
00093     SERVER_EXPORT jack_driver_desc_t * driver_get_descriptor () {
00094         jack_driver_desc_t * desc;
00095         unsigned int i;
00096 
00097         desc = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
00098         strcpy(desc->name, "dummy");                  // size MUST be less then JACK_DRIVER_NAME_MAX + 1
00099         strcpy(desc->desc, "Timer based backend");    // size MUST be less then JACK_DRIVER_PARAM_DESC + 1
00100 
00101         desc->nparams = 6;
00102         desc->params = (jack_driver_param_desc_t*)calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
00103 
00104         i = 0;
00105         strcpy(desc->params[i].name, "capture");
00106         desc->params[i].character = 'C';
00107         desc->params[i].type = JackDriverParamUInt;
00108         desc->params[i].value.ui = 2U;
00109         strcpy(desc->params[i].short_desc, "Number of capture ports");
00110         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00111 
00112         i++;
00113         strcpy(desc->params[i].name, "playback");
00114         desc->params[i].character = 'P';
00115         desc->params[i].type = JackDriverParamUInt;
00116         desc->params[1].value.ui = 2U;
00117         strcpy(desc->params[i].short_desc, "Number of playback ports");
00118         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00119 
00120         i++;
00121         strcpy(desc->params[i].name, "rate");
00122         desc->params[i].character = 'r';
00123         desc->params[i].type = JackDriverParamUInt;
00124         desc->params[i].value.ui = 48000U;
00125         strcpy(desc->params[i].short_desc, "Sample rate");
00126         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00127 
00128         i++;
00129         strcpy(desc->params[i].name, "monitor");
00130         desc->params[i].character = 'm';
00131         desc->params[i].type = JackDriverParamBool;
00132         desc->params[i].value.i = 0;
00133         strcpy(desc->params[i].short_desc, "Provide monitor ports for the output");
00134         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00135 
00136         i++;
00137         strcpy(desc->params[i].name, "period");
00138         desc->params[i].character = 'p';
00139         desc->params[i].type = JackDriverParamUInt;
00140         desc->params[i].value.ui = 1024U;
00141         strcpy(desc->params[i].short_desc, "Frames per period");
00142         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00143 
00144         i++;
00145         strcpy(desc->params[i].name, "wait");
00146         desc->params[i].character = 'w';
00147         desc->params[i].type = JackDriverParamUInt;
00148         desc->params[i].value.ui = 21333U;
00149         strcpy(desc->params[i].short_desc,
00150                "Number of usecs to wait between engine processes");
00151         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00152 
00153         return desc;
00154     }
00155 
00156     SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params) {
00157         jack_nframes_t sample_rate = 48000;
00158         jack_nframes_t period_size = 1024;
00159         unsigned int capture_ports = 2;
00160         unsigned int playback_ports = 2;
00161         unsigned long wait_time = 0;
00162         const JSList * node;
00163         const jack_driver_param_t * param;
00164         bool monitor = false;
00165 
00166         for (node = params; node; node = jack_slist_next (node)) {
00167             param = (const jack_driver_param_t *) node->data;
00168 
00169             switch (param->character) {
00170 
00171                 case 'C':
00172                     capture_ports = param->value.ui;
00173                     break;
00174 
00175                 case 'P':
00176                     playback_ports = param->value.ui;
00177                     break;
00178 
00179                 case 'r':
00180                     sample_rate = param->value.ui;
00181                     break;
00182 
00183                 case 'p':
00184                     period_size = param->value.ui;
00185                     break;
00186 
00187                 case 'w':
00188                     wait_time = param->value.ui;
00189                     break;
00190 
00191                 case 'm':
00192                     monitor = param->value.i;
00193                     break;
00194             }
00195         }
00196 
00197         if (wait_time == 0) // Not set
00198             wait_time = (unsigned long)((((float)period_size) / ((float)sample_rate)) * 1000000.0f);
00199 
00200         Jack::JackDriverClientInterface* driver = new Jack::JackThreadedDriver(new Jack::JackDummyDriver("system", "dummy_pcm", engine, table, wait_time));
00201         if (driver->Open(period_size, sample_rate, 1, 1, capture_ports, playback_ports, monitor, "dummy", "dummy", 0, 0) == 0) {
00202             return driver;
00203         } else {
00204             delete driver;
00205             return NULL;
00206         }
00207     }
00208 
00209 #ifdef __cplusplus
00210 }
00211 #endif