New Bitmap: ArgumentException was unhandled Parameter is not valid

Anusorn W

Dear Sir,

I just try to write very simple code to create Bitmap file

"Bitmap b = new Bitmap (16500, 12500, PixelFormat.Format24bppRgb);"

But I got Error Message "ArgumentException was Unhandled. Parameter is not valid"

My PC got 2 GB Ram and at the time it still available for 1.2 GB. From above image size,
it should use only 16500*12500*3 = 618,750,000 byte.

   I don't know what it's wrong. Or it have such limitation on this syntax.
   Please kindly help to advice.

Anusron W.

7 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes15y ago
The online version of MSDN (http://msdn.microsoft.com/en-us/library/system.gc.gettotalmemory.aspx) does now say that the return value of GC.GetTotalMemory() is:

"A number that is the best available approximation of the number of bytes currently allocated in managed memory."

However, I agree that the Bitmap constructor should call GC.AddMemoryPressure() to tell the runtime that memory has been allocated on the unmanaged heap but, as far as I can see, doesn't do.

I also agree that it would be helpful if the constructor threw a more informative exception so you knew straight away what the problem was.
Zoran Horvat15y ago
That's all true, but Bitmap constructor should call GC.AddMemoryPressure() method as soon as it finds out how much actual RAM its calls to GDI have allocated. Now I've been digging about GC.GetTotalMemory() and GC.AddMemoryPressure() methods and found out something that I didn't know before - GetTotalMemory returns only memory allocated on the managed heap. I can only blame MSDN's incomplete sentence which says:

GC.GetTotalMemory Method
Retrieves the number of bytes currently thought to be allocated.

The same sentence is also popped up by intellisense when you try to type GC.GetTotalMemory, making coders think wrong every time they call this method. Now it is clear that it should say: Retrieves the number of bytes currently thought to be allocated on managed heap. For example in Pro C# 2008 the author defines GetTotalMemory method much more precise: Returns the estimated amount of memory (in bytes) currently allocated on the managed heap.

That would explain why GDI memory does not count. This is an example how MSDN fails to define .NET good enough which in turn produces misunderstandings in code.

There is one more thing that crossed my mind. Again I'm turning back to a misleading ArgumentException. Much better choice would be System.InsufficientMemoryException, which is normally thrown before operation is conducted which is known in advance to end up in OutOfMemoryException. So it would be more informative if Bitmap constructor just threw InsufficientMemoryException when too large a bitmap was attempted to be created.

Zoran
Vulpes15y ago
The Bitmap constructor calls the GDI+ function GDipCreateBitmapFromScan0 under the hood which allocates memory for the Bitmap from the unmanaged heap. This is why there's no 'out of memory' exception though an ArgumentException does bubble up from the unmanaged function.

Also, the GC is only concerned with managed memory and never cleans up unmanaged memory which is no longer used. The latter is the job of the Bitmap.Dispose() method which calls GdipDisposeImage() to do this.
Zoran Horvat15y ago
I've done a little test with this and results are interesting. First of all, ArgumentException should not be the result of insufficient resources, and that was suspicious to me from the beginning. Benchmark code is this:

using System;
using System.Drawing;
using System.Drawing.Imaging;

namespace ConsoleApplication
{
    class Program
    {

        static void Main(string[] args)
        {

            bool failed = false;
            int width = 1000;

            while (!failed)
            {
                try
                {
                    Bitmap b = new Bitmap(width, 1000, PixelFormat.Format24bppRgb);
                    Console.WriteLine("Passed with {0} megapixels (allocated {1} megabytes; bitmap size: {2}x{3})", width / 1000, GC.GetTotalMemory(false), b.Width, b.Height);
                    width *= 2;
                }
                catch (System.Exception ex)
                {
                    Console.WriteLine("Failed for {0} megapixels", width / 1000);
                    Console.WriteLine(ex);
                    failed = true;
                }
            }

            Console.ReadLine();
        }

    }
}

It allocates larger and larger bitmaps, tracking memory consumption and exceptions. At the same time, I'm ensuring that bitmap (variable b) is not garbage collected by printing its dimensions. And this is the output on my computer (which has 4 GB of RAM, by the way):
Passed with 1 megapixels (allocated 186836 megabytes; bitmap size: 1000x1000)
Passed with 2 megapixels (allocated 195028 megabytes; bitmap size: 2000x1000)
Passed with 4 megapixels (allocated 195028 megabytes; bitmap size: 4000x1000)
Passed with 8 megapixels (allocated 195028 megabytes; bitmap size: 8000x1000)
Passed with 16 megapixels (allocated 195028 megabytes; bitmap size: 16000x1000)
Passed with 32 megapixels (allocated 195028 megabytes; bitmap size: 32000x1000)
Passed with 64 megapixels (allocated 195028 megabytes; bitmap size: 64000x1000)
Passed with 128 megapixels (allocated 195028 megabytes; bitmap size: 128000x1000)
Failed for 256 megapixels
System.ArgumentException: Parameter is not valid.
   at System.Drawing.Bitmap..ctor(Int32 width, Int32 height, PixelFormat format)
   at ConsoleApplication.Program.Main(String[] args) in ...

What seems odd here is that memory consumption does not grow, not even as memory pressure. That last part is also very suspicious because memory consumption of the process grows as new larger instances of bitmap are allocated. This indicates that Bitmap class does not add memory pressure to the GC, which probably has something to do with memory management under Windows - like GDI-consumed memory does not count into whatever other objects count in. Anyway, I would expect that memory to be included in GC's count but it is not.

When I made a change to the code, by just doing b.Dispose() after the status printout, the result was that it has failed one step further, when trying to allocate 512 millions of pixels in bitmap, which is consistent with the fact that memory consumption was the cause of the problem.

What remains a bit of mistery is this: why would Bitmap constructor throw argument exception instead of OutOfMemory exception. Maybe because it did not run out of memory, but only would run out of memory should it really create the bitmap as requested. Another question is why MSDN says nothing about this case. For .NET Framework 4 they only say this:
ArgumentException - A PixelFormat value is specified whose name does not start with Format. For example, specifying Gdi will cause an ArgumentException, but Format48bppRgb will not.

So the result seems to be this - Bitmap constructor fails if its execution would lead to out of memory condition or something similar (maybe out of handles has the same effect, ect.).

Zoran
Vulpes15y ago
On most Windows systems, a process is limited to 2 GB total memory of which around 1.4 MB is actually available for use after you've deducted the memory needed for loaded dlls etc.

Depending on what else you're doing, the figure can be much lower than 1.4 MB if the large object heap (objects >= 85K) becomes fragmented as no compaction takes place when old objects are destroyed.

So, my guess is that the system is unable to allocate the 600 MB needed for the Bitmap which is why you're getting the ArgumentException.

If you have any other large bitmaps in memory which are no longer needed, I'd call Dispose() on these before attempting to create the new one. Similarly, if you have any large arrays or other collections which are not needed I'd set all references to these to null.

I'd then call GC.Collect() to free up as much memory as possible, before you try to create the new Bitmap.
Anusorn W15y ago
Dear Zoran,

      Thanks for your kindly reply my issue.

      I'm very sure this error message came out from this line and I tried to do as your suggestion.
And I got message as following.

       System.ArgumentException: Parameter is not valid.
         at System.Drawing.Bitmap..ctor(Int32 width, Int32 height, PixelFormat format)
         at AOI_Solution0.OpenJob.btnOpen_Click(Object sender, EventArgs e) in D:\Bluezens\Document\Software Application\AOI SOLUTION0 V1.506 Add Setup Project1\AOI_Solution0\AOI_Solution0\OpenJob.cs:line 238

      And I would like to know how is your system memory size. I'm not so sure whether it related to this matter or not.
As above Line 238 is syntax to create Bitmap which I got error message.

      Please kindly give more advice to me once again.

Regards
Anusorn W.
Zoran Horvat15y ago
Anusorn,

This statement works fine on my computer. Are you sure that this is the precise line on which exception was raised? Also, if you wrap this line in try-catch block, is there an inner exception that could give more information? Something like this:

try
{
    Bitmap b = new Bitmap(16500, 12500, PixelFormat.Format24bppRgb);
}
catch (System.Exception ex)
{
    Console.WriteLine(ex);
    if (ex.InnerException != null)
        Console.WriteLine("Inner exception: {0}", ex.InnerException);   // This will also be present in WriteLine(ex) above
}

Zoran