📄 file_image_to_jpg.java
字号:
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Date;
class BitString {
public byte len = 0;
public short val = 0;
}
public class File_Image_To_JPG {
// Static table initialization
private byte ZigZag[] = {
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
};
long YTable[] = new long[64];
long UVTable[] = new long[64];
int fdtbl_Y[] = new int[64];
int fdtbl_UV[] = new int[64];
private void initQuantTables(int sf) {
int YQT[] = {
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
};
for (int i = 0; i < 64; i++) {
int t = ((YQT[i]*sf+50)/100);
if (t < 1) {
t = 1;
} else if (t > 255) {
t = 255;
}
YTable[ZigZag[i]] = t;
}
int UVQT[] = {
17, 18, 24, 47, 99, 99, 99, 99,
18, 21, 26, 66, 99, 99, 99, 99,
24, 26, 56, 99, 99, 99, 99, 99,
47, 66, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99,
99, 99, 99, 99, 99, 99, 99, 99
};
for (int i = 0; i < 64; i++) {
int t = ((UVQT[i]*sf+50)/100);
if (t < 1) {
t = 1;
} else if (t > 255) {
t = 255;
}
UVTable[ZigZag[i]] = t;
}
// long aasf[] = { //sure: aasf * 1000
// 1000, 1387, 1307, 1176,
// 1000, 786, 541, 276
// };
long aasf[] = { //sure: aasf * 1000
1000, 1387, 1307, 1176,
1000, 787, 541, 276
};
/*long aasf[] = { //sure: aasf * 1000000000
1000000000, 1387039845, 1306562965, 1175875602,
1000000000, 785694958, 541196100, 275899379
};*/
/*long aasf[] = {
1.0, 1.387039845, 1.306562965, 1.175875602,
1.0, 0.785694958, 0.541196100, 0.275899379
};*/
int i = 0;
for (int row = 0; row < 8; row++)
{
for (int col = 0; col < 8; col++)
{
long tI = aasf[row] * aasf[col];
fdtbl_Y[i] = (int)(10000 * 100000 / (YTable [ZigZag[i]] * tI * 8/10)); //sure fdtbl_Y * 10000
fdtbl_UV[i] = (int)(10000 * 100000 / (UVTable[ZigZag[i]] * tI * 8/10)); //sure fdtbl_UV * 10000
// System.out.println("fdtbl_Y["+i+"]: "+fdtbl_Y[i]+" fdtbl_UV["+i+"] "+fdtbl_UV[i]);
i++;
}
}
YQT = null;
UVQT = null;
aasf = null;
}
private BitString YDC_HT[];
private BitString UVDC_HT[];
private BitString YAC_HT[];
private BitString UVAC_HT[];
private BitString[] computeHuffmanTbl(int nrcodes[], int std_table[]) {
int codevalue = 0;
int pos_in_table = 0;
BitString HT[] = new BitString[260];
for (int k =1; k<=16; k++) {
for (int j=1; j<=nrcodes[k]; j++) {
HT[std_table[pos_in_table]] = new BitString();
HT[std_table[pos_in_table]].val = (byte)codevalue;
HT[std_table[pos_in_table]].len = (byte)k;
pos_in_table++;
codevalue++;
}
codevalue*=2;
}
return HT;
}
private int std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
private int std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
private int std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d};
private int std_ac_luminance_values[] = {
0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,
0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,
0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,
0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,
0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,
0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,
0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,
0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,
0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,
0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,
0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,
0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,
0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,
0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
0xf9,0xfa
};
private int std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0};
private int std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11};
private int std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77};
private int std_ac_chrominance_values[] = {
0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,
0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,
0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,
0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,
0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,
0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,
0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,
0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,
0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,
0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,
0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,
0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,
0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,
0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,
0xf9,0xfa
};
private void initHuffmanTbl() {
YDC_HT = computeHuffmanTbl(std_dc_luminance_nrcodes,std_dc_luminance_values);
UVDC_HT = computeHuffmanTbl(std_dc_chrominance_nrcodes,std_dc_chrominance_values);
YAC_HT = computeHuffmanTbl(std_ac_luminance_nrcodes,std_ac_luminance_values);
UVAC_HT = computeHuffmanTbl(std_ac_chrominance_nrcodes,std_ac_chrominance_values);
}
//private BitString bitcode[] = new BitString[65535];
private byte category[] = new byte[65535];
private byte bitcode_len[] = new byte[65535];
private short bitcode_val[] = new short[65535];
private void initCategoryNumber()
{
int nrlower = 1;
int nrupper = 2;
for (int cat=1; cat<=15; cat++) {
//Positive numbers
for (int nr=nrlower; nr<nrupper; nr++) {
category[32767+nr] = (byte)cat;
bitcode_len[32767+nr] = (byte)cat;
bitcode_val[32767+nr] = (short)nr;
// bitcode[32767+nr] = new BitString();
// bitcode[32767+nr].len = (byte)cat;
// bitcode[32767+nr].val = (byte)nr;
}
//Negative numbers
for (int nr=-(nrupper-1); nr<=-nrlower; nr++) {
category[32767+nr] = (byte)cat;
bitcode_len[32767+nr] = (byte)cat;
bitcode_val[32767+nr] = (short)(nrupper-1+nr);
// bitcode[32767+nr] = new BitString();
// bitcode[32767+nr].len = (byte)cat;
// bitcode[32767+nr].val = (byte)(nrupper-1+nr);
}
nrlower <<= 1;
nrupper <<= 1;
}
}
// IO functions
ByteArrayOutputStream byteout = null;
private int bytenew = 0;
private int bytepos = 7;
private void writeBits(BitString bs) {
int value = bs.val;
int posval = bs.len-1;
while ( posval >= 0 ) {
int tx = (value & (1 << posval));
if (tx != 0) {
bytenew |= (1 << bytepos);
}
posval--;
bytepos--;
if (bytepos < 0) {
if (bytenew == 0xFF) {
writeByte(0xFF);
writeByte(0);
}
else {
writeByte(bytenew);
}
bytepos=7;
bytenew=0;
}
}
}
private void writeBits(ByteArrayOutputStream baos, int value, int posval){
writeBits(baos, value, posval, false);
}
private void writeBits(ByteArrayOutputStream baos, int value, int posval, boolean needToPrint) {
while ( posval >= 0 ) {
int tx = (value & (1 << posval));
if (tx != 0) {
bytenew |= (1 << bytepos);
}
posval--;
bytepos--;
if (bytepos < 0) {
if (bytenew == 0xFF) {
writeByte(baos, 0xFF);
writeByte(baos, 0);
if(needToPrint){
System.out.print((byte)0xFF+" "+0);
}
}
else {
writeByte(baos, bytenew);
if(needToPrint){
System.out.print((byte)bytenew+" ");
}
}
bytepos=7;
bytenew=0;
}
}
}
private void writeBits(ByteArrayOutputStream baos, BitString bs) {
writeBits(baos, bs, false);
}
private void writeBits(ByteArrayOutputStream baos, BitString bs, boolean needToPrint) {
// writeByte(baos, (byte)bs.val);
int value = bs.val;
int posval = bs.len-1;
while ( posval >= 0 ) {
int tx = (value & (1 << posval));
if (tx != 0) {
bytenew |= (1 << bytepos);
}
posval--;
bytepos--;
if (bytepos < 0) {
if (bytenew == 0xFF) {
writeByte(baos, 0xFF);
writeByte(baos, 0);
if(needToPrint){
System.out.print((byte)0xFF+" "+0);
}
}
else {
writeByte(baos, bytenew);
if(needToPrint){
System.out.print((byte)bytenew+" ");
}
}
bytepos=7;
bytenew=0;
}
}
}
private void writeByte(int value)
{
byteout.write((byte)(value&0xFF));
}
private void writeByte(byte[] value) throws IOException
{
byteout.write(value);
}
private void writeByte(ByteArrayOutputStream baos, int value)
{
baos.write((byte)(value&0xFF));
}
private void writeByte(ByteArrayOutputStream baos, byte[] value) throws IOException
{
baos.write(value);
}
private void writeWord(int value)
{
writeByte((value>>8)&0xFF);
writeByte((value )&0xFF);
}
// DCT & quantization core
int tmp0,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7;
int tmp10,tmp11,tmp12,tmp13;
int z1,z2,z3,z4,z5;
int z11,z13;
int[] fDCTQuant(int data[], int fdtbl[]) {
/* Pass 1: process rows. */
int dataOff=0;
for (int i=0; i<8; i++) {
tmp0 = data[dataOff+0] + data[dataOff+7];
tmp7 = data[dataOff+0] - data[dataOff+7];
tmp1 = data[dataOff+1] + data[dataOff+6];
tmp6 = data[dataOff+1] - data[dataOff+6];
tmp2 = data[dataOff+2] + data[dataOff+5];
tmp5 = data[dataOff+2] - data[dataOff+5];
tmp3 = data[dataOff+3] + data[dataOff+4];
tmp4 = data[dataOff+3] - data[dataOff+4];
/* Even part */
tmp10 = tmp0 + tmp3; /* phase 2 */
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;
data[dataOff+0] = tmp10 + tmp11; /* phase 3 */
data[dataOff+4] = tmp10 - tmp11;
z1 = (tmp12 + tmp13) * 7071 / 10000; /* c4 */ //sure: 0.707106781
data[dataOff+2] = tmp13 + z1; /* phase 5 */
data[dataOff+6] = tmp13 - z1;
/* Odd part */
tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;
/* The rotator is modified from fig 4-8 to avoid extra negations. */
z5 = (tmp10 - tmp12) * 3827 / 10000; /* c6 */ //sure: 0.382683433
z2 = 5412 * tmp10 / 10000+ z5; /* c2-c6 */ //sure: 0.541196100
z4 = 13066 * tmp12 / 10000 + z5; /* c2+c6 */ //sure: 1.306562965
z3 = tmp11 * 7071 / 10000; /* c4 */ //sure: 0.707106781
z11 = tmp7 + z3; /* phase 5 */
z13 = tmp7 - z3;
data[dataOff+5] = z13 + z2; /* phase 6 */
data[dataOff+3] = z13 - z2;
data[dataOff+1] = z11 + z4;
data[dataOff+7] = z11 - z4;
dataOff += 8; /* advance pointer to next row */
}
/* Pass 2: process columns. */
dataOff = 0;
for (int i=0; i<8; i++) {
tmp0 = data[dataOff+ 0] + data[dataOff+56];
tmp7 = data[dataOff+ 0] - data[dataOff+56];
tmp1 = data[dataOff+ 8] + data[dataOff+48];
tmp6 = data[dataOff+ 8] - data[dataOff+48];
tmp2 = data[dataOff+16] + data[dataOff+40];
tmp5 = data[dataOff+16] - data[dataOff+40];
tmp3 = data[dataOff+24] + data[dataOff+32];
tmp4 = data[dataOff+24] - data[dataOff+32];
/* Even part */
tmp10 = tmp0 + tmp3; /* phase 2 */
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -