Kerry D. Wong » GDI+

Understanding “A generic error occurred in GDI+.” Error

kwong — Fri, 16 Nov 2007 03:33:04 +0000

When dealing with GDI+ in .Net (e.g. certain objects in System.Drawing namespace), we would sometimes get the following exception:

System.Runtime.InteropServices.ExternalException: "A generic error occurred in GDI+."

Debugging this exception can be extremely frustrating as it can happen under many different circumstances (here and here), and the error message is too generic to provide any useful information.

This exception mostly occurs when trying to write over an image opened by an Image or Bitmap object. For example, the following code snippet will generate this error:

            Image img = Image.FromFile(fileName);
            try
            {
                img.Save(fileName); //throws exception!
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

The method listed above tries to open an image file, process the image (code not shown) and then save the image under the same file name. Unfortunately, due to the way GDI+ handles images, the image file was locked during the whole life time of the img object. And thus an exception was thrown from the underlying Windows API.

Based on Microsoft’s Knowledgebase article’s recommendations, we can prevent this exceptions in two ways (see the article for details):

1. Create a non-indexed image:

        public void Method1()
        {
            Image img = Image.FromFile(fileName);
            Bitmap bmp = img as Bitmap;
            Graphics g = Graphics.FromImage(bmp);
            Bitmap bmpNew = new Bitmap(bmp);
            g.DrawImage(bmpNew, new Point(0, 0));
            g.Dispose();
            bmp.Dispose();
            img.Dispose();
 
            //code to manipulate bmpNew goes here.
 
            bmpNew.Save(fileName);
        }

2. Create an indexed image:

        public void Method2()
        {
            Image img = Image.FromFile(fileName);
            Bitmap bmp = img as Bitmap;
 
            BitmapData bmpData = bmp.LockBits(new Rectangle(0, 0, img.Width, img.Height), ImageLockMode.ReadWrite, bmp.PixelFormat);
 
            int byteCount = bmpData.Stride * bmpData.Height;
            byte[] bytes = new byte[byteCount];
 
            Marshal.Copy(bmpData.Scan0,  bytes,0, byteCount);
            bmp.UnlockBits(bmpData);
 
            Bitmap bmpNew = new Bitmap(bmp.Width, bmp.Height);
            BitmapData bmpData1 = bmpNew.LockBits(new Rectangle(new Point(), bmpNew.Size), ImageLockMode.ReadWrite, bmp.PixelFormat);
            Marshal.Copy(bytes, 0, bmpData1.Scan0, bytes.Length);
            bmpNew.UnlockBits(bmpData1);
            bmp.Dispose();
 
            //code to manipulate bmpNew goes here.
            bmpNew.Save(fileName);
        }

As can be seen, both methods utilize a secondary image to hold a copy of the original image and makes modifications there. The second image is effectively decoupled from the original one since an explicit copy is made in either method.

The source code of this article can be downloaded here.

GDI+ Unable to Handle JPEG Compressed TIFF Images

kwong — Thu, 15 Nov 2007 02:55:28 +0000

A few weeks ago, I wrote about the lousy error message handling in GDI+. Apparently, it is not only just lousy, but incomplete as well.

Earlier today at work, I was converting a few TIFF images using a tool I developed a couple of months ago. I encountered "Out of Memory" errors on a few of those images and given my experience before, I had assumed that those images were corrupted (e.g. the header information is invalid). This became somewhat more evident when I tried to open them using the Windows default image viewer (Windows Picture and Fax Viewer), which complained that the image could not be opened.

So at first, I thought that the images were corrupted indeed. But after talking with the engineer who gathered the image, I found out that there was nothing wrong with those images as the same "unreadable" images can be opened by a lot of third party tools. As it turned out, those "unreadable" images are JPEG compressed TIFF images.

After some research, I came to the conclusion that GDI+ in Windows (XP and Server 2003) simply could not handle this type of TIFF file. When opened the returning message is the same as if the file header was not recognized. While I did not find any official article from Microsoft that states such a problem, the following knowledge base article pretty much admitted it.

The workaround mentioned in the knowledge base article however, does not work for me as in my particular situation, the reading of the images need to be autonomous.

As a fast work around due to the time constraint, I used a free command line utility to convert the JPEG compressed TIFF into non-compressed TIFF and sure enough, the formerly unreadable images were read successfully.

Lousy GDI+ Error Messages

kwong — Wed, 24 Oct 2007 01:07:19 +0000

I have heard many people complaining about how GDI+ handles errors. It seems that many of the GDI+ error messages are either too broad to have any concrete meanings (e.g. "A generic error occurred in GDI+") or simply just misleading.

Trying to open an empty (0 byte) file of any type using Image.FromFile(…) function in .Net would result in an "Out of memory" exception.

The .Net Image.FromFile() function simply wraps around a GDI+ function GdipLoadImageFromFile and returns whatever error code the underlying function returns. And when an empty file is passed to the FromFile() function, the return code is 3 which translates into "Out of memory".

To me, this is really misleading, and I wonder how many developers had been scratching their heads trying to figure out what went wrong with their code when prompted with this error message. I wish Microsoft could have changed it to something more meaningful and in this case something like "Invalid image header" or "Invalid image file format"?