mh5parse.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2009 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 "mh5parse.h"
#include "glue_assert.h"
#include "glue_memory.h"
#include "mh5group.h"
#include "mh5json.h"

#define BKG_TITLE_TOKEN       "t"
#define BKG_BOOKING_TOKEN     "b"
#define BKG_CRIDTYPE_TOKEN    "ct"
#define BKG_SYNOPSIS_TOKEN    "s"
#define BKG_LOCATION_TOKEN    "l"
#define BKG_DVB_TOKEN         "dvb://"

#define BKG_CRID_TTL_STRING   "{\"ct\":\"49\",\"t\":\""
#define BKG_SYNOPSIS_STRING   "\",\"s\":\""
#define BKG_BOOKING_PREFIX    "\",\"b\":["
#define BKG_LOCATION_PREFIX   "\"l\":\"dvb://"
#define BKG_DURATION_PREFIX    "--PT"
#define BKG_BOOKING_ENDFIX    "]}"

#define MAX_INT_LENGTH        32
#define MIN_DATA_BLOCK        32


static MHEG5Bool EncodeOctetString(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte *data,
   MHEG5Int len);
static MHEG5Bool EncodeChar(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte ch);
static MHEG5Bool AppendString(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte *data,
   MHEG5Int len);
static MHEG5Bool AppendInteger(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Int value);
static MHEG5Bool AppendChar(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte ch);

#ifdef INCLUDE_IC
static MHEG5Bool AddOctetString(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte *data,
   MHEG5Int len);
static MHEG5Bool AddEncodedChar(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte ch);
#endif /* INCLUDE_IC */


#ifdef INCLUDE_PVR_AU

/* JSON callbacks */
static void* NewLocation( unsigned int val, void *array, void *cptr );
static void* BookingArray( unsigned int val, void *array, void *cptr );
static void* DoneLocation( unsigned int val, void *array, void *cptr );

static S_STRING title_str;
static S_STRING synop_str;
static S_STRING ctype_str;
static S_BOOKING **p_booking_ptr = NULL;

static const S_JSON_MEMBERS booking_members[] = {
   DECLARE_OBJECT( DoneLocation ),
   DECLARE_MEMBER( BKG_LOCATION_TOKEN, JST_CBF_STRING, NewLocation, NULL ),
   DECLARE_OBJEND()
};

static const S_JSON_MEMBERS crid_members[] = {
   DECLARE_MEMBER( BKG_CRIDTYPE_TOKEN, JST_PTR_STRING, &ctype_str, NULL ),
   DECLARE_MEMBER( BKG_TITLE_TOKEN, JST_PTR_ASTRING, &title_str, NULL ),
   DECLARE_MEMBER( BKG_SYNOPSIS_TOKEN, JST_PTR_ASTRING, &synop_str, NULL ),
   DECLARE_MEMBER( BKG_BOOKING_TOKEN, JST_CBF_ARRAY_OBJ, BookingArray, booking_members ),
   DECLARE_OBJEND()
};

#endif /*INCLUDE_PVR_AU*/


static MHEG5Bool MHEG5IsDigit(U32BIT ch, U32BIT base, U32BIT *value)
{
   MHEG5Bool rc = MHEG5FALSE;

   if (ch >= '0' && ch <= '9')
   {
      if (ch - '0' < base)
      {
         *value = ch - '0';
         rc = MHEG5TRUE;
      }
   }
   else if (ch >= 'a' && ch <= 'z')
   {
      if (base > 10 && ch - 'a' < base - 10)
      {
         *value = ch - 'a' + 10;
         rc = MHEG5TRUE;
      }
   }
   else if (ch >= 'A' && ch <= 'Z')
   {
      if (base > 10 && ch - 'A' < base - 10)
      {
         *value = ch - 'A' + 10;
         rc = MHEG5TRUE;
      }
   }

   return rc;
}

MHEG5Bool MHEG5parseDvbUrl(U8BIT *buffer, U32BIT length, S_DVB_LOCATOR *dvb_loc)
{
   U32BIT originalNetworkId = 0;
   U32BIT transportStreamId = 0;
   U32BIT serviceId = 0;
   U32BIT value, ndx = 0;
   MHEG5Bool rtn_val = MHEG5TRUE;
   enum {ST_FIRST_DIGIT, ST_FIRST_NUMBER, ST_FIRST_DOT,
         ST_SECOND_NUMBER, ST_SECOND_DOT,
         ST_THIRD_NUMBER, ST_END, ST_ERROR} state = ST_FIRST_DIGIT;

   /* URL is dvb://<original network id>.[<transport stream id>].<service id> */

   while (ndx != length && state != ST_ERROR)
   {
      switch (state)
      {
         case ST_FIRST_DIGIT:
            if (!MHEG5IsDigit(buffer[ndx], 16, &value))
            {
               state = ST_ERROR;
            }
            else
            {
               originalNetworkId = value;
               state = ST_FIRST_NUMBER;
            }
            break;
         case ST_FIRST_NUMBER:
            if (buffer[ndx] == '.')
            {
               state = ST_FIRST_DOT;
            }
            else if (!MHEG5IsDigit(buffer[ndx], 16, &value))
            {
               state = ST_ERROR;
            }
            else
            {
               originalNetworkId *= 16;
               originalNetworkId += value;
            }
            break;
         case ST_FIRST_DOT:
            if (buffer[ndx] == '.')
            {
               state = ST_SECOND_DOT;
            }
            else if (!MHEG5IsDigit(buffer[ndx], 16, &value))
            {
               state = ST_ERROR;
            }
            else
            {
               transportStreamId = value;
               state = ST_SECOND_NUMBER;
            }
            break;
         case ST_SECOND_NUMBER:
            if (buffer[ndx] == '.')
            {
               state = ST_SECOND_DOT;
            }
            else if (!MHEG5IsDigit(buffer[ndx], 16, &value))
            {
               state = ST_ERROR;
            }
            else
            {
               transportStreamId *= 16;
               transportStreamId += value;
            }
            break;
         case ST_SECOND_DOT:
            if (!MHEG5IsDigit(buffer[ndx], 16, &value))
            {
               state = ST_ERROR;
            }
            else
            {
               serviceId = value;
               state = ST_THIRD_NUMBER;
            }
            break;
         case ST_THIRD_NUMBER:
            if (!MHEG5IsDigit(buffer[ndx], 16, &value))
            {
               state = ST_ERROR;
            }
            else
            {
               serviceId *= 16;
               serviceId += value;
            }
            break;
         default:
            /* case ST_END, and case ST_ERROR tested outside of switch */
            ;
      }
      ++ndx;
   }
   if (state == ST_THIRD_NUMBER)
   {
      dvb_loc->original_network_id = (U16BIT)originalNetworkId;
      dvb_loc->transport_stream_id = (U16BIT)transportStreamId;
      dvb_loc->service_id = (U16BIT)serviceId;
   }
   else
   {
      rtn_val = MHEG5FALSE;
   }
   return rtn_val;
}

int MHEG5parseLcn( U8BIT *buf, U8BIT *end )
{
   U8BIT *p;
   U32BIT value;
   int lcn = 0;

   for (p = buf; p != end; p++)
   {
      if (MHEG5IsDigit(*p, 10, &value))
      {
         lcn = (lcn * 10) + value;
      }
      else
      {
         break;
      }
   }
   if (p == end)
   {
      return lcn;
   }
   return -1;
}

#ifdef INCLUDE_PVR_AU

static int ParseLocation( char *in_data, int chrs_left, S_LOCATION *p_loc )
{
   int posn = 0, value;

   while (posn != chrs_left && in_data[posn] != '@')
      posn++;

   if (posn == chrs_left ||
       strncmp((char *)in_data, (char *)"dvb://", 6) != 0 ||
       !MHEG5parseDvbUrl((U8BIT *)in_data + 6, posn - 6, &p_loc->dvb_loc ))
   {
      posn = -1;
   }
   else
   {
      int count = 0;
      posn++;
      value = 0;
      while (posn < chrs_left && in_data[posn] != '\"')
      {
         if (in_data[posn] >= '0' && in_data[posn] <= '9')
         {
            switch (count)
            {
               /*YEAR*/
               case 0: value = (int)(in_data[posn] - '0'); break;
               case 1: case 2:
                  value = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               case 3:
                  p_loc->date.year = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               /*MONTH*/
               case 4: value = (int)(in_data[posn] - '0'); break;
               case 5:
                  p_loc->date.month = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               /*DAY*/
               case 6: value = (int)(in_data[posn] - '0'); break;
               case 7:
                  p_loc->date.day = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               /*TIME-HOUR*/
               case 9: value = (int)(in_data[posn] - '0'); break;
               case 10:
                  p_loc->time.hour = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               /*TIME-MINUTE*/
               case 12: value = (int)(in_data[posn] - '0'); break;
               case 13:
                  p_loc->time.minute = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               /*DURATION-HOUR*/
               case 17: value = (int)(in_data[posn] - '0'); break;
               case 18:
                  p_loc->duration.hour = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               /*DURATION-MINUTE*/
               case 20: value = (int)(in_data[posn] - '0'); break;
               case 21:
                  p_loc->duration.minute = (value * 10) + (int)(in_data[posn] - '0');
                  break;
               default:
                  TRACE(TERROR, ("%c count=%d", in_data[posn], count))
                  posn = chrs_left;
                  break;
            }
         }
         else
         {
            switch (count)
            {
               case 8:
                  if (in_data[posn] != 'T')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               case 11:
               case 17:
                  if (in_data[posn] != ':')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               case 14:
                  if (in_data[posn] != '-')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               case 15:
                  if (in_data[posn] != 'P')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               case 16:
                  if (in_data[posn] != 'T')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               case 19:
                  if (in_data[posn] != 'H')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               case 22:
                  if (in_data[posn] != 'M')
                  {
                     TRACE(TERROR, ("%c %d", in_data[posn], in_data[posn]))
                     posn = chrs_left;
                  }
                  break;
               default:
                  TRACE(TERROR, ("%c count=%d", in_data[posn], count))
                  posn = chrs_left;
                  break;
            }
         }
         posn++;
         count++;
      }
      if (count < 23)
      {
         /*error occured*/
         posn = -1;
      }
   }
   return posn;
}

static void* NewLocation( unsigned int val, void *array, void *cptr )
{
   S_LOCATION *pLoc = (S_LOCATION *)cptr;

   memset( pLoc, 0, sizeof(S_LOCATION));
   if (ParseLocation((char *)array, val, pLoc ) == -1)
   {
      return 0;
   }
   return cptr;
}

static void* DoneLocation( unsigned int val, void *array, void *cptr )
{
   S_LOCATION *pLoc = (S_LOCATION *)cptr;
   return (void *)(pLoc + 1);
}

static void* BookingArray( unsigned int val, void *array, void *cptr )
{
   S_BOOKING *pBook;

   switch (val)
   {
      default:
         /* val is number of booking locations */
         pBook = MHEG5getMem( sizeof(S_BOOKING) + (val * sizeof(S_LOCATION)));
         if (pBook != NULL)
         {
            *p_booking_ptr = pBook;
            p_booking_ptr = &(pBook->next);
            pBook->next = NULL;
            pBook->num_locs = val;
            pBook->p_locs = (S_LOCATION *)(pBook + 1);
            return pBook->p_locs;
         }

      case JSON_VALUE_FINISH:
         TRACE(TERROR, ("Array FINISH"))
         break;

      case JSON_VALUE_ERROR:
         TRACE(TERROR, ("Array ERROR"))
         break;
   }
   return 0;
}

int MHEG5parseDecodeBookings( MHEG5String bookingString, S_CRID_DETAILS *pDetails )
{   /* Decode string in the format described by the [JSON] schema */
   int result = FALSE;

   memset( pDetails, 0, sizeof(S_CRID_DETAILS));
   p_booking_ptr = &(pDetails->bookings);

   if (JSON_Parse( bookingString.data, bookingString.len, crid_members, pDetails ) == JSON_OKAY)
   {
      if (ctype_str.zlen == 2 && ctype_str.zptr != NULL &&
          title_str.zptr != NULL && synop_str.zptr != NULL)
      {
         if (ctype_str.zptr[0] == '4' && ctype_str.zptr[1] == '9')
         {
            result = TRUE;
            pDetails->type = 49;
         }
         else if (ctype_str.zptr[0] == '5' && ctype_str.zptr[1] == '0')
         {
            result = TRUE;
            pDetails->type = 50;
         }
      }
   }
   ctype_str.zptr = NULL;
   ctype_str.zlen = 0;
   pDetails->title = title_str;
   title_str.zptr = NULL;
   title_str.zlen = 0;
   pDetails->description = synop_str;
   synop_str.zptr = NULL;
   synop_str.zlen = 0;
   if (!result)
   {
      MHEG5freeDecodeBookings( pDetails );
   }
   return result;
}

void MHEG5freeDecodeBookings( S_CRID_DETAILS *pDetails )
{
   if (pDetails->title.zptr != NULL)
   {
      JSON_FreeAstring( &pDetails->title );
   }
   if (pDetails->description.zptr != NULL)
   {
      JSON_FreeAstring( &pDetails->description );
   }
   if (pDetails->bookings != NULL)
   {
      S_BOOKING *pNext, *pBook = pDetails->bookings;
      do
      {
         pNext = pBook->next;
         MHEG5freeMem( pBook );
         pBook = pNext;
      }
      while (pBook != NULL);
   }
}

char* ParseCatHexNum( char *p_os, U16BIT num )
{
   const char ch[16] = "0123456789abcdef";
   if (num > 0x000)
   {
      if (num > 0x00f)
      {
         if (num > 0x0f0)
         {
            if (num > 0xf00)
            {
               *p_os = ch[(num >> 12) & 0xf];
               p_os++;
            }
            *p_os = ch[(num >> 8) & 0xf];
            p_os++;
         }
         *p_os = ch[(num >> 4) & 0xf];
         p_os++;
      }
      *p_os = ch[(num >> 0) & 0xf];
      p_os++;
   }
   return p_os;
}

char* ParseCatDecNum( char *p_os, U16BIT num )
{
   U16BIT n = num, c = 0;
   char ch[7];
   while (n != 0)
   {
      ch[c++] = (char)(n % 10) + '0';
      n = n / 10;
   }
   while (c < 2)
   {
      ch[c++] = '0';
   }
   while (c--)
   {
      *p_os = ch[c];
      p_os++;
   }
   return p_os;
}

void MHEG5parseEncodeBooking( S_CRID_DETAILS *pDetails, MHEG5String out_str )
{
   U32BIT n_locs;

   assert( pDetails );
   assert( pDetails->bookings );

   n_locs = pDetails->bookings->num_locs;
   /* Check that num_locs has some sensible value,
    * it seems crazy for there to be anywhere near as many as 16 locations for one booking */
   if (n_locs != 0 && n_locs < 16)
   {
      MHEG5Int len;

      len = sizeof(BKG_CRID_TTL_STRING);
      len += pDetails->title.zlen;
      len += sizeof(BKG_SYNOPSIS_STRING);
      len += pDetails->description.zlen;
      len += sizeof(BKG_BOOKING_PREFIX);
      /* 65 is length of '"location":"dvb://233a.1234.5678@20091128T15:00+01:00--PT00H20M",' i.e. max poss for a location */
      len += 65 * n_locs;
      len += sizeof(BKG_BOOKING_ENDFIX);

      out_str.data = (MHEG5Byte *)MHEG5getMem( len );

      if (out_str.data != NULL)
      {
         S_LOCATION *p_loc = pDetails->bookings->p_locs;
         char *os_data = (char *)out_str.data;

         len = sizeof(BKG_CRID_TTL_STRING);
         memcpy(os_data, BKG_CRID_TTL_STRING, len);
         if (pDetails->type == 50)
         {
            while (*os_data != '4')
               os_data++;
            *os_data = '5';
            os_data++;
            *os_data = '0';
            os_data = (char *)&out_str.data[len];
         }
         else
         {
            os_data += len;
         }
         memcpy(os_data, pDetails->title.zptr, pDetails->title.zlen);
         os_data += pDetails->title.zlen;

         memcpy(os_data, BKG_SYNOPSIS_STRING, sizeof(BKG_SYNOPSIS_STRING));
         os_data += sizeof(BKG_SYNOPSIS_STRING);

         memcpy(os_data, pDetails->description.zptr, pDetails->description.zlen);
         os_data += pDetails->description.zlen;

         memcpy(os_data, BKG_BOOKING_PREFIX, sizeof(BKG_BOOKING_PREFIX));
         os_data += sizeof(BKG_BOOKING_PREFIX);

         do
         {
            assert( p_loc->dvb_loc.original_network_id != 0 && p_loc->dvb_loc.service_id != 0 );

            memcpy(os_data, BKG_LOCATION_PREFIX, sizeof(BKG_LOCATION_PREFIX));
            os_data += sizeof(BKG_LOCATION_PREFIX);

            /* dvb location stuff */
            os_data = ParseCatHexNum( os_data, p_loc->dvb_loc.original_network_id );
            *os_data = '.';
            os_data++;
            os_data = ParseCatHexNum( os_data, p_loc->dvb_loc.transport_stream_id );
            *os_data = '.';
            os_data++;
            os_data = ParseCatHexNum( os_data, p_loc->dvb_loc.service_id );
            *os_data = '@';
            os_data++;
            os_data = ParseCatDecNum( os_data, p_loc->date.year );
            os_data = ParseCatDecNum( os_data, p_loc->date.month );
            os_data = ParseCatDecNum( os_data, p_loc->date.day );
            *os_data = 'T';
            os_data++;
            os_data = ParseCatDecNum( os_data, p_loc->time.hour );
            *os_data = ':';
            os_data++;
            os_data = ParseCatDecNum( os_data, p_loc->time.minute );
            *os_data = '+';
            os_data++;
            os_data = ParseCatDecNum( os_data, p_loc->offset.hour );
            *os_data = ':';
            os_data++;
            os_data = ParseCatDecNum( os_data, p_loc->offset.minute );

            memcpy(os_data, BKG_DURATION_PREFIX, sizeof(BKG_DURATION_PREFIX));
            os_data += sizeof(BKG_DURATION_PREFIX);

            os_data = ParseCatDecNum( os_data, p_loc->duration.hour );
            *os_data = 'H';
            os_data++;
            os_data = ParseCatDecNum( os_data, p_loc->duration.minute );
            *os_data = 'M';
            os_data++;
            *os_data = '\"';
            os_data++;
            if (n_locs > 1)
            {
               *os_data = ',';
               os_data++;
            }
            p_loc++;
         }
         while (--n_locs);

         memcpy(os_data, BKG_BOOKING_ENDFIX, sizeof(BKG_BOOKING_ENDFIX));
         os_data += sizeof(BKG_BOOKING_ENDFIX);

         *os_data = 0; /* nul terminate */
         out_str.len = (int)os_data - (int)out_str.data;
      }
   }
   else
   {
      TRACE(TERROR, ("Invalid number of locations %d", n_locs))
   }
}

#endif /*INCLUDE_PVR_AU*/


MHEG5Bool MHEG5parseEncodeQPrintable(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Generic *value)
{
   MHEG5Bool success;
   MHEG5Byte *data;
   MHEG5Int len;

   switch (value->type)
   {
      case MHEG5INT:
         success = AppendInteger(buffer, used, allocated, value->value.i);
         break;

      case MHEG5BOOL:
         if (value->value.b)
         {
            success = AppendString(buffer, used, allocated,
                  (MHEG5Byte *)"True", 4);
         }
         else
         {
            success = AppendString(buffer, used, allocated,
                  (MHEG5Byte *)"False", 5);
         }
         break;

      case MHEG5OCTETSTRING:
         success = EncodeOctetString(buffer, used, allocated,
               value->value.s.data,
               value->value.s.len);
         break;

      case MHEG5CONTENTREF:
         success = EncodeOctetString(buffer, used, allocated,
               value->value.s.data,
               value->value.s.len);
         break;

      case MHEG5OBJECTREF:
         if (value->value.o.gref.len == 0)
         {
            data = value->value.o.gref.ptr.group->groupName.data;
            len = value->value.o.gref.ptr.group->groupName.len;
         }
         else
         {
            data = value->value.o.gref.ptr.name;
            len = value->value.o.gref.len;
         }
         success = AppendChar(buffer, used, allocated, '(');
         if (success)
         {
            success = EncodeOctetString(buffer, used, allocated, data, len);
         }
         if (success)
         {
            success = AppendChar(buffer, used, allocated, ' ');
         }
         if (success)
         {
            success = AppendInteger(buffer, used, allocated, value->value.o.id);
         }
         if (success)
         {
            success = AppendChar(buffer, used, allocated, ')');
         }
         break;

      default:
         success = MHEG5FALSE;
   }

   return success;
}

static MHEG5Bool EncodeOctetString(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte *data,
   MHEG5Int len)
{
   MHEG5Int i;
   MHEG5Bool success;

   success = MHEG5TRUE;
   for (i = 0; success && i < len; ++i)
   {
      success = EncodeChar(buffer, used, allocated, data[i]);
   }

   return success;
}

static MHEG5Bool EncodeChar(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte ch)
{
   MHEG5Bool success;
   MHEG5Byte digit;

   if (ch == 0x0d)
   {
      /* Carriage-Return */
      success = AppendChar(buffer, used, allocated, '\n');
   }
   else if (ch == 0x09)
   {
      /* Tab */
      success = AppendChar(buffer, used, allocated, '\t');
   }
   else if (ch >= 0x20 && ch < 0x7f && ch != '=' && ch != '\'')
   {
      /* Printable character */
      success = AppendChar(buffer, used, allocated, ch);
   }
   else
   {
      /* Encode */
      success = AppendChar(buffer, used, allocated, '=');
      if (success)
      {
         digit = (ch >> 4);
         if (digit < 10)
         {
            digit = '0' + digit;
         }
         else
         {
            digit = 'A' + digit - 10;
         }
         success = AppendChar(buffer, used, allocated, digit);
      }
      if (success)
      {
         digit = ch & 0xf;
         if (digit < 10)
         {
            digit = '0' + digit;
         }
         else
         {
            digit = 'A' + digit - 10;
         }
         success = AppendChar(buffer, used, allocated, digit);
      }
   }

   return success;
}

static MHEG5Bool AppendString(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte *data,
   MHEG5Int len)
{
   MHEG5Int i;
   MHEG5Bool success;

   success = MHEG5TRUE;
   for (i = 0; success && i < len; ++i)
   {
      success = AppendChar(buffer, used, allocated, data[i]);
   }

   return success;
}

static MHEG5Bool AppendInteger(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Int value)
{
   char decimal[MAX_INT_LENGTH];
   MHEG5Int nbytes, i;
   MHEG5Bool success;

   nbytes = sprintf(decimal, "%ld", value);
   success = MHEG5TRUE;
   for (i = 0; success && i < nbytes; ++i)
   {
      success = AppendChar(buffer, used, allocated, decimal[i]);
   }

   return success;
}

static MHEG5Bool AppendChar(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte ch)
{
   MHEG5Int new_size;
   MHEG5Byte *new_block;
   MHEG5Bool success;

   success = MHEG5FALSE;

   if (*buffer != NULL && *used + 1 < *allocated)
   {
      (*buffer)[*used] = ch;
      ++(*used);
      (*buffer)[*used] = '\0';
      success = MHEG5TRUE;
   }
   else if (*buffer == NULL)
   {
      *buffer = MHEG5getMem(MIN_DATA_BLOCK);
      if (*buffer != NULL)
      {
         (*buffer)[0] = ch;
         (*buffer)[1] = '\0';
         *used = 1;
         *allocated = MIN_DATA_BLOCK;
         success = MHEG5TRUE;
      }
   }
   else
   {
      new_size = *allocated * 2;
      new_block = MHEG5getMem(new_size);
      if (new_block != NULL)
      {
         memcpy(new_block, *buffer, *used);
         MHEG5freeMem(*buffer);
         *buffer = new_block;
         *allocated = new_size;
         (*buffer)[*used] = ch;
         ++(*used);
         (*buffer)[*used] = '\0';
         success = MHEG5TRUE;
      }
      else
      {
         MHEG5freeMem(*buffer);
         *buffer = NULL;
      }
   }

   return success;
}

#ifdef INCLUDE_IC

MHEG5Bool MHEG5parseEncodeField(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5String *name,
   MHEG5Generic *value)
{
   MHEG5Byte *data;
   MHEG5Int len;
   MHEG5Bool success;

   success = MHEG5TRUE;

   if (*buffer != NULL && *used > 0)
   {
      success = AppendChar(buffer, used, allocated, '&');
   }
   if (success)
   {
      success = AddOctetString(buffer, used, allocated,
            name->data, name->len);
   }
   if (success)
   {
      success = AppendChar(buffer, used, allocated, '=');
   }
   if (success)
   {
      switch (value->type)
      {
         case MHEG5INT:
            success = AppendInteger(buffer, used, allocated, value->value.i);
            break;
         case MHEG5BOOL:
            if (value->value.b)
            {
               success = AddOctetString(buffer, used, allocated,
                     (MHEG5Byte *)"true", 4);
            }
            else
            {
               success = AddOctetString(buffer, used, allocated,
                     (MHEG5Byte *)"false", 5);
            }
            break;
         case MHEG5OCTETSTRING:
            success = AddOctetString(buffer, used, allocated,
                  value->value.s.data,
                  value->value.s.len);
            break;
         case MHEG5CONTENTREF:
            success = AddOctetString(buffer, used, allocated,
                  value->value.s.data,
                  value->value.s.len);
            break;
         case MHEG5OBJECTREF:
            if (value->value.o.gref.len == 0)
            {
               data = value->value.o.gref.ptr.group->groupName.data;
               len = value->value.o.gref.ptr.group->groupName.len;
            }
            else
            {
               data = value->value.o.gref.ptr.name;
               len = value->value.o.gref.len;
            }
            success = AddOctetString(buffer, used, allocated, data, len);
            if (success)
            {
               success = AddEncodedChar(buffer, used, allocated, ',');
            }
            if (success)
            {
               success = AppendInteger(buffer, used, allocated,
                     value->value.o.id);
            }
            break;
         default:
            success = MHEG5FALSE;
      }
   }

   return success;
}

static MHEG5Bool AddOctetString(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte *data,
   MHEG5Int len)
{
   MHEG5Int i;
   MHEG5Bool success;

   success = MHEG5TRUE;
   for (i = 0; success && i < len; ++i)
   {
      success = AddEncodedChar(buffer, used, allocated, data[i]);
   }

   return success;
}

static MHEG5Bool AddEncodedChar(MHEG5Byte **buffer, MHEG5Int *used,
   MHEG5Int *allocated, MHEG5Byte ch)
{
   MHEG5Bool success;
   static MHEG5Byte hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
                              '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

   if ((ch >= '0' && ch <= '9') ||
       (ch >= 'A' && ch <= 'Z') ||
       (ch >= 'a' && ch <= 'z') ||
       (ch == '-' || ch == '.' || ch == '_' || ch == '~'))
   {
      success = AppendChar(buffer, used, allocated, ch);
   }
   else if (ch == ' ')
   {
      /* convert to '+' */
      success = AppendChar(buffer, used, allocated, '+');
   }
   else
   {
      /* percent-encode */
      success = AppendChar(buffer, used, allocated, '%');
      if (success)
      {
         success = AppendChar(buffer, used, allocated, hex[ch >> 4]);
      }
      if (success)
      {
         success = AppendChar(buffer, used, allocated, hex[ch & 0xf]);
      }
   }

   return success;
}

#endif  /* INCLUDE_IC */