mg_drawtext.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2008 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>
#include <string.h>

#include "stb_osd.h"
#include "mg_font.h"

#include "mg_drawtext.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "mg_osd.h"
#include "osd_utils.h" /* for RGBT() */
#include "glue_assert.h"
#include "glue_debug.h" /* for TRACE */

#ifdef HK_PROFILE
#include "mg_hkfont.h"
#endif

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

#define COLOUR_STACK_SIZE        18

#ifdef OSD_8_BIT
 #define TRANSPARENT_COLOUR   OFFSET_TRANS
#else
 #define TRANSPARENT_COLOUR   0
#endif

/* 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)


/**** this ONLY work for ascii chars '!' - '~' (i.e. cached chars)
 **** in the Tiresias font files ***/
#define GLYPH_NDX(x)        (x - 30)
/****/

#define MAX_NUM_LINES       32
#define MAX_NUM_CHARS       64

#define PNTS_LS_LEN(tls)            ((tls + 255) >> 8)
#define MTRC_POSN(mll, tls, mr, fsz)   mll + (PNTS_LS_LEN(tls) * mr) / fsz

/* conversion calculations for local copy of S_PROPERTIES */
/* letter spaces plus width of chars - in metric units */
#define S_METRIC_POSITION(pp)       MTRC_POSN(pp.metric_line_length, pp.total_letter_space, pp.metric_resn, pp.pnts_font_size)
/* letter spaces plus width of chars - in points */
#define S_POINTS_POSITION(pp)       PNTS_LS_LEN(pp.total_letter_space) + ((pp.metric_line_length * pp.pnts_font_size + pp.metric_resn - 1) / pp.metric_resn)
/* letter spaces plus width of chars - in SD pixels */
#define S_SPIXEL_POSITION(pp)       (((((S_POINTS_POSITION(pp)) * 45) + pp.pixel_par_x - 1) / pp.pixel_par_x) + pp.spxl_tab_start)

/* conversion calculations for pointer to S_PROPERTIES */
/*convert to SD pixels*/
#define P_PNTS_2_SPXL(pp, pts)    ((((pts) * 45) + pp->pixel_par_x - 1) / pp->pixel_par_x)
#define P_MTRC_2_PNTS(pp, mtr)    ((mtr) * pp->pnts_font_size + pp->metric_resn - 1) / pp->metric_resn
#define P_MTRC_2_SPXL(pp, mtr)    P_PNTS_2_SPXL(pp, P_MTRC_2_PNTS(pp, mtr))
/* letter spaces plus width of chars - in metric units */
#define P_METRIC_POSITION(pp)    MTRC_POSN(pp->metric_line_length, pp->total_letter_space, pp->metric_resn, pp->pnts_font_size)
/* letter spaces plus width of chars - in points */
#define P_POINTS_POSITION(pp)    PNTS_LS_LEN(pp->total_letter_space) + ((pp->metric_line_length * pp->pnts_font_size + pp->metric_resn - 1) / pp->metric_resn)
/* letter spaces plus width of chars - in SD pixels */
#define P_SPIXEL_POSITION(pp)    (((((P_POINTS_POSITION(pp)) * 45) + pp->pixel_par_x - 1) / pp->pixel_par_x) + pp->spxl_tab_start)


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

typedef struct _LineLimit
{
   S32BIT position;
   S32BIT l_width;
   U16BIT line_num;
   U16BIT start_ndx;
   U16BIT end_ndx;
} LineLimit;

typedef struct _CharData
{
   S32BIT real_position;
   S32BIT mtrc_position;
   S16BIT mtrc_advance;
   U16BIT uni_chr;
   U16BIT gf_ndx;
   OSDColor colour;
   #ifdef TRACE
   S16BIT spxl_end;
   #endif
   U8BIT width;
} CharData;

typedef enum
{
   NO_BREAK,
   HAD_BREAK,
   BREAKING,
   NEW_LINE,
   OVER_RUN
} EBreakState;

typedef struct s_properties
{
   S32BIT hpxl_last_tab,
          hpxl_pen_posn,
          hpxl_line_end,
          metric_resn,
          metric_line_length,
          spxl_tab_start,
          pnts_tab_start,
          hpxl_letter_offset,
          total_letter_space,
          break_letter_space,
          metric_break_length,
          pnts_font_size,
          pixel_par_x,
          m_to_pix_mlt,
          m_to_pix_div;
   S_FontSize *p_font_size;
   FT_UInt glyph_index,
           glyph_last;
   LineLimit *p_current_line;
   LineLimit break_line;
   //EBreakState break_state;
   //CharData*   char_data;
   U16BIT spxl_box_width,
          hpxl_box_width;
   S16BIT font_index;
   S8BIT char_adv,
         char_left;
   U8BIT font_style;
} S_PROPERTIES;

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

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

#ifdef TRACING

static void traceLine( LineLimit *pLine, CharData *chars, U32BIT f_size, U32BIT m_res )
{
   char str[80];
   CharData *p_chr;
   U32BIT mposn, sposn;
   U16BIT nx;
   char *pch;

   for (nx = pLine->start_ndx, pch = str; nx != pLine->end_ndx && pch != str + 79; nx++, pch++)
   {
      *pch = (char)chars[nx].uni_chr;
   }
   *pch = 0;
   DBG_PRINTF( "Line %d: start=%ld width=%d start=%d end=%d F-Size=%d M-Res=%d\n",
      pLine->line_num, pLine->position, pLine->l_width, pLine->start_ndx, pLine->end_ndx, f_size, m_res );
   DBG_PRINTF( "%s\n", str);
   nx = pLine->start_ndx;
   p_chr = chars + nx;
   while (nx != pLine->end_ndx)
   {
      //tmp = (p_chr->spxl_end * 45 * mg_ctxt.screen_x_factor) / (mg_ctxt.normal_x_factor * 56);
      mposn = p_chr->mtrc_position + p_chr->mtrc_advance;
      sposn = ((mposn * f_size) + m_res - 1) / m_res;
      sposn = ((sposn * 45) + 55) / 56; // assuming plain text
      DBG_PRINTF( "(%c,%ld,%d,%d,%d) ", p_chr->uni_chr, p_chr->real_position - pLine->position, p_chr->width, mposn, sposn);
      nx++;
      p_chr++;
   }
   DBG_PRINTF( "\n");
}

static void trace_lines( U16BIT total, LineLimit *lines, CharData *chars, U32BIT f_size, U32BIT m_res )
{
   U16BIT line_num = 0;
   while (line_num != total)
   {
      if (line_num == lines->line_num)
      {
         traceLine( lines, chars, f_size, m_res );
         lines++;
      }
      line_num++;
   }
}

#endif /*TRACING*/

static U16BIT ProcessMarkup( U16BIT *data, OSDColor *cStack, U8BIT *cCount, pHyperAttribs ha )
{
   U16BIT mu_length = 0;
   if ((*data <= 0x5e) && (*data >= 0x40))
   {
      mu_length = data[1] + 1; /* add 1 for the 'length' byte itself */
   }
   switch (*data)
   {
      case UNICODE_HYPER_ANCHOR_START:
         if ((ha != NULL) && (*cCount < COLOUR_STACK_SIZE))
         {
            ha->number_of_links++;
            if (ha->markup_state == 0)
            {
               ha->markup_state = 2;
            }
            else
            {
               ha->markup_state++;
            }
            ha->save_colour = *cCount;
            (*cCount)++;
            /*Note: focus_position should be zero when not interacting so no need for testing (ha->interacting)*/
            if (ha->focus_position == ha->number_of_links)
            {
               cStack[*cCount] = ha->active_colour;
            }
            else
            {
               cStack[*cCount] = ha->link_colour;
            }
         }
         break;

      case UNICODE_TEXT_COLOUR_START:
         if ((mu_length == 5) && (*cCount < COLOUR_STACK_SIZE))
         {
            /* correct length byte, so extract the new text colour from the markup */
            cStack[++(*cCount)] = RGBT( data[2], data[3], data[4], data[5] );
         }
         break;

      case UNICODE_HYPER_ATTRIB_START:
         if ((ha != NULL) && (mu_length > 1) && (ha->markup_state == 0))
         {
            U16BIT mu_lft = mu_length - 2;
            U16BIT mu_ind = data[2];
            if (mu_ind & 0x08)
            {
               ha->anchor_wrap = TRUE;
            }
            else
            {
               ha->anchor_wrap = FALSE;
            }
            data += 3;
            if ((mu_ind & 0x40) && (mu_lft > 3))
            {
               ha->link_colour = RGBT( data[0], data[1], data[2], data[3] );
               data += 4;
               mu_lft -= 4;
            }
            if ((mu_ind & 0x20) && (mu_lft > 3))
            {
               ha->active_colour = RGBT( data[0], data[1], data[2], data[3] );
               data += 4;
               mu_lft -= 4;
            }
            if ((mu_ind & 0x10) && (mu_lft > 3))
            {
               ha->visit_colour = RGBT( data[0], data[1], data[2], data[3] );
            }
         }
         break;

      case UNICODE_HYPER_ANCHOR_END:
         if ((ha != NULL) && (ha->markup_state > 1))
         {
            ha->markup_state--;
            *cCount = ha->save_colour;
         }
         break;

      case UNICODE_TEXT_COLOUR_END:
         if ((ha != NULL) && (ha->markup_state > 1))
         {
            if (ha->save_colour)
               ha->save_colour--;
         }
         else
         {
            if (*cCount > 0)
               (*cCount)--;
         }
         break;

      case UNICODE_HYPER_ATTRIB_END:
      default:
         break;
   }
   if ((ha != NULL) && (ha->markup_state == 0))
   {
      ha->markup_state = 1;
   }
   return mu_length;
}

static void doExtraKernHD( S_PROPERTIES *pp )
{
   U32BIT fsz = pp->pnts_font_size;
   switch (pp->glyph_last)
   {
      case GLYPH_NDX('f'):
         if (pp->glyph_index == GLYPH_NDX('t'))
         {
            /* Otherwise f and t touch in HD */
            pp->hpxl_pen_posn++;
            if (fsz == 36)
            {
               pp->hpxl_pen_posn++;
            }
         }
         break;

      default:;
   }
}

static void doExtraKernSD( S_PROPERTIES *pp )
{
   U32BIT fsz = pp->pnts_font_size;
   switch (pp->glyph_last)
   {
      case GLYPH_NDX('a'):
         switch (pp->glyph_index)
         {
            case GLYPH_NDX('f'):
               /*any screen, test 5.5.9 for "waft"*/
               pp->hpxl_pen_posn--;
               break;

            case GLYPH_NDX('r'):
               if (fsz == 26)
               {
                  /*any screen, test 3.12.8 for "mark"*/
                  pp->hpxl_pen_posn--;
               }
            default:;
         }
         break;

      case GLYPH_NDX('d'):
         if (pp->glyph_index == GLYPH_NDX('e'))
         {
            /*any screen, test 3.12.7 for "BitmapDecodeOffset test:"*/
            pp->hpxl_pen_posn--;
         }
         break;

      case GLYPH_NDX('e'):
         switch (pp->glyph_index)
         {
            case GLYPH_NDX('f'):
               /* SD screen: otherwise test ISO 03 T69 scene 10 'refer' loses 'r' */
               pp->hpxl_pen_posn -= 2;
               break;
            case GLYPH_NDX('l'):
               /*any screen, test 5.5.9 for "rely"*/
               pp->hpxl_pen_posn--;
               break;
            case GLYPH_NDX('t'):
               /* just coz SD screen had some over-long words */
               pp->hpxl_pen_posn--;
               break;
            default:;
         }
         break;

      case GLYPH_NDX('f'):
         if (pp->glyph_index == GLYPH_NDX('t'))
         {
            /* Otherwise f and t touch in SD */
            pp->hpxl_pen_posn++;
            if (fsz == 36)
            {
               pp->hpxl_pen_posn++;
            }
         }
         else if ((pp->glyph_index == GLYPH_NDX('i')) ||
                  (pp->glyph_index == GLYPH_NDX('l')))
         {
            if (fsz == 24)
            {
               /* Otherwise f and (i or l) touch in SD */
               pp->hpxl_pen_posn++;
            }
         }
         break;

      case GLYPH_NDX('i'):
         if ((pp->glyph_index == GLYPH_NDX('f')) ||
             (pp->glyph_index == GLYPH_NDX('t'))
             )
         {
            if (fsz == 24)
            {
               pp->hpxl_pen_posn--;
            }
         }
         break;

      case GLYPH_NDX('n'):
         if (pp->glyph_index == GLYPH_NDX('k'))
         {
            /*any screen, in test 5.5.9 for "junk"*/
            pp->hpxl_pen_posn--;
         }
         break;

      case GLYPH_NDX('o'):
         switch (pp->glyph_index)
         {
            case GLYPH_NDX('c'):
               /*any screen, test 5.5.6.2 for "octal"*/
               pp->hpxl_pen_posn--;
               break;

            case GLYPH_NDX('f'):
               /*any screen, coz it looks beter */
               pp->hpxl_pen_posn--;
               break;
            case GLYPH_NDX('m'):
               /*SD screen, test 5.5.9 for "room" */
               pp->hpxl_pen_posn--;
               break;
            default:;
         }
         break;

      case GLYPH_NDX('p'):
         if (pp->glyph_index == GLYPH_NDX('D'))
         {
            /*SD screen, test 3.12.7 for "BitmapDecodeOffset test:"*/
            pp->hpxl_pen_posn--;
         }
         break;

      case GLYPH_NDX('r'):
         switch (pp->glyph_index)
         {
            case GLYPH_NDX('e'):
               /* SD screen: otherwise test ISO 03 T69 scene 10 'refer' loses 'r' */
               pp->hpxl_pen_posn--;
               break;
            case GLYPH_NDX('s'):
               /* otherwise gap too big */
               pp->hpxl_pen_posn--;
               break;
            default:;
         }
         break;

      case GLYPH_NDX('s'):
         if (pp->glyph_index == GLYPH_NDX('t'))
         {
            /*SD screen, test 3.12.7 for "BitmapDecodeOffset test:"*/
            pp->hpxl_pen_posn--;
         }
         break;

      case GLYPH_NDX('u'):
         if (pp->glyph_index == GLYPH_NDX('n'))
         {
            /*any screen, in test 5.5.9 for "junk"*/
            pp->hpxl_pen_posn--;
         }
         break;

      case GLYPH_NDX('w'):
         if (pp->glyph_index == GLYPH_NDX('a') && (fsz == 31))
         {
            /*any screen, test 5.5.9 for "waft"*/
            pp->hpxl_pen_posn--;
         }
         break;

      case GLYPH_NDX('t'):
      case GLYPH_NDX('T'):
         if (pp->glyph_index == GLYPH_NDX('h'))
         {
            if (fsz == 24)
            {
               pp->hpxl_pen_posn++;
            }
         }
         break;

      default:;
   } /*hctiws*/
}

static void AddLetterSpace(S_PROPERTIES *pp, S32BIT tls)
{
   pp->total_letter_space += tls;
   if (pp->total_letter_space > 0)
   {
      tls = ((pp->m_to_pix_mlt * pp->total_letter_space) + (pp->m_to_pix_div - 1)) / pp->m_to_pix_div;
      /* according to UK profile sec 5.5.5.2, must do round up for the divide by 256 */
      tls = (tls + 255) / 256;
   }
   else
   {
      tls = ((pp->m_to_pix_mlt * pp->total_letter_space) - (pp->m_to_pix_div - 1)) / pp->m_to_pix_div;
      tls = (tls - 255) / 256;
   }
   if (pp->hpxl_letter_offset != tls)
   {
      pp->hpxl_pen_posn += tls - pp->hpxl_letter_offset;
      pp->hpxl_letter_offset = tls;
   }
}

static void DoTheKerning( pDrawTextAttrib attrib, S_FontDetails *ftd_ptr, S_PROPERTIES *pp )
{
   FT_Vector kerning;

   if (pp->glyph_last && attrib->letter_space)
   {
      AddLetterSpace(pp,attrib->letter_space);
   }

   if (ftd_ptr->face_type == FTYPE_PFR)
   {
      if (FT_Get_PFR_Kerning(ftd_ptr->face, pp->glyph_last, pp->glyph_index, &kerning) == 0 &&
          kerning.x != 0)
      {
         pp->metric_line_length += kerning.x;
         kerning.x *= pp->m_to_pix_mlt * pp->pnts_font_size;
         kerning.y = ftd_ptr->metric_resolution * pp->m_to_pix_div;
         if (kerning.x < 0)
         {
            kerning.x -= kerning.y >> 1;
         }
         else
         {
            kerning.x += kerning.y >> 2;
         }
         pp->hpxl_pen_posn += kerning.x / kerning.y;
      }
   }
   else if (pp->glyph_last != 0)
   {
      if (pp->glyph_last != ftd_ptr->glyph_ndx_space)
      {
         if (FT_Get_Kerning(ftd_ptr->face, pp->glyph_last, pp->glyph_index, FT_KERNING_UNSCALED, &kerning) == 0)
         {
            /* kerning.x in original font units */
            if (kerning.x != 0)
            {
               pp->metric_line_length += kerning.x;
               kerning.x *= pp->m_to_pix_mlt * pp->pnts_font_size;
               kerning.y = ftd_ptr->metric_resolution * pp->m_to_pix_div;
               if (kerning.x < 0)
               {
                  kerning.x -= kerning.y >> 1;
               }
               else
               {
                  kerning.x += kerning.y >> 2;
               }
               pp->hpxl_pen_posn += kerning.x / kerning.y;
            }
         }
      }
   }
   /* extra kerning here, to ensure we pass DTG tests
    * without making the font smaller than it should be */
   if (pp->font_style == 0 &&           /* PLAIN */
       pp->font_index == BUILT_IN_FONT)   /* UK Profile: tiresias font */
   {
      if (mg_hd_mode == NORMAL_SD)
         doExtraKernSD( pp );
      else
         doExtraKernHD( pp );
   }
   pp->glyph_last = pp->glyph_index;
}

static BOOLEAN LoadPrintableChar( S_FontDetails *ftd_ptr, S_FontSize *f_sz_data,
   S_PROPERTIES *pp, U16BIT u_chr, CharData *char_data )
{
   FT_Face the_face = ftd_ptr->face;
   FT_Int32 load_flags;

   /* First check that FT is using the right font size */
   if (ftd_ptr->current_fnt_id != f_sz_data->fnt_id)
   {
      if (FT_Set_Char_Size( the_face, f_sz_data->width, f_sz_data->height, 72, 72 ) != 0)
      {
         TRACE(TERROR, ("FT_Set_Char_Size FAILED: w=%u, h=%u\n", f_sz_data->width, f_sz_data->height))
         return FALSE;
      }
      ftd_ptr->current_fnt_id = f_sz_data->fnt_id;
   }
   if (char_data->mtrc_advance == 0) /* when this has non-zero value, it's cachable char but no room for cache */
   {
      if (ftd_ptr->face_type == FTYPE_PFR)
      {
         FT_Pos advance;

         if (FT_Get_PFR_Advance( the_face, pp->glyph_index, &advance ) != 0)
         {
            TRACE(TERROR, ("FT_Get_PFR_Advance FAILED: gi=%u\n", pp->glyph_index))
            return FALSE;
         }
         else
         {
            char_data->mtrc_advance = (S16BIT)advance;
         }
      }
      else
      {
         if (FT_Load_Glyph( the_face, pp->glyph_index, FT_LOAD_NO_SCALE ) != 0)
         {
            TRACE(TERROR, ("FT_Load_Glyph FAILED: gi=%u\n", pp->glyph_index))
            return FALSE;
         }
         else
         {
            char_data->mtrc_advance = (S16BIT)the_face->glyph->metrics.horiAdvance;
         }
      }
   }

   load_flags = FT_LOAD_RENDER;
   /* Special cases to overcome a FreeType bug: for
    * "Latin Small Letter A With Tilde U+00E3",
    * "Latin Small Letter N With Tilde U+00F1" and
    * "Latin Small Letter O With Tilde U+00F5"
    * the "tilde" is rendered as a macron for small font sizes, when
    * auto-hinting is enabled. We cannot always control the build options,
    * so a special case is required.
    */
   if (u_chr == 0x00e3 || u_chr == 0x00f1 || u_chr == 0x00f5)
   {
      load_flags |= FT_LOAD_NO_AUTOHINT;
   }
   if (FT_Load_Glyph( the_face, pp->glyph_index, load_flags ) != 0)
   {
      return FALSE;
   }

   char_data->uni_chr = u_chr;
   char_data->gf_ndx = pp->glyph_index;
   char_data->width = the_face->glyph->bitmap.width;
   pp->char_left = the_face->glyph->bitmap_left;
   switch (u_chr)
   {
      case 0x2215: /* divide */
         if (ftd_ptr->font_ndx != BUILT_IN_FONT)
         {
            pp->char_adv = (S8BIT)((the_face->glyph->linearHoriAdvance + 0x7fff) >> 16);
            break;
         }
      case 0xd7:
      case 0xf7:
      case 0x66b:
      /* case UNICODE_FIGURE_SPACE: not neccessary */
      case 0x2212:
      case 0x2214:
         /* This is a bit of a cheat for getting through the DTG test "5.10B Monospace chars", but
          * it is quite reasonable. And it's only way to avoid mucking up the rendering elsewhere.
          */
         pp->char_adv = f_sz_data->figure_adv;
         break;

      case 0x2713: 
      case 0x2717: 
         if ((the_face->glyph->linearHoriAdvance & 0x8000) &&
             (ftd_ptr->current_fnt_id & 0xff) == 24 && pp->hpxl_last_tab == pp->hpxl_pen_posn)
         {
            pp->char_left--;
            pp->hpxl_last_tab--;
            pp->char_adv = (S8BIT)(the_face->glyph->linearHoriAdvance >> 16);
            break;
         }
      default:
         pp->char_adv = (S8BIT)((the_face->glyph->linearHoriAdvance + 0x7fff) >> 16);
   }
   return TRUE;
}

static void InitialiseProperties( pDrawTextAttrib attrib, S_FontSize *f_sz_data, S_PROPERTIES *pp )
{
   pp->glyph_last = 0;
   pp->hpxl_line_end = 0;
   pp->font_style = (U8BIT)((f_sz_data->fnt_id >> 8) & 0xFF);
   if (pp->font_style & FONT_STYLE_NO_SCALE)
   {
      pp->m_to_pix_mlt = 1;
      pp->m_to_pix_div = 1;
      pp->pixel_par_x = 45;
   }
   else if ((pp->font_style & FONT_STYLE_SQUARE) && (mg_hd_mode != NORMAL_SD))
   {
      pp->m_to_pix_mlt = mg_ctxt.osd_y.mlt;
      pp->m_to_pix_div = mg_ctxt.osd_y.div;
      pp->pixel_par_x = 64;
   }
   else
   {
      pp->m_to_pix_mlt = mg_ctxt.osd_x.mlt * 9;
      pp->m_to_pix_div = mg_ctxt.osd_y.div * 14;
      pp->pixel_par_x = 56;
   }
   if ((attrib->justify & JFY_HZ_MASK) == JUSTIFY_H_START)
   {
      pp->hpxl_last_tab = f_sz_data->bound_box.left;
      pp->pnts_tab_start = f_sz_data->pnts_xleftoffset;
      pp->spxl_tab_start = f_sz_data->spxl_xleftoffset;
   }
   else
   {
      pp->hpxl_last_tab = 0;
      pp->spxl_tab_start = 0;
   }
   pp->hpxl_pen_posn = pp->hpxl_last_tab;
   pp->hpxl_letter_offset = 0;
   pp->total_letter_space = 0;
   pp->metric_line_length = 0;
   pp->metric_break_length = 0;
   pp->pnts_font_size = (S32BIT)f_sz_data->fnt_id & 0xFF;
   pp->font_index = f_sz_data->fnt_id >> 16;
}

static void MoveTabPosition( S_PROPERTIES *pp )
{
   S32BIT new_posn;
   /* get sd pixels, and add xLeftOffset since
    * "tab logically advances the rendering of the text by at least the width xOffsetLeft" */
   new_posn = P_SPIXEL_POSITION(pp) + pp->p_font_size->spxl_xleftoffset;
   /* round up to new tab position */
   //TRACE(TTEXT,("new_posn=%d pp->spxl_tab_start=%d pp->metric_line_length=%d", new_posn, pp->spxl_tab_start, pp->metric_line_length ))
   if ((new_posn % 45) != 0)
   {
      new_posn += 45 - (new_posn % 45);
   }
   pp->spxl_tab_start = new_posn;
   /* now that size of chars and letter space been used - zero them */
   pp->metric_line_length = 0;
   pp->hpxl_letter_offset = 0;
   pp->total_letter_space = 0;
   /* calculate tab position in real pixels */
   new_posn = ((new_posn * mg_ctxt.osd_x.mlt) + (mg_ctxt.osd_x.div >> 1)) / mg_ctxt.osd_x.div;
   pp->hpxl_pen_posn = pp->p_current_line->position + new_posn;
   pp->hpxl_last_tab = pp->hpxl_pen_posn;
   /* forget previous glyph to prevent kerning across a tab character */
   pp->glyph_last = 0;
}

static void AddSpaceRendering( pDrawTextAttrib attrib, S_PROPERTIES *pp, CharData *char_data,
   FT_UInt mt_adv, S8BIT pxl_adv )
{
   if (pp->glyph_last && attrib->letter_space)
   {
      AddLetterSpace(pp,attrib->letter_space);
      if (pp->hpxl_pen_posn < pp->p_current_line->position)
      {
         pp->p_current_line->position = pp->hpxl_pen_posn;
      }
   }
   if ((attrib->justify & JFY_HZ_MASK) == JUSTIFY_H_CENTRE)
   {
      char_data->mtrc_position = P_METRIC_POSITION(pp);
      char_data->mtrc_advance = mt_adv;
      char_data->real_position = pp->hpxl_pen_posn;
      char_data->colour = TRANSPARENT_COLOUR; /* <- so that rendering function ignors this character data */
      char_data->width = pxl_adv;
   }
   pp->hpxl_pen_posn += pxl_adv;
   pp->metric_line_length += mt_adv;
}

static void MinorAdjustOfPenPositionAtSpace( S_PROPERTIES *pp )
{
   S32BIT tmp,psn;
   psn = P_POINTS_POSITION(pp);
   tmp = ((pp->m_to_pix_mlt * psn) + (pp->m_to_pix_div >> 1)) / pp->m_to_pix_div;
   tmp += pp->hpxl_last_tab;
   if (tmp != pp->hpxl_pen_posn)
   {
      TPRINT(TTEXT, ("MAPP(%d,%d,%d,%d,%d)", pp->total_letter_space, pp->metric_line_length, psn, tmp, pp->hpxl_pen_posn));
      pp->hpxl_pen_posn += (tmp - pp->hpxl_pen_posn) / 2;
   }
}

static void ProcessWrappingBreak( S_PROPERTIES *pp, CharData *chars, U16BIT cur_ndx )
{
   S32BIT brk_posn, ndx;
   pp->metric_line_length -= pp->metric_break_length;
   brk_posn = MTRC_POSN(pp->metric_break_length, pp->break_letter_space, pp->metric_resn, pp->pnts_font_size);
   TRACE(TTEXT, ("Metric break-posn=%d; After: start=%d 1st-char=0x%x", brk_posn, pp->break_line.start_ndx, chars[pp->break_line.start_ndx].uni_chr))
   if (brk_posn)
   {
      assert( pp->break_line.start_ndx < cur_ndx );
      for (ndx = pp->break_line.start_ndx; ndx != cur_ndx; ndx++)
      {
         assert( chars[ndx].mtrc_position >= brk_posn );
         chars[ndx].mtrc_position -= brk_posn;
      }
   }
   pp->metric_break_length = 0;
   pp->break_letter_space = 0;
}

static void FudgeForHD( S_PROPERTIES *pp, CharData *chars )
{
   CharData *p_start, *p_other, *p_last;
   LineLimit *line = pp->p_current_line;
   S32BIT fudge_size, fudge_last;

   assert(line->end_ndx > line->start_ndx);
   p_start = chars + line->start_ndx;
   p_last = chars + line->end_ndx - 1;
   assert(line->position <= p_start->real_position);

   /* width of chars visible at HD */
   fudge_size = p_last->real_position + p_last->width - line->position;

   /* is char width > box width, and is there more than one char ? */
   if (fudge_size > pp->hpxl_box_width && p_start != p_last)
   {
      /* Ensure SD displayable chars can be seen in HD */
      fudge_size -= pp->hpxl_box_width;
      if (line->position < p_start->real_position)
      {
         /* attempt to sort it, by moving whole line left by one pixel
          * Should not do more than one, coz it would be noticable on
          * multi-line with left margin being jagged */
         line->position++;
         fudge_size--;
         if (fudge_size == 0)
         {
            return; /* fudged it ! */
         }
      }
      /* move end char back by required fudge size */
      p_last->real_position -= fudge_size;
      /* now loop until fudging is done or cannot do anymore */
      do
      {
         fudge_last = fudge_size; /* save fudge size */
         p_other = p_last - 1;
         /* Start from end, and move chars back */
         while (p_other != p_start)
         {
            p_other->real_position -= fudge_size;
            if (p_other->real_position + p_other->width + 1 < p_last->real_position)
            {
               /* still have gap between chars after fudge, so can decrement fudge size
                * i.e. lose one pixel between them */
               fudge_size--;
               p_other->real_position++;
               if (fudge_size == 0)
               {
                  return; /* fudged it ! */
               }
            }
            p_last = p_other;
            p_other--;
         }
         assert(p_other == p_start);
         TRACE(TTEXT, ("More fudging to do %d", fudge_size))
         /* This time, start from beginning and move them up */
         p_last = chars + line->end_ndx - 1;
         p_other++;
         while (p_other != p_last)
         {
            p_other->real_position += fudge_size;
            if (p_start->real_position + p_start->width + 1 < p_other->real_position)
            {
               /* still have gap between chars after fudge, so can decrement fudge size
                * i.e. lose one pixel between them */
               fudge_size--;
               if (fudge_size == 0)
               {
                  return; /* fudged it ! */
               }
            }
            p_start = p_other;
            p_other++;
         }
         assert(p_other == p_last);
         p_start = chars + line->start_ndx;
      }
      while (fudge_size != fudge_last);     /*if these are equal it is not possible to do any more */
      TRACE(TERROR, ("fudging failed to complete %d", fudge_size))
   }
   /* else nothing to do */
}

static void AdjustLineEnding( S_PROPERTIES *pp, CharData *chars )
{
   S32BIT len, mtr_end, width;
   CharData *p_cd;
   LineLimit *line = pp->p_current_line;
   U16BIT ndx;

   assert(line->end_ndx > line->start_ndx);
   ndx = line->end_ndx - 1;
   p_cd = chars + ndx;
   mtr_end = p_cd->mtrc_position + p_cd->mtrc_advance;
   width = pp->spxl_box_width - pp->p_font_size->spxl_xleftoffset;

   ndx = line->start_ndx;
   p_cd = chars + ndx;

   while (ndx != line->end_ndx)
   {
      len = P_MTRC_2_SPXL(pp, mtr_end - p_cd->mtrc_position);
      if (len <= width)
      {
         break;
      }
      p_cd++;
      ndx++;
   }
   assert(ndx <= line->end_ndx);
   line->start_ndx = ndx;

   /* adjust rending length so that displayable chars are centred properly */
   line->l_width -= p_cd->real_position - line->position;
   line->position = p_cd->real_position;
}

static void AdjustLineMiddle( S_PROPERTIES *pp, CharData *chars, U8BIT justify )
{
   S32BIT mleft, mhalf, rright, mright, b_wdth;
   CharData *p_ecd, *p_scd;
   LineLimit *line = pp->p_current_line;
   U16BIT e_ndx, s_ndx;

   assert(line->end_ndx > line->start_ndx);
   e_ndx = line->end_ndx - 1;
   s_ndx = line->start_ndx;
   p_ecd = chars + e_ndx;
   if (justify & WRAP_WORDS)
   {
      /*Strip off extra spaces from end of chars array for this line */
      while (e_ndx != s_ndx && p_ecd->uni_chr == UNICODE_SPACE)
      {
         p_ecd--;
         e_ndx--;
      }
   }
   mright = p_ecd->mtrc_position + p_ecd->mtrc_advance;
   p_scd = chars + s_ndx;
   mleft = p_scd->mtrc_position;
   rright = pp->break_line.position;

 #ifdef ACCURATE_CENTRE_TRUNCATION

   mhalf = mright >> 1;
   b_wdth = pp->spxl_box_width - pp->p_font_size->spxl_xleftoffset;
   while ((e_ndx != s_ndx) && (P_MTRC_2_SPXL(pp, mright - mleft) > b_wdth))
   {
      if (mright - mhalf > mhalf - mleft)
      {
         rright = p_ecd->real_position;
         p_ecd--;
         e_ndx--;
         mright = p_ecd->mtrc_position + p_ecd->mtrc_advance;
      }
      else
      {
         p_scd++;
         s_ndx++;
         mleft = p_scd->mtrc_position;
      }
   }

 #else

   mhalf = mright << 1;
   b_wdth = pp->spxl_box_width; /* twice width of right half */
   while ((e_ndx != s_ndx) && (P_MTRC_2_SPXL(pp, mhalf - mright) > b_wdth))
   {
      rright = p_ecd->real_position;
      p_ecd--;
      e_ndx--;
      mhalf = (p_ecd->mtrc_position + p_ecd->mtrc_advance) << 1;
   }
   b_wdth -= pp->p_font_size->spxl_xleftoffset;
   while ((e_ndx != s_ndx) && (P_MTRC_2_SPXL(pp, mright - mleft) > b_wdth))
   {
      p_scd++;
      s_ndx++;
      mleft = p_scd->mtrc_position << 1;
   }

 #endif /*ACCURATE_CENTRE_TRUNCATION*/

   if (s_ndx != line->start_ndx || e_ndx != (line->end_ndx - 1))
   {
      assert( rright > p_scd->real_position );
      if (rright > p_scd->real_position)
      {
         assert(s_ndx <= (e_ndx + 1));
         line->start_ndx = s_ndx;
         line->end_ndx = e_ndx + 1;

         /* adjust rending length so that displayable chars are centred properly */
         line->position = p_scd->real_position;
         line->l_width = p_ecd->real_position + p_ecd->width - p_scd->real_position;
      }
   }
}

void ProcessNewLine( S_PROPERTIES *pp, CharData *chars, S_FontSize *f_sz_data, U16BIT line_num, U8BIT justify )
{
   TRACE(TTEXT, ("start=%d bk-end=%d", pp->p_current_line->start_ndx, pp->break_line.end_ndx))
   if (pp->p_current_line->start_ndx < pp->break_line.end_ndx)
   {
      pp->p_current_line->l_width = pp->break_line.l_width;
      pp->p_current_line->end_ndx = pp->break_line.end_ndx;
      pp->p_current_line->line_num = line_num;
      pp->hpxl_last_tab = pp->break_line.position;
      switch (justify & JFY_HZ_MASK)
      {
         case JUSTIFY_H_END:
            AdjustLineEnding( pp, chars );
            break;

         case JUSTIFY_H_CENTRE:
            AdjustLineMiddle( pp, chars, justify );
            FudgeForHD( pp, chars );
            break;

         default: /*JUSTIFY_H_START and JUSTIFY_H_JUSTIFIED*/
            FudgeForHD( pp, chars );
            pp->spxl_tab_start = f_sz_data->spxl_xleftoffset;
            pp->pnts_tab_start = f_sz_data->pnts_xleftoffset;
            pp->break_line.position -= f_sz_data->bound_box.left;
            break;
      }
      pp->hpxl_letter_offset = 0;
      pp->total_letter_space = 0;
      pp->p_current_line++;
   }
   else
   {
      if ((justify & JFY_HZ_MASK) == JUSTIFY_H_START)
      {
         pp->break_line.position -= f_sz_data->bound_box.left;
      }
   }
   pp->p_current_line->position = pp->break_line.position;
   pp->p_current_line->start_ndx = pp->break_line.start_ndx;
   pp->break_line.start_ndx = pp->break_line.end_ndx;
}

static LineLimit* ShuffleUpLines( LineLimit *lines, U16BIT num )
{
   U16BIT first = 0;
   while (lines[first].line_num < num)
   {
      first++;
   }
   num = first;
   first = 0;
   while (num != MAX_NUM_LINES)
   {
      lines[first] = lines[num];
      first++;
      num++;
   }
   return &lines[first - 1];
}

static void AddCaretChar( S_PROPERTIES *pp, S_FontDetails *ftd_ptr, S_FontSize *f_sz_data, CharData *char_data,
   OSDColor col, U16BIT caret )
{
   if (f_sz_data->sbit_cache)
   {
      CacheSbit *c_sbit = &f_sz_data->sbit_cache[caret - FIRST_CACHE_CHAR];
      char_data->width = c_sbit->width;
      char_data->real_position = pp->hpxl_pen_posn + c_sbit->left;
      char_data->gf_ndx = 0;
   }
   else
   {
      FT_Face the_face = ftd_ptr->face;
      char_data->gf_ndx = FT_Get_Char_Index( the_face, caret );
      if (FT_Load_Glyph( the_face, char_data->gf_ndx, FT_LOAD_RENDER ) == 0)
      {
         char_data->width = the_face->glyph->bitmap.width;
         char_data->real_position = pp->hpxl_pen_posn + the_face->glyph->bitmap_left;
      }
   }
   char_data->mtrc_position = P_METRIC_POSITION(pp);
   char_data->mtrc_advance = ftd_ptr->horiz_adv[caret - FIRST_CACHE_CHAR];
   char_data->uni_chr = caret;
   char_data->colour = col;
}

static U16BIT PreparePrintableData( const TextString unistr, pDrawTextAttrib attrib, S_FontSize *f_sz_data,
   S_FontDetails *ftd_ptr, U16BIT hpxl_box_width, U16BIT spxl_box_width,
   U16BIT available_lines, LineLimit *lines, CharData *chars, U16BIT *p_chr_cnt )
{
   CharData *char_data = chars;
   FT_UInt *hori_advance = ftd_ptr->horiz_adv;
   OSDColor colour_stack[COLOUR_STACK_SIZE];
   S_PROPERTIES prop;
   U16BIT u_chr, uni_pos, char_count;
   U16BIT total_lines;
   EBreakState break_state;
   U8BIT colour_count, hz_justify;
   U16BIT spxl_avl_width;

   /* Initialise values, including 'properties' */
   lines[0].position = 0;
   lines[0].start_ndx = 0;
   lines[0].end_ndx = 0;
   prop.break_line.start_ndx = 0;
   total_lines = 0;
   char_count = 0;
   colour_count = 0; /* fore colour in 'zero' */
   colour_stack[0] = attrib->fore_colour;
   break_state = NO_BREAK;
   prop.p_font_size = attrib->font.hdl;
   prop.p_current_line = lines;
   prop.metric_resn = ftd_ptr->metric_resolution;
   prop.hpxl_box_width = hpxl_box_width;
   prop.spxl_box_width = spxl_box_width;

   InitialiseProperties( attrib, f_sz_data, &prop );

   hz_justify = attrib->justify & JFY_HZ_MASK;
   if (hz_justify == JUSTIFY_H_START)
   {
      spxl_avl_width = spxl_box_width;
   }
   else
   {
      spxl_avl_width = spxl_box_width - f_sz_data->spxl_xleftoffset;
   }

   /* loop through the string */
   for (uni_pos = 0; uni_pos < unistr.len; uni_pos++)
   {
      if (uni_pos == attrib->entry_point)
      {
         AddCaretChar( &prop, ftd_ptr, f_sz_data, char_data, colour_stack[colour_count], attrib->caret );
         char_count++;
         char_data++;
      }
      u_chr = unistr.data[uni_pos];
      switch (u_chr)
      {
         case UNICODE_LF: case U_CTRL_NULL:
         case U_CTRL_A: case U_CTRL_B: case U_CTRL_C: case U_CTRL_D: case U_CTRL_E:
         case U_CTRL_F: case U_CTRL_G: case U_CTRL_H: case U_CTRL_K: case U_CTRL_L:
         case U_CTRL_N: case U_CTRL_O: case U_CTRL_P: case U_CTRL_Q: case U_CTRL_R:
         case U_CTRL_S: case U_CTRL_T: case U_CTRL_U: case U_CTRL_V: case U_CTRL_W:
         case U_CTRL_X: case U_CTRL_Y: case U_CTRL_Z: case U_CTRL_FS:
         case U_CTRL_GS: case U_CTRL_RS:  case U_CTRL_US:
            TRACE(TTEXT, ("Ignoring control char 0x%x", u_chr))
            break;

         case UNICODE_CR:
            prop.break_line.l_width = prop.hpxl_line_end - prop.p_current_line->position;
            if (break_state != OVER_RUN)
            {
               prop.break_line.end_ndx = char_count;
            }
            prop.break_line.position = prop.hpxl_pen_posn;
            prop.break_line.start_ndx = char_count;
            prop.hpxl_last_tab = prop.hpxl_pen_posn; /* last screen of test 5.9 */
            if (hz_justify == JUSTIFY_H_START)
            {
               prop.pnts_tab_start = f_sz_data->pnts_xleftoffset;
               prop.spxl_tab_start = f_sz_data->spxl_xleftoffset;
            }
            prop.metric_line_length = 0;
            break_state = NEW_LINE;
            break;

         case UNICODE_ESC:
            /* process markup's */
            uni_pos++;
            if (uni_pos != unistr.len)
            {
               uni_pos += ProcessMarkup( &unistr.data[uni_pos], colour_stack, &colour_count, attrib->p_ha );
            }
            break;

         case UNICODE_TAB:
            if (hz_justify == JUSTIFY_H_START)
            {
               MoveTabPosition( &prop );
            }
            else
            {
               u_chr = UNICODE_SPACE;
            }
         case UNICODE_SPACE:
            if (u_chr == UNICODE_SPACE)
            {
               AddSpaceRendering( attrib, &prop, char_data, ftd_ptr->space_horiz_adv, f_sz_data->space_adv );
               if (hz_justify == JUSTIFY_H_CENTRE)
               {
                  /* for centre justify, AddSpaceRendering adds char data,
                   * gf_ndx and uni_chr do not really matter, but might as well have something */
                  char_data->gf_ndx = ftd_ptr->glyph_ndx_space;
                  char_data->uni_chr = u_chr;
               #ifdef TRACE
                  char_data->spxl_end = (S16BIT)S_SPIXEL_POSITION(prop);
               #endif
                  char_count++;
                  char_data++;
               }
               prop.glyph_last = ftd_ptr->glyph_ndx_space;
               /* Special case, only for SD resolution */
               if (mg_ctxt.out_osd_width == 720)
               {
                  MinorAdjustOfPenPositionAtSpace( &prop );
               }
            }
            if ((break_state != BREAKING) && (attrib->justify & WRAP_WORDS))
            {
               prop.break_line.l_width = prop.hpxl_line_end - prop.p_current_line->position;
               if (break_state != OVER_RUN)
               {
                  prop.break_line.end_ndx = char_count;
               }
               if (S_SPIXEL_POSITION(prop) > spxl_avl_width)
               {
                  TRACE(TTEXT, ("Need line break: sdp=%ld, aw=%d", S_SPIXEL_POSITION(prop), spxl_avl_width))
                  prop.break_line.position = prop.hpxl_pen_posn;
                  prop.break_line.start_ndx = char_count;
                  prop.metric_line_length = 0;
                  break_state = NEW_LINE;
               }
               else
               {
                  break_state = BREAKING;
               }
            }
            if (hz_justify == JUSTIFY_H_END)
            {
               if (prop.hpxl_pen_posn > prop.hpxl_line_end)
               {
                  prop.hpxl_line_end = prop.hpxl_pen_posn;
               }
            }
            break;
#if 0
         case UNICODE_HARD_SPACE:
            AddSpaceRendering( attrib, &prop, char_data, ftd_ptr->space_horiz_adv, f_sz_data->space_adv );
            if (hz_justify == JUSTIFY_H_CENTRE)
            {
               /* for centre justify, AddSpaceRendering adds char data,
                * gf_ndx and uni_chr do not really matter, but might as well have something */
               char_data->gf_ndx = ftd_ptr->glyph_ndx_space;
               char_data->uni_chr = u_chr;
               char_count++;
               char_data++;
            }
            prop.glyph_last = ftd_ptr->glyph_ndx_space;
            if (prop.hpxl_pen_posn > prop.hpxl_line_end)
            {
               prop.hpxl_line_end = prop.hpxl_pen_posn;
            }
            break;

         case UNICODE_FIGURE_SPACE:
            AddSpaceRendering( attrib, &prop, char_data, ftd_ptr->fig_horiz_adv, f_sz_data->figure_adv );
            if (hz_justify == JUSTIFY_H_CENTRE)
            {
               /* for centre justify, AddSpaceRendering adds char data,
                * gf_ndx and uni_chr do not really matter, but might as well have something */
               char_data->gf_ndx = ftd_ptr->glyph_ndx_space;
               char_data->uni_chr = u_chr;
               char_count++;
               char_data++;
            }
            prop.glyph_last = ftd_ptr->glyph_ndx_space;
            if (prop.hpxl_pen_posn > prop.hpxl_line_end)
            {
               prop.hpxl_line_end = prop.hpxl_pen_posn;
            }
            break;
#endif
         default:
            /* PRINTABLE CHARS */
            if (u_chr < (FIRST_CACHE_CHAR + CHAR_CACHE_SIZE))
            {
               assert(u_chr >= FIRST_CACHE_CHAR);
               prop.glyph_index = ftd_ptr->glyph_ndx[u_chr - FIRST_CACHE_CHAR];

               char_data->mtrc_advance = (S16BIT)hori_advance[u_chr - FIRST_CACHE_CHAR];

               if (f_sz_data->sbit_cache)
               {
                  CacheSbit *c_sbit = &f_sz_data->sbit_cache[u_chr - FIRST_CACHE_CHAR];
                  char_data->uni_chr = u_chr;
                  char_data->gf_ndx = 0;
                  char_data->width = c_sbit->width;
                  prop.char_left = c_sbit->left;
                  prop.char_adv = c_sbit->advance;
               }
               else
               {
                  if (prop.glyph_index == 0 ||
                      !LoadPrintableChar( ftd_ptr, f_sz_data, &prop, u_chr, char_data ))
                  {
                     break;
                  }
               }
            }
            else
            {
               prop.glyph_index = FT_Get_Char_Index( ftd_ptr->face, u_chr );
               char_data->mtrc_advance = 0;
               if (prop.glyph_index == 0 ||
                   !LoadPrintableChar( ftd_ptr, f_sz_data, &prop, u_chr, char_data ))
               {
                  TRACE(TTEXT, ("0x%x is not printable\n", u_chr))
                  break;
               }
            }
            char_data->colour = colour_stack[colour_count];

            if (break_state == BREAKING)
            {
               prop.break_line.position = prop.hpxl_pen_posn + prop.char_left;
               prop.metric_break_length = prop.metric_line_length;
               prop.break_letter_space = prop.total_letter_space;
               prop.break_line.end_ndx = char_count;
               prop.break_line.start_ndx = char_count;
               break_state = HAD_BREAK;
            }

            DoTheKerning( attrib, ftd_ptr, &prop );

            {
               S32BIT tmp_adv = prop.hpxl_pen_posn + prop.char_left;
               char_data->real_position = tmp_adv;
               if (tmp_adv < prop.p_current_line->position)
               {
                  prop.p_current_line->position = tmp_adv;
               }
               tmp_adv += char_data->width;
               if (tmp_adv > prop.hpxl_line_end)
               {
                  prop.hpxl_line_end = tmp_adv;
               }
            }

            prop.hpxl_pen_posn += prop.char_adv;
            char_data->mtrc_position = S_METRIC_POSITION(prop);
            prop.metric_line_length += char_data->mtrc_advance;
            if (prop.hpxl_pen_posn > prop.hpxl_line_end)
            {
               prop.hpxl_line_end = prop.hpxl_pen_posn;
            }
         #ifdef TRACE
            char_data->spxl_end = (S16BIT)S_SPIXEL_POSITION(prop);
         #endif
            char_count++;
            char_data++;

            if (attrib->justify & WRAP_VERTICAL)
            {
               /* wrap on every char */
               prop.break_line.l_width = prop.hpxl_line_end - prop.p_current_line->position;
               prop.break_line.end_ndx = char_count;
               prop.break_line.position = prop.hpxl_pen_posn;
               prop.metric_line_length = 0;
               break_state = NEW_LINE;
            }
            else
            {
               if (S_SPIXEL_POSITION(prop) > spxl_avl_width)
               {
                  /* this line now exceeds available width */
                  TRACE(TTEXT, ("Need line-break: sdp=%ld, aw=%d", S_SPIXEL_POSITION(prop), spxl_avl_width))
            #ifdef TRACING
                  if (TTEXT & mheg_trace_debug)
                  {
                     prop.p_current_line->l_width = prop.hpxl_line_end - prop.p_current_line->position;
                     prop.p_current_line->end_ndx = char_count;
                     prop.p_current_line->line_num = total_lines;
                     traceLine( prop.p_current_line, chars, prop.pnts_font_size, prop.metric_resn );
                  }
            #endif
                  switch (break_state)
                  {
                     case HAD_BREAK:
                        /* Need to remove from total_letter_space, the letter space after the breaking space char */
                        prop.break_letter_space += attrib->letter_space;
                        prop.total_letter_space -= prop.break_letter_space;
                        ProcessWrappingBreak( &prop, chars, char_count );
                        break_state = NEW_LINE;
                        break;
                     default:
                        if (hz_justify == JUSTIFY_H_START)
                        {
                           TRACE(TTEXT, ("Over run at %d", char_count))
                           assert(break_state == NO_BREAK);
                           prop.break_line.end_ndx = char_count - 1;
                           break_state = OVER_RUN;
                        }
                        break;
                     case OVER_RUN:
                        break;
                  }
               }
            }
      } /*end: switch(u_chr)*/

      if (break_state == NEW_LINE)
      {
         ProcessNewLine( &prop, chars, f_sz_data, total_lines, attrib->justify );

         total_lines++;

         if ((total_lines == available_lines) &&
             ((attrib->justify & JUSTIFY_V_JUSTIFIED) == JUSTIFY_V_START)
             )
         {
            /* GOOD! we've done enough - let's exit loop */
            break;
         }
         if (prop.p_current_line == &lines[MAX_NUM_LINES - 1])
         {
            if ((attrib->justify & JUSTIFY_V_JUSTIFIED) != JUSTIFY_V_END)
            {
               TRACE(TERROR, ("Run out of line space"))
               break; /* eek, cannot do anymore */
            }
            /* for JUSTIFY_V_END, can shuffle up the lines coz only interested in the last ones */
            prop.p_current_line = ShuffleUpLines( lines, total_lines - available_lines );
         }
         prop.glyph_last = 0;
         break_state = NO_BREAK;
      }
   }

   if (uni_pos == attrib->entry_point)
   {
      /* add 'caret' in the end position */
      AddCaretChar( &prop, ftd_ptr, f_sz_data, char_data, colour_stack[colour_count], attrib->caret );
      if ((char_data->real_position + char_data->width) > prop.hpxl_line_end)
      {
         prop.hpxl_line_end = char_data->real_position + char_data->width;
      }
      char_count++;
   }
   /* complete stuff for the last line being processed */
   TRACE(TTEXT, ("last line: mt=%ld, rt=%ld", prop.metric_line_length, prop.hpxl_line_end))
   prop.p_current_line->l_width = prop.hpxl_line_end - prop.p_current_line->position;
   prop.p_current_line->line_num = total_lines;
   if (break_state == OVER_RUN)
   {
      prop.p_current_line->end_ndx = prop.break_line.end_ndx;
   }
   else
   {
      prop.p_current_line->end_ndx = char_count;
      if (prop.p_current_line->start_ndx < char_count)
      { /* there are some visible chars */
         prop.break_line.position = prop.hpxl_pen_posn;
         switch (attrib->justify & JFY_HZ_MASK)
         {
            case JUSTIFY_H_END:
               AdjustLineEnding( &prop, chars );
               break;

            case JUSTIFY_H_CENTRE:
               AdjustLineMiddle( &prop, chars, attrib->justify );
               FudgeForHD( &prop, chars );
               break;

            default: /*JUSTIFY_H_START and JUSTIFY_H_JUSTIFIED*/
               FudgeForHD( &prop, chars );
               break;
         }
      }
   }
   if (prop.p_current_line->l_width)
   {
      total_lines++;
      /* TextDrawFn() requires that there is a terminating lines array element
       * with line_num equal to total_lines */
      prop.p_current_line++;

      prop.p_current_line->line_num = total_lines;
   }
   *p_chr_cnt = char_count;
   return total_lines;
} /* end of PreparePrintableData */

#ifdef OSD_8_BIT

#define TextDrawFn                                    TextDraw8Bit
#define RenderGlyphFn                                 RenderGlyph8Bit
#define TDColor                                       U8BIT
#define MakeTDColor(col)                              OSD_FindNearestColourIndex( col )
#define GreyValue(val)                                (val >> 6)
#define SRC_FORE_MAX                                  3
#define IsOpaqueColor( tcol )                         (tcol >= OFFSET_OPAQUE)
#define NotTransparent( fcol )                        ((fcol >> 24) > 0x18)
#define CombineAlphaColour(pixel, grey_val, fc, tc)      if (grey_val) pixel = aa_8bit_cols[grey_val];
//#define SetColorArrayBack(bck_col)                    aa_8bit_cols[0] = bck_col;
#define CalcColorArray(for_col) \
   if (/*for_col != OFFSET_TRANS &&*/ aa_8bit_cols[3] != for_col) { \
      U8BIT fa, ba, bck_col = aa_8bit_cols[0]; \
      register U32BIT comp, tmp_c, alpha_c; \
      comp = mg_palette[for_col] >> 24; \
      ba = (U8BIT)(mg_palette[bck_col] >> 24); \
      alpha_c = ((((255 ^ ba) * comp) + 382) / 765) + ba; \
      tmp_c = alpha_c << 24; \
      fa = (U8BIT)((comp + 1) / 3); \
      comp = ba; \
      ba = (U8BIT)(((255 ^ fa) * comp) + 127) / 255; \
      comp = ba * ((mg_palette[bck_col] >> 16) & 0xff) + fa * ((mg_palette[for_col] >> 16) & 0xff); \
      tmp_c |= (comp / alpha_c) << 16; \
      comp = ba * ((mg_palette[bck_col] >> 8) & 0xff) + fa * ((mg_palette[for_col] >> 8) & 0xff); \
      tmp_c |= (comp / alpha_c) << 8; \
      comp = ba * (mg_palette[bck_col] & 0xff) + fa * (mg_palette[for_col] & 0xff); \
      tmp_c |= (comp / alpha_c); \
      aa_8bit_cols[1] = OSD_FindNearestColourIndex(tmp_c); \
      comp = 2 * (mg_palette[for_col] >> 24); \
      ba = (U8BIT)(mg_palette[bck_col] >> 24); \
      alpha_c = ((((255 ^ ba) * comp) + 382) / 765) + ba; \
      tmp_c = alpha_c << 24; \
      fa = (U8BIT)((comp + 1) / 3); \
      comp = ba; \
      ba = (U8BIT)(((255 ^ fa) * comp) + 127) / 255; \
      comp = ba * ((mg_palette[bck_col] >> 16) & 0xff) + fa * ((mg_palette[for_col] >> 16) & 0xff); \
      tmp_c |= (comp / alpha_c) << 16; \
      comp = ba * ((mg_palette[bck_col] >> 8) & 0xff) + fa * ((mg_palette[for_col] >> 8) & 0xff); \
      tmp_c |= (comp / alpha_c) << 8; \
      comp = ba * (mg_palette[bck_col] & 0xff) + fa * (mg_palette[for_col] & 0xff); \
      tmp_c |= (comp / alpha_c); \
      aa_8bit_cols[2] = OSD_FindNearestColourIndex(tmp_c); \
      aa_8bit_cols[3] = for_col; \
   }

static U8BIT aa_8bit_cols[4] = {OFFSET_TRANS, OFFSET_TRANS, OFFSET_TRANS, OFFSET_TRANS};

#include "textdrawfn.h"

#undef TextDrawFn
#undef RenderGlyphFn
#undef TDColor
#undef CalcColorArray
#undef MakeTDColor
#undef GreyValue
#undef SRC_FORE_MAX
#undef IsOpaqueColor
#undef NotTransparent
#undef CombineAlphaColour

#endif /*OSD_8_BIT*/


#ifdef OSD_16_BIT

#define TextDrawFn                           TextDraw16Bit
#define RenderGlyphFn                        RenderGlyph16Bit
#define TDColor                              HD2Color
#define MakeTDColor(col)                     MakeHD2Color( col )
#define GreyValue(val)                       val
#define SRC_FORE_MAX                         255
#define IsOpaqueColor( tcol )                ((tcol >> 12) == 0xf)
#define NotTransparent( fcol )               ((fcol >> 28) != 0x0)
#define CombineAlphaColour(pixel, grey_val, full_col, fore_col) \
   grey_val *= (full_col >> 24); \
   if (grey_val & 0xf000) { pixel = (fore_col & 0x0fff) | (grey_val & 0xf000); }

#include "textdrawfn.h"

#undef TextDrawFn
#undef RenderGlyphFn
#undef CombineAlphaColour

#define TextDrawFn                           TextDraw16BitBlend
#define RenderGlyphFn                        RenderGlyph16Blend
#define CombineAlphaColour(pixel, grey_val, full_col, fore_col) \
   grey_val *= (full_col >> 24); \
   if (grey_val & 0xff00) { \
      register U32BIT fa, ba, comp, tmp_c, alpha_c; \
      ba = (U8BIT)(pixel >> 12); \
      comp = ba * 17; \
      alpha_c = ((((15 - ba) *grey_val) + 1912) / 3825) + comp; \
      fa = (U8BIT)(grey_val / SRC_FORE_MAX); \
      ba = (((255 ^ fa) *comp) + 127) / 255; \
      tmp_c = (alpha_c / 17) << 12; \
      comp = ba * ((pixel >> 8) & 0xf) + fa * ((fore_col >> 8) & 0xf); \
      tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c) << 8; \
      comp = ba * ((pixel >> 4) & 0xf) + fa * ((fore_col >> 4) & 0xf); \
      tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c) << 4; \
      comp = ba * (pixel & 0xf) + fa * (fore_col & 0xf); \
      tmp_c |= ((comp + (alpha_c >> 1)) / alpha_c); \
      pixel = (U16BIT)tmp_c; \
   }

#include "textdrawfn.h"

#undef TextDrawFn
#undef RenderGlyphFn
#undef TDColor
#undef MakeTDColor
#undef SRC_FORE_MAX
#undef IsOpaqueColor
#undef NotTransparent
#undef CombineAlphaColour

#endif /* OSD_16_BIT */


#if defined(OSD_31_BIT) || defined(OSD_32_BIT)

#define TextDrawFn                           TextDraw32Bit
#define RenderGlyphFn                        RenderGlyph32Bit
#define TDColor                              OSDColor
#define GreyValue(val)                       val
#define MakeTDColor(col)                     AlphaPlatform(col)
#define SRC_FORE_MAX                         255
#define IsOpaqueColor( tcol )                ((tcol >> 24) == MAX_ALPHA)
#define NotTransparent( fcol )               ((fcol >> 24) != 0x00)
#define CombineAlphaColour(pixel, grey_val, full_col, fore_col) \
   grey_val *= CalcAlpha(fore_col >> 24); \
   if (grey_val > 127) { pixel = (fore_col & 0xffffff) | ((grey_val << 16) & 0xff000000); }

#include "textdrawfn.h"

#undef TextDrawFn
#undef RenderGlyphFn
#undef CombineAlphaColour

#define TextDrawFn                           TextDraw32BitBlend
#define RenderGlyphFn                        RenderGlyph32Blend
#define CombineAlphaColour(pixel, grey_val, full_col, fore_col) \
   grey_val *= CalcAlpha(fore_col >> 24); \
   if (grey_val > 127) { \
      register U32BIT fa, ba, comp, tmp_c, alpha_c; \
      ba = pixel >> 24; \
      alpha_c = ((((MAX_ALPHA - ba) *grey_val) + ((MAX_ALPHA *255) / 2)) / (MAX_ALPHA *255)) + ba; \
      fa = (U8BIT)(grey_val / SRC_FORE_MAX); \
      ba = (((MAX_ALPHA - fa) *ba) + (MAX_ALPHA / 2)) / MAX_ALPHA; \
      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; \
   }

#include "textdrawfn.h"

#undef TextDrawFn
#undef RenderGlyphFn
#undef TDColor
#undef MakeTDColor
#undef SRC_FORE_MAX
#undef IsOpaqueColor
#undef NotTransparent
#undef SignificantFore
#undef CombineAlphaColour

#endif /* OSD_32_BIT */


static CharData* GetCharArray( const TextString unistr, pDrawTextAttrib attrib, CharData *chars )
{
   U32BIT m_size, glph_count;
   CharData *char_data;
   if (unistr.len < MAX_NUM_CHARS)
   {
      char_data = chars;
   }
   else
   {
      /* check that the 'chars' array on the stack is big enough,
       * if not get some heap space for it */
      m_size = 0;
      for (glph_count = 0; glph_count != unistr.len; glph_count++)
      {
         switch (unistr.data[glph_count])
         {
            case UNICODE_ESC:
               if (glph_count + 1 != unistr.len)
               {
                  /*Markup sequence*/
                  glph_count++;
                  if ((unistr.data[glph_count] <= 0x5e) &&
                      (unistr.data[glph_count] >= 0x40) &&
                      (glph_count + 1 != unistr.len))
                  {
                     glph_count++;
                     if ((glph_count + unistr.data[glph_count]) <= unistr.len)
                     {
                        glph_count += unistr.data[glph_count];
                     }
                  }
               }
               break;

            case UNICODE_SPACE:
            case UNICODE_TAB:
         #if 0
            case UNICODE_HARD_SPACE:
            case UNICODE_FIGURE_SPACE:
         #endif
               if ((attrib->justify & JFY_HZ_MASK) == JUSTIFY_H_CENTRE)
               {
                  m_size++;
               }
               break;

            default:
               if (unistr.data[glph_count] > 0x20)
               {
                  /* assume this is a printable char */
                  m_size++;
               }
         }
      }
      if (attrib->entry_point != -1)
      {
         m_size++;
      }
      if (m_size > MAX_NUM_CHARS)
      {
         /* array 'chars' ain't big enough, so allocate buffer for character descriptions */
         char_data = (CharData *)OSD_MemAlloc( sizeof(CharData) * m_size );
         TRACE(TTEXT, ("malloc char_data array (sz=%d) at 0x%x", m_size, char_data))
      }
      else
      {
         char_data = chars;
      }
   }
   return char_data;
}

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

void* MG_DrawUKText( const TextString unistr, pDrawTextAttrib attrib, const VRect txt_box )
{
   S_FontDetails *font_ptr;
   S_FontSize *f_szdata;
   S_SURFACE *canvas = 0;
   CharData *char_data;
   CharData chars[MAX_NUM_CHARS];
   LineLimit lines[MAX_NUM_LINES + 1];
   U16BIT line_count, glph_count;

   assert( attrib );

   TRACE(TTEXT, ("SD box=(%d,%d,%d,%d)", txt_box.left, txt_box.top, txt_box.left + txt_box.width, txt_box.top + txt_box.height))
   TRACE_UNIC(TTEXT, unistr.data, unistr.len)

   f_szdata = attrib->font.hdl;

   if ((f_szdata != NULL) &&
       (txt_box.width > f_szdata->bb_sd_width) &&
       (txt_box.height >= f_szdata->bb_sd_height))
   {
      U16BIT available_lines;
      S_REGION draw;

      TRACE(TTEXT, ("font=%x width=%d, height=%d posn=(%d,%d) ls=%d", attrib->font.hdl->fnt_id,
                    txt_box.width, txt_box.height, txt_box.left, txt_box.top, attrib->line_space))
      /*See MHEG HD spec in DBook section 14.11.3.2 "Bounding box transformation" for scaling of boxes */
      draw.left = (S16BIT)((txt_box.left * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div);
      draw.top = (S16BIT)((txt_box.top * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div);
      draw.right = (S16BIT)txt_box.width;
      draw.bottom = (S16BIT)txt_box.height;
      draw.right = (S16BIT)(((draw.right + txt_box.left) * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div);
      draw.bottom = (S16BIT)(((draw.bottom + txt_box.top) * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div);

      /* box has some size, and may be able to fit some text in */
      if (attrib->line_space == 0)
      {
         /* infinite lines: all on same place! */
         available_lines = MAX_NUM_LINES;
      }
      else
      {
         available_lines = (U16BIT)(((txt_box.height - f_szdata->bb_sd_height) / attrib->line_space) + 1);
         if (available_lines > MAX_NUM_LINES)
         {
            /* defensive programming */
            TRACE(TERROR, ("Num of text lines was restricted from %d to %d", available_lines, MAX_NUM_LINES))
            available_lines = MAX_NUM_LINES;
         }
      }

      MG_CheckCache( f_szdata );

      char_data = GetCharArray( unistr, attrib, chars );
      if (char_data == NULL)
      {
         /*out of memory*/
         return 0;
      }
      font_ptr = MG_FindFont(f_szdata);
      line_count = PreparePrintableData( unistr, attrib, f_szdata, font_ptr, draw.right - draw.left,
            (U16BIT)txt_box.width, available_lines, lines, char_data, &glph_count );
      if (line_count > 0 && glph_count > 0)
      {
         #ifdef TRACING
         TRACE(TTEXT, ("HD box=(%d,%d,%d,%d)", draw.left, draw.top, draw.right, draw.bottom))
         TRACE(TTEXT, ("lines(%d,%d) left=%d avl_width=%d", available_lines, line_count, f_szdata->bound_box.left,
                       txt_box.width - f_szdata->spxl_xleftoffset))
         if (TTEXT & mheg_trace_debug)
            trace_lines( line_count, lines, char_data, f_szdata->fnt_id & 0xff, font_ptr->metric_resolution );
         #endif /*TRACING*/

         canvas = OSD_MemAlloc( sizeof(S_SURFACE));

         if (canvas != NULL)
         {
            canvas->width = draw.right - draw.left;
            canvas->height = draw.bottom - draw.top;
            canvas->srf_type = SRF_TYPE_TXT;
            TRACE(TTEXT, ("canvas=(%d,%d)", canvas->width, canvas->height))

            if (attrib->line_space == 0)
            {
               available_lines = line_count;
            }

            IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
            {
            #ifdef OSD_8_BIT
               canvas->col_buff = OSD_MemAlloc( canvas->width * canvas->height );
               canvas->hw_handle = NULL;
               if (canvas->col_buff != NULL)
               {
                  canvas->buff_pitch = canvas->width;
                  memset( canvas->col_buff,
                     OSD_FindNearestColourIndex(0x00000000),
                     canvas->width * canvas->height );

                  TextDraw8Bit( lines, char_data, f_szdata, font_ptr->face,
                     attrib->justify & JUSTIFY_V_JUSTIFIED, attrib->justify & JUSTIFY_H_JUSTIFIED,
                     attrib->line_space, txt_box.top, txt_box.height,
                     line_count, available_lines, canvas );
               }
            #endif
            }
            ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
            {
            #ifdef OSD_16_BIT
               canvas->hw_handle = STB_OSDMhegCreateSurface( canvas->width, canvas->height,
                     TRUE, 0x0000 );
               OSD_DbgAddSurf( canvas );
               if (canvas->hw_handle != NULL)
               {
                  canvas->buff_pitch = canvas->width << 1;
                  canvas->col_buff = STB_OSDMhegLockBuffer( canvas->hw_handle, &canvas->buff_pitch );
                  if (canvas->col_buff)
                  {
                     TextDraw16Bit( lines, char_data, f_szdata, font_ptr->face,
                        attrib->justify & JUSTIFY_V_JUSTIFIED, attrib->justify & JUSTIFY_H_JUSTIFIED,
                        attrib->line_space, txt_box.top, txt_box.height,
                        line_count, available_lines, canvas );
                     STB_OSDMhegUnlockBuffer( canvas->hw_handle );
                  }
               }
            #endif
            }

            ELSE
            {
            #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
               canvas->hw_handle = STB_OSDMhegCreateSurface( canvas->width, canvas->height,
                     TRUE, 0x00000000 );
               OSD_DbgAddSurf( canvas );
               if (canvas->hw_handle != NULL)
               {
                  canvas->buff_pitch = canvas->width << 2;
                  canvas->col_buff = STB_OSDMhegLockBuffer( canvas->hw_handle, &canvas->buff_pitch );
                  if (canvas->col_buff)
                  {
                     TextDraw32Bit( lines, char_data, f_szdata, font_ptr->face,
                        attrib->justify & JUSTIFY_V_JUSTIFIED, attrib->justify & JUSTIFY_H_JUSTIFIED,
                        attrib->line_space, txt_box.top, txt_box.height,
                        line_count, available_lines, canvas );
                     STB_OSDMhegUnlockBuffer( canvas->hw_handle );
                  }
               }
            #endif
            }
         }
      }

      if (char_data != chars)
      {
         OSD_MemFree( char_data );
      }
   }

   TRACE(TTEXT, ("return=0x%x\n", canvas))
   return canvas;
   /* returning NULL is not necessarily an error. It does that when no actual text to be displayed.
    * This code assumes that where an empty box is required (as when box is too small for text),
    * the higher level software will draw it.
    */
}

S16BIT MG_TextWidth( const TextString unistr, pDrawTextAttrib attrib )
{
   CharData *char_data;
   CharData chars[MAX_NUM_CHARS];
   LineLimit lines[2];
   U16BIT line_count, glph_count;
   H_FontSize f_sz;

   assert( attrib );

   TRACE_UNIC(TTEXT, unistr.data, unistr.len)

   f_sz = attrib->font.hdl;

   if (f_sz == NULL)
   {
      TRACE(TERROR, ("f_sz NULL"))
      lines[0].l_width = 0;
   }
   else
   {
      TRACE(TTEXT, ("font id=%x", f_sz->fnt_id))

      MG_CheckCache( f_sz );

      char_data = GetCharArray( unistr, attrib, chars );
      if (char_data != NULL)
      {
         /* Setting justify to Hz End, means that width of spaces are counted (also tab => space) */
         attrib->justify = JUSTIFY_H_END;
         line_count = PreparePrintableData( unistr, attrib, f_sz, MG_FindFont(f_sz), mg_ctxt.out_osd_width,
               mg_ctxt.out_osd_width, 1, lines, char_data, &glph_count );
         if (line_count == 0)
         {
            lines[0].l_width = 0;
         }
         if (char_data != chars)
         {
            OSD_MemFree( char_data );
         }
      }
   }

   TRACE(TTEXT, ("return=%d", lines[0].l_width))
   return (S16BIT)lines[0].l_width;
}

void MG_DrawScreenText( const TextString unistr, pDrawTextAttrib attrib, S_SURFACE *canvas )
{
   S_FontDetails *font_ptr;
   S_FontSize *f_szdata;
   CharData *char_data;
   CharData chars[MAX_NUM_CHARS];
   LineLimit lines[2];
   U16BIT line_count, glph_count;

   assert( attrib );

   TRACE(TTEXT, ("box=%d,%d", canvas->width, canvas->height))
   TRACE_UNIC(TTEXT, unistr.data, unistr.len)

   f_szdata = attrib->font.hdl;

   if (f_szdata != NULL && canvas != NULL && canvas->col_buff != NULL &&
       (canvas->width > f_szdata->bb_sd_width) &&
       (canvas->height >= f_szdata->bb_sd_height))
   {
      TRACE(TTEXT, ("font=%x ls=%d", attrib->font.hdl->fnt_id, attrib->line_space))

      //MG_CheckCache( f_szdata );

      char_data = GetCharArray( unistr, attrib, chars );
      if (char_data != NULL)
      {
         font_ptr = MG_FindFont(f_szdata);
         line_count = PreparePrintableData( unistr, attrib, f_szdata, font_ptr, canvas->width,
               canvas->width, 1, lines, char_data, &glph_count );
         if (line_count > 0 && glph_count > 0)
         {
            #ifdef TRACING
            TRACE(TTEXT, ("lines(%d,%d)", 1, line_count))
            if (TTEXT & mheg_trace_debug)
               trace_lines( line_count, lines, char_data, f_szdata->fnt_id & 0xff, font_ptr->metric_resolution );
            #endif /*TRACING*/

            if (canvas != NULL)
            {
               TRACE(TTEXT, ("canvas (buf=%p,%d,%d)", canvas->col_buff, canvas->width, canvas->height))

               IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
               {
               #ifdef OSD_8_BIT
                  TextDraw8Bit( lines, char_data, f_szdata, font_ptr->face,
                     attrib->justify & JUSTIFY_V_JUSTIFIED, attrib->justify & JUSTIFY_H_JUSTIFIED,
                     attrib->line_space, 0, canvas->height,
                     line_count, 1, canvas );
               #endif
               }
               ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
               {
               #ifdef OSD_16_BIT
                  TextDraw16BitBlend( lines, char_data, f_szdata, font_ptr->face,
                     attrib->justify & JUSTIFY_V_JUSTIFIED, attrib->justify & JUSTIFY_H_JUSTIFIED,
                     attrib->line_space, 0, canvas->height,
                     line_count, 1, canvas );
               #endif
               }

               ELSE
               {
               #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
                  TextDraw32BitBlend( lines, char_data, f_szdata, font_ptr->face,
                     attrib->justify & JUSTIFY_V_JUSTIFIED, attrib->justify & JUSTIFY_H_JUSTIFIED,
                     attrib->line_space, 0, canvas->height,
                     line_count, 1, canvas );
               #endif
               }
            }
         }

         if (char_data != chars)
         {
            OSD_MemFree( char_data );
         }
      }
   }
   else
   {
      /* Access often code causes things to end up here - appearance seems ok anyway */
      if (f_szdata != NULL && canvas != NULL)
      {
         TRACE(TTEXT, ("Size too small: (%d < %d)? or (%d < %d)?", canvas->width, f_szdata->bb_sd_width, canvas->height, f_szdata->bb_sd_height));
      }
   }
}

void* MG_DrawText( const TextString unistr, pDrawTextAttrib attrib, const VRect txt_box )
{
#ifdef HK_PROFILE
   if (attrib->font.fp.index == HK_FNT_MAGIC)
   {
      return MG_DrawHKText( unistr, attrib, txt_box );
   }
   else
#endif
   {
      return MG_DrawUKText( unistr, attrib, txt_box );
   }
}