[ViewVC] Diff of: cvs/rxvt-unicode/src/rxvtfont.C

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.210 by root, Fri Jun 18 22:11:09 2021 UTC vs.
Revision 1.222 by sf-exg, Sun Nov 21 15:49:49 2021 UTC

 # endif
 #endif
   //{ CS_UNICODE,      "-*-unifont-*-*-*-*-*-*-*-*-c-*-iso10646-1"   }, // this gem of a font has actual dotted circles within the combining character glyphs.
 #if XFT
-  { CS_UNICODE,      "xft:Bitstream Vera Sans Mono:antialias=false:autohint=true" },
+  { CS_UNICODE,      "xft:DejaVu Sans Mono:antialias=false:autohint=true"  },
-  { CS_UNICODE,      "xft:Courier New:antialias=false:autohint=true"              },
+  { CS_UNICODE,      "xft:Courier New:antialias=false:autohint=true"       },
-  { CS_UNICODE,      "xft:Andale Mono:antialias=false:autohint=false"             },
+  { CS_UNICODE,      "xft:Andale Mono:antialias=false:autohint=false"      },
-  { CS_UNICODE,      "xft:Arial Unicode MS:antialias=false:autohint=false"        },
+  { CS_UNICODE,      "xft:Arial Unicode MS:antialias=false:autohint=false" },
   // FreeMono is usually uglier than x fonts, so try after the others
   { CS_UNICODE,      "xft:FreeMono:autohint=true"                  },
 #endif
   }
   bool load (const rxvt_fontprop &prop, bool force_prop)
   {
     width = 1; height = 1;
-    ascent = 1; descent = 0;
+    ascent = 1;
+    descent = (*fs)[2]->descent;
     set_name (strdup ("built-in rendition overflow font"));
     return true;
   }
 #if XFT
 struct rxvt_font_xft : rxvt_font
 {
+#if XFT_CHAR_CACHE
+  // we cache the qascii range xoffsets in the name of speed,
+  // expecting terminals to deal mostly with these characters
+  // we also assume the xoff always fits into uint8_t,
+  // which is questionable, but let's see...
+  // also, it is uncomfortably big, due to the uints.
+  enum { char_cache_min = 0x20, char_cache_max = 0x7e };
+  uint8_t xoff_cache  [char_cache_max - char_cache_min + 1];
+  FT_UInt glyph_cache [char_cache_max - char_cache_min + 1];
+#endif
   rxvt_font_xft ()
   {
     f = 0;
   }
           break;
         }
       FT_Face face = XftLockFace (f);
+      // fuck me plenty: XftLockFace can actually return 0. try not to crash.
+      // we also assume blindly that if the first lock succeeeds, then subsequent
+      // locks will also succeed.
+      if (!face)
+        {
+          XftFontClose (disp, f);
+          success = false;
+          break;
+        }
       ascent  = (face->size->metrics.ascender + 63) >> 6;
       descent = (-face->size->metrics.descender + 63) >> 6;
       height  = max (ascent + descent, (face->size->metrics.height + 63) >> 6);
       width   = 0;
 #if 0 // do it per-character
   if (prop.width != rxvt_fontprop::unset && width > prop.width)
     {
       clear ();
       success = false;
+    }
+#endif
+#if XFT_CHAR_CACHE
+  // populate char cache
+  for (FcChar16 ch = char_cache_min; ch <= char_cache_max; ++ch)
+    {
+      FT_UInt glyph = XftCharIndex (disp, f, ch);
+      glyph_cache [ch - char_cache_min] = glyph;
+      XGlyphInfo g;
+      XftGlyphExtents (disp, f, &glyph, 1, &g);
+      xoff_cache [ch - char_cache_min] = g.xOff;
     }
 #endif
   return success;
 }
   int wcw = max (WCWIDTH (chr), 1);
   XGlyphInfo g;
   XftTextExtents32 (term->dpy, f, &chr, 1, &g);
+  int cwidth = prop->width * wcw;
+  // use same adjustments as in ->draw, see there
+  g.x += g.xOff ? cwidth - g.xOff >> 1 : 0;
+  g.x += g.xOff ? 0 : cwidth;
   int w = g.width - g.x;
-  careful = g.x > 0 || w > prop->width * wcw;
+  careful = g.x > 0 || w > cwidth;
   if (careful && !OVERLAP_OK (w, wcw, prop))
     return false;
   // this weeds out _totally_ broken fonts, or glyphs
 void
 rxvt_font_xft::draw (rxvt_drawable &d, int x, int y,
                      const text_t *text, int len,
                      int fg, int bg)
 {
-  //XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);//D
+  XftGlyphSpec *enc = rxvt_temp_buf<XftGlyphSpec> (len);
-  //XftGlyphSpec *ep = enc;//D
+  XftGlyphSpec *ep = enc;
-  static vector<XftGlyphSpec> enc; enc.resize (0); // static to avoid malloc, still slow
   dTermDisplay;
   dTermGC;
   int w = term->fwidth * len;
   while (len)
     {
       int cwidth = term->fwidth;
       FcChar32 chr = *text++; len--;
-      // handle non-bmp chars when text_t is 16 bit
-      #if ENABLE_COMBINING && !UNICODE_3
-        if (ecb_expect_false (IS_COMPOSE (chr)))
-          if (compose_char *cc = rxvt_composite [chr])
-            if (cc->c2 == NOCHAR)
-              chr = cc->c1;
-      #endif
       while (len && *text == NOCHAR)
         text++, len--, cwidth += term->fwidth;
       if (chr != ' ') // skip spaces
         {
+          // handle non-bmp chars when text_t is 16 bit
+          #if ENABLE_COMBINING && !UNICODE_3
+            if (ecb_expect_false (IS_COMPOSE (chr)))
+              if (compose_char *cc = rxvt_composite [chr])
+                if (cc->c2 == NOCHAR)
+                  chr = cc->c1;
+          #endif
           #if 0
           FT_UInt glyphs [decltype (exp)::max_size];
           for (int i = 0; i < nchrs; ++i)
             glyphs [i] = XftCharIndex (disp, f, chrs [i]);
               XftGlyphExtents (disp, f, glyphs+i, 1, &ep);
               printf ("gs %4x g %4x + %3d,%3d o %3d,%3d wh %3d,%3d\n", chrs[i],glyphs[i],ep.x,ep.y,ep.xOff,ep.yOff,ep.width,ep.height);
             }
           #endif
+          FT_UInt glyph;
+          int xOff;
+          #if XFT_CHAR_CACHE
+          if (ecb_expect_true (IN_RANGE_INC (chr, char_cache_min, char_cache_max)))
+            {
+              glyph = glyph_cache [chr - char_cache_min];
+              xOff  = xoff_cache  [chr - char_cache_min];
+            }
+          else
+          #endif
+            {
-          FT_UInt glyph = XftCharIndex (disp, f, chr);
+              glyph = XftCharIndex (disp, f, chr);
-          XGlyphInfo extents;
+              XGlyphInfo extents;
-          XftGlyphExtents (disp, f, &glyph, 1, &extents);
+              XftGlyphExtents (disp, f, &glyph, 1, &extents);
+              xOff = extents.xOff;
+            }
-          XftGlyphSpec ep;
-          ep.glyph = glyph;
+          ep->glyph = glyph;
-          ep.x = x_;
+          ep->x = x_;
-          ep.y = y_ + ascent;
+          ep->y = y_ + ascent;
           // the xft font cell might differ from the terminal font cell,
-          // in which we use the average between the two
+          // in which case we use the average between the two.
-          ep.x += cwidth - extents.xOff >> 1;
+          ep->x += xOff ? cwidth - xOff >> 1 : 0;
           // xft/freetype represent combining characters as characters with zero
           // width rendered over the previous character with some fonts, while
           // in other fonts, they are considered normal characters, while yet
           // in other fonts, they are shifted all over the place.
           // we handle the first two cases by keying off on xOff being 0
           // for zero-width chars. normally, we would add extents.xOff
-          // of the base chaarcter here, but we don't have that, so we use cwidth.
+          // of the base character here, but we don't have that, so we use cwidth.
-          ep.x += extents.xOff ? 0 : cwidth;
+          ep->x += xOff ? 0 : cwidth;
-          enc.push_back (ep);
+          ++ep;
         }
       x_ += cwidth;
     }
   if (buffered)
     {
-      if (!enc.empty ())
+      if (ep != enc)
         {
           rxvt_drawable &d2 = d.screen->scratch_drawable (w, h);
 #ifdef HAVE_IMG
           Picture dst = 0; // the only assignment is done conditionally in the following if condition
             }
           else
 #endif
             XftDrawRect (d2, &term->pix_colors[bg >= 0 ? bg : Color_bg].c, 0, 0, w, h);
-          XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, &enc[0], enc.size ());
+          XftDrawGlyphSpec (d2, &term->pix_colors[fg].c, f, enc, ep - enc);
           XCopyArea (disp, d2, d, gc, 0, 0, w, h, x, y);
         }
       else
         clear_rect (d, x, y, w, h, bg);
     }
   else
     {
       clear_rect (d, x, y, w, h, bg);
-      XftDrawGlyphSpec (d, &term->pix_colors[fg].c, f, &enc[0], enc.size ());
+      XftDrawGlyphSpec (d, &term->pix_colors[fg].c, f, enc, ep - enc);
     }
 }
 #endif
 }
 int
 rxvt_fontset::find_font_idx (unicode_t unicode)
 {
-  // this limits fmap size. it has to accomodate COMPOSE_HI when UNICODE_3
+  // this limits fmap size. it has to accommodate COMPOSE_HI when UNICODE_3
   if (unicode > 0x1fffff)
     return 0;
   unicode_t hi = unicode >> 8;

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/rxvtfont.C (file contents): Revision 1.210 by root, Fri Jun 18 22:11:09 2021 UTC vs. Revision 1.222 by sf-exg, Sun Nov 21 15:49:49 2021 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtfont.C (file contents):
Revision 1.210 by root, Fri Jun 18 22:11:09 2021 UTC vs.
Revision 1.222 by sf-exg, Sun Nov 21 15:49:49 2021 UTC