Jack2  1.9.10
JackAlsaDriver.cpp
00001 /*
00002 Copyright (C) 2001 Paul Davis
00003 Copyright (C) 2004 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 #define __STDC_FORMAT_MACROS   // For inttypes.h to work in C++
00022 
00023 #include <iostream>
00024 #include <math.h>
00025 #include <stdio.h>
00026 #include <memory.h>
00027 #include <unistd.h>
00028 #include <stdlib.h>
00029 #include <errno.h>
00030 #include <stdarg.h>
00031 #include <signal.h>
00032 #include <sys/types.h>
00033 #include <sys/time.h>
00034 #include <string.h>
00035 
00036 #include "JackAlsaDriver.h"
00037 #include "JackEngineControl.h"
00038 #include "JackClientControl.h"
00039 #include "JackPort.h"
00040 #include "JackGraphManager.h"
00041 #include "JackLockedEngine.h"
00042 #ifdef __ANDROID__
00043 #include "JackAndroidThread.h"
00044 #else
00045 #include "JackPosixThread.h"
00046 #endif
00047 #include "JackCompilerDeps.h"
00048 #include "JackServerGlobals.h"
00049 
00050 static struct jack_constraint_enum_str_descriptor midi_constraint_descr_array[] =
00051 {
00052     { "none", "no MIDI driver" },
00053     { "seq", "ALSA Sequencer driver" },
00054     { "raw", "ALSA RawMIDI driver" },
00055     { 0 }
00056 };
00057 
00058 static struct jack_constraint_enum_char_descriptor dither_constraint_descr_array[] =
00059 {
00060     { 'n', "none" },
00061     { 'r', "rectangular" },
00062     { 's', "shaped" },
00063     { 't', "triangular" },
00064     { 0 }
00065 };
00066 
00067 namespace Jack
00068 {
00069 
00070 int JackAlsaDriver::SetBufferSize(jack_nframes_t buffer_size)
00071 {
00072     jack_log("JackAlsaDriver::SetBufferSize %ld", buffer_size);
00073     int res = alsa_driver_reset_parameters((alsa_driver_t *)fDriver, buffer_size,
00074                                            ((alsa_driver_t *)fDriver)->user_nperiods,
00075                                            ((alsa_driver_t *)fDriver)->frame_rate);
00076 
00077     if (res == 0) { // update fEngineControl and fGraphManager
00078         JackAudioDriver::SetBufferSize(buffer_size);  // Generic change, never fails
00079         // ALSA specific
00080         UpdateLatencies();
00081     } else {
00082         // Restore old values
00083         alsa_driver_reset_parameters((alsa_driver_t *)fDriver, fEngineControl->fBufferSize,
00084                                      ((alsa_driver_t *)fDriver)->user_nperiods,
00085                                      ((alsa_driver_t *)fDriver)->frame_rate);
00086     }
00087 
00088     return res;
00089 }
00090 
00091 void JackAlsaDriver::UpdateLatencies()
00092 {
00093     jack_latency_range_t range;
00094     alsa_driver_t* alsa_driver = (alsa_driver_t*)fDriver;
00095 
00096     for (int i = 0; i < fCaptureChannels; i++) {
00097         range.min = range.max = alsa_driver->frames_per_cycle + alsa_driver->capture_frame_latency;
00098         fGraphManager->GetPort(fCapturePortList[i])->SetLatencyRange(JackCaptureLatency, &range);
00099     }
00100 
00101     for (int i = 0; i < fPlaybackChannels; i++) {
00102         // Add one buffer more latency if "async" mode is used...
00103         range.min = range.max = (alsa_driver->frames_per_cycle * (alsa_driver->user_nperiods - 1)) +
00104                          ((fEngineControl->fSyncMode) ? 0 : fEngineControl->fBufferSize) + alsa_driver->playback_frame_latency;
00105         fGraphManager->GetPort(fPlaybackPortList[i])->SetLatencyRange(JackPlaybackLatency, &range);
00106         // Monitor port
00107         if (fWithMonitorPorts) {
00108             range.min = range.max = alsa_driver->frames_per_cycle;
00109             fGraphManager->GetPort(fMonitorPortList[i])->SetLatencyRange(JackCaptureLatency, &range);
00110         }
00111     }
00112 }
00113 
00114 int JackAlsaDriver::Attach()
00115 {
00116     JackPort* port;
00117     jack_port_id_t port_index;
00118     unsigned long port_flags = (unsigned long)CaptureDriverFlags;
00119     char name[REAL_JACK_PORT_NAME_SIZE];
00120     char alias[REAL_JACK_PORT_NAME_SIZE];
00121 
00122     assert(fCaptureChannels < DRIVER_PORT_NUM);
00123     assert(fPlaybackChannels < DRIVER_PORT_NUM);
00124 
00125     alsa_driver_t* alsa_driver = (alsa_driver_t*)fDriver;
00126 
00127     if (alsa_driver->has_hw_monitoring)
00128         port_flags |= JackPortCanMonitor;
00129 
00130     // ALSA driver may have changed the values
00131     JackAudioDriver::SetBufferSize(alsa_driver->frames_per_cycle);
00132     JackAudioDriver::SetSampleRate(alsa_driver->frame_rate);
00133 
00134     jack_log("JackAlsaDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
00135 
00136     for (int i = 0; i < fCaptureChannels; i++) {
00137         snprintf(alias, sizeof(alias), "%s:%s:out%d", fAliasName, fCaptureDriverName, i + 1);
00138         snprintf(name, sizeof(name), "%s:capture_%d", fClientControl.fName, i + 1);
00139         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize, &port_index) < 0) {
00140             jack_error("driver: cannot register port for %s", name);
00141             return -1;
00142         }
00143         port = fGraphManager->GetPort(port_index);
00144         port->SetAlias(alias);
00145         fCapturePortList[i] = port_index;
00146         jack_log("JackAlsaDriver::Attach fCapturePortList[i] %ld ", port_index);
00147     }
00148 
00149     port_flags = (unsigned long)PlaybackDriverFlags;
00150 
00151     for (int i = 0; i < fPlaybackChannels; i++) {
00152         snprintf(alias, sizeof(alias), "%s:%s:in%d", fAliasName, fPlaybackDriverName, i + 1);
00153         snprintf(name, sizeof(name), "%s:playback_%d", fClientControl.fName, i + 1);
00154         if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, (JackPortFlags)port_flags, fEngineControl->fBufferSize, &port_index) < 0) {
00155             jack_error("driver: cannot register port for %s", name);
00156             return -1;
00157         }
00158         port = fGraphManager->GetPort(port_index);
00159         port->SetAlias(alias);
00160         fPlaybackPortList[i] = port_index;
00161         jack_log("JackAlsaDriver::Attach fPlaybackPortList[i] %ld ", port_index);
00162 
00163         // Monitor ports
00164         if (fWithMonitorPorts) {
00165             jack_log("Create monitor port");
00166             snprintf(name, sizeof(name), "%s:monitor_%d", fClientControl.fName, i + 1);
00167             if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
00168                 jack_error("ALSA: cannot register monitor port for %s", name);
00169             } else {
00170                 fMonitorPortList[i] = port_index;
00171             }
00172         }
00173     }
00174 
00175     UpdateLatencies();
00176 
00177     if (alsa_driver->midi) {
00178         int err = (alsa_driver->midi->attach)(alsa_driver->midi);
00179         if (err)
00180             jack_error ("ALSA: cannot attach MIDI: %d", err);
00181     }
00182 
00183     return 0;
00184 }
00185 
00186 int JackAlsaDriver::Detach()
00187 {
00188     alsa_driver_t* alsa_driver = (alsa_driver_t*)fDriver;
00189     if (alsa_driver->midi)
00190         (alsa_driver->midi->detach)(alsa_driver->midi);
00191 
00192     return JackAudioDriver::Detach();
00193 }
00194 
00195 extern "C" char* get_control_device_name(const char * device_name)
00196 {
00197     char * ctl_name;
00198     const char * comma;
00199 
00200     /* the user wants a hw or plughw device, the ctl name
00201      * should be hw:x where x is the card identification.
00202      * We skip the subdevice suffix that starts with comma */
00203 
00204     if (strncasecmp(device_name, "plughw:", 7) == 0) {
00205         /* skip the "plug" prefix" */
00206         device_name += 4;
00207     }
00208 
00209     comma = strchr(device_name, ',');
00210     if (comma == NULL) {
00211         ctl_name = strdup(device_name);
00212         if (ctl_name == NULL) {
00213             jack_error("strdup(\"%s\") failed.", device_name);
00214         }
00215     } else {
00216         ctl_name = strndup(device_name, comma - device_name);
00217         if (ctl_name == NULL) {
00218             jack_error("strndup(\"%s\", %u) failed.", device_name, (unsigned int)(comma - device_name));
00219         }
00220     }
00221 
00222     return ctl_name;
00223 }
00224 
00225 static int card_to_num(const char* device)
00226 {
00227     int err;
00228     char* ctl_name;
00229     snd_ctl_card_info_t *card_info;
00230     snd_ctl_t* ctl_handle;
00231     int i = -1;
00232 
00233     snd_ctl_card_info_alloca (&card_info);
00234 
00235     ctl_name = get_control_device_name(device);
00236     if (ctl_name == NULL) {
00237         jack_error("get_control_device_name() failed.");
00238         goto fail;
00239     }
00240 
00241     if ((err = snd_ctl_open (&ctl_handle, ctl_name, 0)) < 0) {
00242         jack_error ("control open \"%s\" (%s)", ctl_name,
00243                     snd_strerror(err));
00244         goto free;
00245     }
00246 
00247     if ((err = snd_ctl_card_info(ctl_handle, card_info)) < 0) {
00248         jack_error ("control hardware info \"%s\" (%s)",
00249                     device, snd_strerror (err));
00250         goto close;
00251     }
00252 
00253     i = snd_ctl_card_info_get_card(card_info);
00254 
00255 close:
00256     snd_ctl_close(ctl_handle);
00257 
00258 free:
00259     free(ctl_name);
00260 
00261 fail:
00262     return i;
00263 }
00264 
00265 int JackAlsaDriver::Open(jack_nframes_t nframes,
00266                          jack_nframes_t user_nperiods,
00267                          jack_nframes_t samplerate,
00268                          bool hw_monitoring,
00269                          bool hw_metering,
00270                          bool capturing,
00271                          bool playing,
00272                          DitherAlgorithm dither,
00273                          bool soft_mode,
00274                          bool monitor,
00275                          int inchannels,
00276                          int outchannels,
00277                          bool shorts_first,
00278                          const char* capture_driver_name,
00279                          const char* playback_driver_name,
00280                          jack_nframes_t capture_latency,
00281                          jack_nframes_t playback_latency,
00282                          const char* midi_driver_name)
00283 {
00284     // Generic JackAudioDriver Open
00285     if (JackAudioDriver::Open(nframes, samplerate, capturing, playing,
00286                               inchannels, outchannels, monitor, capture_driver_name, playback_driver_name,
00287                               capture_latency, playback_latency) != 0) {
00288         return -1;
00289     }
00290 
00291     alsa_midi_t *midi = 0;
00292 #ifndef __ANDROID__
00293     if (strcmp(midi_driver_name, "seq") == 0)
00294         midi = alsa_seqmidi_new((jack_client_t*)this, 0);
00295     else if (strcmp(midi_driver_name, "raw") == 0)
00296         midi = alsa_rawmidi_new((jack_client_t*)this);
00297 #endif
00298 
00299     if (JackServerGlobals::on_device_acquire != NULL) {
00300         int capture_card = card_to_num(capture_driver_name);
00301         int playback_card = card_to_num(playback_driver_name);
00302         char audio_name[32];
00303 
00304         if (capture_card >= 0) {
00305             snprintf(audio_name, sizeof(audio_name), "Audio%d", capture_card);
00306             if (!JackServerGlobals::on_device_acquire(audio_name)) {
00307                 jack_error("Audio device %s cannot be acquired...", capture_driver_name);
00308                 return -1;
00309             }
00310         }
00311 
00312         if (playback_card >= 0 && playback_card != capture_card) {
00313             snprintf(audio_name, sizeof(audio_name), "Audio%d", playback_card);
00314             if (!JackServerGlobals::on_device_acquire(audio_name)) {
00315                 jack_error("Audio device %s cannot be acquired...", playback_driver_name);
00316                 if (capture_card >= 0) {
00317                     snprintf(audio_name, sizeof(audio_name), "Audio%d", capture_card);
00318                     JackServerGlobals::on_device_release(audio_name);
00319                 }
00320                 return -1;
00321             }
00322         }
00323     }
00324 
00325     fDriver = alsa_driver_new ((char*)"alsa_pcm", (char*)playback_driver_name, (char*)capture_driver_name,
00326                                NULL,
00327                                nframes,
00328                                user_nperiods,
00329                                samplerate,
00330                                hw_monitoring,
00331                                hw_metering,
00332                                capturing,
00333                                playing,
00334                                dither,
00335                                soft_mode,
00336                                monitor,
00337                                inchannels,
00338                                outchannels,
00339                                shorts_first,
00340                                capture_latency,
00341                                playback_latency,
00342                                midi);
00343     if (fDriver) {
00344         // ALSA driver may have changed the in/out values
00345         fCaptureChannels = ((alsa_driver_t *)fDriver)->capture_nchannels;
00346         fPlaybackChannels = ((alsa_driver_t *)fDriver)->playback_nchannels;
00347         return 0;
00348     } else {
00349         JackAudioDriver::Close();
00350         return -1;
00351     }
00352 }
00353 
00354 int JackAlsaDriver::Close()
00355 {
00356     // Generic audio driver close
00357     int res = JackAudioDriver::Close();
00358 
00359     alsa_driver_delete((alsa_driver_t*)fDriver);
00360 
00361     if (JackServerGlobals::on_device_release != NULL)
00362     {
00363         char audio_name[32];
00364         int capture_card = card_to_num(fCaptureDriverName);
00365         if (capture_card >= 0) {
00366             snprintf(audio_name, sizeof(audio_name), "Audio%d", capture_card);
00367             JackServerGlobals::on_device_release(audio_name);
00368         }
00369 
00370         int playback_card = card_to_num(fPlaybackDriverName);
00371         if (playback_card >= 0 && playback_card != capture_card) {
00372             snprintf(audio_name, sizeof(audio_name), "Audio%d", playback_card);
00373             JackServerGlobals::on_device_release(audio_name);
00374         }
00375     }
00376 
00377     return res;
00378 }
00379 
00380 int JackAlsaDriver::Start()
00381 {
00382     int res = JackAudioDriver::Start();
00383     if (res >= 0) {
00384         res = alsa_driver_start((alsa_driver_t *)fDriver);
00385         if (res < 0) {
00386             JackAudioDriver::Stop();
00387         }
00388     }
00389     return res;
00390 }
00391 
00392 int JackAlsaDriver::Stop()
00393 {
00394     int res = alsa_driver_stop((alsa_driver_t *)fDriver);
00395     if (JackAudioDriver::Stop() < 0) {
00396         res = -1;
00397     }
00398     return res;
00399 }
00400 
00401 int JackAlsaDriver::Read()
00402 {
00403     /* Taken from alsa_driver_run_cycle */
00404     int wait_status;
00405     jack_nframes_t nframes;
00406     fDelayedUsecs = 0.f;
00407 
00408 retry:
00409 
00410     nframes = alsa_driver_wait((alsa_driver_t *)fDriver, -1, &wait_status, &fDelayedUsecs);
00411 
00412     if (wait_status < 0)
00413         return -1;              /* driver failed */
00414 
00415     if (nframes == 0) {
00416         /* we detected an xrun and restarted: notify
00417          * clients about the delay.
00418          */
00419         jack_log("ALSA XRun wait_status = %d", wait_status);
00420         NotifyXRun(fBeginDateUst, fDelayedUsecs);
00421         goto retry; /* recoverable error*/
00422     }
00423 
00424     if (nframes != fEngineControl->fBufferSize)
00425         jack_log("JackAlsaDriver::Read warning fBufferSize = %ld nframes = %ld", fEngineControl->fBufferSize, nframes);
00426 
00427     // Has to be done before read
00428     JackDriver::CycleIncTime();
00429 
00430     return alsa_driver_read((alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
00431 }
00432 
00433 int JackAlsaDriver::Write()
00434 {
00435     return alsa_driver_write((alsa_driver_t *)fDriver, fEngineControl->fBufferSize);
00436 }
00437 
00438 void JackAlsaDriver::ReadInputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
00439 {
00440     for (int chn = 0; chn < fCaptureChannels; chn++) {
00441         if (fGraphManager->GetConnectionsNum(fCapturePortList[chn]) > 0) {
00442             jack_default_audio_sample_t* buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fCapturePortList[chn], orig_nframes);
00443             alsa_driver_read_from_channel((alsa_driver_t *)fDriver, chn, buf + nread, contiguous);
00444         }
00445     }
00446 }
00447 
00448 void JackAlsaDriver::MonitorInputAux()
00449 {
00450     for (int chn = 0; chn < fCaptureChannels; chn++) {
00451         JackPort* port = fGraphManager->GetPort(fCapturePortList[chn]);
00452         if (port->MonitoringInput()) {
00453             ((alsa_driver_t *)fDriver)->input_monitor_mask |= (1 << chn);
00454         }
00455     }
00456 }
00457 
00458 void JackAlsaDriver::ClearOutputAux()
00459 {
00460     for (int chn = 0; chn < fPlaybackChannels; chn++) {
00461         jack_default_audio_sample_t* buf =
00462             (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], fEngineControl->fBufferSize);
00463         memset(buf, 0, sizeof (jack_default_audio_sample_t) * fEngineControl->fBufferSize);
00464     }
00465 }
00466 
00467 void JackAlsaDriver::SetTimetAux(jack_time_t time)
00468 {
00469     fBeginDateUst = time;
00470 }
00471 
00472 void JackAlsaDriver::WriteOutputAux(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
00473 {
00474     for (int chn = 0; chn < fPlaybackChannels; chn++) {
00475         // Output ports
00476         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[chn]) > 0) {
00477             jack_default_audio_sample_t* buf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fPlaybackPortList[chn], orig_nframes);
00478             alsa_driver_write_to_channel(((alsa_driver_t *)fDriver), chn, buf + nwritten, contiguous);
00479             // Monitor ports
00480             if (fWithMonitorPorts && fGraphManager->GetConnectionsNum(fMonitorPortList[chn]) > 0) {
00481                 jack_default_audio_sample_t* monbuf = (jack_default_audio_sample_t*)fGraphManager->GetBuffer(fMonitorPortList[chn], orig_nframes);
00482                 memcpy(monbuf + nwritten, buf + nwritten, contiguous * sizeof(jack_default_audio_sample_t));
00483             }
00484         }
00485     }
00486 }
00487 
00488 int JackAlsaDriver::is_realtime() const
00489 {
00490     return fEngineControl->fRealTime;
00491 }
00492 
00493 int JackAlsaDriver::create_thread(pthread_t *thread, int priority, int realtime, void *(*start_routine)(void*), void *arg)
00494 {
00495 #ifdef __ANDROID__
00496     return JackAndroidThread::StartImp(thread, priority, realtime, start_routine, arg);
00497 #else
00498     return JackPosixThread::StartImp(thread, priority, realtime, start_routine, arg);
00499 #endif
00500 }
00501 
00502 jack_port_id_t JackAlsaDriver::port_register(const char *port_name, const char *port_type, unsigned long flags, unsigned long buffer_size)
00503 {
00504     jack_port_id_t port_index;
00505     int res = fEngine->PortRegister(fClientControl.fRefNum, port_name, port_type, flags, buffer_size, &port_index);
00506     return (res == 0) ? port_index : 0;
00507 }
00508 
00509 int JackAlsaDriver::port_unregister(jack_port_id_t port_index)
00510 {
00511     return fEngine->PortUnRegister(fClientControl.fRefNum, port_index);
00512 }
00513 
00514 void* JackAlsaDriver::port_get_buffer(int port, jack_nframes_t nframes)
00515 {
00516     return fGraphManager->GetBuffer(port, nframes);
00517 }
00518 
00519 int  JackAlsaDriver::port_set_alias(int port, const char* name)
00520 {
00521     return fGraphManager->GetPort(port)->SetAlias(name);
00522 }
00523 
00524 jack_nframes_t JackAlsaDriver::get_sample_rate() const
00525 {
00526     return fEngineControl->fSampleRate;
00527 }
00528 
00529 jack_nframes_t JackAlsaDriver::frame_time() const
00530 {
00531     JackTimer timer;
00532     fEngineControl->ReadFrameTime(&timer);
00533     return timer.Time2Frames(GetMicroSeconds(), fEngineControl->fBufferSize);
00534 }
00535 
00536 jack_nframes_t JackAlsaDriver::last_frame_time() const
00537 {
00538     JackTimer timer;
00539     fEngineControl->ReadFrameTime(&timer);
00540     return timer.CurFrame();
00541 }
00542 
00543 } // end of namespace
00544 
00545 
00546 #ifdef __cplusplus
00547 extern "C"
00548 {
00549 #endif
00550 
00551 static
00552 jack_driver_param_constraint_desc_t *
00553 enum_alsa_devices()
00554 {
00555     snd_ctl_t * handle;
00556     snd_ctl_card_info_t * info;
00557     snd_pcm_info_t * pcminfo_capture;
00558     snd_pcm_info_t * pcminfo_playback;
00559     int card_no = -1;
00560     jack_driver_param_value_t card_id;
00561     jack_driver_param_value_t device_id;
00562     char description[64];
00563     int device_no;
00564     bool has_capture;
00565     bool has_playback;
00566     jack_driver_param_constraint_desc_t * constraint_ptr;
00567     uint32_t array_size = 0;
00568 
00569     snd_ctl_card_info_alloca(&info);
00570     snd_pcm_info_alloca(&pcminfo_capture);
00571     snd_pcm_info_alloca(&pcminfo_playback);
00572 
00573     constraint_ptr = NULL;
00574 
00575     while(snd_card_next(&card_no) >= 0 && card_no >= 0)
00576     {
00577         snprintf(card_id.str, sizeof(card_id.str), "hw:%d", card_no);
00578 
00579         if (snd_ctl_open(&handle, card_id.str, 0) >= 0 &&
00580             snd_ctl_card_info(handle, info) >= 0)
00581         {
00582             snprintf(card_id.str, sizeof(card_id.str), "hw:%s", snd_ctl_card_info_get_id(info));
00583             if (!jack_constraint_add_enum(
00584                     &constraint_ptr,
00585                     &array_size,
00586                     &card_id,
00587                     snd_ctl_card_info_get_name(info)))
00588                 goto fail;
00589 
00590             device_no = -1;
00591 
00592             while (snd_ctl_pcm_next_device(handle, &device_no) >= 0 && device_no != -1)
00593             {
00594                 snprintf(device_id.str, sizeof(device_id.str), "%s,%d", card_id.str, device_no);
00595 
00596                 snd_pcm_info_set_device(pcminfo_capture, device_no);
00597                 snd_pcm_info_set_subdevice(pcminfo_capture, 0);
00598                 snd_pcm_info_set_stream(pcminfo_capture, SND_PCM_STREAM_CAPTURE);
00599                 has_capture = snd_ctl_pcm_info(handle, pcminfo_capture) >= 0;
00600 
00601                 snd_pcm_info_set_device(pcminfo_playback, device_no);
00602                 snd_pcm_info_set_subdevice(pcminfo_playback, 0);
00603                 snd_pcm_info_set_stream(pcminfo_playback, SND_PCM_STREAM_PLAYBACK);
00604                 has_playback = snd_ctl_pcm_info(handle, pcminfo_playback) >= 0;
00605 
00606                 if (has_capture && has_playback)
00607                 {
00608                     snprintf(description, sizeof(description),"%s (duplex)", snd_pcm_info_get_name(pcminfo_capture));
00609                 }
00610                 else if (has_capture)
00611                 {
00612                     snprintf(description, sizeof(description),"%s (capture)", snd_pcm_info_get_name(pcminfo_capture));
00613                 }
00614                 else if (has_playback)
00615                 {
00616                     snprintf(description, sizeof(description),"%s (playback)", snd_pcm_info_get_name(pcminfo_playback));
00617                 }
00618                 else
00619                 {
00620                     continue;
00621                 }
00622 
00623                 if (!jack_constraint_add_enum(
00624                         &constraint_ptr,
00625                         &array_size,
00626                         &device_id,
00627                         description))
00628                     goto fail;
00629             }
00630 
00631             snd_ctl_close(handle);
00632         }
00633     }
00634 
00635     return constraint_ptr;
00636 fail:
00637     jack_constraint_free(constraint_ptr);
00638     return NULL;
00639 }
00640 
00641 static int
00642 dither_opt (char c, DitherAlgorithm* dither)
00643 {
00644     switch (c) {
00645         case '-':
00646         case 'n':
00647             *dither = None;
00648             break;
00649 
00650         case 'r':
00651             *dither = Rectangular;
00652             break;
00653 
00654         case 's':
00655             *dither = Shaped;
00656             break;
00657 
00658         case 't':
00659             *dither = Triangular;
00660             break;
00661 
00662         default:
00663             fprintf (stderr, "ALSA driver: illegal dithering mode %c\n", c);
00664             return -1;
00665     }
00666     return 0;
00667 }
00668 
00669 SERVER_EXPORT const jack_driver_desc_t* driver_get_descriptor ()
00670 {
00671     jack_driver_desc_t * desc;
00672     jack_driver_desc_filler_t filler;
00673     jack_driver_param_value_t value;
00674 
00675     desc = jack_driver_descriptor_construct("alsa", JackDriverMaster, "Linux ALSA API based audio backend", &filler);
00676 
00677     strcpy(value.str, "hw:0");
00678 #ifdef __ANDROID__
00679     jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "ALSA device name", NULL);
00680 #else
00681     jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, enum_alsa_devices(), "ALSA device name", NULL);
00682 #endif
00683 
00684     strcpy(value.str, "none");
00685     jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamString, &value, NULL, "Provide capture ports.  Optionally set device", NULL);
00686     jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamString, &value, NULL, "Provide playback ports.  Optionally set device", NULL);
00687 
00688     value.ui = 48000U;
00689     jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);
00690 
00691     value.ui = 1024U;
00692     jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);
00693 
00694     value.ui = 2U;
00695     jack_driver_descriptor_add_parameter(desc, &filler, "nperiods", 'n', JackDriverParamUInt, &value, NULL, "Number of periods of playback latency", NULL);
00696 
00697     value.i = 0;
00698     jack_driver_descriptor_add_parameter(desc, &filler, "hwmon", 'H', JackDriverParamBool, &value, NULL, "Hardware monitoring, if available", NULL);
00699 
00700     value.i = 0;
00701     jack_driver_descriptor_add_parameter(desc, &filler, "hwmeter", 'M', JackDriverParamBool, &value, NULL, "Hardware metering, if available", NULL);
00702 
00703     value.i = 1;
00704     jack_driver_descriptor_add_parameter(desc, &filler, "duplex", 'D', JackDriverParamBool, &value, NULL, "Provide both capture and playback ports", NULL);
00705 
00706     value.i = 0;
00707     jack_driver_descriptor_add_parameter(desc, &filler, "softmode", 's', JackDriverParamBool, &value, NULL, "Soft-mode, no xrun handling", NULL);
00708 
00709     value.i = 0;
00710     jack_driver_descriptor_add_parameter(desc, &filler, "monitor", 'm', JackDriverParamBool, &value, NULL, "Provide monitor ports for the output", NULL);
00711 
00712     value.c = 'n';
00713     jack_driver_descriptor_add_parameter(
00714         desc,
00715         &filler,
00716         "dither",
00717         'z',
00718         JackDriverParamChar,
00719         &value,
00720         jack_constraint_compose_enum_char(
00721             JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
00722             dither_constraint_descr_array),
00723         "Dithering mode",
00724         NULL);
00725 
00726     value.ui = 0;
00727     jack_driver_descriptor_add_parameter(desc, &filler, "inchannels", 'i', JackDriverParamUInt, &value, NULL, "Number of capture channels (defaults to hardware max)", NULL);
00728     jack_driver_descriptor_add_parameter(desc, &filler, "outchannels", 'o', JackDriverParamUInt, &value, NULL, "Number of playback channels (defaults to hardware max)", NULL);
00729 
00730     value.i = FALSE;
00731     jack_driver_descriptor_add_parameter(desc, &filler, "shorts", 'S', JackDriverParamBool, &value, NULL, "Try 16-bit samples before 32-bit", NULL);
00732 
00733     value.ui = 0;
00734     jack_driver_descriptor_add_parameter(desc, &filler, "input-latency", 'I', JackDriverParamUInt, &value, NULL, "Extra input latency (frames)", NULL);
00735     jack_driver_descriptor_add_parameter(desc, &filler, "output-latency", 'O', JackDriverParamUInt, &value, NULL, "Extra output latency (frames)", NULL);
00736 
00737     strcpy(value.str, "none");
00738     jack_driver_descriptor_add_parameter(
00739         desc,
00740         &filler,
00741         "midi-driver",
00742         'X',
00743         JackDriverParamString,
00744         &value,
00745         jack_constraint_compose_enum_str(
00746             JACK_CONSTRAINT_FLAG_STRICT | JACK_CONSTRAINT_FLAG_FAKE_VALUE,
00747             midi_constraint_descr_array),
00748         "ALSA MIDI driver",
00749         NULL);
00750 
00751     return desc;
00752 }
00753 
00754 static Jack::JackAlsaDriver* g_alsa_driver;
00755 
00756 SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)
00757 {
00758     jack_nframes_t srate = 48000;
00759     jack_nframes_t frames_per_interrupt = 1024;
00760     unsigned long user_nperiods = 2;
00761     const char *playback_pcm_name = "hw:0";
00762     const char *capture_pcm_name = "hw:0";
00763     int hw_monitoring = FALSE;
00764     int hw_metering = FALSE;
00765     int capture = FALSE;
00766     int playback = FALSE;
00767     int soft_mode = FALSE;
00768     int monitor = FALSE;
00769     DitherAlgorithm dither = None;
00770     int user_capture_nchnls = 0;
00771     int user_playback_nchnls = 0;
00772     int shorts_first = FALSE;
00773     jack_nframes_t systemic_input_latency = 0;
00774     jack_nframes_t systemic_output_latency = 0;
00775     const JSList * node;
00776     const jack_driver_param_t * param;
00777     const char *midi_driver = "none";
00778 
00779     for (node = params; node; node = jack_slist_next (node)) {
00780         param = (const jack_driver_param_t *) node->data;
00781 
00782         switch (param->character) {
00783 
00784             case 'C':
00785                 capture = TRUE;
00786                 if (strcmp (param->value.str, "none") != 0) {
00787                     capture_pcm_name = strdup (param->value.str);
00788                     jack_log("capture device %s", capture_pcm_name);
00789                 }
00790                 break;
00791 
00792             case 'P':
00793                 playback = TRUE;
00794                 if (strcmp (param->value.str, "none") != 0) {
00795                     playback_pcm_name = strdup (param->value.str);
00796                     jack_log("playback device %s", playback_pcm_name);
00797                 }
00798                 break;
00799 
00800             case 'D':
00801                 playback = TRUE;
00802                 capture = TRUE;
00803                 break;
00804 
00805             case 'd':
00806                 if (strcmp (param->value.str, "none") != 0) {
00807                     playback_pcm_name = strdup (param->value.str);
00808                     capture_pcm_name = strdup (param->value.str);
00809                     jack_log("playback device %s", playback_pcm_name);
00810                     jack_log("capture device %s", capture_pcm_name);
00811                 }
00812                 break;
00813 
00814             case 'H':
00815                 hw_monitoring = param->value.i;
00816                 break;
00817 
00818             case 'm':
00819                 monitor = param->value.i;
00820                 break;
00821 
00822             case 'M':
00823                 hw_metering = param->value.i;
00824                 break;
00825 
00826             case 'r':
00827                 srate = param->value.ui;
00828                 jack_log("apparent rate = %d", srate);
00829                 break;
00830 
00831             case 'p':
00832                 frames_per_interrupt = param->value.ui;
00833                 jack_log("frames per period = %d", frames_per_interrupt);
00834                 break;
00835 
00836             case 'n':
00837                 user_nperiods = param->value.ui;
00838                 if (user_nperiods < 2) {    /* enforce minimum value */
00839                     user_nperiods = 2;
00840                 }
00841                 break;
00842 
00843             case 's':
00844                 soft_mode = param->value.i;
00845                 break;
00846 
00847             case 'z':
00848                 if (dither_opt (param->value.c, &dither)) {
00849                     return NULL;
00850                 }
00851                 break;
00852 
00853             case 'i':
00854                 user_capture_nchnls = param->value.ui;
00855                 break;
00856 
00857             case 'o':
00858                 user_playback_nchnls = param->value.ui;
00859                 break;
00860 
00861             case 'S':
00862                 shorts_first = param->value.i;
00863                 break;
00864 
00865             case 'I':
00866                 systemic_input_latency = param->value.ui;
00867                 break;
00868 
00869             case 'O':
00870                 systemic_output_latency = param->value.ui;
00871                 break;
00872 
00873             case 'X':
00874                 midi_driver = strdup(param->value.str);
00875                 break;
00876         }
00877     }
00878 
00879     /* duplex is the default */
00880     if (!capture && !playback) {
00881         capture = TRUE;
00882         playback = TRUE;
00883     }
00884 
00885     g_alsa_driver = new Jack::JackAlsaDriver("system", "alsa_pcm", engine, table);
00886     Jack::JackDriverClientInterface* threaded_driver = new Jack::JackThreadedDriver(g_alsa_driver);
00887     // Special open for ALSA driver...
00888     if (g_alsa_driver->Open(frames_per_interrupt, user_nperiods, srate, hw_monitoring, hw_metering, capture, playback, dither, soft_mode, monitor,
00889                           user_capture_nchnls, user_playback_nchnls, shorts_first, capture_pcm_name, playback_pcm_name,
00890                           systemic_input_latency, systemic_output_latency, midi_driver) == 0) {
00891         return threaded_driver;
00892     } else {
00893         delete threaded_driver; // Delete the decorated driver
00894         return NULL;
00895     }
00896 }
00897 
00898 // Code to be used in alsa_driver.c
00899 
00900 void ReadInput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nread)
00901 {
00902     g_alsa_driver->ReadInputAux(orig_nframes, contiguous, nread);
00903 }
00904 void MonitorInput()
00905 {
00906     g_alsa_driver->MonitorInputAux();
00907 }
00908 void ClearOutput()
00909 {
00910     g_alsa_driver->ClearOutputAux();
00911 }
00912 void WriteOutput(jack_nframes_t orig_nframes, snd_pcm_sframes_t contiguous, snd_pcm_sframes_t nwritten)
00913 {
00914     g_alsa_driver->WriteOutputAux(orig_nframes, contiguous, nwritten);
00915 }
00916 void SetTime(jack_time_t time)
00917 {
00918     g_alsa_driver->SetTimetAux(time);
00919 }
00920 
00921 int Restart()
00922 {
00923     int res;
00924     if ((res = g_alsa_driver->Stop()) == 0) {
00925         res = g_alsa_driver->Start();
00926     }
00927     return res;
00928 }
00929 
00930 #ifdef __cplusplus
00931 }
00932 #endif
00933 
00934