Merge pull request #234 from packdat/Stream-Filtering

Improved stream-decoding

Author: ststeiger

PdfSharpCore/Pdf.Advanced/PdfContent.cs

@@ -78,13 +78,13 @@ public bool Compressed
             {
                 if (value)
                 {
-                    PdfItem filter = Elements["/Filter"];
+                    PdfItem filter = Elements[PdfStream.Keys.Filter];
                     if (filter == null)
                     {
                         byte[] bytes = Filtering.FlateDecode.Encode(Stream.Value, _document.Options.FlateEncodeMode);
                         Stream.Value = bytes;
-                        Elements.SetInteger("/Length", Stream.Length);
-                        Elements.SetName("/Filter", "/FlateDecode");
+                        Elements.SetInteger(PdfStream.Keys.Length, Stream.Length);
+                        Elements.SetName(PdfStream.Keys.Filter, "/FlateDecode");
                     }
                 }
             }
@@ -97,15 +97,17 @@ void Decode()
         {
             if (Stream != null && Stream.Value != null)
             {
-                PdfItem item = Elements["/Filter"];
+                PdfItem item = Elements[PdfStream.Keys.Filter];
                 if (item != null)
                 {
-                    byte[] bytes = Filtering.Decode(Stream.Value, item);
+                    var decodeParms = Elements[PdfStream.Keys.DecodeParms];
+                    byte[] bytes = Filtering.Decode(Stream.Value, item, decodeParms);
                     if (bytes != null)
                     {
                         Stream.Value = bytes;
-                        Elements.Remove("/Filter");
-                        Elements.SetInteger("/Length", Stream.Length);
+                        Elements.Remove(PdfStream.Keys.Filter);
+                        Elements.Remove(PdfStream.Keys.DecodeParms);
+                        Elements.SetInteger(PdfStream.Keys.Length, Stream.Length);
                     }
                 }
             }

PdfSharpCore/Pdf.Advanced/PdfCrossReferenceStream.cs

@@ -47,9 +47,10 @@ public PdfCrossReferenceStream(PdfDocument document)
 
         public readonly List<CrossReferenceStreamEntry> Entries = new List<CrossReferenceStreamEntry>();
 
+        [DebuggerDisplay("{Type} {Field2} {Field3}")]
         public struct CrossReferenceStreamEntry
         {
-            // Reference: TABLE 3.16  Entries in a cross-refernece stream / Page 109
+            // Reference: TABLE 3.16  Entries in a cross-reference stream / Page 109
 
             public uint Type;  // 0, 1, or 2.
 

PdfSharpCore/Pdf.Filters/Filter.cs

@@ -37,7 +37,15 @@ namespace PdfSharpCore.Pdf.Filters
     /// </summary>
     public class FilterParms
     {
-        // not yet used
+        /// <summary>
+        /// Gets the decoding-parameters for a filter. May be null
+        /// </summary>
+        public PdfDictionary DecodeParms { get; private set; }
+
+        public FilterParms(PdfDictionary decodeParms)
+        {
+            DecodeParms = decodeParms;
+        }
     }
 
     /// <summary>
@@ -68,9 +76,9 @@ public virtual byte[] Encode(string rawString)
         /// <summary>
         /// Decodes the specified data.
         /// </summary>
-        public byte[] Decode(byte[] data)
+        public byte[] Decode(byte[] data, PdfDictionary decodeParms)
         {
-            return Decode(data, null);
+            return Decode(data, new FilterParms(decodeParms));
         }
 
         /// <summary>

PdfSharpCore/Pdf.Filters/Filtering.cs

@@ -191,27 +191,34 @@ public static byte[] Decode(byte[] data, string filterName)
         {
             Filter filter = GetFilter(filterName);
             if (filter != null)
-                return filter.Decode(data, null);
+                return filter.Decode(data, (PdfDictionary)null);
             return null;
         }
 
         /// <summary>
         /// Decodes the data with the specified filter.
         /// </summary>
-        public static byte[] Decode(byte[] data, PdfItem filterItem)
+        public static byte[] Decode(byte[] data, PdfItem filterItem, PdfItem decodeParms)
         {
             byte[] result = null;
-            if (filterItem is PdfName)
+            if (filterItem is PdfName && (decodeParms == null || decodeParms is PdfDictionary))
             {
                 Filter filter = GetFilter(filterItem.ToString());
                 if (filter != null)
-                    result = filter.Decode(data);
+                    result = filter.Decode(data, decodeParms as PdfDictionary);
             }
-            else if (filterItem is PdfArray)
+            else if (filterItem is PdfArray itemArray && (decodeParms == null || decodeParms is PdfArray))
             {
-                PdfArray array = (PdfArray)filterItem;
-                foreach (PdfItem item in array)
-                    data = Decode(data, item);
+                var decodeArray = decodeParms as PdfArray;
+                // array length of filter and decode parms should match. if they dont, return data unmodified
+                if (decodeArray != null && decodeArray.Elements.Count != itemArray.Elements.Count)
+                    return data;
+                for (var i = 0; i < itemArray.Elements.Count; i++)
+                {
+                    var item = itemArray.Elements[i];
+                    var parms = decodeArray != null ? decodeArray.Elements[i] : null;
+                    data = Decode(data, item, parms);
+                }
                 result = data;
             }
             return result;

PdfSharpCore/Pdf.Filters/FlateDecode.cs

@@ -98,6 +98,8 @@ public override byte[] Decode(byte[] data, FilterParms parms)
             msOutput.Flush();
             if (msOutput.Length >= 0)
             {
+                if (parms.DecodeParms != null)
+                    return StreamDecoder.Decode(msOutput.ToArray(), parms.DecodeParms);
                 return msOutput.ToArray();
             }
             return null;

PdfSharpCore/Pdf.Filters/LzwDecode.cs

@@ -101,6 +101,8 @@ public override byte[] Decode(byte[] data, FilterParms parms)
 
             if (outputStream.Length >= 0)
             {
+                if (parms.DecodeParms != null)
+                    return StreamDecoder.Decode(outputStream.ToArray(), parms.DecodeParms);
                 return outputStream.ToArray();
             }
             return null;

PdfSharpCore/Pdf.Filters/PngFilter.cs

@@ -0,0 +1,83 @@
+using PdfSharpCore.Pdf.IO;
+using System;
+
+namespace PdfSharpCore.Pdf.Filters
+{
+    internal static class PngFilter
+    {
+        /// <summary>
+        /// Implements PNG-Filtering according to the PNG-specification<br></br>
+        /// see: https://datatracker.ietf.org/doc/html/rfc2083#section-6
+        /// </summary>
+        /// <param name="stride">The width of a scanline in bytes</param>
+        /// <param name="bpp">Bytes per pixel</param>
+        /// <param name="inData">The input data</param>
+        /// <param name="inData">The target array where the unfiltered data is stored</param>
+        /// <returns></returns>
+        internal static void Unfilter(int stride, int bpp, byte[] inData, byte[] outData)
+        {
+            var prevRow = new byte[stride];
+            var row = new byte[stride];
+            var pos = 0;
+            var outIndex = 0;
+            while (pos < inData.Length)
+            {
+                Array.Copy(inData, pos + 1, row, 0, stride);
+                var filterType = inData[pos];
+                if (filterType > 4)
+                    throw new PdfReaderException(string.Format("Unexpected Png-Predictor {0} in Xref Stream. Expected 0 to 4.", filterType));
+                switch (filterType)
+                {
+                    case 0:         // None
+                        for (var i = 0; i < row.Length; i++)
+                            outData[outIndex++] = row[i];
+                        break;
+                    case 1:         // Sub
+                        for (var i = 0; i < row.Length; i++)
+                        {
+                            var left = i < bpp ? 0 : outData[outIndex - bpp];
+                            outData[outIndex++] = (byte)(row[i] + left);
+                        }
+                        break;
+                    case 2:         // Up
+                        for (var i = 0; i < row.Length; i++)
+                            outData[outIndex++] = (byte)(row[i] + prevRow[i]);
+                        break;
+                    case 3:         // Average
+                        for (var i = 0; i < row.Length; i++)
+                        {
+                            var left = i < bpp ? 0 : outData[outIndex - bpp];
+                            outData[outIndex++] = (byte)(row[i] + (byte)((left + prevRow[i]) / 2));
+                        }
+                        break;
+                    case 4:         // Paeth
+                        for (var i = 0; i < row.Length; i++)
+                        {
+                            var left = i < bpp ? (byte)0 : outData[outIndex - bpp];
+                            var above = prevRow[i];
+                            var aboveLeft = i < bpp ? (byte)0 : prevRow[i - bpp];
+                            outData[outIndex++] = (byte)(row[i] + PaethPredictor(left, above, aboveLeft));
+                        }
+                        break;
+                }
+                // remember current scanline
+                Array.Copy(outData, outIndex - stride, prevRow, 0, stride);
+                pos += stride + 1;    // each scanline is preceded by a predictor-byte
+            }
+        }
+
+        // https://datatracker.ietf.org/doc/html/rfc2083#page-36
+        private static byte PaethPredictor(byte a, byte b, byte c)
+        {
+            var p = a + b - c;
+            var pa = Math.Abs(p - a);
+            var pb = Math.Abs(p - b);
+            var pc = Math.Abs(p - c);
+            if (pa <= pb && pa <= pc)
+                return a;
+            else if (pb <= pc)
+                return b;
+            return c;
+        }
+    }
+}

PdfSharpCore/Pdf.Filters/StreamDecoder.cs

@@ -0,0 +1,60 @@
+using PdfSharpCore.Pdf.IO;
+using System;
+
+namespace PdfSharpCore.Pdf.Filters
+{
+    internal static class StreamDecoder
+    {
+        // PdfReference, chapter 7.4.4.3
+
+        /// <summary>
+        /// Further decodes a stream of bytes that were processed by the Flate- or LZW-decoder. 
+        /// </summary>
+        /// <param name="data">The data to decode</param>
+        /// <param name="decodeParms">Parameters for the decoder. If this is null, <paramref name="data"/> is returned unchanged</param>
+        /// <returns>The decoded data as a byte-array</returns>
+        /// <exception cref="PdfReaderException"></exception>
+        /// <exception cref="NotImplementedException"></exception>
+        public static byte[] Decode(byte[] data, PdfDictionary decodeParms)
+        {
+            if (decodeParms == null)
+                return data;
+
+            var predictor = decodeParms.Elements.GetInteger("/Predictor");
+            var colors = decodeParms.Elements.GetInteger("/Colors");
+            var bpc = decodeParms.Elements.GetInteger("/BitsPerComponent");
+            var columns = decodeParms.Elements.GetInteger("/Columns");
+
+            // set up defaults according to the spec
+            if (predictor < 1)
+                predictor = 1;
+            if (colors < 1)
+                colors = 1;
+            if (bpc < 1)
+                bpc = 8;
+            if (columns < 1)
+                columns = 1;
+
+            if (predictor == 1)     // no prediction, return data as is
+                return data;
+
+            // TIFF predictor. TODO: implement
+            if (predictor == 2)
+                throw new NotImplementedException("TIFF predictor is not implemented");
+
+            // PNG predictors
+            if (predictor >= 10 && predictor <= 15)
+            {
+                if (bpc != 1 && bpc != 2 && bpc != 4 && bpc != 8 && bpc != 16)
+                    throw new PdfReaderException("Invalid number of bits per component");
+                var stride = (bpc * colors * columns + 7) / 8;
+                var rows = data.Length / (stride + 1);
+                var unfilteredData = new byte[rows * stride];
+                PngFilter.Unfilter(stride, (bpc * colors + 7) / 8, data, unfilteredData);
+                return unfilteredData;
+            }
+
+            throw new PdfReaderException("Invalid predictor " + predictor);
+        }
+    }
+}

PdfSharpCore/Pdf.IO/Parser.cs

@@ -35,13 +35,12 @@
 using PdfSharpCore.Exceptions;
 using PdfSharpCore.Internal;
 using PdfSharpCore.Pdf.Advanced;
-using PdfSharpCore.Pdf.Internal;
 using PdfSharpCore.Pdf.IO.enums;
 
 namespace PdfSharpCore.Pdf.IO
 {
     /*
-       Direct and indireckt objects
+       Direct and indirect objects
 
        * If a simple object (boolean, integer, number, date, string, rectangle etc.) is referenced indirect,
          the parser reads this objects immediatly and consumes the indirection.
@@ -52,7 +51,7 @@ is returned.
        * If a composite object is a direct object, no PdfReference is created and the object is
          parsed immediatly.
 
-       * A refernece to a non existing object is specified as legal, therefore null is returned.
+       * A reference to a non existing object is specified as legal, therefore null is returned.
     */
 
     /// <summary>
@@ -1256,16 +1255,7 @@ private PdfTrailer ReadXRefStream(PdfCrossReferenceTable xrefTable)
             Debug.Assert(xrefStream.Stream != null);
             //string sValue = new RawEncoding().GetString(xrefStream.Stream.UnfilteredValue,);
             //sValue.GetType();
-            byte[] bytesRaw = xrefStream.Stream.UnfilteredValue;
-            byte[] bytes = bytesRaw;
-
-            // HACK: Should be done in UnfilteredValue.
-            if (xrefStream.Stream.HasDecodeParams)
-            {
-                int predictor = xrefStream.Stream.DecodePredictor;
-                int columns = xrefStream.Stream.DecodeColumns;
-                bytes = DecodeCrossReferenceStream(bytesRaw, columns, predictor);
-            }
+            var bytes = xrefStream.Stream.UnfilteredValue;
 
 #if DEBUG_
             for (int idx = 0; idx < bytes.Length; idx++)
@@ -1351,7 +1341,7 @@ private PdfTrailer ReadXRefStream(PdfCrossReferenceTable xrefTable)
                             //// (PDF Reference Implementation Notes 15).
 
                             int position = (int)item.Field2;
-                            objectID = ReadObjectNumber(position);
+                                objectID = ReadObjectNumber(position);
 #if DEBUG
                             if (objectID.ObjectNumber == 1074)
                                 GetType();
@@ -1364,7 +1354,7 @@ private PdfTrailer ReadXRefStream(PdfCrossReferenceTable xrefTable)
 #if DEBUG
                                 GetType();
 #endif
-                                // Add iref for all uncrompressed objects.
+                                // Add iref for all uncompressed objects.
                                 xrefTable.Add(new PdfReference(objectID, position));
 
                             }
@@ -1771,44 +1761,6 @@ private class ParserState
             public Symbol Symbol;
         }
 
-        private byte[] DecodeCrossReferenceStream(byte[] bytes, int columns, int predictor)
-        {
-            int size = bytes.Length;
-            if (predictor < 10 || predictor > 15)
-                throw new ArgumentException("Invalid predictor.", "predictor");
-
-            int rowSizeRaw = columns + 1;
-
-            if (size % rowSizeRaw != 0)
-                throw new ArgumentException("Columns and size of array do not match.");
-
-            int rows = size / rowSizeRaw;
-
-            byte[] result = new byte[rows * columns];
-#if DEBUG
-            for (int i = 0; i < result.Length; ++i)
-                result[i] = 88;
-#endif
-
-            for (int row = 0; row < rows; ++row)
-            {
-                if (bytes[row * rowSizeRaw] != 2)
-                    throw new ArgumentException("Invalid predictor in array.");
-
-                for (int col = 0; col < columns; ++col)
-                {
-                    // Copy data for first row.
-                    if (row == 0)
-                        result[row * columns + col] = bytes[row * rowSizeRaw + col + 1];
-                    else
-                    {
-                        // For other rows, add previous row.
-                        result[row * columns + col] = (byte)(result[row * columns - columns + col] + bytes[row * rowSizeRaw + col + 1]);
-                    }
-                }
-            }
-            return result;
-        }
 
         private readonly PdfDocument _document;
         private readonly Lexer _lexer;