JackDummyDriver.cpp

00001 /*
00002 Copyright (C) 2001 Paul Davis 
00003 Copyright (C) 2004-2006 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 "driver_interface.h"
00025 #include "JackDriverLoader.h"
00026 #include <iostream>
00027 #include <unistd.h>
00028 
00029 namespace Jack
00030 {
00031 
00032 int JackDummyDriver::Open(jack_nframes_t nframes,
00033                           jack_nframes_t samplerate,
00034                           int capturing,
00035                           int playing,
00036                           int inchannels,
00037                           int outchannels,
00038                           bool monitor,
00039                           const char* capture_driver_name,
00040                           const char* playback_driver_name,
00041                           jack_nframes_t capture_latency,
00042                           jack_nframes_t playback_latency)
00043 {
00044     int res = JackAudioDriver::Open(nframes,
00045                                     samplerate,
00046                                     capturing,
00047                                     playing,
00048                                     inchannels,
00049                                     outchannels,
00050                                     monitor,
00051                                     capture_driver_name,
00052                                     playback_driver_name,
00053                                     capture_latency,
00054                                     playback_latency);
00055     fEngineControl->fPeriod = 0;
00056     fEngineControl->fComputation = 500 * 1000;
00057     fEngineControl->fConstraint = 500 * 1000;
00058     return res;
00059 }
00060 
00061 int JackDummyDriver::Process()
00062 {
00063     fLastWaitUst = GetMicroSeconds(); // Take callback date here
00064     JackAudioDriver::Process();
00065     usleep(std::max(0L, long(fWaitTime - (GetMicroSeconds() - fLastWaitUst))));
00066     return 0;
00067 }
00068 
00069 int JackDummyDriver::SetBufferSize(jack_nframes_t buffer_size)
00070 {
00071     fEngineControl->fBufferSize = buffer_size;
00072     fEngineControl->fPeriodUsecs = jack_time_t(1000000.f / fEngineControl->fSampleRate * fEngineControl->fBufferSize); // In microsec
00073     return 0;
00074 }
00075 
00076 void JackDummyDriver::PrintState()
00077 {
00078     std::cout << "JackDummyDriver state" << std::endl;
00079 
00080     jack_port_id_t port_index;
00081 
00082     std::cout << "Input ports" << std::endl;
00083 
00084     for (int i = 0; i < fPlaybackChannels; i++) {
00085         port_index = fCapturePortList[i];
00086         JackPort* port = fGraphManager->GetPort(port_index);
00087         std::cout << port->GetName() << std::endl;
00088         if (fGraphManager->GetConnectionsNum(port_index)) {}
00089     }
00090 
00091     std::cout << "Output ports" << std::endl;
00092 
00093     for (int i = 0; i < fCaptureChannels; i++) {
00094         port_index = fPlaybackPortList[i];
00095         JackPort* port = fGraphManager->GetPort(port_index);
00096         std::cout << port->GetName() << std::endl;
00097         if (fGraphManager->GetConnectionsNum(port_index)) {}
00098     }
00099 }
00100 
00101 } // end of namespace
00102 
00103 #ifdef __cplusplus
00104 extern "C"
00105 {
00106 #endif
00107 
00108     jack_driver_desc_t * driver_get_descriptor () {
00109         jack_driver_desc_t * desc;
00110         unsigned int i;
00111 
00112         desc = (jack_driver_desc_t*)calloc (1, sizeof (jack_driver_desc_t));
00113         strcpy(desc->name, "dummy");
00114         desc->nparams = 6;
00115         desc->params = (jack_driver_param_desc_t*)calloc (desc->nparams, sizeof (jack_driver_param_desc_t));
00116 
00117         i = 0;
00118         strcpy(desc->params[i].name, "capture");
00119         desc->params[i].character = 'C';
00120         desc->params[i].type = JackDriverParamUInt;
00121         desc->params[i].value.ui = 2U;
00122         strcpy(desc->params[i].short_desc, "Number of capture ports");
00123         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00124 
00125         i++;
00126         strcpy(desc->params[i].name, "playback");
00127         desc->params[i].character = 'P';
00128         desc->params[i].type = JackDriverParamUInt;
00129         desc->params[1].value.ui = 2U;
00130         strcpy(desc->params[i].short_desc, "Number of playback ports");
00131         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00132 
00133         i++;
00134         strcpy(desc->params[i].name, "rate");
00135         desc->params[i].character = 'r';
00136         desc->params[i].type = JackDriverParamUInt;
00137         desc->params[i].value.ui = 48000U;
00138         strcpy(desc->params[i].short_desc, "Sample rate");
00139         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00140 
00141         i++;
00142         strcpy(desc->params[i].name, "monitor");
00143         desc->params[i].character = 'm';
00144         desc->params[i].type = JackDriverParamBool;
00145         desc->params[i].value.i = 0;
00146         strcpy(desc->params[i].short_desc, "Provide monitor ports for the output");
00147         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00148 
00149         i++;
00150         strcpy(desc->params[i].name, "period");
00151         desc->params[i].character = 'p';
00152         desc->params[i].type = JackDriverParamUInt;
00153         desc->params[i].value.ui = 1024U;
00154         strcpy(desc->params[i].short_desc, "Frames per period");
00155         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00156 
00157         i++;
00158         strcpy(desc->params[i].name, "wait");
00159         desc->params[i].character = 'w';
00160         desc->params[i].type = JackDriverParamUInt;
00161         desc->params[i].value.ui = 21333U;
00162         strcpy(desc->params[i].short_desc,
00163                "Number of usecs to wait between engine processes");
00164         strcpy(desc->params[i].long_desc, desc->params[i].short_desc);
00165 
00166         return desc;
00167     }
00168 
00169     Jack::JackDriverClientInterface* driver_initialize(Jack::JackEngine* engine, Jack::JackSynchro** table, const JSList* params) {
00170         jack_nframes_t sample_rate = 48000;
00171         jack_nframes_t period_size = 1024;
00172         unsigned int capture_ports = 2;
00173         unsigned int playback_ports = 2;
00174         unsigned long wait_time = 0;
00175         const JSList * node;
00176         const jack_driver_param_t * param;
00177         bool monitor = false;
00178 
00179         for (node = params; node; node = jack_slist_next (node)) {
00180             param = (const jack_driver_param_t *) node->data;
00181 
00182             switch (param->character) {
00183 
00184                 case 'C':
00185                     capture_ports = param->value.ui;
00186                     break;
00187 
00188                 case 'P':
00189                     playback_ports = param->value.ui;
00190                     break;
00191 
00192                 case 'r':
00193                     sample_rate = param->value.ui;
00194                     break;
00195 
00196                 case 'p':
00197                     period_size = param->value.ui;
00198                     break;
00199 
00200                 case 'w':
00201                     wait_time = param->value.ui;
00202                     break;
00203 
00204                 case 'm':
00205                     monitor = param->value.i;
00206                     break;
00207             }
00208         }
00209 
00210         if (wait_time == 0) // Not set
00211             wait_time = (unsigned long)((((float)period_size) / ((float)sample_rate)) * 1000000.0f);
00212 
00213         Jack::JackDriverClientInterface* driver = new Jack::JackThreadedDriver(new Jack::JackDummyDriver("dummy_pcm", engine, table, wait_time));
00214         if (driver->Open(period_size, sample_rate, 1, 1, capture_ports, playback_ports, monitor, "dummy", "dummy", 0, 0) == 0) {
00215             return driver;
00216         } else {
00217             delete driver;
00218             return NULL;
00219         }
00220     }
00221 
00222 #ifdef __cplusplus
00223 }
00224 #endif

Generated on Wed Jan 10 11:42:45 2007 for Jackdmp by  doxygen 1.4.5