mg_hkfont.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 <stdio.h>
#ifdef HK_PROFILE
#include <string.h>

#include <ft2build.h>
#include FT_FREETYPE_H

#include "mg_drawtext.h"
#include "mg_hkfont.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "mg_ctxt.h"
#include "mg_osd.h"
#include "osd_utils.h"
#include "stb_osd.h"

#include "dvb_font.h"

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

/* Unicode control characters: non-printable */
#define U_CTRL_NULL  0x00
#define U_CTRL_A     0x01
#define U_CTRL_B     0x02
#define U_CTRL_C     0x03
#define U_CTRL_D     0x04
#define U_CTRL_E     0x05
#define U_CTRL_F     0x06
#define U_CTRL_G     0x07
#define U_CTRL_H     0x08
#define U_CTRL_K     0x0B
#define U_CTRL_L     0x0C
#define U_CTRL_N     0x0E
#define U_CTRL_O     0x0F
#define U_CTRL_P     0x10
#define U_CTRL_Q     0x11
#define U_CTRL_R     0x12
#define U_CTRL_S     0x13
#define U_CTRL_T     0x14
#define U_CTRL_U     0x15
#define U_CTRL_V     0x16
#define U_CTRL_W     0x17
#define U_CTRL_X     0x18
#define U_CTRL_Y     0x19
#define U_CTRL_Z     0x1A
#define U_CTRL_FS    0x1C
#define U_CTRL_GS    0x1D
#define U_CTRL_RS    0x1E
#define U_CTRL_US    0x1F


/* Unicode character values */
#define UNICODE_SPACE                       (' ')
#define UNICODE_TAB                         ('\t')
#define UNICODE_LF                          (0x0a)
#define UNICODE_CR                          (0x0d)
#define UNICODE_ESC                         (0x1b)
#define UNICODE_HARD_SPACE                  (0xa0)
#define UNICODE_FIGURE_SPACE                (0x2007)
#define UNICODE_APOSTROPHE_N                (0x0149)
#define UNICODE_HYPER_ANCHOR_START          (0x41)
#define UNICODE_HYPER_ANCHOR_END            (0x61)
#define UNICODE_TEXT_COLOUR_START           (0x43)
#define UNICODE_TEXT_COLOUR_END             (0x63)
#define UNICODE_HYPER_ATTRIB_START          (0x44)
#define UNICODE_HYPER_ATTRIB_END            (0x64)

/* HK profile: dont break after chars */
#define UNICODE_QUOTE                        ('"')
#define UNICODE_LEFT_ROUND                   ('(')
#define UNICODE_LEFT_SQUARE                  ('[')
#define UNICODE_LEFT_CURLY                   ('{')
#define UNICODE_LEFT_DQUOTE                  0x201C
#define UNICODE_LEFT_PANGLE                  0x2039
#define UNICODE_LEFT_FULL_CURLY              0xFF5B
#define UNICODE_LEFT_FULL_ROUND              0xFF08
#define UNICODE_LEFT_FULL_SQUARE             0xFF3B
#define UNICODE_LEFT_FULL_DROUND             0xFF5F
#define UNICODE_LEFT_FULL_DQUOTE             0xFF02

/* HK profile: dont break before chars */
#define UNICODE_QUOTE                         ('"')
#define UNICODE_RIGHT_ROUND                   (')')
#define UNICODE_RIGHT_SQUARE                  (']')
#define UNICODE_RIGHT_CURLY                   ('}')
#define UNICODE_RIGHT_DQUOTE                  0x201D
#define UNICODE_RIGHT_PANGLE                  0x203A
#define UNICODE_RIGHT_FULL_CURLY              0xFF5D
#define UNICODE_RIGHT_FULL_ROUND              0xFF09
#define UNICODE_RIGHT_FULL_SQUARE             0xFF3D
#define UNICODE_RIGHT_FULL_DROUND             0xFF60
#define UNICODE_RIGHT_FULL_DQUOTE             0xFF02
#define UNICODE_FULL_QUESTIONMARK             0xFF1F
#define UNICODE_QUESTIONMARK                  0x003F
#define UNICODE_EXCLAMATIONMARK               0x0021
#define UNICODE_FULL_STOP                     ('.')
#define UNICODE_COMMA                         (',')
#define UNICODE_COMMA_FULL                    0xFF0C
#define UNICODE_FULL_STOP_FULL                0xFF0E
#define UNICODE_COLON                         (':')
#define UNICODE_SEMICOLON                     (';')
#define UNICODE_FULL_SEMICOLON                0xFF1B
#define IDEOGRAPHIC_COMMA                     0x3001
#define IDEOGRAPHIC_FULL_STOP                 0x3002

#define HIGH_SURROGATE_START                  0xD800
#define HIGH_SURROGATE_END                    0xDBFF
#define LOW_SURROGATE_START                   0xDC00
#define LOW_SURROGATE_END                     0xDFFF
#define FULL_ADVANCE 1
#define HALF_ADVANCE 2
#define NO_ADVANCE   3

#if 0
#define DIV(x, y) ((((x) * 10) / (y) + 5) / 10)
#else
#define DIV(x, y) ((x) / (y))
#endif

/* SD-HD scaling function, using the existing mg_context */
#define SCALE_X_TO_HD(X) DIV((X * mg_ctxt.osd_x.mlt), mg_ctxt.osd_x.div)
#define SCALE_Y_TO_HD(Y) DIV((Y * mg_ctxt.osd_y.mlt), mg_ctxt.osd_y.div)

/* checks for breakable whitespace */
#define IS_WHITESPACE(X)  ((X) == UNICODE_SPACE || (X) == UNICODE_TAB)

#define SRC_FORE_MAX                         255
#define FactorForeAlpha(fore_value, fore_col) fore_value *= (fore_col >> 24)
#define NotTransTDColor( col )               ((col >> 12) != 0x0)
#define NotOpaqueTDColor( col )              ((col >> 12) != 0xf)


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


typedef struct fontLibrary_s
{
   FT_Library library;
   FT_Face face;
} fontLibrary_t;

typedef struct metrics_s
{
   S32BIT fullAdvance;
   S32BIT halfAdvance;
   S32BIT xOffsetLeft;
   S32BIT yMin;
   S32BIT yMax;
} metrics_t;

/* a character to be rendered */
typedef struct textChar_s
{
   U32BIT uchar;                /* The utf-16 character to print*/
   U16BIT position;             /* X position of the origin of the character */
   U8BIT advanceType;           /* whether the advance is full or half width*/
   U32BIT advance;              /* character advance in pixels*/
   OSDColor colour;             /* ARGB colour (per char) */
   struct textChar_s *next;     /* Next char on the line, NULL if last in line */
   struct textChar_s *previous; /* Previous char on the line, NULL if first in the line */
} textChar_t;

/* A line of characters */
typedef struct textLine_s
{
   textChar_t *firstChar;   /* first character item in line*/
   textChar_t *lastChar;    /* last character item in line*/
   U16BIT fullCharCount;    /* number of full-width chars */
   U16BIT halfCharCount;    /* number of half-width chars */
   U16BIT position;         /* Y position of the line */
   struct textLine_s *next; /* Next line */
   struct textLine_s *previous; /* previous line */
   struct textItem_s *parentObject; /* pointer to the text object containing the line */
} textLine_t;

/* justification function pointer prototype */
typedef void (*justify_fn)(struct textItem_s *textObject);

/* parsed text data structure*/
typedef struct textItem_s
{
   U32BIT boxX, boxY;              /* text box dimensions */
   S_SURFACE *canvas;              /* surface and associated data */
   justify_fn vJustify, hJustify;  /* pointers to justification functions */
   U16BIT *chars;                  /* original string */
   U32BIT charsLen;                /* length of the chars string */
   U16BIT lineCount;               /* number of lines created (CRs and wrapping) */
   U16BIT maxLines;                /* maximum displayable lines of text */
   metrics_t *metrics;             /* metic table for the required font size*/
   pDrawTextAttrib attribs;        /* attributes of the text object */
   textLine_t *firstLine;          /* pointer to the first line */
   textLine_t *lastLine;           /* pointer to the last line */
} textItem_t;

/* structure to build a stack of colours for markup */
typedef struct colourNode_s
{
   OSDColor colour;
   struct colourNode_s *previous;
} colourNode_t;


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

static fontLibrary_t *font = NULL;
static colourNode_t *colourStack = NULL;

/*metrics taken from the profile specification*/
static metrics_t metrics24Point = {22, 11, 1, -3, 18};
static metrics_t metrics26Point = {24, 12, 1, -3, 20};
static metrics_t metrics31Point = {28, 14, 1, -4, 23};
static metrics_t metrics36Point = {32, 16, 2, -4, 27};

static U16BIT overwrite_caret = ENTRY_OVERWRITE_CHAR;
static U16BIT insert_caret = ENTRY_INSERT_CHAR;
/*---local function definitions----------------------------------------------*/

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


static void DestructColourStack(void)
{
   colourNode_t *previous;
   while (colourStack != NULL)
   {
      previous = colourStack->previous;
      STB_MemFree(colourStack);
      colourStack = previous;
   }
}

static void InitColourStack(OSDColor colour)
{
   if (colourStack != NULL)
   {
      DestructColourStack();
   }
   colourStack = STB_MemAlloc(sizeof(colourNode_t));
   colourStack->previous = NULL;
   colourStack->colour = colour;
}

static void PushColour(OSDColor colour)
{
   colourNode_t *new;
   new = STB_MemAlloc(sizeof(colourNode_t));
   new->previous = colourStack;
   new->colour = colour;
   colourStack = new;
}

static OSDColor PopColour(void)
{
   colourNode_t *previous;
   if (colourStack->previous != NULL)
   {
      previous = colourStack->previous;
      STB_MemFree(colourStack);
      colourStack = previous;
   }
   return colourStack->colour;
}

static U16BIT* ReadHyperAttribs(U16BIT *string, pHyperAttribs ha)
{
   U16BIT tagLength;
   U16BIT bytesLeft;
   U16BIT *cursor = string;
   BOOLEAN linkColourEnabled = FALSE;
   BOOLEAN activeColourEnabled = FALSE;
   BOOLEAN visitedColourEnabled = FALSE;
   if ((ha != NULL))
   {
      /*move to the tag length byte*/
      cursor++;
      tagLength = *cursor;
      bytesLeft = tagLength;
      if (bytesLeft >= 2)
      {
         cursor += 2;
         if (((*cursor) & 0x08) != 0)
         {
            ha->anchor_wrap = TRUE;
         }
         else
         {
            ha->anchor_wrap = FALSE;
         }

         if (((*cursor) & 0x40) != 0)
         {
            linkColourEnabled = TRUE;
         }
         if (((*cursor) & 0x20) != 0)
         {
            activeColourEnabled = TRUE;
         }
         if (((*cursor) & 0x10) != 0)
         {
            visitedColourEnabled = TRUE;
         }
         bytesLeft -= 2;
      }
      if (bytesLeft >= 4 && linkColourEnabled)
      {
         ha->link_colour = RGBT(cursor[0], cursor[1], cursor[2], cursor[3]);
         cursor += 4;
         bytesLeft -= 4;
      }
      if (bytesLeft >= 4 && activeColourEnabled)
      {
         ha->active_colour = RGBT(cursor[0], cursor[1], cursor[2], cursor[3]);
         cursor += 4;
         bytesLeft -= 4;
      }
      if (bytesLeft >= 4 && visitedColourEnabled)
      {
         ha->visit_colour = RGBT(cursor[0], cursor[1], cursor[2], cursor[3]);
         cursor += 4;
         bytesLeft -= 4;
      }
   }
   /*return the end position: original + tag length + 1*/
   return string + tagLength + 1;
}

static U16BIT* AddHyperAnchor(U16BIT *string, pHyperAttribs ha)
{
   U16BIT *cursor = string;
   if ((ha != NULL))
   {
      ha->number_of_links++;
      if (ha->markup_state == 0)
      {
         ha->markup_state = 2;
      }
      else
      {
         ha->markup_state++;
      }
      if (ha->focus_position == ha->number_of_links)
      {
         PushColour(ha->active_colour);
      }
      else
      {
         PushColour(ha->link_colour);
      }
      /*move to the tag length byte*/
      cursor++;
      /*move forward [tag length] bytes*/
      cursor += (*cursor);
   }
   return cursor;
}

static void EndHyperAnchor(U16BIT *string, pHyperAttribs ha)
{
   if ((ha != NULL))
   {
      PopColour();
   }
}

static void ScaleAllToHD(textItem_t *textObject)
{
   textLine_t *currentLine;
   textChar_t *currentChar;

   /*scale the text box dimensions*/
   textObject->boxX = SCALE_X_TO_HD(textObject->boxX);
   textObject->boxY = SCALE_Y_TO_HD(textObject->boxY);

   /*go through each line*/
   currentLine = textObject->firstLine;
   while (currentLine != NULL)
   {
      /* scale each line position */
      currentLine->position = SCALE_Y_TO_HD(currentLine->position);
      /* go through each character */
      currentChar = currentLine->firstChar;
      while (currentChar != NULL)
      {
         /* scale each character position */
         currentChar->position = SCALE_X_TO_HD(currentChar->position);
         currentChar = currentChar->next;
      }
      currentLine = currentLine->next;
   }
}

static textChar_t* NewCharacter(U32BIT *pCharacter)
{
   textChar_t *newChar;
   newChar = STB_MemAlloc(sizeof(textChar_t));
   if (newChar != NULL)
   {
      newChar->uchar = *pCharacter;
      newChar->next = NULL;
   }
   return newChar;
}

static textLine_t* NewLine(textItem_t *parent)
{
   textLine_t *newLine;

   newLine = STB_MemAlloc(sizeof(textLine_t));
   if (newLine != NULL)
   {
      newLine->firstChar = NULL;
      newLine->lastChar = NULL;
      newLine->fullCharCount = 0;
      newLine->halfCharCount = 0;
      newLine->next = NULL;
      newLine->parentObject = parent;
      /* add the new line to the end of the text object */
      if (parent->lastLine != NULL)
      {
         parent->lastLine->next = newLine;
         newLine->previous = parent->lastLine;
      }
      else
      {
         newLine->previous = NULL;
      }
      /*set it as the new lastLine in the object*/
      parent->lastLine = newLine;
      parent->lineCount++;
   }
   return newLine;
}

static void DeleteChar(textChar_t *pChar, textLine_t *line)
{
   if (pChar->advanceType == FULL_ADVANCE)
   {
      line->fullCharCount--;
   }
   else if (pChar->advanceType == HALF_ADVANCE)
   {
      line->halfCharCount--;
   }
   STB_MemFree(pChar);
}

static void DeleteRemainingChars(textChar_t *pChar, textLine_t *line)
{
   textChar_t *cursor, *next;

   cursor = pChar;
   if (pChar->previous != NULL)
   {
      pChar->previous->next = NULL;
   }

   while (cursor != NULL)
   {
      next = cursor->next;
      DeleteChar(cursor, line);
      cursor = next;
   }
}

static void DestructLine(textLine_t *line)
{
   DeleteRemainingChars(line->firstChar, line);
   STB_MemFree(line);
}

static void DestructTextObject(textItem_t *text)
{
   textLine_t *cursor, *next;

   cursor = text->firstLine;
   while (cursor != NULL)
   {
      next = cursor->next;
      DestructLine(cursor);
      cursor = next;
   }
   STB_MemFree(text);
}

static BOOLEAN CharIsPrintable(U16BIT uchar, int characterSet)
{
   BOOLEAN print;
   /*if we are using the HK character set*/
   if (characterSet == 12)
   {
      /*if the value is higher than the highest value control character
         it is "printable" (for now)*/
      if (uchar > U_CTRL_US)
      {
         print = TRUE;
      }
      else
      {
         print = FALSE;
      }
   }
   else /*UK character set*/
   {
      /* only allow latin characters*/
      if (uchar > U_CTRL_US && uchar < 0x2000)
      {
         print = TRUE;
      }
      else
      {
         print = FALSE;
      }
   }
   return print;
}

static U32BIT PointsToPixels(U32BIT points, pDrawTextAttrib attribs)
{
   U32BIT pixels;
   switch (attribs->font.fp.style)
   {
      case FONT_STYLE_PLAIN:
         pixels = (points * 45) / 56;
         break;
      case FONT_STYLE_SQUARE:
         pixels = (points * 45) / 64;
         break;
   }
   return pixels;
}

static U32BIT GetLineLengthPixels(textLine_t *line)
{
   U32BIT lineLengthPts;
   U32BIT letterSpaces;
   U32BIT charsWidth;
   textItem_t *text;
   U32BIT fullCharCount = line->fullCharCount;
   U32BIT halfCharCount = line->halfCharCount;

   text = line->parentObject;

   letterSpaces = DIV(((fullCharCount + halfCharCount - 1) * text->attribs->letter_space), 255);

   charsWidth = ((fullCharCount * text->metrics->fullAdvance) + (halfCharCount * text->metrics->halfAdvance));

   lineLengthPts = charsWidth + letterSpaces + text->metrics->xOffsetLeft;

   /*test suite converts points to pixels 1:1*/
#if 1
   return lineLengthPts;
#else
   U32BIT lineLengthPixels;
   lineLengthPixels = PointsToPixels(lineLengthPts, line->parentObject->attribs);
   return lineLengthPixels;
#endif
}

static BOOLEAN IsBreakable(U16BIT character)
{
   BOOLEAN isBreakable;
   if (character >= 0xF900 && character <= 0xFAFF)
      isBreakable = TRUE;
   else if (character >= 0x3190 && character <= 0x319F)
      isBreakable = TRUE;
   else if (character >= 0x4E00 && character <= 0x9FFF)
      isBreakable = TRUE;
   else if (character >= 0x3200 && character <= 0x32FF)
      isBreakable = TRUE;
   else
      isBreakable = FALSE;
   return isBreakable;
}

static BOOLEAN DontBreakBefore(U16BIT character)
{
   switch (character)
   {
      case UNICODE_QUOTE:
      case UNICODE_RIGHT_ROUND:
      case UNICODE_RIGHT_SQUARE:
      case UNICODE_RIGHT_CURLY:
      case UNICODE_RIGHT_DQUOTE:
      case UNICODE_RIGHT_PANGLE:
      case UNICODE_RIGHT_FULL_CURLY:
      case UNICODE_RIGHT_FULL_ROUND:
      case UNICODE_RIGHT_FULL_SQUARE:
      case UNICODE_RIGHT_FULL_DROUND:
      case UNICODE_RIGHT_FULL_DQUOTE:
      case UNICODE_QUESTIONMARK:
      case UNICODE_FULL_QUESTIONMARK:
      case UNICODE_EXCLAMATIONMARK:
      case UNICODE_FULL_STOP:
      case UNICODE_COMMA:
      case UNICODE_FULL_STOP_FULL:
      case UNICODE_COMMA_FULL:
      case UNICODE_COLON:
      case UNICODE_SEMICOLON:
      case UNICODE_FULL_SEMICOLON:
      case UNICODE_HARD_SPACE:
      case IDEOGRAPHIC_COMMA:
      case IDEOGRAPHIC_FULL_STOP:
         return TRUE;
      default:
         return FALSE;
   }
}

static BOOLEAN DontBreakAfter(U16BIT character)
{
   switch (character)
   {
      case UNICODE_QUOTE:
      case UNICODE_LEFT_ROUND:
      case UNICODE_LEFT_SQUARE:
      case UNICODE_LEFT_CURLY:
      case UNICODE_LEFT_DQUOTE:
      case UNICODE_LEFT_PANGLE:
      case UNICODE_LEFT_FULL_CURLY:
      case UNICODE_LEFT_FULL_ROUND:
      case UNICODE_LEFT_FULL_SQUARE:
      case UNICODE_LEFT_FULL_DROUND:
      case UNICODE_LEFT_FULL_DQUOTE:
      case UNICODE_HARD_SPACE:
      case UNICODE_FIGURE_SPACE:
         return TRUE;
      default:
         return FALSE;
   }
}

static void DeleteFollowingWhitespace(textLine_t *line)
{
   textChar_t *cursor;
   cursor = line->lastChar;
   while (IS_WHITESPACE(cursor->uchar))
   {
      cursor = cursor->previous;
   }
   if (cursor->next != NULL)
   {
      DeleteRemainingChars(cursor->next, line);
   }
}

static void DoWrapping(textItem_t *text)
{
   textLine_t *currentLine;
   textLine_t *newLine;
   textChar_t *cursor;
   BOOLEAN breakFound = FALSE;

   currentLine = text->lastLine;

   /*if the character goes over the box boundary*/
   if (GetLineLengthPixels(currentLine) > text->boxX)
   {
      cursor = currentLine->lastChar;

      /*special case where a whitespace char takes the line over the limit*/
      if (IS_WHITESPACE(cursor->uchar))
      {
         currentLine->lastChar = cursor->previous;
         currentLine->lastChar->next = NULL;
         DeleteChar(cursor, currentLine);
         if (text->lineCount < text->maxLines)
         {
            NewLine(text);
         }
         cursor = NULL;
      }
      /*look for a breakpoint*/
      while (!breakFound && cursor != NULL)
      {
         if (IS_WHITESPACE(cursor->uchar))
         {
            /*break after the whitespace if possible*/
            if (cursor->next != NULL)
            {
               cursor = cursor->next;
            }
            breakFound = TRUE;
         }
         /*if current char is DBB or previous char was DBA*/
         else if (DontBreakBefore(cursor->uchar) || DontBreakAfter(cursor->previous->uchar))
         {
            cursor = cursor->previous;
         }
         /*if the current or previous character is breakable */
         else if (IsBreakable(cursor->uchar) || IsBreakable(cursor->previous->uchar))
         {
            breakFound = TRUE;
         }
         else
         {
            cursor = cursor->previous;
         }
      }

      if (breakFound)
      {
         /*put the characters after the breakpoint onto a new line*/
         newLine = NewLine(text);
         cursor->previous->next = NULL;
         newLine->lastChar = currentLine->lastChar;
         currentLine->lastChar = cursor->previous;
         newLine->firstChar = cursor;
         newLine->firstChar->previous = NULL;

         /*go through each character moved to the new line*/
         for (cursor = newLine->firstChar; cursor != NULL; cursor = cursor->next)
         {
            /*move the character count for each onto the new line*/
            if (cursor->advanceType == FULL_ADVANCE)
            {
               currentLine->fullCharCount--;
               newLine->fullCharCount++;
            }
            else if (cursor->advanceType == HALF_ADVANCE)
            {
               currentLine->halfCharCount--;
               newLine->halfCharCount++;
            }
         }

         DeleteFollowingWhitespace(currentLine);
      }
   }
}

static void AddChar(U32BIT *character, textItem_t *text, OSDColor colour)
{
   textLine_t *currentLine;
   textChar_t *newChar;

   currentLine = text->lastLine;

   newChar = NewCharacter(character);
   if (currentLine->firstChar == NULL)
   {
      currentLine->firstChar = newChar;
   }
   newChar->previous = currentLine->lastChar;
   if (currentLine->lastChar != NULL)
   {
      currentLine->lastChar->next = newChar;
   }
   currentLine->lastChar = newChar;
   newChar->colour = colour;

   if (*character < 0x1fff)
   {
      currentLine->halfCharCount++;
      newChar->advanceType = HALF_ADVANCE;
      newChar->advance = text->metrics->halfAdvance;
   }
   else
   {
      currentLine->fullCharCount++;
      newChar->advanceType = FULL_ADVANCE;
      newChar->advance = text->metrics->fullAdvance;
   }

   if (text->attribs->justify & WRAP_WORDS)
   {
      DoWrapping(text);
   }
}

static void AddCaret(textItem_t *text)
{
   textLine_t *currentLine;
   textChar_t *newChar;
   U32BIT *character;
   currentLine = text->lastLine;

   /* Make 'character' point at global var */
   switch (text->attribs->caret)
   {
      case ENTRY_INSERT_CHAR:
         character = (U32BIT *)&insert_caret;
         break;
      case ENTRY_OVERWRITE_CHAR:
         character = (U32BIT *)&overwrite_caret;
         break;
   }

   newChar = NewCharacter(character);
   if (currentLine->firstChar == NULL)
   {
      currentLine->firstChar = newChar;
   }
   newChar->previous = currentLine->lastChar;
   if (currentLine->lastChar != NULL)
   {
      currentLine->lastChar->next = newChar;
   }
   currentLine->lastChar = newChar;
   newChar->colour = text->attribs->fore_colour;

   if (text->attribs->entry_point == text->charsLen)
   {
      currentLine->halfCharCount++;
      newChar->advanceType = HALF_ADVANCE;
      newChar->advance = text->metrics->halfAdvance;
   }
   else
   {
      newChar->advanceType = NO_ADVANCE;
      newChar->advance = 0;
   }

   if (text->attribs->justify & WRAP_WORDS)
   {
      DoWrapping(text);
   }
}

static void GetMaxLines(textItem_t *text)
{
   S32BIT Ymin, Ymax;

   Ymin = 0 - text->metrics->yMin;
   Ymax = text->metrics->yMax;
   text->maxLines = ((text->boxY - (Ymax + Ymin)) / text->attribs->line_space) + 1;

   return;
}

static void FillLines(textItem_t *text)
{
   U16BIT *currentChar;
   OSDColor markupColour;
   U16BIT high_surrogate = 0;
   text->firstLine = NewLine(text);
   text->lastLine = text->firstLine;

   markupColour = text->attribs->fore_colour;

   /*go through the string and fill up the text object*/
   for (currentChar = text->chars; currentChar < text->chars + (text->charsLen); currentChar++)
   {
      if (*currentChar >= HIGH_SURROGATE_START && *currentChar <= HIGH_SURROGATE_END)
      {
         high_surrogate = *currentChar;
         continue;
      }

      if (high_surrogate && *currentChar >= LOW_SURROGATE_START && *currentChar <= LOW_SURROGATE_END)
      {
         /*following rules found on the unicode.org FAQ*/
         U32BIT X, U;
         U32BIT unicode_character;

         X = (high_surrogate & 0x3F) << 10 | (*currentChar & 0x3FF);
         U = ((high_surrogate >> 6) & 0x1F) + 1;
         unicode_character = (U << 16) | X;

         AddChar(&unicode_character, text, markupColour);

         high_surrogate = 0;
         continue;
      }
      else if (high_surrogate)
      {
         high_surrogate = 0;
         continue;
      }
      /*if the current position is the entry point*/
      if (currentChar - text->chars == text->attribs->entry_point)
      {
         /*add the caret*/
         AddCaret(text);
      }

      /*On carriage return character*/
      if (*currentChar == UNICODE_CR)
      {
         /*create new line*/
         NewLine(text);
      }
      /*on markup escape character*/
      else if (*currentChar == UNICODE_ESC)
      {
         /*check the markup code*/
         currentChar++;
         switch (*currentChar)
         {
            case UNICODE_TEXT_COLOUR_START:
               currentChar++;
               if (*currentChar == 4)
               {
                  currentChar++;
                  markupColour = (*currentChar << 16) & 0xff0000;
                  currentChar++;
                  markupColour |= (*currentChar << 8) & 0xff00;
                  currentChar++;
                  markupColour |= *currentChar & 0xff;
                  currentChar++;
                  markupColour |= ((255 - *currentChar) << 24) & 0xff000000;
                  PushColour(markupColour);
               }
               break;
            case UNICODE_TEXT_COLOUR_END:
               markupColour = PopColour();
               break;
            case UNICODE_HYPER_ATTRIB_START:
               currentChar = ReadHyperAttribs(currentChar, text->attribs->p_ha);
               break;
            case UNICODE_HYPER_ANCHOR_START:
               currentChar = AddHyperAnchor(currentChar, text->attribs->p_ha);
               markupColour = colourStack->colour;
               break;
            case UNICODE_HYPER_ANCHOR_END:
               EndHyperAnchor(currentChar, text->attribs->p_ha);
               markupColour = colourStack->colour;
               break;
            default:
               break;
         }
      }
      else if (CharIsPrintable(*currentChar, text->attribs->character_set))
      {
         U32BIT unicode_character = *currentChar;
         AddChar(&unicode_character, text, markupColour);
      }
   }
   if (text->attribs->entry_point == text->charsLen)
   {
      AddCaret(text);
   }
}

static void JustifyHStart(textItem_t *textObject)
{
   textLine_t *currentLine;
   textChar_t *currentChar;
   S32BIT cursor;

   currentLine = textObject->firstLine;
   while (currentLine != NULL)
   {
      currentChar = currentLine->firstChar;
      cursor = textObject->metrics->xOffsetLeft;

      while (currentChar != NULL)
      {
         currentChar->position = cursor;
         if (cursor + (S32BIT)currentChar->advance > (S32BIT)textObject->boxX)
         {
            currentLine->lastChar = currentChar->previous;
            DeleteRemainingChars(currentChar, currentLine);
            currentChar = NULL;
            break;
         }
         else
         {
            cursor += (S32BIT)currentChar->advance;
            currentChar = currentChar->next;
         }
      }

      currentLine = currentLine->next;
   }
}

static void JustifyHCentre(textItem_t *textObject)
{
   textLine_t *currentLine;
   textChar_t *currentChar;
   S32BIT cursor;
   S32BIT lineLength;

   currentLine = textObject->firstLine;
   while (currentLine != NULL)
   {
      lineLength = GetLineLengthPixels(currentLine);
      cursor = ((S32BIT)textObject->boxX - lineLength) / 2;
      currentChar = currentLine->firstChar;

      while (currentChar != NULL)
      {
         currentChar->position = cursor;
         if (cursor + (S32BIT)currentChar->advance > (S32BIT)textObject->boxX)
         {
            currentLine->lastChar = currentChar->previous;
            DeleteRemainingChars(currentChar, currentLine);
            currentChar = NULL;
            break;
         }
         else if (cursor < textObject->metrics->xOffsetLeft)
         {
            currentLine->firstChar = currentChar->next;
            cursor += (S32BIT)currentChar->advance;
            DeleteChar(currentChar, currentLine);
            currentLine->firstChar->previous = NULL;

            currentChar = currentLine->firstChar;
         }
         else
         {
            cursor += (S32BIT)currentChar->advance;
            currentChar = currentChar->next;
         }
      }

      currentLine = currentLine->next;
   }
}

static void JustifyHEnd(textItem_t *textObject)
{
   textLine_t *currentLine;
   textChar_t *currentChar;
   S32BIT cursor;

   currentLine = textObject->lastLine;
   while (currentLine != NULL)
   {
      currentChar = currentLine->lastChar;
      cursor = textObject->boxX - (S32BIT)currentChar->advance;

      while (currentChar != NULL)
      {
         currentChar->position = cursor;
         if (cursor < textObject->metrics->xOffsetLeft)
         {
            /*clever shuffling to delete unneeded chars*/
            currentChar = currentChar->next;
            currentChar->previous->next = NULL;
            DeleteRemainingChars(currentLine->firstChar, currentLine);
            currentLine->firstChar = currentChar;
            currentChar->previous = NULL;
            break;
         }
         else
         {
            currentChar = currentChar->previous;
            if (currentChar != NULL)
            {
               cursor -= (S32BIT)currentChar->advance;
            }
         }
      }

      currentLine = currentLine->previous;
   }
}

static void JustifyVStart(textItem_t *textObject)
{
   textLine_t *currentLine;
   textLine_t *next;
   U32BIT cursor;
   U32BIT lineCount = 0;
   U32BIT yMaxPixels;

   /*calculate positions of lines*/
   currentLine = textObject->firstLine;

   yMaxPixels = textObject->metrics->yMax;

   cursor = yMaxPixels;

   /*slight correction for difference between font size and metrics*/
   cursor += 2;
   while (currentLine != NULL)
   {
      currentLine->position = cursor;
      cursor += textObject->attribs->line_space;
      lineCount++;
      if (lineCount > textObject->maxLines)
      {
         break;
      }
      else
      {
         currentLine = currentLine->next;
      }
   }

   if (currentLine != NULL)
   {
      currentLine->previous->next = NULL;
      while (currentLine != NULL)
      {
         next = currentLine->next;
         DestructLine(currentLine);
         currentLine = next;
      }
   }
}

static void JustifyVCentre(textItem_t *textObject)
{
   textLine_t *currentLine;
   U32BIT cursor;
   U32BIT yMaxPixels, yMinPixels;
   U32BIT linesHeight;

   /*calculate positions of lines*/
   currentLine = textObject->firstLine;

   yMaxPixels = textObject->metrics->yMax;
   yMinPixels = 0 - textObject->metrics->yMin;

   linesHeight = yMaxPixels + yMinPixels + (textObject->attribs->line_space * (textObject->lineCount - 1));
   cursor = (textObject->boxY - linesHeight) / 2;
   cursor += yMaxPixels;

   while (currentLine != NULL)
   {
      currentLine->position = cursor;
      cursor += textObject->attribs->line_space;
      currentLine = currentLine->next;
   }
}

static void JustifyVEnd(textItem_t *textObject)
{
   textLine_t *currentLine;
   U32BIT cursor;
   U32BIT yMinPixels;

   /*calculate positions of lines*/
   currentLine = textObject->lastLine;

   yMinPixels = 0 - textObject->metrics->yMin;

   cursor = textObject->boxY - yMinPixels;

   /*slight correction for difference between font size and metrics*/
   cursor -= 2;

   while (currentLine != NULL)
   {
      currentLine->position = cursor;
      cursor -= textObject->attribs->line_space;
      currentLine = currentLine->previous;
   }
}

static BOOLEAN CreateSurface(textItem_t *textObject)
{
   BOOLEAN success = FALSE;

   textObject->canvas = STB_MemAlloc(sizeof(S_SURFACE));
   if (textObject->canvas != NULL)
   {
      IF_COL_DEPTH(COLOUR_FORMAT_ARGB4444)
      {
         textObject->canvas->hw_handle = STB_OSDMhegCreateSurface(textObject->boxX,
               textObject->boxY,
               TRUE,
               MakeHD2Color(textObject->attribs->back_colour));
      }
      ELSE IF_COL_DEPTH(COLOUR_FORMAT_ARGB8888)
      {
         textObject->canvas->hw_handle = STB_OSDMhegCreateSurface(textObject->boxX,
               textObject->boxY,
               TRUE,
               textObject->attribs->back_colour);
      }

      if (textObject->canvas->hw_handle != NULL)
      {
         textObject->canvas->width = textObject->boxX;
         textObject->canvas->height = textObject->boxY;
         success = TRUE;
      }
   }

   return success;
}

static void BlendColours32(OSDColor *pixel, U32BIT fore_value, OSDColor fore_col)
{
   U32BIT fa, ba, comp, tmp_c, alpha_c;
   ba = *pixel >> 24;

   FactorForeAlpha(fore_value, fore_col);

   alpha_c = ((((255 ^ ba) * fore_value) + 32512) / 65025) + ba;
   fa = (U8BIT)(fore_value / SRC_FORE_MAX);
   ba = (((255 ^ fa) * ba) + 127) / 255;
   tmp_c = alpha_c << 24;
   comp = ba * ((*pixel >> 16) & 0xff) + fa * ((fore_col >> 16) & 0xff);
   tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c) << 16;
   comp = ba * ((*pixel >> 8) & 0xff) + fa * ((fore_col >> 8) & 0xff);
   tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c) << 8;
   comp = ba * (*pixel & 0xff) + fa * (fore_col & 0xff);
   tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c);
   *pixel = tmp_c;
}

static void BlendColours16(HD2Color *pixel, U32BIT fore_value, OSDColor fore_col )
{
   U32BIT fa, ba, comp, tmp_c, alpha_c;
   HD2Color temp_col = MakeHD2Color(fore_col);

   FactorForeAlpha(fore_value, fore_col);
   ba = *pixel >> 12;
   comp = ba * 17;
   alpha_c = ((((15 - ba) * fore_value) + 1912) / 3825) + comp;
   fa = (U8BIT)(fore_value / SRC_FORE_MAX);
   ba = (((255 ^ fa) * comp) + 127) / 255;
   tmp_c = (alpha_c / 17) << 12;
   comp = ba * ((*pixel >> 8) & 0xf) + fa * ((temp_col >> 8) & 0xf);
   tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c) << 8;
   comp = ba * ((*pixel >> 4) & 0xf) + fa * ((temp_col >> 4) & 0xf);
   tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c) << 4;
   comp = ba * (*pixel & 0xf) + fa * (temp_col & 0xf);
   tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c);
   *pixel = tmp_c;
}

static void RenderChar(FT_GlyphSlot glyph, textLine_t *line, textChar_t *charObject)
{
   S_SURFACE *canvas;
   U32BIT glyphHeight;
   U32BIT row_count;
   U32BIT a_point;
   U8BIT *src_buffer, *dest_buffer;
   S32BIT penX, penY;
   OSDColor fore_colour;
   U32BIT fore_value;
   U8BIT *src_pixel;
   OSDColor *dest_pixel;

   canvas = line->parentObject->canvas;

   glyphHeight = glyph->bitmap.rows;

   penX = charObject->position + glyph->bitmap_left;
   penY = line->position - glyph->bitmap_top;

   src_buffer = (U8BIT *)glyph->bitmap.buffer;
   dest_buffer = (U8BIT *)canvas->col_buff;

   fore_colour = charObject->colour;
   if (NotOpaqueTDColor( fore_colour ))
   {
      canvas->opaque = FALSE;
   }
   for (row_count = 0; row_count != glyphHeight && penY < canvas->height; row_count++)
   {
      if (penY < 0)
      {
         penY++;
         continue;
      }

      for (a_point = 0; a_point != glyph->bitmap.width && penX < canvas->width; a_point++)
      {
         if (penX < 0)
         {
            penX++;
            continue;
         }
         src_pixel = &src_buffer[(row_count * glyph->bitmap.pitch) + a_point];
         IF_COL_DEPTH(COLOUR_FORMAT_ARGB4444)
         {
            dest_pixel = (OSDColor *)&dest_buffer[((penY * canvas->buff_pitch / 2) + (penX)) * 2];
            fore_value = *src_pixel;
            if (*src_pixel > 0)
            {
               BlendColours16((HD2Color *)dest_pixel, fore_value, fore_colour );
            }
         }
         ELSE IF_COL_DEPTH(COLOUR_FORMAT_ARGB8888)
         {
            dest_pixel = (OSDColor *)&dest_buffer[((penY * canvas->buff_pitch / 4) + (penX)) * 4];
            fore_value = *src_pixel;
            if (*src_pixel > 0)
            {
               BlendColours32( dest_pixel, fore_value, fore_colour );
            }
         }

         penX++;
      }
      penX = charObject->position + glyph->bitmap_left;
      penY++;
   }
}

static BOOLEAN Render(textItem_t *textObject)
{
   BOOLEAN success;
   textLine_t *currentLine;
   textChar_t *currentChar;
   S_SURFACE *canvas;
   FT_Error err;
   U32BIT fontWidth;
   U32BIT fontHeight;

   fontWidth = PointsToPixels(textObject->attribs->font.fp.size, textObject->attribs);
   fontHeight = textObject->attribs->font.fp.size;

   fontWidth = (fontWidth * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div;
   fontHeight = (fontHeight * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;

   success = CreateSurface(textObject);
   if (success)
   {
      canvas = textObject->canvas;
      canvas->buff_pitch = textObject->boxX * 4;
      canvas->col_buff = STB_OSDMhegLockBuffer( canvas->hw_handle, &canvas->buff_pitch );

      FT_Set_Pixel_Sizes(font->face, fontWidth, fontHeight);
   }
   currentLine = textObject->firstLine;

   while (currentLine != NULL && success)
   {
      currentChar = currentLine->firstChar;

      while (currentChar != NULL && success)
      {
         /*load the required glyph  from the font*/
         err = FT_Load_Char( font->face, currentChar->uchar, FT_LOAD_RENDER );
         if (!err)
         {
            RenderChar(font->face->glyph, currentLine, currentChar);
         }
         else
         {
            success = FALSE;
         }
         currentChar = currentChar->next;
      }
      currentLine = currentLine->next;
   }
   STB_OSDMhegUnlockBuffer( canvas->hw_handle);
   return success;
}

static fontLibrary_t* InitFreetype(pDrawTextAttrib attrib)
{
   fontLibrary_t *newFontLibrary;
   FT_Error ftErr;
   E_MhegErr mhErr = MHERR_INTERNAL;
   S_FontData *fontFileData;

   newFontLibrary = STB_MemAlloc(sizeof(fontLibrary_t));
   if (newFontLibrary != NULL)
   {
      ftErr = FT_Init_FreeType( &newFontLibrary->library );

      if (ftErr)
      {
         STB_MemFree(newFontLibrary);
         newFontLibrary = NULL;
      }
      else
      {
         mhErr = DVB_MhegGetEmbeddedFont(attrib->font_name.zptr, &fontFileData);
      }

      if (mhErr == MHERR_OK && fontFileData != NULL)
      {
         if (fontFileData->dataType == MHEG5_FONT_FILE_PATH_TTF)
         {
            ftErr = FT_New_Face( newFontLibrary->library, (char *)fontFileData->data, 0, &newFontLibrary->face );
         }
         else if (fontFileData->dataType == MHEG5_RAW_FONT_DATA_TTF)
         {
            ftErr = FT_New_Memory_Face( newFontLibrary->library,
                  (FT_Byte *)fontFileData->data,
                  (FT_Long)fontFileData->dataLength,
                  0,
                  &newFontLibrary->face );
         }
      }
      else
      {
         STB_MemFree(newFontLibrary);
         newFontLibrary = NULL;
      }

      if (ftErr)
      {
         STB_MemFree(newFontLibrary);
         newFontLibrary = NULL;
      }
   }
   return newFontLibrary;
}

static textItem_t* InitText(const TextString unistr, pDrawTextAttrib attrib, const VRect txt_box)
{
   textItem_t *newItem;

   newItem = STB_MemAlloc(sizeof(textItem_t));
   if (newItem != NULL)
   {
      switch (attrib->font.fp.size)
      {
         case 24:
            newItem->metrics = &metrics24Point;
            break;
         case 26:
            newItem->metrics = &metrics26Point;
            break;
         case 31:
            newItem->metrics = &metrics31Point;
            break;
         case 36:
            newItem->metrics = &metrics36Point;
            break;
         default:
            STB_MemFree(newItem);
            newItem = NULL;
      }
   }
   if (newItem != NULL)
   {
      newItem->firstLine = NULL;
      newItem->lastLine = NULL;
      newItem->lineCount = 0;
      newItem->chars = unistr.data;
      newItem->charsLen = unistr.len;
      newItem->attribs = attrib;
      newItem->boxX = txt_box.width;
      newItem->boxY = txt_box.height;
      /*set horizontal justification function*/
      switch (attrib->justify & JFY_HZ_MASK)
      {
         case JUSTIFY_H_START:
         case JUSTIFY_H_JUSTIFIED:
            newItem->hJustify = JustifyHStart;
            break;
         case JUSTIFY_H_END:
            newItem->hJustify = JustifyHEnd;
            break;
         case JUSTIFY_H_CENTRE:
            newItem->hJustify = JustifyHCentre;
            break;
         default:
            break;
      }

      switch (attrib->justify & JUSTIFY_VERTI_MASK)
      {
         case JUSTIFY_V_START:
         case JUSTIFY_V_JUSTIFIED:
            newItem->vJustify = JustifyVStart;
            break;
         case JUSTIFY_V_END:
            newItem->vJustify = JustifyVEnd;
            break;
         case JUSTIFY_V_CENTRE:
            newItem->vJustify = JustifyVCentre;
            break;
         default:
            break;
      }
   }
   return newItem;
}

void* MG_DrawHKText(const TextString unistr, pDrawTextAttrib attrib, const VRect txt_box)
{
   textItem_t *textObject;
   S_SURFACE *renderedSurface = NULL;
   BOOLEAN success = FALSE;

   textObject = InitText(unistr, attrib, txt_box);
   if (font == NULL)
   {
      font = InitFreetype(attrib);
   }

   if (font == NULL)
   {
      return NULL;
   }

   GetMaxLines(textObject);

   InitColourStack(attrib->fore_colour);
   if (textObject != NULL)
   {
      FillLines(textObject);
      success = TRUE;
   }
   DestructColourStack();

   if (textObject != NULL && textObject->hJustify != NULL)
   {
      textObject->hJustify(textObject);
   }
   else
   {
      success = FALSE;
   }

   if (textObject != NULL && textObject->vJustify != NULL)
   {
      textObject->vJustify(textObject);
   }
   else
   {
      success = FALSE;
   }
   #if 0
   {
      textLine_t *line;
      textChar_t *character;

      DBG_PRINTF("debugging lines, justify = %x\n", attrib->justify);
      line = textObject->firstLine;
      while (line)
      {
         character = line->firstChar;
         while (character)
         {
            DBG_PRINTF("%x ", *character->uchar);
            character = character->next;
         }
         DBG_PRINTF("\n");
         line = line->next;
      }
   }
   #endif

   if (success)
   {
      ScaleAllToHD(textObject);
      success = Render(textObject);
   }

   if (success)
   {
      renderedSurface = textObject->canvas;
   }
   if (textObject != NULL)
   {
      DestructTextObject(textObject);
   }

   return renderedSurface;
}

#endif