mh5keypress.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2012 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 <glue_memory.h>
#include <glue_debug.h>
#include <glue_queue.h>
#include <glue_main.h>
#include "mheg5_keypress.h"
#include "mheg5_events.h"
#include "mh5application.h"
#include "mh5scene.h"
#include "mh5queue.h"
#include "mh5display.h"
#include "mh5entryfield.h"
#include "mh5hypertext.h"
#include "mh5slider.h"
#include "mh5profile.h"
#include "mh5support.h"
#ifdef INCLUDE_SA_PROFILE
#include "mh5control.h"
#endif
#include "mh5keypress.h"

#ifdef NOTIFY_KEYSET
void MHEG5NotifyEvent( E_MhegEvent event, U32BIT data );
#endif

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

/* It is safe to always include input registers for AU and NZ */
#define INCLUDE_AU_PROFILE
#define INCLUDE_NZ_PROFILE

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

/* User interface function groups */
typedef enum
{
   UK_KGRP_COLOURS,
   UK_KGRP_ARROWS,
   UK_KGRP_ARRS_DIGITS,
   UK_KGRP_COLS_ARROWS,
   UK_KGRP_COLS_ARRS_DIGITS,
   UK_KGRP_COLS_ARRS_DGTS_PVR,
   NZ_KGRP_COLOURS,
   NZ_KGRP_COLS_ARRS_DIGITS,
   NZ_KGRP_COLS_ARROWS,
   OZ_KGRP_COLOURS,
   OZ_KGRP_COLS_ARRS_DIGITS,
   OZ_KGRP_COLS_ARROWS
} E_FunctionGroup;


typedef struct s_keyMask
{
   U8BIT byte;
   U8BIT bit;
} s_keyMask_t;

/*---local (static) variable declarations for this file----------------------*/
static BOOLEAN Register3Accept(E_MHEG5_KEY key);

/*pointer to user input register check function*/
static BOOLEAN (*inputAcceptFn)(E_MHEG5_KEY key) = Register3Accept;

static BOOLEAN promotional_linking_enabled = TRUE;

static s_keyMask_t key_mask_values[TOTAL_MHEG5_KEYS] =
{
   {0, 0x01},  /* MHEG5_KEY_UP    */
   {0, 0x02},  /* MHEG5_KEY_DOWN  */
   {0, 0x04},  /* MHEG5_KEY_LEFT  */
   {0, 0x08},  /* MHEG5_KEY_RIGHT */
   {0, 0x10},  /* MHEG5_KEY_0     */
   {0, 0x10},  /* MHEG5_KEY_1     */
   {0, 0x10},  /* MHEG5_KEY_2     */
   {0, 0x10},  /* MHEG5_KEY_3     */
   {0, 0x10},  /* MHEG5_KEY_4     */
   {0, 0x10},  /* MHEG5_KEY_5     */
   {0, 0x10},  /* MHEG5_KEY_6     */
   {0, 0x10},  /* MHEG5_KEY_7     */
   {0, 0x10},  /* MHEG5_KEY_8     */
   {0, 0x10},  /* MHEG5_KEY_9     */
   {0, 0x20},  /* MHEG5_KEY_SELECT*/
   {0, 0x40},  /* MHEG5_KEY_CANCEL*/
   {0, 0x80},  /* MHEG5_KEY_HELP  */
   {1, 0x01},  /* MHEG5_KEY_RED   */
   {1, 0x02},  /* MHEG5_KEY_GREEN */
   {1, 0x04},  /* MHEG5_KEY_YELLOW*/
   {1, 0x08},  /* MHEG5_KEY_BLUE  */
   {1, 0x10},  /* MHEG5_KEY_TEXT  */
   {1, 0x20},  /* MHEG5_KEY_INFO  */
   {2, 0x20},  /* MHEG5_KEY_EPG   */
   {1, 0x40},  /* MHEG5_KEY_STOP       */
   {1, 0x80},  /* MHEG5_KEY_PLAY       */
   {2, 0x01},  /* MHEG5_KEY_PAUSE      */
   {2, 0x02},  /* MHEG5_KEY_SKIP_FWD   */
   {2, 0x04},  /* MHEG5_KEY_SKIP_BACK  */
   {2, 0x08},  /* MHEG5_KEY_FAST_FWD   */
   {2, 0x10},  /* MHEG5_KEY_REWIND     */
   {2, 0x40},  /* MHEG5_KEY_PLAY_PAUSE */
   {4, 0x01},  /* MHEG5_KEY_RECORD     */
};

BOOLEAN key_mask_enable[TOTAL_MHEG5_KEYS];
BOOLEAN key_unsupported[TOTAL_MHEG5_KEYS] =
{
   FALSE,  /* MHEG5_KEY_UP    */
   FALSE,  /* MHEG5_KEY_DOWN  */
   FALSE,  /* MHEG5_KEY_LEFT  */
   FALSE,  /* MHEG5_KEY_RIGHT */
   FALSE,  /* MHEG5_KEY_0     */
   FALSE,  /* MHEG5_KEY_1     */
   FALSE,  /* MHEG5_KEY_2     */
   FALSE,  /* MHEG5_KEY_3     */
   FALSE,  /* MHEG5_KEY_4     */
   FALSE,  /* MHEG5_KEY_5     */
   FALSE,  /* MHEG5_KEY_6     */
   FALSE,  /* MHEG5_KEY_7     */
   FALSE,  /* MHEG5_KEY_8     */
   FALSE,  /* MHEG5_KEY_9     */
   FALSE,  /* MHEG5_KEY_SELECT*/
   FALSE,  /* MHEG5_KEY_CANCEL*/
   FALSE,  /* MHEG5_KEY_HELP  */
   FALSE,  /* MHEG5_KEY_RED   */
   FALSE,  /* MHEG5_KEY_GREEN */
   FALSE,  /* MHEG5_KEY_YELLOW*/
   FALSE,  /* MHEG5_KEY_BLUE  */
   FALSE,  /* MHEG5_KEY_TEXT  */
   FALSE,  /* MHEG5_KEY_INFO  */
   FALSE,  /* MHEG5_KEY_EPG   */
   FALSE,  /* MHEG5_KEY_STOP       */
   FALSE,  /* MHEG5_KEY_PLAY       */
   FALSE,  /* MHEG5_KEY_PAUSE      */
   FALSE,  /* MHEG5_KEY_SKIP_FWD   */
   FALSE,  /* MHEG5_KEY_SKIP_BACK  */
   FALSE,  /* MHEG5_KEY_FAST_FWD   */
   FALSE,  /* MHEG5_KEY_REWIND     */
   FALSE,  /* MHEG5_KEY_PLAY_PAUSE */
   FALSE,  /* MHEG5_KEY_RECORD     */
};

static int UserInputEventData[TOTAL_MHEG5_KEYS] =
{
   1,    /* MHEG5_KEY_UP    */
   2,    /* MHEG5_KEY_DOWN  */
   3,    /* MHEG5_KEY_LEFT  */
   4,    /* MHEG5_KEY_RIGHT */
   5,    /* MHEG5_KEY_0     */
   6,    /* MHEG5_KEY_1     */
   7,    /* MHEG5_KEY_2     */
   8,    /* MHEG5_KEY_3     */
   9,    /* MHEG5_KEY_4     */
   10,   /* MHEG5_KEY_5     */
   11,   /* MHEG5_KEY_6     */
   12,   /* MHEG5_KEY_7     */
   13,   /* MHEG5_KEY_8     */
   14,   /* MHEG5_KEY_9     */
   15,   /* MHEG5_KEY_SELECT*/
   16,   /* MHEG5_KEY_CANCEL*/
   17,   /* MHEG5_KEY_HELP  */
   100,  /* MHEG5_KEY_RED   */
   101,  /* MHEG5_KEY_GREEN */
   102,  /* MHEG5_KEY_YELLOW*/
   103,  /* MHEG5_KEY_BLUE  */
   104,  /* MHEG5_KEY_TEXT  */
   105,  /* MHEG5_KEY_INFO  */
   300,  /* MHEG5_KEY_EPG   */
   120,  /* MHEG5_KEY_STOP       */
   121,  /* MHEG5_KEY_PLAY       */
   122,  /* MHEG5_KEY_PAUSE      */
   123,  /* MHEG5_KEY_SKIP_FWD   */
   124,  /* MHEG5_KEY_SKIP_BACK  */
   125,  /* MHEG5_KEY_FAST_FWD   */
   126,  /* MHEG5_KEY_REWIND     */
   127,  /* MHEG5_KEY_PLAY_PAUSE */
   400,  /* MHEG5_KEY_RECORD     */
};

#ifdef NOTIFY_KEYSET
static MHEG5Int key_input_reg;
static U32BIT last_keyset = 0;
#endif

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

/*---global function definitions---------------------------------------------*/
/*functions to check if a key is part of a particular register*/
static BOOLEAN Register4Accept(E_MHEG5_KEY key);
static BOOLEAN Register5Accept(E_MHEG5_KEY key);
static BOOLEAN Register6Accept(E_MHEG5_KEY key);
#ifdef INCLUDE_FREESAT
static BOOLEAN Register7Accept(E_MHEG5_KEY key);
#endif
#ifdef INCLUDE_NZ_PROFILE
static BOOLEAN Register13Accept(E_MHEG5_KEY key);
static BOOLEAN Register14Accept(E_MHEG5_KEY key);
static BOOLEAN Register15Accept(E_MHEG5_KEY key);
static BOOLEAN Register16Accept(E_MHEG5_KEY key);
#endif
#ifdef INCLUDE_AU_PROFILE
static BOOLEAN Register33Accept(E_MHEG5_KEY key);
static BOOLEAN Register34Accept(E_MHEG5_KEY key);
static BOOLEAN Register35Accept(E_MHEG5_KEY key);
#endif

static BOOLEAN IsKeypressInMask(E_MHEG5_KEY key);

#ifdef NOTIFY_KEYSET
BOOLEAN NotifyKeyset(void)
{
   U32BIT key;
   U32BIT keyset = 0;
   switch (key_input_reg)
   {
      case 0:
      {
         for (key = MHEG5_KEY_UP; key != MHEG5_KEY_0; key++)
         {
            if (key_mask_enable[key])
            {
               keyset |= KS_NAVIGATION;
               break;
            }
         }
         for (key = MHEG5_KEY_0; key != MHEG5_KEY_SELECT; key++)
         {
            if (key_mask_enable[key])
            {
               keyset |= KS_NUMERIC;
               break;
            }
         }
         if (key_mask_enable[MHEG5_KEY_SELECT])
         {
            keyset |= KS_NAVIGATION;
         }
         if (key_mask_enable[MHEG5_KEY_RED])
         {
            keyset |= KS_RED;
         }
         if (key_mask_enable[MHEG5_KEY_GREEN])
         {
            keyset |= KS_GREEN;
         }
         if (key_mask_enable[MHEG5_KEY_YELLOW])
         {
            keyset |= KS_YELLOW;
         }
         if (key_mask_enable[MHEG5_KEY_BLUE])
         {
            keyset |= KS_BLUE;
         }
         if (key_mask_enable[MHEG5_KEY_INFO])
         {
            keyset |= KS_INFO;
         }
         for (key = MHEG5_KEY_STOP; key != TOTAL_MHEG5_KEYS; key++)
         {
            if (key_mask_enable[key])
            {
               keyset |= KS_VCR;
               break;
            }
         }
         break;
      }
      case 7:
         keyset |= KS_INFO;
      case 6:
         keyset |= KS_VCR;
      case 4:
         keyset |= KS_NUMERIC;
      case 5:
         keyset |= KS_NAVIGATION;
      default:
         keyset |= KS_RED|KS_GREEN|KS_YELLOW|KS_BLUE;
   }
   if (last_keyset != keyset)
   {
      MHEG5NotifyEvent( MHEG_EVENT_KEYSET_CHANGE, keyset );
      last_keyset = keyset;
   }
   return FALSE;
}
#endif

void MHEG5setInputEventRegister(MHEG5Int inputEventRegister)
{
   switch (inputEventRegister)
   {
      case 0:
         /* InputMask extension */
         inputAcceptFn = IsKeypressInMask;
         break;

      default:
      /* Invalid value encoded in scene. What should we do here? Either we
       * grab all the keys, potentially causing user confusion, or we just
       * grab the group 3 keys with the posibility that the user cannot
       * interact with the application. Let's try to keep TV functionality
       * consistant, and hope the broadcaster fixes their broadcast.
       * So fall through to zero case */
      case 1:
      case 2:
      /* Group 1 & 2  not supported*/

      case 3:
         /* Group 3 - Red, Green, Yellow, Blue, Text and Cancel/Exit */
         inputAcceptFn = Register3Accept;
         break;

      case 4:
         /* Group 4 - Group 3, digits, Up, Down, Left, Right, Select */
         inputAcceptFn = Register4Accept;
         break;

      case 5:
         /* Group 5 - Group 4 without digits */
         inputAcceptFn = Register5Accept;
         break;

      case 6:
         /* Group 6 -  */
         inputAcceptFn = Register6Accept;
         break;

      #ifdef INCLUDE_FREESAT
      case 7:
         if (MH5_SupportMhegProfile(CPROFILE_FREESAT))
         {
            /* Group 7 - Freesat with INFO (but no EngineEvent) */
            inputAcceptFn = Register7Accept;
         }
         else
         {
            inputAcceptFn = Register3Accept;
         }
         break;
      #endif

      #ifdef INCLUDE_NZ_PROFILE
      case 13:
         if (MH5_SupportMhegProfile(CPROFILE_NZ))
         {
            /* Group 13 - EPG, Red, Green, Yellow, Blue, Text and Cancel/Exit */
            inputAcceptFn = Register13Accept;
         }
         else
         {
            inputAcceptFn = Register3Accept;
         }
         break;

      case 14:
         if (MH5_SupportMhegProfile(CPROFILE_NZ))
         {
            inputAcceptFn = Register14Accept;
         }
         else
         {
            inputAcceptFn = Register4Accept;
         }
         break;

      case 15:
         if (MH5_SupportMhegProfile(CPROFILE_NZ))
         {
            inputAcceptFn = Register15Accept;
         }
         else
         {
            inputAcceptFn = Register5Accept;
         }
         break;

      case 16:
         if (MH5_SupportMhegProfile(CPROFILE_NZ))
         {
            /* Group 16 - Group 6 with EPG key */
            inputAcceptFn = Register16Accept;
         }
         else
         {
            inputAcceptFn = Register6Accept;
         }
         break;
      #endif /* INCLUDE_NZ_PROFILE*/

      #ifdef INCLUDE_AU_PROFILE
      case 33:
         if (MH5_SupportMhegProfile(CPROFILE_AU))
         {
            /* Group 33 - EPG, INFO, Red, Green, Yellow, Blue, Text and Cancel/Exit */
            inputAcceptFn = Register33Accept;
         }
         else
         {
            inputAcceptFn = Register3Accept;
         }
         break;

      case 34:
         if (MH5_SupportMhegProfile(CPROFILE_AU))
         {
            /* Group 34 - Group 13, digits, Up, Down, Left, Right, Select */
            inputAcceptFn = Register34Accept;
         }
         else
         {
            inputAcceptFn = Register4Accept;
         }
         break;

      case 35:
         if (MH5_SupportMhegProfile(CPROFILE_AU))
         {
            /* Group 35 - Group 14 without digits */
            inputAcceptFn = Register35Accept;
         }
         else
         {
            inputAcceptFn = Register5Accept;
         }
         break;
      #endif /* INCLUDE_AU_PROFILE*/
   }

#ifdef NOTIFY_KEYPRESS_REQ
   DVB_MhegSetInputRegister(inputEventRegister);
#endif  /* NOTIFY_KEYPRESS_REQ */
#ifdef NOTIFY_KEYSET
   key_input_reg = inputEventRegister;
   MH5GlueAddPostProcessFunc( NotifyKeyset );
#endif
}

BOOLEAN MHEG5_IsKeyNeeded(E_MHEG5_KEY keyPress)
{
   BOOLEAN accepted;
   switch (keyPress)
   {
      case MHEG5_KEY_EPG:
      case MHEG5_KEY_INFO:
      #ifdef INCLUDE_SA_PROFILE
         if (MH5_SupportMhegProfile(CPROFILE_SA))
         {
            accepted = TRUE;
            break;
         }
      #endif /*INCLUDE_SA_PROFILE*/
      default:
         if (MHEG5getCurrentScene())
         {
            /*check if the key is part of the selected input register*/
            accepted = inputAcceptFn(keyPress);
         }
         else
         {
            TRACE(TKEYS, ("No scene for key %d", keyPress))
            accepted = FALSE;
         }
   }
   return accepted;
}

void MHEG5userInputEvent(S_KeyPressEvent *params)
{
   E_MHEG5_KEY ui = params->key;
   MHEG5Scene *scene;
   MHEG5Root *application;
   MHEG5Entryfield *entryfield;
   MHEG5Hypertext *hypertext;
   MHEG5Slider *slider;

   scene = MHEG5getCurrentScene();

   /* Check that there is an active scene before sending the event */
   if (!scene)
   {
   #ifdef INCLUDE_SA_PROFILE
      if (MH5_SupportMhegProfile(CPROFILE_SA))
      {
         // For South Africa profile, when no scene, launch default apps.
         switch (ui)
         {
            case MHEG5_KEY_EPG:
               MHEG5StartEpgApp();
               break;
            case MHEG5_KEY_INFO:
               MHEG5StartInfoApp(FALSE);
               break;
            case MHEG5_KEY_SELECT:
               MHEG5StartListApp();
               break;
            default:;
               TRACE(TKEYS, ("No Scene - ignoring key %d", ui));
         }
      }
      else
   #endif /*INCLUDE_SA_PROFILE*/
      {
         TRACE(TKEYS, ("No Scene - ignoring key %d", ui))
      }
   }
   else if (!inputAcceptFn(ui))
   {
      /* If there is a scene then an application should be running */
      TRACE(TKEYS, ("key %d not included in input register", ui))
      if (MH5_SupportMhegProfile(CPROFILE_SA))
      {
         // For South Africa profile, always send these engine events...
         switch (ui)
         {
            case MHEG5_KEY_EPG:
               MHEG5sendEvent((MHEG5Root *)MHEG5getCurrentApplication(), MHEG5ENGINEEVENT, EE_KEYPRESS_EPG);
               break;

            case MHEG5_KEY_INFO:
               MHEG5sendEvent((MHEG5Root *)MHEG5getCurrentApplication(), MHEG5ENGINEEVENT, EE_KEYPRESS_INFO);
               break;
            default:;
         }
      }
   }
   else
   {
      TRACE_SET_TIME();
      TRACE(TKEYS, ("got key %d", ui))

      /* If there is a scene then an application should be running */
      application = (MHEG5Root *)MHEG5getCurrentApplication();

      switch (ui)
      {
         case MHEG5_KEY_TEXT:
            /* Generate TextFunction engine event */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_TEXT);
            break;

         case MHEG5_KEY_CANCEL:
            /* Generate CancelKeyFunction engine event */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_CANCEL );
            break;

         case MHEG5_KEY_RED:
            /* Generate RedKeyFunction engine event */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_RED );
            break;

         case MHEG5_KEY_GREEN:
            /* Generate GreenKeyFunction engine event */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_GREEN );
            break;

         case MHEG5_KEY_YELLOW:
            /* Generate YellowKeyFunction engine event */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_YELLOW );
            break;

         case MHEG5_KEY_BLUE:
            /* Generate BlueKeyFunction engine event */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_BLUE );
            break;

         #ifndef INCLUDE_FREESAT
         case MHEG5_KEY_INFO:
            /* Generate InfoKeyFunction engine event for OZ profile,
             * but not for Freesat.
             */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_INFO );
            break;
         #endif  /* !INCLUDE_FREESAT */

         case MHEG5_KEY_EPG:
            /* Generate EPGKeyFunction engine event - for NZ profile */
            MHEG5sendEvent(application, MHEG5ENGINEEVENT, EE_KEYPRESS_EPG );
            break;

         default:
            /* No other keys generate engine events */
            ;
      }

      if (scene->currentInteractible)
      {
         switch (scene->currentInteractible->clazz)
         {
            case MHEG5ENTRYFIELD:
               entryfield = (MHEG5Entryfield *)scene->currentInteractible;
               MHEG5entryfieldUserInput(entryfield, ui);
               return;

            case MHEG5HYPERTEXT:
               hypertext = (MHEG5Hypertext *)scene->currentInteractible;
               switch (ui)
               {
                  case MHEG5_KEY_UP:
                  case MHEG5_KEY_LEFT:
                     MHEG5hypertextUP(hypertext);
                     break;
                  case MHEG5_KEY_DOWN:
                  case MHEG5_KEY_RIGHT:
                     MHEG5hypertextDOWN(hypertext);
                     break;
                  case MHEG5_KEY_SELECT:
                     MHEG5hypertextSELECT(hypertext);
                     break;
                  case MHEG5_KEY_CANCEL:
                     hypertext->interactible.interactionStatus = MHEG5FALSE;
                     scene->currentInteractible = 0;
                     MHEG5interactibleInteractionCompleted(&hypertext->interactible, (MHEG5Root *)hypertext);
                     return;
                  default:
                     /* Not interested in other keys */
                     ;
               }
               break;

            case MHEG5SLIDER:
               slider = (MHEG5Slider *)scene->currentInteractible;
               switch (ui)
               {
                  case MHEG5_KEY_LEFT:
                     MHEG5sliderLEFT(slider);
                     break;
                  case MHEG5_KEY_UP:
                     MHEG5sliderUP(slider);
                     break;
                  case MHEG5_KEY_RIGHT:
                     MHEG5sliderRIGHT(slider);
                     break;
                  case MHEG5_KEY_DOWN:
                     MHEG5sliderDOWN(slider);
                     break;
                  case MHEG5_KEY_SELECT:
                  /* should there be any difference between the actions of SELECT and EXIT?*/
                  case MHEG5_KEY_CANCEL:
                     MHEG5sliderEXIT(slider);
                     return;
                  default:
                     /* Not interested in other keys */
                     ;
               }
               break;

            default:
               return;
         }
         MHEG5displayRedraw((MHEG5Visible *)scene->currentInteractible );
         return;
      }
      MHEG5sendEvent((MHEG5Root *) scene, MHEG5USERINPUT, UserInputEventData[ui] );
   }
}

static BOOLEAN Register3Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
#ifdef INCLUDE_RECORD_KEY
      case MHEG5_KEY_RECORD:
#endif
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register4Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
      case MHEG5_KEY_SELECT:
#ifdef INCLUDE_RECORD_KEY
      case MHEG5_KEY_RECORD:
#endif
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register5Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_SELECT:
#ifdef INCLUDE_RECORD_KEY
      case MHEG5_KEY_RECORD:
#endif
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register6Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
      case MHEG5_KEY_SELECT:
#ifdef INCLUDE_ICS
      case MHEG5_KEY_STOP:
      case MHEG5_KEY_PLAY:
      case MHEG5_KEY_PAUSE:
      case MHEG5_KEY_PLAY_PAUSE:
      case MHEG5_KEY_SKIP_FWD:
      case MHEG5_KEY_SKIP_BACK:
      case MHEG5_KEY_FAST_FWD:
      case MHEG5_KEY_REWIND:
#endif
#ifdef INCLUDE_RECORD_KEY
      case MHEG5_KEY_RECORD:
#endif
         return TRUE;
      default:
         return FALSE;
   }
}

#ifdef INCLUDE_FREESAT
static BOOLEAN Register7Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
      case MHEG5_KEY_SELECT:
      case MHEG5_KEY_INFO:
#ifdef INCLUDE_ICS
      case MHEG5_KEY_STOP:
      case MHEG5_KEY_PLAY:
      case MHEG5_KEY_PAUSE:
      case MHEG5_KEY_PLAY_PAUSE:
      case MHEG5_KEY_SKIP_FWD:
      case MHEG5_KEY_SKIP_BACK:
      case MHEG5_KEY_FAST_FWD:
      case MHEG5_KEY_REWIND:
#endif
#ifdef INCLUDE_RECORD_KEY
      case MHEG5_KEY_RECORD:
#endif
         return TRUE;
      default:
         return FALSE;
   }
}

#endif  /* INCLUDE_FREESAT */

#ifdef INCLUDE_NZ_PROFILE

static BOOLEAN Register13Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_EPG:
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register14Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
      case MHEG5_KEY_SELECT:
      case MHEG5_KEY_EPG:
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register15Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_SELECT:
      case MHEG5_KEY_EPG:
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register16Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
      case MHEG5_KEY_SELECT:
      case MHEG5_KEY_EPG:
#ifdef INCLUDE_ICS
      case MHEG5_KEY_STOP:
      case MHEG5_KEY_PLAY:
      case MHEG5_KEY_PAUSE:
      case MHEG5_KEY_PLAY_PAUSE:
      case MHEG5_KEY_SKIP_FWD:
      case MHEG5_KEY_SKIP_BACK:
      case MHEG5_KEY_FAST_FWD:
      case MHEG5_KEY_REWIND:
#endif
         return TRUE;
      default:
         return FALSE;
   }
}

#endif /* INCLUDE_NZ_PROFILE*/
#ifdef INCLUDE_AU_PROFILE

static BOOLEAN Register33Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_INFO:
      case MHEG5_KEY_EPG:
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register34Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_0:
      case MHEG5_KEY_1:
      case MHEG5_KEY_2:
      case MHEG5_KEY_3:
      case MHEG5_KEY_4:
      case MHEG5_KEY_5:
      case MHEG5_KEY_6:
      case MHEG5_KEY_7:
      case MHEG5_KEY_8:
      case MHEG5_KEY_9:
      case MHEG5_KEY_SELECT:
      case MHEG5_KEY_INFO:
      case MHEG5_KEY_EPG:
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN Register35Accept(E_MHEG5_KEY key)
{
   switch (key)
   {
      case MHEG5_KEY_CANCEL:
      case MHEG5_KEY_RED:
      case MHEG5_KEY_GREEN:
      case MHEG5_KEY_YELLOW:
      case MHEG5_KEY_BLUE:
      case MHEG5_KEY_TEXT:
      case MHEG5_KEY_UP:
      case MHEG5_KEY_DOWN:
      case MHEG5_KEY_LEFT:
      case MHEG5_KEY_RIGHT:
      case MHEG5_KEY_SELECT:
      case MHEG5_KEY_INFO:
      case MHEG5_KEY_EPG:
         return TRUE;
      default:
         return FALSE;
   }
}

#endif /* INCLUDE_AU_PROFILE*/


MHEG5Bool MHEG5IsInputMaskSupported(MHEG5String query_mask)
{
   int index;
   U8BIT mask_byte;
   MHEG5String untested_bits;
   MHEG5Bool mask_supported;

   mask_supported = MHEG5TRUE;
   untested_bits = MHEG5stringCopy(query_mask);

   /*check all the keys known to MHEG5*/
   for (index = 0; index != TOTAL_MHEG5_KEYS; index++)
   {
      mask_byte = key_mask_values[index].byte;

      if (untested_bits.len > mask_byte)
      {
         if (untested_bits.data[mask_byte] & key_mask_values[index].bit)
         {
            /* check all the keys that are in the input mask*/
            if (!key_unsupported[index])
            {
               mask_supported = MHEG5FALSE;
               break;
            }
            /*turn off the bit that has just been tested*/
            untested_bits.data[mask_byte] &= ~key_mask_values[index].bit;
         }
      }
   }

   for (index = 0; index < untested_bits.len; index++)
   {
      /* Fail if there were characters in the mask unsupported by MHEG5*/
      if (untested_bits.data[index])
      {
         mask_supported = MHEG5FALSE;
         break;
      }
   }
   MHEG5stringDestruct(&untested_bits);
#ifdef NOTIFY_KEYSET
   MH5GlueAddPostProcessFunc( NotifyKeyset );
#endif
   return mask_supported;
}

static BOOLEAN IsKeypressInMask(E_MHEG5_KEY key)
{
   MHEG5Scene *scene;
   BOOLEAN in_mask;
   scene = MHEG5getCurrentScene();
   if (scene != NULL && key < TOTAL_MHEG5_KEYS)
   {
      in_mask = key_mask_enable[key];
   }
   else
   {
      in_mask = FALSE;
   }
   return in_mask;
}

void MHEG5setInputEventMask(MHEG5String *inputEventMask)
{
   s_keyMask_t *keyMask;
   U32BIT byte, key, len;
#ifdef NOTIFY_KEYPRESS_REQ
   E_MHEG5_KEY mask[TOTAL_MHEG5_KEYS];
   U16BIT count = 0;
#endif

   /* Create an array of the keys that are required by the input mask */
   keyMask = key_mask_values;
   len = inputEventMask->len;
   for (key = 0; key != TOTAL_MHEG5_KEYS; key++, keyMask++)
   {
      byte = keyMask->byte;
      if ((byte < len) && (keyMask->bit & inputEventMask->data[byte]) != 0)
      {
         switch ((E_MHEG5_KEY)key)
         {
            case MHEG5_KEY_INFO:
               if (MH5_SupportMhegProfile(CPROFILE_FREESAT | CPROFILE_AU | CPROFILE_SA))
               {
                  key_mask_enable[key] = TRUE;
               }
               else
               {
                  key_mask_enable[key] = FALSE;
               }
               break;
            case MHEG5_KEY_EPG:
               if (MH5_SupportMhegProfile(CPROFILE_NZ | CPROFILE_AU | CPROFILE_SA))
               {
                  key_mask_enable[key] = TRUE;
               }
               else
               {
                  key_mask_enable[key] = FALSE;
               }
               break;
            default:
               key_mask_enable[key] = TRUE;
         }
      #ifdef NOTIFY_KEYPRESS_REQ
         if (key_mask_enable[key])
         {
            mask[count] = (E_MHEG5_KEY)key;
            count++;
         }
      #endif
      }
      else
      {
         key_mask_enable[key] = FALSE;
      }
   }

#ifdef NOTIFY_KEYPRESS_REQ
   /* Notify the controlling application */
   DVB_MhegSetInputMask(mask, count);
#endif
}

BOOLEAN MHEG5_NotifyKeyPress(E_MHEG5_KEY key)
{
   MHEG5eventMessage_t event_msg;

   if ( !MH5GlueIsStarted() )
   {
      TRACE(TKEYS | TMHAPI, ("Keypress( %d ) IGNORED\n", key));
      return FALSE;
   }

   if ( !MH5GlueActiveState() )
   {
      TRACE(TKEYS | TMHAPI, ("Keypress( %d ) IGNORED\n", key));
      return FALSE;
   }

   if ( !MHEG5_IsKeyNeeded( key ))
   {
      TRACE(TKEYS | TMHAPI, ("Keypress( %d ) IGNORED\n", key));
      return FALSE;
   }

   event_msg.proc_msg_func = (F_MSG_PROCESS)MHEG5userInputEvent;
   event_msg.data_type = DT_VALUE;
   event_msg.data.keypress.key = key;
   if (VQ_PutMsg(&event_msg, PRTY_CRITICAL) != MHERR_OK)
   {
      TRACE(TKEYS | TMHAPI, ("Keypress( %d ) IGNORED\n", key));
      return FALSE;
   }

   return TRUE;
}

void MHEG5PromotionalLinkControl( BOOLEAN isEnabled )
{
   if (promotional_linking_enabled != isEnabled)
   {
      promotional_linking_enabled = isEnabled;
      DVB_MhegPromotionalLinkControl(isEnabled);
   }
}

BOOLEAN MHEG5_IsPromotionalLinkingEnabled(void)
{
   return promotional_linking_enabled;
}

void MHEG5_KeySupportDisabled(E_MHEG5_KEY key)
{
   if (key < TOTAL_MHEG5_KEYS)
   {
      key_unsupported[key] = TRUE;
   }
}

void MHEG5_KeySupportEnabled(E_MHEG5_KEY key)
{
   if (key < TOTAL_MHEG5_KEYS)
   {
      key_unsupported[key] = FALSE;
   }
}