[Réseau] BufferedReader et curseur de InputStream

**millie** · 23/09/2007, 19h59

Bonjour,

Lors d'un échange réseau, je recois un message (côté java). Il y a une partie en texte (j'utilise donc le BufferedReader) puis une image écrite en dur. J'aimerais réutiliser directement mon InputStream au moment de la lecture de l'image (car je tiens à avoir directement des bytes).

Le seul problème, c'est que j'ai l'impression que le BufferedReader n'a jamais fait avancer le curseur de l'InputStream. Ce qui fait que mon image a un décalage étant donné que je recommence à lire des parties de texte avec l'InputStream.

Est-ce que vous savez comment obliger le BufferedReader à faire avancer le curseur de l'InputStream à chaque appel de la méthode readLine ?

Sinon, j'ai bien essayer d'utiliser la méthode read de BufferedReader qui lui utilise des char[]. Mais la conversion char -> byte ne s'est jamais bien fait.

Merci

**adiGuba** · 23/09/2007, 22h04

Salut,

Je pense que tu dois envoyer plusieurs données et que tu est déjà à la suivante et que le BufferedReader a "lu" ton image. En effet les Buffered(Reader et InputStream) utilisent un buffer de 8192 éléments qui sont lu d'un bloc pour éviter de trop multiple accès I/O...

Pour t'aider il faudrait connaitre un peu la structure des message que tu envois, mais perso j'utiliserais plutôt BufferedInputStream et j'utiliserais le constructeur String(byte[],charset) pour récupérer la chaine de caractère...

a++

**millie** · 23/09/2007, 22h26

Grosso modo, la partie Java recoit quelque chose du genre :

Code :

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

1
2
3
4
5
6
7
MIPP/1.0 100 OK
Server: TEST
Response:
ImageType: RGBSHORT
ImageWidth: 1200
ImageHeight: 1844
...

Au niveau des trois petits point, cela va être une liste de byte (3*1200*1844 bytes, *3 à cause des 3 couleurs).

Donc, si le byte vaut -128, cela correspond au noir et si le byte vaut 127, cela correspond au blanc.

Grosso modo, au début, je fais pas mal de readLine jusqu'à ImageHeight. Et à ce moment, j'entame la lecture de tout le bloc :
Donc, en utilisant un code du style :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int totalSize = iwidth * iheight *3;
byte[] b = new byte[totalSize];
int received = 0;
int toReceive = totalSize;
int totalReceived = 0;
 
 
while(toReceive>0 && received!=-1) {
	received = stream.read(b, totalReceived, toReceive);
	toReceive -= received;
	totalReceived += received;
}

Et du coup, j'obtiens quelque chose du genre :

Effectivement, le coup du readLine qui lit plus que ce qui était prévu. Je n'y avais pas pensé

Et ça expliquerait le problème.
En fait, la seule solution, ce serait d'utiliser le read du BufferedReader et de transformer mes char en byte.

**adiGuba** · 23/09/2007, 23h32

Envoyé par millie

En fait, la seule solution, ce serait d'utiliser le read du BufferedReader et de transformer mes char en byte.

Non plutôt l'inverse...

Étant donné que le "code" de l'image doit surement correspondre à des caractères invalides et que certain caractères spéciaux peuvent être représentés de différentes manières, il y a de forte chance que tu ne retrouves pas exactement tes bytes ce qui dégraderait l'image

Donc ce serait plus simple de faire l'inverse : utiliser un BufferedInputStream et lire des bytes, et se coder une méthode readLine() qui lirait une ligne depuis un InputStream, par exemple :

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
	public static String readLine(InputStream is, String charsetName) throws IOException {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		int b;
 
		// On lit l'input caractère par caractère (pour ne pas empiéter sur l'image)
		// ==> Du coup il est préférable que ce soit un BufferedInputStream
		while ( (b=is.read()) >= 0) {
			baos.write(b);
			// Et on arrête lorsqu'on trouve un retour à la ligne :
			if (b=='\n') {
				break;
			}
		}
		return new String(baos.toString(charsetName));
	}