mg_font.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2010 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "glue_assert.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "mh5profile.h"
#include "mh5support.h"
#include "mg_ctxt.h"
#include "mg_drawtext.h"

#include "mg_fontapi.h"
#include "mg_font.h"


/* Include Tiresias Screen Font PFR data for UK Profile,
 * header file contains the macros: FILE_DATA_PTR, FILE_DATA_SIZE */
#include "Tires-o_751nz_pfr.h"

/* 7.5.1 ->   xMin=-324,yMin=-508,xMax=2048,yMax=1866 */
/*                 -40       -62       271       231 */

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

#ifndef FONTS_CACHE_MAX
/* Makefile does not say anything, so lets have a default of 131072 bytes.
 * It could be zero and the code should still work fine - if a little slower
 * For SD, with the four font sizes: max cache requirements: 70333 bytes
 */
   #define FONTS_CACHE_MAX 0x00020000
#endif

/* Total number of fonts for MHEG -
 * Five font objects - one for UK profile and four downloaded font
 * But Total number for Hbbtv could a lot more - so limit to 16
 */
#define MAX_FONT_OBJECTS    16


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

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

static FT_Library mg_ft_lib = 0;

static U32BIT mg_cache_in_use;
static U32BIT mg_total_cache_hits;
static U16BIT mg_cached_fontsizes;
static U16BIT mg_last_screen_w = 0;
static U16BIT mg_last_screen_h = 0;
static U16BIT mg_max_fonts_allowed = 1;
static S_FontDetails *mg_font_array[MAX_FONT_OBJECTS];

E_HDMode mg_hd_mode = NORMAL_SD;

/*---local function prototypes for this file---------------------------------*/

static void FreeFontFile( S16BIT font_index );
static void allocateCache( S_FontDetails *fd_ptr, S_FontSize *sz_data );
static void initialiseFontDetails( S_FontDetails *fnt_d_ptr );
static void freeCache( S_FontSize *fsz_ptr );

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

BOOLEAN MG_FontInit( BOOLEAN isHD )
{
   const unsigned char *font_data;
   int font_data_len;

   TRACE(TALWAYS, ("About to Initialise Font %x", mg_ft_lib))

   if (isHD)
   {
      assert(((int)mg_ctxt.out_osd_height * 16) == ((int)mg_ctxt.out_osd_width * 9));
      /* A normal HD platform */
      mg_hd_mode = NORMAL_HD;
   }
   /* else mg_hd_mode stays as NORMAL_SD - i.e. no HD functionality
    */
   if (mg_ft_lib != 0)
   {
      /* already initialised library, so just check to see if need to adjust scaling */
      if ((mg_last_screen_h != mg_ctxt.out_osd_height) || (mg_last_screen_w != mg_ctxt.out_osd_width))
      {
         int f_ndx;
         for (f_ndx = 0; f_ndx != MAX_FONT_OBJECTS && mg_font_array[f_ndx]; f_ndx++)
         {
            initialiseFontDetails( mg_font_array[f_ndx] );
         }
         mg_last_screen_h = mg_ctxt.out_osd_height;
         mg_last_screen_w = mg_ctxt.out_osd_width;
      }
   }
   /* Initialise the Freetype library */
   else if (FT_Init_FreeType( &mg_ft_lib ) == 0)
   {
      TRACE(TALWAYS, ("Initialised OK %x", mg_ft_lib))

      assert( mg_font_array[0] == NULL );

      mg_cache_in_use = 0;
      mg_total_cache_hits = 0;
      mg_cached_fontsizes = 0;
      mg_max_fonts_allowed = 1;

      font_data = FILE_DATA_PTR;
      font_data_len = FILE_DATA_SIZE;

      if (MG_FontLoadFile( font_data, font_data_len ) == 0)
      {
         TRACE(TALWAYS, ("MG_FontLoadFile OK %d", font_data_len))
         mg_last_screen_h = mg_ctxt.out_osd_height;
         mg_last_screen_w = mg_ctxt.out_osd_width;
      }
      else
      {
         TRACE(TERROR, ("MG_FontLoadFile FAILED"))
         /* MG_LoadFontFile returned error, -1 */
         FT_Done_FreeType( mg_ft_lib );
         mg_ft_lib = 0;
      }
   }
   else
   {
      TRACE(TERROR, ("FT_Init_FreeType FAILED"))
      mg_ft_lib = 0;
   }

   return (mg_ft_lib != 0) ? TRUE : FALSE;
}

void MG_SetMaxFonts(U16BIT max)
{
   if (max > BUILT_IN_FONT)
   {
      if (max > MAX_FONT_OBJECTS)
      {
         mg_max_fonts_allowed = MAX_FONT_OBJECTS;
      }
      else
      {
         mg_max_fonts_allowed = max;
      }
   }
}

void MG_FontExit(void)
{
   if (mg_ft_lib)
   {
      int f_ndx;

      for (f_ndx = MAX_FONT_OBJECTS - 1; f_ndx != 0; f_ndx--)
      {
         MG_FontFreeFile( f_ndx );
      }
      FreeFontFile( 0 );

      mg_hd_mode = NORMAL_SD;

      FT_Done_FreeType( mg_ft_lib );
      mg_ft_lib = 0;
   }
}

S16BIT MG_FontLoadFile( const U8BIT *data, U32BIT length )
{
   S_FontDetails *font_ptr;
   U16BIT f_ndx;
   S16BIT rtnVal;
   U8BIT face_num;
   U8BIT *file_data;

   assert( data );
   rtnVal = -1;
   f_ndx = BUILT_IN_FONT;

   TRACE(TFONT, ("About to Initialise Font ptr=%p sz=%d", data, length))

   while ((f_ndx != mg_max_fonts_allowed) && (mg_font_array[f_ndx] != NULL))
      f_ndx++;

   if (f_ndx != mg_max_fonts_allowed)
   {
      assert( mg_font_array[f_ndx] == NULL );
      face_num = 0;
      font_ptr = (S_FontDetails *) FT2_MemAlloc( sizeof(S_FontDetails));
      TRACE(TFONT, ("ndx=%d font_ptr=%p sz=%d", f_ndx, font_ptr, sizeof(S_FontDetails)))
      if (font_ptr != NULL)
      {
         TRACE(TFONT, ("font_ptr->next=%p", font_ptr->next))
         font_ptr->next = NULL;
         font_ptr->face = NULL;
         font_ptr->first_sz = NULL;
         if (f_ndx != BUILT_IN_FONT && length != 0)
         {
            file_data = (U8BIT *)OSD_MemAlloc( length );
            if (file_data == NULL)
            {
               FT2_MemFree( font_ptr );
               font_ptr = NULL;
               /* return index to default font */
               rtnVal = 0;
            }
            else
            {
               memcpy( file_data, data, length );
               font_ptr->file_data = file_data;
               font_ptr->file_size = length;
               mg_font_array[f_ndx] = font_ptr;
            }
         }
         else
         {
            file_data = (U8BIT *)data;
            font_ptr->file_data = NULL;
            mg_font_array[f_ndx] = font_ptr;
         }
         while (font_ptr != NULL)
         {
            TRACE(TFONT, ("font_ptr=%p, font_ptr->face=%p", font_ptr, font_ptr->face))
            if ((length != 0 && FT_New_Memory_Face( mg_ft_lib, file_data, length, face_num, &font_ptr->face ) == 0) ||
                (length == 0 && FT_New_Face( mg_ft_lib, (const char *)file_data, face_num, &font_ptr->face ) == 0))
            {
               face_num++;
               font_ptr->font_ndx = f_ndx;
               if (memcmp( file_data, "PFR0", 4 ) == 0)
               {
                  font_ptr->face_type = FTYPE_PFR;
               }
               else
               {
                  font_ptr->face_type = FTYPE_TTF;
               }
               TRACE(TFONT, ("font_ptr=%p, font_ptr->face=%p", font_ptr, font_ptr->face))
               TRACE(TFONT, ("font_ptr->face->stream=%p, font_ptr->face->stream->read=%p", font_ptr->face->stream, font_ptr->face->stream->read))
               initialiseFontDetails( font_ptr );
               TRACE(TFONT, ("f_ndx=%d", f_ndx))
               if (f_ndx == BUILT_IN_FONT)
               {
                  const U8BIT uk_profile_sizes[6] = { 20, 22, 36, 31, 26, 24 };
                  int i;
                  assert( mg_font_array[0]->face->num_faces == 1 );
                  if (mg_hd_mode == NORMAL_SD)
                  {
                     for (i = 2; i != 6; i++)
                     {
                        if (MG_GetFontSize( BUILT_IN_FONT, uk_profile_sizes[i], FONT_STYLE_PLAIN ) == NULL)
                        {
                           TRACE(TERROR, ("Failed to add font %d,PLAIN", uk_profile_sizes[i]))
                        }
                     }
                  }
                  else
                  {
                     /* support HD-MHEG */
                     for (i = 0; i != 6; i++)
                     {
                        if (MG_GetFontSize( BUILT_IN_FONT, uk_profile_sizes[i], FONT_STYLE_SQUARE ) == NULL)
                        {
                           TRACE(TERROR, ("Failed to add font %d,SQUARE", uk_profile_sizes[i]))
                        }
                     }
                     for (i = 0; i != 6; i++)
                     {
                        if (MG_GetFontSize( BUILT_IN_FONT, uk_profile_sizes[i], FONT_STYLE_PLAIN ) == NULL)
                        {
                           TRACE(TERROR, ("Failed to add font %d,PLAIN", uk_profile_sizes[i]))
                        }
                     }
                  }
               }
               /* else
                * downloaded font object - wait 'til we draw to find out what size is required
                */

               TRACE(TFONT, (" face_num=%d", face_num))
               TRACE(TFONT, (" mg_font_array[f_ndx]->face->num_faces=%d", mg_font_array[f_ndx]->face->num_faces))
               if (face_num < mg_font_array[f_ndx]->face->num_faces)
               {
                  /* more faces to do */
                  font_ptr->next = (S_FontDetails *) FT2_MemAlloc( sizeof(S_FontDetails));
               }
               else
               {
                  /* Success */
                  font_ptr->next = NULL;
                  rtnVal = (S16BIT)f_ndx;
               }
            }
            else
            {
               /* Error */
               TRACE(TERROR, (" f_ndx=%d", f_ndx))
               font_ptr->next = NULL;
               font_ptr->face = NULL;
            }
            font_ptr = font_ptr->next;
         }
      }
      if (rtnVal == -1)
      {
         TRACE(TERROR, (" FAILED %d", f_ndx))
         if (f_ndx != 0)
         {
            MG_FontFreeFile( f_ndx );
            /* when attempting to add downloaded font and get a failure, return index to default font */
            rtnVal = 0;
         }
         else
         {
            FreeFontFile( 0 );
            /* failed to load default font */
         }
      }
   }
   else
   {
      TRACE(TERROR, ("Reached MAX fonts allowed, %d", f_ndx))
      /* when attempting to add downloaded font and get a failure, return index
       * to default font
       */
      rtnVal = 0;
   }

   TRACE(TFONT, (" End %d", rtnVal))
   return rtnVal; /* return font index */
}

void MG_FontFreeFile( S16BIT font_index )
{
   if ((font_index > BUILT_IN_FONT) && (font_index < MAX_FONT_OBJECTS))
   {
      /*not builtin font*/
      if ((mg_font_array[font_index] != NULL) &&
          (mg_font_array[font_index]->file_data != NULL)
          )
      {
         /* free downloaded font file data */
         OSD_MemFree((U8BIT *)mg_font_array[font_index]->file_data );
      }
      FreeFontFile( font_index );
   }
}

S_FontDetails* MG_GetFontPtr( S16BIT font_index )
{
   assert( font_index >= 0 && font_index < MAX_FONT_OBJECTS );

   return mg_font_array[font_index];
}

void MG_ReleaseFontPtr( S_FontDetails *fp )
{
}

static void SetupCaching( S_FontDetails *font_ptr, S_FontSize *fontsize_ptr )
{
   FT_Face the_face = font_ptr->face;
   FT_GlyphSlot the_glyph = the_face->glyph;
   FT_UInt glyph_index_figspace, *glyph_array;
   U32BIT cache_size;
   int chr;

   /* Because of FreeType's weird behaviour in test HD046, we must do following:
    * 1. Set char size,
    * 2. Load a glyph.
    * 3. Set char size again
    * 4. Load glyphs for rendering
    * Only then will results for the glyph bitmaps be consistant */
   TRACE(TFONT, ("FT_Set_Char_Size face=%p w=%d h=%d", the_face, fontsize_ptr->width, fontsize_ptr->height))
   if (FT_Set_Char_Size( the_face, fontsize_ptr->width, fontsize_ptr->height, 72, 72 ) != 0)
   {
      TRACE(TERROR, ("FT_Set_Char_Size FAILED"))
      fontsize_ptr->mem_size = 0;
   }
   else
   {
      glyph_index_figspace = FT_Get_Char_Index( the_face, '0' );
      if (FT_Load_Glyph( the_face, font_ptr->glyph_ndx_space, FT_LOAD_RENDER ) == 0)
      {
         fontsize_ptr->space_adv = (S8BIT)((the_face->glyph->advance.x + 32) >> 6);
         if ((fontsize_ptr->fnt_id >> 8) & FONT_STYLE_NO_SCALE)
         {
            TRACE(TFONT, ("adv=0x%x s=%d", the_face->glyph->advance.x, fontsize_ptr->space_adv))
            fontsize_ptr->space_adv--;
         }
      }
      if (FT_Load_Glyph( the_face, glyph_index_figspace, FT_LOAD_RENDER ) == 0)
      {
         fontsize_ptr->figure_adv = (S8BIT)((the_face->glyph->advance.x + 32) >> 6);
      }
      TRACE(TFONT, ("advances: space=%d fig-sp=%d", fontsize_ptr->space_adv, fontsize_ptr->figure_adv))
   }
   if (FT_Set_Char_Size( the_face, fontsize_ptr->width, fontsize_ptr->height, 72, 72 ) != 0)
   {
      TRACE(TERROR, ("FT_Set_Char_Size FAILED"))
      fontsize_ptr->mem_size = 0;
   }
   else
   {
      /* Now do bitmap cache stuff */
      cache_size = 0;
      glyph_array = font_ptr->glyph_ndx;
      for (chr = 0; chr != CHAR_CACHE_SIZE; chr++)
      {
         if (glyph_array[chr] && FT_Load_Glyph(the_face, glyph_array[chr], FT_LOAD_RENDER) == 0)
         {
            cache_size += the_glyph->bitmap.width * the_glyph->bitmap.rows;
            TRACE(TFONTCACHE, ("Glyph %d (%d,%d) Csize=%d", glyph_array[chr], the_glyph->bitmap.width, the_glyph->bitmap.rows, cache_size))
         }
      }
      fontsize_ptr->mem_size = cache_size;
   }
   fontsize_ptr->sbit_cache = 0;
   fontsize_ptr->cache_hit = 0;
   TRACE(TFONT, (""))
}

H_FontSize MG_AllocateFont(S16BIT fnt_index, U8BIT fnt_size, U8BIT fnt_style)
{
   S_FontSize *f_sz;
   if (fnt_index < 0 || fnt_index >= MAX_FONT_OBJECTS ||
       mg_font_array[fnt_index] == NULL)
   {
      f_sz = MG_GetFontSize( BUILT_IN_FONT, fnt_size, fnt_style );
   }
   else
   {
      f_sz = MG_GetFontSize((U16BIT)fnt_index, fnt_size, fnt_style );
   }
   return f_sz;
}

void MG_ReleaseFont( H_FontSize f_sz )
{
   S16BIT fndx;
   if (f_sz != NULL)
   {
      for (fndx = 0; fndx != MAX_FONT_OBJECTS; fndx++)
      {
         if (mg_font_array[fndx] != NULL)
         {
            S_FontSize **ppfs;
            ppfs = &(mg_font_array[fndx]->first_sz);
            while (*ppfs != NULL)
            {
               if (*ppfs == f_sz)
               {
                  *ppfs = (*ppfs)->next;
                  freeCache( f_sz );
                  FT2_MemFree( f_sz );
                  fndx = MAX_FONT_OBJECTS - 1;
                  break;
               }
               else
               {
                  ppfs = &((*ppfs)->next);
               }
            }
         }
      }
   }
}

S_FontDetails* MG_FindFont( H_FontSize f_sz )
{
   S16BIT fndx;
   S_FontSize *pfs;
   if (f_sz != NULL)
   {
      for (fndx = 0; fndx != MAX_FONT_OBJECTS; fndx++)
      {
         if (mg_font_array[fndx] != NULL)
         {
            pfs = mg_font_array[fndx]->first_sz;
            while (pfs != NULL)
            {
               if (pfs == f_sz)
               {
                  return mg_font_array[fndx];
               }
               pfs = pfs->next;
            }
         }
      }
   }
   return NULL;
}

void   MG_GetFontMetrics( H_FontSize f_sz, S_FontMetrics *pMetrics )
{
   if (f_sz == NULL)
   {
      TRACE(TFONT, ("f_sz is NULL"));
      pMetrics->ascent = 0;
      pMetrics->descent = 0;
      pMetrics->height = 0;
      pMetrics->minWidth = 0;
      pMetrics->maxWidth = 0;
   }
   else
   {
      TRACE(TFONT, ("bbsdw=%d bbsdh=%d bb(%d,%d,%d,%d)", f_sz->bb_sd_width, f_sz->bb_sd_height,
                    f_sz->bound_box.left, f_sz->bound_box.top, f_sz->bound_box.width, f_sz->bound_box.height));
      pMetrics->ascent = f_sz->bound_box.top;
      pMetrics->descent = f_sz->bound_box.height - f_sz->bound_box.top;
      pMetrics->height = f_sz->bound_box.height;
      pMetrics->minWidth = f_sz->bound_box.left;
      pMetrics->maxWidth = f_sz->bound_box.width;
   }
}

S_FontSize* MG_GetFontSize( U16BIT fnt_index, U8BIT fnt_size, U8BIT fnt_style )
{
   S_FontSize *fsz_ptr;
   S_FontDetails *ftd_ptr;
   U32BIT fnt_id;

   TRACE(TFONT, ("(%d %d %x)", fnt_index, fnt_size, fnt_style))
   assert( fnt_index < MAX_FONT_OBJECTS && mg_font_array[fnt_index] );

   /* Make unique font ID for a particular font spec */
   fnt_id = (fnt_index << 16) | (fnt_style << 8) | fnt_size;

   ftd_ptr = mg_font_array[fnt_index];
   fsz_ptr = ftd_ptr->first_sz;
   while ((fsz_ptr != NULL) && (fsz_ptr->fnt_id != fnt_id))
   {
      fsz_ptr = fsz_ptr->next;
   }
   if (fsz_ptr == NULL)
   {
      FT_BBox fnt_bbox;
      FT_UInt outline_resolution;
      FT_Face the_face = ftd_ptr->face;
      S32BIT fnt_sd_sz, fnt_hd_sz, units, ratio_x, ratio_y;
      S32BIT s_size;
      U16BIT bb_hd_h, bb_sd_h, bb_sd_w, bb_hd_t, bb_sd_t;

      /* font size not existing - add new one */

      fsz_ptr = (S_FontSize *)FT2_MemAlloc(sizeof(S_FontSize));
      if (fsz_ptr != NULL)
      {
         fsz_ptr->next = ftd_ptr->first_sz;
         ftd_ptr->first_sz = fsz_ptr;
         fsz_ptr->fnt_id = fnt_id;

         /* FreeType sizes in 1/64th of a point */
         fnt_sd_sz = fnt_size << 6;

         if (fnt_style & FONT_STYLE_NO_SCALE)
         {
            fnt_hd_sz = fnt_sd_sz;
            fnt_sd_sz -= fnt_size << 1; /* bounding box size reduced by 1/32 */
         }
         else
         {
            /* make any scale up for the screen */
            fnt_hd_sz = (fnt_sd_sz * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;
         }

         fsz_ptr->height = fnt_hd_sz;

         fnt_bbox = the_face->bbox;

         if (ftd_ptr->font_ndx == BUILT_IN_FONT)
         {
            if (ftd_ptr->face_type == FTYPE_PFR)
            {
               FT_Fixed metrics_x_scale, metrics_y_scale;

               FT_Get_PFR_Metrics(the_face,
                  &outline_resolution,
                  &ftd_ptr->metric_resolution,
                  &metrics_x_scale,
                  &metrics_y_scale);
            }
            else
            {
               /* For UK profile: use values from Tiresias true-type font version 7.5.1 */
               fnt_bbox.xMin = -324;
               fnt_bbox.xMax = 2048;
               fnt_bbox.yMin = -508;
               fnt_bbox.yMax = 1866;
               ftd_ptr->metric_resolution = 2048;
               outline_resolution = 2048;
            }
         }
         else
         {
            ftd_ptr->metric_resolution = the_face->units_per_EM;
            outline_resolution = the_face->units_per_EM;
         }

         TRACE(TFONT, ("xMin=%d,xMax=%d,yMin=%d,yMax=%d,o_res=%d",
                       fnt_bbox.xMin, fnt_bbox.xMax, fnt_bbox.yMin, fnt_bbox.yMax, outline_resolution))

         units = outline_resolution << 6;

         if (fnt_bbox.yMax > 0)
         {
            bb_sd_t = (U16BIT)(((fnt_bbox.yMax * fnt_sd_sz) + (units - 1)) / units);
            if (fnt_style & FONT_STYLE_NO_SCALE)
            {
               bb_hd_t = bb_sd_t;
            }
            else
            {
               bb_hd_t = (U16BIT)(((fnt_bbox.yMax * fnt_hd_sz) + (units - 1)) / units);
               TRACE(TFONT, ("fnt_hd_sz=%d,units=%d,bb_hd_t=%d", fnt_hd_sz, units, bb_hd_t))
            }
         }
         else
         {
            bb_sd_t = 0;
            bb_hd_t = 0;
         }
         if (fnt_bbox.yMin < 0)
         {
            bb_sd_h = bb_sd_t + (U16BIT)(((-fnt_bbox.yMin * fnt_sd_sz) + (units - 1)) / units);
            if (fnt_style & FONT_STYLE_NO_SCALE)
            {
               bb_hd_h = bb_sd_h;
            }
            else
            {
               bb_hd_h = bb_hd_t + (U16BIT)(((-fnt_bbox.yMin * fnt_hd_sz) + (units - 1)) / units);
               //bb_hd_h = (U16BIT)((((fnt_bbox.yMax-fnt_bbox.yMin) * fnt_hd_sz) + (units - 1)) / units);
               TRACE(TFONT, ("fnt_hd_sz=%d,units=%d,bb_hd_h=%d", fnt_hd_sz, units, bb_hd_h))
            }
         }
         else
         {
            bb_sd_h = bb_sd_t;
            bb_hd_h = bb_hd_t;
         }

         /* For UK profile: even the latest version of tiresias font has same 'xMin' value as version 7.5.1*/
         if (fnt_bbox.xMin < 0)
         {
            /* spxl_xleftoffset should be calculated with ((-xMin*FontSize*parY)/(outlineRes *parX)) and rounded up*/
            s_size = (-fnt_bbox.xMin * fnt_size * 45);
            if (fnt_style & FONT_STYLE_SQUARE)
            {
               fsz_ptr->spxl_xleftoffset = (s_size + units - 1) / units;
            }
            else
            {
               s_size += (outline_resolution * 56) - 1;
               fsz_ptr->spxl_xleftoffset = s_size / (outline_resolution * 56);
            }

            s_size = -fnt_bbox.xMin * fnt_size + outline_resolution - 1;
            fsz_ptr->pnts_xleftoffset = s_size / outline_resolution;

            s_size = ((-fnt_bbox.xMin * fnt_sd_sz) + (units - 1)) / units;
            bb_sd_w = (U16BIT)s_size;
         }
         else
         {
            /* spxl_xleftoffset should be zero when xMin is positive */
            fsz_ptr->spxl_xleftoffset = 0;
            fsz_ptr->pnts_xleftoffset = 0;

            bb_sd_w = 1; /* min of 1 pixel */
         }

         if (fnt_style & FONT_STYLE_SQUARE)
         {
            ratio_x = 1;
            ratio_y = 1;
         }
         else
         {
            /* PLAIN STYLE */
            ratio_x = mg_ctxt.osd_x.mlt * 9;
            ratio_y = mg_ctxt.osd_y.mlt * 14;
            while (((ratio_y & 1) == 0) && ((ratio_x & 1) == 0))
            {
               ratio_y >>= 1;
               ratio_x >>= 1;
            }
            while (((ratio_y % 3) == 0) && ((ratio_x % 3) == 0))
            {
               ratio_y /= 3;
               ratio_x /= 3;
            }
            while (((ratio_y % 5) == 0) && ((ratio_x % 5) == 0))
            {
               ratio_y /= 5;
               ratio_x /= 5;
            }
            units *= ratio_y;
         }
         if (fnt_bbox.xMin < 0)
         {
            if (fnt_style & FONT_STYLE_NO_SCALE)
            {
               s_size = (-fnt_bbox.xMin * fnt_hd_sz * ratio_x) / units;
            }
            else
            {
               s_size = ((-fnt_bbox.xMin * fnt_hd_sz * ratio_x) + (units - 1)) / units;
               /* Test 5.5.8 scene 1, left edge must not overlap line */
               if (mg_hd_mode == NORMAL_HD)
               {
                  if (fnt_size <= 26)
                  {
                     s_size += mg_ctxt.out_osd_width / 720;
                  }
               }
            }
            fsz_ptr->bound_box.left = (U16BIT)s_size;
         }
         else
         {
            fsz_ptr->bound_box.left = 0;
         }
         if (!(fnt_style & FONT_STYLE_NO_SCALE))
         {
            fnt_hd_sz -= (fnt_hd_sz >> 7);
         }
         /* else { fnt_hd_sz -= (fnt_hd_sz >> 6); } */
         fsz_ptr->width = ((fnt_hd_sz * ratio_x) + (ratio_y >> 1)) / ratio_y;
         /* For UK profile: width is not used for profile calc */
         s_size = (fnt_bbox.xMax - fnt_bbox.xMin) * fnt_hd_sz * ratio_x;
         s_size = (s_size + units - 1) / units;
         fsz_ptr->bound_box.width = (U16BIT)s_size;
         TRACE(TFONT, ("%d %d %d %d", fnt_bbox.xMax, fnt_bbox.xMin, fnt_hd_sz, ratio_x))

         TRACE(TFONT, ("HD bbox=(l=%d w=%d t=%d h=%d)", fsz_ptr->bound_box.left, (U16BIT)s_size, bb_hd_t, bb_hd_h))
         fsz_ptr->bb_sd_height = (U8BIT)bb_sd_h;
         fsz_ptr->bb_sd_width = (U8BIT)bb_sd_w;
         fsz_ptr->bb_sd_top = (U8BIT)bb_sd_t;
         fsz_ptr->bound_box.height = bb_hd_h;
         fsz_ptr->bound_box.top = bb_hd_t;

         SetupCaching( ftd_ptr, fsz_ptr );

         TRACE(TFONT, ("font_size=%d CacheSize=%d\n", fnt_size, fsz_ptr->mem_size))

         ftd_ptr->current_fnt_id = fnt_id;
      }
   }
   return fsz_ptr;
}

void MG_CheckCache( S_FontSize *f_szdata )
{
   S_FontDetails *font_ptr;
   if (f_szdata->sbit_cache == 0)
   {
      /* this font size has not got cache data, See if the define cache max will allow it
       */
      if (f_szdata->mem_size < (FONTS_CACHE_MAX - (CHAR_CACHE_SIZE * sizeof(CacheSbit))))
      {
         font_ptr = MG_FindFont( f_szdata );
         if (font_ptr)
         {
            allocateCache( font_ptr, f_szdata );
         }
      }
   }
   else
   {
      f_szdata->cache_hit++;
      mg_total_cache_hits++;
      f_szdata->cache_last = mg_total_cache_hits;
   }
}

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

static void initialiseFontDetails( S_FontDetails *fnt_d_ptr )
{
   FT_Face the_face = fnt_d_ptr->face;
   FT_UInt glyph_index_fig;
   U16BIT nx;

   fnt_d_ptr->first_sz = NULL;

   TRACE(TFONT, (" Font D ptr=%p face=%p", fnt_d_ptr, the_face))

   for (nx = 0; nx != CHAR_CACHE_SIZE; nx++)
   {
      fnt_d_ptr->glyph_ndx[nx] = FT_Get_Char_Index( the_face, nx + FIRST_CACHE_CHAR );
   }
   fnt_d_ptr->glyph_ndx_space = FT_Get_Char_Index( the_face, ' ' );
   glyph_index_fig = FT_Get_Char_Index( the_face, '0' );
   assert( glyph_index_fig != 0 );
   TRACE(TFONT, (" G_fig=%d", glyph_index_fig))


   if (fnt_d_ptr->face_type == FTYPE_PFR)
   {
      FT_Pos advance;

      if (FT_Get_PFR_Advance( the_face, fnt_d_ptr->glyph_ndx_space, &advance ) == 0)
      {
         fnt_d_ptr->space_horiz_adv = advance;
      }
      TRACE(TFONT, (" G_sp_adv=%d", fnt_d_ptr->space_horiz_adv))
      if (FT_Get_PFR_Advance( the_face, glyph_index_fig, &advance ) == 0)
      {
         fnt_d_ptr->fig_horiz_adv = advance;
      }

      for (nx = 0; nx != CHAR_CACHE_SIZE; nx++)
      {
         /* array starts with 'space' char */
         if (fnt_d_ptr->glyph_ndx[nx] &&
             FT_Get_PFR_Advance( the_face, fnt_d_ptr->glyph_ndx[nx], &advance ) == 0)
         {
            /*TRACE(TFONT,("'%c' ha=%ld", nx+FIRST_CACHE_CHAR, advance ))*/
            fnt_d_ptr->horiz_adv[nx] = advance;
         }
      }
   }
   else
   {
      if (FT_Load_Glyph( the_face, fnt_d_ptr->glyph_ndx_space, FT_LOAD_NO_SCALE ) == 0)
      {
         fnt_d_ptr->space_horiz_adv = the_face->glyph->metrics.horiAdvance;
      }
      TRACE(TFONT, (" G_sp_adv=%d", fnt_d_ptr->space_horiz_adv))
      if (FT_Load_Glyph( the_face, glyph_index_fig, FT_LOAD_NO_SCALE ) == 0)
      {
         fnt_d_ptr->fig_horiz_adv = the_face->glyph->metrics.horiAdvance;
      }

      for (nx = 0; nx != CHAR_CACHE_SIZE; nx++)
      {
         /* array starts with 'space' char */
         if (fnt_d_ptr->glyph_ndx[nx] &&
             FT_Load_Glyph( the_face, fnt_d_ptr->glyph_ndx[nx], FT_LOAD_NO_SCALE ) == 0)
         {
            /*TRACE(TFONT,("'%c' w=%ld,ha=%ld", nx+FIRST_CACHE_CHAR,
                                              the_face->glyph->metrics.width,
                                              the_face->glyph->metrics.horiAdvance ))*/
            fnt_d_ptr->horiz_adv[nx] = the_face->glyph->metrics.horiAdvance;
         }
         else
         {
            fnt_d_ptr->horiz_adv[nx] = 0;
         }
      }
   }
}

static void freeCache( S_FontSize *fsz_ptr )
{
   assert( fsz_ptr );
   if (fsz_ptr->sbit_cache)
   {
      FT2_MemFree( fsz_ptr->sbit_cache );
      fsz_ptr->sbit_cache = NULL;
      mg_cached_fontsizes--;
      mg_cache_in_use -= fsz_ptr->mem_size + (CHAR_CACHE_SIZE * sizeof(CacheSbit));
   }
}

static void allocateCache( S_FontDetails *fd_ptr, S_FontSize *sz_data )
{
   FT_Face the_face = fd_ptr->face;
   FT_GlyphSlot the_glyph = the_face->glyph;
   CacheSbit *p_cache;
   U8BIT *bitmaps, *src;
   S_FontSize *pfs;
   U32BIT req_size, lowest_hit, bmp_nx;
   U16BIT chr, x, y = 0;

   assert( sz_data->sbit_cache == 0 );

   req_size = (CHAR_CACHE_SIZE * sizeof(CacheSbit)) + /* cache description space */
      sz_data->mem_size;                       /* plus bitmap space */

   assert( req_size < FONTS_CACHE_MAX );
   lowest_hit = mg_total_cache_hits + 1;
   while ((mg_cache_in_use + req_size) > FONTS_CACHE_MAX)
   {
      /* need to purge cache of less recently used character size */
      assert( mg_font_array[y] );
      pfs = mg_font_array[y]->first_sz;
      while (pfs != NULL)
      {
         if (pfs->sbit_cache != NULL)
         {
            if (mg_cached_fontsizes == 1)
            {
               freeCache( pfs );
               assert( mg_cached_fontsizes == 0);
               assert( mg_cache_in_use == 0 );
               break;
            }
            else
            {
               if (pfs->cache_last != mg_total_cache_hits)
               {
                  /* not the last used font size */
                  if ((mg_cached_fontsizes == 2) || (lowest_hit == pfs->cache_hit))
                  {
                     /* Either only 2 in cache, or assume this is second time
                      * around outer loop and this one really is the lowest hit */
                     freeCache( pfs );
                     lowest_hit = mg_total_cache_hits + 1;
                     break;
                  }
                  else if (lowest_hit > pfs->cache_hit)
                  {
                     lowest_hit = pfs->cache_hit;
                  }
               }
            }
         }
         pfs = pfs->next;
      }
      y++;
      if (y == MAX_FONT_OBJECTS || mg_font_array[y] == NULL)
      {
         y = 0;
      }
   }

   TRACE(TFONT, ("FT_Set_Char_Size face=%p sz=%d w=%d h=%d", the_face, sz_data->fnt_id & 0xff, sz_data->width, sz_data->height))
   if (FT_Set_Char_Size( the_face, sz_data->width, sz_data->height, 72, 72 ) == 0)
   {
      fd_ptr->current_fnt_id = sz_data->fnt_id;
      p_cache = (CacheSbit *)FT2_MemAlloc( req_size );
      if (p_cache)
      {
         mg_cache_in_use += req_size;
         mg_cached_fontsizes++;

         sz_data->sbit_cache = p_cache; /* save the malloced data */
         bitmaps = (U8BIT *)p_cache;
         bitmaps += (CHAR_CACHE_SIZE * sizeof(CacheSbit));  /* bitmaps points to the data area */
         req_size -= (CHAR_CACHE_SIZE * sizeof(CacheSbit)); /* for debugging */

         /* now fill in the data */
         for (bmp_nx = 0, chr = 0; chr != CHAR_CACHE_SIZE; chr++, p_cache++)
         {
            p_cache->bmp_ndx = bmp_nx; /* store start index for this glyph's bitmap */

            if (fd_ptr->glyph_ndx[chr] &&
                FT_Load_Glyph( the_face, fd_ptr->glyph_ndx[chr], FT_LOAD_RENDER ) == 0)
            {
               U32BIT adv;
               U8BIT bwidth = (U8BIT)the_glyph->bitmap.width;
               U8BIT bheight = (U8BIT)the_glyph->bitmap.rows;
               int ptch = the_glyph->bitmap.pitch;
               if (ptch < 0)
                  ptch = -ptch;

               assert( ptch == bwidth );
            #ifdef TRACING
               if (bwidth > sz_data->bound_box.width)
               {
                  TRACE(TERROR, ("bwidth %d > sz_data->bound_box.width %d", bwidth, sz_data->bound_box.width))
               }
            #endif
               if (bmp_nx + (bheight * bwidth) > req_size)
               {
                  /* Should never get here!   Could only happen if Freetype is not behaving itself */
                  TRACE(TERROR, ("!!! Cache size is not big enough !!! (%d,%d,%d,%d)", bmp_nx, bheight, bwidth, req_size))
                  break;
               }

               /* Store bitmap dimensions */
               p_cache->top = the_glyph->bitmap_top;
               p_cache->left = the_glyph->bitmap_left;
               p_cache->width = bwidth;
               p_cache->height = bheight;
               /* calculate advance */
               adv = the_glyph->linearHoriAdvance + 0x8000;
               if (the_glyph->metrics.horiBearingX < 0)
               {
                  S32BIT tmp = -the_glyph->metrics.horiBearingX;
                  if (((sz_data->fnt_id >> 8) & 0xff) == FONT_STYLE_SQUARE)
                  {
                     tmp = tmp * (sz_data->fnt_id & 0xff) * 45 + (2048 * 64) - 1;
                     p_cache->sdleft = tmp >> 17;
                  }
                  else
                  {
                     tmp = tmp * (sz_data->fnt_id & 0xff) * 45 + (2048 * 56) - 1;
                     p_cache->sdleft = tmp / (2048 * 56);
                  }
               }
               else
               {
                  p_cache->sdleft = 0;
               }
               p_cache->advance = (S8BIT)(adv >> 16);

               /* Some minor adjustments - for Tiresias font */
               src = the_glyph->bitmap.buffer;
               if (p_cache->width > p_cache->advance)
               {
                  /* Do nothing */
                  TRACE(TFONTCACHE, ("fsz=%d,fw=%d '%c' %d l=%d,w=%d,a=%d lha_mod=%x",
                                     sz_data->fnt_id, sz_data->width, chr + FIRST_CACHE_CHAR, chr,
                                     p_cache->left, p_cache->width, p_cache->advance, adv & 0xffff))
               }
               else if (p_cache->width + (p_cache->left * 2) < p_cache->advance)
               {
                  if (mg_hd_mode == NORMAL_SD)
                  {
                     switch (chr)
                     {
                        case ('m' - FIRST_CACHE_CHAR):
                           p_cache->advance--;
                           break;
                        default:;
                     }
                  }
               }
               else
               {
                  while (p_cache->width + p_cache->left > p_cache->advance)
                  {
                     TRACE(TFONTCACHE, ("fsz=%d,fw=%d '%c' %d l=%d,w=%d,a=%d lha_mod=%x",
                                        sz_data->fnt_id, sz_data->width, chr + FIRST_CACHE_CHAR, chr,
                                        p_cache->left, p_cache->width, p_cache->advance, adv & 0xffff))
                     if (p_cache->left && (adv & 0xffff) < 0xc000)
                     {
                        p_cache->left--;
                     }
                     else
                     {
                        p_cache->advance++;
                     }
                  }
                  if (chr == 1 && mg_hd_mode == NORMAL_SD && (sz_data->fnt_id & 0xff) == 31)
                  {
                     /* Double quote (") on SD size 31, fudges together.
                      * So reduce the brightness of the bit between each dash */
                     for (x = 0; x != (bheight * bwidth); x++)
                     {
                        if (src[x] < 0xA0)
                        {
                           src[x] >>= 2;
                        }
                     }
                  }
               }

               /* Copy bitmap data for this glyph into cache buffer */
               for (y = 0; y != bheight; y++)
               {
                  for (x = 0; x != bwidth; x++)
                  {
                     bitmaps[bmp_nx++] = src[x];
                  }
                  src += ptch;
               }
               TRACE(TFONTCACHE, ("FT_Alloc %d (%d,%d) sz=%ld", fd_ptr->glyph_ndx[chr], the_face->glyph->bitmap.width, the_face->glyph->bitmap.rows, bmp_nx))
            }
            else
            {
               /* Error */
               p_cache->width = 0;
               p_cache->top = 0;
               p_cache->left = 0;
               p_cache->height = 0;
               p_cache->advance = 0;
            }
         }

         /* This is a bit of a cheat for getting through the DTG test "5.10B Monospace chars", but
          * it is not too unreasonable. And it's only way to avoid mucking up the rendering elsewhere.
          */
         p_cache = sz_data->sbit_cache + ('0' - FIRST_CACHE_CHAR);
         for (chr = 0; chr != 10; chr++, p_cache++)
         {
            p_cache->advance = sz_data->figure_adv;
         }

         sz_data->cache_hit++;
         mg_total_cache_hits++;
         sz_data->cache_last = mg_total_cache_hits;
      }
   }
}

static void FreeFontFile( S16BIT font_index )
{
   S_FontDetails *font_ptr;
   S_FontSize *fsz, *psz;
   TRACE(TFONT, (" ndx=%d", font_index))
   while (mg_font_array[font_index] != NULL)
   {
      font_ptr = mg_font_array[font_index];
      mg_font_array[font_index] = font_ptr->next;
      if (font_ptr->face)
      {
         FT_Done_Face( font_ptr->face );
      }
      fsz = font_ptr->first_sz;
      while (fsz != NULL)
      {
         freeCache( fsz );
         psz = fsz;
         fsz = fsz->next;
         FT2_MemFree( psz );
      }
      FT2_MemFree( font_ptr );
   }
}