Merge branch 'feature/DEVSIX-1058' into develop

Autoported commit.
Original commit hash: [4e4cfb451]

Author: Snipx

itext.tests/itext.kernel.tests/itext/kernel/pdf/EncodingTest.cs

@@ -46,6 +46,7 @@ source product.
 using iText.IO.Font.Constants;
 using iText.Kernel.Font;
 using iText.Kernel.Pdf.Canvas;
+using iText.Kernel.Pdf.Canvas.Parser;
 using iText.Kernel.Utils;
 using iText.Test;
 
@@ -288,5 +289,23 @@ public virtual void SymbolTrueTypeFontSameCharsIdentityTest() {
             NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(outputFolder + fileName, sourceFolder + "cmp_"
                  + fileName, outputFolder, "diff_"));
         }
+
+        /// <exception cref="System.IO.IOException"/>
+        [NUnit.Framework.Test]
+        public virtual void EncodingStreamExtractionTest() {
+            String fileName = sourceFolder + "encodingStream01.pdf";
+            PdfDocument pdfDocument = new PdfDocument(new PdfReader(fileName));
+            String extractedText = PdfTextExtractor.GetTextFromPage(pdfDocument.GetPage(1));
+            NUnit.Framework.Assert.AreEqual("abc", extractedText);
+        }
+
+        /// <exception cref="System.IO.IOException"/>
+        [NUnit.Framework.Test]
+        public virtual void DifferentCodeSpaceRangeLengthsExtractionTest() {
+            String fileName = sourceFolder + "differentCodeSpaceRangeLengths01.pdf";
+            PdfDocument pdfDocument = new PdfDocument(new PdfReader(fileName));
+            String extractedText = PdfTextExtractor.GetTextFromPage(pdfDocument.GetPage(1));
+            NUnit.Framework.Assert.AreEqual("Hello\u7121\u540dworld\u6b98\u528d", extractedText);
+        }
     }
 }

itext.tests/itext.kernel.tests/itext/kernel/pdf/PdfFontTest.cs

@@ -105,6 +105,31 @@ public virtual void CreateDocumentWithKozmin() {
                 "diff_"));
         }
 
+        /// <exception cref="System.IO.IOException"/>
+        /// <exception cref="System.Exception"/>
+        [NUnit.Framework.Test]
+        public virtual void CreateDocumentWithKozminAndDifferentCodespaceRanges() {
+            String filename = destinationFolder + "DocumentWithKozminDifferentCodespaceRanges.pdf";
+            String cmpFilename = sourceFolder + "cmp_DocumentWithKozminDifferentCodespaceRanges.pdf";
+            String title = "Type 0 test";
+            PdfWriter writer = new PdfWriter(filename);
+            writer.SetCompressionLevel(CompressionConstants.NO_COMPRESSION);
+            PdfDocument pdfDoc = new PdfDocument(writer);
+            pdfDoc.GetDocumentInfo().SetAuthor(author).SetCreator(creator).SetTitle(title);
+            PdfFont type0Font = PdfFontFactory.CreateFont("KozMinPro-Regular", "83pv-RKSJ-H", true);
+            NUnit.Framework.Assert.IsTrue(type0Font is PdfType0Font, "Type0Font expected");
+            NUnit.Framework.Assert.IsTrue(type0Font.GetFontProgram() is CidFont, "CidFont expected");
+            PdfPage page = pdfDoc.AddNewPage();
+            PdfCanvas canvas = new PdfCanvas(page);
+            canvas.SaveState().BeginText().MoveText(36, 700).SetFontAndSize(type0Font, 50).ShowText(type0Font.CreateGlyphLine
+                ("Hello\u7121\u540dworld\u6b98\u528d")).EndText().RestoreState();
+            canvas.Release();
+            page.Flush();
+            pdfDoc.Close();
+            NUnit.Framework.Assert.IsNull(new CompareTool().CompareByContent(filename, cmpFilename, destinationFolder, 
+                "diff_"));
+        }
+
         /// <exception cref="System.IO.IOException"/>
         /// <exception cref="System.Exception"/>
         [NUnit.Framework.Test]

itext.tests/itext.kernel.tests/resources/itext/kernel/pdf/EncodingTest/differentCodeSpaceRangeLengths01.pdf

@@ -117,6 +117,10 @@ public const String ENCRYPTED_PAYLOAD_FILE_SPEC_SHALL_HAVE_AFRELATIONSHIP_FILED_
 
         public const String EXISTING_TAG_STRUCTURE_ROOT_IS_NOT_STANDARD = "Existing tag structure of the document has a root of \"{0}\" role in \"{1}\" namespace that is not mapped to the standard role.";
 
+        public const String FAILED_TO_DETERMINE_CID_FONT_SUBTYPE = "Failed to determine CIDFont subtype. The type of CIDFont shall be CIDFontType0 or CIDFontType2.";
+
+        public const String FAILED_TO_PARSE_ENCODING_STREAM = "Failed to parse encoding stream.";
+
         public const String FLUSHED_OBJECT_CONTAINS_FREE_REFERENCE = "Flushed object contains indirect reference which is free. Null object will be written instead.";
 
         public const String FLUSHED_OBJECT_CONTAINS_REFERENCE_WHICH_NOT_REFER_TO_ANY_OBJECT = "Flushed object contains indirect reference which doesn't refer to any other object. Null object will be written instead.";

itext.tests/itext.kernel.tests/resources/itext/kernel/pdf/EncodingTest/encodingStream01.pdf

@@ -42,11 +42,17 @@ source product.
 address: [email protected]
 */
 using System;
+using System.Collections.Generic;
+using Common.Logging;
 using iText.IO.Font.Cmap;
+using iText.IO.Source;
 using iText.IO.Util;
 
 namespace iText.IO.Font {
     public class CMapEncoding {
+        private static readonly IList<byte[]> IDENTITY_H_V_CODESPACE_RANGES = iText.IO.Util.JavaUtil.ArraysAsList(
+            new byte[] { 0, 0 }, new byte[] { (byte)0xff, (byte)0xff });
+
         private String cmap;
 
         private String uniMap;
@@ -59,13 +65,18 @@ public class CMapEncoding {
 
         private IntHashtable code2Cid;
 
+        private IList<byte[]> codeSpaceRanges;
+
         /// <param name="cmap">CMap name.</param>
         public CMapEncoding(String cmap) {
             // true if CMap is Identity-H/V
             this.cmap = cmap;
             if (cmap.Equals(PdfEncodings.IDENTITY_H) || cmap.Equals(PdfEncodings.IDENTITY_V)) {
                 isDirect = true;
             }
+            // Actually this constructor is only called for Identity-H/V cmaps currently.
+            // Even for hypothetical case of non-Identity-H/V, let's use Identity-H/V ranges (two byte ranges) for compatibility with previous behavior
+            this.codeSpaceRanges = IDENTITY_H_V_CODESPACE_RANGES;
         }
 
         /// <param name="cmap">CMap name.</param>
@@ -76,10 +87,25 @@ public CMapEncoding(String cmap, String uniMap) {
             if (cmap.Equals(PdfEncodings.IDENTITY_H) || cmap.Equals(PdfEncodings.IDENTITY_V)) {
                 cid2Uni = FontCache.GetCid2UniCmap(uniMap);
                 isDirect = true;
+                this.codeSpaceRanges = IDENTITY_H_V_CODESPACE_RANGES;
             }
             else {
                 cid2Code = FontCache.GetCid2Byte(cmap);
                 code2Cid = cid2Code.GetReversMap();
+                this.codeSpaceRanges = cid2Code.GetCodeSpaceRanges();
+            }
+        }
+
+        public CMapEncoding(String cmap, byte[] cmapBytes) {
+            this.cmap = cmap;
+            cid2Code = new CMapCidByte();
+            try {
+                CMapParser.ParseCid(cmap, cid2Code, new CMapLocationFromBytes(cmapBytes));
+                code2Cid = cid2Code.GetReversMap();
+                this.codeSpaceRanges = cid2Code.GetCodeSpaceRanges();
+            }
+            catch (System.IO.IOException) {
+                LogManager.GetLogger(GetType()).Error(iText.IO.LogMessageConstant.FAILED_TO_PARSE_ENCODING_STREAM);
             }
         }
 
@@ -126,6 +152,7 @@ public virtual String GetCmapName() {
             return cmap;
         }
 
+        [System.ObsoleteAttribute(@"Will be removed in 7.2. Use GetCmapBytes(int) instead.")]
         public virtual int GetCmapCode(int cid) {
             if (isDirect) {
                 return cid;
@@ -135,6 +162,47 @@ public virtual int GetCmapCode(int cid) {
             }
         }
 
+        public virtual byte[] GetCmapBytes(int cid) {
+            int length = GetCmapBytesLength(cid);
+            byte[] result = new byte[length];
+            FillCmapBytes(cid, result, 0);
+            return result;
+        }
+
+        public virtual int FillCmapBytes(int cid, byte[] array, int offset) {
+            if (isDirect) {
+                array[offset++] = (byte)((cid & 0xff00) >> 8);
+                array[offset++] = (byte)(cid & 0xff);
+            }
+            else {
+                byte[] bytes = cid2Code.Lookup(cid);
+                for (int i = 0; i < bytes.Length; i++) {
+                    array[offset++] = bytes[i];
+                }
+            }
+            return offset;
+        }
+
+        public virtual void FillCmapBytes(int cid, ByteBuffer buffer) {
+            if (isDirect) {
+                buffer.Append((byte)((cid & 0xff00) >> 8));
+                buffer.Append((byte)(cid & 0xff));
+            }
+            else {
+                byte[] bytes = cid2Code.Lookup(cid);
+                buffer.Append(bytes);
+            }
+        }
+
+        public virtual int GetCmapBytesLength(int cid) {
+            if (isDirect) {
+                return 2;
+            }
+            else {
+                return cid2Code.Lookup(cid).Length;
+            }
+        }
+
         public virtual int GetCidCode(int cmapCode) {
             if (isDirect) {
                 return cmapCode;
@@ -144,6 +212,28 @@ public virtual int GetCidCode(int cmapCode) {
             }
         }
 
+        public virtual bool ContainsCodeInCodeSpaceRange(int code, int length) {
+            for (int i = 0; i < codeSpaceRanges.Count; i += 2) {
+                if (length == codeSpaceRanges[i].Length) {
+                    int mask = 0xff;
+                    int totalShift = 0;
+                    byte[] low = codeSpaceRanges[i];
+                    byte[] high = codeSpaceRanges[i + 1];
+                    bool fitsIntoRange = true;
+                    for (int ind = length - 1; ind >= 0; ind--, totalShift += 8, mask <<= 8) {
+                        int actualByteValue = (code & mask) >> totalShift;
+                        if (!(actualByteValue >= (0xff & low[ind]) && actualByteValue <= (0xff & high[ind]))) {
+                            fitsIntoRange = false;
+                        }
+                    }
+                    if (fitsIntoRange) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+
         private static int ToInteger(byte[] bytes) {
             int result = 0;
             foreach (byte b in bytes) {

itext.tests/itext.kernel.tests/resources/itext/kernel/pdf/PdfFontTest/cmp_DocumentWithKozminDifferentCodespaceRanges.pdf

@@ -90,6 +90,9 @@ internal virtual void SetSupplement(int supplement) {
 
         internal abstract void AddChar(String mark, CMapObject code);
 
+        internal virtual void AddCodeSpaceRange(byte[] low, byte[] high) {
+        }
+
         internal virtual void AddRange(String from, String to, CMapObject code) {
             byte[] a1 = DecodeStringToByte(from);
             byte[] a2 = DecodeStringToByte(to);

itext/itext.io/itext/io/LogMessageConstant.cs

@@ -52,6 +52,8 @@ public class CMapCidByte : AbstractCMap {
 
         private readonly byte[] EMPTY = new byte[] {  };
 
+        private IList<byte[]> codeSpaceRanges = new List<byte[]>();
+
         internal override void AddChar(String mark, CMapObject code) {
             if (code.IsNumber()) {
                 byte[] ser = DecodeStringToByte(mark);
@@ -82,5 +84,18 @@ public virtual IntHashtable GetReversMap() {
             }
             return code2cid;
         }
+
+        /// <summary>
+        /// Returns a list containing sequential pairs of code space beginning and endings:
+        /// (begincodespacerange1, endcodespacerange1, begincodespacerange2, endcodespacerange1, ...)
+        /// </summary>
+        public virtual IList<byte[]> GetCodeSpaceRanges() {
+            return codeSpaceRanges;
+        }
+
+        internal override void AddCodeSpaceRange(byte[] low, byte[] high) {
+            codeSpaceRanges.Add(low);
+            codeSpaceRanges.Add(high);
+        }
     }
 }

itext/itext.io/itext/io/font/CMapEncoding.cs

@@ -131,5 +131,14 @@ public override String ToString() {
             }
             return value.ToString();
         }
+
+        public virtual byte[] ToHexByteArray() {
+            if (type == HEX_STRING) {
+                return (byte[])value;
+            }
+            else {
+                return null;
+            }
+        }
     }
 }