How to shrink an image to a target size in bytes in C#?

Question

How to shrink an image to a target size in bytes in C#? Specifically, I am looking to take an image uploaded to an ASP.NET full framework application and shrink it so that it is less or equal to a maximum number of bytes (e.g. 1 MB). I am OK with the dimensions of the image being shrunk as well and can accept some loss of image quality.

Answer 1

If you have access to System.Drawing (.NET Full Framework) then this code works. This algorithm is a bit naive because it simply keeps shrinking the dimensions of the image by 10% until the target size is reached or a maximum number of attempts has been exceeded. It could be improved and made less brute force.

using System.Drawing;
using System.IO;

public static class ImgUtil
{
    /// <summary>
    /// Attempt to shrink an image down to a target size in bytes. If the input image is 
    /// already small enough, it will be returned unaltered. If the image needs to be 
    /// shrunk, the output image will be smaller in terms of width/height but the width/height
    /// ratio will be preserved. There can be some loss of quality. The method attempts to
    /// shrink the dimensions of he image incrementally until the number of bytes is equal or
    /// less than the target. There is a maximum number of attempts. If the maximum number of
    /// attempts is reached, the output image may be larger than the target size.
    /// </summary>
    /// <param name="imageBytes">>Byte array containing the image to be shrunk.</param>
    /// <param name="targetSizeBytes">Target size in bytes.</param>
    /// <param name="maxAttempts">Maximum number of shrink attempts, reducing the dimensions by 10% each attempt.</param>
    /// <returns></returns>
    public static byte[] ShrinkImage(byte[] imageBytes, int targetSizeBytes, int maxAttempts = 10)
    {
        using (var ms = new MemoryStream(imageBytes))
        using (var img = Image.FromStream(ms))
        {
            var attempts = 1;
            var newWidth = img.Width;
            var newHeight = img.Height;
            while ((imageBytes.Length > targetSizeBytes) && (attempts <= maxAttempts))
            {
                // Shrink by 10%
                newWidth = (int)(newWidth * 0.9);
                newHeight = (int)(newHeight * 0.9);

                using (var bitmap = new Bitmap(img, new Size(newWidth, newHeight)))
                using (var outputMs = new MemoryStream())
                {
                    bitmap.Save(outputMs, img.RawFormat);
                    imageBytes = outputMs.ToArray();
                }

                attempts++;
            }
        }

        return imageBytes;
    }
}