How do determine if an image is partially corrupt? C#

Question

I have raw bytes for an image. I use the following to code to determine if the image is corrupt or not

public bool IsValidGDIPlusImage(byte[] imageData)
{
    try
    {
        using (var ms = new MemoryStream(imageData))
        {
            using (var bmp = new Bitmap(ms))
            {
            }
        }
        return true;
    }
    catch (Exception ex)
    {
        return false;
    }
}

If the image is completely corrupt the above code works fine, but what If I have an image that is partially corrupt? Like the JPEG below

How do I determine that the image is partially corrupt?

The original image being below which a simple 300x300 pixel image with a diagonal line from the centre.

Any guidance is highly appreciated. Thanks

Answer 1

Detecting partially damaged images is tough.

A simplistic approach is to check if the start and end byte marks are complete like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Net;
using System.IO;
using System.Drawing;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            try {

                var imgBytes = Helper.DownloadImageAsBytes("https://i.stack.imgur.com/KQI1j.jpg");
                //valid GDI+? Example true!
                Console.WriteLine(IsValidGDIPlusImage(imgBytes));
                //Complete? Example false
                ImageFile imgFile = new ImageFile(imgBytes);
                Console.WriteLine(imgFile.Complete);

            }
            catch(Exception ex)
            {
                Console.Write(ex.Message);
            }
        }

        public static bool IsValidGDIPlusImage(byte[] imageData)
        {
            try
            {
                using (var ms = new MemoryStream(imageData))
                {
                    using (var bmp = new Bitmap(ms))
                    {
                    }
                }
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
    }
}

public class Helper {
    public static byte[] DownloadImageAsBytes(String url) {
        using (var webClient = new WebClient()) { 
            return webClient.DownloadData(url);
        }
    }
}

public class ImageFile {

    private Types  _eFileType   = Types.FileNotFound;
    private bool   _blComplete  = false             ;
    public bool Complete
    {
        get { return _blComplete; }
    }
    private int    _iEndingNull = 0                 ;

    private readonly byte[] _abTagPNG  = { 137, 80, 78, 71, 13, 10, 26, 10  };
    private readonly byte[] _abTagJPG  = { 255, 216, 255                    };
    private readonly byte[] _abTagGIFa = { 71, 73, 70, 56, 55, 97           };
    private readonly byte[] _abTagGIFb = { 71, 73, 70, 56, 57, 97           };
    private readonly byte[] _abEndPNG  = { 73, 69, 78, 68, 174, 66, 96, 130 };
    private readonly byte[] _abEndJPGa = { 255, 217, 255, 255               };
    private readonly byte[] _abEndJPGb = { 255, 217                         };
    private readonly byte[] _abEndGIF  = { 0, 59                            };

    public enum Types { FileNotFound, FileEmpty, FileNull, FileTooLarge, FileUnrecognized, PNG, JPG, GIFa, GIFb }

    public ImageFile(byte[] abtTmp) {

        _eFileType = Types.FileUnrecognized; // default if found

        //byte[] abtTmp = File.ReadAllBytes(_sFilename);
        // check the length of actual data
        int iLength = abtTmp.Length;
        if(abtTmp[abtTmp.Length - 1] == 0) {
            for(int i = (abtTmp.Length - 1); i > -1; i--) {
                if(abtTmp[i] != 0) {
                    iLength = i;
                    break;
                }
            }
        }
        // check that there is actual data
        if(iLength == 0) {
            _eFileType = Types.FileNull;
        } else {
            _iEndingNull = (abtTmp.Length - iLength);
            // resize the data so we can work with it
            Array.Resize<byte>(ref abtTmp, iLength);
            // get the file type
            if(_StartsWith(abtTmp, _abTagPNG)) {
                _eFileType = Types.PNG;
            } else if(_StartsWith(abtTmp, _abTagJPG)) {
                _eFileType = Types.JPG;
            } else if(_StartsWith(abtTmp, _abTagGIFa)) {
                _eFileType = Types.GIFa;
            } else if(_StartsWith(abtTmp, _abTagGIFb)) {
                _eFileType = Types.GIFb;
            }
            // check the file is complete
            switch(_eFileType) {
                case Types.PNG:
                    _blComplete = _EndsWidth(abtTmp, _abEndPNG);
                    break;
                case Types.JPG:
                    _blComplete = (_EndsWidth(abtTmp, _abEndJPGa) || _EndsWidth(abtTmp, _abEndJPGb));
                    break;
                case Types.GIFa:
                case Types.GIFb:
                    _blComplete = _EndsWidth(abtTmp, _abEndGIF);
                    break;
            }
            // get rid of ending null bytes at caller's option
            //if(_blComplete && cullEndingNullBytes) File.WriteAllBytes(_sFilename, abtTmp);
        }

    }


    public Types  FileType        { get { return _eFileType  ; } }
    public bool   IsComplete      { get { return _blComplete ; } }
    public int    EndingNullBytes { get { return _iEndingNull; } }

    private bool _StartsWith(byte[] data, byte[] search) {
        bool blRet = false;
        if(search.Length <= data.Length) {
            blRet = true;
            for(int i = 0; i < search.Length; i++) {
                if(data[i] != search[i]) {
                    blRet = false;
                    break;
                }
            }
        }
        return blRet; // RETURN
    }

    private bool _EndsWidth(byte[] data, byte[] search) {
        bool blRet = false;
        if(search.Length <= data.Length) {
            int iStart = (data.Length - search.Length);
            blRet = true;
            for(int i = 0; i < search.Length; i++) {
                if(data[iStart + i] != search[i]) {
                    blRet = false;
                    break;
                }
            }
        }
        return blRet; // RETURN
    }
}

This works at least for some (more) images but it can not detect images with damaged data between the start and end sections.

References:

• https://www.dreamincode.net/forums/topic/286802-detect-partially-corrupted-image/
• https://stackoverflow.com/a/5139214/8291949 Quote:

You can try some things, but with certain file formats (example: BMP, JPEG to some extent) only a human can ultimately decide if the file is OK or corrupted.

There is open software out for this purpose, recommend to take a look at Bad Peggy (Java). If you are willing to use a bigger library, OpenCV could be useful.

Answer 2

I know I'm rather late to the party here - but I've just been looking into doing the same thing, for JPEG images downloaded over a network (that can sometimes include a satellite link, which is prone to drop-outs).

As per the page at: https://www.file-recovery.com/jpg-signature-format.htm - JPEG images always end with the last two bytes FF D9. So, for JPEG images, you can simply read the last two bytes, and if they don't match those values, then the image isn't complete. Of course, you may have enough of the image for it to render almost perfectly, and that test won't pick up corrupt data in the middle of the file - but as a quick and dirty test for an incomplete file, it works.

I notice that wp78de's solution from two years ago is doing just that (as well as testing for FF D9 FF FF, which I guess means some JPEG images have a four byte end marker?).

Hope that helps.