Convert WebP to PNG or JPEG, and back, in C#

dotnet add package Darnelix.Webp

A Windows Forms project already has System.Drawing. A console or ASP.NET Core project adds it with: dotnet add package System.Drawing.Common.

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;
using Darnelix.Webp;
using Darnelix.Webp.Decoding;
// Both libraries have a type called PixelFormat. Name the two apart once, here.
using GdiPixelFormat = System.Drawing.Imaging.PixelFormat;
using WebpPixelFormat = Darnelix.Webp.PixelFormat;

// Windows only: System.Drawing writes the PNG and the JPEG, Darnelix.Webp reads the WebP.
public static class WebpToImage
{
    public static void ToPng(string webpPath, string pngPath)
    {
        using Bitmap bitmap = Decode(webpPath);
        bitmap.Save(pngPath, ImageFormat.Png);
    }

    // JPEG has no alpha channel, so the image is flattened onto a background colour first.
    public static void ToJpeg(string webpPath, string jpegPath, long quality = 90, Color? background = null)
    {
        using Bitmap decoded = Decode(webpPath);
        using var flat = new Bitmap(decoded.Width, decoded.Height, GdiPixelFormat.Format24bppRgb);
        using (Graphics graphics = Graphics.FromImage(flat))
        {
            graphics.Clear(background ?? Color.White);
            graphics.DrawImageUnscaled(decoded, 0, 0);
        }

        ImageCodecInfo jpeg = Array.Find(ImageCodecInfo.GetImageEncoders(), c => c.FormatID == ImageFormat.Jpeg.Guid)!;
        using var parameters = new EncoderParameters(1);
        parameters.Param[0] = new EncoderParameter(Encoder.Quality, quality);
        flat.Save(jpegPath, jpeg, parameters);
    }

    static Bitmap Decode(string webpPath)
    {
        byte[] file = File.ReadAllBytes(webpPath);

        // BGRA with straight alpha is the memory layout of Format32bppArgb, so no channel is swapped.
        var options = new WebpDecodeOptions { PixelFormat = WebpPixelFormat.Bgra32 };
        using WebpImage image = WebpDecoder.Decode(file, options);
        byte[] pixels = image.Pixels.ToArray();
        int rowBytes = image.Width * 4;

        var bitmap = new Bitmap(image.Width, image.Height, GdiPixelFormat.Format32bppArgb);
        BitmapData data = bitmap.LockBits(
            new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.WriteOnly, GdiPixelFormat.Format32bppArgb);
        try
        {
            // Row by row: the decoder's rows are tightly packed, the bitmap's are data.Stride apart.
            for (int y = 0; y < image.Height; y++)
            {
                Marshal.Copy(pixels, y * rowBytes, data.Scan0 + y * data.Stride, rowBytes);
            }
        }
        finally
        {
            bitmap.UnlockBits(data);
        }

        return bitmap;
    }
}

Usage: WebpToImage.ToPng("photo.webp", "photo.png"); or WebpToImage.ToJpeg("photo.webp", "photo.jpg", 90);

using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;
using Darnelix.Webp;
using Darnelix.Webp.Encoding;
using GdiPixelFormat = System.Drawing.Imaging.PixelFormat;
using WebpPixelFormat = Darnelix.Webp.PixelFormat;

// Windows only: System.Drawing reads the PNG or the JPEG, Darnelix.Webp writes the WebP.
public static class ImageToWebp
{
    // Every pixel survives exactly. The usual choice for a PNG: screenshots, UI, line art.
    public static void Lossless(string imagePath, string webpPath)
    {
        byte[] bgra = ReadBgra(imagePath, out int width, out int height);

        // A new WebpEncodeOptions is zero throughout. Set every field you rely on.
        var options = new WebpEncodeOptions { Lossless = true, Method = 4, AlphaQuality = 100 };
        File.WriteAllBytes(webpPath, WebpEncoder.Encode(bgra, width, height, WebpPixelFormat.Bgra32, options));
    }

    // Smaller files, some loss. The usual choice for a photograph, which is what most JPEGs are.
    public static void Lossy(string imagePath, string webpPath, float quality = 80f)
    {
        byte[] bgra = ReadBgra(imagePath, out int width, out int height);

        var options = new WebpEncodeOptions { Quality = quality, Method = 4, FilterStrength = 60, AlphaQuality = 100 };
        File.WriteAllBytes(webpPath, WebpEncoder.Encode(bgra, width, height, WebpPixelFormat.Bgra32, options));
    }

    static byte[] ReadBgra(string imagePath, out int width, out int height)
    {
        using var bitmap = new Bitmap(imagePath);
        width = bitmap.Width;
        height = bitmap.Height;

        // Asking LockBits for Format32bppArgb converts whatever the file held: 24-bit, indexed, greyscale.
        BitmapData data = bitmap.LockBits(
            new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, GdiPixelFormat.Format32bppArgb);
        try
        {
            // The encoder wants tightly packed rows, so copy each row without the bitmap's padding.
            int rowBytes = width * 4;
            byte[] bgra = new byte[rowBytes * height];
            for (int y = 0; y < height; y++)
            {
                Marshal.Copy(data.Scan0 + y * data.Stride, bgra, y * rowBytes, rowBytes);
            }

            return bgra;
        }
        finally
        {
            bitmap.UnlockBits(data);
        }
    }
}

Usage: ImageToWebp.Lossless("logo.png", "logo.webp"); or ImageToWebp.Lossy("photo.jpg", "photo.webp", 80f);

using System.IO;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using Darnelix.Webp;
using Darnelix.Webp.Decoding;
using Darnelix.Webp.Encoding;
using WebpPixelFormat = Darnelix.Webp.PixelFormat;

// Windows only: WPF's encoders and decoders (the Windows Imaging Component) handle the PNG and
// the JPEG, Darnelix.Webp handles the WebP. Needs <UseWPF>true</UseWPF> in the project file.
public static class WebpWic
{
    public static void ToPng(string webpPath, string pngPath)
    {
        Save(new PngBitmapEncoder(), Decode(webpPath, WebpPixelFormat.Bgra32, PixelFormats.Bgra32), pngPath);
    }

    // Decoding to BGR24 discards the alpha channel. It does not blend onto a background: a pixel
    // that was transparent keeps whatever colour the file stored under it.
    public static void ToJpeg(string webpPath, string jpegPath, int quality = 90)
    {
        var encoder = new JpegBitmapEncoder { QualityLevel = quality };
        Save(encoder, Decode(webpPath, WebpPixelFormat.Bgr24, PixelFormats.Bgr24), jpegPath);
    }

    public static void FromImage(string imagePath, string webpPath)
    {
        BitmapSource source;
        using (FileStream input = File.OpenRead(imagePath))
        {
            // OnLoad reads the whole file now, so the stream can close before the pixels are used.
            BitmapDecoder decoder = BitmapDecoder.Create(
                input, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
            source = new FormatConvertedBitmap(decoder.Frames[0], PixelFormats.Bgra32, null, 0);
        }

        int stride = source.PixelWidth * 4;
        byte[] bgra = new byte[stride * source.PixelHeight];
        source.CopyPixels(bgra, stride, 0);

        var options = new WebpEncodeOptions { Lossless = true, Method = 4, AlphaQuality = 100 };
        File.WriteAllBytes(
            webpPath,
            WebpEncoder.Encode(bgra, source.PixelWidth, source.PixelHeight, WebpPixelFormat.Bgra32, options));
    }

    static BitmapSource Decode(string webpPath, WebpPixelFormat layout, System.Windows.Media.PixelFormat format)
    {
        byte[] file = File.ReadAllBytes(webpPath);
        var options = new WebpDecodeOptions { PixelFormat = layout };
        using WebpImage image = WebpDecoder.Decode(file, options);

        int stride = image.Width * (format.BitsPerPixel / 8);
        return BitmapSource.Create(
            image.Width, image.Height, 96, 96, format, null, image.Pixels.ToArray(), stride);
    }

    static void Save(BitmapEncoder encoder, BitmapSource source, string path)
    {
        encoder.Frames.Add(BitmapFrame.Create(source));
        using FileStream output = File.Create(path);
        encoder.Save(output);
    }
}

The project file needs <UseWPF>true</UseWPF> and a target framework ending in -windows.