(Vp8) Write total size after writing. Separate the writes of each block

Author: Poker-sang

src/ImageSharp/Formats/Webp/BitWriter/BitWriterBase.cs

@@ -4,6 +4,7 @@
 using System.Buffers.Binary;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.Metadata.Profiles.Exif;
+using SixLabors.ImageSharp.Metadata.Profiles.Icc;
 using SixLabors.ImageSharp.Metadata.Profiles.Xmp;
 
 namespace SixLabors.ImageSharp.Formats.Webp.BitWriter;
@@ -41,30 +42,30 @@ internal abstract class BitWriterBase
 
     public byte[] Buffer => this.buffer;
 
+    /// <summary>
+    /// Gets the number of bytes of the encoded image data.
+    /// </summary>
+    /// <returns>The number of bytes of the image data.</returns>
+    public abstract int NumBytes { get; }
+
     /// <summary>
     /// Writes the encoded bytes of the image to the stream. Call Finish() before this.
     /// </summary>
     /// <param name="stream">The stream to write to.</param>
-    public void WriteToStream(Stream stream) => stream.Write(this.Buffer.AsSpan(0, this.NumBytes()));
+    public void WriteToStream(Stream stream) => stream.Write(this.Buffer.AsSpan(0, this.NumBytes));
 
     /// <summary>
     /// Writes the encoded bytes of the image to the given buffer. Call Finish() before this.
     /// </summary>
     /// <param name="dest">The destination buffer.</param>
-    public void WriteToBuffer(Span<byte> dest) => this.Buffer.AsSpan(0, this.NumBytes()).CopyTo(dest);
+    public void WriteToBuffer(Span<byte> dest) => this.Buffer.AsSpan(0, this.NumBytes).CopyTo(dest);
 
     /// <summary>
     /// Resizes the buffer to write to.
     /// </summary>
     /// <param name="extraSize">The extra size in bytes needed.</param>
     public abstract void BitWriterResize(int extraSize);
 
-    /// <summary>
-    /// Returns the number of bytes of the encoded image data.
-    /// </summary>
-    /// <returns>The number of bytes of the image data.</returns>
-    public abstract int NumBytes();
-
     /// <summary>
     /// Flush leftover bits.
     /// </summary>
@@ -86,6 +87,7 @@ protected void ResizeBuffer(int maxBytes, int sizeRequired)
     /// <summary>
     /// Writes the RIFF header to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="riffSize">The block length.</param>
     protected void WriteRiffHeader(Stream stream, uint riffSize)
@@ -99,6 +101,7 @@ protected void WriteRiffHeader(Stream stream, uint riffSize)
     /// <summary>
     /// Calculates the chunk size of EXIF, XMP or ICCP metadata.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="metadataBytes">The metadata profile bytes.</param>
     /// <returns>The metadata chunk size in bytes.</returns>
     protected static uint MetadataChunkSize(byte[] metadataBytes)
@@ -118,9 +121,26 @@ protected static uint AlphaChunkSize(Span<byte> alphaBytes)
         return WebpConstants.ChunkHeaderSize + alphaSize + (alphaSize & 1);
     }
 
+    /// <summary>
+    /// Overwrites ides the write file size.
+    /// </summary>
+    /// <param name="stream">The stream to write to.</param>
+    protected static void OverwriteFileSize(Stream stream)
+    {
+        uint position = (uint)stream.Position;
+        stream.Position = 4;
+        byte[] buffer = new byte[4];
+
+        // "RIFF"(4)+uint32 size(4)
+        BinaryPrimitives.WriteUInt32LittleEndian(buffer, position - WebpConstants.ChunkHeaderSize);
+        stream.Write(buffer);
+        stream.Position = position;
+    }
+
     /// <summary>
     /// Writes a metadata profile (EXIF or XMP) to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="metadataBytes">The metadata profile's bytes.</param>
     /// <param name="chunkType">The chuck type to write.</param>
@@ -146,13 +166,15 @@ protected void WriteMetadataProfile(Stream stream, byte[]? metadataBytes, WebpCh
     /// <summary>
     /// Writes the color profile(<see cref="WebpChunkType.Iccp"/>) to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="iccProfileBytes">The color profile bytes.</param>
     protected void WriteColorProfile(Stream stream, byte[] iccProfileBytes) => this.WriteMetadataProfile(stream, iccProfileBytes, WebpChunkType.Iccp);
 
     /// <summary>
     /// Writes the animation parameter(<see cref="WebpChunkType.AnimationParameter"/>) to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="background">
     /// The default background color of the canvas in [Blue, Green, Red, Alpha] byte order.
@@ -177,6 +199,7 @@ protected void WriteAnimationParameter(Stream stream, uint background, ushort lo
     /// <summary>
     /// Writes the animation frame(<see cref="WebpChunkType.Animation"/>) to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="animation">Animation frame data.</param>
     /// <param name="data">Frame data.</param>
@@ -201,6 +224,7 @@ protected void WriteAnimationFrame(Stream stream, AnimationFrameData animation,
     /// <summary>
     /// Writes the alpha chunk to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="dataBytes">The alpha channel data bytes.</param>
     /// <param name="alphaDataIsCompressed">Indicates, if the alpha channel data is compressed.</param>
@@ -232,14 +256,15 @@ protected void WriteAlphaChunk(Stream stream, Span<byte> dataBytes, bool alphaDa
     /// <summary>
     /// Writes a VP8X header to the stream.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
     /// <param name="exifProfile">A exif profile or null, if it does not exist.</param>
     /// <param name="xmpProfile">A XMP profile or null, if it does not exist.</param>
-    /// <param name="iccProfileBytes">The color profile bytes.</param>
+    /// <param name="iccProfile">The color profile.</param>
     /// <param name="width">The width of the image.</param>
     /// <param name="height">The height of the image.</param>
     /// <param name="hasAlpha">Flag indicating, if a alpha channel is present.</param>
-    protected void WriteVp8XHeader(Stream stream, ExifProfile? exifProfile, XmpProfile? xmpProfile, byte[]? iccProfileBytes, uint width, uint height, bool hasAlpha)
+    protected void WriteVp8XHeader(Stream stream, ExifProfile? exifProfile, XmpProfile? xmpProfile, IccProfile? iccProfile, uint width, uint height, bool hasAlpha)
     {
         if (width > MaxDimension || height > MaxDimension)
         {
@@ -279,7 +304,7 @@ protected void WriteVp8XHeader(Stream stream, ExifProfile? exifProfile, XmpProfi
             flags |= 16;
         }
 
-        if (iccProfileBytes != null)
+        if (iccProfile != null)
         {
             // Set iccp flag.
             flags |= 32;

src/ImageSharp/Formats/Webp/BitWriter/Vp8BitWriter.cs

@@ -72,7 +72,7 @@ public Vp8BitWriter(int expectedSize, Vp8Encoder enc)
     }
 
     /// <inheritdoc/>
-    public override int NumBytes() => (int)this.pos;
+    public override int NumBytes => (int)this.pos;
 
     public int PutCoeffs(int ctx, Vp8Residual residual)
     {
@@ -395,67 +395,58 @@ private void Flush()
     }
 
     /// <summary>
-    /// Writes the encoded image to the stream.
+    /// Write the trunks before data trunk.
     /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="BitWriterBase.scratchBuffer"/></remarks>
     /// <param name="stream">The stream to write to.</param>
+    /// <param name="width">The width of the image.</param>
+    /// <param name="height">The height of the image.</param>
     /// <param name="exifProfile">The exif profile.</param>
     /// <param name="xmpProfile">The XMP profile.</param>
     /// <param name="iccProfile">The color profile.</param>
-    /// <param name="width">The width of the image.</param>
-    /// <param name="height">The height of the image.</param>
     /// <param name="hasAlpha">Flag indicating, if a alpha channel is present.</param>
     /// <param name="alphaData">The alpha channel data.</param>
     /// <param name="alphaDataIsCompressed">Indicates, if the alpha data is compressed.</param>
-    public void WriteEncodedImageToStream(
+    public void WriteTrunksBeforeData(
         Stream stream,
+        uint width,
+        uint height,
         ExifProfile? exifProfile,
         XmpProfile? xmpProfile,
         IccProfile? iccProfile,
-        uint width,
-        uint height,
         bool hasAlpha,
         Span<byte> alphaData,
         bool alphaDataIsCompressed)
     {
-        bool isVp8X = false;
-        byte[]? exifBytes = null;
-        byte[]? xmpBytes = null;
-        byte[]? iccProfileBytes = null;
-        uint riffSize = 0;
-        if (exifProfile != null)
-        {
-            isVp8X = true;
-            exifBytes = exifProfile.ToByteArray();
-            riffSize += MetadataChunkSize(exifBytes!);
-        }
+        // Write file size later
+        this.WriteRiffHeader(stream, 0);
 
-        if (xmpProfile != null)
+        // Write VP8X, header if necessary.
+        bool isVp8X = exifProfile != null || xmpProfile != null || iccProfile != null || hasAlpha;
+        if (isVp8X)
         {
-            isVp8X = true;
-            xmpBytes = xmpProfile.Data;
-            riffSize += MetadataChunkSize(xmpBytes!);
-        }
+            this.WriteVp8XHeader(stream, exifProfile, xmpProfile, iccProfile, width, height, hasAlpha);
 
-        if (iccProfile != null)
-        {
-            isVp8X = true;
-            iccProfileBytes = iccProfile.ToByteArray();
-            riffSize += MetadataChunkSize(iccProfileBytes);
-        }
+            if (iccProfile != null)
+            {
+                this.WriteColorProfile(stream, iccProfile.ToByteArray());
+            }
 
-        if (hasAlpha)
-        {
-            isVp8X = true;
-            riffSize += AlphaChunkSize(alphaData);
+            if (hasAlpha)
+            {
+                this.WriteAlphaChunk(stream, alphaData, alphaDataIsCompressed);
+            }
         }
+    }
 
-        if (isVp8X)
-        {
-            riffSize += ExtendedFileChunkSize;
-        }
+    /// <summary>
+    /// Writes the encoded image to the stream.
+    /// </summary>
+    /// <param name="stream">The stream to write to.</param>
+    public void WriteEncodedImageToStream(Stream stream)
+    {
+        uint numBytes = (uint)this.NumBytes;
 
-        this.Finish();
-        uint numBytes = (uint)this.NumBytes();
         int mbSize = this.enc.Mbw * this.enc.Mbh;
         int expectedSize = (int)((uint)mbSize * 7 / 8);
 
@@ -469,12 +460,10 @@ public void WriteEncodedImageToStream(
         uint pad = vp8Size & 1;
         vp8Size += pad;
 
-        // Compute RIFF size.
-        // At the minimum it is: "WEBPVP8 nnnn" + VP8 data size.
-        riffSize += WebpConstants.TagSize + WebpConstants.ChunkHeaderSize + vp8Size;
+        // Emit header and partition #0
+        this.WriteVp8Header(stream, vp8Size);
+        this.WriteFrameHeader(stream, size0);
 
-        // Emit headers and partition #0
-        this.WriteWebpHeaders(stream, size0, vp8Size, riffSize, isVp8X, width, height, exifProfile, xmpProfile, iccProfileBytes, hasAlpha, alphaData, alphaDataIsCompressed);
         bitWriterPartZero.WriteToStream(stream);
 
         // Write the encoded image to the stream.
@@ -483,16 +472,31 @@ public void WriteEncodedImageToStream(
         {
             stream.WriteByte(0);
         }
+    }
 
+    /// <summary>
+    /// Write the trunks after data trunk.
+    /// </summary>
+    /// <remarks>Think of it as a static method — none of the other members are called except for <see cref="BitWriterBase.scratchBuffer"/></remarks>
+    /// <param name="stream">The stream to write to.</param>
+    /// <param name="exifProfile">The exif profile.</param>
+    /// <param name="xmpProfile">The XMP profile.</param>
+    public void WriteTrunksAfterData(
+        Stream stream,
+        ExifProfile? exifProfile,
+        XmpProfile? xmpProfile)
+    {
         if (exifProfile != null)
         {
-            this.WriteMetadataProfile(stream, exifBytes, WebpChunkType.Exif);
+            this.WriteMetadataProfile(stream, exifProfile.ToByteArray(), WebpChunkType.Exif);
         }
 
         if (xmpProfile != null)
         {
-            this.WriteMetadataProfile(stream, xmpBytes, WebpChunkType.Xmp);
+            this.WriteMetadataProfile(stream, xmpProfile.Data, WebpChunkType.Xmp);
         }
+
+        OverwriteFileSize(stream);
     }
 
     private uint GeneratePartition0()
@@ -512,7 +516,7 @@ private uint GeneratePartition0()
 
         this.Finish();
 
-        return (uint)this.NumBytes();
+        return (uint)this.NumBytes;
     }
 
     private void WriteSegmentHeader()
@@ -662,43 +666,6 @@ private void CodeIntraModes()
         while (it.Next());
     }
 
-    private void WriteWebpHeaders(
-        Stream stream,
-        uint size0,
-        uint vp8Size,
-        uint riffSize,
-        bool isVp8X,
-        uint width,
-        uint height,
-        ExifProfile? exifProfile,
-        XmpProfile? xmpProfile,
-        byte[]? iccProfileBytes,
-        bool hasAlpha,
-        Span<byte> alphaData,
-        bool alphaDataIsCompressed)
-    {
-        this.WriteRiffHeader(stream, riffSize);
-
-        // Write VP8X, header if necessary.
-        if (isVp8X)
-        {
-            this.WriteVp8XHeader(stream, exifProfile, xmpProfile, iccProfileBytes, width, height, hasAlpha);
-
-            if (iccProfileBytes != null)
-            {
-                this.WriteColorProfile(stream, iccProfileBytes);
-            }
-
-            if (hasAlpha)
-            {
-                this.WriteAlphaChunk(stream, alphaData, alphaDataIsCompressed);
-            }
-        }
-
-        this.WriteVp8Header(stream, vp8Size);
-        this.WriteFrameHeader(stream, size0);
-    }
-
     private void WriteVp8Header(Stream stream, uint size)
     {
         Span<byte> buf = stackalloc byte[WebpConstants.TagSize];

src/ImageSharp/Formats/Webp/BitWriter/Vp8LBitWriter.cs

@@ -47,6 +47,9 @@ public Vp8LBitWriter(int expectedSize)
     {
     }
 
+    /// <inheritdoc/>
+    public override int NumBytes => this.cur + ((this.used + 7) >> 3);
+
     /// <summary>
     /// Initializes a new instance of the <see cref="Vp8LBitWriter"/> class.
     /// Used internally for cloning.
@@ -98,9 +101,6 @@ public void WriteHuffmanCodeWithExtraBits(HuffmanTreeCode code, int codeIndex, i
         this.PutBits((uint)((bits << depth) | symbol), depth + nBits);
     }
 
-    /// <inheritdoc/>
-    public override int NumBytes() => this.cur + ((this.used + 7) >> 3);
-
     public Vp8LBitWriter Clone()
     {
         byte[] clonedBuffer = new byte[this.Buffer.Length];
@@ -166,7 +166,7 @@ public void WriteEncodedImageToStream(Stream stream, ExifProfile? exifProfile, X
         }
 
         this.Finish();
-        uint size = (uint)this.NumBytes();
+        uint size = (uint)this.NumBytes;
         size++; // One byte extra for the VP8L signature.
 
         // Write RIFF header.
@@ -177,7 +177,7 @@ public void WriteEncodedImageToStream(Stream stream, ExifProfile? exifProfile, X
         // Write VP8X, header if necessary.
         if (isVp8X)
         {
-            this.WriteVp8XHeader(stream, exifProfile, xmpProfile, iccBytes, width, height, hasAlpha);
+            this.WriteVp8XHeader(stream, exifProfile, xmpProfile, iccProfile, width, height, hasAlpha);
 
             if (iccBytes != null)
             {