Resizing Large JPG Problem

[Theodore Casser]

Hey, everyone. I'm stuck and need some help.
Almost two years ago, my company was asked to code a viewer application to create thumbnails on the fly from image files stored in their document library solution. The application I developed worked fine with any format, using JAI.
Recently, a problem involving huge JPG files came to my attention, as various managers at this location are suddenly discovering the higher resolution capabilities of their digital cameras. It seems to render random images (and the majority of the ones on a given page, but not always the same ones) as black boxes. I'm taking a wild guess that it's a problem due to the size of the files, but I don't quite know how to fix it.
My renderJPEG method is below - I could really use some help if anyone has suggestions, as I'm at a dead end. (This was originally coded using JDK 1.3.1 - we have moved to 1.4.2 on our server (this is part of a servlet), so if you know any optimizations for that, it's safe for us to use it.)
Thanks!

    /**
     * Renders a JPEG into the output stream from a JPEG or GIF image source.
     *
     * @param response The response back to the web browser
     * @param filePath The filepath of the image
     * @param mode Image resizing mode
     * @param maxWidth The maximum width of the final image
     * @param maxHeight The maximum height of the final image
     * @param downloadable Whether or not this image is meant for download
     */
    private void renderJPEG(HttpServletResponse response, String filePath,
        String mode, int maxWidth, int maxHeight, boolean downloadable) {
        try {
            int scaledW;
            int scaledH;
            if (downloadable) {
                response.setContentType("application/x-download-image");
            } else {
                response.setContentType("image/jpeg");
            }
            //debug("Imagetype: " + imagetype);
            BufferedOutputStream out = new BufferedOutputStream(
                response.getOutputStream());
            // Get the image from a file.
            //PlanarImage inImage = JAI.create("fileload",filePath);
            Image inImage = new ImageIcon(filePath).getImage();
            // Set the scale.
            AffineTransform tx = new AffineTransform();
            if (mode != "full") {
                // Determine the scale.
                double scale = (double) maxWidth /
                    (double) inImage.getWidth(null);
                double scaleHeight = (double) maxHeight /
                    (double) inImage.getHeight(null);
                if (scaleHeight < scale) {
                    scale = scaleHeight;
                }
                // If the image is smaller than the desired image size,
                // don't bother scaling.
                if (scale < 1.0d) {
                    tx.scale(scale, scale);
                    // Determine size of new image. One of them should equal maxDim.
                    scaledW = (int) (scale * inImage.getWidth(null));
                    scaledH = (int) (scale * inImage.getHeight(null));
                } else {
                    scaledW = inImage.getWidth(null);
                    scaledH = inImage.getHeight(null);
                }
            } else {
                scaledW = inImage.getWidth(null);
                scaledH = inImage.getHeight(null);
            }
            // Create an image buffer in which to paint the image.
            BufferedImage outImage = new BufferedImage(scaledW, scaledH,
                BufferedImage.TYPE_INT_RGB);
            // Paint image.
            Graphics2D g2d =
                outImage.createGraphics();
            g2d.drawImage(inImage, tx, null);
            g2d.dispose();
            // JPEG-encode the image and write to output stream.
            JPEGImageEncoder encoder =
                JPEGCodec.createJPEGEncoder(out);
            encoder.encode(outImage);
            out.close();
        }
        catch (IOException ioe) {
            log("Exception in renderJPEG(): " + ioe.getMessage(), ioe);
        }
    }

[ November 07, 2003: Message edited by: Theodore Casser ]

[Michael Morris]

Since you are now using 1.4 you may want to look at the new javax.imageio package. That may help to solve your problem. You could change your thumbnails to GIFs with a Transcoder or even change the metadata from the JPEGs to a lower resolution if you think that is the problem.

[Theodore Casser]

Switching to ImageIO seems to have done the trick, at least for the moment. Thanks - I figured that if I asked here, I'd get an answer I could understand PDQ.

[Jim Yingst]

This may be moot now, but: My guess is that the problem was with this line:

g2d.drawImage(inImage, tx, null);

That "null" is supposed to be an ImageObserver which monitors how far along the transformation is. It's an asynchronious API - when this method returns, the transformation has begun, not necessarily completed. If the result were being displayed with a java.awt.Component of some sort, you could use that Component as the ImageObserver, and it would be notified as more data became available, and you might see the image getting updated asynchronously after it was initially displayed. However in this case there's no ready-made Component to use as ImageObserver, so I'd make my own:

import java.awt.Image;
import java.awt.image.ImageObserver;
public class ImageWaiter implements ImageObserver {
    private boolean isDone;
    public boolean imageUpdate(
        Image img,
        int infoflags,
        int x,
        int y,
        int width,
        int height) {
        if ((infoflags & ALLBITS) > 0) {
            synchronized (this) {
                isDone = true;
                return true;
            }
        }
        return false;
    }
    public synchronized void waitFor() {
        while (!isDone)
            try {
                wait();
            } catch (InterruptedException ignore) {}
    }
}

Then use like this:

ImageWaiter waiter = new ImageWaiter();
g2d.drawImage(inImage, tx, waiter);
waiter.waitFor();

[Theodore Casser]

I've found that using an observer just really slows the page massively down. (The application displays eighteen thumbnails at a time. :-\ Don't look at me, I just programmed to the requirements.) But it's working now 100% of the time, so I'm happy.

[Jim Yingst]

I've found that using an observer just really slows the page massively down
Well yes, that's the point. You were using an API which requires time to process. If you ignore the ImageObserver, you're basically not waiting to see if that processing is completed. Naturally this makes things faster, but the disadvantage is that some of your images aren't complete.
Now the ImageObserver I provided waits for exactly one image at a time. If you're trying to display 18 thumbnails, it might well have been more efficient to process the images in parallel, in which case you might want an ImageObserver that waits until all 18 transforms are completed (but allows the different transforms to process concurrently). The MediaTracker works something like this, but I'm not sure out how to plug it in to monitor the results of an AffineTransform. So I just gave the simplest fix I could see. Certainly since you can use imageio now, that's going to be preferable; I just wanted to clarify what was probably going on in your original code.

[Theodore Casser]

Originally posted by Jim Yingst:
I've found that using an observer just really slows the page massively down
Well yes, that's the point. You were using an API which requires time to process. If you ignore the ImageObserver, you're basically not waiting to see if that processing is completed. Naturally this makes things faster, but the disadvantage is that some of your images aren't complete.

No, no, I agree that ignoring the ImageObserver does somewhat put in the risk of it coming back before the application is done processing. Which is a problem. The larger problem is I have users who don't want to hear that answer and complain more (and louder) about the speed.

So I just gave the simplest fix I could see. Certainly since you can use imageio now, that's going to be preferable; I just wanted to clarify what was probably going on in your original code.

I appreciate that. It helps me understand for the next time I have to do this. Now off to figure out how to speed this up so my users stop complaining....

[Theodore Casser]

I'm back. We've encountered a new problem, using the code developed after the above conversation. The code is much quicker now and seems to be working nicely, except...
Well, the server is occasionally now throwing an OutOfMemoryException. There isn't any way anyone can think of, perhaps, to better optimize how javax.imageio runs to avoid this, is there? Has anyone had a similar problem?