textdrawfn.h

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
 *******************************************************************************/
#ifndef RenderGlyphFn
#error This file should be included from mg_drawtext.c
#endif

static void RenderGlyphFn( TDColor *pixel, U8BIT *grey_src, U16BIT height,
   U8BIT width, U8BIT pitch, U16BIT stride, OSDColor full_col
             #ifdef _DEBUG
   , TDColor *cnvs_min, TDColor *cnvs_max
             #endif
   )
{
   U8BIT x;
   TDColor td_col = MakeTDColor(full_col);
#ifdef CalcColorArray
   CalcColorArray(td_col);
#endif
   pitch -= width;
   stride -= width;
   if (IsOpaqueColor(td_col))
   {
      while (height--)
      {
         for (x = width; x--; grey_src++, pixel++)
         {
            U32BIT grey_val = GreyValue( *grey_src );
         #ifdef _DEBUG
            assert((pixel >= cnvs_min) && (pixel < cnvs_max));
         #endif
            if (grey_val == SRC_FORE_MAX)
            {
               *pixel = td_col;
            }
            else
            {
               CombineAlphaColour( *pixel, grey_val, full_col, td_col )
            }
         }
         grey_src += pitch;
         pixel += stride;
      }
   }
   else
   {
      while (height--)
      {
         for (x = width; x--; grey_src++, pixel++)
         {
            U32BIT grey_val = GreyValue( *grey_src );
         #ifdef _DEBUG
            assert((pixel >= cnvs_min) && (pixel < cnvs_max));
         #endif
            CombineAlphaColour( *pixel, grey_val, full_col, td_col )
         }
         grey_src += pitch;
         pixel += stride;
      }
   }
}

static void TextDrawFn( LineLimit *disp_lines, CharData *char_data, S_FontSize *sz_data,
   FT_Face the_face, U8BIT vt_justify, U8BIT hz_justify,
   U16BIT line_space, S16BIT sd_top, U16BIT sd_height,
   U16BIT total_lines, U16BIT avail_lines, S_SURFACE *canvas )
{
   U32BIT m_size, pixel_line_start;
   TDColor *text_origin, *line_origin, *char_origin;
   U8BIT *src_buff;
   CacheSbit *c_sbit;
   S32BIT left, right, ctop, avail_width, hd_top;
   U16BIT line_num, char_ndx, cheight, buff_stride;
   FT_Int32 load_flags;
   CharData *pCharInfo;
#ifdef _DEBUG
   TDColor *cnvs_min, *cnvs_max;
#endif

   line_num = 0;
   char_ndx = 0;

   avail_width = canvas->width;
   text_origin = (TDColor *)canvas->col_buff;
   buff_stride = (U16BIT)(canvas->buff_pitch / sizeof(TDColor));
#ifdef _DEBUG
   cnvs_min = text_origin;
   m_size = buff_stride;
   m_size *= canvas->height;
   cnvs_max = &text_origin[m_size];
#endif
   canvas->opaque = FALSE;
   hd_top = (sd_top * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;
   sd_top += sz_data->bb_sd_top;
   hd_top += sz_data->bound_box.top;
   switch (vt_justify)
   {
      case JUSTIFY_V_END:
         if (total_lines > avail_lines)
         {
            line_num = total_lines - avail_lines;
            while (disp_lines->line_num < line_num)
            {
               char_ndx = disp_lines->end_ndx;
               disp_lines++;
            }
            cheight = avail_lines - 1;
         }
         else
         {
            cheight = total_lines - 1;
         }
         cheight = (cheight * line_space) + sz_data->bb_sd_height;
         assert( cheight <= sd_height );
         if (cheight < sd_height)
         {
            sd_top += sd_height - cheight;
         }
         break;

      case JUSTIFY_V_CENTRE:
         if (total_lines > avail_lines)
         {
            total_lines = avail_lines;
         }
         cheight = ((total_lines - 1) * line_space) + sz_data->bb_sd_height;
         assert( cheight <= sd_height );
         if (cheight < sd_height)
         {
            sd_top += (sd_height - cheight) >> 1;
         }
         break;

      default:
      case JUSTIFY_V_START:
         if (total_lines > avail_lines)
         {
            total_lines = avail_lines;
         }
   }
   while (line_num != total_lines)
   {
      if (line_num == disp_lines->line_num)
      {
         pixel_line_start = (sd_top * mg_ctxt.osd_y.mlt) / mg_ctxt.osd_y.div;
         if (pixel_line_start < (U32BIT)hd_top)
         {
            pixel_line_start = 0;
            line_origin = text_origin;
         }
         else
         {
            pixel_line_start -= hd_top;
            line_origin = text_origin + (pixel_line_start * buff_stride);
         }
         switch (hz_justify)
         {
            case JUSTIFY_H_END:
               right = disp_lines->position + disp_lines->l_width;
               left = right - avail_width;
               break;
            case JUSTIFY_H_CENTRE:
               left = disp_lines->position;
               right = left;
               left += (disp_lines->l_width + 1 - avail_width) >> 1;
               right += (disp_lines->l_width + avail_width) >> 1;
               break;
            default:
            case JUSTIFY_H_START:
               left = disp_lines->position;
               right = left + avail_width;
               break;
         }
         for (char_ndx = disp_lines->start_ndx; char_ndx != disp_lines->end_ndx; char_ndx++)
         {
            pCharInfo = char_data + char_ndx;
            if ((pCharInfo->real_position >= left) &&
                ((pCharInfo->real_position + pCharInfo->width) <= right) &&
                NotTransparent(pCharInfo->colour))
            {
               /* glyph is completely within box and visible */
               ctop = sz_data->bound_box.top;
               if (pCharInfo->gf_ndx != 0)
               {
                  load_flags = FT_LOAD_RENDER;
                  /* Special cases to overcome a FreeType bug: for
                   * "Latin Small Letter A With Tilde U+00E3",
                   * "Latin Small Letter N With Tilde U+00F1" and
                   * "Latin Small Letter O With Tilde U+00F5" the
                   * "tilde" is rendered as a macron for small font
                   * sizes, when auto-hinting is enabled. We cannot
                   * always control the build options, so a special
                   * case is required.
                   */
                  if (pCharInfo->uni_chr == 0x00e3 ||
                      pCharInfo->uni_chr == 0x00f1 ||
                      pCharInfo->uni_chr == 0x00f5)
                  {
                     load_flags |= FT_LOAD_NO_AUTOHINT;
                  }
                  if (FT_Load_Glyph( the_face, pCharInfo->gf_ndx, load_flags ) != 0)
                  {
                     /* ERROR, so goto next glyph */
                     continue;
                  }
                  else
                  {
                     assert( pCharInfo->width == the_face->glyph->bitmap.width );
                     if (the_face->glyph->bitmap.pitch < 0)
                        m_size = -the_face->glyph->bitmap.pitch;
                     else
                        m_size = the_face->glyph->bitmap.pitch;
                     ctop -= the_face->glyph->bitmap_top;
                     cheight = the_face->glyph->bitmap.rows;
                     src_buff = the_face->glyph->bitmap.buffer;
                  }
               }
               else
               {
                  c_sbit = &sz_data->sbit_cache[pCharInfo->uni_chr - FIRST_CACHE_CHAR];
                  m_size = c_sbit->width;
                  ctop -= c_sbit->top;
                  src_buff = (U8BIT *)&sz_data->sbit_cache[CHAR_CACHE_SIZE];
                  src_buff += c_sbit->bmp_ndx;
                  cheight = c_sbit->height;
               }
               assert( sz_data->bound_box.height >= cheight );
               char_origin = line_origin;
               if (ctop > 0)
               {
                  if ((pixel_line_start + ctop + cheight) > canvas->height)
                  {
                     ctop = canvas->height - (cheight + pixel_line_start);
                  }
                  char_origin += ctop * buff_stride;
               }
               char_origin += pCharInfo->real_position - left;

               RenderGlyphFn( char_origin, src_buff, cheight, pCharInfo->width, (U8BIT)m_size, buff_stride, pCharInfo->colour
                           #ifdef _DEBUG
                  , cnvs_min, cnvs_max
                           #endif
                  );
            }
         }
         disp_lines++;
      }
      sd_top += line_space;
      line_num++;
   }
}