What is the best way to resize a JPEG and store it in the Filesystem

Question

Hi All,
I have developped a CMS System that renders JPEGs if it does not have the images available within the desired width already. Within my development setup (Dell Latitude D800 with ubuntu dapper drake) everything works fine and fast, as expected. Then I uploaded the application to my V20Z Server with 4gb RAM and the systems performance goes to its knees. I have hooked in a Java Profiler to see where the problem is, and it showed me that it is hanging wthin
sun.java2d.SunGraphics2D.drawImage(Image, int, int, ImageObserver) which I use to draw my Image to a BufferedImage. Below is my complete source code That I am using. Plus the orofiling results
Do not be confused as I am using the Turbine Framework, which gives me a RawScreen which gives me Access to the HttpServletResponse...
package de.ellumination.carmen.modules.screens;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.Locale;
import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.plugins.jpeg.JPEGImageWriteParam;
import javax.imageio.stream.ImageOutputStream;
import javax.servlet.http.HttpServletResponse;
import org.apache.log4j.Logger;
import org.apache.turbine.modules.screens.RawScreen;
import org.apache.turbine.util.RunData;
import de.ellumination.carmen.om.ImagePeer;
public class Image extends RawScreen
public static final float DEFAULT_COMPRESSION_QUALITY = 1.0F;
* Logger for this class
private static final Logger log = Logger.getLogger(Image.class);
@Override
protected String getContentType(RunData data)
return "image/jpeg";
@Override
protected void doOutput(RunData data) throws Exception
int imageId = data.getParameters().getInt("id");
int width = data.getParameters().getInt("width", -1);
int height = data.getParameters().getInt("height", -1);
HttpServletResponse response = data.getResponse();
de.ellumination.carmen.om.Image image = ImagePeer.retrieveByPK(imageId);
File imgFile = new File(image.getLocation());
if(width > 0 || height > 0)
outputScaledImage(imgFile, response, width, height);
else
outputImage(imgFile, response);
private void outputScaledImage(File imageFile, HttpServletResponse response, int width, int height) throws Exception
File scaledFile = new File(imageFile.getParent() + System.getProperty("file.separator") + width + "_" + imageFile.getName());
if(scaledFile.exists())
outputImage(scaledFile, response);
else
scaleImage(imageFile, scaledFile, width);
outputImage(scaledFile, response);
private void outputImage(File imageFile, HttpServletResponse response) throws Exception
FileInputStream in = new FileInputStream(imageFile);
response.setContentLength((int) imageFile.length());
OutputStream out = response.getOutputStream();
int bSize = 10240;
byte[] buffer = new byte[bSize];
int inBuffer = 0;
while (inBuffer >= 0)
inBuffer = in.read(buffer);
if (inBuffer > 0)
out.write(buffer, 0, inBuffer);
* scales the image to its new size. while scaling the Image, the code first resizes the image using the new Width Parameter.
* If the Image is to high after scaling, it then uses the Images height to determin the scaling Factor.
* @param inputFile the original Image
* @param outputFile the File to store the scaled image to
* @param compressionQuality the compression Quality to use
* @param newWidth the desired images width
* @param newHeight the desired images height
public static void scaleImage(File inputFile, File outputFile, float compressionQuality, int newWidth, int newHeight)
try
if (inputFile.exists())
BufferedImage hiRes = ImageIO.read(inputFile);
double scaleFactor = (double) newWidth / (double) hiRes.getWidth(null);
int tempHeight = (int) (hiRes.getHeight(null) * scaleFactor);
if (tempHeight > newHeight)
scaleFactor = (double) newHeight / (double) hiRes.getHeight(null);
int width = (int) (hiRes.getWidth(null) * scaleFactor);
int height = (int) (hiRes.getHeight(null) * scaleFactor);
scaleImage(outputFile, compressionQuality, hiRes, width, height);
catch (IOException e)
log.error("Unable to create the thumbnail " + outputFile.getAbsolutePath() + " from " + inputFile.getAbsolutePath() + " because of the following Reason.", e);
* scales the image to its new size. while scaling the Image, the code first resizes the image using the new Width Parameter.
* If the Image is to high after scaling, it then uses the Images height to determine the scaling Factor. This method uses the
* default compression quality to store image data.
* @param inputFile the original Image
* @param outputFile the File to store the scaled image to
* @param newWidth the desired images width
* @param newHeight the desired images height
public static void scaleImage(File inputFile, File outputFile, int newWidth, int newHeight)
scaleImage(inputFile, outputFile, DEFAULT_COMPRESSION_QUALITY, newWidth, newHeight);
* scales the image to its new size. while scaling the Image, the code first resizes the image using the new Width Parameter.
* uses the highest image compression quality by default.
* @param inputFile the original Image
* @param outputFile the File to store the scaled image to
* @param compressionQuality the compression Quality of the new Image
* @param newWidth the desired images width
public static void scaleImage(File inputFile, File outputFile, float compressionQuality, int newWidth)
try
if (inputFile.exists())
BufferedImage hiRes = ImageIO.read(inputFile);
double scaleFactor = (double) newWidth / (double) hiRes.getWidth(null);
int width = (int) (hiRes.getWidth(null) * scaleFactor);
int height = (int) (hiRes.getHeight(null) * scaleFactor);
// draw original image to thumbnail image object and
// scale it to the new size on-the-fly
scaleImage(outputFile, compressionQuality, hiRes, width, height);
else
log.error("Unable to create the thumbnail " + outputFile.getAbsolutePath() + " from " + inputFile.getAbsolutePath() + " because inputFile not exists: " + inputFile.getName());
catch (IOException e)
log.error("Unable to create the thumbnail " + outputFile.getAbsolutePath() + " from " + inputFile.getAbsolutePath() + " because of the following Reason.", e);
* scales the image to its new size. while scaling the Image, the code first resizes the image using the new Width Parameter.
* uses the highest image compression quality by default.
* @param inputFile the original Image
* @param outputFile the File to store the scaled image to
* @param newWidth the desired images width
public static void scaleImage(File inputFile, File outputFile, int newWidth)
scaleImage(inputFile, outputFile, DEFAULT_COMPRESSION_QUALITY, newWidth);
* This private method actually scales the inputImage to the desired height, width and compression Quality
* @param outputFile The File in which the Image should be stored.
* @param compressionQuality The Compression Quality to be applied to the image
* @param inputImage the original input Image
* @param width the height of the new Image
* @param height the width of the new Image
* @throws IOException
private static void scaleImage(File outputFile, float compressionQuality, BufferedImage inputImage, int width, int height) throws IOException
BufferedImage lowRes = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
java.awt.Image image = inputImage.getScaledInstance(width, height, java.awt.Image.SCALE_SMOOTH);
ImageWriter writer = null;
Iterator iter = ImageIO.getImageWritersByFormatName("jpg");
if (iter.hasNext()) writer = (ImageWriter) iter.next();
File outputPath = outputFile.getParentFile();
if (outputPath != null)
if (!outputPath.exists()) outputPath.mkdirs();
lowRes.getGraphics().drawImage(image, 0, 0, null);
ImageOutputStream ios = ImageIO.createImageOutputStream(outputFile);
writer.setOutput(ios);
ImageWriteParam iwparam = new JPEGImageWriteParam(Locale.getDefault());
iwparam.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwparam.setCompressionQuality(compressionQuality);
// save thumbnail image to OUTFILE
writer.write(null, new IIOImage(lowRes, null, null), iwparam);
writer.dispose();
ios.close();
image.flush();
inputImage.flush();
lowRes.flush();
* scales the image to its new size. while scaling the Image, the code first resizes the image using the new Width Parameter.
* If the Image is to high after scaling, it then uses the Images height to determin the scaling Factor.
* @param inputImage the original Image
* @param outputFile the File to store the scaled image to
* @param compressionQuality the compression Quality to use
* @param newWidth the desired images width
* @param newHeight the desired images height
public static void scaleImage(BufferedImage inputImage, File outputFile, float compressionQuality, int newWidth, int newHeight)
try
double scaleFactor = (double) newWidth / (double) inputImage.getWidth(null);
int tempHeight = (int) (inputImage.getHeight(null) * scaleFactor);
if (tempHeight > newHeight)
scaleFactor = (double) newHeight / (double) inputImage.getHeight(null);
int width = (int) (inputImage.getWidth(null) * scaleFactor);
int height = (int) (inputImage.getHeight(null) * scaleFactor);
scaleImage(outputFile, compressionQuality, inputImage, width, height);
catch (IOException e)
log.error("Unable to create the thumbnail " + outputFile.getAbsolutePath() + " because of the following Reason.", e);
All Threads     702.570     100 %
java.lang.Thread.run()     551.322     78 %
de.ellumination.carmen.modules.screens.Image.doOutput(RunData)     170.666     24 %
de.ellumination.carmen.modules.screens.Image.outputScaledImage(File, HttpServletResponse, int, int)     170.108     24 %
                         de.ellumination.carmen.modules.screens.Image.scaleImage(File, File, int)     170.108     24 %
                              de.ellumination.carmen.modules.screens.Image.scaleImage(File, File, float, int)     170.108     24 %
                                   de.ellumination.carmen.modules.screens.Image.scaleImage(File, float, BufferedImage, int, int)     165.787     24 %
                                        sun.java2d.SunGraphics2D.drawImage(Image, int, int, ImageObserver)     165.189     24 %
                                        com.sun.imageio.plugins.jpeg.JPEGImageWriter.write(IIOMetadata, IIOImage, ImageWriteParam)     397     0 %
                                        javax.imageio.ImageIO$ImageWriterIterator.next()     69     0 %
                                        javax.imageio.ImageIO.createImageOutputStream(Object)     47     0 %
                                        java.awt.image.BufferedImage.<init>(int, int, int)     36     0 %
                                        java.awt.Image.getScaledInstance(int, int, int)     23     0 %
                                        java.awt.image.BufferedImage.getGraphics()     21     0 %
                                   javax.imageio.ImageIO.read(File)     4.320     1 %
                    de.ellumination.carmen.om.BaseImagePeer.retrieveByPK(int)     557     0 %
               de.ellumination.carmen.modules.screens.Index.doBuildTemplate(RunData, Context)     1.673     0 %
          org.apache.catalina.startup.Bootstrap.main(String[])     151.225     22 %
          org.quartz.core.QuartzSchedulerThread.run()     22     0 %
Now I am looking for the Best way to solve my problem. Maybe I am wrong from the get go.
Runtime Setup Java 1.5.0_04 Tomcat 5.5.12 V20z (AMD64 Opteron 4gb RAM)
Any help is heighly appreciated
Kind regards

Answer 1

This is a bad thing to do with JPEGs. You're better off just reducing the 'q' if you want a smaller/faster/lower resolution image. That way you're throwing away resolution intelligently. Using scaling you're throwing resolution away unintelligently. I was on a project where 40,000 images were scaled when they should have been low-q'd. Don't do it.