LCOV - app.info - gfx/graphite2/src/FeatureMap.cpp

LCOV - code coverage report
| Current view: | directory - gfx/graphite2/src - FeatureMap.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 126 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 8 | 0 | 0.0 %

           1                 : /*  GRAPHITE2 LICENSING
           2                 :
           3                 :     Copyright 2010, SIL International
           4                 :     All rights reserved.
           5                 :
           6                 :     This library is free software; you can redistribute it and/or modify
           7                 :     it under the terms of the GNU Lesser General Public License as published
           8                 :     by the Free Software Foundation; either version 2.1 of License, or
           9                 :     (at your option) any later version.
          10                 :
          11                 :     This program is distributed in the hope that it will be useful,
          12                 :     but WITHOUT ANY WARRANTY; without even the implied warranty of
          13                 :     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
          14                 :     Lesser General Public License for more details.
          15                 :
          16                 :     You should also have received a copy of the GNU Lesser General Public
          17                 :     License along with this library in the file named "LICENSE".
          18                 :     If not, write to the Free Software Foundation, 51 Franklin Street,
          19                 :     Suite 500, Boston, MA 02110-1335, USA or visit their web page on the
          20                 :     internet at http://www.fsf.org/licenses/lgpl.html.
          21                 :
          22                 : Alternatively, the contents of this file may be used under the terms of the
          23                 : Mozilla Public License (http://mozilla.org/MPL) or the GNU General Public
          24                 : License, as published by the Free Software Foundation, either version 2
          25                 : of the License or (at your option) any later version.
          26                 : */
          27                 : #include <cstring>
          28                 :
          29                 : #include "inc/Main.h"
          30                 : #include "inc/Endian.h"
          31                 : #include "inc/FeatureMap.h"
          32                 : #include "inc/FeatureVal.h"
          33                 : #include "graphite2/Font.h"
          34                 : #include "inc/TtfUtil.h"
          35                 : #include <cstdlib>
          36                 : #include "inc/Face.h"
          37                 :
          38                 :
          39                 : using namespace graphite2;
          40                 :
          41                 : namespace
          42                 : {
          43               0 :         static int cmpNameAndFeatures(const void *ap, const void *bp)
          44                 :         {
          45               0 :                 const NameAndFeatureRef & a = *static_cast<const NameAndFeatureRef *>(ap),
          46               0 :                                                                 & b = *static_cast<const NameAndFeatureRef *>(bp);
          47               0 :                 return (a < b ? -1 : (b < a ? 1 : 0));
          48                 :         }
          49                 : }
          50                 :
          51                 :
          52               0 : bool FeatureMap::readFeats(const Face & face)
          53                 : {
          54                 :     size_t lFeat;
          55               0 :     const byte *pFeat = face.getTable(TtfUtil::Tag::Feat, &lFeat);
          56               0 :     const byte *pOrig = pFeat;
          57               0 :     uint16 *defVals=0;
          58                 :     uint32 version;
          59               0 :     if (!pFeat) return true;
          60               0 :     if (lFeat < 12) return false;
          61                 :
          62               0 :     version = be::read<uint32>(pFeat);
          63               0 :     if (version < 0x00010000) return false;
          64               0 :     m_numFeats = be::read<uint16>(pFeat);
          65               0 :     be::skip<uint16>(pFeat);
          66               0 :     be::skip<uint32>(pFeat);
          67               0 :     if (m_numFeats * 16U + 12 > lFeat) { m_numFeats = 0; return false; }             //defensive
          68               0 :     if (!m_numFeats) return true;
          69               0 :     m_feats = new FeatureRef[m_numFeats];
          70               0 :     defVals = gralloc<uint16>(m_numFeats);
          71               0 :     byte currIndex = 0;
          72               0 :     byte currBits = 0;     //to cause overflow on first Feature
          73                 :
          74               0 :     for (int i = 0, ie = m_numFeats; i != ie; i++)
          75                 :     {
          76                 :         uint32 name;
          77               0 :         if (version < 0x00020000)
          78               0 :             name = be::read<uint16>(pFeat);
          79                 :         else
          80               0 :             name = be::read<uint32>(pFeat);
          81               0 :         uint16 numSet = be::read<uint16>(pFeat);
          82                 :
          83                 :         uint32 offset;
          84               0 :         if (version < 0x00020000)
          85               0 :             offset = be::read<uint32>(pFeat);
          86                 :         else
          87                 :         {
          88               0 :             be::skip<uint16>(pFeat);
          89               0 :             offset = be::read<uint32>(pFeat);
          90                 :         }
          91               0 :         if (offset > lFeat)
          92                 :         {
          93               0 :             free(defVals);
          94               0 :             return false;
          95                 :         }
          96               0 :         uint16 flags = be::read<uint16>(pFeat);
          97               0 :         uint16 uiName = be::read<uint16>(pFeat);
          98               0 :         const byte *pSet = pOrig + offset;
          99               0 :         uint16 maxVal = 0;
         100                 :
         101               0 :         if (numSet == 0)
         102                 :         {
         103               0 :             --m_numFeats;
         104               0 :             continue;
         105                 :         }
         106                 :
         107               0 :         if (offset + numSet * 4 > lFeat) return false;
         108               0 :         FeatureSetting *uiSet = gralloc<FeatureSetting>(numSet);
         109               0 :         for (int j = 0; j < numSet; j++)
         110                 :         {
         111               0 :             int16 val = be::read<int16>(pSet);
         112               0 :             if (val > maxVal) maxVal = val;
         113               0 :             if (j == 0) defVals[i] = val;
         114               0 :             uint16 label = be::read<uint16>(pSet);
         115               0 :             new (uiSet + j) FeatureSetting(label, val);
         116                 :         }
         117               0 :         uint32 mask = 1;
         118               0 :         byte bits = 0;
         119               0 :         for (bits = 0; bits < 32; bits++, mask <<= 1)
         120                 :         {
         121               0 :             if (mask > maxVal)
         122                 :             {
         123               0 :                 if (bits + currBits > 32)
         124                 :                 {
         125               0 :                     currIndex++;
         126               0 :                     currBits = 0;
         127               0 :                     mask = 2;
         128                 :                 }
         129               0 :                 ::new (m_feats + i) FeatureRef (currBits, currIndex,
         130                 :                                                (mask - 1) << currBits, flags,
         131               0 :                                                name, uiName, numSet, uiSet, &face);
         132               0 :                 currBits += bits;
         133               0 :                 break;
         134                 :             }
         135                 :         }
         136                 :     }
         137               0 :     m_defaultFeatures = new Features(currIndex + 1, *this);
         138               0 :     m_pNamedFeats = new NameAndFeatureRef[m_numFeats];
         139               0 :     for (int i = 0; i < m_numFeats; i++)
         140                 :     {
         141               0 :         m_feats[i].applyValToFeature(defVals[i], *m_defaultFeatures);
         142               0 :         m_pNamedFeats[i] = m_feats+i;
         143                 :     }
         144                 :
         145               0 :     free(defVals);
         146                 :
         147               0 :     qsort(m_pNamedFeats, m_numFeats, sizeof(NameAndFeatureRef), &cmpNameAndFeatures);
         148                 :
         149               0 :     return true;
         150                 : }
         151                 :
         152               0 : bool SillMap::readFace(const Face & face)
         153                 : {
         154               0 :     if (!m_FeatureMap.readFeats(face)) return false;
         155               0 :     if (!readSill(face)) return false;
         156               0 :     return true;
         157                 : }
         158                 :
         159                 :
         160               0 : bool SillMap::readSill(const Face & face)
         161                 : {
         162                 :     size_t lSill;
         163               0 :     const byte *pSill = face.getTable(TtfUtil::Tag::Sill, &lSill);
         164               0 :     const byte *pBase = pSill;
         165                 :
         166               0 :     if (!pSill) return true;
         167               0 :     if (lSill < 12) return false;
         168               0 :     if (be::read<uint32>(pSill) != 0x00010000UL) return false;
         169               0 :     m_numLanguages = be::read<uint16>(pSill);
         170               0 :     m_langFeats = new LangFeaturePair[m_numLanguages];
         171               0 :     if (!m_langFeats || !m_FeatureMap.m_numFeats) { m_numLanguages = 0; return true; }        //defensive
         172                 :
         173               0 :     pSill += 6;     // skip the fast search
         174               0 :     if (lSill < m_numLanguages * 8U + 12) return false;
         175                 :
         176               0 :     for (int i = 0; i < m_numLanguages; i++)
         177                 :     {
         178               0 :         uint32 langid = be::read<uint32>(pSill);
         179               0 :         uint16 numSettings = be::read<uint16>(pSill);
         180               0 :         uint16 offset = be::read<uint16>(pSill);
         181               0 :         if (offset + 8U * numSettings > lSill && numSettings > 0) return false;
         182               0 :         Features* feats = new Features(*m_FeatureMap.m_defaultFeatures);
         183               0 :         const byte *pLSet = pBase + offset;
         184                 :
         185               0 :         for (int j = 0; j < numSettings; j++)
         186                 :         {
         187               0 :             uint32 name = be::read<uint32>(pLSet);
         188               0 :             uint16 val = be::read<uint16>(pLSet);
         189               0 :             pLSet += 2;
         190               0 :             const FeatureRef* pRef = m_FeatureMap.findFeatureRef(name);
         191               0 :             if (pRef)
         192               0 :                 pRef->applyValToFeature(val, *feats);
         193                 :         }
         194                 :         //std::pair<uint32, Features *>kvalue = std::pair<uint32, Features *>(langid, feats);
         195                 :         //m_langMap.insert(kvalue);
         196               0 :         m_langFeats[i].m_lang = langid;
         197               0 :         m_langFeats[i].m_pFeatures = feats;
         198                 :     }
         199               0 :     return true;
         200                 : }
         201                 :
         202                 :
         203               0 : Features* SillMap::cloneFeatures(uint32 langname/*0 means default*/) const
         204                 : {
         205               0 :     if (langname)
         206                 :     {
         207                 :         // the number of languages in a font is usually small e.g. 8 in Doulos
         208                 :         // so this loop is not very expensive
         209               0 :         for (uint16 i = 0; i < m_numLanguages; i++)
         210                 :         {
         211               0 :             if (m_langFeats[i].m_lang == langname)
         212               0 :                 return new Features(*m_langFeats[i].m_pFeatures);
         213                 :         }
         214                 :     }
         215               0 :     return new Features (*m_FeatureMap.m_defaultFeatures);
         216                 : }
         217                 :
         218                 :
         219                 :
         220               0 : const FeatureRef *FeatureMap::findFeatureRef(uint32 name) const
         221                 : {
         222                 :     NameAndFeatureRef *it;
         223                 :
         224               0 :     for (it = m_pNamedFeats; it < m_pNamedFeats + m_numFeats; ++it)
         225               0 :         if (it->m_name == name)
         226               0 :             return it->m_pFRef;
         227               0 :     return NULL;
         228                 : }
         229                 :
         230               0 : bool FeatureRef::applyValToFeature(uint16 val, Features & pDest) const
         231                 : {
         232               0 :     if (val>m_max || !m_pFace)
         233               0 :       return false;
         234               0 :     if (pDest.m_pMap==NULL)
         235               0 :       pDest.m_pMap = &m_pFace->theSill().theFeatureMap();
         236                 :     else
         237               0 :       if (pDest.m_pMap!=&m_pFace->theSill().theFeatureMap())
         238               0 :         return false;       //incompatible
         239               0 :     pDest.reserve(m_index);
         240               0 :     pDest[m_index] &= ~m_mask;
         241               0 :     pDest[m_index] |= (uint32(val) << m_bits);
         242               0 :     return true;
         243                 : }
         244                 :
         245               0 : uint16 FeatureRef::getFeatureVal(const Features& feats) const
         246                 : {
         247               0 :   if (m_index < feats.size() && &m_pFace->theSill().theFeatureMap()==feats.m_pMap)
         248               0 :     return (feats[m_index] & m_mask) >> m_bits;
         249                 :   else
         250               0 :     return 0;
         251                 : }
         252                 :
         253                 :

Generated by: LCOV version 1.7