[JMF][RTPManager] probleme de transmission ou de reception de video

voila aprés des jours complets de recherche je me suis décidé à demander clairement sur ce forum de l'aide ...

je dois réaliser un logiciel de visioconférence
j'utilise donc un RTPManager pour la transmission de la video

je crois que l'envoie de la video se passe bien ... peut etre est ce alors la réception qui ne fonctionne pas ::

voici le code du server
Code:


package server;

import javax.media.*;
import javax.media.rtp.*;
import javax.media.rtp.event.*;
import javax.media.format.*;
import javax.media.control.*;
import javax.media.protocol.*;
import javax.media.rtp.rtcp.*;

import java.io.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

import javax.swing.*;

import com.sun.media.protocol.DataSource;


public class fenetre_server
{
// Declaration du CaptureDeviceInfo de la Webcam et du micro
CaptureDeviceInfo Webcam = null;
CaptureDeviceInfo Micro = null;

// Declaration des Processors du Micro et de la Webcam
Processor MicroCessor = null;
Processor WebcamCessor = null;

// paneVideo Jpanel contenant le player video
JPanel paneVideo = null;
// player = player video
Player player = null;

JFrame server = null;
javax.media.protocol.DataSource ds = null;

// Ports de transmission de la video
private int local_port = 40000;
private int dest_port = 22224;

// Variables du RTPManager
RTPManager rtpm=null;
SessionAddress localaddr=null;
Vector sendS = new Vector();;


public fenetre_server()
{
afficher_server_webcam();
}

public void configurer_source()
{
// Recherche des CaptureDevices
//Vector deviceList = CaptureDeviceManager.getDeviceList(new AudioFormat( "linear",8000,8,1));
Vector deviceList2 = CaptureDeviceManager.getDeviceList(new VideoFormat(VideoFormat.RGB));

// Creation des CaptureDeviceInfo pour le Micro et la Webcam
//Micro = (CaptureDeviceInfo)deviceList.get(0); // 0 premier par exemple
Webcam = (CaptureDeviceInfo)deviceList2.get(0);


try
{
ds = Manager.createDataSource(Webcam.getLocator());
}
catch (NoDataSourceException e1)
{
e1.printStackTrace();
}
catch (IOException e1)
{
e1.printStackTrace();
}

try
{
//Creation du Processor du Micro et de la Webcam
//MicroCessor = Manager.createProcessor(Micro.getLocator());
WebcamCessor = Manager.createProcessor(ds);
System.out.println("WebCamCessor initialisé");
}
catch(IOException e)
{
System.out.println("Erreur 1 : "+e.getMessage());
}
catch(NoProcessorException e)
{
System.out.println("Erreur 2 : "+e.getMessage());
}
}

public void configuration()
{
//this.MicroCessor = configure(MicroCessor);
this.WebcamCessor = configure(WebcamCessor);

//this.SetSupportedFormat(MicroCessor);
this.SetSupportedFormat(WebcamCessor);

//this.MicroCessor = realize(MicroCessor);
this.WebcamCessor = realize(WebcamCessor);

//this.MicroCessor.start();
this.WebcamCessor.start();

System.out.println("WebCamCessor configuré");
}

public Processor configure(Processor p)
{
//Attendre tant que le Processor n'est pas configuré.
while(p.getState() < Processor.Configured)
{
//Configuration du Processor
p.configure();
}
return p;
}

public void SetSupportedFormat(Processor p)
{
//On met la description du contenu de sortie à RAW_RTP
// pour limiter les formats supportés
ContentDescriptor cd = new ContentDescriptor(ContentDescriptor.RAW_RTP);
p.setContentDescriptor(cd);

//On obtient les différentes pistes du processor
TrackControl track[] = p.getTrackControls();
for(int i = 0 ; i < track.length ; i++)
{
//on obtient les formats supportés pour cette piste
Format suppFormats[] = track[i].getSupportedFormats();

//Si il y a au moins un format supporté
// alors on met le premier
if(suppFormats.length > 0)
{
track[i].setFormat(suppFormats[0]);
}
else
{
track[i].setEnabled(false);
}
}
}

public Processor realize(Processor p)
{
//Attendre tant que le Processor n'est pas réalisé.
while(p.getState() < Processor.Realized)
{
//Réalisation du Processor
p.realize();
}
return p;
}

public void affichage_video()
{
// mise en place du player
try {
// mis ds le try pour eviter les erreurs;
paneVideo = new JPanel();
server.getContentPane().add(paneVideo,BorderLayout.CENTER);

player = Manager.createRealizedPlayer(ds);
player.start();
paneVideo.add(player.getVisualComponent());
System.out.println("Player démarré et affiché.");

paneVideo.repaint();
server.getContentPane().repaint();
server.repaint();
}
catch (IOException ioe) {
WebcamCessor.stop();
WebcamCessor.close();
System.out.println("Erreur ioe : "+ioe);
}
catch (NoPlayerException npe) {
WebcamCessor.stop();
WebcamCessor.close();
System.out.println("Erreur npe : "+npe);
}
catch (CannotRealizeException cre) {
WebcamCessor.stop();
WebcamCessor.close();
System.out.println("Erreur cre : "+cre);
}

}

public void afficher_server_webcam()
{
JButton activer = new JButton("Activer webcam");
activer.addMouseListener(new activer_webcam());
JButton desactiver = new JButton("Désactiver webcam");
desactiver.addMouseListener(new desactiver_webcam());

server = new JFrame("Configurer webcam");
server.setSize(500,500);
server.getContentPane().add(activer,BorderLayout.NORTH);
server.getContentPane().add(desactiver,BorderLayout.SOUTH);

server.show();
}

class activer_webcam implements MouseListener
{

public void mouseClicked(MouseEvent arg0)
{
configurer_source();
configuration();
affichage_video();
//createTransmitter(WebcamCessor);
createRTPManager(WebcamCessor);
//createDataSink(WebcamCessor);

//createRTPManager2(WebcamCessor);
//addDestination("192.168.0.5");
}

public void mouseEntered(MouseEvent arg0) {}
public void mouseExited(MouseEvent arg0) {}
public void mousePressed(MouseEvent arg0) {}
public void mouseReleased(MouseEvent arg0) {}
}

class desactiver_webcam implements MouseListener
{

public void mouseClicked(MouseEvent arg0)
{
WebcamCessor.stop();
WebcamCessor.close();
System.out.println("WebcamCessor fermé");
}

public void mouseEntered(MouseEvent arg0) {}
public void mouseExited(MouseEvent arg0) {}
public void mousePressed(MouseEvent arg0) {}
public void mouseReleased(MouseEvent arg0) {}
}

public void createRTPManager(Processor p)
{
//Creation du DataSource correspondant au Processor
javax.media.protocol.DataSource OutputSource = p.getDataOutput();

//Nouvelle Instance d'un RTPManager
RTPManager rtpm = RTPManager.newInstance();
//rtpm.addFormat(new VideoFormat(VideoFormat.RGB),0);

try
{
//Création d'une SessionAddress correspondant à l'adresse locale
SessionAddress localaddr = new SessionAddress(InetAddress.getLocalHost(),40000);
//Initialisation du RTPManager à partir de la SessionAddresse locale
rtpm.initialize(localaddr);
//Création d'une SessionAddress correspondant à l'adresse de destination
SessionAddress destaddr = new SessionAddress(InetAddress.getByName("192.168.0.5"),22224);
//Ajout de cette SessionAddress dans le RTPManager
rtpm.addTarget(destaddr);
//Creation d'un SendStream à partir du DataSource
SendStream ss2 = rtpm.createSendStream(OutputSource,0);
//Demarrage du SendStream
ss2.start();
System.out.println("SendStream Started");
}
catch(UnknownHostException e){System.out.println("erreur : "+e);}
catch(IOException e) {System.out.println("erreur : "+e); }
catch(InvalidSessionAddressException e) {System.out.println("erreur : "+e); }
catch(UnsupportedFormatException e) { System.out.println("erreur : "+e);}

}
}




et maintenant celui du client
Code:

package client;

import java.io.IOException;
import java.net.InetAddress;

import javax.media.Codec;
import javax.media.*;
import javax.media.format.VideoFormat;
import javax.media.rtp.*;
import javax.media.rtp.event.*;
import javax.swing.*;

public class client_rtpmanager implements ReceiveStreamListener
{
private int local_port = 45000;
private int source_port = 22224;

public static void main(String[] args) {new client_rtpmanager(); }

public client_rtpmanager()
{
JFrame mainfra = new JFrame();
mainfra.setVisible(true);

boolean dataReceived = false;
Object dataSync = new Object();

//Instanciation du RTPManager
RTPManager VideoManager = RTPManager.newInstance();
VideoManager.addFormat(new VideoFormat(VideoFormat.H263_RTP), 0);

try
{
//Creation d'une SessionAddress pour l'adresse locale
SessionAddress add = new SessionAddress(InetAddress.getLocalHost(),local_port);
//SessionAddress add = new SessionAddress();
System.out.println("----------- adresse locale -----------");
System.out.println(add.toString());
//Initialisation du RTPManager à partir de cette SessionAddress
VideoManager.initialize(add);

//Creation d'une SessionAddress pour l'adresse source
SessionAddress add2 = new SessionAddress(InetAddress.getByName("192.168.0.5"),source_port);
System.out.println("----------- adresse source -----------");
System.out.println(add2.toString());
//Ajout de cette SessionAddress dans le RTPManager
VideoManager.addTarget(add2);
}
catch(InvalidSessionAddressException e) {System.out.println("Erreur : "+e); }
catch(IOException e){ System.out.println("Erreur : "+e);}

//Ajout du Listener de Reception de Stream dans le RTPManager
VideoManager.addReceiveStreamListener(this);
System.out.println("Client Started");

}

public void update(ReceiveStreamEvent event)
{
System.out.println("EN cours de réception");

//Verification que l'event est un nouvel event
if(event instanceof NewReceiveStreamEvent)
{
System.out.println("New Reception");

//Nouveau Flux Recu obtenu
ReceiveStream rs = event.getReceiveStream();
try
{
//Creation du Player sur ce flux
Player p = Manager.createRealizedPlayer(rs.getDataSource());
//Si le player a un composant visuel, alors creation d'une fenetre
if(p.getVisualComponent() != null)
{
JFrame fenetre = new JFrame("Player");
fenetre.setSize(160,140);
fenetre.getContentPane().add(p.getVisualComponent());
fenetre.setVisible(true);
}
//Demarrage du Player
p.start();
}
catch(NoPlayerException e) {System.out.println("Erreur e :"+e);}
catch(CannotRealizeException e) {System.out.println("Erreur e :"+e);}
catch(IOException e) {System.out.println("Erreur e :"+e);}
}
else System.out.println("C'était un nouvel receivestream");

}
}

deja met un ecouteur de reseau pour voir s'il y a une communication entre ton client et ton serveur si tu ne sais pas si ton serveur marche.

qu'est ce qu'un ecouteur de réseau ???? jvai chercher ca ...

ethereal, tcpview ...

salut vdavid1982,
j'ai le meme problème que toi !!!
As-tu trouvé la solution ???
je suis désespéré, après plusieurs jours de galère aucune solution trouvée ........

Bonjour

j'ai a peu prés le meme code et moi ça marche !!!

le probleme ne pourrait-il pas venir de cette ligne:
coté client :

VideoManager.addFormat(new VideoFormat(VideoFormat.H263_RTP), 0);

moi j'ai plutot:
VideoManager.addFormat(new VideoFormat(VideoFormat.H263_RTP), 18);

le probleme ke ce code fonctione dans certains ordinateur...

Salut a tous,
j'ai exactement le meme probleme et j'arrive tjr pas a trouver la solution???

Ce code marche bien

Class Emetteur:
import java.net.*;
import java.io.*;

//import pour la JMF
import javax.media.*;
import javax.media.rtp.*;
import javax.media.format.*;
import javax.media.control.*;
import javax.media.protocol.*;


//classe qui gere la communication cote emission
//ainsi que la recuperation du flux de la webcam

public class emetteurCOM {

    private String adresseDest;
    private emetteurIHM parent;
    private MediaLocator videoLocator;
    private Processor WebcamCessor = null;


    public emetteurCOM(emetteurIHM parent) {
        this.parent = parent;
    }


    public void webCam() {

        //configuration de la source webcam
        parent.ecritureAffichage("Configuration de la source (webcam)");
        videoLocator = new MediaLocator("vfw://0");

        try {
            //creation du processor a partir de la webcam trouvee
            parent.ecritureAffichage("Creation du processor");
            WebcamCessor = Manager.createProcessor(videoLocator);
        } catch (NoProcessorException ex) {
        } catch (IOException ex) {
        }

        //appel des differentes methodes pour l'envoi du flux video
        parent.ecritureAffichage("Configuration du processor");
        configure(WebcamCessor);
        parent.ecritureAffichage("Mise au bon format du flux");
        SetSupportedFormat(WebcamCessor);
        parent.ecritureAffichage("Processor pret !");
        WebcamCessor = realize(WebcamCessor);
        parent.ecritureAffichage("Demarrage du processor");
        Demarre(WebcamCessor);
        parent.ecritureAffichage("Creation du RTPManager");
        createRTPManager(WebcamCessor);
    }


    public void setAdresseDest(String adresseDest) {

        this.adresseDest = adresseDest;
    }



    //Pour pouvoir transmettre un flux, un processor doit passer par differentes etapes

    //1- Configuration du Processor (démultiplexe le flux d'entrée et obtient des informations sur le format des données d'entrée)
    public Processor configure(Processor p) {

        //Attendre tant que le Processor n'est pas configuré.
        while (p.getState() < Processor.Configured) {
            //Configuration du Processor
            p.configure();
        }
        return p;
    }



    //2- Mise des differentes pistes du flux dans un format supporte
    public void SetSupportedFormat(Processor p) {

        //On met la description du contenu de sortie à RAW_RTP
        //     pour limiter les formats supportés
        ContentDescriptor cd = new ContentDescriptor(ContentDescriptor.RAW_RTP);
        p.setContentDescriptor(cd);

        //On obtient les différentes pistes du processor
        TrackControl track[] = p.getTrackControls();
        for (int i = 0; i < track.length; i++) {
            //on obtient les formats supportés pour cette piste
            Format suppFormats[] = track[i].getSupportedFormats();

            //Si il y a au moins un format supporté

            //            alors on met le premier
            if (suppFormats.length > 0) {
                track[i].setFormat(suppFormats[0]);
            } else {
                track[i].setEnabled(false);
            }
        }
    }


    //3- Realisation du processor => processor pret !
    public Processor realize(Processor p) {

        //Attendre tant que le Processor n'est pas réalisé.
        while (p.getState() < Processor.Realized) {
            //Réalisation du Processor
            p.realize();
        }
        return p;
    }


    //4- Demarrage du procesor
    public void Demarre(Processor p) {

        //Demarrage du Processor
        p.start();
    }



    //Transmission du flux video

    //Utilisation d'un RTPManager
    public void createRTPManager(Processor p)
    {

        //Creation du DataSource correspondant au Processor
        DataSource OutputSource = p.getDataOutput();

        //Nouvelle Instance d'un RTPManager
        RTPManager rtpm = RTPManager.newInstance();

        try
        {
            //Création d'une SessionAddress
            //     correspondant à l'adresse locale
            SessionAddress localaddr = new SessionAddress
                                       (InetAddress.getLocalHost(), 40000);

            //Initialisation du RTPManager
            //     à partir de la SessionAddresse locale
            rtpm.initialize(localaddr);

            //Création d'une SessionAddress
            //     correspondant à l'adresse de destination
            SessionAddress destaddr = new SessionAddress
                                      (InetAddress.getByName(adresseDest),
                                       22224);

            //Ajout de cette SessionAddress dans le RTPManager
            rtpm.addTarget(destaddr);

            //Creation d'un SendStream à partir du DataSource
            SendStream ss2 = rtpm.createSendStream(OutputSource, 0);

            //Demarrage du SendStream
            ss2.start();
            System.out.println("Started");
        }
        catch (UnknownHostException e)
        {}
        catch (IOException e)
        {}
        catch (InvalidSessionAddressException e)
        {}
        catch (UnsupportedFormatException e)
        {}
    }


}//class


Class IHM pour Emetteur:
import javax.swing.*;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.awt.Dimension;
import java.awt.Color;
import java.awt.event.WindowEvent;
import java.awt.event.WindowAdapter;
import javax.swing.border.*;
import java.text.*;


//classe qui gere l'interace graphique cote emission

public class emetteurIHM extends JFrame{

    private JPanel contentPanel;
    private JPanel panelBouton;
    private JPanel panelAdresse;
    private JButton boutonConnection;
    private JTextArea affichage;
    private JScrollPane scrollAffichage;

    //pour la recuperation de l'adresse IP
    private JFormattedTextField IPDest1;
    private JFormattedTextField IPDest2;
    private JFormattedTextField IPDest3;
    private JFormattedTextField IPDest4;

    private String adresseDest;

    private emetteurCOM com;


    public emetteurIHM() {

        //creation de la fenetre
        super("Emetteur");

        //creation de l'objet permettant la communication en emission
        com = new emetteurCOM(this);

        try {
            jbInit();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }



    public void jbInit() {

        //definition de la taille de la fenetre
        this.setSize(350, 500);
        this.setResizable(false);

        //creation du panel de la JFrame
        contentPanel = (JPanel) getContentPane();

        panelBouton = new JPanel();
        panelAdresse = new JPanel();

        boutonConnection = new JButton("Connection");

        affichage = new JTextArea();
        affichage.setLineWrap(true);
        affichage.setWrapStyleWord(true);
        scrollAffichage = new JScrollPane(affichage);
        affichage.setEditable(false);
        affichage.setBackground(Color.white);
        scrollAffichage.setPreferredSize(new Dimension(0, 400));

        panelBouton.setLayout(new BoxLayout(panelBouton, BoxLayout.X_AXIS));
        panelBouton.setBackground(Color.white);
        panelBouton.add(boutonConnection);
        boutonConnection.setAlignmentY(CENTER_ALIGNMENT);
        panelBouton.add(Box.createRigidArea(new Dimension(20, 0)));

        //pour le format des differents octets de l'adresse IP (integer)
        NumberFormat nf = NumberFormat.getIntegerInstance();


        panelAdresse.setLayout(new BoxLayout(panelAdresse, BoxLayout.X_AXIS));
        panelAdresse.setBackground(Color.white);
        panelAdresse.setBorder(new TitledBorder("IP destinataire"));

        IPDest1 = new JFormattedTextField(nf);
        IPDest1.setHorizontalAlignment(JTextField.RIGHT);
        panelAdresse.add(IPDest1);
        panelAdresse.add(new JLabel("  .  "));

        IPDest2 = new JFormattedTextField(nf);
        IPDest2.setHorizontalAlignment(JTextField.RIGHT);
        panelAdresse.add(IPDest2);
        panelAdresse.add(new JLabel("  .  "));

        IPDest3 = new JFormattedTextField(nf);
        IPDest3.setHorizontalAlignment(JTextField.RIGHT);
        panelAdresse.add(IPDest3);
        panelAdresse.add(new JLabel("  .  "));

        IPDest4 = new JFormattedTextField(nf);
        IPDest4.setHorizontalAlignment(JTextField.RIGHT);
        panelAdresse.add(IPDest4);

        contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));
        contentPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
        contentPanel.setBackground(Color.white);

        contentPanel.add(panelAdresse);
        contentPanel.add(Box.createRigidArea(new Dimension(200, 10)));
        contentPanel.add(panelBouton);
        contentPanel.add(Box.createRigidArea(new Dimension(200, 10)));
        contentPanel.add(scrollAffichage);

        this.gestionEvenementsFenetre();
        this.show();

        boutonConnection.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {

                if (IPDest1.getText().length() == 0 ||
                    IPDest2.getText().length() == 0 ||
                    IPDest3.getText().length() == 0 ||
                    IPDest4.getText().length() == 0) {
                    ecritureAffichage("Aucune adresse n'a ete saisie");
                } else {

                    adresseDest = new String(IPDest1.getText()
                                             + "." + IPDest2.getText()
                                             + "." + IPDest3.getText()
                                             + "." + IPDest4.getText());
                    com.setAdresseDest(adresseDest);
                    com.webCam();
                }
            }
        });
    }



    //gestion des evenements de la fenetre principale
    public void gestionEvenementsFenetre() {

        WindowAdapter win = new WindowAdapter() {
            //fermeture de la fenetre
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        };

        //le gestionnaire gere les evenements de la fenetre courante
        this.addWindowListener(win);
    }



    //permet d'ecrire dans la zone de texte
    public void ecritureAffichage(String s) {
        affichage.append(s + "\n");
    }

}//class

ClassTestEmetteur:
import javax.swing.UIManager;


public class testEmetteur {
    public testEmetteur() {

        try {
            jbInit();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    //programme principal
    public static void main(String[] argv) {

        //permet de donner a notre application l'aspect des appli de l'OS sur laquelle on est
        try {
            UIManager.setLookAndFeel(UIManager.
                                     getSystemLookAndFeelClassName());
        } catch (Exception exception) {
            exception.printStackTrace();
        }

        emetteurIHM em = new emetteurIHM();

    }



    private void jbInit() throws Exception {
    }
}

Class Recepteur:
import java.net.*;
import java.io.*;
import javax.swing.*;

//import pour la jmf
import javax.media.*;
import javax.media.rtp.*;
import javax.media.rtp.event.*;
import javax.media.format.*;
import java.awt.Color;
import java.awt.Dimension;


//classe qui gere toute la reception

public class recepteur {

    private JPanel contentPanel;
    private JLabel label1;

    public static void main(String[] args) {
        new recepteur();
    }

    public recepteur() {

        JFrame mainfra = new JFrame();
        mainfra.setSize(200,100);

        contentPanel = (JPanel) mainfra.getContentPane();
        contentPanel.setBackground(Color.white);
        contentPanel.setLayout(new BoxLayout(contentPanel, BoxLayout.Y_AXIS));

        label1 = new JLabel("En attente du flux video...");

        contentPanel.add(Box.createRigidArea(new Dimension(0, 25)));
        contentPanel.add(label1);
        mainfra.setVisible(true);


        //Instanciation du RTPManager
        RTPManager VideoManager = RTPManager.newInstance();
        VideoManager.addFormat(new VideoFormat(
                VideoFormat.H263_RTP), 18);

        try {
            //Creation d'une SessionAddress pour l'adresse locale
            SessionAddress add = new SessionAddress(
                    InetAddress.getLocalHost(), 22224);

            //Initialisation du RTPManager
            //     à partir de cette SessionAddress
            VideoManager.initialize(add);

            //Creation d'une SessionAddress pour l'adresse source
            SessionAddress add2 = new SessionAddress(
                    InetAddress.getByName("127.0.0.1"), 40000);

            //Ajout de cette SessionAddress dans le RTPManager
            VideoManager.addTarget(add2);
        }

        catch (InvalidSessionAddressException e) {}

        catch (IOException e) {}

        //Ajout du Listener de Reception de Stream dans le RTPManager (on attend l'arrivee d'un flux)
        VideoManager.addReceiveStreamListener(new ReceiveStreamListener() {

                //Gestion de l'évènement ReceiveStreamEvent
                //Cette méthode se produit lorsque l'on reçoit un flux.
                //Il faut donc d'abord s'assurer que c'est un nouveau flux.
                //Ensuite, on récupère le DataSource de ce flux et on crée un Player avec.
                //Enfin si, c'est un flux vidéo, on ajoute le composant visuel dans une nouvelle Fenêtre créée.

            public void update(ReceiveStreamEvent event) {

                //Verification que l'event est un nouvel event
                if (event instanceof NewReceiveStreamEvent) {
                    System.out.println("Reception d'un flux");

                    //Nouveau Flux Recu obtenu
                    ReceiveStream rs = event.getReceiveStream();

                    try {

                        //Creation du Player sur ce flux
                        Player p = Manager.createRealizedPlayer(
                                rs.getDataSource());

                        //Si le player a un composant visuel,
                        //     alors creation d'une fenetre
                        if (p.getVisualComponent() != null) {

                            JFrame fenetre = new JFrame("Reception");
                            fenetre.setSize(320, 280);
                            fenetre.getContentPane().add(
                                    p.getVisualComponent());
                            fenetre.setVisible(true);
                            fenetre.setLocation(100,0);
                        }

                        //Demarrage du Player
                        p.start();

                        label1.setText("Flux video recu");

                    } catch (NoPlayerException e) {}

                    catch (CannotRealizeException e) {}

                    catch (IOException e) {}

                }

            }
        });


        System.out.println("Client demarre");

    }

}//class

et pou bien fonctioner demarer le Recepteur puis l'Emeteur:

Ok merci je vai essayer ça.