mh5queue.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 <string.h>
#include "stb_os.h"
#include "mh5profile.h"
#include "mh5classes.h"
#include "mh5application.h"
#include "mh5eventtokens.h"
#include "mh5actiontokens.h"
#include "glue_memory.h"
#include "mh5object.h"
#include "mh5gate.h"

#include "glue_debug.h"
#include "mh5debug.h"
#include "mh5display.h"
#include "glue_queue.h"
#include "mh5queue.h"

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

#define MHEG5_SYNC_UPDATE 0
/* */
#define MAX_ACTION_LISTS  (1 << 9)
#define ACTION_LIST_MASK  (MAX_ACTION_LISTS - 1)

#define DO_ANY_EVENT          0x0
#define DEFER_ASYNC_EVENTS    0x1
#define SUSPEND_EVENTS        0x2
#define STOP_ALL_EVENTS       0x4

#define SYNC_Q_SIZE           128
#define SHORT_Q_SIZE          8

#define MAX_USER_EVENTS       2

#ifdef TRACING
   #ifdef MH5PRINTOUT
      #define DBGPrintAction(at, t, e, p) if (mheg_trace_debug & TACTIONS) { \
      TraceAction(at, t, e, p); } else { MHEG5PrintAction(t, e, p); }
   #else
      #define DBGPrintAction(at, t, e, p) if (mheg_trace_debug & TACTIONS) { \
      TraceAction(at, t, e, p); }
   #endif
   #define DBGTraceEvent(lk)     if (mheg_trace_debug & (TACTIONS | TEVNTS)) TraceEvent( lk );
   #define DBGTraceToken(lk, t, i) if (mheg_trace_debug & (TACTIONS | TEVNTS)) TraceToken( lk, t, i );
   #define DECLARE_RC   MHEG5ErrorCode rc;
   #define ASSIGN_RC    extra_trace_param = 0; rc =
   #define DBGCheckRC(t, a, p) if (rc != MHEG5ERR_NOERROR) TraceActionError(t, a, p, rc);
#else
   #ifdef MH5PRINTOUT
      #define DBGPrintAction(at, t, e, p) MHEG5PrintAction(t, e, p);
      #define DECLARE_RC
      #define ASSIGN_RC (void)
      #define DBGCheckRC(t, a, p)
   #else
      #ifdef MHEG5LOG
         #define DBGPrintAction(at, t, e, p) printAction(t, e, p);
         #define DECLARE_RC   MHEG5ErrorCode rc;
         #define ASSIGN_RC    rc =
         #define DBGCheckRC(t, a, p) if (rc != MHEG5ERR_NOERROR) printActionError(t, a, p, rc);
     #else
         #define DBGPrintAction(at, t, e, p)
         #define DECLARE_RC
         #define ASSIGN_RC (void)
         #define DBGCheckRC(t, a, p)
      #endif
   #endif
   #define DBGTraceEvent(lk)
   #define DBGTraceToken(lk, t, i)
#endif

#ifdef TRACING
int extra_trace_param;
#endif

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

/* Structure for storing linked list of events. Two seperate queues are
 * maintained, one for asynchronous events and one for synchronous events.
 */
typedef struct sMHEG5EventInfo
{
   MH5GroupPtr e_grp;
   MHEG5Int e_id;
   MHEG5Int e_type;
   MHEG5Int e_data;
#ifdef TRACING
   MHEG5Bool e_clone;
#endif
} S_EventInfo;

typedef struct s_EventQ
{
   struct s_EventQ *next;
   unsigned char hdum;     /*dbg val*/
   unsigned char tail;
   unsigned char tdum;     /*dbg val*/
   unsigned char head;
   S_EventInfo events[256];
} S_EventQueue;

typedef struct s_SyncEventQ
{
   unsigned short size;
   unsigned short slen;
   MHEG5Link *links[SYNC_Q_SIZE];
} S_SyncQueue;

typedef struct s_ShortSyncQ
{
   unsigned short size;
   unsigned short slen;
   MHEG5Link *links[SHORT_Q_SIZE];
} S_ShortSyncQ;

typedef enum
{
   NOTHING,
   EXISTS,
   AVAILABLE,
   RUNNING
} E_RQ_STATUS;

typedef MHEG5ErrorCode (*F_Action)(MHEG5Root *target, MHEG5GList *params);

typedef struct
{
   F_Action func;
   E_RQ_STATUS stat;
} S_Element;

static MHEG5ErrorCode ActionNotSupported(MHEG5Root *target, MHEG5GList *params);
static MHEG5ErrorCode ActionNoProfileSupport(MHEG5Root *target, MHEG5GList *params);
static void MHEG5DeferProcessing(void);
static void CriticalMessageArrived(void);
static void CriticalMessageProcessed(void);

#ifdef MHEG5PROFILE_UK1_06
#define MHEG5toggle              ActionNoProfileSupport
#define MHEG5setLabel            ActionNoProfileSupport
#define MHEG5select              ActionNoProfileSupport
#define MHEG5getSelectionStatus  ActionNoProfileSupport
#define MHEG5getLabel            ActionNoProfileSupport
#define MHEG5deselect            ActionNoProfileSupport
#define MHEG5openConnection      ActionNoProfileSupport
#define MHEG5closeConnection     ActionNoProfileSupport
#endif

/*---local (static) variable declarations for this file----------------------*/
const S_Element element_act[] = {
   {ActionNotSupported, NOTHING   },
   {MHEG5activate, EXISTS    },
   {MHEG5add, RUNNING   },
   {MHEG5addItem, AVAILABLE },
   {MHEG5append, RUNNING   },
   {MHEG5bringToFront, AVAILABLE },
   {MHEG5call, EXISTS    },
   {MHEG5callActionSlot, RUNNING   },
   {MHEG5clear, AVAILABLE },
   {MHEG5clone, AVAILABLE },
   {MHEG5closeConnection, AVAILABLE },
   {MHEG5deactivate, AVAILABLE },
   {MHEG5delItem, AVAILABLE },
   {MHEG5deselect, AVAILABLE },
   {MHEG5deselectItem, AVAILABLE },
   {MHEG5divide, RUNNING   },
   {MHEG5drawArc, AVAILABLE },
   {MHEG5drawLine, AVAILABLE },
   {MHEG5drawOval, AVAILABLE },
   {MHEG5drawPolygon, AVAILABLE },
   {MHEG5drawPolyline, AVAILABLE },
   {MHEG5drawRectangle, AVAILABLE },
   {MHEG5drawSector, AVAILABLE },
   {MHEG5fork, EXISTS    },
   {MHEG5getAvailabilityStatus, EXISTS    },
   {MHEG5getBoxSize, AVAILABLE },
   {MHEG5getCellItem, AVAILABLE },
   {MHEG5getCursorPosition, EXISTS    },
   {MHEG5getEngineSupport, AVAILABLE },
   {MHEG5getEntryPoint, AVAILABLE },
   {MHEG5getFillColour, AVAILABLE },
   {MHEG5getFirstItem, AVAILABLE },
   {MHEG5getHighlightStatus, AVAILABLE },
   {MHEG5getInteractionStatus, AVAILABLE },
   {MHEG5getItemStatus, AVAILABLE },
   {MHEG5getLabel, EXISTS    },
   {MHEG5getLastAnchorFired, AVAILABLE },
   {MHEG5getLineColour, AVAILABLE },
   {MHEG5getLineStyle, AVAILABLE },
   {MHEG5getLineWidth, AVAILABLE },
   {MHEG5getListItem, AVAILABLE },
   {MHEG5getListSize, AVAILABLE },
   {MHEG5getOverwriteMode, AVAILABLE },
   {MHEG5getPortion, AVAILABLE },
   {MHEG5getPosition, AVAILABLE },
   {MHEG5getRunningStatus, AVAILABLE },
   {MHEG5getSelectionStatus, AVAILABLE },
   {MHEG5getSliderValue, AVAILABLE },
   {MHEG5getTextContent, AVAILABLE },
   {MHEG5getTextData, AVAILABLE },
   {MHEG5getTokenPosition, AVAILABLE },
   {MHEG5getVolume, AVAILABLE },
   {MHEG5launch, NOTHING  },
   {MHEG5lockScreen, EXISTS    },
   {MHEG5modulo, RUNNING   },
   {MHEG5move, AVAILABLE },
   {MHEG5moveTo, AVAILABLE },
   {MHEG5multiply, RUNNING   },
   {MHEG5openConnection, AVAILABLE },
   {MHEG5preload, EXISTS    },
   {MHEG5putBefore, AVAILABLE },
   {MHEG5putBehind, AVAILABLE },
   {MHEG5quit, EXISTS    },
   {MHEG5readPersistent, AVAILABLE },
   {MHEG5run, EXISTS    },
   {MHEG5scaleBitmap, AVAILABLE },
   {MHEG5scaleVideo, AVAILABLE },
   {MHEG5scrollItems, AVAILABLE },
   {MHEG5select, AVAILABLE },
   {MHEG5selectItem, AVAILABLE },
   {MHEG5sendEventAction, EXISTS    },
   {MHEG5sendToBack, AVAILABLE },
   {MHEG5setBoxSize, AVAILABLE },
   {MHEG5setCachePriority, AVAILABLE },
   {MHEG5setCounterEndPosition, AVAILABLE },
   {MHEG5setCounterPosition, AVAILABLE },
   {MHEG5setCounterTrigger, AVAILABLE },
   {MHEG5setCursorPosition, EXISTS    },
   {MHEG5setCursorShape, EXISTS    },
   {MHEG5setData, AVAILABLE },
   {MHEG5setEntryPoint, AVAILABLE },
   {MHEG5setFillColour, AVAILABLE },
   {MHEG5setFirstItem, AVAILABLE },
   {MHEG5setFontRef, AVAILABLE },
   {MHEG5setHighlightStatus, AVAILABLE },
   {MHEG5setInteractionStatus, RUNNING   },
   {MHEG5setLabel, AVAILABLE },
   {MHEG5setLineColour, AVAILABLE },
   {MHEG5setLineStyle, AVAILABLE },
   {MHEG5setLineWidth, AVAILABLE },
   {MHEG5setOverwriteMode, AVAILABLE },
   {MHEG5setPaletteRef, AVAILABLE },
   {MHEG5setPortion, AVAILABLE },
   {MHEG5setPosition, AVAILABLE },
   {MHEG5setSliderValue, AVAILABLE },
   {MHEG5setSpeed, AVAILABLE },
   {MHEG5setTimer, EXISTS    },
   {MHEG5setTransparency, AVAILABLE },
   {MHEG5setVariable, RUNNING   },
   {MHEG5setVolume, AVAILABLE },
   {MHEG5spawn, NOTHING   },
   {MHEG5step, AVAILABLE },
   {MHEG5stop, AVAILABLE },
   {MHEG5storePersistent, AVAILABLE },
   {MHEG5subtract, RUNNING   },
   {MHEG5testVariable, RUNNING   },
   {MHEG5toggle, AVAILABLE },
   {MHEG5toggleItem, AVAILABLE },
   {MHEG5transitionTo, NOTHING   },
   {MHEG5unload, AVAILABLE },
   {MHEG5unlockScreen, EXISTS    },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {ActionNotSupported, NOTHING   },
   {MHEG5setBackgroundColour, AVAILABLE },
   {MHEG5setCellPosition, AVAILABLE },
   {MHEG5setInputRegister, EXISTS    },
   {MHEG5setTextColour, AVAILABLE },
   {MHEG5setFontAttributes, AVAILABLE },
   {MHEG5setVideoDecodeOffset, AVAILABLE },
   {MHEG5getVideoDecodeOffset, EXISTS    },
   {MHEG5getFocusPosition, AVAILABLE },
   {MHEG5setFocusPosition, AVAILABLE },
   {MHEG5setBitmapDecodeOffset, AVAILABLE },
   {MHEG5getBitmapDecodeOffset, EXISTS    },
   {MHEG5setSliderParameters, AVAILABLE },
   {ActionNotSupported, NOTHING   },
   {MHEG5setDesktopColour, AVAILABLE },
   {MHEG5getCounterPosition, AVAILABLE },
   {MHEG5getCounterMaxPosition, AVAILABLE },
   {ActionNotSupported, NOTHING   },
   {MHEG5setInputMask, AVAILABLE }
};

/* Rule: Tails NEVER have stuff in that action list, but Heads can */
static MHEG5ActionList mainActionLists[MAX_ACTION_LISTS];
static unsigned int mainActionListHead = 0;
static unsigned int mainActionListTail = 0;
static MHEG5ActionList *action_list_ptr = NULL;

/* Queue for asynchronous events (external events) */
static S_EventQueue *frst_a_queue = NULL;
static S_EventQueue *last_a_queue = NULL;

/* Current investigation has shown that maximum SYNC QUEUE size (and required temp Q size) is 11
 * for DTG test suite 3.0.2 - test 3.13.3 Sync Events 3 - so can assume it's less than 256! */
/* Queue for synchronous events (events generated by actions) */
static S_SyncQueue *the_sync_q = NULL;

/* Flag to indicate whether events should be queued or discarded */
static MHEG5Bool queueEvents = MHEG5TRUE;

static int processing_state = DO_ANY_EVENT;
static void *state_mutex = NULL;
static void *queue_notify_hdl = NULL;

/* Maintain a count of how many times event processing has been disabled. If
 * this count is greater than 0, processing_state flag will be clear of the SUSPEND_EVENTS bit
 */
static int eventProcessingDisableCount = 0;
static int critical_msg_count = 0;

/* Flag to indicate whether a display update was requested */
static MHEG5Bool displayUpdateRequested = MHEG5FALSE;

/* Counter for user input events - too many user input events can cause
 * long delays and user confusion.
 */
static MHEG5Int userInputEventCount = 0;

/*******************
 * GLOBAL DATA      *
 ********************/

#if defined(MH5PRINTOUT) || defined(TRACING)
int event_indent_num = 0;
#endif


/***********************
 * FUNCTION DEFINITIONS *
 ************************/

MHEG5ErrorCode ActionNotSupported(MHEG5Root *target, MHEG5GList *params)
{
   USE_UNWANTED_PARAM(target);
   USE_UNWANTED_PARAM(params);
   return MHEG5ERR_NOTYETSUPPORTED;
}

MHEG5ErrorCode ActionNoProfileSupport(MHEG5Root *target, MHEG5GList *params)
{
   USE_UNWANTED_PARAM(target);
   USE_UNWANTED_PARAM(params);
   return MHEG5ERR_NOTSUPPORTEDBYPROFILE;
}

/*******************************************************************************
 ********************* Debug/Tracing/Logging functions *************************
 *******************************************************************************/

#ifdef MH5PRINTOUT

void MHEG5queuePrint(char *out)
{
   S_EventQueue *a_queue = frst_a_queue;
   U8BIT tail;

   MHEG_PRINT(out, "Asynchronous event queue:");
   MHEG5newLine(out);
   while (a_queue)
   {
      tail = a_queue->tail;
      while (tail != a_queue->head)
      {
         MHEG_PRINT(out, "Event from (");
         MHEG5stringPrint(a_queue->events[tail].e_grp->groupName, out);
         MHEG_PRINT(out, " ");
         MHEG5intPrint(a_queue->events[tail].e_id, out);
         MHEG_PRINT(out, ") ");
         MHEG5eventPrint((MHEG5EventType)a_queue->events[tail].e_type, out);
         MHEG5intPrint(a_queue->events[tail].e_data, out);
         MHEG5newLine(out);
         tail++;
      }
      a_queue = a_queue->next;
   }
   MHEG_PRINT(out, "Synchronous event queue:");
   MHEG5newLine(out);
   if (the_sync_q)
   {
      for (tail = 0; tail != the_sync_q->slen; tail++)
      {
         MHEG_PRINT(out, "Event from (");
         MHEG5stringPrint(the_sync_q->links[tail]->ingredient.root.grp->groupName, out);
         MHEG_PRINT(out, " ");
         MHEG5intPrint(the_sync_q->links[tail]->ingredient.root.id, out);
         MHEG_PRINT(out, ") ");
         MHEG5eventPrint(the_sync_q->links[tail]->eventType, out);
         MHEG5intPrint(the_sync_q->links[tail]->eventData.value.i, out);
         MHEG5newLine(out);
      }
   }
}

extern int mheg_trace_source;

void MHEG5PrintEvent(MHEG5EventType e, MHEG5Int id)
{
   int ind;
   char buff[256];
   if (mheg_trace_source & 2)
   {
      ind = (event_indent_num << 1) % MAX_EVENT_INDENT;

      buff[ind + 1] = 0;
      while (ind != 0)
      {
         buff[ind] = ' ';
         ind--;
      }
      buff[0] = '\n';
      strcat(buff, MHEG5eventToString(e));
      strcat(buff, " ");
      printf(buff);
      MHEG5intPrint(id, buff);
   }
}

#endif /*MH5PRINTOUT*/

#ifdef TRACING
static void TraceEvent( MHEG5Link *link )
{
   MHEG5Group *grp_ptr;
   int ind;
   char buff[160];

   ind = (event_indent_num << 1) % MAX_EVENT_INDENT;

   buff[ind + 1] = 0;
   while (ind != 0)
   {
      buff[ind] = ' ';
      ind--;
   }
   buff[0] = '\n';
   DBG_PRINTF( buff );
   DBG_PRINTF( MHEG5eventToString(link->eventType));
   grp_ptr = link->ingredient.root.grp;
   DBG_PRINTF(" link: %c%ld ", (grp_ptr->root.clazz == MHEG5SCENE) ? 'S' : 'A', link->ingredient.root.id );
   grp_ptr = (MHEG5Group *)MHEG5getCurrentApplication();
   assert( grp_ptr );
   if ((grp_ptr == link->sourcegid.ptr.group) ||
       ((link->sourcegid.len != 0) && MHEG5sameGroup(grp_ptr, link->sourcegid)))
   {
      DBG_PRINTF(" src: A%ld", link->source );
   }
   else
   {
      DBG_PRINTF(" src: S%ld", link->source );
   }
   if (link->eventData.type == MHEG5INT)
   {
      DBG_PRINTF(" data: %ld", link->eventData.value.i );
   }
   else if (link->eventData.type == MHEG5BOOL)
   {
      if (link->eventData.value.b)
      {
         DBG_PRINTF(" data: TRUE" );
      }
      else
      {
         DBG_PRINTF(" data: FALSE" );
      }
   }
}

static void TraceAction(MHEG5Root *at, MHEG5Root *t, MHEG5ElemActionType a, MHEG5GList *l)
{
   int ind;
   char buff[224];
   char tmp[32];

   if (t == NULL)
   {
      return;
   }

   ind = (event_indent_num << 1) % MAX_EVENT_INDENT;

   buff[ind + 1] = 0;
   while (ind != 0)
   {
      buff[ind] = ' ';
      ind--;
   }
   buff[0] = '\n';
   DBG_PRINTF(buff);
   DBG_PRINTF(MHEG5actionToString(a));
   strcpy(buff, "( ");
   if (at != NULL)
   {
      if (t == at)
      {
         sprintf(tmp, "%c%ld ", (at->grp->root.clazz == MHEG5SCENE) ? 'S' : 'A', at->id);
         strcat(buff, tmp);
      }
      else
      {
         sprintf(tmp, "%c%ld->%c%ld ", (at->grp->root.clazz == MHEG5SCENE) ? 'S' : 'A', at->id,
            (t->grp->root.clazz == MHEG5SCENE) ? 'S' : 'A', t->id );
         strcat(buff, tmp);
      }
   }
   while (l)
   {
      switch (l->generic.type)
      {
         case MHEG5NONE:
            strcat(buff, "?");
            break;
         case MHEG5INT:
            assert( !l->generic.indirect );
            sprintf(tmp, "%ld", l->generic.value.i);
            strcat(buff, tmp);
            break;
         case MHEG5BOOL:
            if (l->generic.value.b)
            {
               strcat(buff, "true");
            }
            else
            {
               strcat(buff, "false");
            }
            break;
         case MHEG5NULL:
            break;
         case MHEG5CONTENTREF:
            strcat(buff, "CR:");
         /* fallthrough */

         case MHEG5OCTETSTRING:
            assert( !l->generic.indirect );
            MHEG5stringTrace(l->generic.value.s, buff, 0, 100);
            break;
         case MHEG5BRACKETOPEN:
            strcat(buff, "(");
            break;
         case MHEG5BRACKETCLOSE:
            strcat(buff, ")");
            break;
         case MHEG5EVENT:
            strcat(buff, MHEG5eventToString(l->generic.value.e));
            break;
         case MHEG5INTPAIR:
            sprintf(tmp, "%ld,", l->generic.value.p.x);
            strcat(buff, tmp);
            sprintf(tmp, "%ld", l->generic.value.p.y);
            strcat(buff, tmp);
            break;
         case MHEG5OBJREFEXT:
         case MHEG5OBJECTREF:
            at = MHEG5findObject(l->generic.value.o.gref, l->generic.value.o.id);
            if (at == NULL)
            {
               strcat(buff, "UNKNOWN:");
               if (l->generic.value.o.gref.len)
               {
                  strcat(buff, "(");
                  MHEG5stringTrace( *((MHEG5String *)&l->generic.value.o.gref), buff, 0, 100 );
                  sprintf(tmp, " %ld)", l->generic.value.o.id);
               }
               else
               {
                  sprintf(tmp, "%ld", l->generic.value.o.id);
               }
               strcat(buff, tmp);
            }
            else
            {
               sprintf(tmp, "%c%ld", (at->grp->root.clazz == MHEG5SCENE) ? 'S' : 'A', at->id);
               strcat(buff, tmp);
               if (l->generic.indirect && at->clazz == MHEG5OBJECTREFVARIABLE)
               {
                  t = MHEG5resolveRealObject( at );
                  if (t == NULL)
                  {
                     strcat(buff, "->BAD");
                  }
                  else
                  {
                     sprintf(tmp, "->%c%ld", (t->grp->root.clazz == MHEG5SCENE) ? 'S' : 'A', t->id );
                     strcat(buff, tmp);
                  }
               }
            }
            break;
         default:
            strcat(buff, "// :InternalError ");
            break;
      }
      strcat(buff, " ");
      if (strlen(buff) > 196)
      {
         DBG_PRINTF(buff);
         buff[0] = 0;
      }
      l = l->next;
   }
   strcat(buff, ")");
   DBG_PRINTF(buff);
}

static void TraceActionError( MHEG5Root *target, MHEG5ElemActionType type,
   MHEG5GList *firstParam, MHEG5ErrorCode rc )
{
   int id;
   id = (target) ? target->id : -1;
   if (mheg_trace_debug & TACTIONS)
   {
      DBG_PRINTF("\n");
   }
   switch (rc)
   {
      case MHEG5ERR_NOTYETSUPPORTED:
         TRACE(TERROR, ("%s(%d) not supported", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_NOTSUPPORTEDBYPROFILE:
         if (extra_trace_param != 0)
         {
            TRACE(TERROR, ("%s(%d) \"%s\" not supported by profile", MHEG5actionToString(type), id, (char *)extra_trace_param))
         }
         else
         {
            TRACE(TERROR, ("%s(%d) not supported by profile", MHEG5actionToString(type), id))
         }
         break;
      case MHEG5ERR_WRONGNUMBEROFPARAMS:
         TRACE(TERROR, ("%s(%d) had wrong number of params", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_TARGETNOTAVAILABLE:
         if (id == -1)
         {
            TRACE(TERROR, ("%s - target object does not exist", MHEG5actionToString(type)))
         }
         else
         {
            /*TRACE(TERROR,("%s(%d) target object is not available",MHEG5actionToString(type), id ))*/
         }
         break;
      case MHEG5ERR_WRONGTARGET:
         TRACE(TERROR, ("%s(%d) - wrong type of target object", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE:
         TRACE(TERROR, ("%s(%d) - param not available", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_WRONGPARAM:
         TRACE(TERROR, ("%s(%d) - wrong type of param", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_PARAMNOTACTIVE:
         TRACE(TERROR, ("%s(%d) - one param is not active", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_NOSCENE:
         TRACE(TERROR, ("%s(%d) - missing current scene", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_TARGETNOTACTIVE:
         TRACE(TERROR, ("%s(%d) - target not active", MHEG5actionToString(type), id))
         break;
      case MHEG5ERR_NOSUCHITEM:
         TRACE(TERROR, ("%s(%d) - no such tokengroup item %d", MHEG5actionToString(type), id, extra_trace_param >> 16))
         break;
      case MHEG5ERR_NOSUCHSLOT:
         TRACE(TERROR, ("%s(%d) - no slot for token position %d, slot %d", MHEG5actionToString(type), id, extra_trace_param >> 16, extra_trace_param & 0xffff))
         break;
      default:
         break;
   }
}

#endif /*TRACING*/

#ifdef MHEG5LOG

static void printEvent(S_EventInfo *eventItem)
{
   char eventName[30];
   char generic[16];

   eventName[0] = '\0';
   generic[0] = '\0';
   MHEG5eventPrint((MHEG5EventType)eventItem->e_type, eventName);
   MHEG5intPrint(eventItem->e_data, generic);
   DEBUG_PRINT(("INFO: Testing event source ( %d ), type %s, data %s\n", eventItem->e_id, eventName, generic));
}

static void printAction(MHEG5Root *t, MHEG5ElemActionType type,
   MHEG5GList *firstParam)
{
   MHEG5GList *paramList;
   char buf[2000];

   MHEG5LogPrintf(MHEG5MESSAGE, "ElementaryAction ");
   MHEG5LogPrintAction(MHEG5MESSAGE, type );
   MHEG5LogPrintf(MHEG5MESSAGE, " from object ");
   MHEG5LogPrintObjectRef(MHEG5MESSAGE, t->grp, 0);
   MHEG5LogPrintf(MHEG5MESSAGE, " - ");

   paramList = firstParam;

   do
   {
      buf[0] = '\0';
      MHEG5genericPrint(paramList->generic, buf, 0);
      MHEG5LogPrintf(MHEG5MESSAGE, "%s ", buf);
      paramList++;
   }
   while (!paramList->generic.isfirst);

   MHEG5LogPrintf(MHEG5MESSAGE, "\n");
}

static void printActionError( MHEG5Root *target, MHEG5ElemActionType type,
   MHEG5GList *firstParam, MHEG5ErrorCode rc )
{
   MHEG5LogPrintf(MHEG5WARNING, "ERROR: ElementaryAction ");
   MHEG5LogPrintAction(MHEG5WARNING, type );
   MHEG5LogPrintf(MHEG5WARNING, " from object ");
   MHEG5LogPrintObjectRef(MHEG5WARNING, target->grp, 0);
   MHEG5LogPrintf(MHEG5WARNING, " - ");
   if (target)
   {
      MHEG5LogPrintf(MHEG5WARNING, " target ID %d - ", target->id);
   }
   else
   {
      MHEG5LogPrintf(MHEG5WARNING, " No target specified");
   }
   switch (rc)
   {
      case MHEG5ERR_NOTYETSUPPORTED:
         MHEG5LogPrintf(MHEG5WARNING, "action not supported by this engine");
         break;
      case MHEG5ERR_NOTSUPPORTEDBYPROFILE:
         MHEG5LogPrintf(MHEG5WARNING, "action not supported by profile %s", MHEG5PROFILEID);
         break;
      case MHEG5ERR_WRONGNUMBEROFPARAMS:
         MHEG5LogPrintf(MHEG5WARNING, "wrong number of params given");
         break;
      case MHEG5ERR_TARGETNOTAVAILABLE:
         MHEG5LogPrintf(MHEG5WARNING, "target object is not available");
         break;
      case MHEG5ERR_WRONGTARGET:
         MHEG5LogPrintf(MHEG5WARNING, "wrong type of target object");
         break;
      case MHEG5ERR_REFERENCEDPARAMNOTAVAILABLE:
         MHEG5LogPrintf(MHEG5WARNING, "param not available");
         break;
      case MHEG5ERR_WRONGPARAM:
         MHEG5LogPrintf(MHEG5WARNING, "wrong type of param");
         break;
      case MHEG5ERR_PARAMNOTACTIVE:
         MHEG5LogPrintf(MHEG5WARNING, " action aborted because one param is not active");
         break;
      case MHEG5ERR_NOSCENE:
         MHEG5LogPrintf(MHEG5WARNING, " action aborted because of missing current scene");
         break;
      case MHEG5ERR_TARGETNOTACTIVE:
         MHEG5LogPrintf(MHEG5WARNING, " action aborted because target not active");
         break;
      case MHEG5ERR_NOSUCHITEM:
         MHEG5LogPrintf(MHEG5WARNING, " action aborted because no such tokengroup item");
         break;
      case MHEG5ERR_NOSUCHSLOT:
         MHEG5LogPrintf(MHEG5WARNING, " action aborted - no action slot found");
         break;
      default:
         break;
   }
   MHEG5LogPrintf(MHEG5WARNING, "\n");
}

#endif /*MHEG5LOG*/



/*******************************************************************************
 ***************** The REAL functions for Event/Action Queues ******************
 *******************************************************************************/

int MHEG5InitQueues(void)
{
   int rtn = 1;
   frst_a_queue = (S_EventQueue *)MHEG5getMem( sizeof(S_EventQueue));
   if (frst_a_queue != NULL)
   {
      the_sync_q = (S_SyncQueue *)MHEG5getMem( sizeof(S_SyncQueue));
      if (the_sync_q != NULL)
      {
         state_mutex = STB_OSCreateMutex();
         TRACE(TKEYS, ("state_mutex=%d", state_mutex))
         if (state_mutex != NULL)
         {
            initialiseActiveLinkQs();

            queue_notify_hdl = VQ_RegisterNotify( MHEG5DeferProcessing,
                  CriticalMessageArrived, CriticalMessageProcessed );

            frst_a_queue->next = NULL;
            frst_a_queue->tail = 0;
            frst_a_queue->head = 0;
            last_a_queue = frst_a_queue;

            the_sync_q->size = SYNC_Q_SIZE;
            the_sync_q->slen = 0;
         }
         else
         {
            MHEG5freeMem(frst_a_queue);
            MHEG5freeMem(the_sync_q);
            frst_a_queue = 0;
            the_sync_q = 0;
            rtn = 0;
         }
      }
      else
      {
         MHEG5freeMem(frst_a_queue);
         frst_a_queue = 0;
         rtn = 0;
      }
   }
   else
   {
      rtn = 0;
   }
   return rtn;
}

void MHEG5stopEventsAndResetQueue( void )
{
   S_EventQueue *e_q, *n_q;
   unsigned int i;

   /* Stop receiving any more events () */
   queueEvents = MHEG5FALSE;

   /* An Application Launch or Spawn constitutes a context change, as defined
    * in section 53.3 of ISO/IEC13522-5. This causes pending elementary actions
    * and events to be destroyed.
    */
   DEBUG_PRINT(("INFO: MHEG5queueReset clearing event and action queues\n"));
   TRACE(TEVNTS, ("*************** QUEUE RESET *****************\n"))
   e_q = frst_a_queue->next;
   while (e_q)
   {
      n_q = e_q->next;
      MHEG5freeMem( e_q );
      e_q = n_q;
   }
   frst_a_queue->tail = frst_a_queue->head;
   frst_a_queue->next = 0;
   last_a_queue = frst_a_queue;

   assert( the_sync_q->size == SYNC_Q_SIZE );
   the_sync_q->slen = 0;

   i = mainActionListHead;
   while (i != mainActionListTail)
   {
      mainActionLists[i].a_ptr = NULL;
      mainActionLists[i].total = 0;
   #if defined(MH5PRINTOUT) || defined(TRACING)
      mainActionLists[i].indent = 0;
   #endif
      i++;
      i &= ACTION_LIST_MASK;
   }

   userInputEventCount = 0;
}

void MHEG5queueResetScene( MHEG5Root *grp )
{
   S_EventQueue *e_q;
   U8BIT t;
   unsigned int i;

   e_q = frst_a_queue;

   TRACE(TEVNTS, ("**** Scene=%p, e_q->tail=0x%x, e_q->head=0x%x ****\n", grp, e_q->tail, e_q->head))

   do
   {
      for (t = e_q->tail; t != e_q->head; t++)
      {
         if (e_q->events[t].e_grp == (MHEG5Group *)grp)
         {
            e_q->events[t].e_grp = NULL;
            e_q->events[t].e_id = 0;
            e_q->events[t].e_type = MHEG5NONEEVENT;
         }
      }
      e_q = e_q->next;
   }
   while (e_q);

   assert( the_sync_q->size == SYNC_Q_SIZE );
   the_sync_q->slen = 0;
   i = mainActionListHead;
   while (i != mainActionListTail)
   {
      mainActionLists[i].a_ptr = NULL;
      mainActionLists[i].total = 0;
   #if defined(MH5PRINTOUT) || defined(TRACING)
      mainActionLists[i].indent = 0;
   #endif

      i++;
      i &= ACTION_LIST_MASK;
   }

   userInputEventCount = 0;
}

void MHEG5ExitQueues(void)
{
   if (frst_a_queue != NULL)
   {
      MHEG5freeMem(frst_a_queue);
      frst_a_queue = NULL;
   }
   if (the_sync_q != NULL)
   {
      MHEG5freeMem(the_sync_q);
      the_sync_q = NULL;
   }
   if (state_mutex != NULL)
   {
      STB_OSDeleteMutex( state_mutex );
      state_mutex = NULL;
   }

   if (queue_notify_hdl != NULL)
   {
      VQ_UnRegisterNotify(queue_notify_hdl);
      queue_notify_hdl = NULL;
   }

   userInputEventCount = 0;
}

void MHEG5AppendActionList( MHEG5ActionList actions )
{
   unsigned int newTail = (mainActionListTail + 1) & ACTION_LIST_MASK;

   if (newTail == mainActionListHead)
   {
      /* Serious as when a malloc fails - no memory! */
      TRACE(TERROR, ("Eeek! MainActionLists is FULL"))
   }
   else
   {
      /* Store the group of the action source */
      /* Store the new actions on the queue */
      mainActionLists[mainActionListTail] = actions;
    #if defined(MH5PRINTOUT) || defined(TRACING)
      mainActionLists[mainActionListTail].indent = 1;
    #endif
      mainActionListTail = newTail;
   }
}

static void doAsyncEvent( S_EventInfo *eventItem )
{
   MHEG5Link *link;
   int cnt = 0;

   /* Get pointer to the list of active Link objects */
   link = activeLinksHead[eventItem->e_type];

   if (eventItem->e_type == MHEG5USERINPUT)
   {
   #ifdef TRACING
      TRACE(TKEYS, (": User Input, Edata=%d", eventItem->e_data))
   #endif
      userInputEventCount--;
   }

#if defined(MH5PRINTOUT) || defined(TRACING)
   event_indent_num = 0;
#endif

   /* Repeat for each active Link object for this event type */
   while (link)
   {
      /* We can only get here coz there are active links for this event,
       * and e_grp is only NULL when e_type is a NONEVENT so we assert ... */
      assert( eventItem->e_grp != NULL );

      #ifdef _WINDOWS
      assert((unsigned int)eventItem->e_grp != 0xfeeefeee);
      #endif
      /* Check whether source ID matches */
      if (link->source == eventItem->e_id)
      {
         #ifdef TRACING
         assert( !eventItem->e_clone );
         #endif
         /* Check whether event data matches */
         if ((link->eventData.type == MHEG5NONE) ||
             ((link->eventData.type == MHEG5INT) && (link->eventData.value.i == eventItem->e_data)) ||
             ((link->eventData.type == MHEG5BOOL) && (link->eventData.value.b == eventItem->e_data)))
         {
            /* Check whether source GID matches */
            if ((eventItem->e_grp == link->sourcegid.ptr.group) ||
                ((link->sourcegid.len != 0) && MHEG5sameGroup(eventItem->e_grp, link->sourcegid)))
            {
               /* This Link Fires ! */
               if (cnt != 0)
               {
                  TRACE(TERROR, ("more than one link (%d) fires: Link %ld", cnt, link->ingredient.root.id))
               }
               cnt++;
               #ifdef MH5PRINTOUT
               MHEG5PrintEvent(eventItem->e_type, eventItem->e_id);
               #endif

               DBGTraceEvent( link );

               MHEG5AppendActionList( link->linkEffect );
            }
         }
      }
      /* Process the next link in the list */
      link = link->nextActiveLink;
   }
}

static void processSyncEvents(void)
{
   MHEG5Link **pLinks = the_sync_q->links + the_sync_q->slen;
   //TRACE(TEVNTS,("events=%d",the_sync_q->slen))
   do
   {
      pLinks--;
      mainActionListHead--;
      mainActionListHead &= ACTION_LIST_MASK;
      if (mainActionListHead == mainActionListTail)
      {
         /* Head has reached the tail, Get here in test 3.11C scene 2 */

         /* Note: setting ENABLE_RED_KEY_IN_3_11C may allow async events
          * to be processed before continuing with sync events
          * which would not be strictly correct according to 3.13.3 */
       #ifndef ENABLE_RED_KEY_IN_3_11C
         /* Try to recover some space in mainActionLists */
         do
         {
            mainActionListHead++;
            mainActionListHead &= ACTION_LIST_MASK;
         }
         while (mainActionListHead != mainActionListTail &&
                mainActionLists[mainActionListHead].total == 0);
         mainActionListHead--;
         mainActionListHead &= ACTION_LIST_MASK;
         if (mainActionListHead == mainActionListTail)
      #endif 
         {
            TRACE(TERROR, ("Eeek! Head reached tail"))
            mainActionListHead++;
            mainActionListHead &= ACTION_LIST_MASK;
            break;
         }
      }
      /*TRACE(TEVNTVERB,("link effect for %ld",(*pLinks)->ingredient.root.id))*/
      mainActionLists[mainActionListHead] = (*pLinks)->linkEffect;
   #if defined(MH5PRINTOUT) || defined(TRACING)
      mainActionLists[mainActionListHead].indent = event_indent_num + 1;
   #endif
      the_sync_q->slen--;
   }
   while (the_sync_q->slen);
}

void MHEG5queueResolveTargets( MHEG5ActionList actions )
{
   MHEG5GList *params;
   while (actions.total)
   {
      if (element_act[(int)actions.a_ptr->type].stat != NOTHING &&
          actions.a_ptr->target == NULL)
      {
         params = actions.a_ptr->firstParam;
         actions.a_ptr->targetIsIndirect = params->generic.indirect;
         actions.a_ptr->firstParam = MHEG5resolveORef( params, &actions.a_ptr->target );
      }
      actions.a_ptr++;
      actions.total--;
   }
}

void MHEG5queueUnresolveTargets( MHEG5ActionList actions )
{
   while (actions.total)
   {
      actions.a_ptr->firstParam = actions.a_ptr->origFirstParam;
      actions.a_ptr->target = NULL;
      actions.a_ptr++;
      actions.total--;
   }
}

static void processActions(void)
{
   MHEG5Root *target;
   MHEG5Action *action;
   E_RQ_STATUS rq_stat;
   DECLARE_RC

   /* While there are actions in the queue and event processing is enabled */
   while (mainActionListHead != mainActionListTail)
   {
      while (mainActionLists[mainActionListHead].total != 0)
      {
         /* take action off list */
         action = mainActionLists[mainActionListHead].a_ptr;
         mainActionLists[mainActionListHead].a_ptr++;
         mainActionLists[mainActionListHead].total--;
      #if defined(MH5PRINTOUT) || defined(TRACING)
         event_indent_num = mainActionLists[mainActionListHead].indent;
      #endif

         #ifdef DEBUG_ACTION_ENUMS
         assert( action->magic == ACTION_MAGIC_VAL );
         #endif
         assert( action->type > MHEG5NONEACTION );
         assert( action->type < ACTION_LAST );

         /* Execute the action. This may place new synchronous events onto the synchronous event queue */
         rq_stat = element_act[(int)action->type].stat;
         if (rq_stat == NOTHING)
         {
            target = NULL;
         }
         else
         {
            target = action->target;
            if (action->targetIsIndirect && target != NULL)
            {
               target = MHEG5resolveRealObject( target );
            }
            if (target != NULL)
            {
               switch (rq_stat)
               {
                  case RUNNING:
                     if (!target->runningStatus)
                     {
                        break;
                     }
                  case AVAILABLE:
                     if (!target->availabilityStatus)
                     {
                        break;
                     }
                  default:
                  case EXISTS:
                     rq_stat = NOTHING;
                     break;
               }
            }
         }
         if (rq_stat == NOTHING)
         {
            DBGPrintAction( action->target, target, action->type, action->firstParam )

            /* Call the function that implements this action */
            ASSIGN_RC element_act[(int)action->type].func( target, action->firstParam );

            DBGCheckRC( target, action->type, action->firstParam )
         }

         if (displayUpdateRequested)
         {
            /* This action requests an immediate screen update */
            MHEG5displayUpdate();
            displayUpdateRequested = MHEG5FALSE;
         }

         /* Process any synchronous events that have been raised as a result of
          * executing this action. And prepend actions to main queue */
         if (the_sync_q->slen)
         {
            processSyncEvents();
         }

         if (processing_state > DEFER_ASYNC_EVENTS)
         {
            /* suspend queue processing */
            return;
         }
      }
      assert( mainActionLists[mainActionListHead].total == 0 );
      mainActionListHead++;
      mainActionListHead &= ACTION_LIST_MASK;
   }
   /* Update the on screen display to reflect the changes caused by any of the
    * actions we just executed.
    */
   MHEG5displayUnlockStreams();
   MHEG5displayUpdate();
   displayUpdateRequested = MHEG5FALSE;
}

void MHEG5processQueue(void)
{
   S_EventQueue *a_queue;
   unsigned int newHead;

   STB_OSMutexLock(state_mutex);
   processing_state &= ~DEFER_ASYNC_EVENTS;
   STB_OSMutexUnlock(state_mutex);

   if (processing_state == DO_ANY_EVENT)
   {
      /* Process any pending synchronous events, queued as a result of re-enabling
       * event processing. And prepend actions to main queue */
      if (the_sync_q->slen)
      {
         processSyncEvents();
      }

      /* Process any pending actions resulting from the synchronous events we just
       * processed. All actions in the queue will be processed.
       */
      processActions();

      /* Process each asynchronous event in the queue, processing all resulting
       * actions and synchronous events before proceeding to the next asynchronous
       * event.
       */
      assert( frst_a_queue );
      do
      {
         newHead = 0;
         a_queue = frst_a_queue;
         /* While there are events in the queue and event processing is enabled */
         while (processing_state == DO_ANY_EVENT && a_queue->tail != a_queue->head)
         {
            doAsyncEvent( a_queue->events + a_queue->tail );

            a_queue->tail++;

            /* Process any actions generated as a result of processing the
             * asynchronous event. All actions in the queue will be processed.
             */
            //TRACE(TEVNTS,(" EQ=%x h=%d t=%d s=%d ",a_queue,a_queue->tail, a_queue->head, processing_state ))
            processActions();
         }
         if (a_queue->next && (a_queue->tail == a_queue->head))
         {
            //TRACE(TEVNTS,(" EQ=%x N=%x F=%x s=%d ",a_queue, a_queue->next, frst_a_queue, processing_state ))
            /* move the Async queue */
            frst_a_queue = a_queue->next;
            MHEG5freeMem(a_queue);
            newHead = 1;
         }
      }
      while (newHead);
   }
}

void MHEG5actionListExecute( MHEG5Group *source, MHEG5ActionList act_q )
{
   S_ShortSyncQ temp_event_q;
   MHEG5ActionList tmp_action_q[SHORT_Q_SIZE];
   S_SyncQueue *save_sync_q;
   MHEG5Root *target;
   MHEG5Action *action;
   E_RQ_STATUS rq_stat;
   DECLARE_RC

   /* ensure MHEG5sendEvent() does not go beyond the short size */
   temp_event_q.size = SHORT_Q_SIZE;
   temp_event_q.slen = 0;
   tmp_action_q[0] = act_q;
   action_list_ptr = tmp_action_q + 1;

   //TRACE(TEVNTS,("events=%d",the_sync_q->slen))
   save_sync_q = the_sync_q;
   the_sync_q = (S_SyncQueue *)&temp_event_q;

   #if defined(MH5PRINTOUT) || defined(TRACING)
   event_indent_num++;
   #endif

   do
   {
      action_list_ptr--;
      while (action_list_ptr->total != 0)
      {
         action = action_list_ptr->a_ptr;
         action_list_ptr->a_ptr++;
         action_list_ptr->total--;

         assert((action->type != MHEG5LAUNCH) && (action->type != MHEG5QUIT) &&
            (action->type != MHEG5SPAWN) && (action->type != MHEG5TRANSITIONTO));

         assert( action->type > MHEG5NONEACTION );
         assert( action->type < ACTION_LAST );

         rq_stat = element_act[(int)action->type].stat;
         if (rq_stat == NOTHING)
         {
            target = NULL;
         }
         else
         {
            target = action->target;
            if (action->targetIsIndirect && target != NULL)
            {
               target = MHEG5resolveRealObject( target );
            }
            if (target != NULL)
            {
               switch (rq_stat)
               {
                  case RUNNING:   if (!target->runningStatus)
                        break;
                  case AVAILABLE: if (!target->availabilityStatus)
                        break;
                  default:
                  case EXISTS:
                     rq_stat = NOTHING;
                     break;
               }
            }
         }
         if (rq_stat == NOTHING)
         {
            DBGPrintAction( action->target, target, action->type, action->firstParam );

            /* Call the function that implements this action */
            ASSIGN_RC element_act[(int)action->type].func( target, action->firstParam );

            DBGCheckRC( target, action->type, action->firstParam )
         }

         /* Process any synchronous events raised */
         if (temp_event_q.slen != 0)
         {
            MHEG5Link *link = temp_event_q.links[0];
            do
            {
               temp_event_q.slen--;
               action_list_ptr++;
               *action_list_ptr = link->linkEffect;
               link++;
            }
            while (temp_event_q.slen != 0);
         }
      }
      assert( action_list_ptr->total == 0 );
   } while (action_list_ptr != tmp_action_q);
   //TRACE(TEVNTS,("events=%d",the_sync_q->slen))
   the_sync_q = save_sync_q;
   action_list_ptr = NULL;
}

void MHEG5PrependActionList( MHEG5ActionList actions )
{
   if (action_list_ptr != NULL)
   {
      action_list_ptr++;
      *action_list_ptr = actions;
   }
   else
   {
      mainActionListHead--;
      mainActionListHead &= ACTION_LIST_MASK;
      /* Store the group of the action source */
      /* Store the new actions on the queue */
      mainActionLists[mainActionListHead] = actions;

      #if defined(MH5PRINTOUT) || defined(TRACING)
      mainActionLists[mainActionListHead].indent = event_indent_num + 1;
      #endif
   }
}

void MHEG5queueEvents(void)
{
   queueEvents = MHEG5TRUE;
}

void MHEG5sendEvent(MHEG5Root *source, MHEG5EventType a_type, MHEG5Int data )
{
   S_EventInfo *newInfo;
   U8BIT new_tail;

   assert( a_type >= MHEG5ANCHORFIRED );

   if (!source)
   {
      INFO_PRINT(("INFO: MHEG5sendEvent: Ignoring event %d - source is invalid\n", a_type));
      return;
   }

   if (!queueEvents)
   {
      /* Event processing is currently disabled - ignore this event */
      INFO_PRINT(("INFO: MHEG5sendEvent: Ignoring event %d (from %ld) - queueEvents is FALSE\n", a_type, source->id));
      return;
   }

   if (a_type == MHEG5USERINPUT)
   {
   #ifdef TRACING
      TRACE(TKEYS, (": User Input, Edata=%d", data))
   #endif
      if (userInputEventCount == MAX_USER_EVENTS)
      {
         /* Too many user input events */
         INFO_PRINT(("INFO: MHEG5sendEvent: Too many user input events\n"));
         return;
      }
   }
   else
   {
   #ifdef TRACING
      /*TRACE(TEVNTVERB,(" t=%d Id=%ld num=%ld",a_type,source->id,number_on_aq))*/
   #endif
   }


   /* We cannot assume that just coz there are no links waiting now,
    * that there will be no links by the time the async Q is processed
    * so we have to store all Async events *
      if ( existsLinkCount[a_type] == 0 )
      {
      INFO_PRINT(("INFO: MHEG5sendEvent: Ignor %s (from %d) - no links existing\n", MHEG5eventToString(a_type), source->id));
      return;
      }
    ****/

   new_tail = last_a_queue->head;
   new_tail++;
   if (new_tail == last_a_queue->tail)
   {
      /* overflow of Q - it is reasonable to expect that this will happen - like in DTG X.1 test */
      last_a_queue->next = (S_EventQueue *)MHEG5getMem( sizeof(S_EventQueue));
      if (last_a_queue->next == NULL)
      {
         /* malloc fail */
         return;
      }
      last_a_queue = last_a_queue->next;
      last_a_queue->next = NULL;
      last_a_queue->tail = 0;
      last_a_queue->head = 1;
      newInfo = last_a_queue->events;
   }
   else
   {
      newInfo = last_a_queue->events + last_a_queue->head;
      last_a_queue->head = new_tail;
   }

   /* Set data for the new event structure */
   newInfo->e_grp = source->grp;
   newInfo->e_id = source->id;
   newInfo->e_type = (U16BIT)a_type;
   newInfo->e_data = data;
#ifdef TRACING
   if (source->clazz == MHEG5SCENE || source->clazz == MHEG5APPLICATION)
      newInfo->e_clone = MHEG5FALSE;
   else
      newInfo->e_clone = ((MHEG5Ingredient *)source)->cloned;
#endif
   if (a_type == MHEG5USERINPUT)
   {
      userInputEventCount++;
   }
}

void MHEG5sendAppEngineEvent( E_ENGINE_EVENT engine_event )
{
   MHEG5Root *application = (MHEG5Root *)MHEG5getCurrentApplication();

   /* Check that an application is running before sending the event */
   if (application)
   {
      MHEG5sendEvent(application, MHEG5ENGINEEVENT, engine_event );
   }
}

void MHEG5sendSync(MHEG5Root *source, MHEG5EventType e_type, MHEG5Int e_data )
{
   MHEG5Link *link;
   int count = 0;
   MHEG5Int source_id = source->id;
   #ifdef REVERSE_MULTIPLE_LINK_ORDER
   MHEG5Link *links[8];
   #endif

   assert( source );
   assert( e_type < MHEG5ANCHORFIRED );

   if (!queueEvents)
   {
      /* Event processing is currently disabled - ignore this e_type */
      INFO_PRINT(("INFO: MHEG5sendSync: Ignoring event %d (from %ld) - queueEvents is FALSE\n", e_type, source->id));
      return;
   }

   /*TRACE(TEVNTVERB,(" t=%d Id=%ld num=%ld",e_type,source->id,number_on_aq))*/

   /* Get pointer to the list of active Link objects */
   link = activeLinksHead[e_type];

   /* Repeat for each active Link object for this event type */
   while (link)
   {
      assert( link->ingredient.root.runningStatus ); /* It MUST be active */

      /* Check whether source ID matches */
      if (link->source == source_id)
      {
         /* Check whether event data matches */
         if ((link->eventData.type == MHEG5NONE) ||
             ((link->eventData.type == MHEG5INT) && (link->eventData.value.i == e_data)) ||
             ((link->eventData.type == MHEG5BOOL) && (link->eventData.value.b == e_data)))
         {
            /* Check whether source GID matches */
            if ((source->grp == link->sourcegid.ptr.group) ||
                ((link->sourcegid.len != 0) && MHEG5sameGroup(source->grp, link->sourcegid)))
            {
               /* This Link Fires ! */
               //TRACE(TEVNTS,("firing link %ld",link->ingredient.root.id))

               #ifdef REVERSE_MULTIPLE_LINK_ORDER
               /* On NZ stream, found that it has bug in mheg app (courtesy of S&T) that relies on
                * particular order for firing links that matches for a particular Sync event
                * Really the app only wants the most recent one to be activated, but thats not to spec
                * so we will reverse the order here for AUS/NZ build
                */
               links[count++] = link;

               #else

               if (the_sync_q->slen != the_sync_q->size)
               {
                  /* I don't believe it is possible for 128 (SYNC_Q_SIZE) synchronous events to be added
                   * without processing any of them, nor would one expect that when doing
                   * OnStartUp, OnCloseDown type of actions could there be more than 8 (SHORT_Q_SIZE)
                   * but checked it's ok anyway */
                  the_sync_q->links[the_sync_q->slen] = link;
                  the_sync_q->slen++;
                  if (count != 0)
                  {
                     TRACE(TERROR, ("more than one link (%d) fires: Link %ld", count, link->ingredient.root.id))
                  }
                  count++;
               }

               #endif
            }
         }
      }
      /* Process the next active link in the list */
      link = link->nextActiveLink;
   }

   #ifdef REVERSE_MULTIPLE_LINK_ORDER
   while (count--)
   {
      if (the_sync_q->slen != the_sync_q->size)
      {
         the_sync_q->links[the_sync_q->slen] = links[count];
         the_sync_q->slen++;
      }
   }
   #endif
}

void MHEG5enableEventProcessing(MHEG5Bool enable)
{
   /* Keep a count of the number of requests to disable events. Only enable
    * event processing when the counter is zero.
    */
   if (enable)
   {
      /* Check that we have previously received a disable request */
      assert(eventProcessingDisableCount > 0);

      /* Decrement the counter of disable requests */
      eventProcessingDisableCount--;

      if (eventProcessingDisableCount <= 0)
      {
         /* Enable event processing */
         STB_OSMutexLock(state_mutex);
         processing_state &= ~SUSPEND_EVENTS;
         STB_OSMutexUnlock(state_mutex);
      }
   }
   else
   {
      assert(eventProcessingDisableCount <= 1);

      /* This is a disable request - increment the disable request counter */
      eventProcessingDisableCount++;

      /* We have at least one outstanding disable request - disable event
       * processing
       */
      STB_OSMutexLock(state_mutex);
      processing_state |= SUSPEND_EVENTS;
      STB_OSMutexUnlock(state_mutex);
   }
}

void MHEG5eventProcessingReset(void)
{
   eventProcessingDisableCount = 0;
   STB_OSMutexLock(state_mutex);
   processing_state &= ~SUSPEND_EVENTS;
   STB_OSMutexUnlock(state_mutex);
}

static void MHEG5DeferProcessing(void)
{
   STB_OSMutexLock(state_mutex);
   processing_state |= DEFER_ASYNC_EVENTS;
   STB_OSMutexUnlock(state_mutex);
}

void CriticalMessageArrived(void)
{
   STB_OSMutexLock(state_mutex);
   critical_msg_count++;
   processing_state |= STOP_ALL_EVENTS;
   STB_OSMutexUnlock(state_mutex);
}

void CriticalMessageProcessed(void)
{
   STB_OSMutexLock(state_mutex);
   assert( critical_msg_count > 0 );
   if (critical_msg_count > 0)
   {
      critical_msg_count--;
      if (critical_msg_count == 0)
      {
         processing_state &= ~STOP_ALL_EVENTS;
      }
   }
   STB_OSMutexUnlock(state_mutex);
}

void MHEG5requestDisplayUpdate(void)
{
   displayUpdateRequested = MHEG5TRUE;
}