mg_dla.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2006 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
 *******************************************************************************/
#undef DEBUG_FUNCTION
#define INTELLIGENT_RENDER_WITH_SCREEN_COORDS

/*---includes for this file--------------------------------------------------*/

/* compiler library header files */

/* third party header files */

/* OBS header files */
#include "osd_utils.h"
#include "glue_memory.h"
#include "glue_debug.h"
#include "mg_osd.h"
#include "mg_api.h"

#if defined(OSD_31_BIT) || defined(OSD_32_BIT)
   #define DLA_struct     _DLA4_Surface
   #define DLA_Surface     DLA4_Surface
   #define DLA_FUNCTION(func) DLA_PC4_ ## func
   #define DLAColor  OSDColor
   #include "dla_inl.h"
   #if defined(OSD_16_BIT) || defined(OSD_8_BIT)
      #undef DLA_struct
      #undef DLA_Surface
      #undef DLA_FUNCTION
      #undef DLAColor
      #undef DLA_INL_H
   #endif
#endif
#ifdef OSD_16_BIT
   #define DLA_struct     _DLA2_Surface
   #define DLA_Surface     DLA2_Surface
   #define DLA_FUNCTION(func) DLA_PC2_ ## func
   #define DLAColor  HD2Color
   #include "dla_inl.h"
   #ifdef OSD_8_BIT
      #undef DLA_struct
      #undef DLA_Surface
      #undef DLA_FUNCTION
      #undef DLAColor
      #undef DLA_INL_H
   #endif
#endif
#ifdef OSD_8_BIT
   #define DLA_struct     _DLA1_Surface
   #define DLA_Surface     DLA1_Surface
   #define DLA_FUNCTION(func) DLA_PC1_ ## func
   #define DLAColor  U8BIT
   #include "dla_inl.h"
#endif
#undef DLA_struct
#undef DLA_Surface
#undef DLA_FUNCTION
#undef DLAColor

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

#define MAX(a, b)    ((a) > (b) ? (a) : (b))
#define MIN(a, b)    ((a) < (b) ? (a) : (b))

#ifdef INTELLIGENT_RENDER_WITH_SCREEN_COORDS
#define HD_SCALEUP_RECT(dli, x, y, w, h, lw) \
   if (mg_ctxt.osd_y.mlt != mg_ctxt.osd_y.div) \
   { \
      w = HD_X_SCALEUP(dli->sd_x + w + x); \
      x = HD_X_SCALEUP(dli->sd_x + x); \
      w -= x; \
      x -= HD_X_SCALEUP(dli->sd_x); \
      h = HD_Y_SCALEUP(dli->sd_y + h + y); \
      y = HD_Y_SCALEUP(dli->sd_y + y); \
      h -= y; \
      y -= HD_Y_SCALEUP(dli->sd_y); \
      if (lw) { \
         lw = HD_W_SCALEUP(lw); \
      } \
   }

#define HD_SCALEUP_REGN(dli, l, t, r, b) \
   if (mg_ctxt.osd_y.mlt != mg_ctxt.osd_y.div) \
   { \
      r = HD_X_SCALEUP(dli->sd_x + r) - HD_X_SCALEUP(dli->sd_x); \
      l = HD_X_SCALEUP(dli->sd_x + l) - HD_X_SCALEUP(dli->sd_x); \
      t = HD_Y_SCALEUP(dli->sd_y + t) - HD_Y_SCALEUP(dli->sd_y); \
      b = HD_Y_SCALEUP(dli->sd_y + b) - HD_Y_SCALEUP(dli->sd_y); \
   }

#else /*INTELLIGENT_RENDER_WITH_SCREEN_COORDS*/

#define HD_SCALEUP_RECT(dli, x, y, w, h, lw) \
   if (mg_ctxt.osd_y.mlt != mg_ctxt.osd_y.div) \
   { \
      w = HD_X_SCALEUP(w + x); \
      x = HD_X_SCALEUP(x); \
      w -= x; \
      h = HD_Y_SCALEUP(h + y); \
      y = HD_Y_SCALEUP(y); \
      h -= y; \
      if (lw) { \
         lw = HD_W_SCALEUP(lw); \
      } \
   }

#define HD_SCALEUP_REGN(dli, l, t, r, b) \
   if (mg_ctxt.osd_y.mlt != mg_ctxt.osd_y.div) \
   { \
      r = HD_X_SCALEUP(r); \
      l = HD_X_SCALEUP(l); \
      t = HD_Y_SCALEUP(t); \
      b = HD_Y_SCALEUP(b); \
   }

#endif /*INTELLIGENT_RENDER_WITH_SCREEN_COORDS*/

#define LOCK_BUFFER( di, c_sz ) \
   if (di->canvas.col_buff == NULL) { \
      di->canvas.col_buff = STB_OSDMhegLockBuffer( di->canvas.hw_handle, &di->canvas.buff_pitch ); \
   }

#define UNLOCK_BUFFER( di ) \
   if (di->canvas.col_buff != NULL) { \
      STB_OSDMhegUnlockBuffer( di->canvas.hw_handle ); \
      di->canvas.col_buff = NULL; \
   }

/* did you know...?
 * #define PI (3.1415926535897F)
 */


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

typedef struct _DLA_Info
{
   OSDColor canvas_colour;
   OSDColor border_colour;
   S_POLYGON polygon;
   S16BIT border_width;
   S16BIT sd_width, sd_height;
   #ifdef INTELLIGENT_RENDER_WITH_SCREEN_COORDS
   S16BIT sd_x;
   S16BIT sd_y;
   S16BIT hd_x;
   S16BIT hd_y;
   #endif
   S_SURFACE canvas;
} DLA_Info;

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

void OSDclearDynamicLineart(void *data)
{
   DLA_Info *dla_info;
   U32BIT c_col, c_size;

   FUNCTION_START(OSDclearDynamicLineart);

   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;

      /* Clear canvas */
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         c_size = dla_info->canvas.width * dla_info->canvas.height;
         c_col = OSD_FindNearestColourIndex(dla_info->canvas_colour);
         memset(dla_info->canvas.col_buff, c_col, c_size );

         /* Reset opacity information */
         if (OSD_IsColourOpaque(c_col))
         {
            if (dla_info->border_width == 0)
            {
               dla_info->canvas.opaque = TRUE;
            }
            else
            {
               c_col = OSD_FindNearestColourIndex(dla_info->border_colour);
               dla_info->canvas.opaque = OSD_IsColourOpaque(c_col);
            }
         }
         else
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         HD2Color col;
         HD2Color *c_buf;

         LOCK_BUFFER( dla_info, 2 )

         c_size = (dla_info->canvas.buff_pitch * dla_info->canvas.height) / 2;
         c_buf = (HD2Color *)dla_info->canvas.col_buff;
         c_col = dla_info->canvas_colour;
         col = MakeHD2Color(c_col);
         while (c_size != 0)
         {
            c_size--;
            *c_buf = col;
            c_buf++;
         }
         if ((col >> 12) == 0xf)
         {
            if (dla_info->border_width == 0)
            {
               dla_info->canvas.opaque = TRUE;
            }
            else
            {
               dla_info->canvas.opaque = (dla_info->border_colour >> 28) == 0xf;
            }
         }
         else
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor *c_buf;

         LOCK_BUFFER( dla_info, 4 )

         c_size = (dla_info->canvas.buff_pitch * dla_info->canvas.height) / 4;
         c_buf = (OSDColor *)dla_info->canvas.col_buff;
         ConvertAlpha(dla_info->canvas_colour, c_col);
         while (c_size != 0)
         {
            c_size--;
            *c_buf = c_col;
            c_buf++;
         }
         if ((c_col >> 24) == MAX_ALPHA)
         {
            if (dla_info->border_width == 0)
            {
               dla_info->canvas.opaque = TRUE;
            }
            else
            {
               dla_info->canvas.opaque = (dla_info->border_colour >> 24) == 0xff;
            }
         }
         else
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }

   FUNCTION_FINISH(OSDclearDynamicLineart);
}

void* OSDinitDynamicLineart(int x, int y, int w, int h,
   int line_width, int bordered,
   OSDColor line_colour, OSDColor fill_colour)
{
   S16BIT sd_width = w, sd_height = h;
   DLA_Info *new_info = 0;

   FUNCTION_START(OSDinitDynamicLineart)

   if (!bordered)
      line_width = 0;

   if (mg_ctxt.osd_y.mlt != mg_ctxt.osd_y.div)
   {
      w = HD_X_SCALEUP(x + w);
      w -= HD_X_SCALEUP(x);
      h = HD_Y_SCALEUP(y + h);
      h -= HD_Y_SCALEUP(y);
   }
   if (w > 0 && h > 0)
   {
      /* Allocate dynamic line-art info, and space for the canvas */
      new_info = (DLA_Info *)OSD_MemAlloc( sizeof(DLA_Info));
      if (new_info != NULL)
      {
         TRACE(TGRAPHICS, ("(%d,%d,%d,%d,lw=%d,b=%d,lcol=0x%x,fcol=0x%x)", x, y, w, h,
                           line_width, bordered, line_colour, fill_colour))
         new_info->canvas_colour = fill_colour;
         new_info->border_colour = line_colour;
         new_info->border_width = line_width;
         new_info->canvas.width = w;
         new_info->canvas.height = h;
         new_info->sd_width = sd_width;
         new_info->sd_height = sd_height;
         #ifdef INTELLIGENT_RENDER_WITH_SCREEN_COORDS
         new_info->sd_x = x;
         new_info->sd_y = y;
         new_info->hd_x = HD_X_SCALEUP(x);
         new_info->hd_y = HD_Y_SCALEUP(y);
         #endif
         IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
         {
            #ifdef OSD_8_BIT
            U8BIT col = OSD_FindNearestColourIndex(new_info->canvas_colour);

            new_info->canvas.buff_pitch = w;
            new_info->canvas.hw_handle = NULL;
            new_info->canvas.col_buff = OSD_MemAlloc( w * h );

            if (new_info->canvas.col_buff)
            {
               memset( new_info->canvas.col_buff, col, w * h );
            }
            if (OSD_IsColourOpaque( col ))
            {
               if (line_width == 0)
               {
                  new_info->canvas.opaque = TRUE;
               }
               else
               {
                  col = OSD_FindNearestColourIndex( line_colour );
                  new_info->canvas.opaque = OSD_IsColourOpaque(col);
               }
            }
            else
            {
               new_info->canvas.opaque = FALSE;
            }
            #endif
         }
         ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
         {
            #if defined(OSD_16_BIT)
            HD2Color col = MakeHD2Color(fill_colour);
            new_info->canvas.buff_pitch = w << 1;
            new_info->canvas.hw_handle = STB_OSDMhegCreateSurface( w, h, TRUE, col );
            OSD_DbgAddSurf( &new_info->canvas );
            new_info->canvas.col_buff = NULL;
            if ((col >> 12) == 0xf)
            {
               if (line_width == 0)
               {
                  new_info->canvas.opaque = TRUE;
               }
               else
               {
                  new_info->canvas.opaque = (line_colour >> 28) == 0xf;
               }
            }
            else
            {
               new_info->canvas.opaque = FALSE;
            }
            #endif
         }

         ELSE
         {
            #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
            OSDColor f_col;
            new_info->canvas.buff_pitch = w << 2;
            ConvertAlpha(fill_colour, f_col);
            new_info->canvas.hw_handle = STB_OSDMhegCreateSurface( w, h, TRUE, f_col );
            OSD_DbgAddSurf( &new_info->canvas );
            new_info->canvas.col_buff = NULL;
            if ((f_col >> 24) == MAX_ALPHA)
            {
               if (line_width == 0)
               {
                  new_info->canvas.opaque = TRUE;
               }
               else
               {
                  new_info->canvas.opaque = (line_colour >> 24) == 0xff;
               }
            }
            else
            {
               new_info->canvas.opaque = FALSE;
            }
            #endif
         }
         new_info->polygon.point_list = NULL;
         new_info->polygon.num_points = 0;
      }
   }

   FUNCTION_FINISH(OSDinitDynamicLineart)

   return new_info;
}

void OSDfreeDynamicLineart(void *data)
{
   DLA_Info *dla_info;
   FUNCTION_START(OSDfreeDynamicLineart);

   assert( data != NULL );

   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         OSD_MemFree( dla_info->canvas.col_buff );
         #endif
      }
      ELSE
      {
         #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
         UNLOCK_BUFFER( dla_info )
         STB_OSDMhegDestroySurface( dla_info->canvas.hw_handle );
         OSD_DbgRemSurf( &dla_info->canvas );
         #endif
      }
      OSD_MemFree( data );
   }

   FUNCTION_FINISH(OSDfreeDynamicLineart);
}

void OSDdrawArc(void *data, int x, int y, int w, int h,
   int start_angle, int arc_angle, int line_width,
   OSDColor line_colour)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawArc);
   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         U8BIT c_ndx = OSD_FindNearestColourIndex(line_colour);

         DLA_PC1_Arc((DLA1_Surface *)&dla_info->canvas, x, y, w, h,
            start_angle, arc_angle, line_width, c_ndx );

         if (!OSD_IsColourOpaque(c_ndx))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         HD_SCALEUP_RECT(dla_info, x, y, w, h, line_width);

         LOCK_BUFFER( dla_info, 2 )

         DLA_PC2_Arc((DLA2_Surface *)&dla_info->canvas, x, y, w, h,
            start_angle, arc_angle, line_width, MakeHD2Color(line_colour));

         if ((line_colour >> 28) != 0xf)
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor l_col;
         ConvertAlpha(line_colour, l_col);

         HD_SCALEUP_RECT(dla_info, x, y, w, h, line_width);

         LOCK_BUFFER( dla_info, 4 )

         DLA_PC4_Arc((DLA4_Surface *)&dla_info->canvas, x, y, w, h,
            start_angle, arc_angle, line_width, l_col );

         if ((l_col >> 24) != MAX_ALPHA)
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }
   FUNCTION_FINISH(OSDdrawArc);
}

void OSDdrawEllipse(void *data, int x, int y, int w, int h,
   int line_width, OSDColor line_colour, OSDColor fill_colour)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawEllipse);
   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         U8BIT f_ndx = OSD_FindNearestColourIndex(fill_colour);
         U8BIT l_ndx = OSD_FindNearestColourIndex(line_colour);

         DLA_PC1_Ellipse((DLA1_Surface *)&dla_info->canvas, x, y, w, h,
            line_width, f_ndx, l_ndx );

         if (!OSD_IsColourOpaque(f_ndx) || !OSD_IsColourOpaque(l_ndx))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         HD_SCALEUP_RECT(dla_info, x, y, w, h, line_width);

         LOCK_BUFFER( dla_info, 2 )

         DLA_PC2_Ellipse((DLA2_Surface *)&dla_info->canvas, x, y, w, h,
            line_width, MakeHD2Color(fill_colour), MakeHD2Color(line_colour));

         if (((fill_colour >> 28) != 0xf) || ((line_colour >> 28) != 0xf))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor f_col, l_col;
         ConvertAlpha(fill_colour, f_col);
         ConvertAlpha(line_colour, l_col);

         HD_SCALEUP_RECT(dla_info, x, y, w, h, line_width);

         LOCK_BUFFER( dla_info, 4 )

         DLA_PC4_Ellipse((DLA4_Surface *)&dla_info->canvas, x, y, w, h,
            line_width, f_col, l_col );

         if (((f_col >> 24) != MAX_ALPHA) || ((l_col >> 24) != MAX_ALPHA))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }
   FUNCTION_FINISH(OSDdrawEllipse);
}

void OSDdrawSector(void *data, int x, int y, int w, int h,
   int start_angle, int arc_angle, int line_width,
   OSDColor line_colour, OSDColor fill_colour)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawSector);
   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         U8BIT f_ndx = OSD_FindNearestColourIndex(fill_colour);
         U8BIT l_ndx = OSD_FindNearestColourIndex(line_colour);

         DLA_PC1_Sector((DLA1_Surface *)&dla_info->canvas, x, y, w, h,
            start_angle, arc_angle, line_width, f_ndx, l_ndx );

         if (!OSD_IsColourOpaque(f_ndx) || !OSD_IsColourOpaque(l_ndx))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         HD_SCALEUP_RECT(dla_info, x, y, w, h, line_width);

         LOCK_BUFFER( dla_info, 2 )

         DLA_PC2_Sector((DLA2_Surface *)&dla_info->canvas, x, y + 1, w, h,
            start_angle, arc_angle, line_width,
            MakeHD2Color(fill_colour), MakeHD2Color(line_colour));

         if (((fill_colour >> 28) != 0xf) || ((line_colour >> 28) != 0xf))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor f_col, l_col;
         ConvertAlpha(fill_colour, f_col);
         ConvertAlpha(line_colour, l_col);

         HD_SCALEUP_RECT(dla_info, x, y, w, h, line_width);

         LOCK_BUFFER( dla_info, 4 )

         DLA_PC4_Sector((DLA4_Surface *)&dla_info->canvas, x, y + 1, w, h,
            start_angle, arc_angle, line_width, f_col, l_col );

         if (((f_col >> 24) != MAX_ALPHA) || ((l_col >> 24) != MAX_ALPHA))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }
   FUNCTION_FINISH(OSDdrawSector);
}

void OSDdrawDrawLine(void *data, int x1, int y1, int x2, int y2,
   int line_width, OSDColor line_colour)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawDrawLine);
   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      HD_SCALEUP_REGN(dla_info, x1, y1, x2, y2);
      line_width = HD_W_SCALEUP(line_width);
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         U8BIT l_ndx = OSD_FindNearestColourIndex(line_colour);

         DLA_PC1_Line((DLA1_Surface *)&dla_info->canvas, x1, y1, x2, y2,
            line_width, l_ndx );

         if (!OSD_IsColourOpaque(l_ndx))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         LOCK_BUFFER( dla_info, 2 )

         DLA_PC2_Line((DLA2_Surface *)&dla_info->canvas, x1, y1, x2, y2,
            line_width, MakeHD2Color(line_colour));

         if ((line_colour >> 28) != 0xf)
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor l_col;
         ConvertAlpha(line_colour, l_col);

         LOCK_BUFFER( dla_info, 4 )

         DLA_PC4_Line((DLA4_Surface *)&dla_info->canvas, x1, y1, x2, y2,
            line_width, l_col );

         if ((l_col >> 24) != MAX_ALPHA)
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }
   FUNCTION_FINISH(OSDdrawDrawLine)
}

void OSDdrawPolygonStart(void *data)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawPolygonStart);

   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      dla_info->polygon.point_list = NULL;
      dla_info->polygon.num_points = 0;
   }

   FUNCTION_FINISH(OSDdrawPolygonStart);
}

void OSDdrawPolygonAdd(void *data, int x, int y)
{
   DLA_Info *dla_info;
   S_POINT_LIST *pl;

   FUNCTION_START(OSDdrawPolygonAdd);

   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      pl = (S_POINT_LIST *)OSD_MemAlloc( sizeof(S_POINT_LIST));
      if (pl != NULL)
      {
         #ifdef INTELLIGENT_RENDER_WITH_SCREEN_COORDS
         pl->point.x = HD_X_SCALEUP(dla_info->sd_x + x) - dla_info->hd_x;
         pl->point.y = HD_Y_SCALEUP(dla_info->sd_y + y) - dla_info->hd_y;
         #else
         pl->point.x = HD_X_SCALEUP(x);
         pl->point.y = HD_Y_SCALEUP(y);
         #endif
         pl->next = dla_info->polygon.point_list;
         dla_info->polygon.point_list = pl;
         dla_info->polygon.num_points++;
      }
   }

   FUNCTION_FINISH(OSDdrawPolygonAdd);
}

void OSDdrawPolygon(void *data, int line_width, OSDColor line_colour,
   OSDColor fill_colour, int filled)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawPolygon);

   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         U8BIT f_ndx = OSD_FindNearestColourIndex(fill_colour);
         U8BIT l_ndx = OSD_FindNearestColourIndex(line_colour);

         if (filled)
         {
            DLA_PC1_Polygon((DLA1_Surface *)&dla_info->canvas, dla_info->polygon,
               line_width, f_ndx, l_ndx );
         }
         else
         {
            DLA_PC1_Polyline((DLA1_Surface *)&dla_info->canvas, dla_info->polygon,
               line_width, l_ndx );
         }

         if (!OSD_IsColourOpaque(f_ndx) || !OSD_IsColourOpaque(l_ndx))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT

         line_width = HD_W_SCALEUP(line_width);

         LOCK_BUFFER( dla_info, 2 )

         if (filled)
         {
            DLA_PC2_Polygon((DLA2_Surface *)&dla_info->canvas, dla_info->polygon,
               line_width, MakeHD2Color(fill_colour), MakeHD2Color(line_colour));
         }
         else
         {
            DLA_PC2_Polyline((DLA2_Surface *)&dla_info->canvas, dla_info->polygon,
               line_width, MakeHD2Color(line_colour));
         }
         if (((fill_colour >> 28) != 0xf) || ((line_colour >> 28) != 0xf))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor f_col, l_col;
         ConvertAlpha(fill_colour, f_col);
         ConvertAlpha(line_colour, l_col);

         line_width = HD_W_SCALEUP(line_width);

         LOCK_BUFFER( dla_info, 4 )

         if (filled)
         {
            DLA_PC4_Polygon((DLA4_Surface *)&dla_info->canvas, dla_info->polygon,
               line_width, f_col, l_col );
         }
         else
         {
            DLA_PC4_Polyline((DLA4_Surface *)&dla_info->canvas, dla_info->polygon,
               line_width, l_col );
         }
         if (((f_col >> 24) != MAX_ALPHA) || ((l_col >> 24) != MAX_ALPHA))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }

   FUNCTION_FINISH(OSDdrawPolygon);
}

void OSDdrawRectangle(void *data, int x1, int y1, int x2, int y2,
   int line_width, OSDColor line_colour, OSDColor fill_colour)
{
   DLA_Info *dla_info;

   FUNCTION_START(OSDdrawRectangle);
   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      TRACE(TGRAPHICS, ("sd(l=%d,t=%d,r=%d,b=%d)", x1, y1, x2, y2))
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
         #ifdef OSD_8_BIT
         U8BIT f_ndx = OSD_FindNearestColourIndex(fill_colour);
         U8BIT l_ndx = OSD_FindNearestColourIndex(line_colour);

         DLA_PC1_Rectangle((DLA1_Surface *)&dla_info->canvas, x1, y1, x2, y2,
            line_width, line_width, f_ndx, l_ndx );

         if (!OSD_IsColourOpaque(f_ndx) || !OSD_IsColourOpaque(l_ndx))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_8_BIT*/
      }
      ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
      {
         #ifdef OSD_16_BIT
         HD_SCALEUP_REGN(dla_info, x1, y1, x2, y2);

         LOCK_BUFFER( dla_info, 2 )

         TRACE(TGRAPHICS, ("hd(l=%d,t=%d,r=%d,b=%d)", x1, y1, x2, y2))
         DLA_PC2_Rectangle((DLA2_Surface *)&dla_info->canvas, x1, y1, x2, y2,
            HD_X_SCALEUP(line_width), HD_Y_SCALEUP(line_width),
            MakeHD2Color(fill_colour), MakeHD2Color(line_colour));

         if (((fill_colour >> 28) != 0xf) || ((line_colour >> 28) != 0xf))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_16_BIT*/
      }

      ELSE
      {
         #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
         OSDColor f_col, l_col;
         ConvertAlpha(fill_colour, f_col);
         ConvertAlpha(line_colour, l_col);

         HD_SCALEUP_REGN(dla_info, x1, y1, x2, y2);

         LOCK_BUFFER( dla_info, 4 )

         TRACE(TGRAPHICS, ("hd(l=%d,t=%d,r=%d,b=%d)", x1, y1, x2, y2))
         DLA_PC4_Rectangle((DLA4_Surface *)&dla_info->canvas, x1, y1, x2, y2,
            HD_W_SCALEUP(line_width), HD_W_SCALEUP(line_width),
            f_col, l_col );

         if (((f_col >> 24) != MAX_ALPHA) || ((l_col >> 24) != MAX_ALPHA))
         {
            dla_info->canvas.opaque = FALSE;
         }
         #endif /*OSD_32_BIT*/
      }
   }
   FUNCTION_FINISH(OSDdrawRectangle);
}

void MG_OSDdisplayDynamicLineart(void *data, S_REGION *overlap, int x, int y )
{
   DLA_Info *dla_info;
   U16BIT x1_bw, y1_bw, x2_bw, y2_bw;

   FUNCTION_START(OSDdisplayDynamicLineart);

   if (data != NULL)
   {
      dla_info = (DLA_Info *)data;
      if (mg_ctxt.osd_y.mlt == mg_ctxt.osd_y.div)
      {
         x1_bw = y1_bw = x2_bw = y2_bw = dla_info->border_width;
      }
      else
      {
         #ifdef INTELLIGENT_RENDER_WITH_SCREEN_COORDS
         x1_bw = HD_X_SCALEUP(dla_info->border_width);
         y1_bw = HD_Y_SCALEUP(dla_info->border_width);
         x2_bw = HD_X_SCALEUP(dla_info->border_width);
         y2_bw = HD_Y_SCALEUP(dla_info->border_width);
         #else
         #error Be intelligent
         x1_bw = HD_W_SCALEUP(dla_info->border_width);
         y1_bw = HD_W_SCALEUP(dla_info->border_width);
         x2_bw = dla_info->canvas.width - HD_W_SCALEUP(dla_info->sd_width - dla_info->border_width);
         y2_bw = dla_info->canvas.height - HD_W_SCALEUP(dla_info->sd_height - dla_info->border_width);
         #endif
      }
      if (dla_info->border_width != 0)
      {
         TRACE(TGRAPHICS, ("bord_width=%d", dla_info->border_width))
         /* Draw border (must be done last) */
         IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
         {
            #ifdef OSD_8_BIT
            DLA_PC1_Border((DLA1_Surface *)&dla_info->canvas, x1_bw, y1_bw, x2_bw, y2_bw,
               OSD_FindNearestColourIndex(dla_info->border_colour));

            #endif /*OSD_8_BIT*/
         }
         ELSE IF_COL_DEPTH( COLOUR_FORMAT_ARGB4444 )
         {
            #ifdef OSD_16_BIT
            LOCK_BUFFER( dla_info, 2 )

            DLA_PC2_Border((DLA2_Surface *)&dla_info->canvas, x1_bw, y1_bw, x2_bw, y2_bw,
               MakeHD2Color(dla_info->border_colour));
            #endif /*OSD_16_BIT*/
         }

         ELSE
         {
            #if defined(OSD_31_BIT) || defined(OSD_32_BIT)
            OSDColor b_col;
            ConvertAlpha(dla_info->border_colour, b_col);

            LOCK_BUFFER( dla_info, 4 )

            DLA_PC4_Border((DLA4_Surface *)&dla_info->canvas, x1_bw, y1_bw, x2_bw, y2_bw, b_col );

            #endif /*OSD_32_BIT*/
         }
      }
      /* Write canvas to OSD buffer */
      IF_COL_DEPTH( COLOUR_FORMAT_PALETTE )
      {
      }
      ELSE
      {
         #if defined(OSD_16_BIT) || defined(OSD_31_BIT) || defined(OSD_32_BIT)
         UNLOCK_BUFFER( dla_info )
         #endif
      }
      MG_DisplayImage( &dla_info->canvas, overlap, HD_X_SCALEUP(x), HD_Y_SCALEUP(y));
   }

   FUNCTION_FINISH(OSDdisplayDynamicLineart);
}