libcm/cmMidiPort.c

#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmTime.h"
#include "cmMidi.h"
#include "cmMidiPort.h"



//===================================================================================================
//
//

enum 
{ 
  kBufByteCnt = 1024, 

  kExpectStatusStId=0,       // 0
  kExpectDataStId,           // 1
  kExpectStatusOrDataStId,   // 2
  kExpectEOXStId             // 3
};

typedef struct cmMpParserCb_str
{
  cmMpCallback_t           cbFunc;
  void*                    cbDataPtr;
  struct cmMpParserCb_str* linkPtr;
} cmMpParserCb_t;

typedef struct
{
  cmErr_t        err;

  cmMpParserCb_t* cbChain;
  
  cmMidiPacket_t  pkt;

  unsigned      state;          // parser state id
  unsigned      errCnt;         // accumlated error count
  cmMidiByte_t  status;         // running status
  cmMidiByte_t  data0;          // data byte 0
  unsigned      dataCnt;        // data byte cnt for current status 
  unsigned      dataIdx;        // index (0 or 1) of next data byte
  cmMidiByte_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
} cmMpParser_t;

cmMpParser_t* _cmMpParserFromHandle( cmMpParserH_t h )
{
  cmMpParser_t* p = (cmMpParser_t*)h.h;
  assert(p!=NULL);
  return p;
}

void _cmMpParserReport( cmMpParser_t* p )
{
  cmRptPrintf(p->err.rpt,"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 _cmMpParserDestroy( cmMpParser_t* p )
{
  cmMemPtrFree(&p->buf);

  cmMpParserCb_t* c = p->cbChain;
  while(c != NULL)
  {
    cmMpParserCb_t* nc = c->linkPtr;
    cmMemFree(c);
    c = nc;
  }

  cmMemPtrFree(&p);

}
 
cmMpParserH_t cmMpParserCreate( unsigned devIdx, unsigned portIdx, cmMpCallback_t cbFunc, void* cbDataPtr, unsigned bufByteCnt, cmRpt_t* rpt )
{
  cmMpRC_t      rc = kOkMpRC;
  cmMpParserH_t h;
  cmMpParser_t* p = cmMemAllocZ( cmMpParser_t, 1 );

  cmErrSetup(&p->err,rpt,"MIDI Parser");

  p->pkt.devIdx        = devIdx;
  p->pkt.portIdx       = portIdx;

  //p->cbChain           = cmMemAllocZ( cmMpParserCb_t, 1 );
  //p->cbChain->cbFunc    = cbFunc;
  //p->cbChain->cbDataPtr = cbDataPtr;
  //p->cbChain->linkPtr   = NULL;
  p->cbChain           = NULL;
  p->buf               = cmMemAllocZ( cmMidiByte_t, bufByteCnt );
  p->bufByteCnt        = bufByteCnt;
  p->bufIdx            = 0;
  p->msgCnt            = 0;
  p->state             = kExpectStatusStId;
  p->dataIdx           = cmInvalidIdx;
  p->dataCnt           = cmInvalidCnt;
  p->status            = kInvalidStatusMdId;

  h.h = p;

  if( cbFunc != NULL )
    rc = cmMpParserInstallCallback(h, cbFunc, cbDataPtr );
    

  if( rc != kOkMpRC )
  {
    h.h = NULL;
    _cmMpParserDestroy(p);
  }
  

  return h;
} 

void        cmMpParserDestroy(    cmMpParserH_t* hp )
{
  if( hp==NULL || hp->h == NULL )
    return;

  cmMpParser_t* p = _cmMpParserFromHandle(*hp);

  _cmMpParserDestroy(p);
  
  hp->h = NULL;

}

unsigned    cmMpParserErrorCount( cmMpParserH_t h )
{
  cmMpParser_t* p = _cmMpParserFromHandle(h);
  if( p == NULL )
    return 0;

  return p->errCnt;
}

void _cmMpParserCb( cmMpParser_t* p, cmMidiPacket_t* pkt, unsigned pktCnt )
{
  cmMpParserCb_t* c = p->cbChain;
  for(; c!=NULL; c=c->linkPtr)
  {
    pkt->cbDataPtr = c->cbDataPtr;
    c->cbFunc( pkt, pktCnt );
  }
}

void _cmMpTransmitChMsgs( cmMpParser_t* p )
{
  if( p->msgCnt > 0 )
  {
    p->pkt.msgArray = (cmMidiMsg*)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( cmMpParser_t* p )
{
  p->pkt.msgArray = NULL;
  p->pkt.sysExMsg = p->buf;
  p->pkt.msgCnt   = p->bufIdx;
  //p->cbFunc( &p->pkt, 1 );
  _cmMpParserCb(p,&p->pkt,1);
  p->bufIdx = 0;

}

void _cmMpParserStoreChMsg( cmMpParser_t* p, const cmTimeSpec_t* timeStamp,  cmMidiByte_t d )
{
  // if there is not enough room left in the buffer then transmit
  // the current messages
  if( p->bufByteCnt - p->bufIdx < sizeof(cmMidiMsg) )
    _cmMpTransmitChMsgs(p);


  assert( p->bufByteCnt - p->bufIdx >= sizeof(cmMidiMsg) );

  // get a pointer to the next msg in the buffer
  cmMidiMsg* msgPtr = (cmMidiMsg*)(p->buf + p->bufIdx);

  // fill the buffer msg
  msgPtr->timeStamp = *timeStamp;
  msgPtr->status  = p->status;

  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(cmMidiMsg);

}

void cmMpParseMidiData( cmMpParserH_t h, const cmTimeSpec_t* timeStamp, const cmMidiByte_t* iBuf, unsigned iByteCnt )
{
  
  cmMpParser_t* p = _cmMpParserFromHandle(h);

  if( p == NULL )
    return;
  
  const cmMidiByte_t* ip = iBuf;
  const cmMidiByte_t* ep  = iBuf + iByteCnt;

  for(; ip < ep; ++ip )
  {
    // if this byte is a status byte
    if( cmMidiIsStatus(*ip) )
    {
      if( p->state != kExpectStatusStId && p->state != kExpectStatusOrDataStId )
        ++p->errCnt;

      p->status  = *ip;
      p->dataCnt = cmMidiStatusToByteCount(*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 = cmInvalidCnt;
          p->dataIdx = cmInvalidIdx;
          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 = cmInvalidIdx;
            p->dataCnt = cmInvalidCnt;
          }

      }

      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);
 
}

cmMpRC_t  cmMpParserMidiTriple(   cmMpParserH_t h, const cmTimeSpec_t* timeStamp, cmMidiByte_t status, cmMidiByte_t d0, cmMidiByte_t d1 )
{
  cmMpRC_t rc = kOkMpRC;
  cmMpParser_t* p = _cmMpParserFromHandle(h);
  cmMidiByte_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 = cmErrMsg(&p->err,kInvalidArgMpRC,"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 = cmInvalidCnt;

 errLabel:
  return rc;
}

cmMpRC_t  cmMpParserTransmit(    cmMpParserH_t h )
{
  cmMpParser_t* p = _cmMpParserFromHandle(h);
  _cmMpTransmitChMsgs(p);
  return kOkMpRC;
}

cmMpRC_t      cmMpParserInstallCallback( cmMpParserH_t h, cmMpCallback_t  cbFunc, void* cbDataPtr )
{
  cmMpParser_t*   p        = _cmMpParserFromHandle(h);
  cmMpParserCb_t* newCbPtr = cmMemAllocZ( cmMpParserCb_t, 1 );
  cmMpParserCb_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 kOkMpRC;
}

cmMpRC_t      cmMpParserRemoveCallback(  cmMpParserH_t h, cmMpCallback_t cbFunc, void* cbDataPtr )
{
  cmMpParser_t*   p = _cmMpParserFromHandle(h);
  cmMpParserCb_t* c1 = p->cbChain;  // target link
  cmMpParserCb_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 cmErrMsg(&p->err,kCbNotFoundMpRC,"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;

  cmMemFree(c1);
  
  return kOkMpRC;
}

bool cmMpParserHasCallback( cmMpParserH_t h, cmMpCallback_t cbFunc, void* cbDataPtr )
{
  cmMpParser_t*   p = _cmMpParserFromHandle(h);
  cmMpParserCb_t* c = p->cbChain;  // target link

  // search for the cbFunc to remove
  for(; c!=NULL; c=c->linkPtr)
    if( c->cbFunc == cbFunc && c->cbDataPtr == cbDataPtr )
      return true;

  return false;
}

//====================================================================================================
//
//

unsigned    cmMpDeviceNameToIndex(const cmChar_t* name)
{
  assert(name!=NULL);
  unsigned i;
  unsigned n = cmMpDeviceCount();
  for(i=0; i<n; ++i)
    if( strcmp(cmMpDeviceName(i),name)==0)
      return i;
  return cmInvalidIdx;
}

unsigned    cmMpDevicePortNameToIndex( unsigned devIdx, unsigned flags, const cmChar_t* name )
{
  unsigned i;
  unsigned n = cmMpDevicePortCount(devIdx,flags);
  for(i=0; i<n; ++i)
    if( strcmp(cmMpDevicePortName(devIdx,flags,i),name)==0)
      return i;

  return cmInvalidIdx;
}

//====================================================================================================
//
//

void cmMpTestPrint( void* userDataPtr, const char* fmt, va_list vl )
{
  vprintf(fmt,vl);
}

void cmMpTestCb( const cmMidiPacket_t* pktArray, unsigned pktCnt )
{
  unsigned i,j;
  for(i=0; i<pktCnt; ++i)
  {
    const cmMidiPacket_t* p = pktArray + i;

    for(j=0; j<p->msgCnt; ++j)
      if( p->msgArray != NULL )
        printf("%ld %ld 0x%x %i %i\n", p->msgArray[j].timeStamp.tv_sec, p->msgArray[j].timeStamp.tv_nsec, p->msgArray[j].status,p->msgArray[j].d0, p->msgArray[j].d1);
      else
        printf("0x%x ",p->sysExMsg[j]);

  }
}

void cmMpTest( cmCtx_t* ctx )
{
  char ch;
  unsigned parserBufByteCnt = 1024;
  cmMpInitialize(ctx,cmMpTestCb,NULL,parserBufByteCnt,"app");
  cmMpReport(&ctx->rpt);

 
  cmRptPrintf(&ctx->rpt,"<return> to continue\n");

  while((ch = getchar()) != 'q')
  {
    cmMpDeviceSend(2,0,0x90,60,60);
  }
 

  cmMpFinalize();
}