Merge pull request #227 from jafin/feature/2gbfiles

feat: Add basic support for reading/writing files >2gb

Author: ststeiger

PdfSharpCore.Test/Helpers/TestData.cs

@@ -0,0 +1,22 @@
+namespace PdfSharpCore.Test.Helpers
+{
+    public static class TestData
+    {
+        public static string LoremIpsumText =
+            @"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed non sapien leo. Aliquam elementum volutpat lacus, sit amet aliquet est volutpat at. Nam eleifend vehicula bibendum. Sed lacinia velit ex, id auctor tellus varius a. Vivamus cursus ut nulla quis pretium. Nunc accumsan felis nec tortor fermentum iaculis. Vivamus non lacus ullamcorper, porta justo ut, dictum nibh. Cras scelerisque in risus vitae hendrerit. Duis venenatis felis in lacinia vestibulum. Proin mauris ex, efficitur nec tincidunt in, imperdiet eget risus. Nulla porttitor mollis pellentesque. Fusce pretium ut odio et imperdiet.
+
+Vivamus euismod velit id massa mollis, quis congue metus faucibus. Donec ante enim, vehicula a cursus ut, porta vel dui. Proin porta faucibus dolor non consequat. Mauris aliquam, leo a interdum pretium, tellus nisi semper libero, at suscipit dui mi bibendum turpis. Phasellus tempor mauris a eleifend placerat. Fusce in velit ut lectus sagittis varius. Etiam vulputate, libero sit amet posuere posuere, orci nunc ultricies velit, non porttitor dui ante feugiat purus. Ut semper congue lacinia. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed facilisis ante at sapien dignissim, ut volutpat elit dictum. Morbi nulla ante, laoreet non vulputate et, facilisis ut lectus. Mauris mollis mi nec venenatis congue. Fusce efficitur vitae massa non vehicula. Fusce euismod molestie posuere. Nunc facilisis ipsum nec justo scelerisque, nec cursus diam gravida.
+
+Morbi at sapien risus. Nunc dui tellus, faucibus rhoncus euismod vitae, maximus at lacus. Nam neque dui, venenatis at euismod vel, ullamcorper a velit. Maecenas placerat tellus quis justo feugiat molestie. Mauris tristique sollicitudin nisi at sagittis. Integer eleifend, velit et facilisis rutrum, nisi ipsum sodales turpis, non dictum odio dui sed velit. Aliquam consequat ac lorem non hendrerit. Morbi quis mollis nibh, et mattis nisi. Donec nec ultricies dui, nec pellentesque sapien. Vivamus sed lectus fermentum mauris placerat sodales ut sed quam. Nam facilisis, risus quis hendrerit mattis, velit nisi placerat neque, in feugiat urna nisl in nibh. Suspendisse potenti. Proin sollicitudin maximus ligula, eu sodales tellus posuere vitae. Integer orci magna, ultricies in luctus a, euismod quis lectus. Phasellus blandit justo mauris, nec maximus sapien tempor non. Ut eu quam aliquam, facilisis nibh sit amet, blandit eros.
+
+Nulla accumsan augue diam, sed egestas ipsum vestibulum vel. Praesent vitae dignissim quam. Nunc mollis tincidunt vehicula. In vitae euismod urna, eget tincidunt magna. In quis ligula eu magna vehicula venenatis. Vestibulum sapien sem, congue in congue et, vehicula et risus. Suspendisse aliquam, est et commodo porta, nibh tortor mollis nisi, quis porttitor ligula leo a ipsum. Aliquam viverra sodales leo quis faucibus.
+
+In sit amet laoreet nisl. Aenean et tortor diam. Maecenas imperdiet massa eget justo faucibus dignissim. Donec nec finibus diam, vel lobortis neque. Ut justo felis, suscipit et justo ultrices, fringilla convallis nisi. Vestibulum egestas felis vehicula tellus maximus, a ultrices magna aliquet. Cras eu laoreet mauris. Duis id euismod est. Nulla facilisi. Vivamus fermentum metus velit, vitae vulputate lectus laoreet in. Aenean semper ante odio. Ut aliquam ligula eu enim ullamcorper, ac pellentesque enim hendrerit. Vestibulum eu efficitur nisl. Aenean tempor diam nec nulla rutrum, sit amet congue urna blandit.
+
+Duis ullamcorper tellus ac mattis vestibulum. Integer nibh nunc, commodo sit amet pharetra sit amet, molestie a sapien. Nulla magna orci, semper at enim non, ultricies faucibus nulla. Aenean leo ex, rutrum ut fermentum ut, fringilla sit amet diam. Morbi et congue tortor, non maximus tellus. Nunc sit amet placerat ipsum, at molestie tellus. Etiam tincidunt eleifend ligula, quis dapibus elit tempus tempor. Curabitur feugiat mattis leo eu blandit. Maecenas sed vestibulum mi. In molestie eleifend euismod. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Vivamus id turpis a magna sollicitudin pellentesque.
+
+Donec sollicitudin efficitur sapien iaculis fringilla. Donec rutrum sagittis dolor, at auctor turpis finibus et. Aliquam et dictum risus. Praesent viverra efficitur congue. Suspendisse condimentum posuere risus, id dignissim enim viverra ut. Aliquam eleifend nisl eu dolor luctus, nec rhoncus nisi porta. Donec ut lacinia risus. Curabitur bibendum lacus consequat sem consequat euismod. Donec auctor cursus ante quis rutrum. Aliquam mattis eget libero non porta.
+
+Maecenas mollis sollicitudin felis at imperdiet. Duis dignissim purus quis interdum mattis. Nam sit amet quam quis enim hendrerit tincidunt. Aliquam euismod metus justo, non lobortis risus vehicula in. Pellentesque tempus, leo at placerat interdum, diam lectus gravida purus, id placerat justo quam nec mauris. Ut ullamcorper commodo dui in pretium. Suspendisse luctus mauris lacinia neque faucibus sollicitudin. Pellentesque ut ipsum metus. Quisque rutrum, risus eget feugiat vestibulum, enim nisl ornare risus, sit amet interdum arcu lacus at turpis. Mauris nec tristique massa. Curabitur diam urna, dapibus eget lorem porta, venenatis mattis justo. Sed eleifend accumsan lectus, id tempor metus semper in.";
+    }
+}

PdfSharpCore.Test/IO/IoBaseTest.cs

@@ -0,0 +1,73 @@
+using System.IO;
+using System.Text;
+using FluentAssertions;
+using PdfSharpCore.Pdf;
+using PdfSharpCore.Pdf.IO;
+using PdfSharpCore.Test.Helpers;
+using Xunit;
+
+namespace PdfSharpCore.Test.IO
+{
+    public abstract class IoBaseTest
+    {
+        private readonly string _rootPath = PathHelper.GetInstance().RootDir;
+        private const string _outputDirName = "Out";
+
+        public void CanReadPdf(string fileName)
+        {
+            var path = GetOutFilePath(fileName);
+            using var fs = File.OpenRead(path);
+            var inputDocument = Pdf.IO.PdfReader.Open(fs, PdfDocumentOpenMode.Import);
+            var info = inputDocument.Info;
+            info.Should().NotBeNullOrEmpty();
+        }
+
+        protected void SaveDocument(PdfDocument document, string name)
+        {
+            var outFilePath = GetOutFilePath(name);
+            var dir = Path.GetDirectoryName(outFilePath);
+            if (!Directory.Exists(dir))
+            {
+                Directory.CreateDirectory(dir);
+            }
+
+            document.Save(outFilePath);
+        }
+
+        protected void ValidateFileIsPdf(string v)
+        {
+            var path = GetOutFilePath(v);
+            Assert.True(File.Exists(path));
+            var fi = new FileInfo(path);
+            Assert.True(fi.Length > 1);
+
+            using var stream = File.OpenRead(path);
+            ReadStreamAndVerifyPdfHeaderSignature(stream);
+        }
+
+        private static void ReadStreamAndVerifyPdfHeaderSignature(Stream stream)
+        {
+            var readBuffer = new byte[5];
+            var pdfSignature = Encoding.ASCII.GetBytes("%PDF-"); // PDF must start with %PDF-
+
+            stream.Read(readBuffer, 0, readBuffer.Length);
+            readBuffer.Should().Equal(pdfSignature);
+        }
+
+        protected void ValidateTargetAvailable(string file)
+        {
+            var path = GetOutFilePath(file);
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+
+            Assert.False(File.Exists(path));
+        }
+
+        protected string GetOutFilePath(string name)
+        {
+            return Path.Combine(_rootPath, _outputDirName, name);
+        }
+    }
+}

PdfSharpCore.Test/IO/LargePDFReadWrite.cs

@@ -0,0 +1,59 @@
+using PdfSharpCore.Drawing;
+using PdfSharpCore.Drawing.Layout;
+using PdfSharpCore.Pdf;
+using PdfSharpCore.Test.Helpers;
+using PdfSharpCore.Test.IO;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace PdfSharpCore.Test
+{
+    public class LargePDFReadWrite : IoBaseTest
+    {
+        private readonly ITestOutputHelper output;
+
+        public LargePDFReadWrite(ITestOutputHelper output)
+        {
+            this.output = output;
+        }
+
+        [Fact(Skip = "Too slow for Unit test runner")]
+        public void CanCreatePdfOver2gb()
+        {
+            const string outName = "CreateLargePdf.pdf";
+            int pageCount = 70000; //2.1gb @ 369sec to create
+            ValidateTargetAvailable(outName);
+
+            var document = new PdfDocument();
+            var watch = new System.Diagnostics.Stopwatch();
+            var font = new XFont("Arial", 10);
+
+            watch.Start();
+            for (var i = 0; i < pageCount; i++)
+            {
+                AddAPage(document, font);
+            }
+
+            watch.Stop();
+
+            SaveDocument(document, outName);
+            output.WriteLine($"CreatePDF took {watch.Elapsed.TotalSeconds} sec");
+            ValidateFileIsPdf(outName);
+            CanReadPdf(outName);
+        }
+
+        private void AddAPage(PdfDocument document, XFont font)
+        {
+            const int x = 40;
+            const int y = 50;
+            var page = document.AddPage();
+            var renderer = XGraphics.FromPdfPage(page);
+            var tf = new XTextFormatter(renderer);
+            var width = page.Width.Value - 50 - x;
+            var height = page.Height.Value - 50 - y;
+            var rect = new XRect(40, 50, width, height);
+            renderer.DrawRectangle(XBrushes.SeaShell, rect);
+            tf.DrawString(TestData.LoremIpsumText, font, XBrushes.Black, rect, XStringFormats.TopLeft);
+        }
+    }
+}

PdfSharpCore/Pdf.Advanced/PdfReference.cs

@@ -79,7 +79,7 @@ public PdfReference(PdfObject pdfObject)
         /// <summary>
         /// Initializes a new PdfReference instance from the specified object identifier and file position.
         /// </summary>
-        public PdfReference(PdfObjectID objectID, int position)
+        public PdfReference(PdfObjectID objectID, long position)
         {
             _objectID = objectID;
             _position = position;
@@ -152,12 +152,12 @@ public int GenerationNumber
         /// <summary>
         /// Gets or sets the file position of the related PdfObject.
         /// </summary>
-        public int Position
+        public long Position
         {
             get { return _position; }
             set { _position = value; }
         }
-        int _position;  // I know it should be long, but I have never seen a 2GB PDF file.
+        long _position;
 
         //public bool InUse
         //{

PdfSharpCore/Pdf.IO/Lexer.cs

@@ -35,8 +35,6 @@
 using PdfSharpCore.Internal;
 using PdfSharpCore.Pdf.Internal;
 
-#pragma warning disable 1591
-
 namespace PdfSharpCore.Pdf.IO
 {
     /// <summary>
@@ -54,15 +52,15 @@ public class Lexer
         public Lexer(Stream pdfInputStream)
         {
             _pdfSteam = pdfInputStream;
-            _pdfLength = (int)_pdfSteam.Length;
+            _pdfLength = _pdfSteam.Length;
             _idxChar = 0;
             Position = 0;
         }
 
         /// <summary>
         /// Gets or sets the position within the PDF stream.
         /// </summary>
-        public int Position
+        public long Position
         {
             get { return _idxChar; }
             set
@@ -173,7 +171,7 @@ public Symbol ScanNextToken()
         /// </summary>
         public byte[] ReadStream(int length)
         {
-            int pos;
+            long pos;
 
             // Skip illegal blanks behind «stream».
             while (_currChar == Chars.SP)
@@ -203,7 +201,7 @@ public byte[] ReadStream(int length)
         /// <summary>
         /// Reads a string in raw encoding.
         /// </summary>
-        public String ReadRawString(int position, int length)
+        public string ReadRawString(long position, int length)
         {
             _pdfSteam.Position = position;
             byte[] bytes = new byte[length];
@@ -303,23 +301,17 @@ public Symbol ScanNumber()
             long l = Int64.Parse(_token.ToString(), CultureInfo.InvariantCulture);
             if (l >= Int32.MinValue && l <= Int32.MaxValue)
                 return Symbol.Integer;
-            if (l > 0 && l <= UInt32.MaxValue)
-                return Symbol.UInteger;
+            if (l >= Int64.MinValue && l <= Int64.MaxValue)
+                return Symbol.Long;
 
             // Got an AutoCAD PDF file that contains this: /C 264584027963392
             // Best we can do is to convert it to real value.
             return Symbol.Real;
-            //thr ow new PdfReaderException("Number exceeds integer range.");
         }
 
         public Symbol ScanNumberOrReference()
         {
             Symbol result = ScanNumber();
-            if (result == Symbol.Integer)
-            {
-                int pos = Position;
-                string objectNumber = Token;
-            }
             return result;
         }
 
@@ -643,7 +635,7 @@ bool PeekReference()
             // A Reference has the form "nnn mmm R". The implementation of the the parser used a
             // reduce/shift algorithm in the first place. But this case is the only one we need to
             // look ahead 3 tokens. 
-            int positon = Position;
+            var positon = Position;
 
             // Skip digits.
             while (char.IsDigit(_currChar))
@@ -731,32 +723,32 @@ public char MoveToNonWhiteSpace()
             return _currChar;
         }
 
-#if DEBUG
-        public string SurroundingsOfCurrentPosition(bool hex)
-        {
-            const int range = 20;
-            int start = Math.Max(Position - range, 0);
-            int length = Math.Min(2 * range, PdfLength - start);
-            long posOld = _pdfSteam.Position;
-            _pdfSteam.Position = start;
-            byte[] bytes = new byte[length];
-            _pdfSteam.Read(bytes, 0, length);
-            _pdfSteam.Position = posOld;
-            string result = "";
-            if (hex)
-            {
-                for (int idx = 0; idx < length; idx++)
-                    result += ((int)bytes[idx]).ToString("x2");
-                //result += string.Format("{0:", (int) bytes[idx]);
-            }
-            else
-            {
-                for (int idx = 0; idx < length; idx++)
-                    result += (char)bytes[idx];
-            }
-            return result;
-        }
-#endif
+// #if DEBUG
+//         public string SurroundingsOfCurrentPosition(bool hex)
+//         {
+//             const int range = 20;
+//             int start = Math.Max(Position - range, 0);
+//             int length = Math.Min(2 * range, PdfLength - start);
+//             long posOld = _pdfSteam.Position;
+//             _pdfSteam.Position = start;
+//             byte[] bytes = new byte[length];
+//             _pdfSteam.Read(bytes, 0, length);
+//             _pdfSteam.Position = posOld;
+//             string result = "";
+//             if (hex)
+//             {
+//                 for (int idx = 0; idx < length; idx++)
+//                     result += ((int)bytes[idx]).ToString("x2");
+//                 //result += string.Format("{0:", (int) bytes[idx]);
+//             }
+//             else
+//             {
+//                 for (int idx = 0; idx < length; idx++)
+//                     result += (char)bytes[idx];
+//             }
+//             return result;
+//         }
+// #endif
 
         /// <summary>
         /// Gets the current symbol.
@@ -810,6 +802,7 @@ public uint TokenToUInteger
                 return uint.Parse(_token.ToString(), CultureInfo.InvariantCulture);
             }
         }
+        public long TokenToLong => long.Parse(_token.ToString(), CultureInfo.InvariantCulture);
 
         /// <summary>
         /// Interprets current token as real or integer literal.
@@ -876,13 +869,13 @@ internal static bool IsDelimiter(char ch)
         /// <summary>
         /// Gets the length of the PDF output.
         /// </summary>
-        public int PdfLength
+        public long PdfLength
         {
             get { return _pdfLength; }
         }
 
-        readonly int _pdfLength;
-        int _idxChar;
+        readonly long _pdfLength;
+        long _idxChar;
         char _currChar;
         char _nextChar;
         StringBuilder _token;