Java CMYK to RGB conversion – speed comparison of DIY versus letting Java do it

Some optimisations are best left to Java. For example a System.arraycopy is the fastest way to create a new version because it is optimised in hardware inside Java. So in general, any function which might have hardware optimisation is best left to the JVM.

So what about image data conversion? Is it better to delegate it to Java or Do It Yourself? I have been looking at a file which was slow to decode. The bottleneck turned out to be the CMYK to RGB conversion so I decided to have  a look…

My original code used a ColorConvertOp to do the image conversion on the raw CMYK data and then create an RGB image with the converted data. Here is the code.

int[] bands = { 0, 1, 2, 3 };

/**turn it into a BufferedImage so we can filter*/DataBuffer db = new DataBufferByte(data, data.length);

/**create RGB colorspace and model*/ColorSpace rgbCS=GenericColorSpace.getColorSpaceInstance();

/**define the conversion. hints can be replaced with null*/ColorConvertOp CSToRGB = new ColorConvertOp(
   DeviceCMYKColorSpace.getColorSpaceInstance(), rgbCS, 
   ColorSpaces.hints);

/**create RGB colorspace and model*/ComponentColorModel rgbModel = new ComponentColorModel(
   rgbCS, new int[] { 8, 8, 8 }, false, false, ColorModel.OPAQUE, 
   DataBuffer.TYPE_BYTE);

image =new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);

WritableRaster rgbRaster=rgbModel.
   createCompatibleWritableRaster(width, height);

CSToRGB.filter(Raster.createInterleavedRaster(db, width, 
   height, width*4, 4, bands, null), rgbRaster);

image.setData(rgbRaster);

On the sample page it takes 73 seconds on my fast Mac.

Version 2 does the pixel conversion manually and then builds the image from that. A major advantage of this is that I can add optimisations. In this case I cache the last value so I only need to do the conversion if the value changes – on an empty page of 10,000 white pixels I will get a massive boost as I only need to convert the value once and reuse it.

ColorSpace CMYK=DeviceCMYKColorSpace.getColorSpaceInstance();

BufferedImage image = null;

byte[] new_data = new byte[w * h * 3];

int pixelCount = w * h*4;

float lastC=-1,lastM=-1,lastY=-1,lastK=-1;
float C, M, Y, K;
float[] rgb=new float[3];

/**
* loop through each pixel changing CMYK values to RGB
*/int pixelReached = 0;

for (int i = 0; i < pixelCount; i = i + 4) {

C = (buffer[i]&0xff)/255f;
M = (buffer[i + 1]&0xff)/255f;
Y = (buffer[i + 2]&0xff)/255f;
K = (buffer[i + 3]&0xff)/255f;

if(lastC==C && lastM==M && lastY==Y && lastK==K){
//use existing values if not changed
}else{//work out new

rgb=CMYK.toRGB(new float[]{C,M,Y,K});

//cache values
lastC=C;
lastM=M;
lastY=Y;
lastK=K;

}

new_data[pixelReached++]=(byte)(rgb[0]*255);
new_data[pixelReached++]=(byte)(rgb[1]*255);
new_data[pixelReached++]=(byte) (rgb[2]*255);
}

/**
* turn data into RGB image
*/image =new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
Raster raster = createInterleavedRaster(new_data, w, h);
image.setData(raster);

The method is longer, but what is the speed difference? On my Mac this takes an astonishing 11 seconds! My next task is to see whether it is the same on other platforms…

I’ve kept the old code (in the hope Oracle one day optimises the filter function), but for the moment you can guess which version I am using…

Have you found any similar cases where a DIY approach is much faster?

Why do developers choose JDeli over free alternatives?

1. Works with newer image formats such as AVIF, HEIC, JPEG XL, WEBP (AVIF next release) that are not supported in Java.
2. Better support than alternatives for JPEG, PNG, TIFF.
3. Process images up to 3x faster than ImageIO and other Java image libraries.
4. Prevent JVM crashes caused by native code in other image libraries such as ImageIO.
5. Image security as JDeli processes images on your servers with no calls to any external system or third party library.

// Read an image
BufferedImage bufferedImage = JDeli.read(dicomImageFile);

// Read an image
BufferedImage bufferedImage = JDeli.read(heicImageFile);

// Write an image
JDeli.write(bufferedImage, "heic", outputStreamOrFile);

// Read an image
BufferedImage bufferedImage = JDeli.read(jpegImageFile);

// Write an image
JDeli.write(bufferedImage, "jpeg", outputStreamOrFile);

// Read an image
BufferedImage bufferedImage = JDeli.read(jpeg2000ImageFile);

// Write an image
JDeli.write(bufferedImage, "jpx", outputStreamOrFile);

// Write an image
JDeli.write(bufferedImage, "pdf", outputStreamOrFile);

// Read an image
BufferedImage bufferedImage = JDeli.read(pngImageFile);

// Write an image
JDeli.write(bufferedImage, "png", outputStreamOrFile);

// Read an image
BufferedImage bufferedImage = JDeli.read(tiffImageFile);

// Write an image
JDeli.write(bufferedImage, "tiff", outputStreamOrFile);

// Read an image
BufferedImage bufferedImage = JDeli.read(webpImageFile);

// Write an image
JDeli.write(bufferedImage, "webp", outputStreamOrFile);