LCOV - app.info - gfx/ots/src/head.cc

LCOV - code coverage report
| Current view: | directory - gfx/ots/src - head.cc (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 72 | 0 | 0.0 %
| Date: | 2012-06-02 | Functions: | 4 | 0 | 0.0 %

           1                 : // Copyright (c) 2009 The Chromium Authors. All rights reserved.
           2                 : // Use of this source code is governed by a BSD-style license that can be
           3                 : // found in the LICENSE file.
           4                 :
           5                 : #include "head.h"
           6                 :
           7                 : #include <cstring>
           8                 :
           9                 : // head - Font Header
          10                 : // http://www.microsoft.com/opentype/otspec/head.htm
          11                 :
          12                 : namespace ots {
          13                 :
          14               0 : bool ots_head_parse(OpenTypeFile *file, const uint8_t *data, size_t length) {
          15               0 :   Buffer table(data, length);
          16               0 :   file->head = new OpenTypeHEAD;
          17                 :
          18               0 :   uint32_t version = 0;
          19               0 :   if (!table.ReadU32(&version) ||
          20               0 :       !table.ReadU32(&file->head->revision)) {
          21               0 :     return OTS_FAILURE();
          22                 :   }
          23                 :
          24               0 :   if (version >> 16 != 1) {
          25               0 :     return OTS_FAILURE();
          26                 :   }
          27                 :
          28                 :   // Skip the checksum adjustment
          29               0 :   if (!table.Skip(4)) {
          30               0 :     return OTS_FAILURE();
          31                 :   }
          32                 :
          33                 :   uint32_t magic;
          34               0 :   if (!table.ReadTag(&magic) ||
          35               0 :       std::memcmp(&magic, "\x5F\x0F\x3C\xF5", 4)) {
          36               0 :     return OTS_FAILURE();
          37                 :   }
          38                 :
          39               0 :   if (!table.ReadU16(&file->head->flags)) {
          40               0 :     return OTS_FAILURE();
          41                 :   }
          42                 :
          43                 :   // We allow bits 0..4, 11..13
          44               0 :   file->head->flags &= 0x381f;
          45                 :
          46               0 :   if (!table.ReadU16(&file->head->ppem)) {
          47               0 :     return OTS_FAILURE();
          48                 :   }
          49                 :
          50                 :   // ppem must be in range
          51               0 :   if (file->head->ppem < 16 ||
          52                 :       file->head->ppem > 16384) {
          53               0 :     return OTS_FAILURE();
          54                 :   }
          55                 :
          56                 :   // ppem must be a power of two
          57                 : #if 0
          58                 :   // We don't call ots_failure() for now since lots of TrueType fonts are
          59                 :   // not following this rule. Putting OTS_WARNING here is too noisy.
          60                 :   if ((file->head->ppem - 1) & file->head->ppem) {
          61                 :     return OTS_FAILURE();
          62                 :   }
          63                 : #endif
          64                 :
          65               0 :   if (!table.ReadR64(&file->head->created) ||
          66               0 :       !table.ReadR64(&file->head->modified)) {
          67               0 :     return OTS_FAILURE();
          68                 :   }
          69                 :
          70               0 :   if (!table.ReadS16(&file->head->xmin) ||
          71               0 :       !table.ReadS16(&file->head->ymin) ||
          72               0 :       !table.ReadS16(&file->head->xmax) ||
          73               0 :       !table.ReadS16(&file->head->ymax)) {
          74               0 :     return OTS_FAILURE();
          75                 :   }
          76                 :
          77               0 :   if (file->head->xmin > file->head->xmax) {
          78               0 :     return OTS_FAILURE();
          79                 :   }
          80               0 :   if (file->head->ymin > file->head->ymax) {
          81               0 :     return OTS_FAILURE();
          82                 :   }
          83                 :
          84               0 :   if (!table.ReadU16(&file->head->mac_style)) {
          85               0 :     return OTS_FAILURE();
          86                 :   }
          87                 :
          88                 :   // We allow bits 0..6
          89               0 :   file->head->mac_style &= 0x7f;
          90                 :
          91               0 :   if (!table.ReadU16(&file->head->min_ppem)) {
          92               0 :     return OTS_FAILURE();
          93                 :   }
          94                 :
          95                 :   // We don't care about the font direction hint
          96               0 :   if (!table.Skip(2)) {
          97               0 :     return OTS_FAILURE();
          98                 :   }
          99                 :
         100               0 :   if (!table.ReadS16(&file->head->index_to_loc_format)) {
         101               0 :     return OTS_FAILURE();
         102                 :   }
         103               0 :   if (file->head->index_to_loc_format < 0 ||
         104                 :       file->head->index_to_loc_format > 1) {
         105               0 :     return OTS_FAILURE();
         106                 :   }
         107                 :
         108                 :   int16_t glyph_data_format;
         109               0 :   if (!table.ReadS16(&glyph_data_format) ||
         110                 :       glyph_data_format) {
         111               0 :     return OTS_FAILURE();
         112                 :   }
         113                 :
         114               0 :   return true;
         115                 : }
         116                 :
         117               0 : bool ots_head_should_serialise(OpenTypeFile *file) {
         118               0 :   return file->head != NULL;
         119                 : }
         120                 :
         121               0 : bool ots_head_serialise(OTSStream *out, OpenTypeFile *file) {
         122               0 :   if (!out->WriteU32(0x00010000) ||
         123               0 :       !out->WriteU32(file->head->revision) ||
         124               0 :       !out->WriteU32(0) ||  // check sum not filled in yet
         125               0 :       !out->WriteU32(0x5F0F3CF5) ||
         126               0 :       !out->WriteU16(file->head->flags) ||
         127               0 :       !out->WriteU16(file->head->ppem) ||
         128               0 :       !out->WriteR64(file->head->created) ||
         129               0 :       !out->WriteR64(file->head->modified) ||
         130               0 :       !out->WriteS16(file->head->xmin) ||
         131               0 :       !out->WriteS16(file->head->ymin) ||
         132               0 :       !out->WriteS16(file->head->xmax) ||
         133               0 :       !out->WriteS16(file->head->ymax) ||
         134               0 :       !out->WriteU16(file->head->mac_style) ||
         135               0 :       !out->WriteU16(file->head->min_ppem) ||
         136               0 :       !out->WriteS16(2) ||
         137               0 :       !out->WriteS16(file->head->index_to_loc_format) ||
         138               0 :       !out->WriteS16(0)) {
         139               0 :     return OTS_FAILURE();
         140                 :   }
         141                 :
         142               0 :   return true;
         143                 : }
         144                 :
         145               0 : void ots_head_free(OpenTypeFile *file) {
         146               0 :   delete file->head;
         147               0 : }
         148                 :
         149                 : }  // namespace

Generated by: LCOV version 1.7