mh5streamevent.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2006 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "mh5base.h"
#include "mh5profile.h"
#include "mh5streamevent.h"
#include "mh5gate.h"
#include "mh5memory.h"          /* for stream event name */
#include "mh5object.h"
#include "mh5queue.h"

#ifndef CI_PLUS_ONLY
 #include "mheg5_control.h"
 #include "glue_dsmcc.h"
 #include "glue_queue.h"
#endif
#include "mh5hfs.h"
#include "glue_main.h"

/*---constant definitions for this file--------------------------------------*/

#define MAX_STREAMS             16


/*---local typedef structs for this file-------------------------------------*/

#ifndef CI_PLUS_ONLY
/* Event information for each listening link */
typedef struct sSeEventInfo
{
   struct sSeEventInfo *next;
   MHEG5Link *link;                    /* MHEG link object */
   MHEG5Stream *stream;                /* MHEG stream object associated with 'link' */
   H_DsmEvent eventHandle;   /* DSM-CC stream event subscription handle */
   U_PARAM unique;
} EventInfo;
#endif

/*---local (static) variable declarations for this file----------------------*/

#ifndef CI_PLUS_ONLY
static EventInfo *event_info_list = 0;
static MHEG5Stream *stream_array[MAX_STREAMS] = {
   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
   NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
};
static U32BIT gUniqueIds = 0;
#endif

/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/


#ifndef CI_PLUS_ONLY

static void FreeFromEventList(EventInfo *eventInfo)
{
   EventInfo **pp_EventInfo;

   pp_EventInfo = &event_info_list;
   while (*pp_EventInfo != NULL)
   {
      if (*pp_EventInfo == eventInfo)
      {
         TRACE(TSTRM, (" FREE evtInfo=0x%x evHl=%p", eventInfo, eventInfo->eventHandle))
         if (eventInfo->eventHandle != 0)
         {
            DSMCC_ClientEventUnsubscribe(MHEG5_DsmccInstance(), eventInfo->eventHandle);
         }
         *pp_EventInfo = eventInfo->next;
         MHEG5freeMem(eventInfo);
         break;
      }
      pp_EventInfo = &((*pp_EventInfo)->next);
   }
}

static void StreamEventCallback(S_StreamEvent *param)
{
   EventInfo *eventInfo;

   eventInfo = event_info_list;
   while (eventInfo != NULL)
   {
      if (eventInfo->unique.ptr == param->unique.ptr)
      {
         TRACE(TSTRM|TEVNTS, ("link_id=%d name=%s",
            eventInfo->link->ingredient.root.id, MHEG5linkEventName(eventInfo->link)))

         /****  Append action list for this Asynchronous event ****
          * This by-passes normal Async Queue (used by MHEG5sendEvent), but this is OK since,
          * by definition, async events do not have any particular order.
          * We need to do this, because this function is called for each link that is listening.
          * Using MHEG5sendEvent() would mean that when more than one link is listening on same
          * stream (where at least one link is 'any match'), you would get multiple instances
          * of the one stream event on a link, which would be wrong */
         MHEG5AppendActionList( eventInfo->link->linkEffect );
         break;
      }
      eventInfo = eventInfo->next;
   }
}

static void MHEG5streamEventNotifyCallback(void *info, U8BIT *eventName,
   U32BIT data_len, U8BIT *data_ptr)
{
   MHEG5eventMessage_t event_msg;
   TRACE(TSTRM | TEVNTS, ("name=%s data=(%.*s) id=%u", eventName, (int)data_len, data_ptr, (unsigned int)info))
   event_msg.proc_msg_func = (F_MSG_PROCESS)StreamEventCallback;
   event_msg.data_type = DT_VALUE;
   event_msg.data.streamEvent.unique.ptr = info;
   if (VQ_PutMsg(&event_msg, PRTY_HIGH) != MHERR_OK)
   {
      DBGTRACE(TERROR,"")
   }
}

static void StreamEventSubscribe( MHEG5Link *link, MHEG5Stream *stream )
{
   EventInfo *eventInfo;

   eventInfo = event_info_list;
   while (eventInfo != NULL)
   {
      if (eventInfo->link == link)
      {
         break;
      }
      eventInfo = eventInfo->next;
   }
   if (eventInfo != NULL)
   {
      if (stream->reloading)
      {
         if (DSMCC_ClientEventSubscribeName( MHEG5_DsmccInstance(), stream->dsmRef,
                MHEG5linkEventName(eventInfo->link),
                MHEG5streamEventNotifyCallback,
                eventInfo->unique.ptr, &eventInfo->eventHandle) == FS_STATUS_OK)
         {
            TRACE(TSTRM, ("dsmcc EventSubscribe OK, id=%p evHl=%p", eventInfo->unique.ptr, eventInfo->eventHandle))
         }
         else
         {
            TRACE(TERROR, ("evtInfo=0x%x reloading", eventInfo))
            FreeFromEventList(eventInfo);
         }
      }
   }
   else
   {
      eventInfo = (EventInfo *) MHEG5getMem( sizeof(EventInfo));
      if (!eventInfo)
      {
         TRACE(TERROR, ("unable to allocate memory"));
      }
      else
      {
         eventInfo->eventHandle = 0;
         eventInfo->stream = stream;
         eventInfo->link = link;
         eventInfo->unique.u32 = ++gUniqueIds;

         if (DSMCC_ClientEventSubscribeName( MHEG5_DsmccInstance(), stream->dsmRef,
                MHEG5linkEventName(eventInfo->link),
                MHEG5streamEventNotifyCallback,
                eventInfo->unique.ptr, &eventInfo->eventHandle) == FS_STATUS_OK)
         {
            TRACE(TSTRM, ("dsmcc EventSubscribe OK, id=%p evHl=%p", eventInfo->unique.ptr, eventInfo->eventHandle))
            /* Successful subscription - add to list */
            eventInfo->next = event_info_list;
            event_info_list = eventInfo;
         }
         else
         {
            TRACE(TERROR, ("evtInfo=0x%x", eventInfo))
            MHEG5freeMem(eventInfo);
         }
      }
   }
}

static void SubscribeActive(MHEG5Stream *stream)
{
   MHEG5Link *link;

   /* Find every Link with an interest in this stream */
   link = activeLinksHead[MHEG5STREAMEVENT];
   while (link)
   {
      if ((link->source == stream->ingredient.root.id) &&
          ((stream->ingredient.root.grp == link->sourcegid.ptr.group) ||
           ((link->sourcegid.len != 0) && MHEG5sameGroup(stream->ingredient.root.grp, link->sourcegid))))
      {
         if (stream->dsmRef != 0)
         {
            StreamEventSubscribe( link, stream );
         }
      }
      /* Process the next link in the list */
      link = link->nextActiveLink;
   }
}

static void UnsubscribeActive(MHEG5Stream *stream)
{
   EventInfo *eventInfo;

   /* Unsubscribe from each event with this stream as source */
   eventInfo = event_info_list;
   while (eventInfo != NULL)
   {
      if (eventInfo->stream == stream)
      {
         EventInfo *next = eventInfo->next;
         TRACE(TSTRM, (" FREE evtInfo=0x%x evHl=%p", eventInfo, eventInfo->eventHandle))
         FreeFromEventList(eventInfo);
         eventInfo = next;
      }
      else
      {
         eventInfo = eventInfo->next;
      }
   }
}

static MHEG5Stream* FindEventSource(MHEG5Link *link)
{
   int ndx;
   MHEG5Stream *pStream;
   for (ndx = 0; ndx != MAX_STREAMS; ndx++)
   {
      if (stream_array[ndx] != NULL)
      {
         pStream = stream_array[ndx];
         if (link->source == pStream->ingredient.root.id)
         {
            if ((pStream->ingredient.root.grp == link->sourcegid.ptr.group) ||
                ((link->sourcegid.len != 0) && MHEG5sameGroup(pStream->ingredient.root.grp, link->sourcegid)))
            {
               break;
            }
         }
         pStream = NULL;
      }
   }
   return pStream;
}

static void MHEG5streamClear(MHEG5Stream *stream)
{
   assert( stream );

   if (stream->dsmClearFunc)
   {
      /* Unload stream object */
      stream->dsmClearFunc( stream->dsmRef );
      /* invalidate the references */
      stream->dsmClearFunc = NULL;
      stream->dsmRef = NULL;
   }
}

#endif  /* !CI_PLUS_ONLY */


void MHEG5streamAdd(MHEG5Stream *stream)
{
   #ifndef CI_PLUS_ONLY
   int ndx;
   for (ndx = 0; ndx != MAX_STREAMS; ndx++)
   {
      if (stream_array[ndx] == NULL)
      {
         stream_array[ndx] = stream;
         break;
      }
   }
   assert( ndx != MAX_STREAMS );
   #endif
}

void MHEG5streamRemove(MHEG5Stream *stream)
{
   #ifndef CI_PLUS_ONLY
   int ndx;

   assert( stream );

   /* Unsubscribe from each event with this stream as source */
   UnsubscribeActive(stream);

   for (ndx = 0; ndx != MAX_STREAMS; ndx++)
   {
      if (stream_array[ndx] == stream)
      {
         stream_array[ndx] = NULL;
         break;
      }
   }
   assert( stream->dsmRef == NULL || ndx != MAX_STREAMS );

   MHEG5streamClear( stream );
   #endif
}

void MHEG5streamUnloadAll(void)
{
   #ifndef CI_PLUS_ONLY
   int ndx;
   TRACE(TSTRM, (""))
   for (ndx = 0; ndx != MAX_STREAMS; ndx++)
   {
      if (stream_array[ndx] != NULL)
      {
         TRACE(TSTRM, ("name=%s", stream_array[ndx]->ingredient.content.ref.referenced.reference.data))

         /* Clear the multiplex reference for stream objects. */
         memset(&(stream_array[ndx]->dvbLocator), 0, sizeof(S_DVB_LOCATOR));

         if (stream_array[ndx]->dsmRef)
         {
            stream_array[ndx]->reloading = MHEG5TRUE;
         }
         MHEG5streamClear( stream_array[ndx] );
      }
   }
   #endif
}

void MHEG5streamReloadAll(void)
{
   #ifndef CI_PLUS_ONLY
   int ndx;
   for (ndx = 0; ndx != MAX_STREAMS; ndx++)
   {
      if (stream_array[ndx] != NULL)
      {
         TRACE(TSTRM, ("name=%s", stream_array[ndx]->ingredient.content.ref.referenced.reference.data))
         assert( stream_array[ndx]->dsmRef == NULL );
         if (stream_array[ndx]->ingredient.contentHook == CHOOK_STREAM_NORMAL)
         {
            stream_array[ndx]->reloading = MHEG5TRUE;
            MHEG5ingredientContentPrepare((MHEG5Ingredient *)stream_array[ndx]);
         }
      }
   }
   #endif
}

void MHEG5refreshStreamObject(MHEG5Stream *stream)
{
   #ifndef CI_PLUS_ONLY
   assert(stream);
   /* only get in this function if load was successful */
   if (stream->dsmRef &&
       stream->ingredient.root.runningStatus)
   {
      /* running stream has dsm events */
      SubscribeActive(stream);
   }
   stream->reloading = FALSE;
   #endif
}

void MHEG5notifyStreamRunning(MHEG5Stream *stream)
{
   #ifndef CI_PLUS_ONLY
   assert(stream);
   if (stream->dsmRef)
   {
      /* running stream has dsm events */
      SubscribeActive(stream);
   }
   #endif
}

void MHEG5notifyStreamStopped(MHEG5Stream *stream)
{
   #ifndef CI_PLUS_ONLY
   assert(stream);
   if (stream->dsmRef)
   {
      /* running stream has dsm events */
      UnsubscribeActive(stream);
   }
   #endif
}

void MHEG5notifyLinkActive(MHEG5Link *link)
{
   #ifndef CI_PLUS_ONLY
   MHEG5Stream *stream;

   stream = FindEventSource(link);

   if (stream != NULL)
   {
      TRACE(TSTRM, (" lnk=%d sir=%x, sio=%x", link->ingredient.root.id,
                    stream->ingredient.root.runningStatus, stream->dsmRef))

      if (stream->ingredient.root.runningStatus &&
          stream->dsmRef != 0)
      {
         StreamEventSubscribe( link, stream );
      }
   }
   #endif
}

void MHEG5notifyLinkInactive(MHEG5Link *link)
{
   #ifndef CI_PLUS_ONLY
   EventInfo *eventInfo;

   eventInfo = event_info_list;
   while (eventInfo != NULL)
   {
      if (eventInfo->link == link)
      {
         TRACE(TSTRM, (" FREE evtInfo=0x%x evHl=%p", eventInfo, eventInfo->eventHandle))
         FreeFromEventList(eventInfo);
         break;
      }
      eventInfo = eventInfo->next;
   }
   #endif
}