Attachment #516244 for bug #637481

Attachment #516244: patch to add vhea/vmtx support to OTS for bug #637481

View | Details | Raw Unified | Return to bug 637481
Collapse All | Expand All





#include "head.h"
#include "maxp.h"

// hhea - Horizontal Header
// http://www.microsoft.com/opentype/otspec/hhea.htm

namespace ots {

bool ots_Xhea_parse(OpenTypeFile *file, const uint8_t *data, size_t length,
                    OpenTypeHHEA **out_hhea) {
  Buffer table(data, length);
  OpenTypeHHEA *hhea = new OpenTypeHHEA;
  *out_hhea = hhea;

  uint32_t version = 0;
  if (!table.ReadU32(&version)) {
    return OTS_FAILURE();
  }
  if (version >> 16 != 1) {
    return OTS_FAILURE();
  }


  if (hhea->num_hmetrics > file->maxp->num_glyphs) {
    return OTS_FAILURE();
  }

  return true;
}

bool ots_hhea_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
  return ots_Xhea_parse(file, data, length, &file->hhea);
}

bool ots_vhea_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
  return ots_Xhea_parse(file, data, length, reinterpret_cast<OpenTypeHHEA**>(&file->vhea));
}

bool ots_hhea_should_serialise(OpenTypeFile *file) {
  return file->hhea;
}

bool ots_vhea_should_serialise(OpenTypeFile *file) {
  return file->preserve_otl && file->vhea;
}

bool ots_Xhea_serialise(OTSStream *out, OpenTypeFile *file, const OpenTypeHHEA *hhea) {
  if (!out->WriteU32(0x00010000) ||
      !out->WriteS16(hhea->ascent) ||
      !out->WriteS16(hhea->descent) ||
      !out->WriteS16(hhea->linegap) ||
      !out->WriteU16(hhea->adv_width_max) ||
      !out->WriteS16(hhea->min_lsb) ||
      !out->WriteS16(hhea->min_rsb) ||
      !out->WriteS16(hhea->x_max_extent) ||

      !out->WriteS16(0) ||  // metric data format
      !out->WriteU16(hhea->num_hmetrics)) {
    return OTS_FAILURE();
  }

  return true;
}

bool ots_hhea_serialise(OTSStream *out, OpenTypeFile *file) {
  return ots_Xhea_serialise(out, file, file->hhea);
}

bool ots_vhea_serialise(OTSStream *out, OpenTypeFile *file) {
  return ots_Xhea_serialise(out, file, reinterpret_cast<const OpenTypeHHEA*>(file->vhea));
}

void ots_hhea_free(OpenTypeFile *file) {
  delete file->hhea;
}

void ots_vhea_free(OpenTypeFile *file) {
  delete file->vhea;
}

}  // namespace ots





  int16_t min_rsb;
  int16_t x_max_extent;
  int16_t caret_slope_rise;
  int16_t caret_slope_run;
  int16_t caret_offset;
  uint16_t num_hmetrics;
};

struct OpenTypeVHEA {
  int16_t ascent;
  int16_t descent;
  int16_t linegap;
  uint16_t adv_width_max;
  int16_t min_lsb;
  int16_t min_rsb;
  int16_t x_max_extent;
  int16_t caret_slope_rise;
  int16_t caret_slope_run;
  int16_t caret_offset;
  uint16_t num_hmetrics;
};

}  // namespace ots

#endif  // OTS_HHEA_H_





#include "hhea.h"
#include "maxp.h"

// hmtx - Horizontal Metrics
// http://www.microsoft.com/opentype/otspec/hmtx.htm

namespace ots {

bool ots_Xmtx_parse(OpenTypeFile *file, const uint8_t *data, size_t length,
                    const OpenTypeHHEA *hhea, OpenTypeHMTX **out_hmtx) {
  Buffer table(data, length);
  OpenTypeHMTX *hmtx = new OpenTypeHMTX;
  *out_hmtx = hmtx;

  if (!hhea || !file->maxp) {
    return OTS_FAILURE();
  }

  // |num_hmetrics| is a uint16_t, so it's bounded < 65536. This limits that
  // amount of memory that we'll allocate for this to a sane amount.
  const unsigned num_hmetrics = hhea->num_hmetrics;

  if (num_hmetrics > file->maxp->num_glyphs) {
    return OTS_FAILURE();
  }
  if (!num_hmetrics) {
    return OTS_FAILURE();
  }
  const unsigned num_lsbs = file->maxp->num_glyphs - num_hmetrics;

    int16_t lsb = 0;
    if (!table.ReadU16(&adv) || !table.ReadS16(&lsb)) {
      return OTS_FAILURE();
    }

    // Since so many fonts don't have proper value on |adv| and |lsb|,
    // we should not call ots_failure() here. For example, about 20% of fonts
    // in http://www.princexml.com/fonts/ (200+ fonts) fails these tests.
    if (adv > hhea->adv_width_max) {
      OTS_WARNING("bad adv: %u > %u", adv, hhea->adv_width_max);
      adv = hhea->adv_width_max;
    }
    if (lsb < hhea->min_lsb) {
      OTS_WARNING("bad lsb: %d < %d", lsb, hhea->min_lsb);
      lsb = hhea->min_lsb;
    }

    hmtx->metrics.push_back(std::make_pair(adv, lsb));
  }

  hmtx->lsbs.reserve(num_lsbs);
  for (unsigned i = 0; i < num_lsbs; ++i) {
    int16_t lsb;
    if (!table.ReadS16(&lsb)) {
      // Some Japanese fonts (e.g., mona.ttf) fail this test.
      return OTS_FAILURE();
    }

    if (lsb < hhea->min_lsb) {
      // The same as above. Three fonts in http://www.fontsquirrel.com/fontface
      // (e.g., Notice2Std.otf) have weird lsb values.
      OTS_WARNING("bad lsb: %d < %d", lsb, hhea->min_lsb);
      lsb = hhea->min_lsb;
    }

    hmtx->lsbs.push_back(lsb);
  }

  return true;
}

bool ots_hmtx_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
  return ots_Xmtx_parse(file, data, length, file->hhea, &file->hmtx);
}

bool ots_vmtx_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
  return ots_Xmtx_parse(file, data, length, reinterpret_cast<const OpenTypeHHEA*>(file->vhea), reinterpret_cast<OpenTypeHMTX**>(&file->vmtx));
}

bool ots_hmtx_should_serialise(OpenTypeFile *file) {
  return file->hmtx;
}

bool ots_vmtx_should_serialise(OpenTypeFile *file) {
  return file->preserve_otl && file->vmtx;
}

bool ots_Xmtx_serialise(OTSStream *out, OpenTypeFile *file, const OpenTypeHMTX *hmtx) {
  for (unsigned i = 0; i < hmtx->metrics.size(); ++i) {
    if (!out->WriteU16(hmtx->metrics[i].first) ||
        !out->WriteS16(hmtx->metrics[i].second)) {
      return OTS_FAILURE();
    }
  }

  for (unsigned i = 0; i < hmtx->lsbs.size(); ++i) {
    if (!out->WriteS16(hmtx->lsbs[i])) {
      return OTS_FAILURE();
    }
  }

  return true;
}

bool ots_hmtx_serialise(OTSStream *out, OpenTypeFile *file) {
  return ots_Xmtx_serialise(out, file, file->hmtx);
}

bool ots_vmtx_serialise(OTSStream *out, OpenTypeFile *file) {
  return ots_Xmtx_serialise(out, file, reinterpret_cast<const OpenTypeHMTX*>(file->vmtx));
}

void ots_hmtx_free(OpenTypeFile *file) {
  delete file->hmtx;
}

void ots_vmtx_free(OpenTypeFile *file) {
  delete file->vmtx;
}

}  // namespace ots






namespace ots {

struct OpenTypeHMTX {
  std::vector<std::pair<uint16_t, int16_t> > metrics;
  std::vector<int16_t> lsbs;
};

struct OpenTypeVMTX {
  std::vector<std::pair<uint16_t, int16_t> > metrics;
  std::vector<int16_t> lsbs;
};

}  // namespace ots

#endif  // OTS_HMTX_H_





  { Tag("prep"), ots::ots_prep_parse, ots::ots_prep_serialise,
    ots::ots_prep_should_serialise, ots::ots_prep_free, false },
  { Tag("LTSH"), ots::ots_ltsh_parse, ots::ots_ltsh_serialise,
    ots::ots_ltsh_should_serialise, ots::ots_ltsh_free, false },
  { Tag("VORG"), ots::ots_vorg_parse, ots::ots_vorg_serialise,
    ots::ots_vorg_should_serialise, ots::ots_vorg_free, false },
  { Tag("kern"), ots::ots_kern_parse, ots::ots_kern_serialise,
    ots::ots_kern_should_serialise, ots::ots_kern_free, false },
  { Tag("vhea"), ots::ots_vhea_parse, ots::ots_vhea_serialise,
    ots::ots_vhea_should_serialise, ots::ots_vhea_free, false },
  { Tag("vmtx"), ots::ots_vmtx_parse, ots::ots_vmtx_serialise,
    ots::ots_vmtx_should_serialise, ots::ots_vmtx_free, false },
  { Tag("GDEF"), ots::ots_gdef_parse, ots::ots_gdef_serialise,
    ots::ots_gdef_should_serialise, ots::ots_gdef_free, false },
  { Tag("GPOS"), ots::ots_gpos_parse, ots::ots_gpos_serialise,
    ots::ots_gpos_should_serialise, ots::ots_gpos_free, false },
  { Tag("GSUB"), ots::ots_gsub_parse, ots::ots_gsub_serialise,
    ots::ots_gsub_should_serialise, ots::ots_gsub_free, false },
  // TODO(yusukes): Support GDEF, GPOS, GSUB, mort, base, and jstf tables.
  { 0, NULL, NULL, NULL, NULL, false }





  F(loca, LOCA) \
  F(ltsh, LTSH) \
  F(maxp, MAXP) \
  F(name, NAME) \
  F(os2, OS2) \
  F(post, POST) \
  F(prep, PREP) \
  F(vdmx, VDMX) \
  F(vhea, VHEA) \
  F(vmtx, VMTX) \
  F(vorg, VORG) \
  F(gdef, GDEF) \
  F(gpos, GPOS) \
  F(gsub, GSUB)

#define F(name, capname) struct OpenType##capname;
FOR_EACH_TABLE_TYPE
#undef F

Return to bug 637481