/*!
\brief Called once when the thread starts.
*/
bool JackClient::Init()
{
/*
Execute buffer_size callback.
Since StartThread uses fThread.StartSync, we are sure that buffer_size callback
is executed before StartThread returns (and then IsActive will be true).
So no RT callback can be called at the same time.
*/
jack_log("JackClient::kBufferSizeCallback buffer_size = %ld", GetEngineControl()->fBufferSize);
if (fBufferSize) {
fBufferSize(GetEngineControl()->fBufferSize, fBufferSizeArg);
}
// Init callback
InitAux();
// Setup context
if (!jack_tls_set(JackGlobals::fRealTimeThread, this)) {
jack_error("Failed to set thread realtime key");
}
// Setup RT
if (GetEngineControl()->fRealTime) {
set_threaded_log_function();
SetupRealTime();
}
return true;
}
main()
{
InitAux();
AddKonnect_Aux0(0,&VirtualBits,VirtualBitsEx);
for(;;)
{
T=WaitNextTimeSlice();
ServiceKonnectPWM();
// Fixed
// Vout = 0.1;
//Generate a 5 Hz 3V Sine Wave
Vout = 3.0f*sin(T * TWO_PI * 5.0) + 5.0;
//Generate a Saw Tooth wave
// Vout = 2 + 6.0* (5.0*T - ((int)(5.0*T)));
//Generate a 5 Hz Square wave
// Vout = (5.0*T - ((int)(5.0*T))) > 0.5 ? 8 : 2;
}
}
int JackClient::ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2)
{
int res = 0;
jack_log("JackClient::ClientNotify ref = %ld name = %s notify = %ld", refnum, name, notify);
// Done all time: redirected on subclass implementation JackLibClient and JackInternalClient
switch (notify) {
case kAddClient:
res = ClientNotifyImp(refnum, name, notify, sync, message, value1, value2);
break;
case kRemoveClient:
res = ClientNotifyImp(refnum, name, notify, sync, message, value1, value2);
break;
case kActivateClient:
jack_log("JackClient::kActivateClient name = %s ref = %ld ", name, refnum);
InitAux();
break;
}
/*
The current semantic is that notifications can only be received when the client has been activated,
although is this implementation, one could imagine calling notifications as soon as the client has be opened.
*/
if (IsActive()) {
switch (notify) {
case kAddClient:
jack_log("JackClient::kAddClient fName = %s name = %s", GetClientControl()->fName, name);
if (fClientRegistration && strcmp(GetClientControl()->fName, name) != 0) { // Don't call the callback for the registering client itself
fClientRegistration(name, 1, fClientRegistrationArg);
}
break;
case kRemoveClient:
jack_log("JackClient::kRemoveClient fName = %s name = %s", GetClientControl()->fName, name);
if (fClientRegistration && strcmp(GetClientControl()->fName, name) != 0) { // Don't call the callback for the registering client itself
fClientRegistration(name, 0, fClientRegistrationArg);
}
break;
case kBufferSizeCallback:
jack_log("JackClient::kBufferSizeCallback buffer_size = %ld", value1);
if (fBufferSize) {
res = fBufferSize(value1, fBufferSizeArg);
}
break;
case kSampleRateCallback:
jack_log("JackClient::kSampleRateCallback sample_rate = %ld", value1);
if (fSampleRate) {
res = fSampleRate(value1, fSampleRateArg);
}
break;
case kGraphOrderCallback:
jack_log("JackClient::kGraphOrderCallback");
if (fGraphOrder) {
res = fGraphOrder(fGraphOrderArg);
}
break;
case kStartFreewheelCallback:
jack_log("JackClient::kStartFreewheel");
SetupDriverSync(true);
// Drop RT only when the RT thread is actually running
if (fThread.GetStatus() == JackThread::kRunning) {
fThread.DropRealTime();
}
if (fFreewheel) {
fFreewheel(1, fFreewheelArg);
}
break;
case kStopFreewheelCallback:
jack_log("JackClient::kStopFreewheel");
SetupDriverSync(false);
if (fFreewheel) {
fFreewheel(0, fFreewheelArg);
}
// Acquire RT only when the RT thread is actually running
if (GetEngineControl()->fRealTime && fThread.GetStatus() == JackThread::kRunning) {
if (fThread.AcquireRealTime(GetEngineControl()->fClientPriority) < 0) {
jack_error("JackClient::AcquireRealTime error");
}
}
break;
case kPortRegistrationOnCallback:
jack_log("JackClient::kPortRegistrationOn port_index = %ld", value1);
if (fPortRegistration) {
fPortRegistration(value1, 1, fPortRegistrationArg);
}
break;
case kPortRegistrationOffCallback:
jack_log("JackClient::kPortRegistrationOff port_index = %ld ", value1);
if (fPortRegistration) {
fPortRegistration(value1, 0, fPortRegistrationArg);
}
break;
case kPortConnectCallback:
jack_log("JackClient::kPortConnectCallback src = %ld dst = %ld", value1, value2);
if (fPortConnect) {
fPortConnect(value1, value2, 1, fPortConnectArg);
}
break;
case kPortDisconnectCallback:
jack_log("JackClient::kPortDisconnectCallback src = %ld dst = %ld", value1, value2);
if (fPortConnect) {
fPortConnect(value1, value2, 0, fPortConnectArg);
}
break;
case kPortRenameCallback:
jack_log("JackClient::kPortRenameCallback port = %ld", value1);
if (fPortRename) {
fPortRename(value1, message, GetGraphManager()->GetPort(value1)->GetName(), fPortRenameArg);
}
break;
case kXRunCallback:
jack_log("JackClient::kXRunCallback");
if (fXrun) {
res = fXrun(fXrunArg);
}
break;
case kShutDownCallback:
jack_log("JackClient::kShutDownCallback");
ShutDown(jack_status_t(value1), message);
break;
case kSessionCallback:
jack_log("JackClient::kSessionCallback");
if (fSession) {
jack_session_event_t* event = (jack_session_event_t*)malloc( sizeof(jack_session_event_t));
char uuid_buf[JACK_UUID_SIZE];
event->type = (jack_session_event_type_t)value1;
event->session_dir = strdup(message);
event->command_line = NULL;
event->flags = (jack_session_flags_t)0;
snprintf(uuid_buf, sizeof(uuid_buf), "%d", GetClientControl()->fSessionID);
event->client_uuid = strdup(uuid_buf);
fSessionReply = kPendingSessionReply;
// Session callback may change fSessionReply by directly using jack_session_reply
fSession(event, fSessionArg);
res = fSessionReply;
}
break;
case kLatencyCallback:
res = HandleLatencyCallback(value1);
break;
}
}
return res;
}
main()
{
InitAux();
AddKonnect(0,&VirtualBits,VirtualBitsEx);
}
