Version 1.5.3vdr-1.5.3

- Fixed some spelling errors in 'newplugin' (thanks to Ville Skyttä).
- Fixed a busy loop in fast forward if the next video data file is missing
  (thanks to Reinhard Nissl).
- Fixed handling frequencies in NitFilter::Process() (thanks to Anssi Hannula).
- Fixed a race condition with signal handlers at program exit (thanks to Udo
  Richter).
- Non-primary devices in Transfer mode are now also used for recording (thanks
  to Anssi Hannula).
- Fixed handling ChannelUp/Down keys if there is currently a replay running
  (thanks to Marco Schlüßler).
- The new SVDRP command REMO can be used to turn VDR's remote control off and
  on in case other programs need to be controlled (based on patches from Krzysztof
  Parma and Helmut Auer).
- Increased the maximum number of CA system ids to cope with the AlphaCrypt
  CAM's version 3.11 firmware.
- Fixed getting the code setting from the locale (thanks to Matthias Schwarzott).
- Implemented support for Freetype fonts (based on a patch from Alexander Riedel).
  The font names and sizes can be adjusted in the "Setup/OSD" menu.
  Note that VDR now requires freetype fonts to be installed in
  /usr/share/fonts/truetype.
- If the OSD device in use has at least 8bpp bitmap depth and this is also
  used by the current skin, Freetype fonts are displayed "anti-aliased".
  The new setup parameter "OSD/Anti-alias" can be used to turn this off.
- The new function cOsd::SetAntiAliasGranularity() can be used to help the OSD
  in managing the available color palette entries when doing anti-aliasing.
  Skins that use 8bpp bitmaps can call this function with the maximum number
  of colors used, and the maximum number of color combinations. The OSD will
  then evenly split the available palette entries between the various colors
  combinations, so that fonts can be "anti-aliased". By default a total of
  10 colors and 10 combinations is assumed.
- The pixel fonts have been completely removed from the VDR source.
- VDR is now "UTF-8 aware". It handles strings according to the character
  encoding used on the user's system. All internationalization strings and
  incoming SI data are converted to the system encoding.
- Plugins that handle strings need to be aware that on systems with UTF-8
  encoding a "character symbol" may consist of more than a single byte in
  memory. The functions and macros named Utf8...() can be used to handle
  strings without needing to care about the underlying character encoding
  (see tools.h for details).
- Even though the weekdays of repeating timers are presented to the user as UTF-8
  characters in the OSD, the timers.conf file and the SVDRP timer commands still
  use single byte characters ("MTWTFSS") to make sure this information is handled
  correctly between systems with different character encodings.
- Added a missing i18n string for "CAM" in the Turkish OSD texts.
- Improved editing strings that are too long to fit into the editable area.
- Changes to the OSD settings in the "Setup/OSD" menu now immediately take effect
  when the "Ok" key is pressed.

1 files changed, 265 insertions, 87 deletions

diff --git a/font.c b/font.c
index 5e22fcd..af8b7cb 100644
--- a/font.c
+++ b/font.c
@@ -4,125 +4,296 @@
  * See the main source file 'vdr.c' for copyright information and
  * how to reach the author.
  *
- * $Id: font.c 1.14 2007/03/11 09:51:44 kls Exp $
+ * $Id: font.c 1.15 2007/06/09 14:41:27 kls Exp $
  */
 
-#include "config.h"
-#include <ctype.h>
 #include "font.h"
+#include <ctype.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include "config.h"
+#include "osd.h"
 #include "tools.h"
 
-#include "fontfix-iso8859-1.c"
-#include "fontosd-iso8859-1.c"
-#include "fontsml-iso8859-1.c"
-
-#include "fontfix-iso8859-2.c"
-#include "fontosd-iso8859-2.c"
-#include "fontsml-iso8859-2.c"
+// --- cFreetypeFont ---------------------------------------------------------
 
-#include "fontfix-iso8859-5.c"
-#include "fontosd-iso8859-5.c"
-#include "fontsml-iso8859-5.c"
+#define KERNING_UNKNOWN  (-10000)
 
-#include "fontfix-iso8859-7.c"
-#include "fontosd-iso8859-7.c"
-#include "fontsml-iso8859-7.c"
+struct tKerning {
+  uint prevSym;
+  int kerning;
+  tKerning(uint PrevSym, int Kerning) { prevSym = PrevSym; kerning = Kerning; }
+  };
 
-#include "fontfix-iso8859-9.c"
-#include "fontosd-iso8859-9.c"
-#include "fontsml-iso8859-9.c"
+class cGlyph : public cListObject {
+private:
+  uint charCode;
+  uchar *bitmap;
+  int advanceX;
+  int advanceY;
+  int left;  ///< The bitmap's left bearing expressed in integer pixels.
+  int top;   ///< The bitmap's top bearing expressed in integer pixels.
+  int width; ///< The number of pixels per bitmap row.
+  int rows;  ///< The number of bitmap rows.
+  int pitch; ///< The pitch's absolute value is the number of bytes taken by one bitmap row, including padding.
+  cVector<tKerning> kerningCache;
+public:
+  cGlyph(uint CharCode, FT_GlyphSlotRec_ *GlyphData);
+  virtual ~cGlyph();
+  uint CharCode(void) const { return charCode; }
+  uchar *Bitmap(void) const { return bitmap; }
+  int AdvanceX(void) const { return advanceX; }
+  int AdvanceY(void) const { return advanceY; }
+  int Left(void) const { return left; }
+  int Top(void) const { return top; }
+  int Width(void) const { return width; }
+  int Rows(void) const { return rows; }
+  int Pitch(void) const { return pitch; }
+  int GetKerningCache(uint PrevSym) const;
+  void SetKerningCache(uint PrevSym, int Kerning);
+  };
 
-#include "fontfix-iso8859-13.c"
-#include "fontosd-iso8859-13.c"
-#include "fontsml-iso8859-13.c"
+cGlyph::cGlyph(uint CharCode, FT_GlyphSlotRec_ *GlyphData)
+{
+  charCode = CharCode;
+  advanceX = GlyphData->advance.x >> 6;
+  advanceY = GlyphData->advance.y >> 6;
+  left = GlyphData->bitmap_left;
+  top = GlyphData->bitmap_top;
+  width = GlyphData->bitmap.width;
+  rows = GlyphData->bitmap.rows;
+  pitch = GlyphData->bitmap.pitch;
+  bitmap = MALLOC(uchar, rows * pitch);
+  memcpy(bitmap, GlyphData->bitmap.buffer, rows * pitch);
+}
 
-#include "fontfix-iso8859-15.c"
-#include "fontosd-iso8859-15.c"
-#include "fontsml-iso8859-15.c"
+cGlyph::~cGlyph()
+{
+  free(bitmap);
+}
 
-// --- cFont -----------------------------------------------------------------
+int cGlyph::GetKerningCache(uint PrevSym) const
+{
+  for (int i = kerningCache.Size(); --i > 0; ) {
+      if (kerningCache[i].prevSym == PrevSym)
+         return kerningCache[i].kerning;
+      }
+  return KERNING_UNKNOWN;
+}
 
-static const void *const FontData[eDvbCodeSize][eDvbFontSize] = {
-  { FontOsd_iso8859_1,  FontFix_iso8859_1,  FontSml_iso8859_1 },
-  { FontOsd_iso8859_2,  FontFix_iso8859_2,  FontSml_iso8859_2 },
-  { FontOsd_iso8859_5,  FontFix_iso8859_5,  FontSml_iso8859_5 },
-  { FontOsd_iso8859_7,  FontFix_iso8859_7,  FontSml_iso8859_7 },
-  { FontOsd_iso8859_9,  FontFix_iso8859_9,  FontSml_iso8859_9 },
-  { FontOsd_iso8859_13, FontFix_iso8859_13, FontSml_iso8859_13 },
-  { FontOsd_iso8859_15, FontFix_iso8859_15, FontSml_iso8859_15 },
-  };
+void cGlyph::SetKerningCache(uint PrevSym, int Kerning)
+{
+  kerningCache.Append(tKerning(PrevSym, Kerning));
+}
 
-static const char *FontCode[eDvbCodeSize] = {
-  "iso8859-1",
-  "iso8859-2",
-  "iso8859-5",
-  "iso8859-7",
-  "iso8859-9",
-  "iso8859-13",
-  "iso8859-15",
+class cFreetypeFont : public cFont {
+private:
+  int height;
+  int bottom;
+  FT_Library library; ///< Handle to library
+  FT_Face face; ///< Handle to face object
+  mutable cList<cGlyph> glyphCacheMonochrome;
+  mutable cList<cGlyph> glyphCacheAntiAliased;
+  int Bottom(void) const { return bottom; }
+  int Kerning(cGlyph *Glyph, uint PrevSym) const;
+  cGlyph* Glyph(uint CharCode, bool AntiAliased = false) const;
+public:
+  cFreetypeFont(const char *Name, int CharHeight);
+  virtual ~cFreetypeFont();
+  virtual int Width(uint c) const;
+  virtual int Width(const char *s) const;
+  virtual int Height(void) const { return height; }
+  virtual void DrawText(cBitmap *Bitmap, int x, int y, const char *s, tColor ColorFg, tColor ColorBg, int Width) const;
   };
 
-eDvbCode cFont::code = code_iso8859_1;
-cFont *cFont::fonts[eDvbFontSize] = { NULL };
+cFreetypeFont::cFreetypeFont(const char *Name, int CharHeight)
+{
+  height = 0;
+  bottom = 0;
+  int error = FT_Init_FreeType(&library);
+  if (!error) {
+     error = FT_New_Face(library, Name, 0, &face);
+     if (!error) {
+        if (face->num_fixed_sizes && face->available_sizes) { // fixed font
+           // TODO what exactly does all this mean?
+           height = face->available_sizes->height;
+           for (uint sym ='A'; sym < 'z'; sym++) { // search for descender for fixed font FIXME
+               FT_UInt glyph_index = FT_Get_Char_Index(face, sym);
+               error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
+               if (!error) {
+                  error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
+                  if (!error) {
+                     if (face->glyph->bitmap.rows-face->glyph->bitmap_top > bottom)
+                        bottom = face->glyph->bitmap.rows-face->glyph->bitmap_top;
+                     }
+                  else
+                     esyslog("ERROR: FreeType: error %d in FT_Render_Glyph", error);
+                  }
+               else
+                  esyslog("ERROR: FreeType: error %d in FT_Load_Glyph", error);
+               }
+           }
+        else {
+           error = FT_Set_Char_Size(face, // handle to face object
+                                    0,    // char_width in 1/64th of points
+                                    CharHeight * 64, // CharHeight in 1/64th of points
+                                    0,    // horizontal device resolution
+                                    0);   // vertical device resolution
+           if (!error) {
+              height = ((face->size->metrics.ascender-face->size->metrics.descender) + 63) / 64;
+              bottom = abs((face->size->metrics.descender - 63) / 64);
+              }
+           else
+              esyslog("ERROR: FreeType: error %d during FT_Set_Char_Size (font = %s)\n", error, Name);
+           }
+        }
+     else
+        esyslog("ERROR: FreeType: load error %d (font = %s)", error, Name);
+     }
+  else
+     esyslog("ERROR: FreeType: initialization error %d (font = %s)", error, Name);
+}
 
-cFont::cFont(const void *Data)
+cFreetypeFont::~cFreetypeFont()
 {
-  SetData(Data);
+  FT_Done_Face(face);
+  FT_Done_FreeType(library);
 }
 
-void cFont::SetData(const void *Data)
+int cFreetypeFont::Kerning(cGlyph *Glyph, uint PrevSym) const
 {
-  if (Data) {
-     height = ((tCharData *)Data)->height;
-     for (int i = 0; i < NUMCHARS; i++)
-         data[i] = (tCharData *)&((tPixelData *)Data)[(i < 32 ? 0 : i - 32) * (height + 2)];
+  int kerning = 0;
+  if (Glyph && PrevSym) {
+     kerning = Glyph->GetKerningCache(PrevSym);
+     if (kerning == KERNING_UNKNOWN) {
+        FT_Vector delta;
+        FT_UInt glyph_index = FT_Get_Char_Index(face, Glyph->CharCode());
+        FT_UInt glyph_index_prev = FT_Get_Char_Index(face, PrevSym);
+        FT_Get_Kerning(face, glyph_index_prev, glyph_index, FT_KERNING_DEFAULT, &delta);
+        kerning = delta.x / 64;
+        Glyph->SetKerningCache(PrevSym, kerning);
+        }
      }
-  else
-     height = 0;
+  return kerning;
 }
 
-int cFont::Width(const char *s) const
+cGlyph* cFreetypeFont::Glyph(uint CharCode, bool AntiAliased) const
 {
-  int w = 0;
-  while (s && *s)
-        w += Width(*s++);
-  return w;
+  // Lookup in cache:
+  cList<cGlyph> *glyphCache = AntiAliased ? &glyphCacheAntiAliased : &glyphCacheMonochrome;
+  for (cGlyph *g = glyphCache->First(); g; g = glyphCache->Next(g)) {
+      if (g->CharCode() == CharCode)
+         return g;
+      }
+
+  FT_UInt glyph_index = FT_Get_Char_Index(face, CharCode);
+
+  // Load glyph image into the slot (erase previous one):
+  int error = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT);
+  if (error)
+     esyslog("ERROR: FreeType: error during FT_Load_Glyph");
+  else {
+#if ((FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 1 && FREETYPE_PATCH >= 7) || (FREETYPE_MAJOR == 2 && FREETYPE_MINOR == 2 && FREETYPE_PATCH <= 1))// TODO workaround for bug? which one?
+     if (AntiAliased || CharCode == 32)
+#else
+     if (AntiAliased)
+#endif
+        error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_NORMAL);
+     else
+        error = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_MONO);
+     if (error)
+        esyslog("ERROR: FreeType: error during FT_Render_Glyph %d, %d\n", CharCode, glyph_index);
+     else { //new bitmap
+        cGlyph *Glyph = new cGlyph(CharCode, face->glyph);
+        glyphCache->Add(Glyph);
+        return Glyph;
+        }
+     }
+  return NULL;
 }
 
-int cFont::Height(const char *s) const
+int cFreetypeFont::Width(uint c) const
 {
-  int h = 0;
-  if (s && *s)
-     h = height; // all characters have the same height!
-  return h;
+  cGlyph *g = Glyph(c, Setup.AntiAlias);
+  return g ? g->AdvanceX() : 0;
 }
 
-bool cFont::SetCode(const char *Code)
+int cFreetypeFont::Width(const char *s) const
 {
-  for (int i = 0; i < eDvbCodeSize; i++) {
-      if (strcmp(Code, FontCode[i]) == 0) {
-         SetCode(eDvbCode(i));
-         return true;
-         }
-      }
-  return false;
+  int w = 0;
+  if (s) {
+     uint prevSym = 0;
+     while (*s) {
+           int sl = Utf8CharLen(s);
+           uint sym = Utf8CharGet(s, sl);
+           s += sl;
+           cGlyph *g = Glyph(sym, Setup.AntiAlias);
+           if (g)
+              w += g->AdvanceX() + Kerning(g, prevSym);
+           prevSym = sym;
+           }
+     }
+  return w;
 }
 
-void cFont::SetCode(eDvbCode Code)
+void cFreetypeFont::DrawText(cBitmap *Bitmap, int x, int y, const char *s, tColor ColorFg, tColor ColorBg, int Width) const
 {
-  if (code != Code) {
-     code = Code;
-     for (int i = 0; i < eDvbFontSize; i++) {
-         if (fonts[i])
-            fonts[i]->SetData(FontData[code][i]);
-         }
+  if (s && height) { // checking height to make sure we actually have a valid font
+     bool AntiAliased = Setup.AntiAlias && Bitmap->Bpp() >= 8;
+     tIndex fg = Bitmap->Index(ColorFg);
+     uint prevSym = 0;
+     while (*s) {
+           int sl = Utf8CharLen(s);
+           uint sym = Utf8CharGet(s, sl);
+           s += sl;
+           cGlyph *g = Glyph(sym, AntiAliased);
+           int kerning = Kerning(g, prevSym);
+           prevSym = sym;
+           uchar *buffer = g->Bitmap();
+           int symWidth = g->Width();
+           if (Width && x + symWidth + g->Left() + kerning - 1 > Width)
+              break; // we don't draw partial characters
+           if (x + symWidth + g->Left() + kerning > 0) {
+              for (int row = 0; row < g->Rows(); row++) {
+                  for (int pitch = 0; pitch < g->Pitch(); pitch++) {
+                      uchar bt = *(buffer + (row * g->Pitch() + pitch));
+                      if (AntiAliased) {
+                         if (bt > 0x00) {
+                            int px = x + pitch + g->Left() + kerning;
+                            int py = y + row + (height - Bottom() - g->Top());
+                            if (bt == 0xFF)
+                               Bitmap->SetIndex(px, py, fg);
+                            else {
+                               tColor bg = (ColorBg != clrTransparent) ? ColorBg : Bitmap->GetColor(px, py);
+                               Bitmap->SetIndex(px, py, Bitmap->Index(Bitmap->Blend(ColorFg, bg, bt)));
+                               }
+                            }
+                         }
+                      else { //monochrome rendering
+                         for (int col = 0; col < 8 && col + pitch * 8 <= symWidth; col++) {
+                             if (bt & 0x80)
+                                Bitmap->SetIndex(x + col + pitch * 8 + g->Left() + kerning, y + row + (height - Bottom() - g->Top()), fg);
+                             bt <<= 1;
+                             }
+                         }
+                      }
+                  }
+              }
+           x += g->AdvanceX() + kerning;
+           if (x > Bitmap->Width() - 1)
+              break;
+           }
      }
 }
 
-void cFont::SetFont(eDvbFont Font, const void *Data)
+// --- cFont -----------------------------------------------------------------
+
+cFont *cFont::fonts[eDvbFontSize] = { NULL };
+
+void cFont::SetFont(eDvbFont Font, const char *Name, int CharHeight)
 {
   delete fonts[Font];
-  fonts[Font] = new cFont(Data ? Data : FontData[code][Font]);
+  fonts[Font] = new cFreetypeFont(*Name == '/' ? Name : *AddDirectory(FONTDIR, Name), CharHeight);
 }
 
 const cFont *cFont::GetFont(eDvbFont Font)
@@ -131,8 +302,13 @@ const cFont *cFont::GetFont(eDvbFont Font)
      Font = fontOsd;
   else if (Setup.UseSmallFont == 2)
      Font = fontSml;
-  if (!fonts[Font])
-     SetFont(Font);
+  if (!fonts[Font]) {
+     switch (Font) {
+       case fontOsd: SetFont(Font, AddDirectory(FONTDIR, Setup.FontOsd), Setup.FontOsdSize); break;
+       case fontSml: SetFont(Font, AddDirectory(FONTDIR, Setup.FontSml), Setup.FontSmlSize); break;
+       case fontFix: SetFont(Font, AddDirectory(FONTDIR, Setup.FontFix), Setup.FontFixSize); break;
+       }
+     }
   return fonts[Font];
 }
 
@@ -176,16 +352,18 @@ void cTextWrapper::Set(const char *Text, const cFont *Font, int Width)
   stripspace(text); // strips trailing newlines
 
   for (char *p = text; *p; ) {
-      if (*p == '\n') {
+      int sl = Utf8CharLen(p);
+      uint sym = Utf8CharGet(p, sl);
+      if (sym == '\n') {
          lines++;
          w = 0;
          Blank = Delim = NULL;
          p++;
          continue;
          }
-      else if (isspace(*p))
+      else if (sl == 1 && isspace(sym))
          Blank = p;
-      int cw = Font->Width(*p);
+      int cw = Font->Width(sym);
       if (w + cw > Width) {
          if (Blank) {
             *Blank = '\n';
@@ -214,7 +392,7 @@ void cTextWrapper::Set(const char *Text, const cFont *Font, int Width)
          Delim = p;
          Blank = NULL;
          }
-      p++;
+      p += sl;
       }
 }