482 lines
11 KiB
C++
482 lines
11 KiB
C++
//| Copyright: (C) 2020-2024 Kevin Larke <contact AT larke DOT org>
|
|
//| License: GNU GPL version 3.0 or above. See the accompanying LICENSE file.
|
|
#include "cwCommon.h"
|
|
#include "cwLog.h"
|
|
#include "cwCommonImpl.h"
|
|
#include "cwTest.h"
|
|
#include "cwMem.h"
|
|
#include "cwTime.h"
|
|
#include "cwMidi.h"
|
|
#include "cwMidiDecls.h"
|
|
#include "cwMidiParser.h"
|
|
|
|
namespace cw
|
|
{
|
|
namespace midi
|
|
{
|
|
namespace parser
|
|
{
|
|
enum
|
|
{
|
|
kBufByteCnt = 1024,
|
|
|
|
kExpectStatusStId=0, // 0
|
|
kExpectDataStId, // 1
|
|
kExpectStatusOrDataStId, // 2
|
|
kExpectEOXStId // 3
|
|
};
|
|
|
|
typedef struct cmMpParserCb_str
|
|
{
|
|
cbFunc_t cbFunc;
|
|
void* cbDataPtr;
|
|
struct cmMpParserCb_str* linkPtr;
|
|
} cbRecd_t;
|
|
|
|
typedef struct parser_str
|
|
{
|
|
cbRecd_t* cbChain;
|
|
|
|
packet_t pkt;
|
|
|
|
unsigned state; // parser state id
|
|
unsigned errCnt; // accumlated error count
|
|
uint8_t status; // running status
|
|
uint8_t data0; // data byte 0
|
|
unsigned dataCnt; // data byte cnt for current status
|
|
unsigned dataIdx; // index (0 or 1) of next data byte
|
|
uint8_t* buf; // output buffer
|
|
unsigned bufByteCnt; // output buffer byte cnt
|
|
unsigned bufIdx; // next output buffer index
|
|
unsigned msgCnt; // count of channel messages in the buffer
|
|
} parser_t;
|
|
|
|
parser_t* _handleToPtr( handle_t h )
|
|
{
|
|
return handleToPtr<handle_t,parser_t>(h);
|
|
}
|
|
|
|
void _cmMpParserCb( parser_t* p, packet_t* pkt, unsigned pktCnt )
|
|
{
|
|
cbRecd_t* c = p->cbChain;
|
|
for(; c!=NULL; c=c->linkPtr)
|
|
{
|
|
//pkt->cbArg = c->cbDataPtr;
|
|
c->cbFunc( c->cbDataPtr, pkt, pktCnt );
|
|
}
|
|
}
|
|
|
|
void _cmMpTransmitChMsgs( parser_t* p )
|
|
{
|
|
if( p->msgCnt > 0 )
|
|
{
|
|
p->pkt.msgArray = (msg_t*)p->buf;
|
|
p->pkt.msgCnt = p->msgCnt;
|
|
p->pkt.sysExMsg = NULL;
|
|
|
|
//p->cbFunc( &p->pkt, 1 );
|
|
_cmMpParserCb(p,&p->pkt,1);
|
|
|
|
p->bufIdx = 0;
|
|
p->msgCnt = 0;
|
|
}
|
|
}
|
|
|
|
void _cmMpTransmitSysEx( parser_t* p )
|
|
{
|
|
p->pkt.msgArray = NULL;
|
|
p->pkt.sysExMsg = p->buf;
|
|
p->pkt.msgCnt = p->bufIdx;
|
|
_cmMpParserCb(p,&p->pkt,1);
|
|
p->bufIdx = 0;
|
|
|
|
}
|
|
|
|
void _cmMpParserStoreChMsg( parser_t* p, const time::spec_t* timeStamp, uint8_t d )
|
|
{
|
|
// if there is not enough room left in the buffer then transmit
|
|
// the current messages
|
|
if( p->bufByteCnt - p->bufIdx < sizeof(msg_t) )
|
|
_cmMpTransmitChMsgs(p);
|
|
|
|
|
|
assert( p->bufByteCnt - p->bufIdx >= sizeof(msg_t) );
|
|
|
|
// get a pointer to the next msg in the buffer
|
|
msg_t* msgPtr = (msg_t*)(p->buf + p->bufIdx);
|
|
|
|
if( midi::isChStatus(p->status) )
|
|
{
|
|
msgPtr->status = p->status & 0xf0;
|
|
msgPtr->ch = p->status & 0x0f;
|
|
}
|
|
else
|
|
{
|
|
msgPtr->status = p->status;
|
|
msgPtr->ch = 0;
|
|
}
|
|
|
|
// fill the buffer msg
|
|
msgPtr->timeStamp = *timeStamp;
|
|
msgPtr->uid = kInvalidId;
|
|
|
|
switch( p->dataCnt )
|
|
{
|
|
case 0:
|
|
break;
|
|
case 1:
|
|
msgPtr->d0 = d;
|
|
msgPtr->d1 = 0;
|
|
break;
|
|
|
|
case 2:
|
|
msgPtr->d0 = p->data0;
|
|
msgPtr->d1 = d;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
|
|
// update the msg count and next buffer
|
|
++p->msgCnt;
|
|
|
|
p->bufIdx += sizeof(msg_t);
|
|
|
|
}
|
|
|
|
void _report( parser_t* p )
|
|
{
|
|
cwLogInfo("state:%i st:0x%x d0:%i dcnt:%i didx:%i buf[%i]->%i msg:%i err:%i\n",p->state,p->status,p->data0,p->dataCnt,p->dataIdx,p->bufByteCnt,p->bufIdx,p->msgCnt,p->errCnt);
|
|
}
|
|
|
|
void _destroy( parser_t* p )
|
|
{
|
|
mem::release(p->buf);
|
|
|
|
cbRecd_t* c = p->cbChain;
|
|
while(c != NULL)
|
|
{
|
|
cbRecd_t* nc = c->linkPtr;
|
|
mem::release(c);
|
|
c = nc;
|
|
}
|
|
|
|
mem::release(p);
|
|
|
|
}
|
|
|
|
} // parser
|
|
} // midi
|
|
} // cw
|
|
|
|
cw::rc_t cw::midi::parser::create( handle_t& hRef, unsigned devIdx, unsigned portIdx, cbFunc_t cbFunc, void* cbDataPtr, unsigned bufByteCnt )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
parser_t* p = mem::allocZ<parser_t>( 1 );
|
|
|
|
|
|
p->pkt.devIdx = devIdx;
|
|
p->pkt.portIdx = portIdx;
|
|
|
|
p->cbChain = NULL;
|
|
p->buf = mem::allocZ<uint8_t>( bufByteCnt );
|
|
p->bufByteCnt = bufByteCnt;
|
|
p->bufIdx = 0;
|
|
p->msgCnt = 0;
|
|
p->state = kExpectStatusStId;
|
|
p->dataIdx = kInvalidIdx;
|
|
p->dataCnt = kInvalidCnt;
|
|
p->status = kInvalidStatusMdId;
|
|
|
|
hRef.set(p);
|
|
|
|
if( cbFunc != NULL )
|
|
rc = installCallback(hRef, cbFunc, cbDataPtr );
|
|
|
|
|
|
if( rc != kOkRC )
|
|
{
|
|
_destroy(p);
|
|
hRef.clear();
|
|
}
|
|
|
|
|
|
return rc;
|
|
}
|
|
|
|
|
|
cw::rc_t cw::midi::parser::destroy( handle_t& hRef )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
if( !hRef.isValid() )
|
|
return rc;
|
|
|
|
parser_t* p = _handleToPtr(hRef);
|
|
|
|
_destroy(p);
|
|
|
|
hRef.clear();
|
|
|
|
return rc;
|
|
}
|
|
|
|
unsigned cw::midi::parser::errorCount( handle_t h )
|
|
{
|
|
parser_t* p = _handleToPtr(h);
|
|
if( p == NULL )
|
|
return 0;
|
|
|
|
return p->errCnt;
|
|
}
|
|
|
|
|
|
void cw::midi::parser::parseMidiData( handle_t h, const time::spec_t* timeStamp, const uint8_t* iBuf, unsigned iByteCnt )
|
|
{
|
|
|
|
parser_t* p = _handleToPtr(h);
|
|
|
|
if( p == NULL )
|
|
return;
|
|
|
|
const uint8_t* ip = iBuf;
|
|
const uint8_t* ep = iBuf + iByteCnt;
|
|
|
|
for(; ip < ep; ++ip )
|
|
{
|
|
// if this byte is a status byte
|
|
if( isStatus(*ip) )
|
|
{
|
|
if( p->state != kExpectStatusStId && p->state != kExpectStatusOrDataStId )
|
|
++p->errCnt;
|
|
|
|
p->status = *ip;
|
|
p->dataCnt = statusToByteCount(*ip);
|
|
|
|
switch( p->status )
|
|
{
|
|
case kSysExMdId: // if this is the start of a sys-ex msg ...
|
|
// ... clear the buffer to prepare from sys-ex data
|
|
_cmMpTransmitChMsgs(p);
|
|
|
|
p->state = kExpectEOXStId;
|
|
p->dataCnt = kInvalidCnt;
|
|
p->dataIdx = kInvalidIdx;
|
|
p->buf[ p->bufIdx++ ] = kSysExMdId;
|
|
break;
|
|
|
|
case kSysComEoxMdId: // if this is the end of a sys-ex msg
|
|
assert( p->bufIdx < p->bufByteCnt );
|
|
p->buf[p->bufIdx++] = *ip;
|
|
_cmMpTransmitSysEx(p);
|
|
p->state = kExpectStatusStId;
|
|
break;
|
|
|
|
default: // ... otherwise it is a 1,2, or 3 byte msg status
|
|
if( p->dataCnt > 0 )
|
|
{
|
|
p->state = kExpectDataStId;
|
|
p->dataIdx = 0;
|
|
}
|
|
else
|
|
{
|
|
// this is a status only msg - store it
|
|
_cmMpParserStoreChMsg(p,timeStamp,*ip);
|
|
|
|
p->state = kExpectStatusStId;
|
|
p->dataIdx = kInvalidIdx;
|
|
p->dataCnt = kInvalidCnt;
|
|
}
|
|
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
// at this point the current byte (*ip) is a data byte
|
|
|
|
switch(p->state)
|
|
{
|
|
|
|
case kExpectStatusOrDataStId:
|
|
assert( p->dataIdx == 0 );
|
|
|
|
case kExpectDataStId:
|
|
switch( p->dataIdx )
|
|
{
|
|
case 0: // expecting data byte 0 ...
|
|
|
|
switch( p->dataCnt )
|
|
{
|
|
case 1: // ... of a 1 byte msg - the msg is complete
|
|
_cmMpParserStoreChMsg(p,timeStamp,*ip);
|
|
p->state = kExpectStatusOrDataStId;
|
|
break;
|
|
|
|
case 2: // ... of a 2 byte msg - prepare to recv the second data byte
|
|
p->state = kExpectDataStId;
|
|
p->dataIdx = 1;
|
|
p->data0 = *ip;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
}
|
|
break;
|
|
|
|
case 1: // expecting data byte 1 of a two byte msg
|
|
assert( p->dataCnt == 2 );
|
|
assert( p->state == kExpectDataStId );
|
|
|
|
_cmMpParserStoreChMsg(p,timeStamp,*ip);
|
|
p->state = kExpectStatusOrDataStId;
|
|
p->dataIdx = 0;
|
|
break;
|
|
|
|
default:
|
|
assert(0);
|
|
|
|
}
|
|
break;
|
|
|
|
case kExpectEOXStId:
|
|
assert( p->bufIdx < p->bufByteCnt );
|
|
|
|
p->buf[p->bufIdx++] = *ip;
|
|
|
|
// if the buffer is full - then transmit it
|
|
if( p->bufIdx == p->bufByteCnt )
|
|
_cmMpTransmitSysEx(p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} // ip loop
|
|
|
|
_cmMpTransmitChMsgs(p);
|
|
|
|
}
|
|
|
|
cw::rc_t cw::midi::parser::midiTriple( handle_t h, const time::spec_t* timeStamp, uint8_t status, uint8_t d0, uint8_t d1 )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
parser_t* p = _handleToPtr(h);
|
|
uint8_t mb = 0xff; // a midi triple may never have a status of 0xff
|
|
|
|
if( d0 == 0xff )
|
|
p->dataCnt = 0;
|
|
else
|
|
if( d1 == 0xff )
|
|
p->dataCnt = 1;
|
|
else
|
|
p->dataCnt = 2;
|
|
|
|
p->status = status;
|
|
switch( p->dataCnt )
|
|
{
|
|
case 0:
|
|
mb = status;
|
|
break;
|
|
|
|
case 1:
|
|
mb = d0;
|
|
break;
|
|
|
|
case 2:
|
|
p->data0 = d0;
|
|
mb = d1;
|
|
break;
|
|
|
|
default:
|
|
rc = cwLogError(kInvalidArgRC,"An invalid MIDI status byte (0x%x) was encountered by the MIDI data parser.");
|
|
goto errLabel;
|
|
break;
|
|
}
|
|
|
|
if( mb != 0xff )
|
|
_cmMpParserStoreChMsg(p,timeStamp,mb);
|
|
|
|
p->dataCnt = kInvalidCnt;
|
|
|
|
errLabel:
|
|
return rc;
|
|
}
|
|
|
|
cw::rc_t cw::midi::parser::transmit( handle_t h )
|
|
{
|
|
parser_t* p = _handleToPtr(h);
|
|
_cmMpTransmitChMsgs(p);
|
|
return kOkRC;
|
|
}
|
|
|
|
|
|
cw::rc_t cw::midi::parser::installCallback( handle_t h, cbFunc_t cbFunc, void* cbDataPtr )
|
|
{
|
|
parser_t* p = _handleToPtr(h);
|
|
cbRecd_t* newCbPtr = mem::allocZ<cbRecd_t>( 1 );
|
|
cbRecd_t* c = p->cbChain;
|
|
|
|
newCbPtr->cbFunc = cbFunc;
|
|
newCbPtr->cbDataPtr = cbDataPtr;
|
|
newCbPtr->linkPtr = NULL;
|
|
|
|
if( p->cbChain == NULL )
|
|
p->cbChain = newCbPtr;
|
|
else
|
|
{
|
|
while( c->linkPtr != NULL )
|
|
c = c->linkPtr;
|
|
|
|
c->linkPtr = newCbPtr;
|
|
}
|
|
|
|
return kOkRC;
|
|
}
|
|
|
|
cw::rc_t cw::midi::parser::removeCallback( handle_t h, cbFunc_t cbFunc, void* cbDataPtr )
|
|
{
|
|
parser_t* p = _handleToPtr(h);
|
|
cbRecd_t* c1 = p->cbChain; // target link
|
|
cbRecd_t* c0 = NULL; // link pointing to target
|
|
|
|
// search for the cbFunc to remove
|
|
for(; c1!=NULL; c1=c1->linkPtr)
|
|
{
|
|
if( c1->cbFunc == cbFunc && c1->cbDataPtr == cbDataPtr)
|
|
break;
|
|
|
|
c0 = c1;
|
|
}
|
|
|
|
// if the cbFunc was not found
|
|
if( c1 == NULL )
|
|
return cwLogError(kInvalidArgRC,"Unable to locate the callback function %p for removal.",cbFunc);
|
|
|
|
// the cbFunc to remove was found
|
|
|
|
// if it was the first cb in the chain
|
|
if( c0 == NULL )
|
|
p->cbChain = c1->linkPtr;
|
|
else
|
|
c0->linkPtr = c1->linkPtr;
|
|
|
|
mem::release(c1);
|
|
|
|
return kOkRC;
|
|
}
|
|
|
|
bool cw::midi::parser::hasCallback( handle_t h, cbFunc_t cbFunc, void* cbArg )
|
|
{
|
|
parser_t* p = _handleToPtr(h);
|
|
cbRecd_t* c = p->cbChain; // target link
|
|
|
|
// search for the cbFunc to remove
|
|
for(; c!=NULL; c=c->linkPtr)
|
|
if( c->cbFunc == cbFunc && c->cbDataPtr == cbArg )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|