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