void sys_close_audio(void)
{
if (sys_externalschedlib)
{
return;
}
if (!audio_isopen())
return;
#ifdef USEAPI_PORTAUDIO
if (sys_audioapiopened == API_PORTAUDIO)
pa_close_audio();
else
#endif
#ifdef USEAPI_JACK
if (sys_audioapiopened == API_JACK)
jack_close_audio();
else
#endif
#ifdef USEAPI_OSS
if (sys_audioapiopened == API_OSS)
oss_close_audio();
else
#endif
#ifdef USEAPI_ALSA
if (sys_audioapiopened == API_ALSA)
alsa_close_audio();
else
#endif
#ifdef USEAPI_MMIO
if (sys_audioapiopened == API_MMIO)
mmio_close_audio();
else
#endif
#ifdef USEAPI_AUDIOUNIT
if (sys_audioapiopened == API_AUDIOUNIT)
audiounit_close_audio();
else
#endif
#ifdef USEAPI_ESD
if (sys_audioapiopened == API_ESD)
esd_close_audio();
else
#endif
#ifdef USEAPI_DUMMY
if (sys_audioapiopened == API_DUMMY)
dummy_close_audio();
else
#endif
post("sys_close_audio: unknown API %d", sys_audioapiopened);
sys_inchannels = sys_outchannels = 0;
sys_audioapiopened = -1;
sched_set_using_audio(SCHED_AUDIO_NONE);
audio_state = 0;
audio_callback_is_open = 0;
sys_vgui("set pd_whichapi 0\n");
}
int libpd_init_audio(int inChans, int outChans, int sampleRate) {
int indev[MAXAUDIOINDEV], inch[MAXAUDIOINDEV],
outdev[MAXAUDIOOUTDEV], outch[MAXAUDIOOUTDEV];
indev[0] = outdev[0] = DEFAULTAUDIODEV;
inch[0] = inChans;
outch[0] = outChans;
sys_set_audio_settings(1, indev, 1, inch,
1, outdev, 1, outch, sampleRate, -1, 1, DEFDACBLKSIZE);
sched_set_using_audio(SCHED_AUDIO_CALLBACK);
sys_reopen_audio();
return 0;
}
void Pd::setSampleRate(const int samplerate) noexcept
{
Pd& pd = Pd::get();
if(pd.m_sample_rate != samplerate)
{
int indev[MAXAUDIOINDEV], inch[MAXAUDIOINDEV],
outdev[MAXAUDIOOUTDEV], outch[MAXAUDIOOUTDEV];
indev[0] = outdev[0] = DEFAULTAUDIODEV;
inch[0] = pd.m_max_channels;
outch[0] = pd.m_max_channels;
sys_set_audio_settings(1, indev, 1, inch,
1, outdev, 1, outch, samplerate, -1, 1, DEFDACBLKSIZE);
sched_set_using_audio(SCHED_AUDIO_CALLBACK);
sys_reopen_audio();
pd.m_sample_rate = sys_getsr();
}
}
Pd::Pd() noexcept
{
signal(SIGFPE, SIG_IGN);
sys_printhook = NULL;
sys_soundin = NULL;
sys_soundout = NULL;
// are all these settings necessary?
sys_schedblocksize = DEFDACBLKSIZE;
sys_externalschedlib = 0;
sys_printtostderr = 0;
sys_usestdpath = 0;
sys_debuglevel = 1;
sys_verbose = 1;
sys_noloadbang = 0;
sys_nogui = 1;
sys_hipriority = 0;
sys_nmidiin = 0;
sys_nmidiout = 0;
sys_init_fdpoll();
#ifdef HAVE_SCHED_TICK_ARG
sys_time = 0;
#endif
pd_init();
sys_set_audio_api(API_DUMMY);
sys_searchpath = NULL;
m_sample_rate = 0;
int indev[MAXAUDIOINDEV], inch[MAXAUDIOINDEV],
outdev[MAXAUDIOOUTDEV], outch[MAXAUDIOOUTDEV];
indev[0] = outdev[0] = DEFAULTAUDIODEV;
inch[0] = m_max_channels;
outch[0] = m_max_channels;
sys_set_audio_settings(1, indev, 1, inch,
1, outdev, 1, outch, 44100, -1, 1, DEFDACBLKSIZE);
sched_set_using_audio(SCHED_AUDIO_CALLBACK);
sys_reopen_audio();
m_sample_rate = sys_getsr();
m_console.clear();
m_console.push_back({"Camomile " + getVersion()+" for Pure Data "+getPdVersion()+"\n", Post::Type::Log});
m_console_changed = true;
sys_printhook = reinterpret_cast<t_printhook>(print);
}
/* 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 cpd_init()
{
int devices = 0;
int ioputs = 2;
static char initialized = 0;
assert("Pure Data is already initialized." && !initialized);
if(!initialized)
{
cpd_mutex_init(&c_mutex);
sys_soundin = NULL;
sys_soundout = NULL;
c_current_instance = NULL;
sys_printhook = (t_printhook)(cpd_print);
signal(SIGFPE, SIG_IGN);
sys_soundin = NULL;
sys_soundout = NULL;
sys_schedblocksize = DEFDACBLKSIZE;
sys_externalschedlib = 0;
sys_printtostderr = 0;
sys_usestdpath = 0;
sys_debuglevel = 1;
sys_verbose = 4;
sys_noloadbang = 0;
sys_nogui = 1;
sys_hipriority = 0;
sys_nmidiin = 0;
sys_nmidiout = 0;
sys_init_fdpoll();
pd_init();
sys_startgui(NULL);
sys_set_audio_api(API_DUMMY);
sys_searchpath = NULL;
sys_set_audio_settings(1, &devices, 1, &ioputs, 1, &devices, 1, &ioputs, 44100, -1, 1, DEFDACBLKSIZE);
sched_set_using_audio(SCHED_AUDIO_CALLBACK);
sys_reopen_audio();
c_sample_ins = sys_soundin;
c_sample_outs = sys_soundout;
c_first_instance = pd_this;
c_sym_bng = gensym("bng");
c_sym_hsl = gensym("hsl");
c_sym_vsl = gensym("vsl");
c_sym_tgl = gensym("tgl");
c_sym_nbx = gensym("nbx");
c_sym_vradio = gensym("vradio");
c_sym_hradio = gensym("hradio");
c_sym_vu = gensym("vu");
c_sym_cnv = gensym("cnv");
c_sym_empty = gensym("empty");
bob_tilde_setup();
bonk_tilde_setup();
choice_setup();
fiddle_tilde_setup();
loop_tilde_setup();
lrshift_tilde_setup();
pique_setup();
sigmund_tilde_setup();
stdout_setup();
initialized = 1;
}
}
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
}
