+#ifdef HAVE_LIBOTF
+
+static Lisp_Object
+ftfont_otf_features (gsub_gpos)
+ OTF_GSUB_GPOS *gsub_gpos;
+{
+ Lisp_Object scripts, langsyses, features, sym;
+ int i, j, k;
+
+ for (scripts = Qnil, i = gsub_gpos->ScriptList.ScriptCount - 1; i >= 0; i--)
+ {
+ OTF_Script *otf_script = gsub_gpos->ScriptList.Script + i;
+
+ for (langsyses = Qnil, j = otf_script->LangSysCount - 1; j >= -1; j--)
+ {
+ OTF_LangSys *otf_langsys;
+
+ if (j >= 0)
+ otf_langsys = otf_script->LangSys + j;
+ else if (otf_script->DefaultLangSysOffset)
+ otf_langsys = &otf_script->DefaultLangSys;
+ else
+ break;
+
+ for (features = Qnil, k = otf_langsys->FeatureCount - 1; k >= 0; k--)
+ {
+ OTF_TAG_SYM (sym, gsub_gpos->FeatureList.Feature[k].FeatureTag);
+ features = Fcons (sym, features);
+ }
+ if (j >= 0)
+ OTF_TAG_SYM (sym, otf_script->LangSysRecord[j].LangSysTag);
+ else
+ sym = Qnil;
+ langsyses = Fcons (Fcons (sym, features), langsyses);
+ }
+
+ OTF_TAG_SYM (sym, gsub_gpos->ScriptList.Script[i].ScriptTag);
+ scripts = Fcons (Fcons (sym, langsyses), scripts);
+ }
+ return scripts;
+
+}
+
+
+static Lisp_Object
+ftfont_otf_capability (font)
+ struct font *font;
+{
+ struct ftfont_info *ftfont_info = (struct ftfont_info *) font;
+ OTF *otf = ftfont_get_otf (ftfont_info);
+ Lisp_Object gsub_gpos;
+
+ if (! otf)
+ return Qnil;
+ gsub_gpos = Fcons (Qnil, Qnil);
+ if (OTF_get_table (otf, "GSUB") == 0)
+ XSETCAR (gsub_gpos, ftfont_otf_features (otf->gsub));
+ if (OTF_get_table (otf, "GPOS") == 0)
+ XSETCDR (gsub_gpos, ftfont_otf_features (otf->gpos));
+ return gsub_gpos;
+}
+
+#ifdef HAVE_M17N_FLT
+
+struct MFLTFontFT
+{
+ MFLTFont flt_font;
+ struct font *font;
+ FT_Face ft_face;
+ OTF *otf;
+};
+
+static int
+ftfont_get_glyph_id (font, gstring, from, to)
+ MFLTFont *font;
+ MFLTGlyphString *gstring;
+ int from, to;
+{
+ struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
+ FT_Face ft_face = flt_font_ft->ft_face;
+ MFLTGlyph *g;
+
+ for (g = gstring->glyphs + from; from < to; g++, from++)
+ if (! g->encoded)
+ {
+ FT_UInt code = FT_Get_Char_Index (ft_face, g->code);
+
+ g->code = code > 0 ? code : FONT_INVALID_CODE;
+ g->encoded = 1;
+ }
+ return 0;
+}
+
+static int
+ftfont_get_metrics (font, gstring, from, to)
+ MFLTFont *font;
+ MFLTGlyphString *gstring;
+ int from, to;
+{
+ struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
+ FT_Face ft_face = flt_font_ft->ft_face;
+ MFLTGlyph *g;
+
+ for (g = gstring->glyphs + from; from < to; g++, from++)
+ if (! g->measured)
+ {
+ if (g->code != FONT_INVALID_CODE)
+ {
+ FT_Glyph_Metrics *m;
+
+ if (FT_Load_Glyph (ft_face, g->code, FT_LOAD_DEFAULT) != 0)
+ abort ();
+ m = &ft_face->glyph->metrics;
+
+ g->lbearing = m->horiBearingX;
+ g->rbearing = m->horiBearingX + m->width;
+ g->ascent = m->horiBearingY;
+ g->descent = m->height - m->horiBearingY;
+ g->xadv = m->horiAdvance;
+ }
+ else
+ {
+ g->lbearing = 0;
+ g->rbearing = g->xadv = flt_font_ft->font->space_width << 6;
+ g->ascent = flt_font_ft->font->ascent << 6;
+ g->descent = flt_font_ft->font->descent << 6;
+ }
+ g->yadv = 0;
+ g->measured = 1;
+ }
+ return 0;
+}
+
+static int
+ftfont_check_otf (MFLTFont *font, MFLTOtfSpec *spec)
+{
+ struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
+ OTF *otf = flt_font_ft->otf;
+ OTF_Tag *tags;
+ int i, n, negative;
+
+ for (i = 0; i < 2; i++)
+ {
+ if (! spec->features[i])
+ continue;
+ for (n = 0; spec->features[i][n]; n++);
+ tags = alloca (sizeof (OTF_Tag) * n);
+ for (n = 0, negative = 0; spec->features[i][n]; n++)
+ {
+ if (spec->features[i][n] == 0xFFFFFFFF)
+ negative = 1;
+ else if (negative)
+ tags[n - 1] = spec->features[i][n] | 0x80000000;
+ else
+ tags[n] = spec->features[i][n];
+ }
+ if (n - negative > 0
+ && OTF_check_features (otf, i == 0, spec->script, spec->langsys,
+ tags, n - negative) != 1)
+ return 0;
+ }
+ return 1;
+}
+
+#define DEVICE_DELTA(table, size) \
+ (((size) >= (table).StartSize && (size) <= (table).EndSize) \
+ ? (table).DeltaValue[(size) - (table).StartSize] << 6 \
+ : 0)
+
+static void
+adjust_anchor (FT_Face ft_face, OTF_Anchor *anchor,
+ unsigned code, int x_ppem, int y_ppem, int *x, int *y)
+{
+ if (anchor->AnchorFormat == 2)
+ {
+ FT_Outline *outline;
+ int ap = anchor->f.f1.AnchorPoint;
+
+ FT_Load_Glyph (ft_face, (FT_UInt) code, FT_LOAD_MONOCHROME);
+ outline = &ft_face->glyph->outline;
+ if (ap < outline->n_points)
+ {
+ *x = outline->points[ap].x << 6;
+ *y = outline->points[ap].y << 6;
+ }
+ }
+ else if (anchor->AnchorFormat == 3)
+ {
+ if (anchor->f.f2.XDeviceTable.offset)
+ *x += DEVICE_DELTA (anchor->f.f2.XDeviceTable, x_ppem);
+ if (anchor->f.f2.YDeviceTable.offset)
+ *y += DEVICE_DELTA (anchor->f.f2.YDeviceTable, y_ppem);
+ }
+}
+
+static OTF_GlyphString otf_gstring;
+
+static int
+ftfont_drive_otf (font, spec, in, from, to, out, adjustment)
+ MFLTFont *font;
+ MFLTOtfSpec *spec;
+ MFLTGlyphString *in;
+ int from, to;
+ MFLTGlyphString *out;
+ MFLTGlyphAdjustment *adjustment;
+{
+ struct MFLTFontFT *flt_font_ft = (struct MFLTFontFT *) font;
+ FT_Face ft_face = flt_font_ft->ft_face;
+ OTF *otf = flt_font_ft->otf;
+ int len = to - from;
+ int i, j, gidx;
+ OTF_Glyph *otfg;
+ char script[5], *langsys = NULL;
+ char *gsub_features = NULL, *gpos_features = NULL;
+
+ if (len == 0)
+ return from;
+ OTF_tag_name (spec->script, script);
+ if (spec->langsys)
+ {
+ langsys = alloca (5);
+ OTF_tag_name (spec->langsys, langsys);
+ }
+ for (i = 0; i < 2; i++)
+ {
+ char *p;
+
+ if (spec->features[i] && spec->features[i][1] != 0xFFFFFFFF)
+ {
+ for (j = 0; spec->features[i][j]; j++);
+ if (i == 0)
+ p = gsub_features = alloca (6 * j);
+ else
+ p = gpos_features = alloca (6 * j);
+ for (j = 0; spec->features[i][j]; j++)
+ {
+ if (spec->features[i][j] == 0xFFFFFFFF)
+ *p++ = '*', *p++ = ',';
+ else
+ {
+ OTF_tag_name (spec->features[i][j], p);
+ p[4] = ',';
+ p += 5;
+ }
+ }
+ *--p = '\0';
+ }
+ }
+
+ if (otf_gstring.size == 0)
+ {
+ otf_gstring.glyphs = (OTF_Glyph *) malloc (sizeof (OTF_Glyph) * len);
+ otf_gstring.size = len;
+ }
+ else if (otf_gstring.size < len)
+ {
+ otf_gstring.glyphs = (OTF_Glyph *) realloc (otf_gstring.glyphs,
+ sizeof (OTF_Glyph) * len);
+ otf_gstring.size = len;
+ }
+ otf_gstring.used = len;
+ memset (otf_gstring.glyphs, 0, sizeof (OTF_Glyph) * len);
+ for (i = 0; i < len; i++)
+ {
+ otf_gstring.glyphs[i].c = in->glyphs[from + i].c;
+ otf_gstring.glyphs[i].glyph_id = in->glyphs[from + i].code;
+ }
+
+ OTF_drive_gdef (otf, &otf_gstring);
+ gidx = out->used;
+
+ if (gsub_features)
+ {
+ if (OTF_drive_gsub (otf, &otf_gstring, script, langsys, gsub_features)
+ < 0)
+ goto simple_copy;
+ if (out->allocated < out->used + otf_gstring.used)
+ return -2;
+ for (i = 0, otfg = otf_gstring.glyphs; i < otf_gstring.used; )
+ {
+ MFLTGlyph *g;
+ int min_from, max_to;
+ int j;
+
+ g = out->glyphs + out->used;
+ *g = in->glyphs[from + otfg->f.index.from];
+ if (g->code != otfg->glyph_id)
+ {
+ g->c = 0;
+ g->code = otfg->glyph_id;
+ g->measured = 0;
+ }
+ out->used++;
+ min_from = g->from;
+ max_to = g->to;
+ if (otfg->f.index.from < otfg->f.index.to)
+ {
+ /* OTFG substitutes multiple glyphs in IN. */
+ for (j = from + otfg->f.index.from + 1;
+ j <= from + otfg->f.index.to; j++)
+ {
+ if (min_from > in->glyphs[j].from)
+ min_from = in->glyphs[j].from;
+ if (max_to < in->glyphs[j].to)
+ max_to = in->glyphs[j].to;
+ }
+ g->from = min_from;
+ g->to = max_to;
+ }
+ for (i++, otfg++; (i < otf_gstring.used
+ && otfg->f.index.from == otfg[-1].f.index.from);
+ i++, otfg++)
+ {
+ g = out->glyphs + out->used;
+ *g = in->glyphs[from + otfg->f.index.to];
+ if (g->code != otfg->glyph_id)
+ {
+ g->c = 0;
+ g->code = otfg->glyph_id;
+ g->measured = 0;
+ }
+ out->used++;
+ }
+ }
+ }
+ else
+ {
+ if (out->allocated < out->used + len)
+ return -2;
+ for (i = 0; i < len; i++)
+ out->glyphs[out->used++] = in->glyphs[from + i];
+ }
+
+ if (gpos_features)
+ {
+ MFLTGlyph *base = NULL, *mark = NULL, *g;
+ int x_ppem, y_ppem, x_scale, y_scale;
+
+ if (OTF_drive_gpos (otf, &otf_gstring, script, langsys, gpos_features)
+ < 0)
+ return to;
+
+ x_ppem = ft_face->size->metrics.x_ppem;
+ y_ppem = ft_face->size->metrics.y_ppem;
+ x_scale = ft_face->size->metrics.x_scale;
+ y_scale = ft_face->size->metrics.y_scale;
+
+ for (i = 0, otfg = otf_gstring.glyphs, g = out->glyphs + gidx;
+ i < otf_gstring.used; i++, otfg++, g++)
+ {
+ MFLTGlyph *prev;
+
+ if (! otfg->glyph_id)
+ continue;
+ switch (otfg->positioning_type)
+ {
+ case 0:
+ break;
+ case 1: /* Single */
+ case 2: /* Pair */
+ {
+ int format = otfg->f.f1.format;
+
+ if (format & OTF_XPlacement)
+ adjustment[i].xoff
+ = otfg->f.f1.value->XPlacement * x_scale / 0x10000;
+ if (format & OTF_XPlaDevice)
+ adjustment[i].xoff
+ += DEVICE_DELTA (otfg->f.f1.value->XPlaDevice, x_ppem);
+ if (format & OTF_YPlacement)
+ adjustment[i].yoff
+ = - (otfg->f.f1.value->YPlacement * y_scale / 0x10000);
+ if (format & OTF_YPlaDevice)
+ adjustment[i].yoff
+ -= DEVICE_DELTA (otfg->f.f1.value->YPlaDevice, y_ppem);
+ if (format & OTF_XAdvance)
+ adjustment[i].xadv
+ += otfg->f.f1.value->XAdvance * x_scale / 0x10000;
+ if (format & OTF_XAdvDevice)
+ adjustment[i].xadv
+ += DEVICE_DELTA (otfg->f.f1.value->XAdvDevice, x_ppem);
+ if (format & OTF_YAdvance)
+ adjustment[i].yadv
+ += otfg->f.f1.value->YAdvance * y_scale / 0x10000;
+ if (format & OTF_YAdvDevice)
+ adjustment[i].yadv
+ += DEVICE_DELTA (otfg->f.f1.value->YAdvDevice, y_ppem);
+ adjustment[i].set = 1;
+ }
+ break;
+ case 3: /* Cursive */
+ /* Not yet supported. */
+ break;
+ case 4: /* Mark-to-Base */
+ case 5: /* Mark-to-Ligature */
+ if (! base)
+ break;
+ prev = base;
+ goto label_adjust_anchor;
+ default: /* i.e. case 6 Mark-to-Mark */
+ if (! mark)
+ break;
+ prev = mark;
+
+ label_adjust_anchor:
+ {
+ int base_x, base_y, mark_x, mark_y;
+ int this_from, this_to;
+
+ base_x = otfg->f.f4.base_anchor->XCoordinate * x_scale / 0x10000;
+ base_y = otfg->f.f4.base_anchor->YCoordinate * y_scale / 0x10000;
+ mark_x = otfg->f.f4.mark_anchor->XCoordinate * x_scale / 0x10000;
+ mark_y = otfg->f.f4.mark_anchor->YCoordinate * y_scale / 0x10000;;
+
+ if (otfg->f.f4.base_anchor->AnchorFormat != 1)
+ adjust_anchor (ft_face, otfg->f.f4.base_anchor,
+ prev->code, x_ppem, y_ppem, &base_x, &base_y);
+ if (otfg->f.f4.mark_anchor->AnchorFormat != 1)
+ adjust_anchor (ft_face, otfg->f.f4.mark_anchor, g->code,
+ x_ppem, y_ppem, &mark_x, &mark_y);
+ adjustment[i].xoff = (base_x - mark_x);
+ adjustment[i].yoff = - (base_y - mark_y);
+ adjustment[i].back = (g - prev);
+ adjustment[i].xadv = 0;
+ adjustment[i].advance_is_absolute = 1;
+ adjustment[i].set = 1;
+ this_from = g->from;
+ this_to = g->to;
+ for (j = 0; prev + j < g; j++)
+ {
+ if (this_from > prev[j].from)
+ this_from = prev[j].from;
+ if (this_to < prev[j].to)
+ this_to = prev[j].to;
+ }
+ for (; prev <= g; prev++)
+ {
+ prev->from = this_from;
+ prev->to = this_to;
+ }
+ }
+ }
+ if (otfg->GlyphClass == OTF_GlyphClass0)
+ base = mark = g;
+ else if (otfg->GlyphClass == OTF_GlyphClassMark)
+ mark = g;
+ else
+ base = g;
+ }
+ }
+ return to;
+
+ simple_copy:
+ if (out->allocated < out->used + len)
+ return -2;
+ font->get_metrics (font, in, from, to);
+ memcpy (out->glyphs + out->used, in->glyphs + from,
+ sizeof (MFLTGlyph) * len);
+ out->used += len;
+ return to;
+}
+
+static MFLTGlyphString gstring;
+
+static int m17n_flt_initialized;
+
+extern Lisp_Object QCfamily;
+
+Lisp_Object
+ftfont_shape_by_flt (lgstring, font, ft_face, otf)
+ Lisp_Object lgstring;
+ struct font *font;
+ FT_Face ft_face;
+ OTF *otf;
+{
+ EMACS_UINT len = LGSTRING_LENGTH (lgstring);
+ EMACS_UINT i;
+ struct MFLTFontFT flt_font_ft;
+
+ if (! m17n_flt_initialized)
+ {
+ M17N_INIT ();
+ m17n_flt_initialized = 1;
+ }
+
+ for (i = 0; i < len; i++)
+ if (NILP (LGSTRING_GLYPH (lgstring, i)))
+ break;
+ len = i;
+
+ if (gstring.allocated == 0)
+ {
+ gstring.allocated = len * 2;
+ gstring.glyph_size = sizeof (MFLTGlyph);
+ gstring.glyphs = malloc (sizeof (MFLTGlyph) * gstring.allocated);
+ }
+ else if (gstring.allocated < len * 2)
+ {
+ gstring.allocated = len * 2;
+ gstring.glyphs = realloc (gstring.glyphs,
+ sizeof (MFLTGlyph) * gstring.allocated);
+ }
+ for (i = 0; i < len; i++)
+ gstring.glyphs[i].c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
+ gstring.used = len;
+ gstring.r2l = 0;
+
+ {
+ Lisp_Object family = Ffont_get (LGSTRING_FONT (lgstring), QCfamily);
+
+ if (NILP (family))
+ flt_font_ft.flt_font.family = Mnil;
+ else
+ flt_font_ft.flt_font.family
+ = msymbol ((char *) SDATA (SYMBOL_NAME (family)));
+ }
+ flt_font_ft.flt_font.x_ppem = ft_face->size->metrics.x_ppem;
+ flt_font_ft.flt_font.y_ppem = ft_face->size->metrics.y_ppem;
+ flt_font_ft.flt_font.get_glyph_id = ftfont_get_glyph_id;
+ flt_font_ft.flt_font.get_metrics = ftfont_get_metrics;
+ flt_font_ft.flt_font.check_otf = ftfont_check_otf;
+ flt_font_ft.flt_font.drive_otf = ftfont_drive_otf;
+ flt_font_ft.flt_font.internal = NULL;
+ flt_font_ft.font = font;
+ flt_font_ft.ft_face = ft_face;
+ flt_font_ft.otf = otf;
+ for (i = 0; i < 3; i++)
+ {
+ int result = mflt_run (&gstring, 0, len, &flt_font_ft.flt_font, NULL);
+ if (result != -2)
+ break;
+ gstring.allocated += gstring.allocated;
+ gstring.glyphs = realloc (gstring.glyphs,
+ sizeof (MFLTGlyph) * gstring.allocated);
+ }
+ if (gstring.used > LGSTRING_LENGTH (lgstring))
+ return Qnil;
+ for (i = 0; i < gstring.used; i++)
+ {
+ MFLTGlyph *g = gstring.glyphs + i;
+
+ g->from = LGLYPH_FROM (LGSTRING_GLYPH (lgstring, g->from));
+ g->to = LGLYPH_TO (LGSTRING_GLYPH (lgstring, g->to));
+ }
+
+ for (i = 0; i < gstring.used; i++)
+ {
+ Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
+ MFLTGlyph *g = gstring.glyphs + i;
+
+ if (NILP (lglyph))
+ {
+ lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil);
+ LGSTRING_SET_GLYPH (lgstring, i, lglyph);
+ }
+ LGLYPH_SET_FROM (lglyph, g->from);
+ LGLYPH_SET_TO (lglyph, g->to);
+ LGLYPH_SET_CHAR (lglyph, g->c);
+ LGLYPH_SET_CODE (lglyph, g->code);
+ LGLYPH_SET_WIDTH (lglyph, g->xadv >> 6);
+ LGLYPH_SET_LBEARING (lglyph, g->lbearing >> 6);
+ LGLYPH_SET_RBEARING (lglyph, g->rbearing >> 6);
+ LGLYPH_SET_ASCENT (lglyph, g->ascent >> 6);
+ LGLYPH_SET_DESCENT (lglyph, g->descent >> 6);
+ if (g->adjusted)
+ {
+ Lisp_Object vec;
+
+ vec = Fmake_vector (make_number (3), Qnil);
+ ASET (vec, 0, make_number (g->xoff >> 6));
+ ASET (vec, 1, make_number (g->yoff >> 6));
+ ASET (vec, 2, make_number (g->xadv >> 6));
+ LGLYPH_SET_ADJUSTMENT (lglyph, vec);
+ }
+ }
+ return make_number (i);
+}
+
+Lisp_Object
+ftfont_shape (lgstring)
+ Lisp_Object lgstring;
+{
+ struct font *font;
+ struct ftfont_info *ftfont_info;
+ OTF *otf;
+
+ CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font);
+ ftfont_info = (struct ftfont_info *) font;
+ otf = ftfont_get_otf (ftfont_info);
+ if (! otf)
+ return make_number (0);
+ return ftfont_shape_by_flt (lgstring, font, ftfont_info->ft_size->face, otf);
+}
+
+#endif /* HAVE_M17N_FLT */
+#endif /* HAVE_LIBOTF */
+
HCoop / bpt / emacs.git / blobdiff