Plusieurs Player pour la même data-source vidéo

**byn1984** · 03/05/2011, 16h28

Je récupère un flux vidéo avec une camera. Je veux enregistrer ce flux en gardant le visionnage du vidéo au même temps . la partie que j'ai développé donne les résultats suivant:
- fixe le vidéo.
- fais des sauvegardes
- Bloques les autres fonctionnalités
le code suivant est le code de la partie exécuter en évènement de bouton enregistrer:

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
try
		{
			processor = Manager.createRealizedProcessor(processorModel);
		}
		catch (IOException e) { System.out.println (e); }
		catch (NoProcessorException e) { System.out.println (e); }
		catch (CannotRealizeException e) { System.out.println (e); }
 
            DataSource source = processor.getDataOutput();
 
	       MediaLocator dest = new MediaLocator("file:///C://testcam.avi");
 
		// create a datasink to do the file
		DataSink dataSink = null;
		MyDataSinkListener dataSinkListener = null;
		try
		{
			dataSink = Manager.createDataSink(source, dest);
			dataSinkListener = new MyDataSinkListener();
			dataSink.addDataSinkListener(dataSinkListener);
			dataSink.open();
		}
		catch (IOException e) { System.out.println (e); }
		catch (NoDataSinkException e) { System.out.println (e); }
		catch (SecurityException e) { System.out.println (e); }
 
		// now start the datasink and processor
		try
		{
			dataSink.start();
		}
		catch (IOException e) { System.out.println (e); }
		 processor.start();
 
		System.out.println ("debut de la capture ...");
		try { Thread.currentThread().sleep(lapsTime); } catch (InterruptedException ie) {}	// capture for lapsTime seconds
		System.out.println ("... capture terminee");
 
	 	processor.stop();
	 	processor.close();
 
	 	dataSinkListener.waitEndOfStream(10);
		dataSink.close();
 
		System.out.println ("[fin du test]");

y a t il une solution merci

**Fichman** · 03/05/2011, 22h22

La solution pour pouvoir visionner et écrire le flux en même temps est de cloner la datasource.
J'avais fais un truc du genre :

Code :

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

1
2
3
4
5
 
//On rend la DataSource clonable pour permettre une capture et un enregistrement simultanés à partir des mêmes flux
dsAffiche=Manager.createCloneableDataSource(dsAffiche);
//On clone une des DataSources
dsRecord= ((SourceCloneable)dsAffiche).createClone();

Le player se branche sur l'une des source et le processor sur la source clonée.

**byn1984** · 05/05/2011, 16h20

Envoyé par Fichman

La solution pour pouvoir visionner et écrire le flux en même temps est de cloner la datasource.
J'avais fais un truc du genre :

Code :

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

1
2
3
4
5
 
//On rend la DataSource clonable pour permettre une capture et un enregistrement simultanés à partir des mêmes flux
dsAffiche=Manager.createCloneableDataSource(dsAffiche);
//On clone une des DataSources
dsRecord= ((SourceCloneable)dsAffiche).createClone();

Le player se branche sur l'une des source et le processor sur la source clonée.

MErci ça fonctionne très très bien

j"ai un autre problème si la phase d"enregistrement commence alors je peux pas arrêter l"enregistrement tant que le délai fixé n"est pas atteint

**Fichman** · 05/05/2011, 21h02

Ben il faut faire une méthode à part pour arrêter l'enregistrement.
Du coup tu enlèves le Thread.sleep(x).

Je crois que c'est mieux que je mette ici un fichier "utilitaire" que j'avais fait à l'époque, ça t'aideras certainement (je t'épargne les getters et setters) :

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
 
public class ReadandSave implements ControllerListener{
    /**
     * Représente le flux vidéo de la WebCam
     */
    private CaptureDeviceInfo captureDevice ;
    /**
     * Représente le flux audio de la WebCam
     */
    private CaptureDeviceInfo captureSoundDevice;
    /**
     * Encapsulation des flux
     */
    private DataSource dsAffiche;
    /**
     * Encapsulation des flux
     */
    private DataSource dsRecord;
    /**
     * Encapsulation des flux
     */
    private DataSource dsDestination;
    /**
     * Le lecteur qui permettra d'afficher la vidéo
     */
    private Player player;
    /**
     * Permet d'effectuer des traitements sur les médias, ici l'enregistrement
     */
    private Processor processor;
    private JFrame frame;
    private Format format;
    private String nomUtilisateur;
    /**
     * L'adresse du dernier fichier enregistré
     */
    private String LastCapture;
    /**
     * Permet de faciliter l'enregistrement
     */
    private StateHelper stateHelper;
    /**
     * Flux de sortie du processor qui permettra de créer le fichier vidéo sur le disque
     */
    private DataSink fileWriter;
    /**
     * Le composant dans lequel sera afficher la vidéo
     */
    private Component video;
    /**
     * le composant de contrôle : barre de lecture
     */
    private Component controleVideo;
    private boolean isPLayerRealized;
    private boolean isProcessorRealized;
    private boolean isStarted;
    private boolean isRun;
    /**
     * Le fichier que l'on veut lire
     */
    private File mFile;
    private boolean isFile;
    /**
     * Le nombre de DataSource connectées
     */
    private int nbDsConnected;
 
    /**
     * 
     * @param f le fichier que l'on souhaite lire. Si f est null alors c'est une capture depuis la WebCam
     */
    public ReadandSave (File f){
        mFile=f;
        isFile=false;
    }
 
    /**
     * Initialisations
     *
     */
    public void traitement(){
        dsAffiche=dsRecord=dsDestination=null;
        player=null;
        processor=null;
        format=null;
        stateHelper=null;
        fileWriter=null;
        video=null;
        isPLayerRealized = isProcessorRealized=isRun=false;
        this.init();
        this.createPlayer();
    }
 
    /**
     * Méthode qui permet de lire un fichier.
     * Dans le cas de Windows, il est nécessaire de remettre l'adresse du fichier en format "Unix" avant de pouvoir le lire
     *
     */
    public void Affiche(){
        try{
            //On vérifie qu'on a bien transmis un fichier au constructeur
            if (mFile!=null){
                //On récupère le chemin du fichier
                String path = mFile.getPath();
                //On remplace les "\" par des "/" dans le cas d'un OS Windows
                String path2 = "file://"+path.replace('\\', '/');
                //On crée une DataSource à partir du fichier passé en paramètre au constructeur
                MediaLocator ml = new MediaLocator(path2);
                dsAffiche = Manager.createDataSource(ml);
                //On "branche" la source
                dsAffiche.connect();
                //On crée le player à partir de la DataSource
                player = Manager.createPlayer(dsAffiche);                
                //Notre classe permettra de gérer les différents états du player
                player.addControllerListener(this);
                System.out.println ("Player créé");
                isFile=true;
                //Le player réserve les ressources qui lui seront nécessaire
                player.realize();
                //On paramètre la sortie
                this.Lecture();
            }
        }
        catch (Exception e){
            System.err.println("Erreur dans la création du player de lecture");
            e.printStackTrace();
        }
    }
 
    /**
     * Méthode qui défini et configure les flux de données (vidéo et audio) provenant de la WebCam
     *
     */
    public void init(){
        System.out.println("Init");
 
        //Récupération d'un périphérique vidéo à partir de son nom
        captureDevice = CaptureDeviceManager
        .getDevice("vfw:Microsoft WDM Image Capture (Win32):0");
 
        //Récupération d'un périphérique audio à partir de son nom
        captureSoundDevice = CaptureDeviceManager
        .getDevice("DirectSoundCapture");
 
        //On récupère la liste des formats vidéo disponibles pour cette source
        Format [] formats = captureDevice.getFormats();
        //On choisi un des formats disponibles
        format = formats[4]; //VGA 640x480
 
        //Récupération du MediaLocator lié au périphérique de capture
        MediaLocator mediaVideoLocator = captureDevice.getLocator();
        MediaLocator mediaSoundLocator = captureSoundDevice.getLocator();
 
        try {
            DataSource [] datasourcetab = new DataSource [2];
            // récupération d'une datasource à partir d'un MediaLocator
            datasourcetab[0] = Manager.createDataSource(mediaVideoLocator);
            datasourcetab[1] = Manager.createDataSource(mediaSoundLocator);
 
            //On mixe les deux sources.
            dsAffiche = Manager.createMergingDataSource(datasourcetab); 
 
            //On rend la DataSource clonable pour permettre une capture et un enregistrement simultanés à partir des mêmes flux
            dsAffiche=Manager.createCloneableDataSource(dsAffiche);
            //On clone une des DataSources
            dsRecord= ((SourceCloneable)dsAffiche).createClone();
        }
        catch(Exception e){
            System.err.println("Erreur dans la datasource");
            e.printStackTrace();
        }
    }
 
    /**
     * Méthode qui crée le player en fonction d'une DataSource définie précédement
     *
     */
    public void createPlayer(){
        System.out.println("Create player");
        try{
            // connexion sur la DataSource
            dsAffiche.connect();
            //On incrémente le nombre de DataSource utilisée
            nbDsConnected++;
            // connexion d'un player sur la datasource
            player = Manager.createPlayer(dsAffiche);
            player.addControllerListener(this);
            //préparation du player et du périphérique
            player.realize();
        }
        catch (Exception e){
            System.err.println ("Erreur dans la création du player");
            e.printStackTrace();
        }
    }
 
    /**
     * Méthode qui crée un processor pour l'enregistrement des flux de la WebCam sur disque.
     * On peut choisir ici, le format du fichier d'arrivée ainsi que la qualité de celui-ci
     *
     */
    public void createProcessor(){
        System.out.println("Create processor");
        try{
            //création d'un processeur
            processor = Manager.createProcessor(dsRecord);
            processor.addControllerListener(this);
            //création d'un objet helper permettant de simplifier la configuration
            stateHelper = new StateHelper(processor);
            //configuration du processeur
            stateHelper.configure();
            //On incrémente le nombre de DataSource utilisée
            nbDsConnected++;
 
 
 
            //configuration de la destination : ici onveut un fichier de type vidéo
            processor.setContentDescriptor(new FileTypeDescriptor(FileTypeDescriptor.MSVIDEO));
            //On récupère un contrôle sur le flux traité par le processor
            TrackControl []tracks = processor.getTrackControls();
            tracks[0].setEnabled(true);
            Format s;
            //On défini le format de sortie, ici la vidéo sera en format MJPEG
            VideoFormat vdf = new VideoFormat(VideoFormat.MJPG);
            tracks[0].setFormat(vdf);
 
            //initialisations
            stateHelper.realize();
            isProcessorRealized=true;
            //On règle la qualité de la vidéo (taux de compression)
            float coef=0.90f;
            Object[] ctrl= tracks[0].getControls();
            QualityControl qualit = (QualityControl)ctrl[0];
            qualit.setQuality(coef); 
 
             //récupération de la source de sortie
            dsDestination = processor.getDataOutput();
 
            Locale locale = Locale.getDefault();
            /** 2. Construction du DateFormat en choisiant un format :
             * SHORT = 01/01/2002
             * FULL = lundi 1 janvier 2002
             */
            DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.FULL, locale);
            String date=dateFormat.format(new Date());
 
            MediaLocator destination;
            //Permet éventuellement d'attribuer une adresse dynamique au fichier de sortie
            String adresse = Adresse.PrefixAdresseVideo+"/"+date+"/"+nomUtilisateur+".avi";
            //création d'un MediaLocator lié à un fichier (destination)
            destination = new MediaLocator(adresse);
            LastCapture = destination.getURL().toString();//Permet d'éviter les problèmes d'emplacement à cause des lettres attibuées aux partitions du disque
 
            //création d'un DataSink pour écrire dans le fichier le flux entrant 
            //(synchronisation entre la source et la destination) 
            fileWriter = Manager.createDataSink(dsDestination, destination);
        }
        catch (Exception e){
            System.err.println ("Erreur dans la création du processor");
            e.printStackTrace();
        }
    }
 
 
 
    /**
     * Paramètre le rendu visuel du fichier que l'on veut lire
     *
     */
    public void Lecture(){
        System.out.println("Start lecture");
        //Les méthodes qui suivent ne peuvent être appelées que si le player se trouve dans un état "realized"
        while(player.getState()!=Player.Realized){
            //On attend ...
        }
        isPLayerRealized=true;
        //Si on est dans le cas d'une capture depuis la WebCam, on force l'affichage au format VGA : 640x480
        if (!isFile){
            FormatControl[] fmtControl =  ((CaptureDevice)dsAffiche).getFormatControls();
            fmtControl[0].setFormat(format); 
        }
        //On récupère le composant visuel lié au player
        video = player.getVisualComponent();
        //On récupère le composant de contrôle
        controleVideo = player.getControlPanelComponent();
        //On peut régler ici le taux de rafraichissement (dépend des WebCams)
        FrameRateControl rate = (FrameRateControl)player.getControl("javax.media.control.FrameRateControl");
        rate.setFrameRate(15);
 
    }
 
    /**
     * On lit la vidéo qu'elle vienne d'un fichier ou de la WebCam
     *
     */
    public void startLecture(){
        if(nbDsConnected<1){
            try{
                //La DataSource doit être connectée pour pouvoir entamer une lecture
                dsAffiche.connect();
            }
            catch(Exception e){
                System.err.println("Erreur dans la reconnection de la DataSource dsAffiche");
            }
 
        }
        //Démarrage de la lecture
        player.start();
    }
 
    /**
     * On pause la lecture
     *
     */
    public void pauseLecture(){
        player.stop();
        System.out.println("Lecture en pause");
    }
 
    /**
     * On stoppe la lecture
     *
     */
    public void stopLecture(){
        player.stop();
        nbDsConnected--;
        System.out.println("Lecture stoppée");
    }
 
    /**
     * On démarre l'enregistrement
     *
     */
    public void startRecord(){
        System.out.println ("Début de l'enregistrement");
        try{
 
            //ouveture de la lecture / enregistrement (préparation)
            fileWriter.open();
            //démarrage du processor et du filewriter
            fileWriter.start();
            //Au maximum l'enregistrement durera 2 mins (durée en ms)
            stateHelper.playToEndOfMedia(90000);
        }
        catch(Exception e){
            System.err.println("Erreur dans startRecord");
            e.printStackTrace();
        }
 
 
    }
 
    /**
     * On stoppe l'enregistrement
     *
     */
    public void stopRecord(){
        System.out.println ("Fin de l'enregistrement");
 
        try{
            //fermeture de la capture
            stateHelper.close();
            //fermeture du fichier
            fileWriter.close();
            nbDsConnected--;
            System.out.println("Enregistrement stoppé");
 
        }
        catch(Exception e){
            System.err.println("Erreur dans stopRecord");
            e.printStackTrace();
        }
    }
 
    /**
     * Méthode qui permet de réaliser un screenshot 
     * @return une image du "screenshot" de la vidéo
     */
    public Image photo(){
        //On récupère un contrôle pour l'extraction de l'image
        FrameGrabbingControl fgc = (FrameGrabbingControl) player
        .getControl("javax.media.control.FrameGrabbingControl");
        Buffer buf;
        //On récupère un Buffer contenant l'image demandée
        buf = fgc.grabFrame();
 
        //Convertion du buffer en image (via BufferToImage)
        BufferToImage btoi;
        btoi = new BufferToImage((VideoFormat) buf.getFormat());
        Image img;
        //Création de l'image
        img = btoi.createImage(buf);
        //On enregistre l'image sur le disque via la méthode statique save() de la classe Frames
        Frames.save(img, Adresse.adresseMannequin);
        return img;
    }
 
    /**
     * Permet de contrôler les états successifs du player et du processor
     */
    public void controllerUpdate(ControllerEvent arg0) {
        if ((arg0.getClass()).equals(RealizeCompleteEvent.class)){
            if (arg0.getSource()==player){
                System.out.println ("Player realized");
                isPLayerRealized=true;
            }
            if (arg0.getSource()==processor){
                System.out.println ("Processor realized");
                isProcessorRealized=true;
            }
 
        }
 
        //Si l'utilisateur stoppe manuellement le player ou le processor
        if ((arg0.getClass()).equals(StopByRequestEvent.class)){
            //On déconnecte les DataSource
            if (arg0.getSource()==player){
                dsAffiche.disconnect();
            }
            if (arg0.getSource()==processor){
                dsRecord.disconnect();
            }
 
        }
 
    }
 
}

**byn1984** · 09/05/2011, 13h49

merci pour votre aide
j"ai ajouté un thread dont le script ci-dessous qui lance l'enregistrement sans arrêter les autres fonctionnalité et les autres boutons.
Le code thread:

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
/**
 *
 * @author Naoufel
 */import javax.media.*;
import javax.media.protocol.*;
    import java.awt.Color;
    import java.awt.Dimension;
    import java.awt.FlowLayout;
    import java.awt.Graphics2D;
    import java.awt.Image;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    import java.awt.image.BufferedImage;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
 
    import java.util.Vector;
 
    import java.util.logging.Level;
    import java.util.logging.Logger;
    import javax.imageio.ImageIO;
    import javax.media.Buffer;
    import javax.media.CaptureDeviceInfo;
    import javax.media.CaptureDeviceManager;
    import javax.media.ControllerAdapter;
    import javax.media.ControllerEvent;
    import javax.media.Format;
    import javax.media.Manager;
    import javax.media.NoDataSourceException;
    import javax.media.Player;
    import javax.media.RealizeCompleteEvent;
    import javax.media.control.FrameGrabbingControl;
    import javax.media.format.VideoFormat;
    import javax.media.protocol.DataSource;
    import javax.media.util.BufferToImage;
 
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import java.io.*;
 
import javax.media.*;
import javax.media.control.*;
import javax.media.datasink.*;
import javax.media.format.*;
import javax.media.protocol.*;
import java.awt.Dimension;
import javax.media.format.VideoFormat;
import javax.media.protocol.DataSource;
import java.awt.FileDialog;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.Manager;
import javax.media.NoPlayerException;
import javax.media.Player;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
import javax.media.Format;
import java.util.Vector;
import javax.imageio.ImageIO;
import javax.media.CaptureDeviceInfo;
import javax.media.CaptureDeviceManager;
import javax.media.ControllerAdapter;
import javax.media.ControllerEvent;
import javax.media.NoDataSourceException;
import javax.media.RealizeCompleteEvent;
import jmapps.util.StateHelper;
public class MonThread extends Thread {
    private static Processor processor ;
    DataSink dataSink = null; 
    MyDataSinkListener dataSinkListener = null;
    private static int					lapsTime = 10000;
 public void run(DataSource dsRecord) {
 // faire quelque chose
                               ///////////////////////////////if (debugDeviceList)		System.exit(0);
processor = null;
		MediaLocator audioMediaLocator = null;//captureAudioDevice.getLocator();
		DataSource audioDataSource = null;
 
		DataSource mixedDataSource = null;
		try
		{
			DataSource dArray[] = new DataSource[1];
			dArray[0] = dsRecord;
			mixedDataSource = javax.media.Manager.createMergingDataSource(dArray);
		}
		catch (IncompatibleSourceException ise) { System.out.println (ise); }
 
		// setup output file format  ->> msvideo
		FileTypeDescriptor outputType = new FileTypeDescriptor(FileTypeDescriptor.MSVIDEO);
 
		// setup output video and audio data format
		Format outputFormat[] = new Format[1];
		outputFormat[0] = new VideoFormat(VideoFormat.MJPG);
               // outputFormat[1] = new VideoFormat(VideoFormat.MJPG);
		// constructeur du processor
		final ProcessorModel processorModel = new ProcessorModel(mixedDataSource, outputFormat, outputType);
 
		try
		{
 
                processor = Manager.createRealizedProcessor(processorModel);
                // processor = Manager.createProcessor(dsRecord);
                //création d'un objet helper permettant de simplifier la configuration
                //création d'un objet helper permettant de simplifier la configuration
            } catch (CannotRealizeException ex) {
                Logger.getLogger(MonThread.class.getName()).log(Level.SEVERE, null, ex);
            }
 
 
 
		catch (IOException e) { System.out.println (e); }
		catch (NoProcessorException e) { System.out.println (e); }
 
 
                 DataSource source = processor.getDataOutput();
            /////////////////
 
 
	       MediaLocator dest = new MediaLocator("file:///C://testcam.avi");
 
		// create a datasink to do the file
 
		try
		{
			dataSink = Manager.createDataSink(source, dest);
			dataSinkListener = new MyDataSinkListener();
			dataSink.addDataSinkListener(dataSinkListener);
			dataSink.open();
		}
		catch (IOException e) { System.out.println (e); }
		catch (NoDataSinkException e) { System.out.println (e); }
		catch (SecurityException e) { System.out.println (e); }
 
		// now start the datasink and processor
		try
		{
			dataSink.start();
		}
		catch (IOException e) { System.out.println (e); }
		 processor.start();
 
		System.out.println ("debut de la capture ...");
		//try { Thread.currentThread().sleep(lapsTime); } catch (InterruptedException ie) {}	// capture for lapsTime seconds
 }
 void stop1()    {
                System.out.println ("... capture terminee");
	 	processor.stop();
	 	processor.close();
	 	dataSinkListener.waitEndOfStream(0);
		dataSink.close();
 
		System.out.println ("[fin du test]");
 }
}