Probleme de Threads

**Tarteens** · 28/08/2006, 10h25

Bonjour à tous, je suis confronté a un probleme assez complexe qui requiere votre aide.
Voilà je suis en train de developper un petit enregistreur vocal en java.
La Lecture et L'enregistrement marche parfaitement.La ou je bloque c'est que je n'arrive a faire une pause durant l'enregistrement,et apres avoir epluché plusieurs docs, aucune solution proposé n'est satisfaisante.

Je vous ci dessous le code source de la classe recorder :

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
import java.io.IOException;
import java.io.File;
 
import javax.sound.sampled.DataLine;
import javax.sound.sampled.TargetDataLine;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.AudioFileFormat;
 
class Recorder implements Runnable {
    private AudioFileFormat.Type fileType = AudioFileFormat.Type.WAVE;
    private final int MONO = 1;
    // private AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, 22050, 16, MONO, 2, 22050, true);
    private AudioFormat format;
    private TargetDataLine mic;
    private Thread thread;
    private File soundFile;
    boolean pleaseWait = false;
 
 
    public Recorder(File name,int qualite_) {
        this.soundFile=name;
        format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, qualite_, 16, MONO, 2, qualite_, false);
    }
    public void startRecording() {
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
 
        if (!AudioSystem.isLineSupported(info)) {
            System.err.println("Line not supported" + info);
            System.exit(1);
        }
 
        try {
            mic=(TargetDataLine)AudioSystem.getLine(info);
            mic.open(format, mic.getBufferSize());
        } catch (LineUnavailableException e) {
            System.err.println("Line not available" + e);
            System.exit(1);
        }
        thread = new Thread(this);
        thread.start();
    }
 
    public void stopRecording() {
        mic.stop();
        mic.close();
    }
 
    public void run() {
 
        mic.start();
        AudioInputStream sound = new AudioInputStream(mic);
        try {
 
            AudioSystem.write(sound, fileType, soundFile);
            System.out.println(thread.getState().toString());
 
        } catch(IOException e) { System.out.println(e); }
    }
}

Merci beaucoup d'avance pour votre aide.

**Tarteens** · 28/08/2006, 10h55

Pour donner plus de précision a mon probleme, je veux pouvoir mettre en pause l'enregistrement sur un bouton, et reprendre l'enregistrement qd on rappuie sur le bouton.

**mavina** · 28/08/2006, 11h54

je propose au hasard :

lors du clic sur le bouton, tu passes un booleen a true.
et lors de ton traitement, tu testes ce booleen.
Ca donnerai a peu pres ca : (à réadapter, changements mis en gras)

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
import java.io.IOException;
import java.io.File;

import javax.sound.sampled.DataLine;
import javax.sound.sampled.TargetDataLine;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.AudioFileFormat;

class Recorder implements Runnable {
    private AudioFileFormat.Type fileType = AudioFileFormat.Type.WAVE;
    private final int MONO = 1;
    // private AudioFormat format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, 22050, 16, MONO, 2, 22050, true);
    private AudioFormat format;
    private TargetDataLine mic;
    private Thread thread;
    private File soundFile;
    boolean pleaseWait = false;
    boolean pause = false;
    
    
    public Recorder(File name,int qualite_) {
        this.soundFile=name;
        format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, qualite_, 16, MONO, 2, qualite_, false);
    }
    public void startRecording() {
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
        
        if (!AudioSystem.isLineSupported(info)) {
            System.err.println("Line not supported" + info);
            System.exit(1);
        }
        
        try {
            mic=(TargetDataLine)AudioSystem.getLine(info);
            mic.open(format, mic.getBufferSize());
        } catch (LineUnavailableException e) {
            System.err.println("Line not available" + e);
            System.exit(1);
        }
        thread = new Thread(this);
        thread.start();
    }
    
    public void stopRecording() {
        mic.stop();
        mic.close();
    }
    
    public void run() {
        
        mic.start();
        AudioInputStream sound = new AudioInputStream(mic);
        try {
            if(!pause)
            {
                AudioSystem.write(sound, fileType, soundFile);
                System.out.println(thread.getState().toString());
            }
            
        } catch(IOException e) { System.out.println(e); }
    }
   public void pause() // change l'etat de la pause
   {
       pause=!pause;
   }
   public void actionPerformed(ActionEvent e) // fonction a declancher lors du clic sur le bouton, tu peux le gerer dans une classe privée à part pour plus de lisibilite
   {
      pause();
   }
}

En esperant t'avoir aidé, ou du moins mis sur la piste

Fred

**Tarteens** · 29/08/2006, 12h04

J'ai essaier avec le boolean, mais ce n'est pas concluant, ca continu d'enregistrer.

Quelq'un aurait d'autre idée pour mettre en pause un thread et le reprendre sur simple appuie sur un bouton ?

**divxdede** · 29/08/2006, 12h41

A mon avis tu dois interrompre ton TargetDataLine (mic) d'une facon ou d'une autre... Mais je ne connais absolument pas cette api

**Tarteens** · 29/08/2006, 13h57

Je pensais plutot que c'était le code dans le run qu'il fallait interrompre, et donc la methode write de la classe AudioSystem.

Parceque qd j'exécute le methode thread.start(), je demarre le run() ? c'est bien ca?donc j'execute le write()? c'est bien lui qu'il faut que je mette en pause.

Merci d'éclairer ma lanterne sur le sujet.

**divxdede** · 29/08/2006, 14h16

Je ne suis pas sur, car d'apres ce que j'ai cru comprendre de l'api.
Meme si tu met en pause le write. le TargetDataLine representant ta source va continuer d'alimenter un buffer.

quand tu réactiveras l'écriture, elle reprendra en piochant dans le buffer (et donc il n'y aura pas de pause dans les données).

Tu n'auras fait que mettre en pause l'écriture.

**Tarteens** · 29/08/2006, 15h19

est-ce que l'utilisation de interrupt ou wait ou notify pourrai parer a mon probleme?

parceque je ne vois pas du tout comment utiliser ces différentes méthodes sans bloquer mon programme.

**had35** · 29/08/2006, 16h14

Apparemment, les flux audio sont du même type que tout autre type de flux, ils héritent de InputStream et OutputStream. Si tu veux pouvoir interrompre l'enregistrement audio, tu dois écrire toi-même la boucle de transfert entre l'entrée et la sortie.

Ca donne quelque chose comme ça :

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
 
public void run() {
     InputStream in = AudioSystem.getAudioStream(mic);
     OutputStream out = new FileOutputStream(soundFile);
 
     synchronized(out) {
          int i = in.read();
          while(i != -1) {
               if(pause) //définir une méthode qui modifie ce drapeau
                    wait();
               else
                    notifyAll();
               out.write(i);
               i = in.read();
          }
     }
}

Et personnellement, je trouve qu'il serait plus propre d'écrire ton thread dans une classe interne.

**Tarteens** · 29/08/2006, 16h36

J'ai essaier ta soluce mais ca na pas marcher

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
 
public void run() {
        try {
            InputStream in = new AudioInputStream(mic);
            OutputStream out = new FileOutputStream(soundFile);
 
            synchronized(out) {
                mic.start();
                int i = in.read();
                while(i != -1) {
                    if(pause)//définir une méthode qui modifie ce drapeau
                    {
                        try{wait();}catch(Exception ex){ex.printStackTrace();}
                    }
                    else
                        notifyAll();
                    out.write(i);
                    i = in.read();
                }
            }
        } catch(IOException e) {System.out.println(e);}
    }

J'obtient une erreur de type

java.io.IOException: cannot read a single byte if frame size > 1

lorsque le programme arrive a la ligne

int i = in.read();

**had35** · 29/08/2006, 17h05

Je ne sais pas trop ce que c'est que ce frame size car je ne manipule jamais les flux audio.

Mais de toute façon, la synchronisation de mon thread est mauvaise. Du coup, plus moyen de redémarrer

On devrait plutôt avoir quelque chose comme ça, en tous les cas pour la synchronisation :

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
 
private static Object OutputStream out = new FileOutputStream(soundFile);
private static boolean pause;
 
public void run() {
     synchronized(out) {
          if(pause) {
               out.notifyAll();
               return;
          }
          InputStream in = AudioSystem.getAudioStream(mic);
          int i = in.read();
          while(i != -1) {
               if(pause) //définir une méthode qui modifie ce drapeau
                    out.wait();
               out.write(i);
               i = in.read();
          }
     }
}
 
public void restart() {
     pause = b;
     this.start();
}

[EDIT] Je viens de jeter un coup d'oeil rapide, il faut que tu modifie AudioFormat pour avoir un frame size de 1.

**divxdede** · 29/08/2006, 17h36

Je ne suis pas du tout convaincus que suspendre le thread effectuant les "write" va rééllement arretter l'enregistrement.

Quand tu effectues un transfert d'un InputStream vers un OutputStream. Meme si tu fais une pose de 20s en arrettant le transfert, quand tu reprendras, tu reprendras exactement là ou tu en etais.

Surtout qu'il semblerait qu'il y ai un buffer coté DataLigneTransfert donc a moins que tu ais fais une pause suffisament longue pour saturer le buffer, tu ne perdra aucune données et donc fait aucune pause.

En réalité ce qu'il faut mettre en pause c'est le mécanisme qui alimente le InputStream et non le mécanisme de transfert du InputStream vers le OutputStream. Enfin c'est mon avis.

**divxdede** · 29/08/2006, 18h15

Je ne peu absolument pas tester ce code (pas de carte son à mon taff)

Mais je partirais sur ce genre d'idée (a voir si j'ai bien compris l'api)

Usage:

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
// Initialisation du recorder
Recorder rec = new Recorder( file , quality );
Thread    recThread = new Thread(rec);
recThread.start();
 
// Démarage de l'enregistrement initial
rec.start();
 
// On veut faire une pause
rec.pause();
 
// on veut reprendre
rec.resume();
 
// on veut finir l'enregistrement (et le Thread)
rec.close();
 
// A ce stade si on veut faire un autre enregistrement, il faut faire un nouveau Recorder (ou modifier le code)

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
package test.audio;
 
import java.io.IOException;
import java.io.File;
 
import javax.sound.sampled.DataLine;
import javax.sound.sampled.TargetDataLine;
import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.AudioFileFormat;
 
class Recorder implements Runnable 
{
    private AudioFileFormat.Type fileType = AudioFileFormat.Type.WAVE;
    private final int MONO = 1;
 
    /** for sync purpose */
    private Object sync = new Object(){};
 
    private AudioFormat    format     = null;
    private TargetDataLine mic        = null;
    private File           soundFile  = null;
 
    /** Etats des demandes liées au thread 
     */
    private boolean        run        = false;
    private boolean        exit       = false;
 
    /** Create a recorder
     */
    public Recorder(File name,int qualite) 
    {
        this.soundFile = name;
        this.format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, qualite, 16, MONO, 2, qualite, false);
 
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
 
        if (! AudioSystem.isLineSupported(info) ) 
            System.err.println("Line not supported" + info);
 
        try {
 
            mic = (TargetDataLine)AudioSystem.getLine(info);
        } 
        catch (LineUnavailableException e) {
            System.err.println("Line not available" + e);
        }
    }
 
    /** Start the recording
     *  We can call only a unique time on a particular recorder
     */
    public void start()
    {  
       synchronized(sync)
       {
           /** Si la fin programée à déja eu lieu, on ne fait rien
            */
           if( this.exit ) return;
 
           /** Inscrit le demarrage programé */
           this.run = true;
 
           try
           {
               if( mic != null && !mic.isOpen() )
               {
                   mic.open( format, mic.getBufferSize() );
                   this.resume();
               }
           }
           catch(LineUnavailableException lue){ lue.printStackTrace(); }
 
           sync.notifyAll();
       }
    }
 
    /** Stop the recording
     *  The Recorder-Thread should finish the write process and terminating normally
     *  We can't call anymore a start() , if you want such functionalities, see pause() && resume()
     */
    public void close() {
        synchronized(sync)
        {
            if( mic != null && mic.isOpen() ) 
            {
                this.pause();
                mic.close();
            }
 
            this.exit = true; // Inscrit la fin programée
            sync.notifyAll();
        }
    }
 
    /** Pause the recording
     *  @see #resume
     */
    public void pause()
    {   if( mic == null ) return;
        if( mic.isActive() )
        {
            mic.stop();
            mic.flush();
        }
    }
 
    /** Resume the recording
     *  @see #pause
     */
    public void resume()
    {   if( mic == null ) return;
        if( mic.isOpen() && ! mic.isActive() )
            mic.start();
    }
 
    /** Main recording-process
     */
    public void run() {
 
        synchronized( sync )
        {
            // Attente soit d'un demarrage de l'enregistrement soit d'une fin
            while( !this.exit && !this.run )
            {
                try
                {
                    sync.wait();
                }
                catch(InterruptedException ie) { /* do nothing */ }
            }
            if( this.exit ) return;
        }
 
        /** On peut effectuer le transfert
         *  le close() sur l'objet mic() provoquera la fin de lecteur du AudioInputStream et provoquera la fin normale du thread
         */
        AudioInputStream sound = new AudioInputStream(mic);
        try {
 
            AudioSystem.write(sound, fileType, soundFile);
        }
        catch(IOException e)
        { System.out.println(e); }
    }
}

**Betatesteur** · 29/08/2006, 18h23

si ça peut t'aider.

http://etudiant.univ-mlv.fr/~arinie/.../recorder.html

**had35** · 30/08/2006, 09h44

Envoyé par divxdede

Quand tu effectues un transfert d'un InputStream vers un OutputStream. Meme si tu fais une pose de 20s en arrettant le transfert, quand tu reprendras, tu reprendras exactement là ou tu en etais.

Ben, c'est ce qu'il voulait faire Tarteen, une pause dans l'enregistrement

Mais la synchronisation de mes threads n'est toujours pas satisfaisante. Cette fois je publie la 1.0

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
 
private class TransfertAudio extends Thread {
 
     private Object OutputStream out = new FileOutputStream(soundFile);
     private boolean pause = true;
 
     public void run() {
          synchronized(out) {
               if(!pause) {
                    out.notifyAll();
                    return;
               }
               pause = false; //c'est pas terrible mais c'est ce que j'ai trouvé de plus simple
               InputStream in = AudioSystem.getAudioStream(mic);
               int i = in.read();
               while(i != -1) {
                    if(pause) //définir une méthode qui modifie ce drapeau
                         out.wait();
                    out.write(i);
                    i = in.read();
               }
          }
     }
 
     public void restart() {
          pause = false;
          run();
     }
 
     public void pause() {
          pause = true;
     }
}

**divxdede** · 30/08/2006, 09h50

Oui mais d'aprés moi, faire une pause dans le transfert n'arrette pas l'enregistrement. l'API continuera d'alimenter l'inputStream en remplissant un buffer. Quand tu vas reprendre l'ecriture tu ne fera que rattrapper le retard que tu as pris en arrettant le transfert.

Avec ce principe, tu fera une pause qu'a partir du moment où le buffer est plein. Ou alors faut le flusher a la reprise pour etre sur de ne pas ecrire ce que l'api avait enregistrée pendant la pause.

**had35** · 30/08/2006, 10h00

Ah oui, je vois ce que tu veux dire. Mais alors, est-ce que ce n'est pas plutôt l'inverse. C'est-à-dire que les données sont actuellement perdues le temps que dure la pause car je ne pense pas que l'api prévois de tampon de taille variable.

**Tarteens** · 30/08/2006, 10h59

c'est bon merci pour votre aide mais j'ai trouver un code qui marche du tonnere

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
 
package MyPocket;
import java.io.*;
import java.security.SecurityPermission;
import javax.sound.sampled.*;   
import javax.sound.sampled.Control.Type;
import javax.sound.sampled.Line.Info;
 
class NewRecorder implements Runnable {
 
    AudioInputStream audioInputStream;
    File file;
    String fileName ="totot";
    TargetDataLine line;
    Thread thread;
    AudioFormat format;
    public NewRecorder(int qualite)
    {
        format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED, qualite, 16, 1, 2, qualite, false);
    }
 
    public void start()
    {
        thread= new Thread (this);
        thread.start();
    }
 
    public void stop()
    {
        thread = null;
    }
 
    public void saveToFile(String name) {
        AudioFileFormat.Type fileType = AudioFileFormat.Type.WAVE;
        if (audioInputStream == null) {
 
            return;
        } else if (file != null) {
            createAudioInputStream(file, false);
        }
        try {
            audioInputStream.reset();
        } catch (Exception e) { 
 
            return;
        }
        File file = new File(fileName = name);
        try {
            if (AudioSystem.write(audioInputStream, fileType, file) == -1) {
                throw new IOException("Problems writing to file");
            }
        } catch (Exception ex) { ex.toString(); }
    }
 
 
    public void createAudioInputStream(File file, boolean updateComponents) {
        if (file != null && file.isFile()) 
        {
            try {
                this.file = file;
                audioInputStream = AudioSystem.getAudioInputStream(file);       
                fileName = file.getName();       
            } catch (Exception ex) {ex.printStackTrace();}
        }
    }
 
 
    public void run() {
        audioInputStream = null;
 
        DataLine.Info info = new DataLine.Info(TargetDataLine.class,format);
        if(!AudioSystem.isLineSupported(info)) {
            System.out.println("Line Matching "+ info+" not supported");
            return;
        }
 
        try {
            line = (TargetDataLine)AudioSystem.getLine(info);
            line.open(format,line.getBufferSize());
        }catch(LineUnavailableException ex) { System.out.println(ex); return;} catch (Exception ex) { System.out.println(ex); return; }
 
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int frameSizeInBytes = format.getFrameSize();
        int bufferLengthInFrames = line.getBufferSize() / 8;
        int bufferLengthInBytes = bufferLengthInFrames * frameSizeInBytes;
        byte[] data = new byte[bufferLengthInBytes];
        int numBytesRead;
 
        line.start();
 
        while (thread != null) {
            if((numBytesRead = line.read(data, 0, bufferLengthInBytes)) == -1) {
                break;
            }
            out.write(data, 0, numBytesRead);
        }
        line.stop();
        line.close();
        line = null;
        try {
            out.flush();
            out.close();
        } catch (IOException ex) {
            ex.printStackTrace();
        }
 
        byte audioBytes[] = out.toByteArray();
        ByteArrayInputStream bais = new ByteArrayInputStream(audioBytes);
        audioInputStream = new AudioInputStream(bais, format, audioBytes.length / frameSizeInBytes);
        try {
            audioInputStream.reset();
        } catch (Exception ex) {
            ex.printStackTrace();
            return;
        }
    }
}

Et pour la pause j'ai coder ca pour mon bouton

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
if(btnpause.getText() == "Pause") {
               if (NRec.thread != null) {
                   NRec.line.stop();
                   btnpause.setText("Resume");
                   btnstop.setEnabled(false);
               }
           }else if(btnpause.getText() == "Resume") {
               if (NRec.thread != null) {
                   NRec.line.start();
                   btnpause.setText("Pause");
                   btnstop.setEnabled(true);
               }
           }