feat: add support for Ideographic Variation Sequences (IVS) in TrueType fonts

Author: obo

openpdf/src/main/java/com/lowagie/text/pdf/FontDetails.java

@@ -54,6 +54,7 @@
 import com.lowagie.text.Utilities;
 import java.awt.font.GlyphVector;
 import java.io.UnsupportedEncodingException;
+import java.util.Arrays;
 import java.util.HashMap;
 
 /**
@@ -222,6 +223,70 @@ byte[] convertToBytes(String text, TextRenderingOptions options) {
                         b = s.getBytes(CJKFont.CJK_ENCODING);
 
                     } else {
+                        //ivs font handler,Simply judge whether it is IVS font or not
+                        if (mayContainIVS(text)) {
+                            glyph = new char[len * 2];
+                            for (int k = 0; k < len; ) {
+                                int baseCp;
+                                int charCount;
+                                if (k < len - 1 && Character.isHighSurrogate(text.charAt(k))
+                                        && Character.isLowSurrogate(text.charAt(k + 1))) {
+                                    baseCp = Character.toCodePoint(text.charAt(k), text.charAt(k + 1));
+                                    charCount = 2;
+                                } else {
+                                    baseCp = text.charAt(k);
+                                    charCount = 1;
+                                }
+
+                                int vsCp = -1;
+                                int vsCharCount = 0;
+                                int nextIndex = k + charCount;
+
+                                if (nextIndex < len) {
+                                    int potentialVs = text.charAt(nextIndex);
+                                    if (isVariationSelector(potentialVs)) {
+                                        vsCp = potentialVs;
+                                        vsCharCount = 1;
+                                    }
+                                    else if (nextIndex < len - 1
+                                            && Character.isHighSurrogate(text.charAt(nextIndex))
+                                            && Character.isLowSurrogate(text.charAt(nextIndex + 1))) {
+                                        int potentialVsPair = Character.toCodePoint(
+                                                text.charAt(nextIndex), text.charAt(nextIndex + 1));
+                                        if (isVariationSelector(potentialVsPair)) {
+                                            vsCp = potentialVsPair;
+                                            vsCharCount = 2;
+                                        }
+                                    }
+                                }
+
+                                if (vsCp != -1) {
+                                    int[] format14Metrics = this.ttu.getFormat14MetricsTT(baseCp, vsCp);
+                                    if (format14Metrics != null) {
+                                        int gl = format14Metrics[0];
+                                        if (!this.longTag.containsKey(gl)) {
+                                            this.longTag.put(gl, new int[]{gl, format14Metrics[1], baseCp, vsCp});
+                                        }
+                                        glyph[i++] = (char) gl;
+                                        k += charCount + vsCharCount;
+                                        continue;
+                                    }
+                                }
+                                metrics = this.ttu.getMetricsTT(baseCp);
+                                if (metrics != null) {
+                                    int gl = metrics[0];
+                                    if (!this.longTag.containsKey(gl)) {
+                                        this.longTag.put(gl, new int[]{gl, metrics[1], baseCp});
+                                    }
+                                    glyph[i++] = (char) gl;
+                                }
+
+                                k += charCount;
+                            }
+                            glyph = Arrays.copyOfRange(glyph, 0, i);
+                            b = convertCharsToBytes(glyph);
+                            break;
+                        }
                         String fileName = ((TrueTypeFontUnicode) getBaseFont()).fileName;
                         if (options.isGlyphSubstitutionEnabled() && FopGlyphProcessor.isFopSupported()
                                 && (fileName != null && fileName.length() > 0
@@ -241,6 +306,43 @@ byte[] convertToBytes(String text, TextRenderingOptions options) {
         return b;
     }
 
+    private static boolean isVariationSelector(int codePoint) {
+        return (codePoint >= 0xFE00 && codePoint <= 0xFE0F)
+                || (codePoint >= 0xE0100 && codePoint <= 0xE01EF);
+    }
+
+    /**
+     * Quickly determine whether the text may contain IVS (to decide whether to use the IVS dedicated path)
+     * Note: This means "may contain," not "must contain"—err on the side of caution to avoid omissions
+     */
+    private static boolean mayContainIVS(String text) {
+        if (text == null) return false;
+
+        for (int i = 0; i < text.length(); i++) {
+            char c = text.charAt(i);
+
+            if (c >= '\uFE00' && c <= '\uFE0F') {
+                return true;
+            }
+
+            if (c >= '\udb40' && c <= '\udb43') {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private byte[] convertCharsToBytes(char[] chars) {
+        byte[] result = new byte[chars.length * 2];
+
+        for (int i = 0; i < chars.length; ++i) {
+            result[2 * i] = (byte) (chars[i] / 256);
+            result[2 * i + 1] = (byte) (chars[i] % 256);
+        }
+
+        return result;
+    }
+
     private byte[] convertToBytesWithGlyphs(String text) throws UnsupportedEncodingException {
         int len = text.length();
         int[] metrics = null;

openpdf/src/main/java/com/lowagie/text/pdf/TrueTypeFont.java

@@ -206,6 +206,8 @@ class TrueTypeFont extends BaseFont {
 
     protected HashMap<Integer, int[]> cmapExt;
 
+    protected HashMap<String, int[]> cmap05;
+
     /**
      * The map containing the kerning information. It represents the content of table 'kern'. The key is an
      * <CODE>Integer</CODE> where the top 16 bits are the glyph number for the first character and the lower 16 bits
@@ -797,6 +799,7 @@ void readCMaps() throws DocumentException, IOException {
         int map31 = 0;
         int map30 = 0;
         int mapExt = 0;
+        int map05 = 0;
         for (int k = 0; k < num_tables; ++k) {
             int platId = rf.readUnsignedShort();
             int platSpecId = rf.readUnsignedShort();
@@ -808,6 +811,8 @@ void readCMaps() throws DocumentException, IOException {
                 map31 = offset;
             } else if (platId == 3 && platSpecId == 10) {
                 mapExt = offset;
+            } else if (platId == 0 && platSpecId == 5) {
+                map05 = offset;
             }
             if (platId == 1 && platSpecId == 0) {
                 map10 = offset;
@@ -860,6 +865,87 @@ void readCMaps() throws DocumentException, IOException {
                     break;
             }
         }
+        if (map05 > 0) {
+            int format14Location = table_location[0] + map05;
+            this.rf.seek((long) format14Location);
+            int format = this.rf.readUnsignedShort();
+            if (format == 14) {
+                this.cmap05 = this.readFormat14(format14Location);
+            }
+        }
+    }
+
+    HashMap<String, int[]> readFormat14(int format14Location) throws IOException {
+        HashMap<String, int[]> result = new HashMap<>();
+        long startPosition = this.rf.getFilePointer() - 4; // 回退到读取 byteLength 之前的位置
+
+        int byteLength = this.rf.readInt();
+        int numVarSelectorRecords = this.rf.readInt();
+
+        if (numVarSelectorRecords < 0 || numVarSelectorRecords > 10000) {
+            throw new IOException("Invalid numVarSelectorRecords: " + numVarSelectorRecords);
+        }
+
+        Map<Integer, Integer> nonDefaultOffsetMap = new HashMap<>();
+
+        for (int i = 0; i < numVarSelectorRecords; ++i) {
+            byte[] input = new byte[3];
+            this.rf.read(input);
+            int selectorUnicodeValue = this.byte2int(input, 3);
+            int defaultUVSOffset = this.rf.readInt();
+            int nonDefaultUVSOffset = this.rf.readInt();
+
+            if (nonDefaultUVSOffset > 0) { // 只处理非零偏移
+                nonDefaultOffsetMap.put(selectorUnicodeValue, nonDefaultUVSOffset);
+            }
+        }
+
+        for (Map.Entry<Integer, Integer> entry : nonDefaultOffsetMap.entrySet()) {
+            Integer selectorUnicodeValue = entry.getKey();
+            int nonDefaultUVSOffset = entry.getValue();
+
+            this.rf.seek((long) (format14Location + nonDefaultUVSOffset));
+            int mappingNums = this.rf.readInt();
+
+            if (mappingNums < 0 || mappingNums > 10000) {
+                // invalid mapping
+                continue;
+            }
+
+            for (int i = 0; i < mappingNums; ++i) {
+                byte[] input = new byte[3];
+                this.rf.read(input);
+                int unicodeValue = this.byte2int(input, 3);
+                int glyphId = this.rf.readUnsignedShort();
+                result.put(unicodeValue + "_" + selectorUnicodeValue,
+                        new int[]{glyphId, this.getGlyphWidth(glyphId)});
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 将大端序（Big-Endian）的字节数组转换为无符号整数（最多4字节）
+     * @param data 输入字节数组
+     * @param n 读取字节数（1~4）
+     * @return 对应的非负整数值
+     */
+    public int byte2int(byte[] data, int n) {
+        if (data == null || n <= 0 || n > 4 || data.length < n) {
+            return 0;
+        }
+        int result = 0;
+        for (int i = 0; i < n; i++) {
+            result = (result << 8) | (data[i] & 0xFF); // & 0xFF 确保无符号
+        }
+        return result;
+    }
+
+    public int[] getFormat14MetricsTT(int char1, int char2) {
+        if (this.cmap05 != null) {
+            return this.cmap05.get(char1 + "_" + char2);
+        }
+        return null;
     }
 
     HashMap<Integer, int[]> readFormat12() throws IOException {
@@ -1419,6 +1505,9 @@ public int[] getMetricsTT(int c) {
         if (cmap10 != null) {
             return cmap10.get(c);
         }
+        if (cmap05 != null) {
+            return cmap05.get(c);
+        }
         return null;
     }
 

openpdf/src/main/java/com/lowagie/text/pdf/TrueTypeFontUnicode.java

@@ -268,7 +268,13 @@ private PdfStream getToUnicode(int[][] metrics) {
             --size;
             int[] metric = metrics[k];
             String fromTo = toHex(metric[0]);
-            buf.append(fromTo).append(fromTo).append(toHex(metric[2])).append('\n');
+            String hexString;
+            if (metric.length == 4) {
+                hexString = toHex(metric[2], metric[3]);
+            } else {
+                hexString = toHex(metric[2]);
+            }
+            buf.append(fromTo).append(fromTo).append(hexString).append('\n');
         }
         buf.append(
                 "endbfrange\n" +
@@ -585,4 +591,27 @@ public int[] getCharBBox(int c) {
         return bboxes[m[0]];
     }
 
+    private String toHex(int char1, int char2) {
+        String hex1;
+        int high;
+        int low;
+        if (char1 < 65536) {
+            hex1 = toHex4(char1);
+        } else {
+            char1 -= 65536;
+            high = char1 / 1024 + '\ud800';
+            low = char1 % 1024 + '\udc00';
+            hex1 = toHex4(high) + toHex4(low);
+        }
+        String hex2;
+        if (char2 < 65536) {
+            hex2 = toHex4(char2);
+        } else {
+            char2 -= 65536;
+            high = char2 / 1024 + '\ud800';
+            low = char2 % 1024 + '\udc00';
+            hex2 = toHex4(high) + toHex4(low);
+        }
+        return "[<" + hex1 + hex2 + ">]";
+    }
 }