Discussion :

[minod]

Salut.

J'essaie de récupérer pour mon client et par socket des images contenues sur un serveur. Lorsque je réécris les images sur le disque, ça fonctionne assez bien (mais a un côté aléatoire : des fois ça en passe 4, des fois 10...), et quand j'essaie de les afficher dans un JPanel ça bloque à 1 ou 2 images.

le Client:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
public class Client {
 
	static final int port = 3334;
	static final String host = "aluminod";
	public static final double STEP = 2000.0;
	public static final int DELAY = 0;
 
	private Socket socket;
	private PrintWriter printWriter;
	private BufferedReader input;
	private int imgNumber = 0;
	private static MoviePanel pane;
	private Timer timer;
 
	public Client() throws UnknownHostException, IOException{
		this.socket = new Socket(host, port);
		System.out.println("SOCKET = " + socket);
		this.printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);
		this.input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		start();
	}
 
	public static void main(String[] args){
		JFrame frame = new JFrame("test");
		pane = new MoviePanel();
		frame.setPreferredSize(new Dimension(600,400));
		frame.setSize(new Dimension(600,400));
		frame.setVisible(true);
		frame.setLocation(Toolkit.getDefaultToolkit().getScreenSize().width/2-300, Toolkit.getDefaultToolkit().getScreenSize().height/2-200);
 
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.getContentPane().setLayout(new BorderLayout());
		frame.getContentPane().add(pane, BorderLayout.CENTER);
		frame.add(pane);
 
 
		try {
			new Client();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
 
	}
 
	private void start(){
		this.timer = new Timer();
		timer.scheduleAtFixedRate(new TimerTask() {
			public void run() {
				try {
					sendParamsToVC();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}, DELAY, (long) STEP);
	}
 
	private void sendParamsToVC() throws IOException {
		System.out.println("---sending---");
		String mess = buildMessage();
 
 
		//envoi du message au serveur
		printWriter.println(mess);
 
		// lecture de la réponse du serveur
		InputStream is = socket.getInputStream();
		int taille = Integer.parseInt(input.readLine());
		byte[] mybytearray = new byte[taille];
		is.read(mybytearray, 0, taille);    
		BufferedImage img = ImageIO.read(new ByteArrayInputStream(mybytearray));
 
		pane.change(img);
		imgNumber++;
	}
 
	private String buildMessage(){
		String mess;
		if(imgNumber <10)mess = "000"+imgNumber;
		else if(imgNumber<=13)mess = "00"+imgNumber;
		else {
			mess = "NO_IMG";
			timer.cancel();
		}
		return mess;
 
	}
}

Le Serveur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
public class Server {
	static final int port = 3334;
 
	public static void main(String[] args) throws Exception {
		ServerSocket servsocket = new ServerSocket(port); 
		while (true) {
			Socket client = servsocket.accept();
			System.out.println("connection accepted");
 
			BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
			BufferedOutputStream output = new BufferedOutputStream(client.getOutputStream());
 
			while (true) {
				String str = reader.readLine();          // lecture du message
				if (str.equals("NO_IMG")){
					System.out.println("ECHO = " + str);
					System.out.println("fermeture");
					break;
				}
				System.out.println("ECHO = " + str);   // trace locale
 
				//renvoi de l'image
				OutputStream os = client.getOutputStream();
				byte[]data = getByteFromImage(str);
				PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())),true);
				writer.println(data.length);
				writer.flush();
				os.write(data, 0, data.length);
				os.flush();
 
			}
			output.close();
			reader.close();
			client.close();
		}
	}
 
	public static byte[] getByteFromImage(String numImage) {        
 
		BufferedImage img = ImageLoader.createBufferedImage(numImage);
 
        /** On crée la nouvelle image */
        BufferedImage bufferedImage = new BufferedImage(
                    img.getWidth(null),
                    img.getHeight(null),
                    BufferedImage.TYPE_INT_BGR );
        Graphics g = bufferedImage.createGraphics();
        g.drawImage(img,0,0,null);
        g.dispose();             
        ByteArrayOutputStream out = new ByteArrayOutputStream();
 
        try {
            ImageIO.write(bufferedImage, "jpeg", out);
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        byte buffer[] = out.toByteArray();
 
        try {
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        return (buffer);
	}
}

Voilà, je pense que je ne gère pas très bien mes stream d'entrée/sortie, et me demande si un traitement par UDP / flux ne serait pas meilleur, mais je ne sais absolument pas faire cela.

[minod]

Un premier problème de résolu :

J'oubliais de faire un printwriter.flush().

Ca fonctionne mieux mais bloque après 4 ou 5 images à:
is.read(mybytearray, 0, size); (côté client)

[bulbo]

Bonjour,

Ce serait bien d'avoir des détails sur ce qui ne se passe pas bien.. ça bloque après une ou deux images c'est un peu trop vague pour nous aider.

En l'état je pense que tu as un petit soucis ici:

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
// lecture de la réponse du serveur
		InputStream is = socket.getInputStream();
		int taille = Integer.parseInt(input.readLine());
		byte[] mybytearray = new byte[taille];
		is.read(mybytearray, 0, taille);    
		BufferedImage img = ImageIO.read(new ByteArrayInputStream(mybytearray));

Reads up to len bytes of data from the input stream into an array of bytes. An attempt is made to read as many as len bytes, but a smaller number may be read. The number of bytes actually read is returned as an integer.

Comme le dit la javadoc, ton read ne va peut-être pas pouvoir lire en une seule fois toute ton image. Il faudrait que tu aies une boucle qui exécute des read jusqu'à ce que tu aies tout lu ou jusqu'à un retour de -1 signifiant qu'il y a eu un problème de lecture.

Bulbo

[minod]

oui en effet, j'ai pas mal avancé entre temps.

le souci était que je ne vérifiais pas combien de bytes avaient été lus.

désormais je fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// lecture de la réponse du serveur
 
		byte[]imgSize = new byte[SIZE_OF_LENGTH_ARRAY];
		bis.read(imgSize, 0, SIZE_OF_LENGTH_ARRAY);
		ByteBuffer bb = ByteBuffer.wrap(imgSize);
		int size = bb.getInt();
 
		System.out.println("Client: size="+size);
		byte[] tmpData = new byte[size];
		System.out.println("tmpData length = "+tmpData.length);
		int readen = bis.read(tmpData, 0, tmpData.length);
		System.out.println("readen="+readen);
 
		byte[]finalData = new byte[size];
		if(readen == size){
			finalData = tmpData;
		}
		else{
			int totalRead = readen;
			int j=1;
			while(totalRead<size){
				System.out.println("-----------append number "+j+"----------");
				System.out.println("totalRead="+totalRead);
				for(int i=0;i<tmpData.length;i++){
					finalData[i]=tmpData[i];
				}
				tmpData = new byte[size-totalRead];
				int tmpRead = bis.read(tmpData, 0, size-totalRead);
				System.out.println("tmpRead="+tmpRead);
				for(int i=0;i<tmpData.length;i++){
					finalData[i+totalRead]=tmpData[i];
				}
				totalRead+=tmpRead;
				j++;
			}
			System.out.println("totalRead final="+totalRead);
		}
 
		BufferedImage img = ImageIO.read(new ByteArrayInputStream(finalData));

Ca fonctionne bien si je parviens à lire l'image en un seul coup, ou en deux.
Mais si je passe plus d'une fois dans la boucle, je récupère une image nulle.

Un exemple de trace : la première image est bien décodée, mais la seconde non, alors que je lis apparemment le bon nombre de bytes (85921)

---Client: sending mess number 1---
Client: size=31099
tmpData length = 31099
readen=31099
---Client: sending mess number 2---
Client: size=85921
tmpData length = 85921
readen=17520
-----------append number 1----------
totalRead=17520
tmpRead=17520
-----------append number 2----------
totalRead=35040
tmpRead=17520
-----------append number 3----------
totalRead=52560
tmpRead=31408
-----------append number 4----------
totalRead=83968
tmpRead=1953
totalRead final=85921
image nulle


EDIT:
Résolu, la boucle for écrasait des données, en la sortant du while c'est ok.
Merci !