mg_osd.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 "mh5profile.h"
#include "stb_osd.h"
#include "dvb_video.h"
#include "decoder.h"
#include "osd_utils.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "mg_api.h"
#include "mg_osd.h"

#include "mg_fontapi.h"

#ifndef OSD_32_BIT
 #ifndef OSD_31_BIT
  #ifndef OSD_16_BIT
   #ifndef OSD_8_BIT
/* oops - we should be supporting something! */
    #error "Should define at least one of OSD_8_BIT, OSD_16_BIT, OSD_31_BIT or OSD_32_BIT!"
   #endif
  #endif
 #endif
#endif

/*---constant definitions for this file--------------------------------------*/
#define MAGIC_SURF         0x5e4f

#define DESKTOP_COLOUR        0xff000000
#define TOTAL_TRANSPARENCY    0x00000000

/*
 * SD_BlendColour( U8BIT pixel, U8BIT colour, ColourBlend last )
 */
#define SD_BlendColour( pxl, clr, prv, swtch )

#define C2L_ALPHA_CHNNL    0xf000

#define C4L_ALPHA_CHNNL    0xff000000

#ifdef OSD_8_BIT
/* Offsets into the MHEG palette */
#define OFFSET_SEMI             (PALETTE_OFFSET + 1)
#define OFFSET_GREY             (PALETTE_OFFSET + 49)
#define OFFSET_BLACK            (PALETTE_OFFSET + 53)
#define OFFSET_WHITE            (PALETTE_OFFSET + 187)
#define DESKTOP_COLOUR_INDEX    OFFSET_BLACK
/* Number of colours in the D-Book palette */
#define NUM_SUBT_COLOURS         64
#define NUM_MHEG_COLOURS         188
#define NUM_MANU_COLOURS         4

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

typedef struct _NearCol
{
   const U8BIT red[8];
   const U8BIT green[16];
   const U8BIT blue[4];
} NearCol;

/*---global variable declarations for this file----------------------*/

/* MHEG palette
 * For OSDColour, the transparency is reversed from the UK profile spec.
 * (i.e. opaque in UK prof is 0x00, but for OSDColor, it is 0xff ) */
OSDColor dbook_colour_palette[NUM_SUBT_COLOURS + NUM_MHEG_COLOURS + NUM_MANU_COLOURS] =
{
   /* Subtitle colours */
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
   0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,

   /* Fully transparent (index: 0) */
   0x00000000,

   /* Semi-transparent (index: 1-48) */
   0xb3000000, 0xb30000ff, 0xb3550000, 0xb35500ff, 0xb3aa0000, 0xb3aa00ff, 0xb3ff0000, 0xb3ff00ff,
   0xb3003300, 0xb30033ff, 0xb3553300, 0xb35533ff, 0xb3aa3300, 0xb3aa33ff, 0xb3ff3300, 0xb3ff33ff,
   0xb3006600, 0xb30066ff, 0xb3556600, 0xb35566ff, 0xb3aa6600, 0xb3aa66ff, 0xb3ff6600, 0xb3ff66ff,
   0xb3009900, 0xb30099ff, 0xb3559900, 0xb35599ff, 0xb3aa9900, 0xb3aa99ff, 0xb3ff9900, 0xb3ff99ff,
   0xb300cc00, 0xb300ccff, 0xb355cc00, 0xb355ccff, 0xb3aacc00, 0xb3aaccff, 0xb3ffcc00, 0xb3ffccff,
   0xb300ff00, 0xb300ffff, 0xb355ff00, 0xb355ffff, 0xb3aaff00, 0xb3aaffff, 0xb3ffff00, 0xb3ffffff,

   /* Opaque greys (index: 49-52) */
   0xff2a2a2a, 0xff555555, 0xffaaaaaa, 0xffd4d4d4,

   /* Opaque (index: 53-187) */
   0xff000000, 0xff00007f, 0xff0000ff, 0xff001f00, 0xff001f7f, 0xff001fff, 0xff003f00, 0xff003f7f,
   0xff003fff, 0xff005f00, 0xff005f7f, 0xff005fff, 0xff007f00, 0xff007f7f, 0xff007fff, 0xff009f00,
   0xff009f7f, 0xff009fff, 0xff00bf00, 0xff00bf7f, 0xff00bfff, 0xff00df00, 0xff00df7f, 0xff00dfff,
   0xff00ff00, 0xff00ff7f, 0xff00ffff, 0xff3f0000, 0xff3f007f, 0xff3f00ff, 0xff3f1f00, 0xff3f1f7f,
   0xff3f1fff, 0xff3f3f00, 0xff3f3f7f, 0xff3f3fff, 0xff3f5f00, 0xff3f5f7f, 0xff3f5fff, 0xff3f7f00,
   0xff3f7f7f, 0xff3f7fff, 0xff3f9f00, 0xff3f9f7f, 0xff3f9fff, 0xff3fbf00, 0xff3fbf7f, 0xff3fbfff,
   0xff3fdf00, 0xff3fdf7f, 0xff3fdfff, 0xff3fff00, 0xff3fff7f, 0xff3fffff, 0xff7f0000, 0xff7f007f,
   0xff7f00ff, 0xff7f1f00, 0xff7f1f7f, 0xff7f1fff, 0xff7f3f00, 0xff7f3f7f, 0xff7f3fff, 0xff7f5f00,
   0xff7f5f7f, 0xff7f5fff, 0xff7f7f00, 0xff7f7f7f, 0xff7f7fff, 0xff7f9f00, 0xff7f9f7f, 0xff7f9fff,
   0xff7fbf00, 0xff7fbf7f, 0xff7fbfff, 0xff7fdf00, 0xff7fdf7f, 0xff7fdfff, 0xff7fff00, 0xff7fff7f,
   0xff7fffff, 0xffbf0000, 0xffbf007f, 0xffbf00ff, 0xffbf1f00, 0xffbf1f7f, 0xffbf1fff, 0xffbf3f00,
   0xffbf3f7f, 0xffbf3fff, 0xffbf5f00, 0xffbf5f7f, 0xffbf5fff, 0xffbf7f00, 0xffbf7f7f, 0xffbf7fff,
   0xffbf9f00, 0xffbf9f7f, 0xffbf9fff, 0xffbfbf00, 0xffbfbf7f, 0xffbfbfff, 0xffbfdf00, 0xffbfdf7f,
   0xffbfdfff, 0xffbfff00, 0xffbfff7f, 0xffbfffff, 0xffff0000, 0xffff007f, 0xffff00ff, 0xffff1f00,
   0xffff1f7f, 0xffff1fff, 0xffff3f00, 0xffff3f7f, 0xffff3fff, 0xffff5f00, 0xffff5f7f, 0xffff5fff,
   0xffff7f00, 0xffff7f7f, 0xffff7fff, 0xffff9f00, 0xffff9f7f, 0xffff9fff, 0xffffbf00, 0xffffbf7f,
   0xffffbfff, 0xffffdf00, 0xffffdf7f, 0xffffdfff, 0xffffff00, 0xffffff7f, 0xffffffff,

   /* Manufacturer colours */
   0x00000000, 0x00000000, 0x00000000, 0x00000000
};

OSDColor *mg_palette = NULL;
static S_REGION osd_update_rgn;

#endif /* OSD_8_BIT */

S_MGContext mg_ctxt = {
   0, 0,  /* output screen coordinate system */
   0, 0,  /* output OSD coordinate system */
   0, 0,  /* input coordinate system (e.g. mheg scene) */
   { 1, 1 },  /* OSD horizontal scaling factor  */
   { 1, 1 },  /* OSD vertical scaling factor    */
   { 1, 1 },  /* Video horizontal scaling factor */
   { 1, 1 },  /* Video vertical scaling factor   */
   { 1, 1 },  /* Line width scaling factor */
   NULL,   /* screen surface handle */
   NULL,   /* screen buffer */
   0,      /* screen stride */
   0,      /* offset_left */
   COLOUR_FORMAT_PALETTE,              /* colour depth */
  #if defined(OSD_31_BIT) && defined(OSD_32_BIT)
   0xff,
  #endif
};

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

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

static U16BIT OSD_GCD( U16BIT a, U16BIT b );

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

BOOLEAN MG_IsHdSupported(void)
{
   if (mg_ctxt.colour_format >= 16 &&
       mg_ctxt.out_osd_width >= 1280 &&
       mg_ctxt.out_osd_height >= 720)
   {
      return TRUE;
   }
   return FALSE;
}

void MG_OSDInit( U16BIT inWidth, U16BIT inHeight,
   U16BIT outWidth, U16BIT outHeight )
{
   BOOLEAN out_changed, inp_changed;
   U16BIT gcd;

   FUNCTION_START(x)
   inp_changed = (mg_ctxt.input_width != inWidth ||
                  mg_ctxt.input_height != inHeight) ? TRUE : FALSE;
   out_changed = (mg_ctxt.out_osd_width != outWidth ||
                  mg_ctxt.out_osd_height != outHeight) ? TRUE : FALSE;

   if (out_changed || inp_changed)
   {
      TRACE(TSTATE, ("in=(%d,%d) out=(%d,%d)", inWidth, inHeight, outWidth, outHeight))

      mg_ctxt.input_width = inWidth;
      mg_ctxt.input_height = inHeight;
      mg_ctxt.out_osd_width = outWidth;
      mg_ctxt.out_osd_height = outHeight;

      //gcd = OSD_GCD(inWidth,outWidth);
      gcd = OSD_GCD( OSD_GCD(inWidth, outWidth), OSD_GCD(inHeight, outHeight));
      mg_ctxt.osd_x.mlt = outWidth / gcd;
      mg_ctxt.osd_x.div = inWidth / gcd;
      //gcd = OSD_GCD(inHeight,outHeight);
      mg_ctxt.osd_y.mlt = outHeight / gcd;
      mg_ctxt.osd_y.div = inHeight / gcd;

      gcd = OSD_GCD(inWidth, mg_ctxt.out_video_width);
      mg_ctxt.vid_x.mlt = mg_ctxt.out_video_width / gcd;
      mg_ctxt.vid_x.div = inWidth / gcd;

      gcd = OSD_GCD(inHeight, mg_ctxt.out_video_height);
      mg_ctxt.vid_y.mlt = mg_ctxt.out_video_height / gcd;
      mg_ctxt.vid_y.div = inHeight / gcd;

      /* mean factor is used for line width:
       *   mean = (sx/nx + sy/ny) / 2 = (sx*ny + sy * nx) / (2 * nx * ny)
       */
      mg_ctxt.line_w.mlt = ((mg_ctxt.osd_x.mlt * mg_ctxt.osd_y.div +
                             mg_ctxt.osd_y.mlt * mg_ctxt.osd_x.div));
      mg_ctxt.line_w.div = (2 * mg_ctxt.osd_x.div * mg_ctxt.osd_y.div);

      gcd = OSD_GCD(mg_ctxt.line_w.mlt, mg_ctxt.line_w.div);
      mg_ctxt.line_w.mlt /= gcd;
      mg_ctxt.line_w.div /= gcd;

      if (!MG_FontInit( MG_IsHdSupported()))
      {
         TRACE(TERROR, ("MG_FontInit Failed!\n"))
      }
   }
   if (out_changed)
   {
      TRACE(TGRAPHICS, ("About to Initialise OSD"))
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
      #ifdef OSD_8_BIT
         STB_OSDSetMhegPalette( 0, NUM_MHEG_COLOURS + PALETTE_OFFSET, (U32BIT *)mg_palette );
      #endif /*OSD_8_BIT*/
      }
      mg_ctxt.hw_handle = STB_OSDMhegSetResolution(outWidth, outHeight, mg_ctxt.colour_format);
      DVB_MhegSetScalingResolution(outWidth, outHeight);
   }
   FUNCTION_FINISH(x)
}

void MG_OSDMhegInit( U16BIT inWidth, U16BIT inHeight, E_ASPECT_RATIO sar )
{
   FUNCTION_START(x)
#ifdef NO_SCALE_ASPECT
   USE_UNWANTED_PARAM(sar);
#else
   if (sar == ASPECT_RATIO_4_3 && DVB_MhegGetDisplayAspectRatio() == ASPECT_RATIO_16_9)
   {
      if (!mg_ctxt.offset_left)
      {
         MG_OSDclear();
      }
      mg_ctxt.offset_left = mg_ctxt.out_osd_width >> 3;
   }
   else
   {
      if (mg_ctxt.offset_left)
      {
         MG_OSDclear();
      }
      mg_ctxt.offset_left = 0;
   }
#endif /*NO_SCALE_ASPECT*/
   MG_OSDInit( inWidth, inHeight, mg_ctxt.out_osd_width, mg_ctxt.out_osd_height );
   FUNCTION_FINISH(x)
}

E_MhegErr MG_Initialise( U16BIT screenWidth, U16BIT screenHeight, U8BIT colourDepth )
{
   E_MhegErr result;
   FUNCTION_START(x)
   TRACE(TSTATE, ("(screen= %d x %d, %d bit)", screenWidth, screenHeight, colourDepth))
   if (colourDepth == 0)
   {
      /* Resolution change, just get the current value */
      colourDepth = mg_ctxt.colour_format;
   }
   else
   {
      mg_ctxt.colour_format = colourDepth;
   }
   if (screenWidth < 720 || screenHeight < 576
      #ifndef OSD_8_BIT
       || (colourDepth == COLOUR_FORMAT_PALETTE)
      #endif
      #ifndef OSD_16_BIT
       || (colourDepth == COLOUR_FORMAT_ARGB4444)
      #endif
      #ifndef OSD_31_BIT
       || (colourDepth == COLOUR_FORMAT_ARGB7888)
      #endif
      #ifndef OSD_32_BIT
       || (colourDepth == COLOUR_FORMAT_ARGB8888)
      #endif
       )
   {
      DPL1(("- Invalid Graphic Capabilities\n"));
      result = MHERR_BAD_PARAMETER;
      TRACE(TSTATE,("result=%d",result))
   }
   else
   {
      result = MHERR_OK;

     #if defined(OSD_31_BIT) && defined(OSD_32_BIT)
      // ST platform
      mg_ctxt.max_alpha = (mg_ctxt.colour_format == COLOUR_FORMAT_ARGB7888) ? 128 : 255;
     #endif

      mg_ctxt.out_video_width = screenWidth;
      mg_ctxt.out_video_height = screenHeight;

      TRACE(TSTATE,("result=%d",result))

     #ifdef OSD_8_BIT
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         TRACE(TSTATE,("result=%d",result))
         mg_palette = &dbook_colour_palette[NUM_SUBT_COLOURS - PALETTE_OFFSET];
         if (mg_ctxt.hw_handle == NULL)
         {
            mg_ctxt.hw_handle = STB_OSDMhegCreateSurface( screenWidth, screenHeight, TRUE, 0 );
            if (mg_ctxt.hw_handle == NULL)
            {
               result = MHERR_OTHER;
            }
         }
         mg_ctxt.screen_stride = screenWidth;
         if (mg_ctxt.screen_buff == NULL)
         {
            mg_ctxt.screen_buff = STB_OSDMhegLockBuffer( mg_ctxt.hw_handle, &mg_ctxt.screen_stride );
         }
         TRACE(TGRAPHICS, ("hdl=0x%x, buff=0x%x, stride=%d cft=%d", mg_ctxt.hw_handle,
                           mg_ctxt.screen_buff, mg_ctxt.screen_stride, mg_ctxt.colour_format))
      }
     #endif /*OSD_8_BIT*/

      MG_OSDInit( SD_WIDTH, SD_HEIGHT, screenWidth, screenHeight );
   }
   TRACE(TSTATE,("result=%d",result))
   FUNCTION_FINISH(x)
   return result;
}

void MG_Terminate(void)
{
   FUNCTION_START(OSDExit)

   #ifdef OSD_8_BIT
   if (mg_ctxt.screen_buff != NULL)
   {
      STB_OSDMhegUnlockBuffer( mg_ctxt.hw_handle );
      STB_OSDMhegDestroySurface( mg_ctxt.hw_handle );
      mg_ctxt.screen_buff = NULL;
   }
   #endif

   MG_FontExit();

   mg_ctxt.out_osd_width = 0;

   FUNCTION_FINISH(OSDExit)
}

#ifdef OSD_8_BIT

static void DrawRectangle8Bit( S_REGION rgn, U8BIT colour_index, BOOLEAN overwrite )
{
   U16BIT x, y, w;
   U8BIT *buffer;

   assert( colour_index < NUM_MHEG_COLOURS );

   w = rgn.right - rgn.left;
   buffer = mg_ctxt.screen_buff;
   buffer += (rgn.top * mg_ctxt.screen_stride) + rgn.left;

   TRACE(TGRAPHICS, ("rgn=%d,%d,%d,%d col=0x%x ow=%d", rgn.left, rgn.top, rgn.right, rgn.bottom, colour_index, overwrite))
   /*TRACE(TGRAPHICS,("b=0x%x",buffer))*/
   if (overwrite)
   {
      for (y = rgn.top; y != rgn.bottom; y++)
      {
         memset(buffer, colour_index, w );
         buffer += mg_ctxt.screen_stride;
      }
   }
   else
   {
      w = mg_ctxt.screen_stride - w;
      for (y = rgn.top; y != rgn.bottom; y++)
      {
         for (x = rgn.left; x != rgn.right; x++)
         {
            OSD_BlendPixels(buffer, colour_index);
            ++buffer;
         }
         buffer += w;
      }
   }
   /* Update region size */
   if (rgn.left < osd_update_rgn.left)
   {
      osd_update_rgn.left = rgn.left;
   }
   if (rgn.top < osd_update_rgn.top)
   {
      osd_update_rgn.top = rgn.top;
   }
   if (rgn.right > osd_update_rgn.right)
   {
      osd_update_rgn.right = rgn.right;
   }
   if (rgn.bottom > osd_update_rgn.bottom)
   {
      osd_update_rgn.bottom = rgn.bottom;
   }
}

#endif /* OSD_8_BIT */


static void DrawClippedRectangle( S_REGION *overlap, S_REGION rgn, OSDColor fore_col )
{
   if (rgn.left < overlap->left)
   {
      rgn.left = overlap->left;
   }
   if (rgn.right > overlap->right)
   {
      rgn.right = overlap->right;
   }
   if (rgn.top < overlap->top)
   {
      rgn.top = overlap->top;
   }
   if (rgn.bottom > overlap->bottom)
   {
      rgn.bottom = overlap->bottom;
   }
   if ((rgn.bottom > rgn.top) && (rgn.right > rgn.left))
   {
      TRACE(TGRAPHICS, ("region (%d,%d,%d,%d)", rgn.left, rgn.top, rgn.right, rgn.bottom))
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         if (fore_col != OFFSET_TRANS)
         {
            /*TRACE(TGRAPHICS,("col=0x%x",fore_col))*/
            DrawRectangle8Bit( rgn, (U8BIT)fore_col, (fore_col >= OFFSET_OPAQUE));
         }
         #endif
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         if ((fore_col & C2L_ALPHA_CHNNL) != 0)
         {
            S_RECTANGLE rect;
            rect.left = rgn.left;
            rect.width = rgn.right - rgn.left;
            rect.top = rgn.top;
            rect.height = rgn.bottom - rgn.top;
            #ifndef NO_SCALE_ASPECT
            if (mg_ctxt.offset_left)
            {
               rect.left *= 3;
               rect.left >>= 2;
               rect.left += mg_ctxt.offset_left;
               rect.width *= 3;
               rect.width >>= 2;
            }
            #endif /*NO_SCALE_ASPECT*/
            //TRACE(TGRAPHICS,("actual (%d,%d,%d,%d)",rect.left, rect.top, rect.left+rect.width, rect.top+rect.height));
            STB_OSDMhegFillRectangle( &rect, fore_col, ((fore_col & C2L_ALPHA_CHNNL) == C2L_ALPHA_CHNNL) ?
               STB_BLIT_COPY : STB_BLIT_A_BLEND );
         }
         #endif
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         if ((fore_col & C4L_ALPHA_CHNNL) != 0)
         {
            S_RECTANGLE rect;
            OSDColor col;
            ConvertAlpha(fore_col, col);
            rect.left = rgn.left;
            rect.width = rgn.right - rgn.left;
            rect.top = rgn.top;
            rect.height = rgn.bottom - rgn.top;
            #ifndef NO_SCALE_ASPECT
            if (mg_ctxt.offset_left)
            {
               rect.left *= 3;
               rect.left >>= 2;
               rect.left += mg_ctxt.offset_left;
               rect.width *= 3;
               rect.width >>= 2;
            }
            #endif /*NO_SCALE_ASPECT*/
            //TRACE(TGRAPHICS,("actual (%d,%d,%d,%d)",rect.left, rect.top, rect.left+rect.width, rect.top+rect.height))
            STB_OSDMhegFillRectangle( &rect, col, ((col >> 24) == MAX_ALPHA) ?
               STB_BLIT_COPY : STB_BLIT_A_BLEND );
         }
         #endif
      }
   }
}

void MG_OSDdisplayRectangle( S_REGION *overlap, int x, int y, int width, int height,
   int line_width, /*int lineStyle,*/ OSDColor lineColour, OSDColor fillColour )
{
   OSDColor tmp_col;
   S_REGION scaled_overlap;
   TRACE(TGRAPHICS, ("x=%d,y=%d,w=%d,h=%d", x, y, width, height));
   if (width > 0 && height > 0)
   {
      S_REGION rgn, outline_region, inner_region;
      rgn.left = x;
      rgn.top = y;
      rgn.right = x + width;
      rgn.bottom = y + height;
      scaled_overlap = *overlap;
      TRACE(TGRAPHICS, ("line_width=%d line_col=%x fill_col=%x", line_width, lineColour, fillColour));

      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         tmp_col = (OSDColor)OSD_FindNearestColourIndex(lineColour);
         #endif
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         tmp_col = MakeHD2Color( lineColour );
         rgn.left = HD_X_SCALEUP(rgn.left);
         rgn.top = HD_Y_SCALEUP(rgn.top);
         rgn.right = HD_X_SCALEUP(rgn.right);
         rgn.bottom = HD_Y_SCALEUP(rgn.bottom);
         scaled_overlap.left = HD_X_SCALEUP(overlap->left);
         scaled_overlap.top = HD_Y_SCALEUP(overlap->top);
         scaled_overlap.right = HD_X_SCALEUP(overlap->right);
         scaled_overlap.bottom = HD_Y_SCALEUP(overlap->bottom);
         line_width = HD_W_SCALEUP(line_width);
         #endif
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         tmp_col = lineColour;
         rgn.left = HD_X_SCALEUP(rgn.left);
         rgn.top = HD_Y_SCALEUP(rgn.top);
         rgn.right = HD_X_SCALEUP(rgn.right);
         rgn.bottom = HD_Y_SCALEUP(rgn.bottom);
         scaled_overlap.left = HD_X_SCALEUP(overlap->left);
         scaled_overlap.top = HD_Y_SCALEUP(overlap->top);
         scaled_overlap.right = HD_X_SCALEUP(overlap->right);
         scaled_overlap.bottom = HD_Y_SCALEUP(overlap->bottom);
         line_width = HD_W_SCALEUP(line_width);
         #endif
      }

      assert( rgn.right >= rgn.left );
      assert( rgn.bottom >= rgn.top );

      if (line_width > (rgn.right - rgn.left))
      {
         line_width = rgn.right - rgn.left;
      }
      if (line_width > (rgn.bottom - rgn.top))
      {
         line_width = rgn.bottom - rgn.top;
      }

      if (line_width > 0)
      {
         TRACE(TGRAPHICS, ("l_col=%x", tmp_col));

         /* Check if we can combine all into a single rectangle (without any "inner" area) */
         if ((rgn.top + line_width >= rgn.bottom - line_width) ||
             (rgn.left + line_width >= rgn.right - line_width))
         {
            /* Combine into a single rectangle */
            outline_region.left = rgn.left;
            outline_region.top = rgn.top;
            outline_region.right = rgn.right;
            outline_region.bottom = rgn.bottom;

            DrawClippedRectangle( &scaled_overlap, outline_region, tmp_col );
         }
         else
         {
            /* Top */
            outline_region.left = rgn.left;
            outline_region.top = rgn.top;
            outline_region.bottom = rgn.top + line_width;
            outline_region.right = rgn.right;

            DrawClippedRectangle( &scaled_overlap, outline_region, tmp_col );

            /* Bottom */
            outline_region.left = rgn.left;
            outline_region.top = rgn.bottom - line_width;
            outline_region.bottom = rgn.bottom;
            outline_region.right = rgn.right;

            DrawClippedRectangle( &scaled_overlap, outline_region, tmp_col );

            /* Left */
            outline_region.left = rgn.left;
            outline_region.top = rgn.top + line_width;
            outline_region.bottom = rgn.bottom - line_width;
            outline_region.right = rgn.left + line_width;

            DrawClippedRectangle( &scaled_overlap, outline_region, tmp_col );

            /* Right */
            outline_region.left = rgn.right - line_width;
            outline_region.top = rgn.top + line_width;
            outline_region.bottom = rgn.bottom - line_width;
            outline_region.right = rgn.right;

            DrawClippedRectangle( &scaled_overlap, outline_region, tmp_col );
         }
      }
      if (width > line_width && height > line_width)
      {
         IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
         {
            #ifdef OSD_8_BIT
            tmp_col = (OSDColor)OSD_FindNearestColourIndex(fillColour);
            #endif
         }
         ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
         {
            #ifdef OSD_16_BIT
            tmp_col = MakeHD2Color( fillColour );
            #endif
         }

         ELSE
         {
            #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
            tmp_col = fillColour;
            #endif
         }
         TRACE(TGRAPHICS, ("f_col=%x", tmp_col))

         inner_region.left = rgn.left + line_width;
         inner_region.top = rgn.top + line_width;
         inner_region.right = rgn.right - line_width;
         inner_region.bottom = rgn.bottom - line_width;

         DrawClippedRectangle( &scaled_overlap, inner_region, tmp_col );
      }
   }
}

void MG_OSDdisplayVideo( S_REGION rgn )
{
   FUNCTION_START(OSDDisplayVideo)

   TRACE(TGRAPHICS, ("OSDdisplayVideo( %d,%d,%d,%d )\n", rgn.top, rgn.left, rgn.right, rgn.bottom))

   /* 'punch' hole through OSD for viewing video behind */
   if ((rgn.bottom > rgn.top) && (rgn.right > rgn.left))
   {
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         DrawRectangle8Bit( rgn, 0, TRUE );
         #endif
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         S_RECTANGLE rect;
         rgn.top = HD_Y_SCALEUP(rgn.top);
         rgn.bottom = HD_Y_SCALEUP(rgn.bottom);
         rgn.left = HD_X_SCALEUP(rgn.left);
         rgn.right = HD_X_SCALEUP(rgn.right);
         rect.left = rgn.left;
         rect.top = rgn.top;
         rect.width = rgn.right - rgn.left;
         rect.height = rgn.bottom - rgn.top;
         #ifndef NO_SCALE_ASPECT
         if (mg_ctxt.offset_left)
         {
            rect.left *= 3;
            rect.left >>= 2;
            rect.left += mg_ctxt.offset_left;
            rect.width *= 3;
            rect.width >>= 2;
         }
         #endif /*NO_SCALE_ASPECT*/
         STB_OSDMhegFillRectangle( &rect, MakeHD2Color(TOTAL_TRANSPARENCY), STB_BLIT_COPY );
         #endif
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         S_RECTANGLE rect;
         rgn.top = HD_Y_SCALEUP(rgn.top);
         rgn.bottom = HD_Y_SCALEUP(rgn.bottom);
         rgn.left = HD_X_SCALEUP(rgn.left);
         rgn.right = HD_X_SCALEUP(rgn.right);
         rect.left = rgn.left;
         rect.top = rgn.top;
         rect.width = rgn.right - rgn.left;
         rect.height = rgn.bottom - rgn.top;
         #ifndef NO_SCALE_ASPECT
         if (mg_ctxt.offset_left)
         {
            rect.left *= 3;
            rect.left >>= 2;
            rect.left += mg_ctxt.offset_left;
            rect.width *= 3;
            rect.width >>= 2;
         }
         #endif /*NO_SCALE_ASPECT*/
         STB_OSDMhegFillRectangle( &rect, TOTAL_TRANSPARENCY, STB_BLIT_COPY );
         #endif
      }
   }

   TRACE(TGRAPHICS, (""))
   FUNCTION_FINISH(OSDDisplayVideo)
}

void MG_OSDerase( S_REGION rgn, OSDColor colour )
{
   FUNCTION_START(OSDerase);

   TRACE(TGRAPHICS, ("region (%d,%d,%d,%d)", rgn.left, rgn.top, rgn.right, rgn.bottom))
   /* Clear area to black */
   if ((rgn.bottom > rgn.top) && (rgn.right > rgn.left))
   {
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         DrawRectangle8Bit( rgn, OSD_FindNearestColourIndex(colour), TRUE );
         #endif
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         S_RECTANGLE rect;
         rgn.top = HD_Y_SCALEUP(rgn.top);
         rgn.bottom = HD_Y_SCALEUP(rgn.bottom);
         rgn.left = HD_X_SCALEUP(rgn.left);
         rgn.right = HD_X_SCALEUP(rgn.right);
         //TRACE(TGRAPHICS,("actual(%d,%d,%d,%d)",rgn.left, rgn.top, rgn.right, rgn.bottom))
         rect.left = rgn.left;
         rect.top = rgn.top;
         rect.width = rgn.right - rgn.left;
         rect.height = rgn.bottom - rgn.top;
         #ifndef NO_SCALE_ASPECT
         if (mg_ctxt.offset_left)
         {
            rect.left *= 3;
            rect.left >>= 2;
            rect.left += mg_ctxt.offset_left;
            rect.width *= 3;
            rect.width >>= 2;
         }
         #endif /*NO_SCALE_ASPECT*/
         STB_OSDMhegFillRectangle( &rect, MakeHD2Color(colour), STB_BLIT_COPY );
         #endif
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         S_RECTANGLE rect;
         OSDColor col;
         ConvertAlpha(colour, col);
         rgn.top = HD_Y_SCALEUP(rgn.top);
         rgn.bottom = HD_Y_SCALEUP(rgn.bottom);
         rgn.left = HD_X_SCALEUP(rgn.left);
         rgn.right = HD_X_SCALEUP(rgn.right);
         //TRACE(TGRAPHICS,("actual(%d,%d,%d,%d)",rgn.left, rgn.top, rgn.right, rgn.bottom))
         rect.left = rgn.left;
         rect.top = rgn.top;
         rect.width = rgn.right - rgn.left;
         rect.height = rgn.bottom - rgn.top;
         #ifndef NO_SCALE_ASPECT
         if (mg_ctxt.offset_left)
         {
            rect.left *= 3;
            rect.left >>= 2;
            rect.left += mg_ctxt.offset_left;
            rect.width *= 3;
            rect.width >>= 2;
         }
         #endif /*NO_SCALE_ASPECT*/
         STB_OSDMhegFillRectangle( &rect, col, STB_BLIT_COPY );
         #endif
      }
   }

   FUNCTION_FINISH(OSDerase)
}

void MG_OSDclear(void)
{
   FUNCTION_START(MG_OSDclear)
   TRACE(TGRAPHICS, (""))
   IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
   {
      #ifdef OSD_8_BIT
      S_REGION rgn = { 0, 0, 720, 576 };
      DrawRectangle8Bit( rgn, 0, TRUE );
      MG_OSDUpdate();
      #endif
   }
   ELSE
   {
      #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
      STB_OSDMhegClear();
      STB_OSDMhegUpdate();
      #endif
   }
   FUNCTION_FINISH(MG_OSDclear)
}

#ifdef OSD_8_BIT

void MG_OSDUpdate( void )
{
   IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
   {
      S_RECTANGLE rect;
      rect.left = osd_update_rgn.left;
      rect.top = osd_update_rgn.top;
      rect.width = osd_update_rgn.right - osd_update_rgn.left;
      rect.height = osd_update_rgn.bottom - osd_update_rgn.top;
      #ifdef _TRACING
      {
         U8BIT *data;
         data = (U8BIT *)mg_ctxt.screen_buff + (osd_update_rgn.top * mg_ctxt.screen_stride) + osd_update_rgn.left;
         data += mg_ctxt.screen_stride * (rect.height / 2);
         TRACE(TGRAPHICS, ("Middle OSD Line:"))
         TRACE_BUFF(TGRAPHICS, data, rect.width)
      }
      #endif
      TRACE(TGRAPHICS, ("regn (%d,%d,%d,%d)", osd_update_rgn.left, osd_update_rgn.top,
                        osd_update_rgn.right, osd_update_rgn.bottom))
      TRACE(TGRAPHICS, ("rect (%d,%d,%d,%d)", rect.left, rect.top, rect.width, rect.height))
      STB_OSDMhegBlitBitmap( mg_ctxt.hw_handle, &rect, mg_ctxt.screen_stride,
         osd_update_rgn.left, osd_update_rgn.top, STB_BLIT_COPY );
      STB_OSDMhegUpdate();
      osd_update_rgn.left = mg_ctxt.out_osd_width;
      osd_update_rgn.top = mg_ctxt.out_osd_height;
      osd_update_rgn.right = 0;
      osd_update_rgn.bottom = 0;
   }
   ELSE
   {
      TRACE(TGRAPHICS, (""))
      #if defined(OSD_16_BIT) || defined(OSD_32_BIT)
      STB_OSDMhegUpdate();
      #endif
   }
}

U8BIT OSD_FindNearestColourIndex(OSDColor target)
{
   U8BIT r, g, b, a;
   static OSDColor target_cache = 0x00000000;
   static U8BIT offset_cache = OFFSET_TRANS;
   static const NearCol mg_nearest_colour = {
      /* red  */ {0, 27, 27, 54, 54, 81, 81, 108},
      /* green*/ {0, 3, 3, 6, 6, 9, 9, 12, 12, 15, 15, 18, 18, 21, 21, 24},
      /* blue */ {0, 1, 1, 2}
   };

   if (target != target_cache)
   {
      target_cache = target;

      a = (U8BIT)(((target >> 24) & 0xff) ^ 0xff);
      r = (U8BIT)((target >> 16) & 0xff);
      g = (U8BIT)((target >> 8) & 0xff);
      b = (U8BIT)(target & 0xff);

      if (a < 0x19)
      {
         if (r == g && g == b && ((r > 21 && r < 106) || (r > 148 && r < 233)))
         {
            /* grey */
            offset_cache = (r >> 6) + OFFSET_GREY;
         }
         else
         {
            /* opaque */
            offset_cache = mg_nearest_colour.red[r >> 5] + mg_nearest_colour.green[g >> 4] +
               mg_nearest_colour.blue[b >> 6] + OFFSET_BLACK;
         }
      }
      else if (a <= 0xe6)
      {
         /* semi-transparent */
         offset_cache = (b >> 7) + OFFSET_SEMI;

         if (r & 0x80)
         {
            if (r <= 212)
            {
               offset_cache += 4;
            }
            else
            {
               offset_cache += 6;
            }
         }
         else
         {
            if (r > 42)
            {
               offset_cache += 2;
            }
         }

         if (g & 0x80)
         {
            if (g <= 178)
            {
               offset_cache += 24;
            }
            else
            {
               if (g <= 229)
               {
                  offset_cache += 32;
               }
               else
               {
                  offset_cache += 40;
               }
            }
         }
         else
         {
            if (g <= 71)
            {
               if (g <= 25)
               {
                  offset_cache += 0;
               }
               else
               {
                  offset_cache += 8;
               }
            }
            else
            {
               offset_cache += 16;
            }
         }
      }
      else
      {
         /* fully transparent */
         offset_cache = OFFSET_TRANS;
      }
   }

   return offset_cache;
}

void OSD_BlendPixels(U8BIT *pixel, U8BIT colour)
{
   static U8BIT back_colour_cache[2] = {0, 0};
   static U8BIT colour_cache[2] = {0, 0};
   static U8BIT offset_cache[2] = {0, 0};
   static U8BIT lru = 0;

   U8BIT back_colour;
   U8BIT front_red_index, front_green_index, front_blue_index;
   U8BIT back_red_index, back_green_index, back_blue_index, back_grey_index;
   U8BIT red_index, green_index, blue_index;
   U8BIT red_value, green_value, blue_value;
   OSDColor back;

   static const U8BIT red_blend[4][8] = {
      {  0, 0, 0, 27, 27, 27, 27, 27},
      { 27, 27, 27, 54, 54, 54, 54, 54},
      { 54, 54, 54, 54, 54, 81, 81, 81},
      { 81, 81, 81, 81, 81, 108, 108, 108}
   };
   static const U8BIT green_blend[6][16] = {
      { 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6},
      { 3, 3, 3, 6, 6, 6, 6, 6, 6, 9, 9, 9, 9, 9, 9, 9},
      { 6, 9, 9, 9, 9, 9, 9, 9, 9, 12, 12, 12, 12, 12, 12, 15},
      { 9, 12, 12, 12, 12, 12, 12, 15, 15, 15, 15, 15, 15, 15, 15, 18},
      {12, 15, 15, 15, 15, 15, 15, 18, 18, 18, 18, 18, 18, 21, 21, 21},
      {18, 18, 18, 18, 18, 18, 18, 21, 21, 21, 21, 21, 21, 24, 24, 24}
   };
   static const U8BIT blue_blend[2][4] = {
      {0, 0, 0, 1},
      {1, 2, 2, 2}
   };
   static const U8BIT black_red_blend[4] = {0, 59, 119, 179};
   static const U8BIT black_green_blend[6] = {0, 35, 71, 107, 143, 179};
   static const U8BIT black_blue_blend[2] = {0, 179};
   static const U8BIT grey_red_blend[4][4] = {
      {12, 25, 50, 63},
      {72, 85, 110, 122},
      {131, 144, 170, 182},
      {191, 204, 229, 242}
   };
   static const U8BIT grey_green_blend[6][4] = {
      {12, 25, 50, 63},
      {48, 61, 86, 98},
      {84, 96, 122, 134},
      {119, 132, 158, 170},
      {155, 168, 193, 206},
      {191, 204, 229, 242}
   };
   static const U8BIT grey_blue_blend[2][4] = {
      {12, 25, 50, 63},
      {191, 204, 229, 242}
   };
   static const U8BIT back_red[8] = {
      0, 63, 63, 127, 127, 191, 191, 255
   };
   static const U8BIT back_green[16] = {
      0, 31, 31, 63, 63, 95, 95, 127, 127, 159, 159, 191, 191, 223, 223, 255
   };
   static const U8BIT back_blue[4] = {
      0, 127, 127, 255
   };
   static const U8BIT front_red[4] = {
      0, 85, 170, 255
   };
   static const U8BIT front_green[6] = {
      0, 51, 102, 153, 204, 255
   };
   static const U8BIT front_blue[2] = {
      0, 255
   };
   static const U8BIT opaque_grey_blend[2][4] = {
      {OFFSET_BLACK, OFFSET_GREY, OFFSET_GREY, OFFSET_GREY + 1},
      {OFFSET_GREY + 2, OFFSET_GREY + 3, OFFSET_GREY + 3, OFFSET_WHITE}
   };
   static const U8BIT grey_grey_blend[2][4] = {
      {OFFSET_BLACK, OFFSET_GREY, OFFSET_GREY, OFFSET_GREY},
      {OFFSET_GREY + 2, OFFSET_GREY + 2, OFFSET_WHITE, OFFSET_WHITE}
   };

   /* Top colour is fully transparent so return immediately leaving
      the target pixel unchanged */
   assert( colour != OFFSET_TRANS );

   back_colour = *pixel;

   /* Two levels of cache, for text speed-up */
   if (back_colour_cache[0] == back_colour &&
       colour_cache[0] == colour)
   {
      *pixel = offset_cache[0];
   }
   else if (back_colour_cache[1] == back_colour &&
            colour_cache[1] == colour)
   {
      *pixel = offset_cache[1];
   }
   else
   {
      back_colour_cache[lru] = back_colour;
      colour_cache[lru] = colour;

      if (colour >= OFFSET_OPAQUE || back_colour < OFFSET_OPAQUE)
      {
         /* Back colour is (semi-)transparent, or front colour is opaque */
         offset_cache[lru] = colour;
      }
      else
      {
         assert( mg_palette != NULL );

         /* Front colour is semi-transparent, back colour is opaque */
         colour -= OFFSET_SEMI;
         back = mg_palette[*pixel];

         front_red_index = (colour >> 1) & 0x3;  /* Front red index   */
         front_green_index = (colour >> 3) & 0x7;  /* Front green index */
         front_blue_index = colour & 0x1;         /* Front blue index  */
         if (back_colour == OFFSET_BLACK)
         {
            /* Back colour is black */

            /* Lookup blended colours */
            red_value = black_red_blend[front_red_index];
            green_value = black_green_blend[front_green_index];
            blue_value = black_blue_blend[front_blue_index];
            offset_cache[lru] = OSD_FindNearestColourIndex((0xff << 24) | (red_value << 16) | (green_value << 8) | blue_value);
         }
         else if (back_colour > OFFSET_BLACK)
         {
            /* Back colour is not grey */
            back_red_index = (back >> 21) & 0x7;
            back_green_index = (back >> 12) & 0xf;
            back_blue_index = (back >> 6) & 0x3;

            /* Special case: "grey" on "grey" */
            if (back_red[back_red_index] == back_green[back_green_index] &&
                back_red[back_red_index] == back_blue[back_blue_index] &&
                front_red[front_red_index] == front_green[front_green_index] &&
                front_red[front_red_index] == front_blue[front_blue_index])
            {
               /* Approximate as grey ONLY */
               offset_cache[lru] = opaque_grey_blend[back_blue_index][front_blue_index];
            }
            else
            {
               /* Lookup blended indices */
               red_index = red_blend[front_red_index][back_red_index];
               green_index = green_blend[front_green_index][back_green_index];
               blue_index = blue_blend[front_blue_index][back_blue_index];

               /* Semi-transparent on opaque is opaque */
               offset_cache[lru] = OFFSET_BLACK + red_index + green_index + blue_index;
            }
         }
         else
         {
            /* Back colour is grey */
            back_grey_index = (back >> 6) & 0x3;

            /* Special case: real grey on "grey" */
            if (front_red[front_red_index] == front_green[front_green_index] &&
                front_red[front_red_index] == front_blue[front_blue_index])
            {
               offset_cache[lru] = grey_grey_blend[front_blue_index][back_grey_index];
            }
            else
            {
               /* Lookup blended colours */
               red_value = grey_red_blend[front_red_index][back_grey_index];
               green_value = grey_green_blend[front_green_index][back_grey_index];
               blue_value = grey_blue_blend[front_blue_index][back_grey_index];
               offset_cache[lru] = OSD_FindNearestColourIndex((0xff << 24) | (red_value << 16) | (green_value << 8) | blue_value);
            }
         }
      }
      *pixel = offset_cache[lru];
      lru = 1 - lru;
   }
}

#endif /* OSD_8_BIT */

void MG_DisplayImage( S_SURFACE *surf, S_REGION *overlap, S32BIT x, S32BIT y )
{
   S32BIT w1, y1, w2, y2;
   S32BIT fr, tr, fc, tc;

   assert( surf );

   /* Calculate rows and columns in update region - (without considering possible 4:3 aspect) */
   w1 = (overlap->left * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div;
   w2 = (overlap->right * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div;

   y1 = (overlap->top * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;
   y2 = (overlap->bottom * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;

   TRACE(TGRAPHICS, ("HDoverlap(l=%d,t=%d,r=%d,b=%d)", w1, y1, w2, y2))
   TRACE(TGRAPHICS, ("Surf(%d,%d) type=%d posn(%d,%d)", surf->width, surf->height, surf->srf_type, x, y))

   /* from column */
   if (x < w1)
   {
      fc = w1 - x;
      x = w1;
   }
   else
   {
      fc = 0;
   }

   /* to column */
   tc = surf->width;
   if (x + tc - fc > w2)
   {
      tc = fc + w2 - x;
   }

   /* from row */
   if (y < y1)
   {
      fr = y1 - y;
      y = y1;
   }
   else
   {
      fr = 0;
   }

   /* to row */
   tr = surf->height;
   if (y + tr - fr > y2)
   {
      tr = fr + y2 - y;
   }

   if (fc < tc && fr < tr)
   {
      TRACE(TGRAPHICS, ("actual(l=%d,t=%d,r=%d,b=%d)", x + fc, y + fr, x + tc, y + tr))

      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         S32BIT i, j;
         U8BIT *pixndx, *srfndx;

         w1 = tc - fc;
         y1 = tr - fr;

         pixndx = mg_ctxt.screen_buff;
         pixndx += y * mg_ctxt.screen_stride + x;
         srfndx = surf->col_buff;
         srfndx += fr * surf->width + fc;
         if (surf->opaque)
         {
            w2 = surf->width;
            y2 = mg_ctxt.screen_stride;
            for (i = fr; i != tr; ++i)
            {
               memcpy(pixndx, srfndx, w1);
               pixndx += y2;
               srfndx += w2;
            }
         }
         else
         {
            w2 = surf->width - w1;
            y2 = mg_ctxt.screen_stride - w1;
            for (i = fr; i != tr; ++i)
            {
               for (j = fc; j != tc; ++j)
               {
                  if (*srfndx != OFFSET_TRANS)
                  {
                     OSD_BlendPixels(pixndx, *srfndx);
                  }
                  ++pixndx;
                  ++srfndx;
               }
               srfndx += w2;
               pixndx += y2;
            }
         }
         /* Update region size */
         if (x < osd_update_rgn.left)
         {
            osd_update_rgn.left = x;
         }
         if (y < osd_update_rgn.top)
         {
            osd_update_rgn.top = y;
         }
         if (x + w1 > osd_update_rgn.right)
         {
            osd_update_rgn.right = x + w1;
         }
         if (y + y1 > osd_update_rgn.bottom)
         {
            osd_update_rgn.bottom = y + y1;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         S_RECTANGLE rect;
         rect.left = fc;
         rect.top = fr;
         rect.width = tc - fc;
         rect.height = tr - fr;
         #ifdef NO_SCALE_ASPECT
         STB_OSDMhegBlitBitmap( surf->hw_handle, &rect, surf->buff_pitch, x, y,
            (surf->opaque) ? STB_BLIT_COPY : STB_BLIT_A_BLEND );
         #else
         {
            S_RECTANGLE dstr;
            dstr.top = y;
            dstr.height= rect.height;
            if (mg_ctxt.offset_left)
            {
               dstr.left = ((x*3)/4) + mg_ctxt.offset_left;
               dstr.width = (rect.width*3)/4;
            }
            else
            {
               dstr.left = x;
               dstr.width = rect.width;
            }
            STB_OSDMhegBlitStretch( &rect, surf->hw_handle, &dstr, mg_ctxt.hw_handle,
               (surf->opaque) ? STB_BLIT_COPY : STB_BLIT_A_BLEND );
         }
         #endif /*NO_SCALE_ASPECT*/
         #endif
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         S_RECTANGLE rect;
         rect.left = fc;
         rect.top = fr;
         rect.width = tc - fc;
         rect.height = tr - fr;
         #ifdef NO_SCALE_ASPECT
         STB_OSDMhegBlitBitmap( surf->hw_handle, &rect, surf->buff_pitch, x, y,
            (surf->opaque) ? STB_BLIT_COPY : STB_BLIT_A_BLEND );
         #else
         {
            S_RECTANGLE dstr;
            dstr.top = y;
            dstr.height= rect.height;
            if (mg_ctxt.offset_left)
            {
               dstr.left = ((x*3)/4) + mg_ctxt.offset_left;
               dstr.width = (rect.width*3)/4;
            }
            else
            {
               dstr.left = x;
               dstr.width = rect.width;
            }
            STB_OSDMhegBlitStretch( &rect, surf->hw_handle, &dstr, mg_ctxt.hw_handle,
               (surf->opaque) ? STB_BLIT_COPY : STB_BLIT_A_BLEND );
         }
         #endif /*NO_SCALE_ASPECT*/
         #endif /*OSD_32_BIT*/
      }
   }
}

void MG_OSDdisplayImage( void *data, S_REGION *overlap, int x, int y )
{
   MG_DisplayImage((S_SURFACE *)data, overlap,
      (x * mg_ctxt.osd_x.mlt) / mg_ctxt.osd_x.div,
      (y * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div );
}

#ifdef SRF_MEM_DGB
static S_SURFACE *surflist_head = NULL;
static S_SURFACE *surflist_tail = NULL;
static U32BIT surfpixel_total = 0;
static U32BIT surfpixel_tmax = 0;

void OSD_DbgAddSurf( S_SURFACE *srf )
{
   assert( srf != NULL );
   if (surflist_tail == NULL)
   {
      /*first one*/
      assert( surflist_head == NULL );
      surflist_head = srf;
      surflist_tail = srf;
      srf->prev = NULL;
   }
   else
   {
      surflist_tail->next = srf;
      srf->prev = surflist_tail;
      surflist_tail = srf;
   }
   srf->next = NULL;
   surfpixel_total += srf->width * srf->height;
   if (surfpixel_total > surfpixel_tmax)
   {
      surfpixel_tmax = surfpixel_total;
   }
}

void OSD_DbgRemSurf( S_SURFACE *srf )
{
   assert( srf != NULL );
   surfpixel_total -= srf->width * srf->height;
   if (surflist_head == srf)
   {
      surflist_head = srf->next;
      if (surflist_head != NULL)
      {
         surflist_head->prev = NULL;
      }
   }
   else
   {
      assert( srf->prev );
      srf->prev->next = srf->next;
   }
   if (surflist_tail == srf)
   {
      surflist_tail = srf->prev;
      if (surflist_tail != NULL)
      {
         surflist_tail->next = NULL;
      }
   }
   else
   {
      assert( srf->next );
      srf->next->prev = srf->prev;
   }
}

void OSD_DbgListSrf(void)
{
   S_SURFACE *srf = surflist_head;
}

#endif /*SRF_MEM_DGB*/

void MG_FreeData( void *data )
{
   S_SURFACE *srf = (S_SURFACE *)data;
   assert(data);
   IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
   {
      #ifdef OSD_8_BIT
      if (srf->col_buff != NULL)
      {
         OSD_MemFree( srf->col_buff );
      }
      #endif
   }
   ELSE
   {
      #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
      if (srf->hw_handle)
      {
         STB_OSDMhegDestroySurface( srf->hw_handle );
         OSD_DbgRemSurf( srf );
      }
      #endif
   }
   OSD_MemFree( data );
}

#ifdef SURFACE_THRESHOLD

void MG_ApplySurfaceThreshold(void **data, S32BIT threshold)
{
   S_SURFACE *surface;
   S32BIT total;

   if (*data != NULL && threshold > 0)
   {
      surface = (*data);
      total = surface->width * surface->height;
      if (total >= threshold)
      {
         MG_FreeData(surface);
         *data = NULL;
      }
   }
}

#endif

static U16BIT OSD_GCD( U16BIT a, U16BIT b )
{
   U16BIT c;

   /* Find the GCD */
   if (b != 0)
   {
      c = a % b;
      while (c != 0)
      {
         a = b;
         b = c;
         c = a % b;
      }
   }

   return b;
}