JNIEXPORT void JNICALL Java_com_synthbot_jasiohost_AsioDriver_ASIODisposeBuffers
(JNIEnv *env, jclass clazz) {
free(bufferVars.bufferInfos);
free(bufferVars.callbacks);
ASIOError errorCode = ASIODisposeBuffers();
switch (errorCode) {
case ASE_OK: {
// normal operation
return;
}
case ASE_InvalidMode: {
env->ThrowNew(
env->FindClass("com/synthbot/jasiohost/AsioException"),
"No buffers to dispose of. None were ever created.");
return;
}
case ASE_NotPresent: {
env->ThrowNew(
env->FindClass("com/synthbot/jasiohost/AsioException"),
"No input or output is present.");
return;
}
default: {
env->ThrowNew(
env->FindClass("com/synthbot/jasiohost/AsioException"),
"Unknown error code.");
}
}
}
SndASIO::~SndASIO()
{
ASIOStop();
m_running = false;
ASIODisposeBuffers();
ASIOExit();
asioDrivers->removeCurrentDriver();
delete asioDrivers;
delete[] m_channelinfos;
delete[] m_outsndbuff;
delete[] m_insndbuff;
delete[] m_bufferinfos;
}
void PlayerDlg::DestroyAsio()
{
if (m_bAsioDriverLoaded)
{
if (m_bAsioInitialized)
{
if (m_bAsioBufferCreated)
{
if (m_bAsioStarted)
{
ASIOStop();
}
ASIODisposeBuffers();
}
ASIOExit();
}
asioDrivers->removeCurrentDriver();
}
}
// Main:
int main()
{
int retval = 0;
bool inited = false, buffersCreated = false, started = false;
char *error = NULL;
drv.sampleRate = 44100.0;
// Initialize FX parameters:
fx.f0_gain.init();
fx.f1_compressor.init();
// Set our own inputs:
for (int i = 0; i < icr; ++i)
{
fx.f0_gain.input.gain[i] = _mm256_set1_pd(0); // dB
fx.f1_compressor.input.threshold[i] = _mm256_set1_pd(-30); // dBFS
fx.f1_compressor.input.attack[i] = _mm256_set1_pd(1.0); // msec
fx.f1_compressor.input.release[i] = _mm256_set1_pd(80); // msec
fx.f1_compressor.input.ratio[i] = _mm256_set1_pd(0.25); // N:1
fx.f1_compressor.input.gain[i] = _mm256_set1_pd(6); // dB
}
// Calculate input-dependent values:
fx.f0_gain.recalc();
fx.f1_compressor.recalc();
// FX parameters are all set.
#ifdef NOT_LIVE
// Test mode:
#if 0
const auto t0 = mm256_if_then_else(_mm256_cmp_pd(_mm256_set1_pd(-1.0), _mm256_set1_pd(0.0), _CMP_LT_OQ), _mm256_set1_pd(0.0), _mm256_set1_pd(-1.0));
printvec_dB(t0);
printf("\n\n");
const auto p0 = mm256_if_then_else(_mm256_cmp_pd(_mm256_set1_pd(-1.0), _mm256_set1_pd(0.0), _CMP_LT_OQ), _mm256_set1_pd(0.0), _mm256_set1_pd(1.0));
printvec_dB(t0);
printf("\n\n");
const auto t1 = mm256_if_then_else(_mm256_cmp_pd(_mm256_set1_pd(0.0), _mm256_set1_pd(0.0), _CMP_LT_OQ), _mm256_set1_pd(0.0), _mm256_set1_pd(-1.0));
printvec_dB(t1);
printf("\n\n");
const auto p1 = mm256_if_then_else(_mm256_cmp_pd(_mm256_set1_pd(0.0), _mm256_set1_pd(0.0), _CMP_LT_OQ), _mm256_set1_pd(0.0), _mm256_set1_pd(1.0));
printvec_dB(t1);
printf("\n\n");
goto done;
#endif
vec8_i32 in, out;
long long c = 0LL;
for (int i = 0; i < 20; ++i)
{
for (int n = 0; n < 48; ++n, ++c)
{
double s = sin(2.0 * 3.14159265358979323846 * (double)c / drv.sampleRate);
int si = (int)(s * INT_MAX / 2);
in = _mm256_set1_epi32(si);
processEffects(in, out, 0);
}
#if 1
printf("samp: ");
printvec_samp(in);
printf("\n");
printf("input: ");
for (int n = 0; n < icr; ++n)
{
printvec_dB(fx.fi_monitor.levels[n]);
if (n < icr - 1) printf(" ");
}
printf("\n");
printf("gain: ");
for (int n = 0; n < icr; ++n)
{
printvec_dB(fx.f0_output.levels[n]);
if (n < icr - 1) printf(" ");
}
printf("\n");
printf("comp: ");
for (int n = 0; n < icr; ++n)
{
printvec_dB(fx.fo_monitor.levels[n]);
if (n < icr - 1) printf(" ");
}
printf("\n");
printf("samp: ");
printvec_samp(out);
printf("\n\n");
#endif
}
#else
// ASIO live engine mode:
if (!loadAsioDriver("UA-1000"))
{
error = "load failed.";
goto err;
}
if (ASIOInit(&drv.driver) != ASE_OK)
goto err;
inited = true;
if (ASIOGetChannels(&drv.inputChannels, &drv.outputChannels) != ASE_OK)
goto err;
printf("in: %d, out %d\n", drv.inputChannels, drv.outputChannels);
if (ASIOGetBufferSize(&drv.minSize, &drv.maxSize, &drv.preferredSize, &drv.granularity) != ASE_OK)
goto err;
printf("min buf size: %d, preferred: %d, max buf size: %d\n", drv.minSize, drv.preferredSize, drv.maxSize);
if (ASIOGetSampleRate(&drv.sampleRate) != ASE_OK)
goto err;
printf("rate: %f\n\n", drv.sampleRate);
if (ASIOOutputReady() == ASE_OK)
drv.postOutput = true;
else
drv.postOutput = false;
// fill the bufferInfos from the start without a gap
ASIOBufferInfo *info = drv.bufferInfos;
// prepare inputs (Though this is not necessarily required, no opened inputs will work, too
if (drv.inputChannels > kMaxInputChannels)
drv.inputBuffers = kMaxInputChannels;
else
drv.inputBuffers = drv.inputChannels;
for (int i = 0; i < drv.inputBuffers; i++, info++)
{
info->isInput = ASIOTrue;
info->channelNum = i;
info->buffers[0] = info->buffers[1] = 0;
}
// prepare outputs
if (drv.outputChannels > kMaxOutputChannels)
drv.outputBuffers = kMaxOutputChannels;
else
drv.outputBuffers = drv.outputChannels;
for (int i = 0; i < drv.outputBuffers; i++, info++)
{
info->isInput = ASIOFalse;
info->channelNum = i;
info->buffers[0] = info->buffers[1] = 0;
}
asioCallbacks.asioMessage = asioMessage;
asioCallbacks.bufferSwitch = bufferSwitch;
asioCallbacks.bufferSwitchTimeInfo = bufferSwitchTimeInfo;
// Create the buffers:
if (ASIOCreateBuffers(drv.bufferInfos, drv.inputBuffers + drv.outputBuffers, drv.preferredSize, &asioCallbacks) != ASE_OK)
goto err;
else
buffersCreated = true;
// now get all the buffer details, sample word length, name, word clock group and activation
for (int i = 0; i < drv.inputBuffers + drv.outputBuffers; i++)
{
drv.channelInfos[i].channel = drv.bufferInfos[i].channelNum;
drv.channelInfos[i].isInput = drv.bufferInfos[i].isInput;
if (ASIOGetChannelInfo(&drv.channelInfos[i]) != ASE_OK)
goto err;
//printf("%s[%2d].type = %d\n", drv.channelInfos[i].isInput ? "in " : "out", drv.channelInfos[i].channel, drv.channelInfos[i].type);
if (drv.channelInfos[i].type != ASIOSTInt32LSB)
{
error = "Application assumes sample types of ASIOSTInt32LSB!";
goto err;
}
}
// get the input and output latencies
// Latencies often are only valid after ASIOCreateBuffers()
// (input latency is the age of the first sample in the currently returned audio block)
// (output latency is the time the first sample in the currently returned audio block requires to get to the output)
if (ASIOGetLatencies(&drv.inputLatency, &drv.outputLatency) != ASE_OK)
goto err;
printf ("latencies: input: %d, output: %d\n", drv.inputLatency, drv.outputLatency);
// Start the engine:
if (ASIOStart() != ASE_OK)
goto err;
else
started = true;
printf("Engine started.\n\n");
const int total_time = 30;
for (int i = 0; i < total_time; ++i)
{
printf("Engine running %2d. \r", total_time - i);
Sleep(1000);
}
#endif
goto done;
err:
if (error == NULL)
error = drv.driver.errorMessage;
if (error != NULL)
fprintf(stderr, "%s\r\n", error);
retval = -1;
done:
if (started)
ASIOStop();
if (buffersCreated)
ASIODisposeBuffers();
if (inited)
ASIOExit();
return retval;
}
int main(int argc, char* argv[])
{
out_counter=0;
in_counter=0;
// load the driver, this will setup all the necessary internal data structures
if (!loadAsioDriver (ASIO_DRIVER_NAME))
printf("didn't load\n");
else
{
// initialize the driver
if (ASIOInit (&asioDriverInfo.driverInfo) == ASE_OK)
{
printf ("asioVersion: %d\n"
"driverVersion: %d\n"
"Name: %s\n"
"ErrorMessage: %s\n",
asioDriverInfo.driverInfo.asioVersion, asioDriverInfo.driverInfo.driverVersion,
asioDriverInfo.driverInfo.name, asioDriverInfo.driverInfo.errorMessage);
if (init_asio_static_data (&asioDriverInfo) == 0)
{
// ASIOControlPanel(); you might want to check wether the ASIOControlPanel() can open
// set up the asioCallback structure and create the ASIO data buffer
asioCallbacks.bufferSwitch = &bufferSwitch;
asioCallbacks.sampleRateDidChange = &sampleRateChanged;
asioCallbacks.asioMessage = &asioMessages;
asioCallbacks.bufferSwitchTimeInfo = &bufferSwitchTimeInfo;
if (create_asio_buffers (&asioDriverInfo) == ASE_OK)
{
if (ASIOStart() == ASE_OK)
{
// Now all is up and running
fprintf (stdout, "\nASIO Driver started succefully.\n\n");
while (!asioDriverInfo.stopped)
{
#if WINDOWS
Sleep(100); // goto sleep for 100 milliseconds
#elif MAC
unsigned long dummy;
Delay (6, &dummy);
#endif
fprintf (stdout, "%d ms / %d ms / %d samps", asioDriverInfo.sysRefTime, (long)(asioDriverInfo.nanoSeconds / 1000000.0), (long)asioDriverInfo.samples);
// create a more readable time code format (the quick and dirty way)
double remainder = asioDriverInfo.tcSamples;
long hours = (long)(remainder / (asioDriverInfo.sampleRate * 3600));
remainder -= hours * asioDriverInfo.sampleRate * 3600;
long minutes = (long)(remainder / (asioDriverInfo.sampleRate * 60));
remainder -= minutes * asioDriverInfo.sampleRate * 60;
long seconds = (long)(remainder / asioDriverInfo.sampleRate);
remainder -= seconds * asioDriverInfo.sampleRate;
fprintf(stdout,"/%ld/",/*std::sqrt((long double)*/(sum));
fprintf (stdout, " / TC: %2.2d:%2.2d:%2.2d:%5.5d", (long)hours, (long)minutes, (long)seconds, (long)remainder);
fprintf (stdout, " \r");
#if !MAC
fflush (stdout);
#endif
if ( kbhit() )
break;
}
ASIOStop();
}
ASIODisposeBuffers();
}
}
ASIOExit();
}
asioDrivers->removeCurrentDriver();
}
printf("\n\n\nin = %d out = %d\n",in_counter,out_counter);
return 0;
}
virtual void Close() {
boost::mutex::scoped_lock lk(mutex_buffer);
ASIOStop();
ASIODisposeBuffers();
ASIOExit();
}
