BrotliEncoder.cs

using System;
using System.IO;
using System.IO.Compression;
using System.Threading.Tasks;
using Waher.Runtime.IO;
 
namespace Waher.Networking.HTTP.Brotli
{
    public class BrotliEncoder : TransferEncoding
    {
        private readonly string? compressedFileName;
        private TransferEncoding? uncompressedStream;
        private MemoryStream? ms = null;
        private BrotliStream? brEncoder = null;
        private BrotliStream? brDecoder = null;
        private long? bytesLeft;
        private int pos = 0;
        private bool dataWritten = false;
        private bool finished = false;
 
        public BrotliEncoder(string? CompressedFileName, TransferEncoding UncompressedStream, long? ExpectedContentLength)
            : base(null, UncompressedStream)
        {
            this.compressedFileName = CompressedFileName;
            this.uncompressedStream = UncompressedStream;
            this.bytesLeft = ExpectedContentLength;
        }
 
        public void PrepareForCompression()
        {
            this.ms = new MemoryStream();
            this.brEncoder = new BrotliStream(this.ms, CompressionMode.Compress, true);
        }
 
        public override Task BeforeContentAsync(HttpResponse Response, bool ExpectContent)
        {
            return this.uncompressedStream!.BeforeContentAsync(Response, ExpectContent);
        }
 
        public override Task<ulong> DecodeAsync(bool ConstantBuffer, byte[] Data, int Offset, int NrRead)
        {
            return Task.FromResult(0x100000000UL);  // TODO: Support Content-Encoding in POST, PUT and PATCH, etc.
        }
 
        public override async Task<bool> EncodeAsync(bool ConstantBuffer, byte[] Data, int Offset, int NrBytes, bool LastData)
        {
            if (NrBytes > 0)
            {
                if (this.finished)
                    return false;
 
                this.dataWritten = true;
 
                if (this.bytesLeft.HasValue)
                {
                    if (NrBytes > this.bytesLeft.Value)
                        NrBytes = (int)this.bytesLeft.Value;
 
                    await this.brEncoder!.WriteAsync(Data, Offset, NrBytes);
 
                    this.bytesLeft -= NrBytes;
                    if (this.bytesLeft <= 0)
                    {
                        this.finished = true;
                        await this.FlushAsync(LastData);
                    }
                }
                else
                    await this.brEncoder!.WriteAsync(Data, Offset, NrBytes);
            }
 
            return true;
        }
 
        public override async Task<bool> FlushAsync(bool EndOfData)
        {
            if (this.dataWritten)
            {
                await this.brEncoder!.FlushAsync();
                this.dataWritten = false;
 
                byte[] Data = this.ms!.ToArray();
                int c = Data.Length;
                if (this.pos < c)
                {
                    c -= this.pos;
                    if (!await this.uncompressedStream!.EncodeAsync(true, Data, this.pos, c, EndOfData))
                        return false;
 
                    if (!string.IsNullOrEmpty(this.compressedFileName))
                    {
                        if (this.pos == 0)
                            await Files.WriteAllBytesAsync(this.compressedFileName, Data, this.pos, c);
                        else
                            await Files.AppendAllBytesAsync(this.compressedFileName, Data, this.pos, c);
                    }
 
                    this.pos += c;
                }
 
                return await this.uncompressedStream!.FlushAsync(EndOfData);
            }
 
            return true;
        }
 
        public override async Task<bool> ContentSentAsync()
        {
            await this.FlushAsync(true);
            return await this.uncompressedStream!.ContentSentAsync();
        }
 
        public override void Dispose()
        {
            this.uncompressedStream?.Dispose();
            this.uncompressedStream = null;
 
            this.brEncoder?.Dispose();
            this.brEncoder = null;
 
            this.brDecoder?.Dispose();
            this.brDecoder = null;
 
            this.ms?.Dispose();
            this.ms = null;
 
            base.Dispose();
        }
 
        public override bool InvalidEncoding => this.uncompressedStream!.InvalidEncoding;
 
        public override bool TransferError => this.uncompressedStream!.TransferError;
    }
}