void CDaemon::handleClientRead()
{
QTcpSocket * socket = qobject_cast<QTcpSocket *>(sender());
while(socket->bytesAvailable() > 8)
{
QDataStream stream(socket);
quint64 size;
stream >> size;
if(socket->bytesAvailable() >= size)
{
QByteArray buffer(socket->read(size));
QDataStream bStream(buffer);
quint8 opcode;
bStream >> opcode;
switch(opcode)
{
case OPCODE_ADD:
handleAdd(bStream); break;
case OPCODE_REMOVE:
handleRemove(bStream); break;
case OPCODE_START:
handleStart(bStream); break;
case OPCODE_STOP:
handleAbort(bStream); break;
case OPCODE_QUEUE:
handleQueue(bStream); break;
default:
qWarning() << "Unhandled packet:" << quint32(opcode); break;
}
}
}
void QXmppStream::_q_socketConnected()
{
info(QString("Socket connected to %1 %2").arg(
d->socket->peerAddress().toString(),
QString::number(d->socket->peerPort())));
handleStart();
}
// Handles an incoming message for the flow graph.
// Returns TRUE if the message was handled, otherwise FALSE.
UtlBoolean MpFlowGraphBase::handleMessage(OsMsg& rMsg)
{
MpFlowGraphMsg* pMsg = (MpFlowGraphMsg*) &rMsg ;
UtlBoolean retCode;
MpResource* ptr1;
MpResource* ptr2;
int int1;
int int2;
retCode = FALSE;
ptr1 = (MpResource*) pMsg->getPtr1(); // get the parameters out of
ptr2 = (MpResource*) pMsg->getPtr2(); // the message
int1 = pMsg->getInt1();
int2 = pMsg->getInt2();
switch (pMsg->getMsg())
{
case MpFlowGraphMsg::FLOWGRAPH_ADD_LINK:
retCode = handleAddLink(ptr1, int1, ptr2, int2);
break;
case MpFlowGraphMsg::FLOWGRAPH_ADD_RESOURCE:
retCode = handleAddResource(ptr1, int1);
break;
case MpFlowGraphMsg::FLOWGRAPH_DESTROY_RESOURCES:
retCode = handleDestroyResources();
break;
case MpFlowGraphMsg::FLOWGRAPH_DISABLE:
retCode = handleDisable();
break;
case MpFlowGraphMsg::FLOWGRAPH_ENABLE:
retCode = handleEnable();
break;
case MpFlowGraphMsg::FLOWGRAPH_REMOVE_LINK:
retCode = handleRemoveLink(ptr1, int1);
break;
case MpFlowGraphMsg::FLOWGRAPH_REMOVE_RESOURCE:
retCode = handleRemoveResource(ptr1);
break;
case MpFlowGraphMsg::FLOWGRAPH_SET_SAMPLES_PER_FRAME:
retCode = handleSetSamplesPerFrame(int1);
break;
case MpFlowGraphMsg::FLOWGRAPH_SET_SAMPLES_PER_SEC:
retCode = handleSetSamplesPerSec(int1);
break;
case MpFlowGraphMsg::FLOWGRAPH_START:
retCode = handleStart();
break;
case MpFlowGraphMsg::FLOWGRAPH_STOP:
retCode = handleStop();
break;
default:
break;
}
return retCode;
}
// Handle an incoming message
// Return TRUE if the message was handled, otherwise FALSE.
UtlBoolean MpMediaTask::handleMessage(OsMsg& rMsg)
{
UtlBoolean handled;
MpFlowGraphBase* pFlowGraph;
MpMediaTaskMsg* pMsg;
if (rMsg.getMsgType() != OsMsg::MP_TASK_MSG)
return FALSE; // the method only handles MP_TASK_MSG messages
pMsg = (MpMediaTaskMsg*) &rMsg;
pFlowGraph = (MpFlowGraphBase*) pMsg->getPtr1();
handled = TRUE; // until proven otherwise, assume we'll handle the msg
switch (pMsg->getMsg())
{
case MpMediaTaskMsg::MANAGE:
{
OsEvent* event = (OsEvent*)pMsg->getPtr2();
if (!handleManage(pFlowGraph))
mHandleMsgErrs++;
if (event) event->signal(0);
break;
}
case MpMediaTaskMsg::SET_FOCUS:
if (!handleSetFocus(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::START:
if (!handleStart(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::STOP:
if (!handleStop(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::UNMANAGE:
{
OsEvent* event = (OsEvent*)pMsg->getPtr2();
if (!handleUnmanage(pFlowGraph))
mHandleMsgErrs++;
if (event) event->signal(0);
break;
}
case MpMediaTaskMsg::WAIT_FOR_SIGNAL:
if (!handleWaitForSignal(pMsg))
mHandleMsgErrs++;
break;
default:
handled = FALSE; // we didn't handle the message after all
break;
}
return handled;
}
void
ReplayConductor::handleSetReplayRate( double rate )
{
bool wasPlaying = isPlaying_;
if ( wasPlaying )
handlePause();
clock_.setReplayRate( rate );
if ( wasPlaying )
handleStart();
}
PlayerCommand* PlayerDriver::DoProcessQueue(status_t& ret)
{
PlayerCommand* ec = dequeueCommand();
printf("HelixOverWebkit [%s] [%s] [%d] ec %p, ec->command() %d\n", __FILE__, __FUNCTION__, __LINE__, ec, (ec == NULL)?-1: ec->command());
if (ec)
{
switch(ec->command())
{
case PlayerCommand::PLAYER_SET_DATA_SOURCE:
ret = handleSetDataSource(static_cast<PlayerSetDataSource*>(ec));
break;
case PlayerCommand::PLAYER_PREPARE:
ret = handlePrepare(static_cast<PlayerPrepare*>(ec));
break;
case PlayerCommand::PLAYER_START:
ret = handleStart(static_cast<PlayerStart*>(ec));
break;
case PlayerCommand::PLAYER_STOP:
ret = handleStop(static_cast<PlayerStop*>(ec));
break;
case PlayerCommand::PLAYER_PAUSE:
ret = handlePause(static_cast<PlayerPause*>(ec));
break;
case PlayerCommand::PLAYER_SEEK:
ret = handleSeek(static_cast<PlayerSeek*>(ec));
break;
case PlayerCommand::PLAYER_GET_POSITION:
ret = handleGetPosition(static_cast<PlayerGetPosition*>(ec));
break;
case PlayerCommand::PLAYER_RESET:
ret = handleReset(static_cast<PlayerReset*>(ec));
break;
case PlayerCommand::PLAYER_QUIT:
ret = handleQuit(static_cast<PlayerQuit*>(ec));
break;
default:
//cout << "Unexpected command %d" << ec->command();
break;
}
}
return ec;
}
void
ReplayConductor::handleEvents()
{
IceUtil::Mutex::Lock lock(mutex_);
// Pop all the events off the queue and deal with them.
while ( !eventQueue_.empty() )
{
Event e = eventQueue_.front();
eventQueue_.pop();
switch ( e.type() )
{
case SetReplayRate:
handleSetReplayRate(e.replayRate());
break;
case Start:
handleStart();
break;
case Pause:
handlePause();
break;
case StepForward:
handleStepForward();
break;
case StepBackward:
handleStepBackward();
break;
case FastForward:
handleFastForward(e.time());
break;
case FastForwardToEnd:
handleFastForwardToEnd();
break;
case Rewind:
handleRewind(e.time());
break;
case RewindToStartAndStop:
handleRewindToStartAndStop();
break;
default:
cout << "ERROR(replayconductor.cpp): Don't know how to handle event: " << toString(e) << endl;
}
}
}
void
ReplayConductor::handleRewind( const IceUtil::Time &deltaT )
{
bool wasPlaying = isPlaying_;
if ( wasPlaying )
handlePause();
int sec, usec;
masterFileReader_.getCursorTime( sec, usec );
IceUtil::Time tNew = orcalog::iceUtilTime( sec, usec );
tNew -= deltaT;
masterFileReader_.placeCursorAtOrAfterTime( tNew.toSeconds(),
(int)(tNew.toMicroSeconds()-tNew.toSeconds()*1e6) );
if ( wasPlaying )
handleStart();
}
void EndpointListener::monitorEvents()
{
OSS_LOG_NOTICE("EndpointListener::monitorEvents( " << _endpointName << " ) - STARTED processing events");
handleStart();
while(!_isTerminating)
{
SIPMessage::Ptr pRequest;
_eventQueue.dequeue(pRequest);
if (pRequest)
{
OSS_LOG_DEBUG(pRequest->createContextId(true) << "EndpointListener::monitorEvents( " << _endpointName << " ) - processing event " << pRequest->startLine());
onHandleEvent(pRequest);
}
else
{
OSS_LOG_DEBUG("EndpointListener::monitorEvents( " << _endpointName << " ) - dropping NULL event");
}
}
handleStop();
OSS_LOG_NOTICE("EndpointListener::monitorEvents( " << _endpointName << " ) TERMINATED");
}
void QXmppIncomingClient::onPasswordReply()
{
QXmppPasswordReply *reply = qobject_cast<QXmppPasswordReply *> (sender());
if (!reply)
return;
reply->deleteLater();
const QString jid = QString ("%1@%2").arg (d->saslServer->username(), d->domain);
switch (reply->error())
{
case QXmppPasswordReply::NoError:
d->jid = jid;
info (QString ("Authentication succeeded for '%1' from %2").arg (d->jid, d->origin()));
updateCounter ("incoming-client.auth.success");
sendPacket (QXmppSaslSuccess());
handleStart();
break;
case QXmppPasswordReply::AuthorizationError:
warning (QString ("Authentication failed for '%1' from %2").arg (jid, d->origin()));
updateCounter ("incoming-client.auth.not-authorized");
sendPacket (QXmppSaslFailure ("not-authorized"));
disconnectFromHost();
break;
case QXmppPasswordReply::TemporaryError:
warning (QString ("Temporary authentication failure for '%1' from %2").arg (jid, d->origin()));
updateCounter ("incoming-client.auth.temporary-auth-failure");
sendPacket (QXmppSaslFailure ("temporary-auth-failure"));
disconnectFromHost();
break;
}
}
void QXmppStream::_q_socketEncrypted()
{
debug("Socket encrypted");
handleStart();
}
// Handle an incoming message
// Return TRUE if the message was handled, otherwise FALSE.
UtlBoolean MpMediaTask::handleMessage(OsMsg& rMsg)
{
UtlBoolean handled;
MpFlowGraphBase* pFlowGraph;
MpMediaTaskMsg* pMsg;
if (rMsg.getMsgType() != OsMsg::MP_TASK_MSG)
return FALSE; // the method only handles MP_TASK_MSG messages
pMsg = (MpMediaTaskMsg*) &rMsg;
pFlowGraph = (MpFlowGraphBase*) pMsg->getPtr1();
handled = TRUE; // until proven otherwise, assume we'll handle the msg
#ifdef _PROFILE /* [ */
// Log the time it takes to handle messages other than WAIT_FOR_SIGNAL.
long long start_time;
if (pMsg->getMsg() != MpMediaTaskMsg::WAIT_FOR_SIGNAL)
{
timeval t;
gettimeofday(&t, NULL);
start_time = (t.tv_sec * 1000000) + t.tv_usec;
}
#endif /* _PROFILE ] */
if (getMessageQueue()->numMsgs() > 100)
{
OsSysLog::add(FAC_SIP, PRI_DEBUG,
"MpMediaTask::handleMessage msgType = %d, "
"queue length = %d",
pMsg->getMsg(), getMessageQueue()->numMsgs());
}
switch (pMsg->getMsg())
{
case MpMediaTaskMsg::MANAGE:
if (!handleManage(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::SET_FOCUS:
if (!handleSetFocus(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::START:
if (!handleStart(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::STOP:
if (!handleStop(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::UNMANAGE:
if (!handleUnmanage(pFlowGraph))
mHandleMsgErrs++;
break;
case MpMediaTaskMsg::WAIT_FOR_SIGNAL:
if (!handleWaitForSignal(pMsg))
mHandleMsgErrs++;
break;
default:
handled = FALSE; // we didn't handle the message after all
break;
}
#ifdef _PROFILE /* [ */
// Log the time it takes to handle messages other than WAIT_FOR_SIGNAL.
if (pMsg->getMsg() != MpMediaTaskMsg::WAIT_FOR_SIGNAL)
{
timeval t;
gettimeofday(&t, NULL);
long long end_time = (t.tv_sec * 1000000) + t.tv_usec;
mOtherMessages.tally(end_time - start_time);
}
#endif /* _PROFILE ] */
return handled;
}
void QXmppIncomingClient::handleStanza (const QDomElement &nodeRecv)
{
const QString ns = nodeRecv.namespaceURI();
if (d->idleTimer->interval())
d->idleTimer->start();
if (ns == ns_tls && nodeRecv.tagName() == QLatin1String ("starttls"))
{
sendData ("<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>");
socket()->flush();
socket()->startServerEncryption();
return;
}
else if (ns == ns_sasl)
{
if (!d->passwordChecker)
{
warning ("Cannot perform authentication, no password checker");
sendPacket (QXmppSaslFailure ("temporary-auth-failure"));
disconnectFromHost();
return;
}
if (nodeRecv.tagName() == QLatin1String ("auth"))
{
QXmppSaslAuth auth;
auth.parse (nodeRecv);
d->saslServer = QXmppSaslServer::create (auth.mechanism(), this);
if (!d->saslServer)
{
sendPacket (QXmppSaslFailure ("invalid-mechanism"));
disconnectFromHost();
return;
}
d->saslServer->setRealm (d->domain.toUtf8());
QByteArray challenge;
QXmppSaslServer::Response result = d->saslServer->respond (auth.value(), challenge);
if (result == QXmppSaslServer::InputNeeded)
{
// check credentials
d->checkCredentials (auth.value());
}
else if (result == QXmppSaslServer::Challenge)
sendPacket (QXmppSaslChallenge (challenge));
else
{
// FIXME: what condition?
sendPacket (QXmppSaslFailure());
disconnectFromHost();
return;
}
}
else if (nodeRecv.tagName() == QLatin1String ("response"))
{
QXmppSaslResponse response;
response.parse (nodeRecv);
if (!d->saslServer)
{
warning ("SASL response received, but no mechanism selected");
sendPacket (QXmppSaslFailure());
disconnectFromHost();
return;
}
QByteArray challenge;
QXmppSaslServer::Response result = d->saslServer->respond (response.value(), challenge);
if (result == QXmppSaslServer::InputNeeded)
{
// check credentials
d->checkCredentials (response.value());
}
else if (result == QXmppSaslServer::Succeeded)
{
// authentication succeeded
d->jid = QString ("%1@%2").arg (d->saslServer->username(), d->domain);
info (QString ("Authentication succeeded for '%1' from %2").arg (d->jid, d->origin()));
updateCounter ("incoming-client.auth.success");
sendPacket (QXmppSaslSuccess());
handleStart();
}
else
{
// FIXME: what condition?
sendPacket (QXmppSaslFailure());
disconnectFromHost();
}
}
}
else if (ns == ns_client)
{
if (nodeRecv.tagName() == QLatin1String ("iq"))
{
const QString type = nodeRecv.attribute ("type");
if (QXmppBindIq::isBindIq (nodeRecv) && type == QLatin1String ("set"))
{
QXmppBindIq bindSet;
bindSet.parse (nodeRecv);
d->resource = bindSet.resource().trimmed();
if (d->resource.isEmpty())
d->resource = QXmppUtils::generateStanzaHash();
d->jid = QString ("%1/%2").arg (QXmppUtils::jidToBareJid (d->jid), d->resource);
QXmppBindIq bindResult;
bindResult.setType (QXmppIq::Result);
bindResult.setId (bindSet.id());
bindResult.setJid (d->jid);
sendPacket (bindResult);
// bound
emit connected();
return;
}
else if (QXmppSessionIq::isSessionIq (nodeRecv) && type == QLatin1String ("set"))
{
QXmppSessionIq sessionSet;
sessionSet.parse (nodeRecv);
QXmppIq sessionResult;
sessionResult.setType (QXmppIq::Result);
sessionResult.setId (sessionSet.id());
sessionResult.setTo (d->jid);
sendPacket (sessionResult);
return;
}
}
// check the sender is legitimate
const QString from = nodeRecv.attribute ("from");
if (!from.isEmpty() && from != d->jid && from != QXmppUtils::jidToBareJid (d->jid))
{
warning (QString ("Received a stanza from unexpected JID %1").arg (from));
return;
}
// process unhandled stanzas
if (nodeRecv.tagName() == QLatin1String ("iq") ||
nodeRecv.tagName() == QLatin1String ("message") ||
nodeRecv.tagName() == QLatin1String ("presence"))
{
QDomElement nodeFull (nodeRecv);
// if the sender is empty, set it to the appropriate JID
if (nodeFull.attribute ("from").isEmpty())
{
if (nodeFull.tagName() == QLatin1String ("presence") &&
(nodeFull.attribute ("type") == QLatin1String ("subscribe") ||
nodeFull.attribute ("type") == QLatin1String ("subscribed")))
nodeFull.setAttribute ("from", QXmppUtils::jidToBareJid (d->jid));
else
nodeFull.setAttribute ("from", d->jid);
}
// if the recipient is empty, set it to the local domain
if (nodeFull.attribute ("to").isEmpty())
nodeFull.setAttribute ("to", d->domain);
// emit stanza for processing by server
emit elementReceived (nodeFull);
}
}
}
// Handle decoding incoming MIDI traffic a byte at a time -- remembers
// what it needs to from one call to the next.
//
// This is a private function & not meant to be called from outside this class.
// It's used whenever data is available from the serial port.
//
void Midi::recvByte(int value)
{
int tmp;
int channel;
int bigval; /* temp 14-bit value for pitch, song pos */
if (recvMode_ & MODE_PROPRIETARY
&& value != STATUS_END_PROPRIETARY)
{
/* If proprietary handling compiled in, just pass all data received
* after a START_PROPRIETARY event to proprietary_decode
* until get an END_PROPRIETARY event
*/
#ifdef CONFIG_MIDI_PROPRIETARY
proprietaryDecode(value);
#endif
return;
}
if (value & 0x80) {
/* All < 0xf0 events get at least 1 arg byte so
* it's ok to mask off the low 4 bits to figure
* out how to handle the event for < 0xf0 events.
*/
tmp = value;
if (tmp < 0xf0)
tmp &= 0xf0;
switch (tmp) {
/* These status events take 2 bytes as arguments */
case STATUS_EVENT_NOTE_OFF:
case STATUS_EVENT_NOTE_ON:
case STATUS_EVENT_VELOCITY_CHANGE:
case STATUS_EVENT_CONTROL_CHANGE:
case STATUS_PITCH_CHANGE:
case STATUS_SONG_POSITION:
recvBytesNeeded_ = 2;
recvByteCount_ = 0;
recvEvent_ = value;
break;
/* 1 byte arguments */
case STATUS_EVENT_PROGRAM_CHANGE:
case STATUS_AFTER_TOUCH:
case STATUS_SONG_SELECT:
recvBytesNeeded_ = 1;
recvByteCount_ = 0;
recvEvent_ = value;
return;
/* No arguments ( > 0xf0 events) */
case STATUS_START_PROPRIETARY:
recvMode_ |= MODE_PROPRIETARY;
#ifdef CONFIG_MIDI_PROPRIETARY
proprietaryDecodeStart();
#endif
break;
case STATUS_END_PROPRIETARY:
recvMode_ &= ~MODE_PROPRIETARY;
#ifdef CONFIG_MIDI_PROPRIETARY
proprietaryDecodeEnd();
#endif
break;
case STATUS_TUNE_REQUEST:
handleTuneRequest();
break;
case STATUS_SYNC:
handleSync();
break;
case STATUS_START:
handleStart();
break;
case STATUS_CONTINUE:
handleContinue();
break;
case STATUS_STOP:
handleStop();
break;
case STATUS_ACTIVE_SENSE:
handleActiveSense();
break;
case STATUS_RESET:
handleReset();
break;
}
return;
}
if (++recvByteCount_ == recvBytesNeeded_) {
/* Copy out the channel (if applicable; in some cases this will be meaningless,
* but in those cases the value will be ignored)
*/
channel = (recvEvent_ & 0x0f) + 1;
tmp = recvEvent_;
if (tmp < 0xf0) {
tmp &= 0xf0;
}
/* See if this event matches our MIDI channel
* (or we're accepting for all channels)
*/
if (!channelIn_
|| (channel == channelIn_)
|| (tmp >= 0xf0))
{
switch (tmp) {
case STATUS_EVENT_NOTE_ON:
/* If velocity is 0, it's actually a note off & should fall thru
* to the note off case
*/
if (value) {
handleNoteOn(channel, recvArg0_, value);
break;
}
case STATUS_EVENT_NOTE_OFF:
handleNoteOff(channel, recvArg0_, value);
break;
case STATUS_EVENT_VELOCITY_CHANGE:
handleVelocityChange(channel, recvArg0_, value);
break;
case STATUS_EVENT_CONTROL_CHANGE:
handleControlChange(channel, recvArg0_, value);
break;
case STATUS_EVENT_PROGRAM_CHANGE:
handleProgramChange(channel, value);
break;
case STATUS_AFTER_TOUCH:
handleAfterTouch(channel, value);
break;
case STATUS_PITCH_CHANGE:
bigval = (value << 7) | recvArg0_;
handlePitchChange(bigval);
break;
case STATUS_SONG_POSITION:
bigval = (value << 7) | recvArg0_;
handleSongPosition(bigval);
break;
case STATUS_SONG_SELECT:
handleSongSelect(value);
break;
}
}
/* Just reset the byte count; keep the same event -- might get more messages
trailing from current event.
*/
recvByteCount_ = 0;
}
recvArg0_ = value;
}
void Clock::handleStep( unsigned int numSteps )
{
double runtime = dt_ * numSteps;
handleStart( runtime );
}
// Handle decoding incoming MIDI traffic a byte at a time -- remembers
// what it needs to from one call to the next.
//
// This is a private function & not meant to be called from outside this class.
// It's used whenever data is available from the serial port.
//
void USBMidi::dispatchPacket(uint32 p)
{
union EVENT_t e;
e.i=p;
// !!!!!!!!!!!!!!!! Add a sysex handler FIX THIS VERY VERY SHORTLY !!!!!!!!!!!!!!
if (recvMode_ & MODE_PROPRIETARY
&& CIN_IS_SYSEX(e.p.cin))
{
/* If sysex handling compiled in, just pass all data received
* to the sysex handler
*/
#ifdef CONFIG_MIDI_PROPRIETARY
// handleSysex(p);
#endif
return;
}
switch (e.p.cin) {
case CIN_3BYTE_SYS_COMMON:
if (e.p.midi0 == MIDIv1_SONG_POSITION_PTR) {
handleSongPosition(((uint16)e.p.midi2)<<7|((uint16)e.p.midi1));
}
break;
case CIN_2BYTE_SYS_COMMON:
switch (e.p.midi0) {
case MIDIv1_SONG_SELECT:
handleSongSelect(e.p.midi1);
break;
case MIDIv1_MTC_QUARTER_FRAME:
// reference library doesnt handle quarter frame.
break;
}
break;
case CIN_NOTE_OFF:
handleNoteOff(MIDIv1_VOICE_CHANNEL(e.p.midi0), e.p.midi1, e.p.midi2);
break;
case CIN_NOTE_ON:
handleNoteOn(MIDIv1_VOICE_CHANNEL(e.p.midi0), e.p.midi1, e.p.midi2);
break;
case CIN_AFTER_TOUCH:
handleVelocityChange(MIDIv1_VOICE_CHANNEL(e.p.midi0), e.p.midi1, e.p.midi2);
break;
case CIN_CONTROL_CHANGE:
handleControlChange(MIDIv1_VOICE_CHANNEL(e.p.midi0), e.p.midi1, e.p.midi2);
break;
case CIN_PROGRAM_CHANGE:
handleProgramChange(MIDIv1_VOICE_CHANNEL(e.p.midi0), e.p.midi1);
break;
case CIN_CHANNEL_PRESSURE:
handleAfterTouch(MIDIv1_VOICE_CHANNEL(e.p.midi0), e.p.midi1);
break;
case CIN_PITCH_WHEEL:
handlePitchChange(((uint16)e.p.midi2)<<7|((uint16)e.p.midi1));
break;
case CIN_1BYTE:
switch (e.p.midi0) {
case MIDIv1_CLOCK:
handleSync();
break;
case MIDIv1_TICK:
break;
case MIDIv1_START:
handleStart();
break;
case MIDIv1_CONTINUE:
handleContinue();
break;
case MIDIv1_STOP:
handleStop();
break;
case MIDIv1_ACTIVE_SENSE:
handleActiveSense();
break;
case MIDIv1_RESET:
handleReset();
break;
case MIDIv1_TUNE_REQUEST:
handleTuneRequest();
break;
default:
break;
}
break;
}
}
