void glob_audio_setapi(void *dummy, t_floatarg f)
{
int newapi = f;
if (newapi)
{
if (newapi == sys_audioapi)
{
if (!audio_isopen() && audio_shouldkeepopen())
sys_reopen_audio();
}
else
{
sys_close_audio();
sys_audioapi = newapi;
/* bash device params back to default */
audio_naudioindev = audio_naudiooutdev = 1;
audio_audioindev[0] = audio_audiooutdev[0] = DEFAULTAUDIODEV;
audio_audiochindev[0] = audio_audiochoutdev[0] = SYS_DEFAULTCH;
sys_reopen_audio();
}
glob_audio_properties(0, 0);
}
else if (audio_isopen())
{
sys_close_audio();
}
}
static void
jack_shutdown (void *arg)
{
verbose(1, "JACK-server shut down");
sys_close_audio();
jack_client = NULL;
}
/* start or stop the audio hardware */
void sys_set_audio_state(int onoff)
{
if (onoff) /* start */
{
if (!audio_isopen())
sys_reopen_audio();
}
else
{
if (audio_isopen())
sys_close_audio();
}
}
void glob_audio_dialog(t_pd *dummy, t_symbol *s, int argc, t_atom *argv)
{
int naudioindev, audioindev[MAXAUDIOINDEV], chindev[MAXAUDIOINDEV];
int naudiooutdev, audiooutdev[MAXAUDIOOUTDEV], choutdev[MAXAUDIOOUTDEV];
int rate, advance, audioon, i, nindev, noutdev;
int audioindev1, audioinchan1, audiooutdev1, audiooutchan1;
int newaudioindev[4], newaudioinchan[4],
newaudiooutdev[4], newaudiooutchan[4];
/* the new values the dialog came back with: */
int newrate = atom_getintarg(16, argc, argv);
int newadvance = atom_getintarg(17, argc, argv);
int statewas;
for (i = 0; i < 4; i++)
{
newaudioindev[i] = atom_getintarg(i, argc, argv);
newaudioinchan[i] = atom_getintarg(i+4, argc, argv);
newaudiooutdev[i] = atom_getintarg(i+8, argc, argv);
newaudiooutchan[i] = atom_getintarg(i+12, argc, argv);
}
for (i = 0, nindev = 0; i < 4; i++)
{
if (newaudioinchan[i] > 0)
{
newaudioindev[nindev] = newaudioindev[i];
newaudioinchan[nindev] = newaudioinchan[i];
/* post("in %d %d %d", nindev,
newaudioindev[nindev] , newaudioinchan[nindev]); */
nindev++;
}
}
for (i = 0, noutdev = 0; i < 4; i++)
{
if (newaudiooutchan[i] > 0)
{
newaudiooutdev[noutdev] = newaudiooutdev[i];
newaudiooutchan[noutdev] = newaudiooutchan[i];
/* post("out %d %d %d", noutdev,
newaudiooutdev[noutdev] , newaudioinchan[noutdev]); */
noutdev++;
}
}
sys_close_audio();
sys_open_audio(nindev, newaudioindev, nindev, newaudioinchan,
noutdev, newaudiooutdev, noutdev, newaudiooutchan,
newrate, newadvance, 1);
}
int m_mainloop(void)
{
while (sys_quit != SYS_QUIT_QUIT)
{
if (sched_useaudio == SCHED_AUDIO_CALLBACK)
m_callbackscheduler();
else m_pollingscheduler();
if (sys_quit == SYS_QUIT_RESTART)
{
sys_quit = 0;
sys_close_audio();
sys_reopen_audio();
}
}
return (0);
}
/* start or stop the audio hardware */
void sys_set_audio_state(int onoff)
{
if (onoff) /* start */
{
if (!audio_isopen())
sys_reopen_audio();
}
else
{
if (audio_isopen())
{
sys_close_audio();
sched_set_using_dacs(0);
}
}
audio_state = onoff;
}
void sys_set_audio_settings_reopen(int naudioindev, int *audioindev, int nchindev,
int *chindev, int naudiooutdev, int *audiooutdev, int nchoutdev,
int *choutdev, int rate, int advance, int callback, int newblocksize)
{
if (callback < 0)
callback = 0;
if (newblocksize != (1<<ilog2(newblocksize)) ||
newblocksize < DEFDACBLKSIZE || newblocksize > 2048)
newblocksize = DEFDACBLKSIZE;
if (!audio_callback_is_open && !callback)
sys_close_audio();
sys_set_audio_settings(naudioindev, audioindev, nchindev, chindev,
naudiooutdev, audiooutdev, nchoutdev, choutdev,
rate, advance, (callback >= 0 ? callback : 0), newblocksize);
if (!audio_callback_is_open && !callback)
sys_reopen_audio();
else sched_reopenmeplease();
}
static void audiosettings_setdriver(t_audiosettings *x, t_symbol*s, int argc, t_atom*argv) {
int id=-1;
s=gensym("<unknown>"); /* just re-use the argument, which is not needed anyhow */
switch(argc) {
case 0:
audiosettings_listdrivers(x);
return;
case 1:
if(A_FLOAT==argv->a_type) {
s=as_getdrivername(atom_getint(argv));
break;
} else if (A_SYMBOL==argv->a_type) {
s=atom_getsymbol(argv);
break;
}
}
id=as_getdriverid(s);
if(id<0) {
pd_error(x, "invalid driver '%s'", s->s_name);
return;
}
verbose(1, "setting driver '%s' (=%d)", s->s_name, id);
#ifdef HAVE_SYS_CLOSE_AUDIO
sys_close_audio();
sys_set_audio_api(id);
sys_reopen_audio();
#else
if (s_pdsym->s_thing) {
t_atom ap[1];
SETFLOAT(ap, id);
typedmess(s_pdsym->s_thing,
gensym("audio-setapi"),
1,
ap);
}
#endif
}
/* debugging */
void glob_foo(void *dummy, t_symbol *s, int argc, t_atom *argv)
{
t_symbol *arg = atom_getsymbolarg(0, argc, argv);
#ifdef ROCKBOX
(void) dummy;
(void) s;
#endif
if (arg == gensym("restart"))
{
int naudioindev, audioindev[MAXAUDIOINDEV], chindev[MAXAUDIOINDEV];
int naudiooutdev, audiooutdev[MAXAUDIOOUTDEV], choutdev[MAXAUDIOOUTDEV];
int rate, advance;
sys_get_audio_params(&naudioindev, audioindev, chindev,
&naudiooutdev, audiooutdev, choutdev, &rate, &advance);
sys_close_audio();
sys_open_audio(naudioindev, audioindev, naudioindev, chindev,
naudiooutdev, audiooutdev, naudiooutdev, choutdev, rate, advance,
1);
}
#ifdef USEAPI_ALSA
else if (arg == gensym("alsawrite"))
{
int n = atom_getintarg(1, argc, argv);
alsa_putzeros(n);
}
else if (arg == gensym("alsaread"))
{
int n = atom_getintarg(1, argc, argv);
alsa_getzeros(n);
}
else if (arg == gensym("print"))
{
alsa_printstate();
}
#endif
}
static void m_pollingscheduler( void)
{
int idlecount = 0;
sys_time_per_dsp_tick = (TIMEUNITPERSEC) *
((double)sys_schedblocksize) / sys_dacsr;
#ifdef THREAD_LOCKING
sys_lock();
#endif
sys_clearhist();
if (sys_sleepgrain < 100)
sys_sleepgrain = sys_schedadvance/4;
if (sys_sleepgrain < 100)
sys_sleepgrain = 100;
else if (sys_sleepgrain > 5000)
sys_sleepgrain = 5000;
sys_initmidiqueue();
while (!sys_quit)
{
int didsomething = 0;
int timeforward;
sys_addhist(0);
waitfortick:
if (sched_useaudio != SCHED_AUDIO_NONE)
{
#ifdef THREAD_LOCKING
/* T.Grill - send_dacs may sleep ->
unlock thread lock make that time available
- could messaging do any harm while sys_send_dacs is running?
*/
sys_unlock();
#endif
timeforward = sys_send_dacs();
#ifdef THREAD_LOCKING
/* T.Grill - done */
sys_unlock();
#endif
/* if dacs remain "idle" for 1 sec, they're hung up. */
if (timeforward != 0)
idlecount = 0;
else
{
idlecount++;
if (!(idlecount & 31))
{
static double idletime;
if (sched_useaudio != SCHED_AUDIO_POLL)
{
bug("m_pollingscheduler\n");
return;
}
/* on 32nd idle, start a clock watch; every
32 ensuing idles, check it */
if (idlecount == 32)
idletime = sys_getrealtime();
else if (sys_getrealtime() - idletime > 1.)
{
post("audio I/O stuck... closing audio\n");
sys_close_audio();
sched_set_using_audio(SCHED_AUDIO_NONE);
goto waitfortick;
}
}
}
}
else
{
if (1000. * (sys_getrealtime() - sched_referencerealtime)
> clock_gettimesince(sched_referencelogicaltime))
timeforward = SENDDACS_YES;
else timeforward = SENDDACS_NO;
}
sys_setmiditimediff(0, 1e-6 * sys_schedadvance);
sys_addhist(1);
if (timeforward != SENDDACS_NO)
sched_tick(sys_time + sys_time_per_dsp_tick);
if (timeforward == SENDDACS_YES)
didsomething = 1;
sys_addhist(2);
sys_pollmidiqueue();
if (sys_pollgui())
{
if (!didsomething)
sched_didpoll++;
didsomething = 1;
}
sys_addhist(3);
/* test for idle; if so, do graphics updates. */
if (!didsomething)
{
sched_pollformeters();
sys_reportidle();
#ifdef THREAD_LOCKING
sys_unlock(); /* unlock while we idle */
#endif
/* call externally installed idle function if any. */
if (!sys_idlehook || !sys_idlehook())
{
/* if even that had nothing to do, sleep. */
if (timeforward != SENDDACS_SLEPT)
sys_microsleep(sys_sleepgrain);
}
#ifdef THREAD_LOCKING
sys_lock();
#endif
sys_addhist(5);
sched_didnothing++;
}
}
#ifdef THREAD_LOCKING
sys_unlock();
#endif
}
