Read parameters

src/ImageSharp/Formats/Heif/Av1/Av1TransformMode.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1;
+
+internal enum Av1TransformMode : byte
+{
+    Only4x4 = 0,
+    Largest = 1,
+    Select = 2,
+}

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuConstraintDirectionalEnhancementFilterParameters.cs

@@ -5,9 +5,11 @@ namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
 
 internal class ObuConstraintDirectionalEnhancementFilterParameters
 {
-    public bool BitCount { get; internal set; }
+    public int BitCount { get; internal set; }
 
-    public int[] YStrength { get; internal set; }
+    public int[] YStrength { get; internal set; } = new int[4];
 
-    public int[] UVStrength { get; internal set; }
+    public int[] UVStrength { get; internal set; } = new int[4];
+
+    public int Damping { get; internal set; }
 }

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuDeltaLoopFilterParameters.cs

@@ -0,0 +1,13 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
+
+internal class ObuDeltaLoopFilterParameters
+{
+    public bool IsPresent { get; internal set; }
+
+    public int Resolution { get; internal set; }
+
+    public bool Multi { get; internal set; }
+}

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuDeltaQParameters.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
+
+internal class ObuDeltaQParameters
+{
+    public bool IsPresent { get; set; }
+
+    public int Resolution { get; set; }
+}

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuFilmGrainParameters.cs

@@ -5,4 +5,5 @@ namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
 
 internal class ObuFilmGrainParameters
 {
+    public bool ApplyGrain { get; set; }
 }

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuFrameHeader.cs

@@ -13,35 +13,43 @@ internal class ObuFrameHeader
 
     public bool AllowHighPrecisionMotionVector { get; set; }
 
-    public ObuTileInfo TilesInfo { get; internal set; } = new ObuTileInfo();
+    public ObuTileInfo TilesInfo { get; set; } = new ObuTileInfo();
 
-    public bool CodedLossless { get; internal set; }
+    public bool CodedLossless { get; set; }
 
-    public bool[] LosslessArray { get; internal set; } = new bool[ObuConstants.MaxSegmentCount];
+    public bool[] LosslessArray { get; set; } = new bool[ObuConstants.MaxSegmentCount];
 
     public ObuQuantizationParameters QuantizationParameters { get; set; } = new ObuQuantizationParameters();
 
     public ObuSegmentationParameters SegmentationParameters { get; set; } = new ObuSegmentationParameters();
 
-    public bool AllLossless { get; internal set; }
+    public bool AllLossless { get; set; }
 
-    public bool AllowWarpedMotion { get; internal set; }
+    public bool AllowWarpedMotion { get; set; }
 
-    public ObuReferenceMode ReferenceMode { get; internal set; }
+    public ObuReferenceMode ReferenceMode { get; set; }
 
-    public ObuFilmGrainParameters FilmGrainParameters { get; internal set; } = new ObuFilmGrainParameters();
+    public ObuFilmGrainParameters FilmGrainParameters { get; set; } = new ObuFilmGrainParameters();
 
-    public bool ReducedTxSet { get; internal set; }
+    public bool ReducedTransformSet { get; set; }
 
-    public ObuLoopFilterParameters LoopFilterParameters { get; internal set; } = new ObuLoopFilterParameters();
+    public ObuLoopFilterParameters LoopFilterParameters { get; set; } = new ObuLoopFilterParameters();
 
-    public ObuLoopRestorationParameters[] LoopRestorationParameters { get; internal set; } = new ObuLoopRestorationParameters[3];
+    public ObuLoopRestorationParameters[] LoopRestorationParameters { get; set; } = new ObuLoopRestorationParameters[3];
 
-    public ObuConstraintDirectionalEnhancementFilterParameters ConstraintDirectionalEnhancementFilterParameters { get; internal set; } = new ObuConstraintDirectionalEnhancementFilterParameters();
+    public ObuConstraintDirectionalEnhancementFilterParameters CdefParameters { get; set; } = new ObuConstraintDirectionalEnhancementFilterParameters();
 
-    public int ModeInfoStride { get; internal set; }
+    public int ModeInfoStride { get; set; }
 
-    public bool DisableFrameEndUpdateCdf { get; internal set; }
+    public bool DisableFrameEndUpdateCdf { get; set; }
+
+    public ObuSkipModeParameters SkipModeParameters { get; set; } = new ObuSkipModeParameters();
+
+    public Av1TransformMode TransformMode { get; set; }
+
+    public ObuDeltaLoopFilterParameters DeltaLoopFilterParameters { get; set; } = new ObuDeltaLoopFilterParameters();
+
+    public ObuDeltaQParameters DeltaQParameters { get; set; } = new ObuDeltaQParameters();
 
     internal ObuFrameSize FrameSize { get; set; } = new ObuFrameSize();
 

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuLoopFilterParameters.cs

@@ -5,5 +5,5 @@ namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
 
 internal class ObuLoopFilterParameters
 {
-    public bool[] FilterLevel { get; internal set; }
+    public int[] FilterLevel { get; internal set; } = new int[2];
 }

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuOrderHintInfo.cs

@@ -5,6 +5,8 @@ namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
 
 internal class ObuOrderHintInfo
 {
+    public bool EnableOrderHint { get; internal set; }
+
     internal bool EnableJointCompound { get; set; }
 
     internal bool EnableReferenceFrameMotionVectors { get; set; }

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuReader.cs

@@ -693,10 +693,10 @@ internal class ObuReader
             // Single image is always Intra.
         }
 
-        SetupFrameBufferReferences(sequenceHeader, frameInfo);
+        // SetupFrameBufferReferences(sequenceHeader, frameInfo);
-        CheckAddTemporalMotionVectorBuffer(sequenceHeader, frameInfo);
+        // CheckAddTemporalMotionVectorBuffer(sequenceHeader, frameInfo);
-        SetupFrameSignBias(sequenceHeader, frameInfo);
 
+        // SetupFrameSignBias(sequenceHeader, frameInfo);
         if (sequenceHeader.IsReducedStillPictureHeader || frameInfo.DisableCdfUpdate)
         {
             frameInfo.DisableFrameEndUpdateCdf = true;
@@ -704,22 +704,21 @@ internal class ObuReader
 
         if (frameInfo.PrimaryReferenceFrame == ObuConstants.PrimaryReferenceFrameNone)
         {
-            SetupPastIndependence();
+            // SetupPastIndependence();
         }
 
-        GenerateNextReferenceFrameMap(sequenceHeader, frameInfo);
+        // GenerateNextReferenceFrameMap(sequenceHeader, frameInfo);
-
         frameInfo.TilesInfo = ReadTileInfo(reader, sequenceHeader, frameInfo);
-        frameInfo.QuantizationParameters = ReadQuantizationParameters(reader, sequenceHeader.ColorConfig, planesCount);
+        ReadQuantizationParameters(reader, frameInfo.QuantizationParameters, sequenceHeader.ColorConfig, planesCount);
-        ReadSegmentationParameters(reader, sequenceHeader, frameInfo);
+        ReadSegmentationParameters(reader, sequenceHeader, frameInfo, planesCount);
-        ReadDeltaQParameters(reader, frameInfo);
+        ReadFrameDeltaQParameters(reader, frameInfo);
-        ReadDeltaLoopFilterParameters(reader, frameInfo);
+        ReadFrameDeltaLoopFilterParameters(reader, frameInfo);
-        SetupSegmentationDequantization();
 
+        // SetupSegmentationDequantization();
         Av1MainParseContext mainParseContext = new();
         if (frameInfo.PrimaryReferenceFrame == ObuConstants.PrimaryReferenceFrameNone)
         {
-            ResetParseContext(mainParseContext, frameInfo.QuantizationParameters.BaseQIndex);
+            // ResetParseContext(mainParseContext, frameInfo.QuantizationParameters.BaseQIndex);
         }
 
         int tilesCount = frameInfo.TilesInfo.TileColumnCount * frameInfo.TilesInfo.TileRowCount;
@@ -758,20 +757,20 @@ internal class ObuReader
 
         frameInfo.AllLossless = frameInfo.CodedLossless && frameInfo.FrameSize.FrameWidth == frameInfo.FrameSize.SuperResolutionUpscaledWidth;
         ReadLoopFilterParameters(reader, sequenceHeader, frameInfo, planesCount);
-        ReadConstraintDirectionalEnhancementFilterParameters(reader, sequenceHeader, frameInfo, planesCount);
+        ReadCdefParameters(reader, sequenceHeader, frameInfo, planesCount);
-        ReadLoopRestorationParameter(reader, sequenceHeader, frameInfo, planesCount);
+        ReadLoopRestorationParameters(reader, sequenceHeader, frameInfo, planesCount);
         ReadTransformMode(reader, frameInfo);
 
         frameInfo.ReferenceMode = ReadFrameReferenceMode(reader, isIntraFrame);
-        ReadSkipModeParameters(reader, frameInfo, isIntraFrame, sequenceHeader, frameInfo.ReferenceMode);
+        ReadSkipModeParameters(reader, sequenceHeader, frameInfo, isIntraFrame, frameInfo.ReferenceMode);
         if (isIntraFrame || frameInfo.ErrorResilientMode || !sequenceHeader.EnableWarpedMotion)
         {
             frameInfo.AllowWarpedMotion = false;
         }
 
-        frameInfo.ReducedTxSet = reader.ReadBoolean();
+        frameInfo.ReducedTransformSet = reader.ReadBoolean();
         ReadGlobalMotionParameters(reader, sequenceHeader, frameInfo, isIntraFrame);
-        frameInfo.FilmGrainParameters = ReadFilmGrainParameters(reader, sequenceHeader, frameInfo);
+        frameInfo.FilmGrainParameters = ReadFilmGrainFilterParameters(reader, sequenceHeader, frameInfo);
     }
 
     private static bool IsSegmentationFeatureActive(ObuSegmentationParameters segmentationParameters, int segmentId, ObuSegmentationLevelFeature feature)
@@ -839,11 +838,11 @@ internal class ObuReader
         header.PayloadSize -= headerBytes;
 
         bool noIbc = !frameInfo.AllowIntraBlockCopy;
-        bool doLoopFilter = noIbc && (frameInfo.LoopFilterParameters.FilterLevel[0] || frameInfo.LoopFilterParameters.FilterLevel[1]);
+        bool doLoopFilter = noIbc && (frameInfo.LoopFilterParameters.FilterLevel[0] != 0 || frameInfo.LoopFilterParameters.FilterLevel[1] != 0);
         bool doCdef = noIbc && (!frameInfo.CodedLossless &&
-            (frameInfo.ConstraintDirectionalEnhancementFilterParameters.BitCount ||
+            (frameInfo.CdefParameters.BitCount != 0 ||
-            frameInfo.ConstraintDirectionalEnhancementFilterParameters.YStrength[0] != 0 ||
+            frameInfo.CdefParameters.YStrength[0] != 0 ||
-            frameInfo.ConstraintDirectionalEnhancementFilterParameters.UVStrength[0] != 0));
+            frameInfo.CdefParameters.UVStrength[0] != 0));
         bool doLoopRestoration = noIbc &&
             (frameInfo.LoopRestorationParameters[(int)Av1Plane.Y].FrameRestorationType != ObuRestorationType.RestoreNone ||
             frameInfo.LoopRestorationParameters[(int)Av1Plane.U].FrameRestorationType != ObuRestorationType.RestoreNone ||
@@ -862,7 +861,7 @@ internal class ObuReader
             }
 
             // TODO: Pass more info to the decoder.
-            DecodeTile(sequenceHeader, frameInfo, tileInfo, tileNum);
+            // DecodeTile(sequenceHeader, frameInfo, tileInfo, tileNum);
         }
 
         if (tileGroupEnd != tileCount - 1)
@@ -870,7 +869,240 @@ internal class ObuReader
             return;
         }
 
-        FinishDecodeTiles(sequenceHeader, frameInfo, doCdef, doLoopRestoration);
+        // FinishDecodeTiles(sequenceHeader, frameInfo, doCdef, doLoopRestoration);
+    }
+
+    private static int ReadDeltaQ(Av1BitStreamReader reader)
+    {
+        int deltaQ = 0;
+        if (reader.ReadBoolean())
+        {
+            deltaQ = (int)reader.ReadLiteral(7);
+        }
+
+        return deltaQ;
+    }
+
+    private static void ReadFrameDeltaQParameters(Av1BitStreamReader reader, ObuFrameHeader frameInfo)
+    {
+        frameInfo.DeltaQParameters.Resolution = 0;
+        frameInfo.DeltaQParameters.IsPresent = false;
+        if (frameInfo.QuantizationParameters.BaseQIndex > 0)
+        {
+            frameInfo.DeltaQParameters.IsPresent = reader.ReadBoolean();
+        }
+
+        if (frameInfo.DeltaQParameters.IsPresent)
+        {
+            frameInfo.DeltaQParameters.Resolution = (int)reader.ReadLiteral(2);
+        }
+    }
+
+    private static void ReadFrameDeltaLoopFilterParameters(Av1BitStreamReader reader, ObuFrameHeader frameInfo)
+    {
+        frameInfo.DeltaLoopFilterParameters.IsPresent = false;
+        frameInfo.DeltaLoopFilterParameters.Resolution = 0;
+        frameInfo.DeltaLoopFilterParameters.Multi = false;
+        if (frameInfo.DeltaQParameters.IsPresent)
+        {
+            if (!frameInfo.AllowIntraBlockCopy)
+            {
+                frameInfo.DeltaLoopFilterParameters.IsPresent = reader.ReadBoolean();
+            }
+
+            if (frameInfo.DeltaLoopFilterParameters.IsPresent)
+            {
+                frameInfo.DeltaLoopFilterParameters.Resolution = (int)reader.ReadLiteral(4);
+                frameInfo.DeltaLoopFilterParameters.Multi = reader.ReadBoolean();
+            }
+        }
+    }
+
+    private static void ReadQuantizationParameters(Av1BitStreamReader reader, ObuQuantizationParameters quantParams, ObuColorConfig colorInfo, int planesCount)
+    {
+        quantParams.BaseQIndex = (int)reader.ReadLiteral(8);
+        quantParams.DeltaQDc[(int)Av1Plane.Y] = ReadDeltaQ(reader);
+        quantParams.DeltaQAc[(int)Av1Plane.Y] = 0;
+        if (planesCount > 1)
+        {
+            bool areUvDeltaDifferent = false;
+            quantParams.DeltaQDc[(int)Av1Plane.U] = ReadDeltaQ(reader);
+            quantParams.DeltaQAc[(int)Av1Plane.U] = ReadDeltaQ(reader);
+            if (areUvDeltaDifferent)
+            {
+                quantParams.DeltaQDc[(int)Av1Plane.V] = ReadDeltaQ(reader);
+                quantParams.DeltaQAc[(int)Av1Plane.V] = ReadDeltaQ(reader);
+            }
+            else
+            {
+                quantParams.DeltaQDc[(int)Av1Plane.V] = quantParams.DeltaQDc[(int)Av1Plane.U];
+                quantParams.DeltaQAc[(int)Av1Plane.V] = quantParams.DeltaQAc[(int)Av1Plane.U];
+            }
+        }
+        else
+        {
+            quantParams.DeltaQDc[(int)Av1Plane.U] = 0;
+            quantParams.DeltaQAc[(int)Av1Plane.U] = 0;
+            quantParams.DeltaQDc[(int)Av1Plane.V] = 0;
+            quantParams.DeltaQAc[(int)Av1Plane.V] = 0;
+        }
+
+        quantParams.IsUsingQMatrix = reader.ReadBoolean();
+        if (quantParams.IsUsingQMatrix)
+        {
+            quantParams.QMatrix[(int)Av1Plane.Y] = (int)reader.ReadLiteral(4);
+            quantParams.QMatrix[(int)Av1Plane.U] = (int)reader.ReadLiteral(4);
+            if (!colorInfo.HasSeparateUvDeltaQ)
+            {
+                quantParams.QMatrix[(int)Av1Plane.V] = quantParams.QMatrix[(int)Av1Plane.U];
+            }
+            else
+            {
+                quantParams.QMatrix[(int)Av1Plane.V] = (int)reader.ReadLiteral(4);
+            }
+        }
+        else
+        {
+            quantParams.QMatrix[(int)Av1Plane.Y] = 0;
+            quantParams.QMatrix[(int)Av1Plane.U] = 0;
+            quantParams.QMatrix[(int)Av1Plane.V] = 0;
+        }
+    }
+
+    private static void ReadSegmentationParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, int planesCount)
+    {
+        frameInfo.SegmentationParameters.SegmentationEnabled = reader.ReadBoolean();
+        if (!frameInfo.SegmentationParameters.SegmentationEnabled)
+        {
+            // CopyFeatureInfo();
+            return;
+        }
+
+        // TODO: Parse more stuff.
+    }
+
+    private static void ReadLoopFilterParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, int planesCount)
+    {
+        if (frameInfo.CodedLossless || frameInfo.AllowIntraBlockCopy)
+        {
+            frameInfo.LoopFilterParameters.FilterLevel[0] = 0;
+            frameInfo.LoopFilterParameters.FilterLevel[1] = 0;
+            return;
+        }
+
+        // TODO: Parse more stuff.
+    }
+
+    private static void ReadTransformMode(Av1BitStreamReader reader, ObuFrameHeader frameInfo)
+    {
+        if (frameInfo.CodedLossless)
+        {
+            frameInfo.TransformMode = Av1TransformMode.Only4x4;
+        }
+        else
+        {
+            if (reader.ReadBoolean())
+            {
+                frameInfo.TransformMode = Av1TransformMode.Select;
+            }
+            else
+            {
+                frameInfo.TransformMode = Av1TransformMode.Largest;
+            }
+        }
+    }
+
+    private static void ReadLoopRestorationParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, int planesCount)
+    {
+        _ = planesCount;
+        if (frameInfo.CodedLossless || frameInfo.AllowIntraBlockCopy || !sequenceHeader.EnableRestoration)
+        {
+            frameInfo.LoopRestorationParameters[0].FrameRestorationType = ObuRestorationType.RestoreNone;
+            frameInfo.LoopRestorationParameters[1].FrameRestorationType = ObuRestorationType.RestoreNone;
+            frameInfo.LoopRestorationParameters[2].FrameRestorationType = ObuRestorationType.RestoreNone;
+            return;
+        }
+
+        // TODO: Parse more stuff.
+    }
+
+    private static void ReadCdefParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, int planesCount)
+    {
+        _ = planesCount;
+        if (frameInfo.CodedLossless || frameInfo.AllowIntraBlockCopy || sequenceHeader.CdefLevel == 0)
+        {
+            frameInfo.CdefParameters.BitCount = 0;
+            frameInfo.CdefParameters.YStrength[0] = 0;
+            frameInfo.CdefParameters.YStrength[4] = 0;
+            frameInfo.CdefParameters.UVStrength[0] = 0;
+            frameInfo.CdefParameters.UVStrength[4] = 0;
+            frameInfo.CdefParameters.Damping = 0;
+            return;
+        }
+
+        // TODO: Parse more stuff.
+    }
+
+    private static void ReadGlobalMotionParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, bool isIntraFrame)
+    {
+        _ = reader;
+        _ = sequenceHeader;
+        _ = frameInfo;
+        if (isIntraFrame)
+        {
+            return;
+        }
+
+        // TODO: Parse more stuff.
+    }
+
+    private static ObuReferenceMode ReadFrameReferenceMode(Av1BitStreamReader reader, bool isIntraFrame)
+    {
+        if (isIntraFrame)
+        {
+            return ObuReferenceMode.SingleReference;
+        }
+
+        return (ObuReferenceMode)reader.ReadLiteral(1);
+    }
+
+    private static void ReadSkipModeParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo, bool isIntraFrame, ObuReferenceMode referenceSelect)
+    {
+        if (isIntraFrame || referenceSelect == ObuReferenceMode.ReferenceModeSelect || !sequenceHeader.OrderHintInfo.EnableOrderHint)
+        {
+            frameInfo.SkipModeParameters.SkipModeAllowed = false;
+        }
+        else
+        {
+            // TODO: Parse more stuff.
+        }
+
+        if (frameInfo.SkipModeParameters.SkipModeAllowed)
+        {
+            frameInfo.SkipModeParameters.SkipModeFlag = reader.ReadBoolean();
+        }
+        else
+        {
+            frameInfo.SkipModeParameters.SkipModeFlag = false;
+        }
+    }
+
+    private static ObuFilmGrainParameters ReadFilmGrainFilterParameters(Av1BitStreamReader reader, ObuSequenceHeader sequenceHeader, ObuFrameHeader frameInfo)
+    {
+        ObuFilmGrainParameters grainParams = new();
+        if (!sequenceHeader.AreFilmGrainingParametersPresent || (!frameInfo.ShowFrame && !frameInfo.ShowableFrame))
+        {
+            return grainParams;
+        }
+
+        grainParams.ApplyGrain = reader.ReadBoolean();
+        if (!grainParams.ApplyGrain)
+        {
+            return grainParams;
+        }
+
+        // TODO: Implement parsing.
+        return grainParams;
     }
 
     private static bool IsValidSequenceLevel(int sequenceLevelIndex)

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuSkipModeParameters.cs

@@ -0,0 +1,11 @@
+// Copyright (c) Six Labors.
+// Licensed under the Six Labors Split License.
+
+namespace SixLabors.ImageSharp.Formats.Heif.Av1.OpenBitstreamUnit;
+
+internal class ObuSkipModeParameters
+{
+    public bool SkipModeAllowed { get; set; }
+
+    public bool SkipModeFlag { get; internal set; }
+}

src/ImageSharp/Formats/Heif/Av1/OpenBitstreamUnit/ObuTileInfo.cs

@@ -23,13 +23,13 @@ internal class ObuTileInfo
 
     internal int TileColumnCount { get; set; }
 
-    internal int[] TileColumnStartModeInfo { get; set; }
+    internal int[] TileColumnStartModeInfo { get; set; } = new int[ObuConstants.MaxTileRowCount + 1];
 
     internal int MinLog2TileRowCount { get; set; }
 
     internal int TileRowCountLog2 { get; set; }
 
-    internal int[] TileRowStartModeInfo { get; set; }
+    internal int[] TileRowStartModeInfo { get; set; } = new int[ObuConstants.MaxTileColumnCount + 1];
 
     internal int TileRowCount { get; set; }