🔒 Locked

BITMAP optimization

Started by biowarrior Dec 5, 2005 at 5:17 AM 8 replies 600+ views

Original Post

Dec 5, 2005 at 5:17 AM

Hey Guys, if someone can help me, I'll be thankful. Well, I have a program which transfer the bitmap (DIB Section) from a MFC's CImage object to an array of integers, which is my pixels array. Here's the code: for (unsigned int y = 0; y < height; y++) { int line = y * width; for (unsigned int x = 0; x < width; x++) { // Extract color information for pixel and build an equivalent Java pixel // for storage in the Java-based integer array. // The CImage::GetPixel return an pixel in the following format: 0xAARRGGBB // But java.awt.Image needs a image in the follow format: 0xAABBGGRR // Where: // A = alpha, R=red, G=green, B=blue, // And the 'or' operator (|) is used to make the image opaque: A=0xFF // This code is very inefficient, try other approaches COLORREF pixel = (COLORREF)cImage.GetPixel(x,y); pixel = 0xff000000 | RGB(GetBValue(pixel), GetGValue(pixel), GetRValue(pixel)); // Store the pixel in the array at the appropriate index. pixelsArray[line + x] = (jint) pixel; } } As you can see, I get pixel by pixel the image from CImage object and put it in my pixel array. This code is extremelly slow and is consuming too much time and processing of my application. Here's the deal, I need performance in this specific code! First of all, my objective was make that code work, now I need to improve that! The most important thing is that I have to make a swith from RGB to BGR pixel format, because the object which will receive the filled array interpret the bytes/pixels in that format. Thanks

Emmanuel Deloget

431

Emmanuel Deloget

Dec 5, 2005 at 6:11 AM

Hello,

1) you can use either [code][/code] or [source lang="cpp"][/source] tags to write code that will be easier to read.

2) If you know how to gain access to the internal pointer of your CImage object, you can use this pointer to read your pixels. To be able to correctly read your bitmap data, you need to know:

the pointer to the beginning of the data
the height and the width of the image
the pitch (ie the distance in bytes from the beginning of one line to the beginning of the next line).

The pitch is equal to

pitch = ((width+3)&(~3))*(bpp)

bpp is bytes per pixel. The address of pixel (x, y) is then

byte *pixeladdr = imagebegin + y * pitch + x * bpp;

Of course, you can use the same kind of addressing that you are using with your java image buffer:

byte *linebegin = imagebegin + y;byte *p = linebegin;for (int x=0; x<width; x++) [  p = linebegin + (x * bpp);  // or even simple and faster, since you avoid the multiply:  // p += bpp; (for each iteration)}

The only problem for me is that I don't know the CImage lib very well (I did my own when I needed one) thus I don't know how to get the image pointer from your CImage instance :P

3) concerning your java image it can help you a lot if you define a union type like this:

union ArgbPixel{  unsigned int argb;  struct   {    unsigned char a, r, g, b;  }};

Your code can be greatly simplified:

  ArgbPixel *pixelArray;  ArgbPixel pixel;  // ...  pixel.argb = cImage.GetPixel(x,y);  std::swap(pixel.r, pixel.g);  pixelArray[line+x].argb = pixel.argb;

HTH,

biowarrior

Author

biowarrior

Dec 5, 2005 at 10:35 AM

Thanks guys, your codes helped me a lot.

The code is at least ten times faster, my benchmark indicates a gain ratio of 95 percent.

biowarrior

Author

biowarrior

Dec 5, 2005 at 11:06 AM

Another thing, someone knows how could I avoid the following multiplication:

line = y * width;

where width is constant through the loop and y variable?

(x << 5) evaluates to the same value as (x * 32), but is very faster! But it only works on number of power of two, like 2, 4, 8, 16, 32, 64, etc. How could I do the same with numbers like 320 and 240, which aren't (at all) multiples of two.

Another thing, anyone here already work with JAI or know something related?

biowarrior

Author

biowarrior

Dec 6, 2005 at 5:35 AM

Ok, you're right, although I gained about 100 ms doing that, every impovement is worth.

My code became this:

unsigned int javaLine = 0;unsigned int cppLine = 0;for (unsigned int y = 0; y < height; y++) {  for (unsigned int x = 0; x < width; x++) {    int index = cppLine + (x << shiftBPP); // = cppLine + (x * bytesPerPixel)    // Notice that I switch from RGB to BGR through index changing    unsigned int pixel = 0xff000000 	| (bitmap[index+2] << 16)					| (bitmap[index+1] << 8) 					| bitmap[index];    pixelsArray[javaLine + x] = (jint) pixel;  }  javaLine += width;  cppLine += pitch;}

biowarrior

Author

biowarrior

Dec 6, 2005 at 5:40 AM

Maybe I did a mistake by specifying that cppLine is unsigned, because my pitch could be negative, but It worked anyway.

Do you see anithing that can be improved in that code?

Topic Locked

This topic has been locked by a moderator. New replies are not allowed.