How to check if the image is too large to open it?

Question

If the specified image file contains an image too large, in term of required memory to load it, an OutOfMemoryError is raised. For the same reason, if the scale factor of a scaling operation would create a too large image, an OutOfMemoryError is raised as follows:

Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap space
    at java.awt.image.DataBufferInt.<init>(DataBufferInt.java:75)
    at java.awt.image.Raster.createPackedRaster(Raster.java:467)
    at java.awt.image.DirectColorModel.createCompatibleWritableRaster(DirectColorModel.java:1032)
    at java.awt.image.BufferedImage.<init>(BufferedImage.java:340)
    at java.awt.image.AffineTransformOp.createCompatibleDestImage(AffineTransformOp.java:461)
    at java.awt.image.AffineTransformOp.filter(AffineTransformOp.java:226)

Is it be possible to prevent this error from occurring, by performing some preliminary check? For example, if the application determines the maximum image size (in pixels) that can be loaded into memory by the amount of available memory, you could avoid performing scaling, whose resulting image would have a number of pixels greater than the determined limit.

How to handle the above problem with an image that is to be read from file? How to get the size of an image file without load it in memory? This problem could be handled using the solutions proposed in this Q&A: this solution is very fast bacause the image size is read from the file, without loading the whole image.

In summary...

The first target consists in performing a preliminary check in order to get the size of the image to show, without load the whole image:

if the image is an image file, this can be achieved using the solution proposed in this Q&A;
if the target image is the result of a scaling procedure, just multiply the size of the current image by the specified scale factor.

In both cases, you get the size of the image that should be loaded into memory, ie the total number of pixels. This value could be compared to a value limit. But, how to calculate this value limit? How to determine the maximum image size or the maximum number of pixels that can be loaded into memory by the amount of available memory?

Could you add the code for how you're loading the image now? It will help determine your options. — Alex Taylor, Aug 23 '15 at 07:32
http://stackoverflow.com/a/12164026/1898397 this answer looks relevant. — Tarun Gupta, Aug 23 '15 at 07:33
@TarunGupta: Thanks! The answer to [this question](http://stackoverflow.com/questions/672916/how-to-get-image-height-and-width-using-java) provide a way to get the image size from file, without loading the entire image. — enzom83, Aug 23 '15 at 07:45
I slightly modified the question, because the first problem was solved by the previous comments, so only the second problem remains. — enzom83, Aug 23 '15 at 07:55
Why can't you just catch the `OutOfMemoryException`? Note that checks before opening might not provide any guarantee that you would avoid the exception anyway. — skyking, Aug 23 '15 at 08:10

Harald K · Accepted Answer · 2015-08-23T09:49:13.580

As you seem to already have found out, from looking at the linked answers and comments, you can obtain the ImageReader for a given format, then ask the reader for dimensions of the final image. However, even if the VM has enough free memory, keep in mind that a BufferedImage needs a contiguous block of memory, and that the largest block available may be a lot smaller than the available memory, due to fragmentation. AFAIK there's no API to find the size of the "largest continuous block of memory" from a VM.

It is possible to create the image up front, before attempting to decode, by using code like this (simplified for readability):

ImageReader reader; // the reader for your format
reader.setInput(input); // your input

// Create image from type specifier
ImageTypeSpecifier spec = reader.getImageTypes(0).next();
BufferedImage destination = spec.createBufferedImage(reader.getWidth(), reader.getHeight();

ImageReadParam param = reader.getDefaultReadParam();
param.setDestination(destination);

reader.read(0, param);  // Image will be decoded to destination

However, keep in mind that the decoding process may need a bit of extra memory for data structures, buffers etc., to efficiently decode images. So even if you know the dimensions, or even have the destination image in memory, there's still a possibility that you will run out of memory while decoding.

(Both creating a destination image up front and the memory used by the process also applies to AffineTransformOp or any BufferedImageOp, really).

So, I think I'll second @skykings advice, you should eventually handle the OutOfMemoryError in some way. It's virtually impossible to guarantee that you have enough memory to decode a given image up front.

How to check if the image is too large to open it?

1 Answers1