Serializing an Image

Creating an image from an array of data is an easy task, but to create a byte-array of data from an image is a little more complicated. But it's required if you want to send a modified image to a server.

To create a byte-array of data from an image, we can use the getRGB(..) method in the image class in MIDP 2.0. From the getRGB method we get an int-array of data containing all the ARGB values of each pixel in the image. Integers in java are four bytes, so we need to split each int value into four byte values.

To mask out each of the bytes in the int we can use the 'AND &' operator and the 'shift-right >>' operator. Here's an example:

<!---->int ARGB = 0xFFFFFFFF;  // AARRGGBB 
int a = (ARGB & 0xFF000000); 
int r = (ARGB & 0x00FF0000); 
int g = (ARGB & 0x0000FF00); 
int b = (ARGB & 0x000000FF);
 
// Here we move each bit to the right.
a = (a >> 24); // a = 0x000000FF 
r = (r >> 16); // r = 0x000000FF 
g = (g >> 8); // g = 0x000000FF
b = b;        // b = 0x000000FF

When we convert the integer to a byte, there are some problems since there are only signed bytes in Java. A byte may contain values between -128 and 127 and from our integer we'll have a value between 0 and 255.

Here are some conversion examples:

<!---->
Integer val 127 = byte val 127.
Integer val 128 = byte val -128.
Integer val 255 = byte val -1.

byte ba = (byte)(a);  // if a=0x000000FF (255), then ba = -1
byte br = (byte)(r); 
byte bg = (byte)(g); 
byte bb = (byte)(b);

We have to loop though each pixel in the image and get each pixel value to our byte-array. When that's done, we can send the image to a server where we can convert the byte-array back to a integer-array and then show our picture.

So, when we convert the byte back to an integer we have to check if the byte value is less than zero.

<!---->int a, r, g, b;
if(ba<0)
     a = 256 - a;

Now our new integer value will be between 0 and 255 and we just have to use the 'shift-left <<' operator and add the values together to get our new int-array.

<!---->a = (a << 24);
r = (r << 16);
g = (g << 8);
b = (b);
 
  0xFF000000 (a)
+ 0x00FF0000 (r)
+ 0x0000FF00 (g)
+ 0x000000FF (b)
= 0xFFFFFFFF (argb)
 
int ARGB = a+r+g+b;

After the integer-array is recreated we can use the createRGBImage(..) method in the Image class to create our image.

Be aware that the byte-array is quite large as it contains all of the ARGB values for each pixel. If an image is 100*60 px, where each pixel is four bytes, the byte array will be 24kb.
example code