we dont need that either
This commit is contained in:
hns
parent
57c322a273
commit
9f8f477bf3
1 changed files with 0 additions and 583 deletions
|
|
@ -1,583 +0,0 @@
|
|||
//////////////////////// DISCLAIMER \\\\\\\\\\\\\\\\\\\\\\\\\
|
||||
// \\
|
||||
// This software is provided by Sean Patrick Breslin for \\
|
||||
// your use or abuse, free of charge and royalties. This \\
|
||||
// software is provide 'AS IS' and as such there are no \\
|
||||
// warrenties expressed or implied. This software is by \\
|
||||
// no means robust, optimized, efficient, tight or any of \\
|
||||
// a number of adjectives used to describe software. This \\
|
||||
// in mind, this software is not to be used for nuclear \\
|
||||
// applications, world domination schemes or discount \\
|
||||
// remote laser surgery. You may copy or modify this \\
|
||||
// code as you see fit. This code works on my PC other \\
|
||||
// than that I cannot help you with this code in any way. \\
|
||||
// I have not decided whether or not I will support this \\
|
||||
// code with bug fixes or enhancements but I'll think \\
|
||||
// about it. \\
|
||||
// \\
|
||||
// USAGE: instanciate the class: \\
|
||||
// GrayJPEG jpg = new GrayJPEG(); \\
|
||||
// \\
|
||||
// and call the method: \\
|
||||
// jpg.compress(Image i, OutputStream os) \\
|
||||
// \\
|
||||
// Where 'i' is a standard Java Image object and \\
|
||||
// 'os' is an output stream where you want the \\
|
||||
// JPEG file written. \\
|
||||
// \\
|
||||
// NOTE: This code will only compress a grayscale image \\
|
||||
// i.e. Black and White, though a color image will \\
|
||||
// not crash the code the results are unknown. \\
|
||||
// \\
|
||||
// PS: I have compiled this with Java 1.0.2 and 1.1.3 \\
|
||||
// and it works under both versions using windows \\
|
||||
// 95 operating system, so knock yourself out and \\
|
||||
// have fun with my code. \\
|
||||
// \\
|
||||
///////////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
|
||||
|
||||
package Acme.JPM.Encoders;
|
||||
|
||||
import java.io.*;
|
||||
import java.net.*;
|
||||
import java.awt.*;
|
||||
import java.awt.image.*;
|
||||
|
||||
public class GrayJPEG {
|
||||
// quantization table in zigzag form for output file
|
||||
private byte[] QNT = {-1, -37, 0, 67, 0,
|
||||
13,9,10,11,10,8,13,11,
|
||||
10,11,14,14,13,15,19,32,
|
||||
21,19,18,18,19,39,28,30,
|
||||
23,32,46,41,49,48,46,41,
|
||||
45,44,51,58,74,62,51,54,
|
||||
70,55,44,45,64,87,65,70,
|
||||
76,78,82,83,82,50,62,90,
|
||||
97,90,80,96,74,81,82,79};
|
||||
|
||||
// table for doing quantization
|
||||
private float[][] QT = {{13, 9, 8,13,19,32,41,49},
|
||||
{10,10,11,15,21,46,48,44},
|
||||
{11,10,13,19,32,46,55,45},
|
||||
{11,14,18,23,41,70,64,50},
|
||||
{14,18,30,45,54,87,82,62},
|
||||
{19,28,44,51,65,83,90,74},
|
||||
{39,51,62,70,82,97,96,81},
|
||||
{58,74,76,78,90,80,82,79}};
|
||||
|
||||
// Zig Zag array
|
||||
private int[][] ZZ = {{ 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}};
|
||||
|
||||
// AC Huffman table
|
||||
private byte[] Bits = {0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,125};
|
||||
private byte[] Huffval = {
|
||||
1,2,3,0,4,17,5,18,33,49,65,6,19,81,97,7,34,113,20,
|
||||
50,-127,-111,-95,8,35,66,-79,-63,21,82,-47,-16,36,
|
||||
51,98,114,-126,9,10,22,23,24,25,26,37,38,39,40,41,
|
||||
42,52,53,54,55,56,57,58,67,68,69,70,71,72,73,74,83,
|
||||
84,85,86,87,88,89,90,99,100,101,102,103,104,105,106,
|
||||
115,116,117,118,119,120,121,122,-125,-124,-123,-122,
|
||||
-121,-120,-119,-118,-110,-109,-108,-107,-106,-105,
|
||||
-104,-103,-102,-94,-93,-92,-91,-90,-89,-88,-87,-86,
|
||||
-78,-77,-76,-75,-74,-73,-72,-71,-70,-62,-61,-60,-59,
|
||||
-58,-57,-56,-55,-54,-46,-45,-44,-43,-42,-41,-40,-39,
|
||||
-38,-31,-30,-29,-28,-27,-26,-25,-24,-23,-22,-15,-14,
|
||||
-13,-12,-11,-10,-9,-8,-7,-6};
|
||||
|
||||
// Header data
|
||||
private String str = "JFIF Breslin Engineering JPEG Image Compression";
|
||||
private byte[] BE, APP0;
|
||||
private byte[] SOI = {-1,-40};
|
||||
private byte[] EOI = {-1,-39};
|
||||
private byte[] SOF = {-1,-64,0,11,8,0,0,0,0,1,1,17,0};
|
||||
private byte[] HuffDC = {-1,-60,0,31,0,0,1,5,1,1,1,1,1,1,0,0,
|
||||
0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11};
|
||||
private byte[] HuffACHeader = {-1,-60,0,-75,16};
|
||||
private byte[] SOS = {-1,-38,0,8,1,1,0,0,63,0};
|
||||
|
||||
// Global variables
|
||||
private int ln, X, Y, LASTK, I, J;
|
||||
private int BitCnt, K, R, CODE, SI, SSSS;
|
||||
private int[] BITS = new int[17];
|
||||
private int[] HUFFVAL = new int[162];
|
||||
private int[] HUFFCODE = new int[257];
|
||||
private int[] HUFFSIZE = new int[257];
|
||||
private int[] EHUFCO = new int[257];
|
||||
private int[] EHUFSI = new int[257];
|
||||
private OutputStream fos;
|
||||
private Image image;
|
||||
private long DATA=0;
|
||||
|
||||
public GrayJPEG() {
|
||||
int x, y, ln = str.length();
|
||||
BE = new byte[ln];
|
||||
str.getBytes(0, ln, BE, 0);
|
||||
ln += 2;
|
||||
byte[] ap = {-1, -32, 0, (byte)ln};
|
||||
APP0 = ap;
|
||||
|
||||
// Generate AC Huffman tables
|
||||
// Get BITS data
|
||||
BITS[0]=0;
|
||||
for(x=1;x<17;x++)
|
||||
BITS[x] = Bits[x-1];
|
||||
|
||||
// Get HUFFVAL data
|
||||
for(x=0;x<162;x++) {
|
||||
HUFFVAL[x] = Huffval[x];
|
||||
if(HUFFVAL[x]<0) HUFFVAL[x] = 256 + HUFFVAL[x];
|
||||
}
|
||||
|
||||
Generate_size_table();
|
||||
Generate_code_table();
|
||||
Order_codes();
|
||||
}
|
||||
|
||||
public void compress(Image i, OutputStream os){
|
||||
int bkk, x, y, w, h, a, b, c, d;
|
||||
int[][] blocks;
|
||||
int[][] blk = new int[8][8];
|
||||
|
||||
image = i;
|
||||
fos = os;
|
||||
X = image.getWidth(null);
|
||||
Y = image.getHeight(null);
|
||||
ln = X*Y;
|
||||
int[] data = new int[ln];
|
||||
w = (X>>3)<<3;
|
||||
h = (Y>>3)<<3;
|
||||
getPixels(data);
|
||||
|
||||
// Set Image dimensions in Start of Frame header
|
||||
SOF[5] = (byte)((h & 0x0000ff00)>>8);
|
||||
SOF[6] = (byte)(h & 0x000000ff);
|
||||
SOF[7] = (byte)((w & 0x0000ff00)>>8);
|
||||
SOF[8] = (byte)(w & 0x000000ff);
|
||||
|
||||
// Set number of blocks
|
||||
w = X/8; h = Y/8; ln = w*h;
|
||||
blocks = new int[ln][];
|
||||
bkk=0;
|
||||
|
||||
// break image in to 8x8 blocks
|
||||
for(a=0;a<(h*8);a+=8) {
|
||||
// Get 8 lines of image
|
||||
for(b=0;b<(w*8);b+=8) {
|
||||
// Get block for FDCT
|
||||
for(c=0;c<8;c++)
|
||||
for(d=0;d<8;d++)
|
||||
// mask off 3 upper bytes of image data
|
||||
blk[c][d] = (data[(a+c)*X+b+d] & 0x000000ff)-128;
|
||||
|
||||
//Do FDCT on Block
|
||||
blocks[bkk++] = FDCT(blk);
|
||||
}
|
||||
}
|
||||
// Write out header data
|
||||
writeHeaders();
|
||||
|
||||
// Encode image scan
|
||||
Huffman(blocks);
|
||||
|
||||
// Write out last bits of image scan
|
||||
writeEndData();
|
||||
|
||||
// Write End of Image marker
|
||||
writeEnd();
|
||||
}
|
||||
|
||||
private void Huffman(int[][] blocks) {
|
||||
int tmp, lp, DIFF, dat, PRED, bits;
|
||||
int[] blk;
|
||||
byte[] data = new byte[1];
|
||||
int[][] HuffTbl = {{2,0},{3,2},{3,3},{3,4},{3,5},{3,6},{4,14},{5,30},{6,62},{7,126},{8,254},{9,510}};
|
||||
long buffer;
|
||||
|
||||
// Encode data blocks
|
||||
// Initialize predictor for new scan
|
||||
PRED = 0; BitCnt=0;
|
||||
for(lp=0;lp<ln;lp++) {
|
||||
blk = blocks[lp];
|
||||
buffer = 0;
|
||||
bits=0;
|
||||
|
||||
// Encode DC coefficient
|
||||
tmp = DIFF = blk[0]-PRED;
|
||||
if(tmp<0) { tmp=-tmp; DIFF--; }
|
||||
|
||||
// find magnitude category data for DC edcoding
|
||||
SSSS = MagCat(tmp);
|
||||
|
||||
// Total number of bits output
|
||||
bits = HuffTbl[SSSS][0] + SSSS;
|
||||
|
||||
// Code word for this category shifted
|
||||
//to accept magnitude data
|
||||
buffer = HuffTbl[SSSS][1]<<SSSS;
|
||||
|
||||
// append bits to code word
|
||||
buffer+=(DIFF&((1<<SSSS)-1));
|
||||
|
||||
// Write out data if greater then or equal to one byte
|
||||
writeData(buffer, bits);
|
||||
|
||||
// Assign PRED for next DC DIFF
|
||||
PRED = blk[0];
|
||||
|
||||
// Encode AC coefficients
|
||||
Encode_AC_coefficients(blk);
|
||||
|
||||
// free up memory for next compression
|
||||
blocks[lp]=null;
|
||||
}
|
||||
}
|
||||
|
||||
private void Encode_AC_coefficients(int[] ZZ) {
|
||||
boolean done = false;
|
||||
int size, code, dat;
|
||||
K=0; R=0;
|
||||
|
||||
while(!done) {
|
||||
K++; dat = ZZ[K];
|
||||
|
||||
if(dat==0) {
|
||||
if(K==63) {
|
||||
// mark EOB
|
||||
code = EHUFCO[0x00];
|
||||
size = EHUFSI[0x00];
|
||||
writeData(code, size);
|
||||
done=true;
|
||||
break;
|
||||
} else {
|
||||
R++;
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
|
||||
while(true) {
|
||||
if(R>15) {
|
||||
R-=16;
|
||||
// Mark RLZ in scan
|
||||
code = EHUFCO[0xf0];
|
||||
size = EHUFSI[0xf0];
|
||||
writeData(code, size);
|
||||
continue;
|
||||
}
|
||||
Encode_R(ZZ[K]);
|
||||
R=0;
|
||||
if(K==63) done=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void Encode_R(int ZZ) {
|
||||
int dat, RS, size, code;
|
||||
dat = ZZ;
|
||||
if(ZZ<0) {
|
||||
dat=-dat;
|
||||
ZZ--;
|
||||
}
|
||||
|
||||
// Get AC magnitude category
|
||||
SSSS = MagCat(dat);
|
||||
RS = (R<<4) + SSSS;
|
||||
|
||||
// append bits
|
||||
code = EHUFCO[RS];
|
||||
size = EHUFSI[RS];
|
||||
writeData(code, size);
|
||||
|
||||
// Mask off upper bits of ZZ
|
||||
ZZ &= ((1<<SSSS)-1);
|
||||
|
||||
// append SSS low order bits of ZZ(K)
|
||||
writeData(ZZ, SSSS);
|
||||
}
|
||||
|
||||
private void Generate_size_table() {
|
||||
// Generate HUFFSIZE table Flow Chart C.1
|
||||
K=0; I=1; J=1;
|
||||
while(true) {
|
||||
if(J>BITS[I]) {
|
||||
J=1; I++;
|
||||
if(I > 16) break;
|
||||
} else {
|
||||
HUFFSIZE[K++]=I;
|
||||
J++;
|
||||
}
|
||||
}
|
||||
HUFFSIZE[K] = 0;
|
||||
LASTK = K;
|
||||
}
|
||||
|
||||
private void Generate_code_table() {
|
||||
// Generate Code table Flow Chart C.2
|
||||
K = 0; CODE = 0; SI = HUFFSIZE[0];
|
||||
while(true) {
|
||||
HUFFCODE[K++] = CODE++;
|
||||
if(HUFFSIZE[K] == SI) continue;
|
||||
if(HUFFSIZE[K] == 0) break;
|
||||
while(true){
|
||||
CODE<<=1; SI++;
|
||||
if(HUFFSIZE[K] == SI)
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void Order_codes() {
|
||||
// Order Codes Flow Chart C.3
|
||||
K=0;
|
||||
while(true) {
|
||||
I = HUFFVAL[K];
|
||||
EHUFCO[I] = HUFFCODE[K];
|
||||
EHUFSI[I] = HUFFSIZE[K++];
|
||||
if(K >= LASTK) break;
|
||||
}
|
||||
}
|
||||
|
||||
private int MagCat(int dat) {
|
||||
int ln;
|
||||
for(;;) {
|
||||
if(dat==0) { ln = 0; break; }
|
||||
if(dat==1) { ln = 1; break; }
|
||||
if(dat<=3) { ln = 2; break; }
|
||||
if(dat<=7) { ln = 3; break; }
|
||||
if(dat<=15) { ln = 4; break; }
|
||||
if(dat<=31) { ln = 5; break; }
|
||||
if(dat<=63) { ln = 6; break; }
|
||||
if(dat<=127) { ln = 7; break; }
|
||||
if(dat<=255) { ln = 8; break; }
|
||||
if(dat<=511) { ln = 9; break; }
|
||||
if(dat<=1023) { ln = 10; break; }
|
||||
if(dat<=2047) { ln = 11; break; }
|
||||
}
|
||||
return ln;
|
||||
}
|
||||
|
||||
private void writeHeaders() {
|
||||
try {
|
||||
fos.write(SOI); // Start of Image marker
|
||||
fos.write(APP0); // Application header
|
||||
fos.write(BE); // JFIF BE jpg compression
|
||||
fos.write(QNT); // Quantization table
|
||||
fos.write(SOF); // Start of Frame marker
|
||||
fos.write(HuffDC); // DC Huffman Table
|
||||
fos.write(HuffACHeader); // AC Huffman Table Header
|
||||
fos.write(Bits); // AC Huffman Table
|
||||
fos.write(Huffval); // AC Huffman Table
|
||||
fos.write(SOS); // Start of Scan header
|
||||
} catch(IOException ioe) { System.err.println("IOException: " + ioe); }
|
||||
}
|
||||
|
||||
private void writeEnd() {
|
||||
try {
|
||||
fos.write(EOI); // End of Image/File
|
||||
fos.close();
|
||||
} catch(IOException ioe) { System.err.println("IOException: " + ioe); }
|
||||
}
|
||||
|
||||
private void getPixels(int[] data) {
|
||||
PixelGrabber pg = new PixelGrabber(image.getSource(), 0, 0, X, Y, data, 0, X);
|
||||
try { if(pg.grabPixels() != true) {
|
||||
try {
|
||||
throw new AWTException("Grabber returned false: " + pg.status());
|
||||
} catch (Exception ex) {
|
||||
System.err.println("System Failed to get Pixels! - " + ex);
|
||||
System.exit(0);
|
||||
};
|
||||
}
|
||||
} catch (InterruptedException ent) {};
|
||||
}
|
||||
|
||||
private void writeData(long dat, int bits) {
|
||||
int tmp;
|
||||
byte[] stuff = {0};
|
||||
byte[] d = new byte[1];
|
||||
|
||||
if(bits>0) {
|
||||
DATA<<=bits;
|
||||
DATA+=dat;
|
||||
BitCnt+=bits;
|
||||
}else
|
||||
return;
|
||||
|
||||
// output bytes untill cnt is less then 8
|
||||
while(BitCnt>7) {
|
||||
BitCnt-=8;
|
||||
tmp=(int)(DATA>>BitCnt);
|
||||
d[0] = (byte)tmp;
|
||||
|
||||
// mask off 8 msb of DATA
|
||||
DATA &= ((1<<BitCnt)-1);
|
||||
|
||||
// write out data
|
||||
try {
|
||||
fos.write(d); // End of Image/File
|
||||
if(d[0]==-1)
|
||||
// if 0xFF data stuff 0x00 byte
|
||||
fos.write(stuff);
|
||||
} catch(IOException ioe) { System.err.println("IOException: " + ioe); }
|
||||
}
|
||||
}
|
||||
|
||||
private void writeEndData() {
|
||||
byte[] d = new byte[1];
|
||||
// finish off scan data to byte boundry
|
||||
if(BitCnt>0) {
|
||||
DATA<<=(8-BitCnt);
|
||||
DATA+=((1<<(8-BitCnt))-1);
|
||||
d[0] = (byte)DATA;
|
||||
try {
|
||||
fos.write(d);
|
||||
} catch(IOException ioe) { System.err.println("IOException: " + ioe); }
|
||||
}
|
||||
}
|
||||
|
||||
private int[] FDCT(int[][] block) {
|
||||
int j1, i, j;
|
||||
int[] blk = new int[64];
|
||||
float[] b = new float[8];
|
||||
float temp;
|
||||
float[] b1 = new float[8];
|
||||
float[][] d = new float[8][8];
|
||||
float f0=(float)0.7071068,f1=(float)0.4903926;
|
||||
float f2=(float)0.4619398,f3=(float)0.4157348;
|
||||
float f4=(float)0.3535534,f5=(float)0.2777851;
|
||||
float f6=(float)0.1913417,f7=(float)0.0975452;
|
||||
|
||||
float df7f1=(float)-0.3928475, sf7f1=(float)0.5879378 ;
|
||||
float df3f5=(float)0.1379497, sf3f5=(float)0.6935199 ;
|
||||
float df6f2=(float)-0.27059805, sf6f2=(float).6532815 ;
|
||||
|
||||
for(i = 0; i < 8; i++) {
|
||||
for(j = 0; j < 8; j++) {
|
||||
b[j] = block[i][j];
|
||||
}
|
||||
// Horizontal transform
|
||||
for(j = 0; j < 4; j++) {
|
||||
j1 = 7 - j;
|
||||
b1[j] = b[j] + b[j1];
|
||||
b1[j1] = b[j] - b[j1];
|
||||
}
|
||||
b[0] = b1[0] + b1[3];
|
||||
b[1] = b1[1] + b1[2];
|
||||
b[2] = b1[1] - b1[2];
|
||||
b[3] = b1[0] - b1[3];
|
||||
b[4] = b1[4];
|
||||
b[5] = (b1[6] - b1[5]) * f0;
|
||||
b[6] = (b1[6] + b1[5]) * f0;
|
||||
b[7] = b1[7];
|
||||
d[i][0] = (b[0] + b[1]) * f4;
|
||||
d[i][4] = (b[0] - b[1]) * f4;
|
||||
|
||||
temp = (b[3]+b[2])*f6 ;
|
||||
d[i][2] = temp - b[3]*df6f2 ;
|
||||
d[i][6] = temp - b[2]*sf6f2 ;
|
||||
|
||||
b1[4] = b[4] + b[5];
|
||||
b1[7] = b[7] + b[6];
|
||||
b1[5] = b[4] - b[5];
|
||||
b1[6] = b[7] - b[6];
|
||||
|
||||
temp = (b1[7]+b1[4])*f7;
|
||||
d[i][1] = temp - b1[7]*df7f1 ;
|
||||
d[i][7] = temp - b1[4]*sf7f1 ;
|
||||
|
||||
temp = (b1[6]+b1[5])*f3;
|
||||
d[i][5] = temp - b1[6]*df3f5 ;
|
||||
d[i][3] = temp - b1[5]*sf3f5 ;
|
||||
}
|
||||
|
||||
// Vertical transform
|
||||
for(i = 0; i < 8; i++) {
|
||||
for(j = 0; j < 4; j++) {
|
||||
j1 = 7 - j;
|
||||
b1[j] = d[j][i] + d[j1][i];
|
||||
b1[j1] = d[j][i] - d[j1][i];
|
||||
}
|
||||
b[0] = b1[0] + b1[3];
|
||||
b[1] = b1[1] + b1[2];
|
||||
b[2] = b1[1] - b1[2];
|
||||
b[3] = b1[0] - b1[3];
|
||||
b[4] = b1[4];
|
||||
b[5] = (b1[6] - b1[5]) * f0;
|
||||
b[6] = (b1[6] + b1[5]) * f0;
|
||||
b[7] = b1[7];
|
||||
d[0][i] = (b[0] + b[1]) * f4;
|
||||
d[4][i] = (b[0] - b[1]) * f4;
|
||||
|
||||
temp = (b[3]+b[2])*f6 ;
|
||||
d[2][i] = temp - b[3]*df6f2 ;
|
||||
d[6][i] = temp - b[2]*sf6f2 ;
|
||||
|
||||
b1[4] = b[4] + b[5];
|
||||
b1[7] = b[7] + b[6];
|
||||
b1[5] = b[4] - b[5];
|
||||
b1[6] = b[7] - b[6];
|
||||
|
||||
temp = (b1[7]+b1[4])*f7;
|
||||
d[1][i] = temp - b1[7]*df7f1 ;
|
||||
d[7][i] = temp - b1[4]*sf7f1 ;
|
||||
|
||||
temp = (b1[6]+b1[5])*f3;
|
||||
d[5][i] = temp - b1[6]*df3f5 ;
|
||||
d[3][i] = temp - b1[5]*sf3f5 ;
|
||||
|
||||
}
|
||||
for(i = 0; i < 8; i++) {
|
||||
for(j = 0; j < 8; j++) {
|
||||
// Quantize and ZigZag data block
|
||||
blk[ZZ[i][j]] = (int)(d[i][j]/QT[i][j]);
|
||||
|
||||
}
|
||||
}
|
||||
return blk;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
try {
|
||||
URL url = new URL(args[0]);
|
||||
URLConnection uc = url.openConnection();
|
||||
uc.connect();
|
||||
|
||||
// Got to open a stream to get around Java NullPointerException bug.
|
||||
InputStream f = uc.getInputStream();
|
||||
|
||||
String mimeType = uc.getContentType();
|
||||
|
||||
// Java prints (not throws!) a ClassNotFoundException if you try
|
||||
// a getContent on text.html or audio/basic (or no doubt many
|
||||
// other types).
|
||||
if ( ! mimeType.startsWith( "image/" ) )
|
||||
System.err.println( args[0] + " is not an image" );
|
||||
else {
|
||||
Object content = uc.getContent();
|
||||
if ( ! ( content instanceof ImageProducer ) )
|
||||
System.err.println( args[0] + " is not a known image type" );
|
||||
else {
|
||||
ImageProducer prod = (ImageProducer) content;
|
||||
Toolkit tk = new Acme.JPM.StubToolkit();
|
||||
Image img = tk.createImage(prod);
|
||||
GrayJPEG jpg = new GrayJPEG();
|
||||
jpg.compress(img, System.out);
|
||||
}
|
||||
}
|
||||
|
||||
// Done with unnecessary stream.
|
||||
f.close();
|
||||
}
|
||||
catch ( Exception e ) {
|
||||
System.err.println( e );
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue