cid2gid

Author: lambdalemon

playa/font.py

@@ -5,12 +5,14 @@
 """
 
 import logging
+import struct
 from io import BytesIO
 from pathlib import Path
 from typing import (
     Dict,
     Iterable,
     List,
+    Mapping,
     Optional,
     Tuple,
     Union,
@@ -61,10 +63,12 @@
     choplist,
     decode_text,
     transform_bbox,
+    IDENTITY_MAPPING,
 )
 
 log = logging.getLogger(__name__)
 LITERAL_STANDARD_ENCODING = LIT("StandardEncoding")
+LITERAL_CIDFONT_TYPE0 = LIT("CIDFontType0")
 
 
 class Font:
@@ -292,12 +296,13 @@ def get_implicit_encoding(
             self.fontfile3 = stream_value(descriptor.get("FontFile3"))
             try:
                 cfffont = CFFFontProgram(self.basefont, BytesIO(self.fontfile3.buffer))
-                self.cfffont = cfffont
-                return {
-                    cid: cfffont.gid2name[gid]
-                    for cid, gid in cfffont.code2gid.items()
-                    if gid in cfffont.gid2name
-                }
+                assert not cfffont.is_cidfont
+                return cfffont.code2name
+            except AssertionError:
+                log.warning(
+                    "Embedded CFFFont %r for Type1 font is a CIDFont", self.fontfile3
+                )
+                return LITERAL_STANDARD_ENCODING
             except Exception:
                 log.debug("Failed to parse CFFFont %r", self.fontfile3, exc_info=True)
                 return LITERAL_STANDARD_ENCODING
@@ -515,6 +520,8 @@ def __init__(
         self,
         spec: Dict[str, PDFObject],
     ) -> None:
+        self.spec = spec
+        self.subtype = resolve1(spec.get("Subtype"))
         self.basefont = get_basefont(spec)
         self.cidsysteminfo = dict_value(spec.get("CIDSystemInfo", {}))
         # These are *supposed* to be ASCII (PDF 1.7 section 9.7.3),
@@ -621,8 +628,44 @@ def __init__(
             self.default_vdisp = 0
             self.positions = {}
             self.vdisps = {}
+
         Font.__init__(self, descriptor, widths, default_width=default_width)
 
+    @property
+    def cid2gid(self) -> Optional[Mapping[int, int]]:
+        """According to PDF 2.0 Sec 9.7.4.2 Glyph selection in CIDFonts:
+        The CID to glyph id mapping, or None in the case of external TrueType
+        font program (Type2 CIDFont), because "...In this case, CIDs shall not
+        participate in glyph selection..."
+        Note that this is not exactly equivalent to the CIDToGIDMap entry,
+        despite what the name might suggest.
+        """
+        if "FontFile2" in self.descriptor:
+            # Type 2, embedded
+            cid2gidmap = resolve1(self.spec.get("CIDToGIDMap"))
+            if isinstance(cid2gidmap, ContentStream):
+                buffer = cid2gidmap.buffer
+                return dict(
+                    enumerate(struct.unpack(">" + "H" * (len(buffer) // 2), buffer))
+                )
+            else:
+                return IDENTITY_MAPPING
+        elif "FontFile3" in self.descriptor:
+            # Type 0, embedded
+            try:
+                fontfile3 = stream_value(self.descriptor.get("FontFile3"))
+                cfffont = CFFFontProgram(self.basefont, BytesIO(fontfile3.buffer))
+                return cfffont.cid2gid if cfffont.is_cidfont else IDENTITY_MAPPING
+            except Exception:
+                log.debug("Failed to parse CFFFont %r", fontfile3, exc_info=True)
+                return IDENTITY_MAPPING
+        elif self.subtype == LITERAL_CIDFONT_TYPE0:
+            # Type 0, external
+            return IDENTITY_MAPPING
+        else:
+            # Type 2, external
+            return None
+
     def get_cmap_from_spec(self, spec: Dict[str, PDFObject]) -> CMapBase:
         """Get cmap from font specification
 

playa/fontprogram.py

@@ -1471,8 +1471,7 @@ def __init__(self, name: str, fp: BinaryIO) -> None:
         self.subr_index = self.INDEX(self.fp)
         # Top DICT DATA
         self.top_dict = self.getdict(self.dict_index[0])
-        if (12, 30) in self.top_dict:
-            raise NotImplementedError("CFF CIDFont not implemented")
+        self.is_cidfont = (12, 30) in self.top_dict
         (charset_pos,) = self.top_dict.get(15, [0])
         (encoding_pos,) = self.top_dict.get(16, [0])
         (charstring_pos,) = self.top_dict.get(17, [0])
@@ -1481,17 +1480,24 @@ def __init__(self, name: str, fp: BinaryIO) -> None:
         self.charstring = self.INDEX(self.fp)
         self.nglyphs = len(self.charstring)
         self._parse_charset(int(charset_pos))
-        self._parse_encoding(int(encoding_pos))
+        if not self.is_cidfont:
+            self.name2gid = {self.getstr(sid): gid for gid, sid in self.gid2sid.items()}
+            self._parse_encoding(int(encoding_pos))
+            self.code2name = {
+                code: self.getstr(self.gid2sid[gid])
+                for code, gid in self.code2gid.items()
+                if gid in self.gid2sid
+            }
+        else:
+            self.cid2gid = {sid: gid for gid, sid in self.gid2sid.items()}
 
     def _parse_encoding(self, encoding_pos: int) -> None:
         # Encodings
         self.code2gid = {}
-        self.gid2code = {}
         if encoding_pos in (0, 1):
             for code, sid in enumerate(self.PREDEFINED_ENCODINGS[encoding_pos]):
                 if gid := self.name2gid.get(self.getstr(sid)):
                     self.code2gid[code] = gid
-                    self.gid2code[gid] = code
             return
         self.fp.seek(encoding_pos)
         (format,) = self.fp.read(1)
@@ -1504,7 +1510,6 @@ def _parse_encoding(self, encoding_pos: int) -> None:
                 struct.unpack("B" * n, self.fp.read(n)), start=1
             ):
                 self.code2gid[code] = gid
-                self.gid2code[gid] = code
         elif format == 1:
             # Format 1
             (n,) = struct.unpack("B", self.fp.read(1))
@@ -1513,7 +1518,6 @@ def _parse_encoding(self, encoding_pos: int) -> None:
                 (first, nleft) = struct.unpack("BB", self.fp.read(2))
                 for code in range(first, first + nleft + 1):
                     self.code2gid[code] = gid
-                    self.gid2code[gid] = code
                     gid += 1
         else:
             raise ValueError("unsupported encoding format: %r" % format)
@@ -1526,13 +1530,12 @@ def _parse_encoding(self, encoding_pos: int) -> None:
 
     def _parse_charset(self, charset_pos: int) -> None:
         # Charsets
-        self.name2gid = {}
-        self.gid2name = {}
+        self.gid2sid = {}
         if charset_pos in (0, 1, 2):
+            if self.is_cidfont:
+                raise ValueError("no predefined charsets for CID CFF fonts")
             for gid, sid in enumerate(self.PREDEFINED_CHARSETS[charset_pos], start=1):
-                sidname = self.getstr(sid)
-                self.name2gid[sidname] = gid
-                self.gid2name[gid] = sidname
+                self.gid2sid[gid] = sid
             return
         self.fp.seek(charset_pos)
         (format,) = self.fp.read(1)
@@ -1543,9 +1546,7 @@ def _parse_charset(self, charset_pos: int) -> None:
             for gid, sid in enumerate(
                 struct.unpack(">" + "H" * n, self.fp.read(2 * n)), start=1
             ):
-                sidname = self.getstr(sid)
-                self.name2gid[sidname] = gid
-                self.gid2name[gid] = sidname
+                self.gid2sid[gid] = sid
         elif format in (1, 2):
             # Format 1 & 2
             range_f = ">HB" if format == 1 else ">HH"
@@ -1554,9 +1555,7 @@ def _parse_charset(self, charset_pos: int) -> None:
             while gid < self.nglyphs:
                 (first, nleft) = struct.unpack(range_f, self.fp.read(range_f_size))
                 for sid in range(first, first + nleft + 1):
-                    sidname = self.getstr(sid)
-                    self.name2gid[sidname] = gid
-                    self.gid2name[gid] = sidname
+                    self.gid2sid[gid] = sid
                     gid += 1
         else:
             raise ValueError("unsupported charset format: %r" % format)

playa/utils.py

@@ -8,6 +8,7 @@
     Iterable,
     Iterator,
     List,
+    Mapping,
     Tuple,
     TypeVar,
     Union,
@@ -687,3 +688,17 @@ def format_int_alpha(value: int) -> str:
 
     result.reverse()
     return "".join(result)
+
+
+class IdentityMapping(Mapping[_T, _T]):
+    def __getitem__(self, key: _T) -> _T:
+        return key
+
+    def __iter__(self) -> Iterator[_T]:
+        yield from ()
+
+    def __len__(self) -> int:
+        return 0
+
+
+IDENTITY_MAPPING: IdentityMapping = IdentityMapping()