Add CFF CIDFont support

In this case CIDs are not equal to GIDs in font processing.

DEVSIX-5767

Author: yulian-gaponenko

io/src/main/java/com/itextpdf/io/font/CFFFont.java

@@ -453,10 +453,7 @@ public void xref() {
             offItem.set(this.myOffset-indexBase.myOffset+1);
         }
     }
-    /**
-     * TODO To change the template for this generated type comment go to
-     * Window - Preferences - Java - Code Generation - Code and Comments
-     */
+
     protected static final class SubrMarkerItem extends Item {
         private OffsetItem offItem;
         private IndexBaseItem indexBase;
@@ -951,6 +948,9 @@ public byte[] getCID(String fontName)
         return b;
     }
 
+    public boolean isCID() {
+        return isCID(getNames()[0]);
+    }
 
     public boolean isCID(String fontName) {
         int j;
@@ -1024,6 +1024,8 @@ protected final class Font {
         public int[] PrivateSubrsOffset;
         public int[][] PrivateSubrsOffsetsArray;
         public int[]       SubrsOffsets;
+
+        public int[] gidToCid;
     }
     // Changed from private to protected by Ygal&Oren
     protected Font[] fonts;

io/src/main/java/com/itextpdf/io/font/CFFFontSubset.java

@@ -48,6 +48,7 @@ This file is part of the iText (R) project.
 import com.itextpdf.io.util.GenericArray;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
@@ -166,9 +167,16 @@ public class CFFFontSubset extends CFFFont {
      * C'tor for CFFFontSubset
      *
      * @param cff        - The font file
-     * @param GlyphsUsed - a Map that contains the glyph used in the subset
      */
+    CFFFontSubset(byte[] cff) {
+        this(cff, Collections.<Integer>emptySet(), true);
+    }
+
     public CFFFontSubset(byte[] cff, Set<Integer> GlyphsUsed) {
+        this(cff, GlyphsUsed, false);
+    }
+
+    CFFFontSubset(byte[] cff, Set<Integer> GlyphsUsed, boolean isCidParsingRequired) {
         // Use CFFFont c'tor in order to parse the font file.
         super(cff);
         this.GlyphsUsed = GlyphsUsed;
@@ -187,6 +195,10 @@ public CFFFontSubset(byte[] cff, Set<Integer> GlyphsUsed) {
             // For each font save the offset array of the charstring
             fonts[i].charstringsOffsets = getIndex(fonts[i].charstringsOffset);
 
+            if (isCidParsingRequired) {
+                initGlyphIdToCharacterIdArray(i, fonts[i].nglyphs, fonts[i].charsetOffset);
+            }
+
             // Process the FDSelect if exist
             if (fonts[i].fdselectOffset >= 0) {
                 // Process the FDSelect
@@ -535,8 +547,8 @@ protected void BuildSubrUsed(int Font, int FD, int SubrOffset, int[] SubrsOffset
         int LBias = CalcBias(SubrOffset, Font);
 
         // For each glyph used find its GID, start & end pos
-        for (int i = 0; i < glyphsInList.size(); i++) {
-            int glyph = (int) glyphsInList.get(i);
+        for (Integer usedGlyph : glyphsInList) {
+            int glyph = (int) usedGlyph;
             int Start = fonts[Font].charstringsOffsets[glyph];
             int End = fonts[Font].charstringsOffsets[glyph + 1];
 
@@ -1704,5 +1716,77 @@ void CreateNonCIDSubrs(int Font, IndexBaseItem PrivateBase, OffsetItem Subrs) {
             OutputList.addLast(new RangeItem(new RandomAccessFileOrArray(rasFactory.createSource(NewSubrsIndexNonCID)), 0, NewSubrsIndexNonCID.length));
         }
     }
+
+    /**
+     * Returns the CID to which specified GID is mapped.
+     *
+     * @param gid glyph identifier
+     *
+     * @return CID value
+     */
+    int getCidForGlyphId(int gid) {
+        return getCidForGlyphId(0, gid);
+    }
+
+    /**
+     * Returns the CID to which specified GID is mapped.
+     *
+     * @param fontIndex index of font for which cid-gid mapping is to be identified
+     * @param gid glyph identifier
+     *
+     * @return CID value
+     */
+    int getCidForGlyphId(int fontIndex, int gid) {
+        if (fonts[fontIndex].gidToCid == null) {
+            return gid;
+        }
+
+        // gidToCid mapping starts with value corresponding to gid == 1, becuase .notdef is omitted
+        int index = gid - 1;
+        return index >= 0 && index < fonts[fontIndex].gidToCid.length
+                ? fonts[fontIndex].gidToCid[index]
+                : gid;
+    }
+
+    /**
+     * Creates glyph-to-character id array.
+     *
+     * @param fontIndex   index of font for which charsets data is to be parsed
+     * @param numOfGlyphs number of glyphs in the font
+     * @param offset      the offset to charsets data
+     */
+    private void initGlyphIdToCharacterIdArray(int fontIndex, int numOfGlyphs, int offset) {
+        // Seek charset offset
+        seek(offset);
+
+        // Read the format
+        int format = getCard8();
+
+        // .notdef is omitted, therefore remaining number of elements is one less than overall number
+        int numOfElements = numOfGlyphs - 1;
+        fonts[fontIndex].gidToCid = new int[numOfElements];
+
+        switch (format) {
+            case 0:
+                for (int i = 0; i < numOfElements; i++) {
+                    int cid = getCard16();
+                    fonts[fontIndex].gidToCid[i] = cid;
+                }
+                break;
+            case 1:
+            case 2:
+                int start = 0;
+                while (start < numOfElements) {
+                    int first = getCard16();
+                    int nLeft = format == 1 ? getCard8() : getCard16();
+                    for (int i = 0; i <= nLeft && start < numOfElements; i++) {
+                        fonts[fontIndex].gidToCid[start++] = first + i;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
 }
 

io/src/main/java/com/itextpdf/io/font/GidAwareGlyph.java

@@ -0,0 +1,41 @@
+/*
+    This file is part of the iText (R) project.
+    Copyright (c) 1998-2022 iText Group NV
+    Authors: iText Software.
+
+    This program is offered under a commercial and under the AGPL license.
+    For commercial licensing, contact us at https://itextpdf.com/sales.  For AGPL licensing, see below.
+
+    AGPL licensing:
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.itextpdf.io.font;
+
+import com.itextpdf.io.font.otf.Glyph;
+
+class GidAwareGlyph extends Glyph {
+    private int gid;
+
+    public GidAwareGlyph(int code, int width, int unicode, int[] bbox) {
+        super(code, width, unicode, bbox);
+    }
+
+    public void setGid(int index) {
+        this.gid = index;
+    }
+
+    public int getGid() {
+        return gid;
+    }
+}

io/src/main/java/com/itextpdf/io/font/TrueTypeFont.java

@@ -43,15 +43,15 @@ This file is part of the iText (R) project.
  */
 package com.itextpdf.io.font;
 
+import com.itextpdf.commons.utils.MessageFormatUtil;
 import com.itextpdf.io.exceptions.IOException;
-import com.itextpdf.io.logs.IoLogMessageConstant;
 import com.itextpdf.io.font.constants.TrueTypeCodePages;
 import com.itextpdf.io.font.otf.Glyph;
 import com.itextpdf.io.font.otf.GlyphPositioningTableReader;
 import com.itextpdf.io.font.otf.GlyphSubstitutionTableReader;
 import com.itextpdf.io.font.otf.OpenTypeGdefTableReader;
+import com.itextpdf.io.logs.IoLogMessageConstant;
 import com.itextpdf.io.util.IntHashtable;
-import com.itextpdf.commons.utils.MessageFormatUtil;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -60,6 +60,7 @@ This file is part of the iText (R) project.
 import java.util.Objects;
 import java.util.Set;
 import java.util.SortedSet;
+import java.util.stream.Collectors;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -214,6 +215,29 @@ public byte[] getSubset(Set<Integer> glyphs, boolean subset) {
         }
     }
 
+    /**
+     * Maps a set of glyph CIDs (as used in PDF file) to corresponding GID values
+     * (as a glyph primary identifier in the font file).
+     * This call is only meaningful for fonts that return true for {@link #isCff()}.
+     * For other types of fonts, GID and CID are always the same, so that call would essentially
+     * return a set of the same values.
+     *
+     * @param glyphs a set of glyph CIDs
+     *
+     * @return a set of glyph ids corresponding to the passed glyph CIDs
+     */
+    public Set<Integer> mapGlyphsCidsToGids(Set<Integer> glyphs) {
+        return glyphs.stream()
+                .map((Integer i) -> {
+                    Glyph usedGlyph = getGlyphByCode(i);
+                    if (usedGlyph instanceof GidAwareGlyph) {
+                        return ((GidAwareGlyph) usedGlyph).getGid();
+                    }
+                    return i;
+                })
+                .collect(Collectors.toSet());
+    }
+
     protected void readGdefTable() throws java.io.IOException {
         int[] gdef = fontParser.tables.get("GDEF");
         if (gdef != null) {
@@ -299,6 +323,10 @@ private void initializeFontProperties() throws java.io.IOException {
         unicodeToGlyph = new LinkedHashMap<>(cmap.size());
         codeToGlyph = new LinkedHashMap<>(numOfGlyphs);
         avgWidth = 0;
+        CFFFontSubset cffFontSubset = null;
+        if (isCff()) {
+            cffFontSubset = new CFFFontSubset(getFontStreamBytes());
+        }
         for (int charCode : cmap.keySet()) {
             int index = cmap.get(charCode)[0];
             if (index >= numOfGlyphs) {
@@ -307,12 +335,24 @@ private void initializeFontProperties() throws java.io.IOException {
                         getFontNames().getFontName(), index));
                 continue;
             }
-            Glyph glyph = new Glyph(index, glyphWidths[index], charCode, bBoxes != null ? bBoxes[index] : null);
+            int cid;
+            Glyph glyph;
+            int[] glyphBBox = bBoxes != null ? bBoxes[index] : null;
+            if (cffFontSubset != null && cffFontSubset.isCID()) {
+                cid = cffFontSubset.getCidForGlyphId(index);
+                GidAwareGlyph cffGlyph = new GidAwareGlyph(cid, glyphWidths[index], charCode, glyphBBox);
+                cffGlyph.setGid(index);
+                glyph = cffGlyph;
+            } else {
+                cid = index;
+                glyph = new Glyph(cid, glyphWidths[index], charCode, glyphBBox);
+            }
+
             unicodeToGlyph.put(charCode, glyph);
             // This is done on purpose to keep the mapping to glyphs with smaller unicode values, in contrast with
             // larger values which often represent different forms of other characters.
-            if (!codeToGlyph.containsKey(index)) {
-                codeToGlyph.put(index, glyph);
+            if (!codeToGlyph.containsKey(cid)) {
+                codeToGlyph.put(cid, glyph);
             }
             avgWidth += glyph.getWidth();
         }

io/src/main/java/com/itextpdf/io/font/otf/Glyph.java

@@ -49,8 +49,6 @@
 import java.util.Arrays;
 
 public class Glyph {
-
-
     private static final char REPLACEMENT_CHARACTER = '\ufffd';
     private static final char[] REPLACEMENT_CHARACTERS = new char[] {REPLACEMENT_CHARACTER};
     private static final String REPLACEMENT_CHARACTER_STRING = String.valueOf(REPLACEMENT_CHARACTER);