Jack2
1.9.10
|
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