/* open audio using whatever parameters were last used */
void sys_reopen_audio( void)
{
int naudioindev, audioindev[MAXAUDIOINDEV], chindev[MAXAUDIOINDEV];
int naudiooutdev, audiooutdev[MAXAUDIOOUTDEV], choutdev[MAXAUDIOOUTDEV];
int rate, advance, callback, blocksize, outcome = 0;
sys_get_audio_params(&naudioindev, audioindev, chindev,
&naudiooutdev, audiooutdev, choutdev, &rate, &advance, &callback,
&blocksize);
sys_setchsr(audio_nextinchans, audio_nextoutchans, rate);
if (!naudioindev && !naudiooutdev)
{
sched_set_using_audio(SCHED_AUDIO_NONE);
return;
}
#ifdef USEAPI_PORTAUDIO
if (sys_audioapi == API_PORTAUDIO)
{
int blksize = (audio_blocksize ? audio_blocksize : 64);
if (sys_verbose)
fprintf(stderr, "blksize %d, advance %d\n", blksize, sys_advance_samples/blksize);
outcome = pa_open_audio((naudioindev > 0 ? chindev[0] : 0),
(naudiooutdev > 0 ? choutdev[0] : 0), rate, STUFF->st_soundin,
STUFF->st_soundout, blksize, sys_advance_samples/blksize,
(naudioindev > 0 ? audioindev[0] : 0),
(naudiooutdev > 0 ? audiooutdev[0] : 0),
(callback ? sched_audio_callbackfn : 0));
}
else
#endif
#ifdef USEAPI_JACK
if (sys_audioapi == API_JACK)
outcome = jack_open_audio((naudioindev > 0 ? chindev[0] : 0),
(naudiooutdev > 0 ? choutdev[0] : 0), rate,
(callback ? sched_audio_callbackfn : 0));
else
#endif
#ifdef USEAPI_OSS
if (sys_audioapi == API_OSS)
outcome = oss_open_audio(naudioindev, audioindev, naudioindev,
chindev, naudiooutdev, audiooutdev, naudiooutdev, choutdev, rate,
audio_blocksize);
else
#endif
#ifdef USEAPI_ALSA
/* for alsa, only one device is supported; it may
be open for both input and output. */
if (sys_audioapi == API_ALSA)
outcome = alsa_open_audio(naudioindev, audioindev, naudioindev,
chindev, naudiooutdev, audiooutdev, naudiooutdev, choutdev, rate,
audio_blocksize);
else
#endif
#ifdef USEAPI_MMIO
if (sys_audioapi == API_MMIO)
outcome = mmio_open_audio(naudioindev, audioindev, naudioindev,
chindev, naudiooutdev, audiooutdev, naudiooutdev, choutdev, rate,
audio_blocksize);
else
#endif
#ifdef USEAPI_AUDIOUNIT
if (sys_audioapi == API_AUDIOUNIT)
outcome = audiounit_open_audio((naudioindev > 0 ? chindev[0] : 0),
(naudioindev > 0 ? choutdev[0] : 0), rate);
else
#endif
#ifdef USEAPI_ESD
if (sys_audioapi == API_ALSA)
outcome = esd_open_audio(naudioindev, audioindev, naudioindev,
chindev, naudiooutdev, audiooutdev, naudiooutdev, choutdev, rate);
else
#endif
#ifdef USEAPI_DUMMY
if (sys_audioapi == API_DUMMY)
outcome = dummy_open_audio(naudioindev, naudiooutdev, rate);
else
#endif
if (sys_audioapi == API_NONE)
;
else post("unknown audio API specified");
if (outcome) /* failed */
{
audio_state = 0;
sched_set_using_audio(SCHED_AUDIO_NONE);
sys_audioapiopened = -1;
audio_callback_is_open = 0;
}
else
{
/* fprintf(stderr, "started w/callback %d\n", callback); */
audio_state = 1;
sched_set_using_audio(
(callback ? SCHED_AUDIO_CALLBACK : SCHED_AUDIO_POLL));
sys_audioapiopened = sys_audioapi;
audio_callback_is_open = callback;
}
sys_vgui("set pd_whichapi %d\n", (outcome == 0 ? sys_audioapi : 0));
}
void sys_set_audio_settings(int naudioindev, int *audioindev, int nchindev,
int *chindev, int naudiooutdev, int *audiooutdev, int nchoutdev,
int *choutdev, int rate, int advance, int callback, int blocksize)
{
int i;
int defaultchannels = SYS_DEFAULTCH;
int inchans, outchans, nrealindev, nrealoutdev;
int realindev[MAXAUDIOINDEV], realoutdev[MAXAUDIOOUTDEV];
int realinchans[MAXAUDIOINDEV], realoutchans[MAXAUDIOOUTDEV];
char indevlist[MAXNDEV*DEVDESCSIZE], outdevlist[MAXNDEV*DEVDESCSIZE];
int indevs = 0, outdevs = 0, canmulti = 0, cancallback = 0;
/* initialize device-arrays */
for(i=0; i<MAXAUDIOINDEV; i++)
realindev[i] = realinchans[i] = 0;
for(i=0; i<MAXAUDIOOUTDEV; i++)
realoutdev[i] = realoutchans[i] = 0;
for(i=0; i<MAXNDEV*DEVDESCSIZE; i++)
indevlist[i] = outdevlist[i] = 0;
audio_getdevs(indevlist, &indevs, outdevlist, &outdevs, &canmulti,
&cancallback, MAXNDEV, DEVDESCSIZE);
if (rate < 1)
rate = DEFAULTSRATE;
if (advance < 0)
advance = DEFAULTADVANCE;
if (blocksize != (1 << ilog2(blocksize)) || blocksize < DEFDACBLKSIZE)
blocksize = DEFDACBLKSIZE;
audio_init();
/* Since the channel vector might be longer than the
audio device vector, or vice versa, we fill the shorter one
in to match the longer one. Also, if both are empty, we fill in
one device (the default) and two channels. */
if (naudioindev == -1)
{ /* no input audio devices specified */
if (nchindev == -1)
{
if (indevs >= 1)
{
nchindev=1;
chindev[0] = defaultchannels;
naudioindev = 1;
audioindev[0] = DEFAULTAUDIODEV;
}
else naudioindev = nchindev = 0;
}
else
{
for (i = 0; i < MAXAUDIOINDEV; i++)
audioindev[i] = i;
naudioindev = nchindev;
}
}
else
{
if (nchindev == -1)
{
nchindev = naudioindev;
for (i = 0; i < naudioindev; i++)
chindev[i] = defaultchannels;
}
else if (nchindev > naudioindev)
{
for (i = naudioindev; i < nchindev; i++)
{
if (i == 0)
audioindev[0] = DEFAULTAUDIODEV;
else audioindev[i] = audioindev[i-1] + 1;
}
naudioindev = nchindev;
}
else if (nchindev < naudioindev)
{
for (i = nchindev; i < naudioindev; i++)
{
if (i == 0)
chindev[0] = defaultchannels;
else chindev[i] = chindev[i-1];
}
naudioindev = nchindev;
}
}
if (naudiooutdev == -1)
{ /* not set */
if (nchoutdev == -1)
{
if (outdevs >= 1)
{
nchoutdev=1;
choutdev[0]=defaultchannels;
naudiooutdev=1;
audiooutdev[0] = DEFAULTAUDIODEV;
}
else nchoutdev = naudiooutdev = 0;
}
else
{
for (i = 0; i < MAXAUDIOOUTDEV; i++)
audiooutdev[i] = i;
naudiooutdev = nchoutdev;
}
}
else
{
if (nchoutdev == -1)
{
nchoutdev = naudiooutdev;
for (i = 0; i < naudiooutdev; i++)
choutdev[i] = defaultchannels;
}
else if (nchoutdev > naudiooutdev)
{
for (i = naudiooutdev; i < nchoutdev; i++)
{
if (i == 0)
audiooutdev[0] = DEFAULTAUDIODEV;
else audiooutdev[i] = audiooutdev[i-1] + 1;
}
naudiooutdev = nchoutdev;
}
else if (nchoutdev < naudiooutdev)
{
for (i = nchoutdev; i < naudiooutdev; i++)
{
if (i == 0)
choutdev[0] = defaultchannels;
else choutdev[i] = choutdev[i-1];
}
naudiooutdev = nchoutdev;
}
}
/* count total number of input and output channels */
for (i = nrealindev = inchans = 0; i < naudioindev; i++)
if (chindev[i] > 0)
{
realinchans[nrealindev] = chindev[i];
realindev[nrealindev] = audioindev[i];
inchans += chindev[i];
nrealindev++;
}
for (i = nrealoutdev = outchans = 0; i < naudiooutdev; i++)
if (choutdev[i] > 0)
{
realoutchans[nrealoutdev] = choutdev[i];
realoutdev[nrealoutdev] = audiooutdev[i];
outchans += choutdev[i];
nrealoutdev++;
}
sys_schedadvance = advance * 1000;
sys_log_error(ERR_NOTHING);
audio_nextinchans = inchans;
audio_nextoutchans = outchans;
sys_setchsr(audio_nextinchans, audio_nextoutchans, rate);
sys_save_audio_params(nrealindev, realindev, realinchans,
nrealoutdev, realoutdev, realoutchans, rate, advance, callback,
blocksize);
}
int alsamm_open_audio(int rate, int blocksize)
{
int err;
char devname[80];
char *cardname;
snd_pcm_hw_params_t* hw_params;
snd_pcm_sw_params_t* sw_params;
/* fragsize is an old concept now use periods, used to be called fragments. */
/* Be aware in ALSA periodsize can be in bytes, where buffersize is in frames,
but sometimes buffersize is in bytes and periods in frames, crazy alsa...
...we use periodsize and buffersize in frames */
int i;
short* tmp_buf;
unsigned int tmp_uint;
snd_pcm_hw_params_alloca(&hw_params);
snd_pcm_sw_params_alloca(&sw_params);
/* see add_devname */
/* first have a look which cards we can get and
set up device infos for them */
#ifdef ALSAMM_DEBUG
if(sys_verbose)
post("naudioindev=%d, nchindev=%d, naudiooutdev=%d, nchoutdev=%d,rate=%d",
naudioindev, nchindev,naudiooutdev, nchoutdev, rate);
#endif
/* init some structures */
for(i=0;i < ALSA_MAXDEV;i++){
alsa_indev[i].a_synced=alsa_outdev[i].a_synced=0;
alsa_indev[i].a_channels=alsa_outdev[i].a_channels=-1; /* query defaults */
}
alsamm_inchannels = 0;
alsamm_outchannels = 0;
/* opening alsa debug channel */
err = snd_output_stdio_attach(&alsa_stdout, stdout, 0);
if (err < 0) {
check_error(err,"attaching alsa debug Output to stdout failed");
/* return; no so bad ... and never should happe */
}
/*
Weak failure prevention:
first card found (out then in) is used as a reference for parameter,
so this set the globals and other cards hopefully don't change them
*/
alsamm_sr = rate;
/* set the asked buffer time (alsa buffertime in us)*/
alsamm_buffertime = alsamm_buffersize = 0;
if(blocksize == 0)
alsamm_buffertime = sys_schedadvance;
else
alsamm_buffersize = blocksize;
if(sys_verbose)
post("syschedadvance=%d us(%d Samples)so buffertime max should be this=%d"
"or sys_blocksize=%d (samples) to use buffersize=%d",
sys_schedadvance,sys_advance_samples,alsamm_buffertime,
blocksize,alsamm_buffersize);
alsamm_periods = 0; /* no one wants periods setting from command line ;-) */
for(i=0;i<alsa_noutdev;i++)
{
/* post("open audio out %d, of %lx, %d",i,&alsa_device[i],
alsa_outdev[i].a_handle); */
if((err = set_hwparams(alsa_outdev[i].a_handle, hw_params,
&(alsa_outdev[i].a_channels))) < 0)
{
check_error(err,"playback device hwparam_set error:");
continue;
}
if((err = set_swparams(alsa_outdev[i].a_handle, sw_params,1)) < 0){
check_error(err,"playback device swparam_set error:");
continue;
}
alsamm_outchannels += alsa_outdev[i].a_channels;
alsa_outdev[i].a_addr =
(char **) malloc(sizeof(char *) * alsa_outdev[i].a_channels);
if(alsa_outdev[i].a_addr == NULL){
check_error(errno,"playback device outaddr allocation error:");
continue;
}
memset(alsa_outdev[i].a_addr, 0, sizeof(char*) * alsa_outdev[i].a_channels);
post("playback device with %d channels and buffer_time %d us opened",
alsa_outdev[i].a_channels, alsamm_buffertime);
}
for(i=0;i<alsa_nindev;i++)
{
if(sys_verbose)
post("capture card %d:--------------------",i);
if((err = set_hwparams(alsa_indev[i].a_handle, hw_params,
&(alsa_indev[i].a_channels))) < 0)
{
check_error(err,"capture device hwparam_set error:");
continue;
}
alsamm_inchannels += alsa_indev[i].a_channels;
if((err = set_swparams(alsa_indev[i].a_handle,
sw_params,0)) < 0){
check_error(err,"capture device swparam_set error:");
continue;
}
alsa_indev[i].a_addr =
(char **) malloc (sizeof(char*) * alsa_indev[i].a_channels);
if(alsa_indev[i].a_addr == NULL){
check_error(errno,"capture device inaddr allocation error:");
continue;
}
memset(alsa_indev[i].a_addr, 0, sizeof(char*) * alsa_indev[i].a_channels);
if(sys_verbose)
post("capture device with %d channels and buffertime %d us opened\n",
alsa_indev[i].a_channels,alsamm_buffertime);
}
/* check for linked handles of input for each output*/
for(i=0; i<(alsa_noutdev < alsa_nindev ? alsa_noutdev:alsa_nindev); i++){
t_alsa_dev *ad = &alsa_outdev[i];
if (alsa_outdev[i].a_devno == alsa_indev[i].a_devno){
if ((err = snd_pcm_link (alsa_indev[i].a_handle,
alsa_outdev[i].a_handle)) == 0){
alsa_indev[i].a_synced = alsa_outdev[i].a_synced = 1;
if(sys_verbose)
post("Linking in and outs of card %d",i);
}
else
check_error(err,"could not link in and outs");
}
}
/* some globals */
sleep_time = (float) alsamm_period_size/ (float) alsamm_sr;
#ifdef ALSAMM_DEBUG
/* start ---------------------------- */
if(sys_verbose)
post("open_audio: after dacsend=%d (xruns=%d)done",dac_send,alsamm_xruns);
alsamm_xruns = dac_send = 0; /* reset debug */
/* start alsa in open or better in send_dacs once ??? we will see */
for(i=0;i<alsa_noutdev;i++)
snd_pcm_dump(alsa_outdev[i].a_handle, alsa_stdout);
for(i=0;i<alsa_nindev;i++)
snd_pcm_dump(alsa_indev[i].inhandle, alsa_stdout);
fflush(stdout);
#endif
sys_setchsr(alsamm_inchannels, alsamm_outchannels, alsamm_sr);
alsamm_start();
/* report success */
return (0);
}
int pd_extern_sched(char *flags)
{
int naudioindev, audioindev[MAXAUDIOINDEV], chindev[MAXAUDIOINDEV];
int naudiooutdev, audiooutdev[MAXAUDIOOUTDEV], choutdev[MAXAUDIOOUTDEV];
int i, j, rate, advance, callback, chin, chout, fill = 0, c, blocksize;
t_binbuf *b = binbuf_new();
sys_get_audio_params(&naudioindev, audioindev, chindev,
&naudiooutdev, audiooutdev, choutdev, &rate, &advance, &callback,
&blocksize);
chin = (naudioindev < 1 ? 0 : chindev[0]);
chout = (naudiooutdev < 1 ? 0 : choutdev[0]);
/* fprintf(stderr, "Pd plug-in scheduler called, chans %d %d, sr %d\n",
chin, chout, (int)rate); */
sys_setchsr(chin, chout, rate);
sys_audioapi = API_NONE;
while ((c = getchar()) != EOF)
{
if (c == ';')
{
int n;
t_atom *ap;
binbuf_text(b, inbuf, fill);
n = binbuf_getnatom(b);
ap = binbuf_getvec(b);
fill = 0;
if (n > 0 && ap[0].a_type == A_FLOAT)
{
/* a list -- take it as incoming signals. */
int chan, nchan = n/DEFDACBLKSIZE;
t_sample *fp;
for (i = chan = 0, fp = sys_soundin; chan < nchan; chan++)
for (j = 0; j < DEFDACBLKSIZE; j++)
*fp++ = atom_getfloat(ap++);
for (; chan < chin; chan++)
for (j = 0; j < DEFDACBLKSIZE; j++)
*fp++ = 0;
sched_tick(sys_time+sys_time_per_dsp_tick);
sys_pollgui();
#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__GNU__)
pollwatchdog();
#endif
printf(";\n");
for (i = chout*DEFDACBLKSIZE, fp = sys_soundout; i--; fp++)
{
printf("%g\n", *fp);
*fp = 0;
}
printf(";\n");
fflush(stdout);
}
else if (n > 1 && ap[0].a_type == A_SYMBOL)
{
t_pd *whom = ap[0].a_w.w_symbol->s_thing;
if (!whom)
error("%s: no such object", ap[0].a_w.w_symbol->s_name);
else if (ap[1].a_type == A_SYMBOL)
typedmess(whom, ap[1].a_w.w_symbol, n-2, ap+2);
else pd_list(whom, 0, n-1, ap+1);
}
}
else if (fill < BUFSIZE)
inbuf[fill++] = c;
else if (fill == BUFSIZE)
fprintf(stderr, "pd-extern: input buffer overflow\n");
}
return (0);
}
int pd_extern_sched(char *flags)
{
int naudioindev, audioindev[MAXAUDIOINDEV], chindev[MAXAUDIOINDEV];
int naudiooutdev, audiooutdev[MAXAUDIOOUTDEV], choutdev[MAXAUDIOOUTDEV];
int i, j, rate, advance, callback, chin, chout, fill = 0, c, blocksize,
useascii = 0;
t_binbuf *b = binbuf_new();
sys_get_audio_params(&naudioindev, audioindev, chindev,
&naudiooutdev, audiooutdev, choutdev, &rate, &advance, &callback,
&blocksize);
chin = (naudioindev < 1 ? 0 : chindev[0]);
chout = (naudiooutdev < 1 ? 0 : choutdev[0]);
if (!flags || flags[0] != 'a')
{
/* signal to stdout object to do binary by attaching an object
to an obscure symbol name */
pd_ambinary_class = class_new(gensym("pd~"), 0, 0, sizeof(t_pd),
CLASS_PD, 0);
pd_bind(&pd_ambinary_class, gensym("#pd_binary_stdio"));
/* On Windows, set stdin and out to "binary" mode */
#ifdef _WIN32
setmode(fileno(stdout),O_BINARY);
setmode(fileno(stdin),O_BINARY);
#endif
}
else
{
if (!(ascii_inbuf = getbytes(BUFSIZE)))
return (1);
useascii = 1;
}
/* fprintf(stderr, "Pd plug-in scheduler called, chans %d %d, sr %d\n",
chin, chout, (int)rate); */
sys_setchsr(chin, chout, rate);
sys_audioapi = API_NONE;
while (useascii ? readasciimessage(b) : readbinmessage(b) )
{
t_atom *ap = binbuf_getvec(b);
int n = binbuf_getnatom(b);
if (n > 0 && ap[0].a_type == A_FLOAT)
{
/* a list -- take it as incoming signals. */
int chan, nchan = n/DEFDACBLKSIZE;
t_sample *fp;
for (i = chan = 0, fp = STUFF->st_soundin; chan < nchan; chan++)
for (j = 0; j < DEFDACBLKSIZE; j++)
*fp++ = atom_getfloat(ap++);
for (; chan < chin; chan++)
for (j = 0; j < DEFDACBLKSIZE; j++)
*fp++ = 0;
sched_tick();
sys_pollgui();
#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)\
|| defined(__GNU__)
pollwatchdog();
#endif
if (useascii)
printf(";\n");
else putchar(A_SEMI);
for (i = chout*DEFDACBLKSIZE, fp = STUFF->st_soundout; i--;
fp++)
{
if (useascii)
printf("%g\n", *fp);
else pd_tilde_putfloat(*fp, stdout);
*fp = 0;
}
if (useascii)
printf(";\n");
else putchar(A_SEMI);
fflush(stdout);
}
else if (n > 1 && ap[0].a_type == A_SYMBOL)
{
t_pd *whom = ap[0].a_w.w_symbol->s_thing;
if (!whom)
error("%s: no such object", ap[0].a_w.w_symbol->s_name);
else if (ap[1].a_type == A_SYMBOL)
typedmess(whom, ap[1].a_w.w_symbol, n-2, ap+2);
else pd_list(whom, 0, n-1, ap+1);
}
}
binbuf_free(b);
return (0);
}
void sys_open_audio(int naudioindev, int *audioindev, int nchindev,
int *chindev, int naudiooutdev, int *audiooutdev, int nchoutdev,
int *choutdev, int rate, int advance, int enable)
{
#ifdef ROCKBOX
int i;
#else
int i, *ip;
#endif
int defaultchannels = SYS_DEFAULTCH;
int inchans, outchans;
if (rate < 1)
rate = SYS_DEFAULTSRATE;
#ifdef ROCKBOX
pd_audio_init();
#else
audio_init();
#endif
/* Since the channel vector might be longer than the
audio device vector, or vice versa, we fill the shorter one
in to match the longer one. Also, if both are empty, we fill in
one device (the default) and two channels. */
if (naudioindev == -1)
{ /* no input audio devices specified */
if (nchindev == -1)
{
nchindev=1;
chindev[0] = defaultchannels;
naudioindev = 1;
audioindev[0] = DEFAULTAUDIODEV;
}
else
{
for (i = 0; i < MAXAUDIOINDEV; i++)
audioindev[i] = i;
naudioindev = nchindev;
}
}
else
{
if (nchindev == -1)
{
nchindev = naudioindev;
for (i = 0; i < naudioindev; i++)
chindev[i] = defaultchannels;
}
else if (nchindev > naudioindev)
{
for (i = naudioindev; i < nchindev; i++)
{
if (i == 0)
audioindev[0] = DEFAULTAUDIODEV;
else audioindev[i] = audioindev[i-1] + 1;
}
naudioindev = nchindev;
}
else if (nchindev < naudioindev)
{
for (i = nchindev; i < naudioindev; i++)
{
if (i == 0)
chindev[0] = defaultchannels;
else chindev[i] = chindev[i-1];
}
naudioindev = nchindev;
}
}
if (naudiooutdev == -1)
{ /* not set */
if (nchoutdev == -1)
{
nchoutdev=1;
choutdev[0]=defaultchannels;
naudiooutdev=1;
audiooutdev[0] = DEFAULTAUDIODEV;
}
else
{
for (i = 0; i < MAXAUDIOOUTDEV; i++)
audiooutdev[i] = i;
naudiooutdev = nchoutdev;
}
}
else
{
if (nchoutdev == -1)
{
nchoutdev = naudiooutdev;
for (i = 0; i < naudiooutdev; i++)
choutdev[i] = defaultchannels;
}
else if (nchoutdev > naudiooutdev)
{
for (i = naudiooutdev; i < nchoutdev; i++)
{
if (i == 0)
audiooutdev[0] = DEFAULTAUDIODEV;
else audiooutdev[i] = audiooutdev[i-1] + 1;
}
naudiooutdev = nchoutdev;
}
else if (nchoutdev < naudiooutdev)
{
for (i = nchoutdev; i < naudiooutdev; i++)
{
if (i == 0)
choutdev[0] = defaultchannels;
else choutdev[i] = choutdev[i-1];
}
naudiooutdev = nchoutdev;
}
}
/* count total number of input and output channels */
for (i = inchans = 0; i < naudioindev; i++)
inchans += chindev[i];
for (i = outchans = 0; i < naudiooutdev; i++)
outchans += choutdev[i];
/* if no input or output devices seem to have been specified,
this really means just disable audio, which we now do. Meanwhile,
we can set audio input and output devices to their defaults. */
if (!inchans && !outchans)
{
enable = 0;
naudioindev = nchindev = naudiooutdev = nchoutdev = 1;
audioindev[0] = audiooutdev[0] = DEFAULTAUDIODEV;
chindev[0] = choutdev[0] = 0;
}
sys_schedadvance = advance * 1000;
sys_setchsr(inchans, outchans, rate);
sys_log_error(ERR_NOTHING);
if (enable && (inchans > 0 || outchans > 0))
{
#ifdef USEAPI_PORTAUDIO
if (sys_audioapi == API_PORTAUDIO)
{
int blksize = (sys_blocksize ? sys_blocksize : 64);
pa_open_audio(inchans, outchans, rate, sys_soundin, sys_soundout,
blksize, sys_advance_samples/blksize,
(naudiooutdev > 0 ? audioindev[0] : 0),
(naudiooutdev > 0 ? audiooutdev[0] : 0));
}
else
#endif
#ifdef USEAPI_JACK
if (sys_audioapi == API_JACK)
jack_open_audio((naudioindev > 0 ? chindev[0] : 0),
(naudiooutdev > 0 ? choutdev[0] : 0), rate);
else
#endif
#ifdef USEAPI_OSS
if (sys_audioapi == API_OSS)
oss_open_audio(naudioindev, audioindev, nchindev, chindev,
naudiooutdev, audiooutdev, nchoutdev, choutdev, rate);
else
#endif
#ifdef USEAPI_ALSA
/* for alsa, only one device is supported; it may
be open for both input and output. */
if (sys_audioapi == API_ALSA)
alsa_open_audio(naudioindev, audioindev, nchindev, chindev,
naudiooutdev, audiooutdev, nchoutdev, choutdev, rate);
else
#endif
#ifdef USEAPI_MMIO
if (sys_audioapi == API_MMIO)
mmio_open_audio(naudioindev, audioindev, nchindev, chindev,
naudiooutdev, audiooutdev, nchoutdev, choutdev, rate);
else
#endif
#ifdef USEAPI_ROCKBOX
if (sys_audioapi == API_ROCKBOX)
rockbox_open_audio(rate);
else
#endif
post("unknown audio API specified");
}
sys_save_audio_params(naudioindev, audioindev, chindev,
naudiooutdev, audiooutdev, choutdev, rate, advance);
if (sys_inchannels == 0 && sys_outchannels == 0)
enable = 0;
audio_state = enable;
#ifndef ROCKBOX
sys_vgui("set pd_whichapi %d\n", (audio_isopen() ? sys_audioapi : 0));
#endif
sched_set_using_dacs(enable);
}
