Hi.

I don't speak English very well, so please sorry my English...

OK, i'am looking to a Source Code (In MASM of course) to Compress Images to JPEG format,
or Create Images directly to this format...

I want that the size of the images be less to 200kb to be able to send it to a server.

Please help me.
:confused: :confused: :confused:
Thanks.
Posted on 2004-07-28 14:26:16 by
Posted on 2004-07-28 19:06:06 by comrade
There are a few steps to compressing raw image data into the JPEG format:

1) Afine transformation - convert Red, Green, Blue (RGB) signals into luminance and chromimance (YCbCr). This is a simple matrix multiply:



RGB -> YCbCr
| Y | | 0.299 0.587 0.114 | | R | | 0 |
| Cb | = |- 0.1687 - 0.3313 0.5 | * | G | + |128|
| Cr | | 0.5 - 0.4187 - 0.0813| | B | |128|


It's the same taking YCbCr back to RGB, but with the differant matrix of course. Here is some sample code (written in C for which I appologize) that does both.



void RGBtoYCbCr( unsigned char r, unsigned char g, unsigned char b, unsigned char *Y, unsigned char *Cb, unsigned char *Cr )
{
// Y = 0.299 * R + 0.587 * G + 0.114 * B
(*Y) = (unsigned char)( (5016388 * r + 9848226 * g + 1912603 * b) >> 24 );
// Cb = -0.1687 * R - 0.3313 * G + 0.5 * B + 128
(*Cb) = (unsigned char)( ((8388608 * b - 2830316 * r - 5558292 * g) >> 24) + 128 );
// Cr = 0.5 * R - 0.4187 * G - 0.0813 * B + 128
(*Cr) = (unsigned char)( ((8388608 * r - 7024620 * g - 1363988 * b) >> 24) + 128 );
}


and



void YCbCrtoRGB( unsigned char Y, unsigned char Cb, unsigned char Cr, unsigned char *r, unsigned char *g, unsigned char *b )
{
// R = Y + 1.402 * (Cr-128)
(*r) = (unsigned char)( Y + ((23521657 * (Cr-128)) >> 24) );
// G = Y - 0.34414 * (Cb-128) - 0.71414 * (Cr-128)
(*g) = (unsigned char)( Y - ((-5773711 * (Cb-128) - 11981281 * (Cr-128)) >> 24) );
// B = Y + 1.772 * (Cb-128)
(*b) = (unsigned char)( Y + ((29729227 * (Cb-128)) >> 24) );
}


So, that's the first step.

2) Sampling - The JPEG standard creators realized that the human eye was more sensitive to changes in brightness rather than changes in color, the raw image data should be sampled in such a way that there is twice as much luminance (one sample per pixel) than chrominance (one sample for ever two pixels).

3) Level shift - All 8-bit YCbCr values are level shifted by converting them to a 8-bit signed representation (subtract 128).

4) Discrete Cosine Transform (DCT) - Now it starts to get really fun. The DCT converts the spacial data of the raw image into the frequency domain. This is a rather complicated process (that's a bit of an understatement), but garners amazing results. The mathematical definition of the DCT is as follows:



c(u,v) 7 7 2*x+1 2*y+1
F(u,v) = --------- * sum sum f(x,y) * cos (------- *u*PI)* cos (------ *v*PI)
4 x=0 y=0 16 16

u,v = 0,1,...,7

{ 1/2 when u=v=0
c(u,v) = { 1/sqrt(2) when u=0, v!=0
{ 1/sqrt(2) when u!=0, v=0
{ 1 otherwise


And the inverse DCT is:



1 7 7 2*x+1 2*y+1
f(x,y) = --- * sum sum c(u,v)*F(u,v)*cos (------- *u*PI)* cos (------ *v*PI)
4 u=0 v=0 16 16

x,y=0,1...7


Here is some sample source code (again written in C):



void dct8x8( int data[8][8] )
{
static const int c1 = 1004; // cos( PI / 16 ) * 2^10
static const int s1 = 200; // sin( PI / 16 ) * 2^10
static const int c3 = 851; // cos( 3 * PI / 16 ) * 2^10
static const int s3 = 569; // sin( 3 * PI / 16 ) * 2^10
static const int r2c6 = 554; // sqrt( 2 ) * cos( 6 * PI / 16 ) * 2^10
static const int r2s6 = 1337; // sqrt( 2 ) * sin( 6 * PI / 16 ) * 2^10
static const int r2 = 362; // sqrt( 2 ) * 2^8

int i, temp[8][8];
int x0, x1, x2, x3, x4, x5, x6, x7, x8;

// Do the rows...
for( i = 0 ; i < 8 ; i++ )
{
x0 = data[i][0]; x1 = data[i][1]; x2 = data[i][2]; x3 = data[i][3];
x4 = data[i][4]; x5 = data[i][5]; x6 = data[i][6]; x7 = data[i][7];

// Stage 1
x8 = x7 + x0; x0 -= x7; x7 = x1 + x6; x1 -= x6;
x6 = x2 + x5; x2 -= x5; x5 = x3 + x4; x3 -= x4;

// Stage 2
x4 = x8 + x5; x8 -= x5;
x5 = x7 + x6; x7 -= x6;
x6 = c1 * (x1 + x2); x2 = (-s1 - c1) * x2 + x6;
x1 = (s1 - c1) * x1 + x6; x6 = c3 * (x0 + x3);
x3 = (-s3 - c3) * x3 + x6; x0 = (s3 - c3) * x0 + x6;

// Stage 3
x6 = x4 + x5; x4 -= x5;
x5 = r2c6 * (x7 + x8); x7 = (-r2s6 - r2c6) * x7 + x5;
x8 = (r2s6 - r2c6) * x8 + x5; x5 = x0 + x2; x0 -= x2;
x2 = x3 + x1; x3 -= x1;

// Stage 4, rounding and output
temp[i][0] = x6; temp[i][4] = x4;
temp[i][2] = (x8+512)>>10; temp[i][6] = (x7+512)>>10;
temp[i][7] = (x2-x5+512)>>10; temp[i][1] = (x2+x5+512)>>10;
temp[i][3] = (x3*r2+65536)>>18; temp[i][5] = (x0*r2+65536)>>18;
}

// Do the columns...
for( i = 0 ; i < 8 ; i++ )
{
x0 = temp[0][i]; x1 = temp[1][i]; x2 = temp[2][i]; x3 = temp[3][i];
x4 = temp[4][i]; x5 = temp[5][i]; x6 = temp[6][i]; x7 = temp[7][i];

// Stage 1
x8 = x7 + x0; x0 -= x7; x7 = x1 + x6; x1 -= x6;
x6 = x2 + x5; x2 -= x5; x5 = x3 + x4; x3 -= x4;

// Stage 2
x4 = x8 + x5; x8 -= x5;
x5 = x7 + x6; x7 -= x6;
x6 = c1 * (x1 + x2); x2 = (-s1 - c1) * x2 + x6;
x1 = (s1 - c1) * x1 + x6; x6 = c3 * (x0 + x3);
x3 = (-s3 - c3) * x3 + x6; x0 = (s3 - c3) * x0 + x6;

// Stage 3
x6 = x4 + x5; x4 -= x5;
x5 = r2c6 * (x7 + x8); x7 = (-r2s6 - r2c6) * x7 + x5;
x8 = (r2s6 - r2c6) * x8 + x5; x5 = x0 + x2; x0 -= x2;
x2 = x3 + x1; x3 -= x1;

// Stage 4, rounding and output
data[0][i] = x6; data[4][i] = x4;
data[2][i] = (x8+512)>>10; data[6][i] = (x7+512)>>10;
data[7][i] = (x2-x5+512)>>10; data[1][i] = (x2+x5+512)>>10;
data[3][i] = (x3*r2+65536)>>18; data[5][i] = (x0*r2+65536)>>18;
}
}


and the Inverse DCT:



void idct8x8( int data[8][8] )
{
static const int c1 = 1004; // cos( PI / 16 ) * 2^10
static const int s1 = 200; // sin( PI / 16 ) * 2^10
static const int c3 = 851; // cos( 3 * PI / 16 ) * 2^10
static const int s3 = 569; // sin( 3 * PI / 16 ) * 2^10
static const int r2c6 = 554; // sqrt( 2 ) * cos( 6 * PI / 16 ) * 2^10
static const int r2s6 = 1337; // sqrt( 2 ) * sin( 6 * PI / 16 ) * 2^10
static const int r2 = 362; // sqrt( 2 ) * 2^8

int i, temp[8][8];
int x0, x1, x2, x3, x4, x5, x6, x7, x8;

// Do the rows...
for( i = 0 ; i < 8 ; i++ )
{
// Stage 4
x0 = data[i][0] << 10; x1 = data[i][1] << 8; x2 = data[i][2];
x3 = data[i][3] * r2; x4 = data[i][4] << 10; x5 = data[i][5] * r2;
x6 = data[i][6]; x7 = data[i][7] << 8; x8 = x7 + x1;
x1 -= x7;

// Stage 3
x7 = x0 + x4; x0 -= x4;
x4 = x1 + x5; x1 -= x5;
x5 = x3 + x8; x8 -= x3;
x3 = r2c6 * (x2 + x6); x6 = x3 + (-r2c6 - r2s6) * x6;
x2 = x3 + (-r2c6 + r2s6) * x2;

// Stage 2
x3 = x7 + x2; x7 -= x2;
x2 = x0 + x6; x0 -= x6;
x6 = c3 * (x4 + x5); x5 = (x6 + (-c3 - s3) * x5) >> 8;
x4 = (x6 + (-c3 + s3) * x4) >> 8;
x6 = c1 * (x1 + x8); x1 = (x6 + (-c1 - s1) * x1) >> 8;
x8 = (x6 + (-c1 + s1) * x8) >> 8;

// Stage 1, rounding and output
x7 += 4096; x2 += 4096; x0 += 4096; x3 += 4096;
temp[i][0]=(x3 + x4) >> 13; temp[i][1] = (x2 + x8) >> 13;
temp[i][2]=(x0 + x1) >> 13; temp[i][3] = (x7 + x5) >> 13;
temp[i][4]=(x7 - x5) >> 13; temp[i][5] = (x0 - x1) >> 13;
temp[i][6]=(x2 - x8) >> 13; temp[i][7] = (x3 - x4) >> 13;
}

// Do the columns...
for( i = 0 ; i < 8 ; i++ )
{
// Stage 4
x0 = temp[0][i] << 10; x1 = temp[1][i] << 8; x2 = temp[2][i];
x3 = temp[3][i] * r2; x4 = temp[4][i] << 10; x5 = temp[5][i] * r2;
x6 = temp[6][i]; x7 = temp[7][i] << 8; x8 = x7 + x1;
x1 -= x7;

// Stage 3
x7 = x0 + x4; x0 -= x4;
x4 = x1 + x5; x1 -= x5;
x5 = x3 + x8; x8 -= x3;
x3 = r2c6 * (x2 + x6); x6 = x3 + (-r2c6 - r2s6) * x6;
x2 = x3 + (-r2c6 + r2s6) * x2;

// Stage 2
x3 = x7 + x2; x7 -= x2;
x2 = x0 + x6; x0 -= x6;
x6 = c3 * (x4 + x5); x5 = (x6 + (-c3 - s3) * x5) >> 8;
x4 = (x6 + (-c3 + s3) * x4) >> 8;
x6 = c1 * (x1 + x8); x1 = (x6 + (-c1 - s1) * x1) >> 8;
x8 = (x6 + (-c1 + s1) * x8) >> 8;

// Stage 1, rounding and output
x7 += 4096; x2 += 4096; x0 += 4096; x3 += 4096;
data[0][i]=(x3 + x4) >> 13; data[1][i] = (x2 + x8) >> 13;
data[2][i]=(x0 + x1) >> 13; data[3][i] = (x7 + x5) >> 13;
data[4][i]=(x7 - x5) >> 13; data[5][i] = (x0 - x1) >> 13;
data[6][i]=(x2 - x8) >> 13; data[7][i] = (x3 - x4) >> 13;
}
}


As you can see (maybe), these functions perform a 2D DCT on an 8x8 block of image data. This can be accomplised by performing a 1D DCT on the rows, then a 1D DCT on the columns (the order doesn't matter, columns could go first).

5) Zig-zag reordering - The 64 DCT coefficients are then reordered in a zig-zag order:



0, 1, 5, 6,14,15,27,28,
2, 4, 7,13,16,26,29,42,
3, 8,12,17,25,30,41,43,
9,11,18,24,31,40,44,53,
10,19,23,32,39,45,52,54,
20,22,33,38,46,51,55,60,
21,34,37,47,50,56,59,61,
35,36,48,49,57,58,62,63


to make a 1D array of length 64.

6) Quantization - Another matrix multiplication. This time, the matrix being multiplied will determing the quality of the resulting image. A typical luminance quantization matrix could be as follows:



16 11 10 16 24 40 51 61
12 12 14 19 26 58 60 55
14 13 16 24 40 57 69 56
14 17 22 29 51 87 80 62
18 22 37 56 68 109 103 77
24 35 55 64 81 104 113 92
49 64 78 87 103 121 120 101
72 92 95 98 112 100 103 99


7) Run Length Coding - If you've ever written a library of Bitmap or Targa images, you're no doubt familiar with RLE. This is very simple so I'll leave it at that.

8) Huffman encoding - Finaly, the last step is to use a Huffman encoder to minimize the space required for common data. There are many good resource on this subject so I'll leave it to you to figure out.

-----------

So, my word of advice. Unless you want to spend many many hourse learning how to encode a JPEG image correctly, I suggest you find a free library and use it instead.

NOTE: The DCT has recently been replaced by the Descrete Wavelet Transform (DWT) which is quite a bit more complicated that the DCT, but has better results.

Spara
Posted on 2004-07-28 19:26:13 by SowWn
Wavelet compression requires some license fees, doesn't it? Or is it just that the current libraries are commercial?
Posted on 2004-07-30 06:16:59 by f0dder
A specific algorithm that performs DWT compression might require a licence, but the DWT theory itself doesn't. People have been using wavelet transforms since the turn of the 20th century.

Spara
Posted on 2004-07-30 13:52:24 by SowWn
Hello, Im trying to the same thing, and I got question to ask. I found this topic with search.
I have tryed do compression manually, so what I got:
Test image(RGB hex):
0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh
0FFFFFFh, 0000000h, 0000000h, 0000000h, 0000000h, 0000000h, 0000000h, 0FFFFFFh
0FFFFFFh, 0000000h, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0000000h, 0FFFFFFh
0FFFFFFh, 0000000h, 0FFFFFFh, 0808080h, 0808080h, 0808080h, 0000000h, 0FFFFFFh
0FFFFFFh, 0000000h, 0FFFFFFh, 0808080h, 0808080h, 0808080h, 0FFFFFFh, 0FFFFFFh
0FFFFFFh, 0000000h, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh
0FFFFFFh, 0000000h, 0000000h, 0000000h, 0000000h, 0000000h, 0000000h, 0FFFFFFh
0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh, 0FFFFFFh

Now I convert RGB to YCbCr
-----
Y  = 0.299 * R + 0.587 * G + 0.114 * B
Cb = -0.1687 * R - 0.3313 * G + 0.5 * B + 128
Cr = 0.5 * R - 0.4187 * G - 0.0813 * B + 128
-----
White (0FFFFFFh):
Y = 0.299 * 255 + 0.587 * 255 + 0.114 * 255 = 255
Cb = -0.1687 * 255 - 0.3313 * 255 + 0.5 * 255 + 128 = 128
Cr = 0.5 * 255 - 0.4187 * 255 - 0.0813 * 255 + 128 = 128
Gray (0808080h):
Y = 0.299 * 128 + 0.587 * 128 + 0.114 * 128 = 128
Cb = -0.1687 * 128 - 0.3313 * 128 + 0.5 * 128 + 128 = 128
Cr = 0.5 * 128 - 0.4187 * 128 - 0.0813 * 128 + 128 = 128
Black (0000000h):
Y = 0.299 * 0 + 0.587 * 0 + 0.114 * 0 = 0
Cb = -0.1687 * 0 - 0.3313 * 0 + 0.5 * 0 + 128 = 128
Cr = 0.5 * 0 - 0.4187 * 128 - 0.0813 * 0 + 128 = 128

Test image(YCbCr dec):
255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128
255 128 128, 000 128 128, 000 128 128, 000 128 128, 000 128 128, 000 128 128, 000 128 128, 255 128 128
255 128 128, 000 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 000 128 128, 255 128 128
255 128 128, 000 128 128, 255 128 128, 128 128 128, 128 128 128, 128 128 128, 000 128 128, 255 128 128
255 128 128, 000 128 128, 255 128 128, 128 128 128, 128 128 128, 128 128 128, 255 128 128, 255 128 128
255 128 128, 000 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128
255 128 128, 000 128 128, 000 128 128, 000 128 128, 000 128 128, 000 128 128, 000 128 128, 255 128 128
255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128, 255 128 128

Test image(YCbCr hex):
0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h
0FF8080h, 0008080h, 0008080h, 0008080h, 0008080h, 0008080h, 0008080h, 0FF8080h
0FF8080h, 0008080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0008080h, 0FF8080h
0FF8080h, 0008080h, 0FF8080h, 0808080h, 0808080h, 0808080h, 0008080h, 0FF8080h
0FF8080h, 0008080h, 0FF8080h, 0808080h, 0808080h, 0808080h, 0FF8080h, 0FF8080h
0FF8080h, 0008080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h
0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h, 0FF8080h

So, what next? Sampling. I didnt understand actually how to, I should remove Cb from each second?
Posted on 2005-06-12 13:57:56 by valka
about the DCT and IDCT : I've heard that the fastest algo for (I)DCT is "AA&N algorithm". is the above faster than this 'aa&n' ?
Posted on 2005-06-13 10:04:52 by ti_mo_n
To tell you the truth, it's been almost a year since I've looked at this code.  At the time I chose the fastest algorithm I could find which might be the one you're talking about.  I do know that it ran at a decent speed and that it worked.  That's pretty much all I was interested in at the time.

Spara

PS: Why is some other dude's name on my posts?
Posted on 2005-06-13 10:49:04 by Sparafusile
wtf? I dont care speed, how to do compression? First I do it myself to understand how it works
Posted on 2005-06-13 11:00:06 by valka

wtf? I dont care speed, how to do compression? First I do it myself to understand how it works

Since you asked in such a nice way, I feel compelled to answer.

The next step is sampling.  You already have your luminance values, but you need to cut the amount of Cb and Cr data in half (because it's not as important).  You do this by taking the average to two adjacent pixels and then using that value for both.  This way you cut the amount of data you're saving to disk by a third, but only reducing the quality by a small amount.

Spara
Posted on 2005-06-13 14:45:13 by Sparafusile
Ok then doing the Sampling:

Test image(YCbCr dec):
255 128 128, 255, 255 128 128, 255, 255 128 128, 255, 255 128 128, 255
255 128 128, 000, 000 128 128, 000, 000 128 128, 000, 000 128 128, 255
255 128 128, 000, 255 128 128, 255, 255 128 128, 255, 000 128 128, 255
255 128 128, 000, 255 128 128, 128, 128 128 128, 128, 000 128 128, 255
255 128 128, 000, 255 128 128, 128, 128 128 128, 128, 255 128 128, 255
255 128 128, 000, 255 128 128, 255, 255 128 128, 255, 255 128 128, 255
255 128 128, 000, 000 128 128, 000, 000 128 128, 000, 000 128 128, 255
255 128 128, 255, 255 128 128, 255, 255 128 128, 255, 255 128 128, 255

Test image(YCbCr hex):
0FF8080h, 0FFh, 0FF8080h, 0FFh, 0FF8080h, 0FFh, 0FF8080h, 0FFh
0FF8080h, 000h, 0008080h, 000h, 0008080h, 000h, 0008080h, 0FFh
0FF8080h, 000h, 0FF8080h, 0FFh, 0FF8080h, 0FFh, 0008080h, 0FFh
0FF8080h, 000h, 0FF8080h, 080h, 0808080h, 080h, 0008080h, 0FFh
0FF8080h, 000h, 0FF8080h, 080h, 0808080h, 080h, 0FF8080h, 0FFh
0FF8080h, 000h, 0FF8080h, 0FFh, 0FF8080h, 0FFh, 0FF8080h, 0FFh
0FF8080h, 0FFh, 0FF8080h, 0FFh, 0FF8080h, 0FFh, 0FF8080h, 0FFh

Did regrouping:
Test image(YCbCr dec):
255 128, 128 255, 255 128, 128 255, 255 128, 128 255, 255 128, 128 255
255 128, 128 000, 000 128, 128 000, 000 128, 128 000, 000 128, 128 255
255 128, 128 000, 255 128, 128 255, 255 128, 128 255, 000 128, 128 255
255 128, 128 000, 255 128, 128 128, 128 128, 128 128, 000 128, 128 255
255 128, 128 000, 255 128, 128 128, 128 128, 128 128, 255 128, 128 255
255 128, 128 000, 255 128, 128 255, 255 128, 128 255, 255 128, 128 255
255 128, 128 000, 000 128, 128 000, 000 128, 128 000, 000 128, 128 255
255 128, 128 255, 255 128, 128 255, 255 128, 128 255, 255 128, 128 255

Test image(YCbCr hex):
0FF80h, 080FFh, 0FF80h, 080FFh, 0FF80h, 080FFh, 0FF80h, 080FFh
0FF80h, 08000h, 00080h, 08000h, 00080h, 08000h, 00080h, 080FFh
0FF80h, 08000h, 0FF80h, 080FFh, 0FF80h, 080FFh, 00080h, 080FFh
0FF80h, 08000h, 0FF80h, 08080h, 08080h, 08080h, 00080h, 080FFh
0FF80h, 08000h, 0FF80h, 08080h, 08080h, 08080h, 0FF80h, 080FFh
0FF80h, 08000h, 0FF80h, 080FFh, 0FF80h, 080FFh, 0FF80h, 080FFh
0FF80h, 080FFh, 0FF80h, 080FFh, 0FF80h, 080FFh, 0FF80h, 080FFh


Subtracting 128:
Test image(YCbCr dec):
127 000, 000 127, 127 000, 000 127, 127 000, 000 127, 127 000, 000 127
127 000, 000 128, 128 000, 000 128, 128 000, 000 128, 128 000, 000 127
127 000, 000 128, 127 000, 000 127, 127 000, 000 127, 128 000, 000 127
127 000, 000 128, 127 000, 000 000, 000 000, 000 000, 128 000, 000 127
127 000, 000 128, 127 000, 000 000, 000 000, 000 000, 127 000, 000 127
127 000, 000 128, 127 000, 000 127, 127 000, 000 127, 127 000, 000 127
127 000, 000 128, 128 000, 000 128, 128 000, 000 128, 128 000, 000 127
127 000, 000 127, 127 000, 000 127, 127 000, 000 127, 127 000, 000 127

Test image(YCbCr hex):
07F00h, 0007Fh, 07F00h, 0007Fh, 07F00h, 0007Fh, 07F00h, 0007Fh
07F00h, 00080h, 08000h, 00080h, 08000h, 00080h, 08000h, 0007Fh
07F00h, 00080h, 07F00h, 0007Fh, 07F00h, 0007Fh, 08000h, 0007Fh
07F00h, 00080h, 07F00h, 00000h, 00000h, 00000h, 08000h, 0007Fh
07F00h, 00080h, 07F00h, 00000h, 00000h, 00000h, 07F00h, 0007Fh
07F00h, 00080h, 07F00h, 0007Fh, 07F00h, 0007Fh, 07F00h, 0007Fh
07F00h, 0007Fh, 07F00h, 0007Fh, 07F00h, 0007Fh, 07F00h, 0007Fh

Is everything correct?
Posted on 2005-06-14 04:25:35 by valka