tile.java

AjaxVNC 一个简单的远程控制服务器

/*
 * Tile.java
 *
 * Created on May 2, 2007, 2:46 AM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package hk.haha.onet.ajaxvnc;


import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.awt.image.DataBuffer;
import java.awt.image.ImageObserver;
import java.awt.image.PixelGrabber;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.util.zip.Adler32;
import java.util.zip.CheckedOutputStream;
import javax.imageio.ImageIO;
import javax.imageio.*;
import javax.imageio.stream.*;
import java.util.Iterator;
import javax.imageio.metadata.*;


/**
 *
 * @author heic
 */
public class Tile {
    
    private boolean DEBUG = false;
    
    private ByteArrayOutputStream stream;
    private Adler32 checksum;
    private long version;
    private boolean dirty;
    private int width;
    private int height;
    private static ImageWriter imgwriter;
    private static ImageWriteParam iwp;
    
    /** Creates a new instance of Tile */
    public Tile() {
        stream = new ByteArrayOutputStream();
        checksum = new Adler32();
        version = 0;
        dirty = true;
        width = 0;
        height = 0;
	// create image writer
	Iterator iter = ImageIO.getImageWritersByFormatName("jpeg");
	imgwriter = (ImageWriter)iter.next();
	iwp = imgwriter.getDefaultWriteParam();
	iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
	iwp.setCompressionQuality(Config.jpeg_quality);   // an integer between 0 and 1
	
	
    }
    private IIOMetadata getIIOMetadata(BufferedImage image, ImageWriter imageWriter, ImageWriteParam param) {
        ImageTypeSpecifier spec = ImageTypeSpecifier.createFromRenderedImage(image);
        IIOMetadata metadata = imageWriter.getDefaultImageMetadata(spec,param);
        return metadata;
    }
    
    private void writeImage(BufferedImage image, OutputStream outs)
    {
        try {
/*            ImageIO.write(image, "JPG", outs);*/
            width = image.getWidth();
            height = image.getHeight();
	    ImageOutputStream ios  = ImageIO.createImageOutputStream(outs);

		imgwriter.setOutput(ios);
		IIOMetadata meta = getIIOMetadata(image, imgwriter, iwp);
		imgwriter.write(meta, new IIOImage(image, null, meta), iwp);
		ios.flush();
	
	    
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public boolean updateImage(BufferedImage image)
    {
        long oldsum;
        CheckedOutputStream checkedstream;
        oldsum = checksum.getValue();
        checksum.reset();
        stream.reset();
        checkedstream = new CheckedOutputStream(stream, checksum);
        writeImage(image, checkedstream);
        if (oldsum != checksum.getValue()) {
            if (DEBUG) System.out.println(getClass().getName() + ": Version changed [" + stream.size() +"]");
            version++;
            dirty = true;
            return true;
        }
        else {
            if (DEBUG) System.out.println(getClass().getName() + ": Version unchange");
            return false;
        }
    }
    
    public int fileSize()
    {
	    return stream.size();
    }
    
    public boolean updateImage2(BufferedImage image)
    {
        long oldsum;
        oldsum = checksum.getValue();
        //calcChecksum(image);
        calcChecksum2(image);
        if (oldsum != checksum.getValue()) {
            if (DEBUG) System.out.println(getClass().getName() + ": Version changed [" + stream.size() +"]");
            stream.reset();
            writeImage(image, stream);
            version++;
            dirty = true;
            return true;
        }
        else {
            if (DEBUG) System.out.println(getClass().getName() + ": Version unchange");
            return false;
        }
    }
    
    public boolean isSameVersion(long ver)
    {
        if (ver != version) {
            return false;
        }
        else {
            return true;
        }
    }
    
    public boolean isDirty()
    {
        return dirty;
    }
    
    public void clearDirty()
    {
        dirty = false;
    }
    
    private void calcChecksum(BufferedImage image)
    {
        int w,h,p;
        DataBuffer db;
        db = image.getData().getDataBuffer();
        
        checksum.reset();
        w = db.getNumBanks();
        h = db.getSize() / w;
        
        for (int i=0; i<h; i+=15)
        {
            p = db.getElem(i);
            checksum.update(p);
        }
        
        //checksum.update(p);
    }
    
    private void calcChecksum2(BufferedImage image)
    {
        int w = image.getWidth();
        int h = image.getHeight();
        int pixels[] = new int[w*h];
        PixelGrabber pg = new PixelGrabber(image, 0, 0, w, h, pixels, 0, w);
        checksum.reset();
	try {
	    pg.grabPixels(1);
	} catch (InterruptedException e) {
	    System.err.println("interrupted waiting for pixels!");
	    return;
	}
	if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
	    System.err.println("image fetch aborted or errored");
	    return;
	}
    
	for (int j = 0; j < h; j++) {
	    for (int i = 0; i < w; i++) {
                if ((j*w+i)%13==0)
                    checksum.update(pixels[j * w + i]);
	    }
	}
        
    }
    
    public byte[] getData()
    {
        return stream.toByteArray();
    }
    
    public int getWidth()
    {
        return width;
    }
    
    public int getHeight()
    {
        return height;
    }
}