mh5link.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * 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 "mh5link.h"
#include "mh5memory.h"          /* for constructor  */
#include "mh5object.h"          /* for actions          */
#include "mh5variable.h"        /* for actions          */
#include "mh5streamevent.h"
#include "mh5queue.h"
#include "mh5debug.h"

#ifdef MH5PRINTOUT
#include <string.h>
#endif  /* #ifdef MH5PRINTOUT */

#ifdef TRACING
#include "mh5eventtokens.h"
#endif

/*---constant definitions for this file--------------------------------------*/
#define MAX_REG_STRINGS 32


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

typedef struct s_LinkString
{
   MHEG5String str;
   U16BIT numLinks;
} S_LinkString;

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

/* Linked list of Link objects that are currently active. This list is checked
 * when processing events to see whether any Links fire.
 */
MHEG5Link *activeLinksHead[MHEG5LASTEVENT + 1];
unsigned int existsLinkCount[MHEG5LASTEVENT + 1];

static S_LinkString registeredStrings[MAX_REG_STRINGS];
static int numberRegistered;

static const char htext_top[] = "rec://htext/top";
static const char htext_bot[] = "rec://htext/bot";

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

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

/*
   Debug
 */
#ifdef MH5PRINTOUT

void MHEG5linkPrint(MHEG5Link *link, char *out)
{
   MHEG5ingredientPrint(&link->ingredient, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":EventSource ");
   if (link->sourcegid.len)
   {
      MHEG_PRINT(out, "(");
      MHEG5stringPrint(*((MHEG5String *)&link->sourcegid), out);
      MHEG_PRINT(out, " ");
      MHEG5intPrint(link->source, out);
      MHEG_PRINT(out, ")");
   }
   else
      MHEG5intPrint(link->source, out);
   MHEG5newLine(out);
   MHEG5indent(out);
   MHEG_PRINT(out, ":EventType ");
   MHEG5eventPrint(link->eventType, out);
   MHEG5newLine(out);
   MHEG5indent(out);
   if (link->eventData.type != MHEG5NONE)
   {
      MHEG_PRINT(out, ":EventData ");
      MHEG5genericPrint(link->eventData, out, 0);
      MHEG5newLine(out);
      MHEG5indent(out);
   }
   MHEG_PRINT(out, ":LinkEffect (");
   MHEG5newLine(out);
   MHEG5actionPrint(link->linkEffect, out);
   MHEG5indent(out);
   MHEG_PRINT(out, ")");
   MHEG5newLine(out);
}

#endif

void initialiseActiveLinkQs(void)
{
   int i;
   MHEG5EventType et;
   for (et = MHEG5NONEEVENT; et != (MHEG5LASTEVENT + 1); et++)
   {
      activeLinksHead[et] = 0;
      existsLinkCount[et] = 0;
   }
   /* null string */
   registeredStrings[0].str.len = 0;
   registeredStrings[0].str.data = NULL;
   registeredStrings[0].numLinks = 0;
   /* hypertext top and bottom event strings */
   registeredStrings[HTEXT_TOP_STR].str.len = 15;
   registeredStrings[HTEXT_TOP_STR].str.data = (MHEG5Byte *)htext_top;
   registeredStrings[HTEXT_TOP_STR].numLinks = 0;
   registeredStrings[HTEXT_BOT_STR].str.len = 15;
   registeredStrings[HTEXT_BOT_STR].str.data = (MHEG5Byte *)htext_bot;
   registeredStrings[HTEXT_BOT_STR].numLinks = 0;
   for (i = 3; i != MAX_REG_STRINGS; i++)
   {
      registeredStrings[i].str.len = 0;
      registeredStrings[i].str.data = NULL;
      registeredStrings[i].numLinks = 0;
   }
   numberRegistered = 3;
}

int LNK_RegisterString( MHEG5String s )
{
   int i;
   if (s.len == 0)
   {
      registeredStrings[0].numLinks++;
      return 0;
   }
   for (i = 1; i != MAX_REG_STRINGS; i++)
   {
      if ((registeredStrings[i].str.len == s.len) &&
          (memcmp(registeredStrings[i].str.data, s.data, s.len) == 0))
      {
         MHEG5stringDestruct( &s );
         registeredStrings[i].numLinks++;
         return i;
      }
      else if (registeredStrings[i].str.len == 0)
      {
         if (i == numberRegistered)
         {
            numberRegistered++;
         }
         registeredStrings[i].numLinks = 1;
         registeredStrings[i].str.len = s.len;
         registeredStrings[i].str.data = s.data;
         return i;
      }
   }
   return -1;
}

int LNK_GetStringIndex( MHEG5String s )
{
   int i;
   if (s.len == 0)
   {
      return 0;
   }
   for (i = 1; i != numberRegistered; i++)
   {
      if ((registeredStrings[i].str.len == s.len) &&
          (memcmp(registeredStrings[i].str.data, s.data, s.len) == 0))
      {
         return i;
      }
   }
   return -1;
}

MHEG5String LNK_GetString( int i )
{
   return registeredStrings[i].str;
}

static void LNK_FreeString( MHEG5Int ndx )
{
   int i = numberRegistered - 1;
   if (registeredStrings[ndx].numLinks)
   {
      registeredStrings[ndx].numLinks--;
   }
   if ((ndx > HTEXT_BOT_STR) &&
       registeredStrings[ndx].str.len &&
       !registeredStrings[ndx].numLinks)
   {
      MHEG5stringDestruct( &registeredStrings[ndx].str );
   }
   if (ndx == i)
   {
      while ((i != HTEXT_BOT_STR) && !registeredStrings[i].str.len)
         i--;
      numberRegistered = i + 1;
   }
}

U8BIT* MHEG5linkEventName( MHEG5Link *link )
{
   MHEG5String eventName;
   if (link->eventData.type == (U16BIT)MHEG5INT)
   {
      eventName = LNK_GetString((int)link->eventData.value.i );
   }
   else
   {
      assert( link->eventData.type == (U16BIT)MHEG5NONE );
      eventName.data = NULL;
   }
   return eventName.data;
}

void MHEG5linkInit(MHEG5Link *link)
{
   assert(link);

   MHEG5ingredientInit(&link->ingredient);

   link->eventData.indirect = MHEG5FALSE;
   link->eventData.type = MHEG5NONE;
}

void MHEG5linkFree(MHEG5Link *link)
{
   MHEG5String name;
   assert(link);

   assert( existsLinkCount[link->eventType] > 0 );
   existsLinkCount[link->eventType]--;

   MHEG5ingredientFree(&link->ingredient);

   if (link->eventData.indirect)
   {
      LNK_FreeString( link->eventData.value.i );
   }

   MHEG5actionDestruct(link->linkEffect);

   if (link->sourcegid.len)
   {
      name.len = link->sourcegid.len;
      name.data = link->sourcegid.ptr.name;
      MHEG5stringDestruct( &name );
   }
   //TRACE(TEVNTS,("link %d, src:%d", link->ingredient.root.id,link->source ))
}

/*
     Internal behaviours
 */
/*
     no special Prepare Function
 */
void MHEG5linkPrepare(MHEG5Link *link)
{
   assert(link);

   MHEG5queueResolveTargets( link->linkEffect );

   MHEG5ingredientPrepare(&link->ingredient);
}

/*
     freeMem of Link
 */
void MHEG5linkDestruct(MHEG5Link *link)
{
   assert(link);
   MHEG5ingredientDestruct(&link->ingredient);

   MHEG5queueUnresolveTargets( link->linkEffect );
}

/*
     Activation
     Execute the following sequence of actions:
     1. Apply the Activation behaviour as inherited from the base class.
     2. Make the Link object receptive to events that fulfil its LinkCondition.
     3. Set the RunningStatus of the Link to True.
     4. Generate an IsRunning event.
 */
void MHEG5linkActivate(MHEG5Link *link)
{
   assert(link);

   if (!link->ingredient.root.runningStatus)
   {
      if (!link->ingredient.root.availabilityStatus)
      {
         MHEG5linkPrepare( link );
      }
      /* Could call the base class activation behaviour, but */
      /* MHEG5ingredientActivate(&link->ingredient); <- does nothing, so don't bother */

      link->ingredient.root.runningStatus = MHEG5TRUE;

   #ifdef TRACING
      if (!(mheg_trace_debug & TACTIONS))
      {
         TRACE(TEVNTS, ("link %d, src:%d typ:%s", link->ingredient.root.id, link->source, MHEG5eventToString(link->eventType)))
      }
   #endif

#ifndef NDEBUG
      /* Debug checking whether link is already in the list */
      {
         MHEG5Link *listItem = activeLinksHead[link->eventType];
         while (listItem != 0)
         {
            assert(listItem != link);
            listItem = listItem->nextActiveLink;
         }
      }
#endif

      /* Add this Link to the list of currently active Link objects
       */
      link->nextActiveLink = activeLinksHead[link->eventType];
      activeLinksHead[link->eventType] = link;

      MHEG5sendSync((MHEG5Root *) link, MHEG5ISRUNNING, 0);

      if (link->eventType == MHEG5STREAMEVENT)
      {
         /* Notify stream event manager than the link became active
          */
         MHEG5notifyLinkActive(link);
      }
   }
}

/*
     Deactivation
     Execute the following sequence of actions:
     1. Put the Link object in an inactive state so that it is not receptive to events.
     2. Apply the Deactivation behaviour as inherited from the base class.
 */
void MHEG5linkDeactivate(MHEG5Link *link)
{
   assert(link);

   if (link->ingredient.root.runningStatus)
   {
      if (link->eventType == MHEG5STREAMEVENT)
      {
         /* Notify stream event manager than the link became inactive
          */
         MHEG5notifyLinkInactive(link);
      }

   #ifdef TRACING
      if (!(mheg_trace_debug & TACTIONS))
      {
         TRACE(TEVNTS, ("link %d, src:%d typ:%s", link->ingredient.root.id, link->source, MHEG5eventToString(link->eventType)))
      }
   #endif

      /* Remove this Link from the list of currently active Link objects
       */
      if (activeLinksHead[link->eventType] == link)
      {
         /* This is the first item in the linked list. Remove from
          * the head of the list.
          */
         activeLinksHead[link->eventType] = link->nextActiveLink;
      }
      else
      {
         MHEG5Link *listItem = activeLinksHead[link->eventType];

         if (listItem != 0)
         {
            while (listItem->nextActiveLink != 0)
            {
               if (listItem->nextActiveLink == link)
               {
                  /* Found the Link - route the nextActiveLink pointer
                   * round it.
                   */
                  listItem->nextActiveLink = link->nextActiveLink;
                  break;
               }
               listItem = listItem->nextActiveLink;
            }
         }

         if (listItem == 0)
         {
            /* Didn't find the Link in the active list */
            assert(0);
            ERROR_PRINT(("ERROR: MHEG5linkDeactivate - couldn't find link in active list\n"));
         }
      }

      MHEG5ingredientDeactivate(&link->ingredient);
   }
}

/*
     Actions
 */
/*
     Activate
     Make a Link receptive to events that meet its LinkCondition.
     Execute the following actions:
     1. If the target Link object is active, disregard this action.
     2. If the target Link is inactive, apply the Activation behaviour of the Link object.
 */
MHEG5ErrorCode MHEG5activate(MHEG5Root *target, MHEG5GList *params)
{
   assert(target);

   if (target->clazz != MHEG5LINK)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (!target->runningStatus)
   {
      MHEG5linkActivate((MHEG5Link *) target);
   }

   return MHEG5ERR_NOERROR;
}

/*
     Deactivate
     Make a Link not receptive to events.
     Execute the following actions:
     1. If the target Link object is inactive, disregard this action.
     2. If the target Link is active, apply the Deactivation behaviour of the Link object.

     Provisions of use:
     The Target object shall be an available Link object.
 */
MHEG5ErrorCode MHEG5deactivate(MHEG5Root *target, MHEG5GList *params)
{
   assert(target);

   if (target->clazz != MHEG5LINK)
   {
      return MHEG5ERR_WRONGTARGET;
   }

   if (target->runningStatus)
   {
      MHEG5linkDeactivate((MHEG5Link *) target);
   }

   return MHEG5ERR_NOERROR;
}