Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / JSAudioThread.java
1 package javajs.util;    
2
3 import javax.sound.sampled.AudioFormat;
4 import javax.sound.sampled.AudioSystem;
5 import javax.sound.sampled.DataLine;
6 import javax.sound.sampled.SourceDataLine;
7
8 import sun.audio.AudioData;
9 import sun.audio.AudioDataStream;
10 import sun.audio.AudioPlayer;
11
12
13 /**
14  * The JSAudioThread adds a layer to JSThread that is specific for audio.
15  * This class utilizes JSAudioLine, which is not fully fleshed out.
16  * 
17  * Two very simple interfaces,
18  * 
19  * (new JSAudioThread()).playULawData(byte[] b);
20  * 
21  * and
22  * 
23  * (new JSAudioThread(audioFormat)).playOnce(byte[] b, offset, length);
24  * 
25  * allow straightforward audio production without having to work with
26  * SourceDataLine directly.
27  * 
28  * As a JSThread, this class implements myInit(), isLooping(), myLoop(),
29  * whenDone(), onException(), and doFinally().
30  * 
31  * If the constructor JSAudioThread(JSAudioThreadUser, AudioFormat, byte[]) is
32  * used, then the JSAudioThreadUser must simply implement fillAudioBuffer(),
33  * checkSoundStatus(), and audioThreadExiting() for very simple streaming audio.
34  * JSAudioThread will then take care of all the timing issues.
35  * 
36  * But the implementer is welcome to override any of the JSThread overrides
37  * themselves in order to customize this further.
38  * 
39  * The standard streaming case, then is:
40  * 
41  * audioThread = new JSAudioThread(audioUser, audioFormat, audioByteBuffer);
42  * audioThread.start();
43  * 
44  * where audioUser provides 
45  * 
46  * checkSoundStatus() (called in isLooping()),
47  * 
48  * fillAudioBuffer() (called in myLoop()),
49  * 
50  * and
51  * 
52  * audioThreadExiting() (called in doFinally()).
53  * 
54  * @author Bob Hanson
55  * 
56  */
57 public class JSAudioThread extends JSThread {
58         
59         protected Owner owner;
60         protected boolean done;
61         protected int myBufferLength;
62         protected SourceDataLine line;
63         protected int rate, nChannels, bitsPerSample;
64         
65         protected byte[] audioByteBuffer;
66         protected int audioBufferByteLength;
67
68         private AudioFormat audioFormat;
69         private int myBufferOffset;
70         private int playCount;
71         
72         public JSAudioThread(Owner owner, AudioFormat audioFormat, byte[] audioByteBuffer) {
73                 this.owner = owner;
74                 setFormat(audioFormat);
75                 setBuffer(audioByteBuffer);
76         }
77
78         /**
79          * A convenience constructor requiring standard settings of 
80          * signed (for 8-bit) and littleEndian (for 16-bit)
81          *   
82          * @param owner
83          * @param rate
84          * @param bitsPerSample
85          * @param nChannels
86          * @param audioByteBuffer
87          */
88         public JSAudioThread(Owner owner, int rate, int bitsPerSample, int nChannels, byte[] audioByteBuffer) {
89                 this.owner = owner;
90                 setFormat(new AudioFormat(rate, bitsPerSample, nChannels, true, false));
91                 setBuffer(audioByteBuffer);
92         }
93         
94         /**
95          * primarily available for (new JSAudioThread()).playULawData
96          * 
97          */
98         public JSAudioThread() {
99         }
100
101         /**
102          * primarily available for (new JSAudioThread()).playOnce
103          * 
104          */
105         public JSAudioThread(AudioFormat audioFormat) {
106                 setFormat(audioFormat);
107         }
108
109         /**
110          * 
111          * A simple 8-bit uLaw data player
112          * 
113          * @param data
114          */
115         public void playULawData(byte[] data) {
116                 // this constructor uses default new AudioFormat(ULAW,8000,8,1,1,8000,true)
117                 // threading is taken care of by the browser in JavaScript
118                 AudioPlayer.player.start(new AudioDataStream(new AudioData(data)));
119         }
120
121
122         /**
123          * Just play once through; no additions
124          * 
125          * @param data
126          */
127         public void playOnce(byte[] data, int offset, int length) {
128                 setBuffer(data);
129                 myBufferOffset = offset;
130                 myBufferLength = length;
131                 playCount = 1;
132                 start();
133         }
134
135         public void setBuffer(byte[] audioByteBuffer) {
136                 this.audioByteBuffer = audioByteBuffer;
137                 audioBufferByteLength = audioByteBuffer.length;
138         }
139         
140         public SourceDataLine getLine() {
141                 return line;
142         }
143         
144         public AudioFormat getFormat() {
145                 return audioFormat;
146         }
147                         
148         public void setFormat(AudioFormat audioFormat) {
149                 this.audioFormat = audioFormat;
150                 rate = (int) audioFormat.getSampleRate();
151                 bitsPerSample = audioFormat.getSampleSizeInBits();
152                 nChannels = audioFormat.getChannels();                  
153         }
154
155         public void resetAudio() {
156                 if (line == null)
157                         return;
158                 line.flush();
159                 line.close();
160                 line = null;
161         }
162
163         /**
164          * Standard initialization of a SourceDataLine
165          * 
166          */
167         @Override
168         protected boolean myInit() {
169                 try {
170                         DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
171                         if (line != null)
172                                 line.close();
173                         line = (SourceDataLine) AudioSystem.getLine(info);
174                         line.open(audioFormat, audioBufferByteLength);
175                         line.start();
176                 } catch (Exception e) {
177                         e.printStackTrace();
178                         return false;
179                 }
180                 return true;
181         }
182         
183         @Override
184         protected boolean isLooping() {
185                 return !done && (--playCount >= 0 || owner != null && owner.checkSoundStatus());
186         }
187
188         @Override
189         protected boolean myLoop() {
190                 if (!done) {
191                         if ((myBufferLength = (owner == null ? myBufferLength : owner.fillAudioBuffer())) <= 0)
192                                 return !(done = true);
193                         try {
194                                 if (line == null)
195                                         myInit();                                       
196                                 line.write(audioByteBuffer, myBufferOffset, myBufferLength);
197                         } catch (Exception e) {
198                                 e.printStackTrace();
199                                 done = true;
200                         }
201                 }
202                 return !done;
203         }
204
205         @Override
206         protected void whenDone() {
207                 done = true;
208                 resetAudio();
209         }
210
211         @Override
212         protected int getDelayMillis() {
213                 // about 25% of the actual play time
214         return 1000                                        // ms/sec 
215                         * (myBufferLength  * 8 / bitsPerSample)        // * samples 
216                         / rate                                         // * seconds/sample) 
217                         / nChannels                                    // / number of channels
218                         / 4;                                           // * 25%
219         }
220
221         @Override
222         protected void onException(Exception e) {
223                 e.printStackTrace();
224         }
225
226         @Override
227         protected void doFinally() {
228                 if (owner != null)
229                         owner.audioThreadExiting();
230         }
231
232         public interface Owner {
233
234                 /**
235                  * 
236                  * @return true if thread should continue; false if not
237                  * 
238                  */
239                 boolean checkSoundStatus();
240
241                 /** fill audio buffer
242                  * 
243                  * @return number of bytes to write to audio line
244                  *
245                  */
246                 int fillAudioBuffer();
247
248                 /**
249                  *  called from the finally clause when complete 
250                  * 
251                  */
252                 void audioThreadExiting();
253                 
254
255         }
256
257 }
258