mip_dispatch.c

Go to the documentation of this file.

 
#include "mip_dispatch.h"
 
#include "mip_packet.h"
#include "mip_field.h"
 
#include <assert.h>
 
 
#ifdef __cplusplus
namespace mip {
namespace C {
#endif
 
enum mip_dispatch_type
{
    MIP_DISPATCH_TYPE_PACKET_PRE  = 1,  
    MIP_DISPATCH_TYPE_PACKET_POST = 2,  
    MIP_DISPATCH_TYPE_FIELD       = 3,  
    MIP_DISPATCH_TYPE_EXTRACT     = 4,  
};
 
 
void mip_dispatch_handler_init_packet_handler(mip_dispatch_handler* handler, uint8_t descriptor_set, bool post_callback, mip_dispatch_packet_callback callback, void* user_data)
{
    handler->_next             = NULL;
    handler->_packet_callback  = callback;
    handler->_user_data        = user_data;
    handler->_type             = post_callback ? MIP_DISPATCH_TYPE_PACKET_POST : MIP_DISPATCH_TYPE_PACKET_PRE;
    handler->_descriptor_set   = descriptor_set;
    handler->_field_descriptor = MIP_INVALID_FIELD_DESCRIPTOR;
    handler->_enabled          = true;
}
 
 
void mip_dispatch_handler_init_field_handler(mip_dispatch_handler* handler, uint8_t descriptor_set, uint8_t field_descriptor, mip_dispatch_field_callback callback, void* user_data)
{
    handler->_next             = NULL;
    handler->_field_callback   = callback;
    handler->_user_data        = user_data;
    handler->_type             = MIP_DISPATCH_TYPE_FIELD;
 
    handler->_descriptor_set   = descriptor_set;
    handler->_field_descriptor = field_descriptor;
    handler->_enabled          = true;
}
 
void mip_dispatch_handler_init_extractor(mip_dispatch_handler* handler, uint8_t descriptor_set, uint8_t field_descriptor, mip_dispatch_extractor extractor, void* field_ptr)
{
    // The only wildcard allowed is MIP_DISPATCH_ANY_DATA_SET when field_descriptor is from the shared data set.
    assert(descriptor_set != MIP_DISPATCH_ANY_DESCRIPTOR);
    assert(field_descriptor != MIP_DISPATCH_ANY_DESCRIPTOR && field_descriptor != MIP_DISPATCH_ANY_DATA_SET);
    assert(!mip_is_data_descriptor_set(descriptor_set) || (descriptor_set != MIP_DISPATCH_ANY_DATA_SET) || mip_is_shared_data_field_descriptor(field_descriptor));
    assert(field_ptr);
 
    handler->_next             = NULL;
    handler->_extract_callback = extractor;
    handler->_user_data        = field_ptr;
 
    handler->_type             = MIP_DISPATCH_TYPE_EXTRACT;
    handler->_descriptor_set   = descriptor_set;
    handler->_field_descriptor = field_descriptor;
    handler->_enabled          = true;
}
 
 
void mip_dispatch_handler_set_enabled(mip_dispatch_handler* handler, bool enable)
{
    handler->_enabled = enable;
}
 
bool mip_dispatch_handler_is_enabled(mip_dispatch_handler* handler)
{
    return handler->_enabled;
}
 
 
 
 
void mip_dispatcher_init(mip_dispatcher* self)
{
    self->_first_handler = NULL;
}
 
 
void mip_dispatcher_add_handler(mip_dispatcher* self, mip_dispatch_handler* handler)
{
    if( self->_first_handler == NULL )
        self->_first_handler = handler;
    else
    {
        mip_dispatch_handler* last = self->_first_handler;
 
        while(last->_next != NULL)
            last = last->_next;
 
        last->_next = handler;
    }
}
 
 
void mip_dispatcher_remove_handler(mip_dispatcher* self, mip_dispatch_handler* handler)
{
    if( self->_first_handler == NULL )
        return;
 
    mip_dispatch_handler* query = self->_first_handler;
 
    if( query == handler )
    {
        self->_first_handler = handler->_next;
        handler->_next = NULL;
        return;
    }
 
    while(query->_next != NULL)
    {
        if( query->_next == handler )
        {
            query->_next = handler->_next;
            handler->_next = NULL;
            return;
        }
    }
}
 
 
void mip_dispatcher_remove_all_handlers(mip_dispatcher* self)
{
    mip_dispatch_handler* query = self->_first_handler;
 
    self->_first_handler = NULL;
 
    // Break the chain (technically not necessary, but aids debugging)
    while(query)
    {
        mip_dispatch_handler* next = query->_next;
        query->_next = NULL;
        query = next;
    }
}
 
static bool mip_dispatch_is_descriptor_set_match(uint8_t desc_set, uint8_t handler_desc_set)
{
    return (
        (handler_desc_set == desc_set) ||
        (handler_desc_set == MIP_DISPATCH_ANY_DESCRIPTOR) ||
        ((handler_desc_set == MIP_DISPATCH_ANY_DATA_SET) && mip_is_data_descriptor_set(desc_set))
    );
}
 
static void mip_dispatcher_call_packet_callbacks(mip_dispatcher* self, const mip_packet* packet, mip_timestamp timestamp, bool post)
{
    const uint8_t descriptor_set = mip_packet_descriptor_set(packet);
 
    // Iterate all packet handlers for this packet.
    for(mip_dispatch_handler* handler = self->_first_handler; handler != NULL; handler = handler->_next)
    {
        switch(handler->_type)
        {
        case MIP_DISPATCH_TYPE_PACKET_POST: if(!post) continue; else break;
        case MIP_DISPATCH_TYPE_PACKET_PRE:  if( post) continue; else break;
        default: continue;
        }
 
        if( mip_dispatch_is_descriptor_set_match(descriptor_set, handler->_descriptor_set) )
            handler->_packet_callback(handler->_user_data, packet, timestamp);
    }
}
 
static bool mip_dispatch_is_descriptor_match(uint8_t desc_set, uint8_t field_desc, uint8_t handler_desc_set, uint8_t handler_field_desc)
{
    return mip_dispatch_is_descriptor_set_match(desc_set, handler_desc_set) && (
        (handler_field_desc == field_desc) ||
        (handler_field_desc == MIP_DISPATCH_ANY_DESCRIPTOR)
    );
}
 
static void mip_dispatcher_call_field_callbacks(mip_dispatcher* self, const mip_field* field, mip_timestamp timestamp)
{
    const uint8_t descriptor_set   = mip_field_descriptor_set(field);
    const uint8_t field_descriptor = mip_field_field_descriptor(field);
 
    // Iterate all field handlers for this field.
    for(mip_dispatch_handler* handler = self->_first_handler; handler != NULL; handler = handler->_next)
    {
        if(handler->_type == MIP_DISPATCH_TYPE_FIELD)
        {
            if( mip_dispatch_is_descriptor_match(descriptor_set, field_descriptor, handler->_descriptor_set, handler->_field_descriptor) )
            {
                handler->_field_callback(handler->_user_data, field, timestamp);
            }
        }
        else if(handler->_type == MIP_DISPATCH_TYPE_EXTRACT)
        {
            if( handler->_descriptor_set == descriptor_set && handler->_field_descriptor == field_descriptor )
            {
                handler->_extract_callback(field, handler->_user_data);
            }
        }
    };
}
 
void mip_dispatcher_dispatch_packet(mip_dispatcher* self, const mip_packet* packet, mip_timestamp timestamp)
{
    mip_dispatcher_call_packet_callbacks(self, packet, timestamp, false);
 
    mip_field field;
    mip_field_init_empty(&field);
    while( mip_field_next_in_packet(&field, packet) )
    {
        mip_dispatcher_call_field_callbacks(self, &field, timestamp);
    }
 
    mip_dispatcher_call_packet_callbacks(self, packet, timestamp, true);
}
 
#ifdef __cplusplus
} // namespace C
} // namespace mip
#endif