Is it possible to optimize this Bilinear Image Resizing Method more?

Question

I'm trying to write a speedy bilinear image resizer, for displaying images so it doesn't need to me 100% accurate, just look correct.
So far i've come up with
     public static final Image resampleImage(Image orgImage, int newWidth, int newHeight) {
          int orgWidth = orgImage.getWidth();
          int orgHeight = orgImage.getHeight();
          int orgLength = orgWidth * orgHeight;
          int orgMax = orgLength - 1;
          int[] rawInput = new int[orgLength];
          orgImage.getRGB(rawInput, 0, orgWidth, 0, 0, orgWidth, orgHeight);
          int newLength = newWidth * newHeight;
          int[] rawOutput = new int[newLength];
          int yd = (orgHeight / newHeight - 1) * orgWidth;
          int yr = orgHeight % newHeight;
          int xd = orgWidth / newWidth;
          int xr = orgWidth % newWidth;
          int outOffset = 0;
          int inOffset = 0;
          // Whole pile of non array variables for the loop.
          int pixelA, pixelB, pixelC, pixelD;
          int xo, yo;
          int weightA, weightB, weightC, weightD;
          int redA, redB, redC, redD;
          int greenA, greenB, greenC, greenD;
          int blueA, blueB, blueC, blueD;
          int red, green, blue;
          for (int y = newHeight, ye = 0; y > 0; y--) {
               for (int x = newWidth, xe = 0; x > 0; x--) {
                    // Set source pixels.
                    pixelA = inOffset;
                    pixelB = pixelA + 1;
                    pixelC = pixelA + orgWidth;
                    pixelD = pixelC + 1;
                    // Get pixel values from array for speed, avoiding overflow.
                    pixelA = rawInput[pixelA];
                    pixelB = pixelB > orgMax ? pixelA : rawInput[pixelB];
                    pixelC = pixelC > orgMax ? pixelA : rawInput[pixelC];
                    pixelD = pixelD > orgMax ? pixelB : rawInput[pixelD];
                    // Calculate pixel weights from error values xe & ye.
                    xo = (xe << 8) / newWidth;
                    yo = (ye << 8) / newHeight;
                    weightD = xo * yo;
                    weightC = (yo << 8) - weightD;
                    weightB = (xo << 8) - weightD;
                    weightA = 0x10000 - weightB - weightC - weightD;
                    // Isolate colour channels.
                    redA = pixelA >> 16;
                    redB = pixelB >> 16;
                    redC = pixelC >> 16;
                    redD = pixelD >> 16;
                    greenA = pixelA & 0x00FF00;
                    greenB = pixelB & 0x00FF00;
                    greenC = pixelC & 0x00FF00;
                    greenD = pixelD & 0x00FF00;
                    blueA = pixelA & 0x0000FF;
                    blueB = pixelB & 0x0000FF;
                    blueC = pixelC & 0x0000FF;
                    blueD = pixelD & 0x0000FF;
                    // Calculate new pixels colour and mask.
                    red = 0x00FF0000 & (redA * weightA + redB * weightB + redC * weightC + redD * weightD);
                    green = 0xFF000000 & (greenA * weightA + greenB * weightB + greenC * weightC + greenD * weightD);
                    blue = 0x00FF0000 & (blueA * weightA + blueB * weightB + blueC * weightC + blueD * weightD);
                    // Store pixel in output buffer and increment offset.
                    rawOutput[outOffset++] = red + (((green | blue) >> 16));
                    // Increment input by x delta.
                    inOffset += xd;
                    // Correct if we have a roll over error.
                    xe += xr;
                    if (xe >= newWidth) {
                         xe -= newWidth;
                         inOffset++;
               // Increment input by y delta.
               inOffset += yd;
               // Correct if we have a roll over error.
               ye += yr;
               if (ye >= newHeight) {
                    ye -= newHeight;
                    inOffset += orgWidth;
          return Image.createRGBImage(rawOutput, newWidth, newHeight, false);
     }I was wondering if anyone can see any problems with this, or suggest any faster ways of doing this.
Thanks
Edited by: chris.beswick on Nov 5, 2008 3:24 AM
Edited by: chris.beswick on Nov 5, 2008 3:40 AM - Changed title to reflect what I am after.

Answer 1

Thanks for the reply.
Sadly, both the methods in the link are for simple nearest neighbour resizing, which looks god awefull. In addition the first one on the page is insanely slow only only needed with much versions of J2ME that do not support directly accessing pixel data from Image (via getRGB()).
I started with something like the second example, and have them tweaked it down while adding in the weighted re sampling of the 4 nearest pixels, to remove jaggies. I've managed to get my "bilinear" version to be only around 4 times slower than nearest neighbour, which given that it reads 4 times the data for each pixel is not bad... just wondering if I can go any faster :D
My current intention is it use a fast nearest neighbour while the image is being moved around / zoomed, and then when there is a pause in user input update the image with the bilinear image.
Also, I'm trying to use variables (xA, xB, xC, xD) in place of arrays(x[0], x[1]. x[2]. x[3]) as I've read somewhere it is faster as there is no need for bounds checks when accessing a variable unlike an array,
Finally, does anyone have any good ideas on using bit shifting to approximate all the multiplication (ie x << 8 instead of x * 256) of the pixels by weights, the resulting answer may be "wrong" but if it is close enough it might work.
Chris
Edited by: chris.beswick on Nov 5, 2008 4:14 AM