Initial support for subsampling interleave mode line

Author: vbaderks

fuzzing/lib-fuzzer-decode/Program.cs

@@ -16,6 +16,9 @@ public static void Main()
                 byte[] input = readOnlyInput.ToArray();
                 var decoder = new JpegLSDecoder(input, false);
                 decoder.ReadHeader();
+                if (decoder.CompressedDataFormat == CompressedDataFormat.AbbreviatedTableSpecification)
+                    return;
+
                 int size = decoder.GetDestinationSize();
                 if (size > 8192 * 8192 * 3)
                     return;

src/JpegLSDecoder.cs

@@ -205,12 +205,14 @@ public InterleaveMode GetInterleaveMode(int componentIndex = 0)
     /// Gets the required size of the destination buffer.
     /// </summary>
     /// <param name="stride">The stride to use; byte count to the next pixel row. Pass 0 (AutoCalculateStride) for the default.</param>
-    /// <returns>The size of the destination buffer in bytes.</returns>
+    /// <returns>The size of the destination buffer in bytes or 0 for abbreviated table specification format.</returns>
     /// <exception cref="InvalidDataException">When the required destination size doesn't fit in an int.</exception>
     /// <exception cref="InvalidOperationException">Thrown when this method is called before <see cref="ReadHeader(bool)"/>.</exception>
     public int GetDestinationSize(int stride = AutoCalculateStride)
     {
         CheckStateHeaderRead();
+        if (CompressedDataFormat == CompressedDataFormat.AbbreviatedTableSpecification)
+            return 0;
 
         checked
         {

src/RunModeContext.cs

@@ -18,10 +18,25 @@ internal RunModeContext(int runInterruptionType, int range)
 
     internal int RunInterruptionType { get; }
 
+    internal readonly int ComputeGolombCodingParameterChecked()
+    {
+        uint temp = (uint)(_a + ((_n >> 1) * RunInterruptionType));
+        uint nTest = _n;
+        int k = 0;
+        for (; nTest < temp; ++k)
+        {
+            nTest <<= 1;
+            if (k > 32)
+                ThrowHelper.ThrowInvalidDataException(ErrorCode.InvalidData);
+        }
+
+        return k;
+    }
+
     internal readonly int ComputeGolombCodingParameter()
     {
-        int temp = _a + ((_n >> 1) * RunInterruptionType);
-        int nTest = _n;
+        uint temp = (uint)(_a + ((_n >> 1) * RunInterruptionType));
+        uint nTest = _n;
         int k = 0;
         for (; nTest < temp; ++k)
         {

src/ScanDecoder.cs

@@ -1207,8 +1207,8 @@ private int DecodeRegular(int qs, int predicted)
     {
         int sign = BitWiseSign(qs);
         ref var context = ref _scanCodec.RegularModeContext[ApplySign(qs, sign)];
+        int correctedPrediction = Traits.CorrectPrediction(predicted + ApplySign(context.C, sign));
         int k = context.ComputeGolombCodingParameterChecked();
-        int predictedValue = Traits.CorrectPrediction(predicted + ApplySign(context.C, sign));
 
         int errorValue;
         var golombCodeMatch = GolombCodeTable[k].Get(PeekByte());
@@ -1233,7 +1233,7 @@ private int DecodeRegular(int qs, int predicted)
 
         context.UpdateVariablesAndBias(errorValue, _scanCodec.NearLossless, _scanCodec.ResetThreshold);
         errorValue = ApplySign(errorValue, sign);
-        return Traits.ComputeReconstructedSample(predictedValue, errorValue);
+        return Traits.ComputeReconstructedSample(correctedPrediction, errorValue);
     }
 
     private int DecodeRunMode(int startIndex, Span<byte> previousLine, Span<byte> currentLine)
@@ -1741,7 +1741,7 @@ private Quad<ushort> DecodeRunInterruptionPixel(Quad<ushort> ra, Quad<ushort> rb
 
     private int DecodeRunInterruptionError(ref RunModeContext context)
     {
-        int k = context.ComputeGolombCodingParameter();
+        int k = context.ComputeGolombCodingParameterChecked();
         int eMappedErrorValue = DecodeMappedErrorValue(k, _scanCodec.Limit - ScanCodec.J[_scanCodec.RunIndex] - 1, _scanCodec.QuantizedBitsPerSample);
         int errorValue = context.ComputeErrorValue(eMappedErrorValue + context.RunInterruptionType, k);
         context.UpdateVariables(errorValue, eMappedErrorValue, (byte)_scanCodec.PresetCodingParameters.ResetValue);

test/CharLS.Managed.Test.csproj

@@ -120,6 +120,10 @@
     <None Update="test-images/fuzzy-input-no-valid-bits-at-the-end.jls">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="test-images/fuzzy-input-bad-run-mode-golomb-code.jls">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+
   </ItemGroup>
 
 </Project>

test/EncodeTest.cs

@@ -439,6 +439,32 @@ public void EncodeSubSamplingInterleaveNone()
         CheckOutput(component2, destination[(2 * 2 * 2)..], decoder, 1, 2 * 1);
     }
 
+    [Fact]
+    public void EncodeSubSamplingInterleaveLine()
+    {
+        JpegLSEncoder encoder = new() { FrameInfo = new FrameInfo(2, 2, 8, 3), InterleaveMode = InterleaveMode.None };
+
+        Memory<byte> encodedData = new byte[encoder.EstimatedDestinationSize];
+        encoder.Destination = encodedData;
+
+        byte[] components = [24, 25, 26, 23, 0, 0, 22, 0, 0, 21, 0, 0];
+
+        encoder.SetSamplingFactor(0, 2, 2);
+        encoder.SetSamplingFactor(1, 1, 1);
+        encoder.SetSamplingFactor(2, 1, 1);
+        encoder.InterleaveMode = InterleaveMode.Line;
+        encoder.Encode(components);
+
+        JpegLSDecoder decoder = new() { Source = encoder.EncodedData };
+        decoder.ReadHeader();
+
+        Span<byte> destination = new byte[decoder.GetDestinationSize()];
+        decoder.Decode(destination);
+
+        //CheckOutput(component0, destination, decoder, 1, 2 * 2);
+        //CheckOutput(component1And2, destination[(2 * 2)..], decoder, 1, 1 * 2);
+    }
+
     [Fact]
     public void EncodeSubSamplingInterleaveSample()
     {

test/JpegLSDecoderTest.cs

@@ -168,6 +168,33 @@ public void DecodeFuzzyInputNoValidBitsAtTheEndThrows()
         Assert.Equal(ErrorCode.InvalidData, exception.GetErrorCode());
     }
 
+    [Fact]
+    public void DecodeFuzzyInputBadRunModeGolombCodeThrows()
+    {
+        JpegLSDecoder decoder = new(ReadAllBytes("test-images/fuzzy-input-bad-run-mode-golomb-code.jls"));
+        byte[] destination = new byte[decoder.GetDestinationSize()];
+
+        var exception = Assert.Throws<InvalidDataException>(() => decoder.Decode(destination));
+
+        Assert.False(string.IsNullOrEmpty(exception.Message));
+        Assert.Equal(ErrorCode.InvalidData, exception.GetErrorCode());
+    }
+
+    [Fact]
+    public void GetDestinationSizeReturnsZeroForAbbreviatedTableSpecification()
+    {
+        byte[] tableData = new byte[255];
+        JpegTestStreamWriter writer = new();
+        writer.WriteStartOfImage();
+        writer.WriteJpegLSPresetParametersSegment(1, 1, tableData, false);
+        writer.WriteMarker(JpegMarkerCode.EndOfImage);
+        JpegLSDecoder decoder = new(writer.GetBuffer());
+
+        int size = decoder.GetDestinationSize();
+
+        Assert.Equal(0, size);
+    }
+
     [Fact]
     public void DecodeDestinationSizeOverflowThrows()
     {
@@ -635,7 +662,7 @@ public void OversizeImageDimensionZeroBeforeStartOfFrame()
     }
 
     [Fact]
-    public void OversizeImageDimensionWithInvalidNumberOfBytesThrows() // NOLINT
+    public void OversizeImageDimensionWithInvalidNumberOfBytesThrows()
     {
         JpegTestStreamWriter writer = new();
         writer.WriteStartOfImage();

test/RunModeContextTest.cs

@@ -13,5 +13,6 @@ public void UpdateVariables()
         runModeContext.UpdateVariables(3, 27, 0);
 
         Assert.Equal(3, runModeContext.ComputeGolombCodingParameter());
+        Assert.Equal(3, runModeContext.ComputeGolombCodingParameterChecked());
     }
 }