Asynchronous Events

An application can register condition(s) to be monitored by the firmware.

When a callback handler is defined, the condition(s) is(are) reported to the application asynchronously from the firmware to the handler.

The way to define an handler is as follows:

• Initialize the receive acquisition as usual.
• A callback handler must be registered using the mxfAsyncEventHandlerInit() function.
• The conditions to monitor must be defined using the mxfAsyncEventConditionsSet() function.

After this registration, the application can read acquisition data as usual and/or receive asynchronous events through the callback handler.

The receive queue can also be read from the callback handler if necessary.

List of conditions

The event conditions that can be monitored are as follows:

Condition	Description
MXF_ASYNCEVENT_COND_RXACQ_BUFFER_THRESHOLD	Acquisition buffer threshold exceeded.
MXF_ASYNCEVENT_COND_RX_ERROR	Receive errors on the RX port.

Example

hfce_buffer_threshold.c

Example

In the example below a condition handler is defined for monitoring the MXF_ASYNCEVENT_COND_RXACQ_BUFFER_THRESHOLD condition and a HFCE RX acquisition channel is started to receive data.

uint32 asyncEventHandler(HMXF_ASYNCEVENT asyncEvent, void *param)
{
MXF_ASYNCEVENT_PENDING_INFO pendingList[64];
HMXF_CHANNEL channel;
uint64 i, maxCount=64, pendingCount, status;
uint64 interruptID;
uint32 rc=MAXT_SUCCESS;
uint64 dev, mod, port;


   // Builds the list of pending events to process
   rc = mxfAsyncEventPendingGet(asyncEvent, maxCount, &pendingCount, pendingList);

   for (i=0; i < pendingCount && !rc; i++)
   {
      switch(pendingList[i].condID)
      {
      // The buffer is almost full, we should then read the data with mxfHFCERxAcqRead().
         case MXF_ASYNCEVENT_COND_RXACQ_BUFFER_THRESHOLD:
         {
         MXF_HFCE_DATAREC *recHfce=(MXF_HFCE_DATAREC *)param;
         HMXF_BUFFER buffer;
         uint64 status;
         uint64 msgCount, byteCount;
         uint32 rc=MAXT_SUCCESS;

           buffer = pendingList[i].condition.rxAcqBufferThreshold.buffer;

           // Read the records
           rc = mxfHFCERxAcqRead(buffer, 0, BUFFER_SIZE, &status, &msgCount, &byteCount, recHfce);

           break;
      }

      // A receive error was detected
      case MXF_ASYNCEVENT_COND_RX_ERROR:
        channel = pendingList[i].condition.rxErr.channel;
        status = pendingList[i].condition.rxErr.status;
        rc = mxfChannelLocationGet(channel, &dev, &mod, &port);
        if(!rc)
           printf("Status 0x%08llx received on channel %llu.%llu.%llu\n", status, dev, mod, port);
        break;

      default:
        printf("Unknown condID 0x%llx)", pendingList[i].condID);
        break;
      }
  }     

  return rc;
}

#define BUFFER_SIZE         1*1024*1024 // 1 MB

int main()
{
HMXF_SERVER  server;
MXF_ASYNCEVENT_CONDITION asyncEventInfo[2];
HMXF_CHANNEL channel;
HMXF_BUFFER  buffer;
HMXF_ASYNCEVENT asyncEvent;
uint32 rc;
MXF_HFCE_DATAREC *hostBuffer;

   ...

  // Allocates RX acquisition buffers
  if (!rc)
      rc = mxfRxAcqBufferAlloc(channel, 1024, &buffer, NULL);

   // Allocates host buffer
   if(!rc)
   {
      hostBuffer = (MXF_HFCE_DATAREC *)malloc(BUFFER_SIZE);
      if(!hostBuffer)
         rc = MAXT_ERROR_MEM;
   }

  // Registers the callback handler service function
   if (!rc)
      rc = mxfAsyncEventHandlerInit(server, asyncEventHandler, hostBuffer, &asyncEvent);

   memset(&asyncEventInfo, 0, sizeof(asyncEventInfo));

    // Acquisition threshold; the callback get called when the receive FIFO is
    // almost full >=4 until it gets to < 1 word (almost empty).
    asyncEventInfo[0].condID = MXF_ASYNCEVENT_COND_RXACQ_BUFFER_THRESHOLD;
    asyncEventInfo[0].condition.rxAcqBufferThreshold.almostFull=4;
    asyncEventInfo[0].condition.rxAcqBufferThreshold.almostEmpty=1;
    asyncEventInfo[0].condition.rxAcqBufferThreshold.buffer=buffer;

    // Receive message in error; the callback get called when a data word in error is detected
    asyncEventInfo[1].condID = MXF_ASYNCEVENT_COND_RX_ERROR;
    asyncEventInfo[1].condition.rxErr.channel = channel;

   // Enables Acquisition threshold interrupt
   if (!rc)
      rc = mxfAsyncEventConditionsSet(asyncEvent, TRUE, 2, asyncEventInfo);

  // Starts the acquisition process
  if (!rc)
        rc = mxfRxAcqModeSet(buffer, MXF_RXACQ_MODE_LINEAR);

   if (!rc)
        rc = mxfRxAcqStart(buffer, MXF_RXACQ_FLAG_DEFAULT, 0, 0);

   ...

   if (!rc)
      rc = mxfRxAcqStop(buffer);

    if (!rc)
      rc = mxfAsyncEventConditionsSet(asyncEvent, FALSE, 2, asyncEventInfo);      

   if (!rc)
      rc = mxfAsyncEventHandlerTerminate(asyncEvent);

   if (hostBuffer)
      free(hostBuffer);

    ...
}