Socket Bilder übertragen

[stulleman]

Hallo zusammen!
Ich arbeite gerade an einem kleinen Projekt in dem der Server dem Client ständig screenshots sendet und der Client diese auf einem JPanel darstellt.
Nun stehe ich vor einem Problem, da mein Programm keine Exceptions mehr wirft, es aber trotzdem nicht funktioniert.

Server/Host :

import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import javax.imageio.ImageIO;


public class Server {

	private ServerSocket serverSocket;
	private Socket clientSocket;
	private DataOutputStream dout;
	private Robot robot;
	
	private int screenWidth, screenHeight;
	
	public Server() {
		startServer();
		waitForClient();
		sendScreenshots();
	}

	/**
	 * Starts the server on port 6493
	 */
	private void startServer() {
		try {
			serverSocket = new ServerSocket(6493);
		} catch(IOException e) {
			e.printStackTrace();
		}
		
		System.out.println("Server started...");
	}
	
	/**
	 * Waits for a client to connect
	 */
	private void waitForClient() {
		try {
			clientSocket = serverSocket.accept();
		} catch(IOException e) {
			e.printStackTrace();
		}
		
		try {
			dout = new DataOutputStream(clientSocket.getOutputStream());
		} catch(IOException e) {
			e.printStackTrace();
		}
		
		System.out.println("Accepted client!");
	}
	
	/**
	 * Sends a png screenshot to the connected Client
	 */
	private void sendScreenshots() {
		Dimension dim = Toolkit.getDefaultToolkit().getScreenSize();
		
		screenWidth = dim.width;
		screenHeight = dim.height;
		
		Rectangle screen = new Rectangle(screenWidth,screenHeight);
		
		BufferedImage screenshot;
		
		try {
			robot = new Robot();
		} catch (AWTException e) {
			e.printStackTrace();
		}
		
		while(true) {
			screenshot = robot.createScreenCapture(screen);
			
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
		    try {
				ImageIO.write(screenshot, "png", baos);
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		    byte[] screenBytes = baos.toByteArray();
		    
		    try {
				dout.writeInt(screenBytes.length);
				dout.write(screenBytes);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new Server();
	}
}

Ich denke bis hier hin ist alles richtig oder?
Und hier müsste irgendwo der Fehler liegen:

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.imageio.ImageIO;

public class Client {

	private Socket socket;
	private DataInputStream din;
	private BufferedImage screenshot;
	
	public BufferedImage getScreenshot() {
		return screenshot;
	}

	public void connectToServer(String ip, int port) {
		try {
			socket = new Socket(ip,port);
			
			din = new DataInputStream(socket.getInputStream());
			
		} catch(UnknownHostException e) {
			e.printStackTrace();
		} catch(IOException e) {
			e.printStackTrace();
		}	
	}
	
	public void getScreenshots() {
		int length;
		byte[] buffer;
		
		while(true) {
			try {
				length = din.readInt();
				
				buffer = new byte[length];
				
				for(int i = 0; i < length; i++) {
					buffer[i] = din.readByte();
				}
				
				ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
				
			    try {
					screenshot = ImageIO.read(bais);
				} catch (IOException e) {
					e.printStackTrace();
				}
				
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

Frame:

import javax.swing.JFrame;

public class ClientGUI extends JFrame {

	/**
	 * 
	 */
	private static final long serialVersionUID = -3320531674461503451L;

	private ClientGUIPanel panel;
	
	public ClientGUI() {
		initUI();
	}
	
	private void initUI() {
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		setTitle("Remote screenshot");
		setSize(600,600);
		
		panel = new ClientGUIPanel();
		add(panel);
		
		setVisible(true);
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new ClientGUI();
	}
}

Panel:

import java.awt.Graphics;
import java.awt.image.BufferedImage;

import javax.swing.JPanel;

public class ClientGUIPanel extends JPanel 
implements Runnable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -7866627091470809232L;
	
	private Client client;
	private BufferedImage screenshot;

	public ClientGUIPanel() {
		client = new Client();
		client.connectToServer("localhost", 6493);
		client.getScreenshots();
		
		Thread thread = new Thread(this);
		thread.start();
	}
	
	@Override
	public void paintComponent(Graphics g) {
		g.drawImage(screenshot, 0, 0, null);
	}

	@Override
	public void run() {
		while(true) {
			screenshot = client.getScreenshot();
			
			repaint();
			
			try {
				Thread.sleep(10);
			} catch(InterruptedException e) {
				
			}
		}
	}
}

Ich denke es wäre zu viel verlangt wenn sich jemand durch den ganzen Code arbeiten soll, aber vielleicht erkennt einer die Struktur dahinter und erkennt darin schon einen Fehler

Danke schon mal!
Max

 

[stulleman]

Entschuldigung! Ich habe mein Problem selber gelöst!
Das Problem war in der Client Klasse, die getScreenshot() Methode war überflüssig und das Programm ist in der while Schleife hängen geblieben!

Das ist die neue Client Klasse, falls es jemand interessiert

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;

import javax.imageio.ImageIO;

public class Client {

	private Socket socket;
	private DataInputStream din;
	private BufferedImage screenshot;

	public void connectToServer(String ip, int port) {
		try {
			socket = new Socket(ip,port);
			
			din = new DataInputStream(socket.getInputStream());
			
		} catch(UnknownHostException e) {
			e.printStackTrace();
		} catch(IOException e) {
			e.printStackTrace();
		}	
	}
	
	public BufferedImage getScreenshot() {
		int length;
		byte[] buffer;
		
		try {
			length = din.readInt();
			
			buffer = new byte[length];
			
			for(int i = 0; i < length; i++) {
				buffer[i] = (byte) din.read();
			}
			
			ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
			
		    try {
				screenshot = ImageIO.read(bais);
			} catch (IOException e) {
				e.printStackTrace();
			}
			
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		return screenshot;
	}
}

 

[stulleman]

Eine letzte Frage bleibt noch!
Und zwar stopfe ich den Stream ja mit vielen Bildern voll, und der Client kommt da ja wahrscheinlich nicht hinterher. Würde es sich lohnen den Server erst ein Bild schicken zu lassen wenn das alte gelesen wurde? Oder gibt es da eine bestimmt Technik?

 

[Cola_Colin]

Wäre der limitierende Faktor nicht eher das Netzwerk und nicht die Darstellung des Bildes beim Clienten ?
Einfach nur anzeigen kann man pro Sekunde sicher mehr Bilder als man pro Sekunde Bilder übers Netzwerk schicken kann oder pro Sekunde mit dem Robot Screenshots machen kann.
Eigentlich sollte also eher der Client viel auf den Server warten und nicht andersherum ?

 

[stulleman]

Ach so, das war mir nicht bewusst
Das heißt nicht der Stream wird voll gepackt, sonder der Client wartet lange auf ein neues Bild?
Na gut dann brauche ich eine schnellere Methode Screenshots zu machen!

 

[Kr0e]

1. Das löst TCP, dein Protokoll TCP sendet nur die TCP window size. Danach muss erstmal von der GEgenseite bestätigt werden, einer der Gründe warum TCP geringfügig langsamer ist als UDP -> COntextwechsel. Sprich wenn der Client nicht fertig sein sollte (Was aber aus Gründen der langsamen Robotfunktion und dem Netzwerk nicht vorkommen sollte), dann blockiert die send() methode des Servers solange, bis das aktuelle Frame geleert ist. Bei google gibts dazu mehr: TCP window size!


2. Schneller wirst du deine Screenshots mit pure Java nicht hinkriegen. Falls es geht, dann musst du auf jeden Fall auf alternative Bilbiotheken ausweichen. DirectX kann das instant, du kannst direkt den VRAM Puffer nehmen -> natürlich nur unter Windows. Auch die GDI+ Alternativen bei Windows sind zu lahm für solche Faxen. Natürlich brauchst du Alternativen für andere Betriebssystem. Da hab ich aber keinen Plan. Manche Forenmitglieber behaupten, dass läge an der zeit, die Java braucht, um Puffer für die Screenshots zu stellen. Das ist seit langem nicht mehr der ausschlaggebende Faktor, sondern einfach das Fehlen des Zugriffs auf die Grafikkarte. Mit DX kann man innerhalb weniger ms einen kompletten SCreenshot machen (Egal ob Hd oder nicht). Bei Java dauert das selbst bei nicht HD gut und gerne mal 100 - 200 ms, je nach Kapazität.

-> JNI wäre hier ein Stichwort, bedeutet aber etwas mehr Arbeit ;-)

Gruß,

Chris

 

[Marco13]

Ganz allgemein wurde dieses Problem aber schon mehrfach behandelt, in
http://www.java-forum.org/awt-swing-swt/99632-bildqualitaet-verringern.html oder
http://www.java-forum.org/netzwerkprogrammierung/110914-bilduebertragung.html
findest du sicher einiges an "Inpsiration"...

 

[stulleman]

Ich habe jetzt schon sehr oft von JNI gehört doch ich lerne erst seid einem Jahr Java in der Schule und will mich nicht direkt übernehmen
Vielleicht ist das ja später eine alternative für mich, wollte ja nur raus finden ob ich überhaupt Bilder übers Netzwerk in Echtzeit schicken kann !
Danke trotzdem