outputprocessor.java

桌面控制的程序啊啊 啊啊 啊啊 啊啊 啊啊 啊啊 啊啊啊

// Decompiled by DJ v3.9.9.91 Copyright 2005 Atanas Neshkov  Date: 3/8/2007 1:20:58 PM
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   OutputProcessor.java

package server;

import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.peer.RobotPeer;
import java.io.ObjectOutputStream;
import java.net.Socket;
import sun.awt.ComponentFactory;

public class OutputProcessor
    implements Runnable
{

    public OutputProcessor(Socket i)
    {
        socket = i;
    }

    public void run()
    {
        try
        {
            output = new ObjectOutputStream(socket.getOutputStream());
            int i = 0;
            do
            {
                Rectangle size = new Rectangle(Toolkit.getDefaultToolkit().getScreenSize());
                long s = System.currentTimeMillis();
                int newPix[] = createScreenCapture(size);
                int minPix[] = proMinPixels(newPix, oldPixels, size.width, size.height);
                oldPixels = newPix;
                minPix = compressData(minPix);
                writeImage(output, minPix);
                if(++i == 10)
                {
                    Runtime.getRuntime().gc();
                    Runtime.getRuntime().gc();
                    Runtime.getRuntime().gc();
                    Runtime.getRuntime().gc();
                    Runtime.getRuntime().gc();
                    i = 0;
                } else
                {
                    Thread.sleep(500L);
                }
            } while(true);
        }
        catch(Exception exception)
        {
            return;
        }
    }

    private static int[] createScreenCapture(Rectangle screenRect)
    {
        try
        {
            if(peer == null)
                try
                {
                    Toolkit toolkit = Toolkit.getDefaultToolkit();
                    if(toolkit instanceof ComponentFactory)
                        peer = ((ComponentFactory)toolkit).createRobot(new Robot(), GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice());
                }
                catch(Exception exception) { }
            return peer == null ? null : peer.getRGBPixels(screenRect);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    private int[] proMinPixels(int newPixel[], int oldPixel[], int width, int height)
    {
        if(oldPixel == null || newPixel.length != oldPixel.length)
        {
            realNum = newPixel.length + 6;
            buffer = new int[realNum];
            buffer[0] = width;
            buffer[1] = height;
            buffer[4] = width;
            buffer[5] = height;
            System.arraycopy(newPixel, 0, buffer, 6, newPixel.length);
            return buffer;
        }
        int len = newPixel.length;
        int minX = 0x7fffffff;
        int minY = 0x7fffffff;
        int maxX = 0;
        int maxY = 0;
        for(int i = 0; i < len; i++)
            if(newPixel[i] != oldPixel[i])
            {
                int x = i % width;
                int y = i / width;
                if(x < minX)
                    minX = x;
                if(x > maxX)
                    maxX = x;
                if(y < minY)
                    minY = y;
                if(y > maxY)
                    maxY = y;
            }

        if(minX == 0x7fffffff)
            return null;
        int resultWidth = (maxX - minX) + 1;
        int resultHeight = (maxY - minY) + 1;
        realNum = resultWidth * resultHeight + 6;
        if(buffer.length < realNum)
            buffer = new int[realNum];
        buffer[0] = width;
        buffer[1] = height;
        buffer[2] = minX;
        buffer[3] = minY;
        buffer[4] = maxX + 1;
        buffer[5] = maxY + 1;
        int resultIndex = 6;
        for(int i = 0; i < resultHeight; i++)
        {
            System.arraycopy(newPixel, (minY + i) * width + minX, buffer, resultIndex, resultWidth);
            resultIndex += resultWidth;
        }

        return buffer;
    }

    private int[] compressData(int data[])
    {
        if(data == null)
            return null;
        int compressIndex = 6;
        for(int i = 6; i < realNum;)
        {
            int j = i;
            int p;
            for(p = data[i]; ++i < realNum && p == data[i];);
            j = i - j;
            if(j > 1)
                buffer[compressIndex++] = j;
            buffer[compressIndex++] = p;
        }

        if(compressIndex < buffer.length)
        {
            int temp[] = new int[compressIndex];
            System.arraycopy(buffer, 0, temp, 0, compressIndex);
            return temp;
        } else
        {
            return buffer;
        }
    }

    private void writeImage(ObjectOutputStream output, int data[])
        throws Exception
    {
        if(data == null)
        {
            return;
        } else
        {
            output.writeObject(data);
            output.flush();
            output.reset();
            return;
        }
    }

    private static int tempTest[];
    private int realNum;
    private int buffer[];
    private static final int HEADER_LEN = 6;
    private int oldPixels[];
    private ObjectOutputStream output;
    private Socket socket;
    private static RobotPeer peer;
    private BufferedImage image;
}