sockets geignet um ein picture frame zu senden?

Hallo,

ich hab ein programm das das bild signal von der Grabber karte einließt und den pointer hierauf in einem named Pipe also Fifo speichert.

Das ander Programm von Glut liest den Fifo aus und stellt das bild dar.

das funktioniert auch soweit nun meine Frage ich würd das gern mit sockets machen , da die programme mal auf 2 verschiendenen rechner laufen sollen.

geht das überhaupt mit sockets? und falls ja hat da jemand ein tipp wie ich des mach?

hab mich bisher noch net mit sockets auseinandergesetzt

danke für euro hinweise und tipps

oli 22

Aktueller Codeausschnitt aus dem Grabbing Programm:

..
int fififo;
short* GrabImg1;
...
while (1)
   {
	 try 
	 {
	   Grabber1->grab(true);
	   GrabImg1 = (unsigned short *) Grabber1->getRGB16(); 

		write(fd_fifo,&GrabImg1,sizeof(unsigned short* )) ;//write signal in pipe

	   if (stopGrabingParam==1)  //stop grabbing
	 	{  
	 	  stopGrabingParam=0;
	 	  pthread_exit(NULL);
		} 			
	 }

Ausschnitt von dem Glut Programm:

...
void Showimag::getImages(void)
{
	unsigned short *ja;
		if( !( read( file, &ja, sizeof (unsigned short* ) ) ) )  //auslesen der pipe
			  fprintf(stderr,"fehler beim öffnen der pipe" );

  Img=ja;
}

...

//Glut main 
void* Showimag::showDisplay(void *arg)
{ 
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowSize((int)(PixZoom*WIDTH),(int)(PixZoom*HEIGHT));

  glutInitWindowPosition(000,000);    //window position in X,Y
  glutCreateWindow("camerawindow1");  //window name  

  glutDisplayFunc(display);

  glutReshapeFunc(reshape);

  glutKeyboardFunc(keyboard);
  glutIdleFunc(idle);

  glClearColor(0.,0.,0., 0.);

  sleep(1);

  glutMainLoop();
  return 0;

Naja ein Bild ist ja nur ne Aufreihung von Bytes (Farbwerten und anderen Informationen den es gibt ja Geräteabhängige- und Geräteunabhängige Images)

Du müsstest dir bei deinem Client und Serverprogramm (was über Sockets läuft)
nen kleines minimales Protkoll einfallen lassen!
z.B.: Der Client schickt dem Server - Programm das Schlüsselwort Imagebegin
Der Server schaltet dann auf einen bestimmten Modus und schreibt nun alle folgenden
Bytes in eine Datei solange bis das Schlüsselwort Imageends vom Client gesendet wird. Das wäre grob gesagt den Ansatz den ich bei Bildinformationen und Sockets gehen würde!

P.S.: Du müsstest dir auch noch ne Schlüsselwortkonstellation fuer den Dateinamen des zu sendenten Images einfalen lassen!

Grüsse

Power Off

Wenn ein Pointer ueber eine Pipe uebergeben wird, ist das wahrscheinlich ein Pointer auf Shared Memory, also Speicher, der zwischen zwei Programmen geteilt wird.

Den Pointer an einen anderen Rechner zu uebergeben, ist m.W. nicht moeglich, da m.W. kein Distributed Shared Memory Protokoll oder sowas existiert.

Ein Zeiger ist ja ein Zeiger in den Speicher des lokalen Rechners, sendet man den Zeiger an einen anderen Rechner, so nuetzt das nichts, da die Daten ja dort nicht gespeichert sind.

Man kann das Problem aber folgendermassen loesen: Man schreibt ein Programm, das den Pointer aus der Pipe ausliest, dann den Shared Memory Bereich mit dem Bild ausliest, und dann das Bild ueber einen Socket an einen anderen Rechner versendet, also die Bilddaten. Auf der anderen Seite macht man es genau anders herum: Man schreibt ein Programm, das die Bilddaten ueber den Socket in den Speicher einliest, und via Shared Memory exponiert, sowie den Pointer auf einer Pipe anbietet (d.h. den Pointer beim Lesezugriff zurueckliefert).

Hey das mit dem Pointer übergeben dass das so nicht funktioniert hab ich mir schon gedacht...
dank euch mal für die Lösungsansätze an sowas hab ich auch gedacht...

Ok deine Ausführungen warum das so auf 2 Rechner nicht funktioniert sind klar.

ZU dem Problemlösungsvorschlag hab ich noch ein paar Fragen:

Man kann das Problem aber folgendermassen loesen: Man schreibt ein Programm, das den Pointer aus der Pipe ausliest,
--> ok das hab ich ja schon
dann den Shared Memory Bereich mit dem Bild ausliest,
-->? wie mach ich das am besten??da fehlt mir der Ansatz
und dann das Bild ueber einen Socket an einen anderen Rechner versendet, also die Bilddaten.
--> naja denk mal bilddaten sind ja nur Integer werte oder??? also am besten als integer array oder??? wie mach ich das wiederum am besten?

Auf der anderen Seite macht man es genau anders herum: Man schreibt ein Programm, das die Bilddaten ueber den Socket in den Speicher einliest
--> in was für ein Speicher einließt??? ein shared memory?? den ich erst noch anlegen muss oder?
, und via Shared Memory exponiert,
-->??? versteh ich net
sowie den Pointer auf einer Pipe anbietet (d.h. den Pointer beim Lesezugriff zurueckliefert).
-->> das ist mir au net so recht klar

Sorry wenn ich nerv aber ich frag einfach und sag wenn mir was net ganz deutlich ist danke für eure hilfe

rüdiger

Sender:

size_t laenge_des_image; //irgend wie auslesen
write(sock, &laenge_des_image, sizeof(size_t));
write(sock, GrabImg1, laenge_des_image);

Empfänger:

size_t laenge_des_image;
read(sock, &laenge_des_image, sizeof(size_t));
short image[laenge_des_image];
read(sock, image, laenge_des_image);

ok ich versuch das posting von kingruedi zu erklären...
sender:

//hier weiss ich size_t die länge des bildes zu
size_t laenge_des_image; //irgend wie auslesen 

//hier sag ich dem socket dass er genau so gross wie das eine bild sein muss
write(sock, &laenge_des_image, sizeof(size_t));

//hier shcick ich das bild GrabImg1 an den socket
write(sock, GrabImg1, laenge_des_image);

empfänger:

//ich weiss wieder wie lang(groß) das bild sein wird
size_t laenge_des_image;

//ich les das bild ein
read(sock, &laenge_des_image, sizeof(size_t));

//ich mach mir ein short arry mit dem bilder
short image[laenge_des_image];

//ich les das bild aus
read(sock, image, laenge_des_image);

irgendwie komisch stimmt das so?

aber das hat dann ja nichts mit dem Beitrag von Power Off zu tun oder? so schick ich doch einfach über ein socket die bilder rüber stimmt des? danke mal