1 /*
2 * Copyright (c) 2006, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import javax.sound.sampled.AudioFormat;
25 import javax.sound.sampled.AudioSystem;
26 import javax.sound.sampled.DataLine;
27 import javax.sound.sampled.LineUnavailableException;
28 import javax.sound.sampled.SourceDataLine;
29 import javax.sound.sampled.TargetDataLine;
30
31 /*
32 * @test
33 * @bug 6372428
34 * @summary playback and capture doesn't interrupt after terminating thread that
35 * calls start()
36 * @run main bug6372428
37 * @key headful
38 */
39 public class bug6372428 {
40 public bug6372428() {
41 }
42
43 public static void main(final String[] args) {
44 bug6372428 pThis = new bug6372428();
45 boolean failed1 = false;
46 boolean failed2 = false;
47 log("");
48 log("****************************************************************");
49 log("*** Playback Test");
50 log("****************************************************************");
51 log("");
52 try {
53 pThis.testPlayback();
54 } catch (IllegalArgumentException | LineUnavailableException e) {
55 System.out.println("Playback test is not applicable. Skipped");
56 } catch (Exception ex) {
57 ex.printStackTrace();
58 failed1 = true;
59 }
60 log("");
61 log("");
62 log("****************************************************************");
63 log("*** Capture Test");
64 log("****************************************************************");
65 log("");
66 try {
67 pThis.testRecord();
68 } catch (IllegalArgumentException | LineUnavailableException e) {
69 System.out.println("Record test is not applicable. Skipped");
70 } catch (Exception ex) {
71 ex.printStackTrace();
72 failed2 = true;
73 }
74 log("");
75 log("");
76 log("****************************************************************");
77 if (failed1 || failed2) {
78 String s = "";
79 if (failed1 && failed2)
80 s = "playback and capture";
81 else if (failed1)
82 s = "playback only";
83 else
84 s = "capture only";
85 throw new RuntimeException("Test FAILED (" + s + ")");
86 }
87 log("*** All tests passed successfully.");
88 }
89
90 final static int DATA_LENGTH = 15; // in seconds
91 final static int PLAYTHREAD_DELAY = 5; // in seconds
92
93 // playback test classes/routines
94
95 class PlayThread extends Thread {
96 SourceDataLine line;
97 public PlayThread(SourceDataLine line) {
98 this.line = line;
99 this.setDaemon(true);
100 }
101
102 public void run() {
103 log("PlayThread: starting...");
104 line.start();
105 log("PlayThread: delaying " + (PLAYTHREAD_DELAY * 1000) + "ms...");
106 delay(PLAYTHREAD_DELAY * 1000);
107 log("PlayThread: exiting...");
108 }
109 }
110
111 class WriteThread extends Thread {
112 SourceDataLine line;
113 byte[] data;
114 volatile int remaining;
115 volatile boolean stopRequested = false;
116 public WriteThread(SourceDataLine line, byte[] data) {
117 this.line = line;
118 this.data = data;
119 remaining = data.length;
120 this.setDaemon(true);
121 }
122
123 public void run() {
124 while (remaining > 0 && !stopRequested) {
125 int avail = line.available();
126 if (avail > 0) {
127 if (avail > remaining)
128 avail = remaining;
129 int written = line.write(data, data.length - remaining, avail);
130 remaining -= written;
131 log("WriteThread: " + written + " bytes written");
132 } else {
133 delay(100);
134 }
135 }
136 if (remaining == 0) {
137 log("WriteThread: all data has been written, draining");
138 line.drain();
139 } else {
140 log("WriteThread: stop requested");
141 }
142 log("WriteThread: stopping");
143 line.stop();
144 log("WriteThread: exiting");
145 }
146
147 public boolean isCompleted() {
148 return (remaining <= 0);
149 }
150
151 public void requestStop() {
152 stopRequested = true;
153 }
154 }
155
156 void testPlayback() throws LineUnavailableException {
157 // prepare audio data
158 AudioFormat format = new AudioFormat(22050, 8, 1, false, false);
159 byte[] soundData = new byte[(int) (format.getFrameRate() * format.getFrameSize() * DATA_LENGTH)];
160
161 // create & open source data line
162 //SourceDataLine line = AudioSystem.getSourceDataLine(format);
163 DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
164 SourceDataLine line = (SourceDataLine)AudioSystem.getLine(info);
165
166 line.open(format);
167
168 // start write data thread
169 WriteThread p1 = new WriteThread(line, soundData);
170 p1.start();
171
172 // start line
173 PlayThread p2 = new PlayThread(line);
174 p2.start();
175
176 // monitor line
177 long lineTime1 = line.getMicrosecondPosition() / 1000;
178 long realTime1 = currentTimeMillis();
179 while (true) {
180 delay(500);
181 if (!line.isActive()) {
182 log("audio data played completely");
183 break;
184 }
185 long lineTime2 = line.getMicrosecondPosition() / 1000;
186 long realTime2 = currentTimeMillis();
187 long dLineTime = lineTime2 - lineTime1;
188 long dRealTime = realTime2 - realTime1;
189 log("line pos: " + lineTime2 + "ms" + ", thread is " + (p2.isAlive() ? "alive" : "DIED"));
190 if (dLineTime < 0) {
191 throw new RuntimeException("ERROR: line position have decreased from " + lineTime1 + " to " + lineTime2);
192 }
193 if (dRealTime < 450) {
194 // delay() has been interrupted?
195 continue;
196 }
197 lineTime1 = lineTime2;
198 realTime1 = realTime2;
199 }
200 }
201
202
203 // recording test classes/routines
204
205 class RecordThread extends Thread {
206 TargetDataLine line;
207 public RecordThread(TargetDataLine line) {
208 this.line = line;
209 this.setDaemon(true);
210 }
211
212 public void run() {
213 log("RecordThread: starting...");
214 line.start();
215 log("RecordThread: delaying " + (PLAYTHREAD_DELAY * 1000) + "ms...");
216 delay(PLAYTHREAD_DELAY * 1000);
217 log("RecordThread: exiting...");
218 }
219 }
220
221 class ReadThread extends Thread {
222 TargetDataLine line;
223 byte[] data;
224 volatile int remaining;
225 public ReadThread(TargetDataLine line, byte[] data) {
226 this.line = line;
227 this.data = data;
228 remaining = data.length;
229 this.setDaemon(true);
230 }
231
232 public void run() {
233 log("ReadThread: buffer size is " + data.length + " bytes");
234 delay(200);
235 while ((remaining > 0) && line.isOpen()) {
236 int avail = line.available();
237 if (avail > 0) {
238 if (avail > remaining)
239 avail = remaining;
240 int read = line.read(data, data.length - remaining, avail);
241 remaining -= read;
242 log("ReadThread: " + read + " bytes read");
243 } else {
244 delay(100);
245 }
246 if (remaining <= 0) {
247 log("ReadThread: record buffer is full, exiting");
248 break;
249 }
250 }
251 if (remaining > 0) {
252 log("ReadThread: line has been stopped, exiting");
253 }
254 }
255
256 public int getCount() {
257 return data.length - remaining;
258 }
259 public boolean isCompleted() {
260 return (remaining <= 0);
261 }
262 }
263
264 void testRecord() throws LineUnavailableException {
265 // prepare audio data
266 AudioFormat format = new AudioFormat(22050, 8, 1, false, false);
267
268 // create & open target data line
269 //TargetDataLine line = AudioSystem.getTargetDataLine(format);
270 DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);
271 TargetDataLine line = (TargetDataLine)AudioSystem.getLine(info);
272
273 line.open(format);
274
275 // start read data thread
276 byte[] data = new byte[(int) (format.getFrameRate() * format.getFrameSize() * DATA_LENGTH)];
277 ReadThread p1 = new ReadThread(line, data);
278 p1.start();
279
280 // start line
281 //new RecordThread(line).start();
282 RecordThread p2 = new RecordThread(line);
283 p2.start();
284
285 // monitor line
286 long endTime = currentTimeMillis() + DATA_LENGTH * 1000;
287
288 long realTime1 = currentTimeMillis();
289 long lineTime1 = line.getMicrosecondPosition() / 1000;
290
291 while (realTime1 < endTime && !p1.isCompleted()) {
292 delay(100);
293 long lineTime2 = line.getMicrosecondPosition() / 1000;
294 long realTime2 = currentTimeMillis();
295 long dLineTime = lineTime2 - lineTime1;
296 long dRealTime = realTime2 - realTime1;
297 log("line pos: " + lineTime2 + "ms" + ", thread is " + (p2.isAlive() ? "alive" : "DIED"));
298 if (dLineTime < 0) {
299 line.stop();
300 line.close();
301 throw new RuntimeException("ERROR: line position have decreased from " + lineTime1 + " to " + lineTime2);
302 }
303 if (dRealTime < 450) {
304 // delay() has been interrupted?
305 continue;
306 }
307 lineTime1 = lineTime2;
308 realTime1 = realTime2;
309 }
310 log("stopping line...");
311 line.stop();
312 line.close();
313
314 /*
315 log("");
316 log("");
317 log("");
318 log("recording completed, delaying 5 sec");
319 log("recorded " + p1.getCount() + " bytes, " + DATA_LENGTH + " seconds: " + (p1.getCount() * 8 / DATA_LENGTH) + " bit/sec");
320 log("");
321 log("");
322 log("");
323 delay(5000);
324 log("starting playing...");
325 playRecorded(format, data);
326 */
327 }
328
329 void playRecorded(AudioFormat format, byte[] data) throws Exception {
330 //SourceDataLine line = AudioSystem.getSourceDataLine(format);
331 DataLine.Info info = new DataLine.Info(SourceDataLine.class, format);
332 SourceDataLine line = (SourceDataLine)AudioSystem.getLine(info);
333
334 line.open();
335 line.start();
336
337 int remaining = data.length;
338 while (remaining > 0) {
339 int avail = line.available();
340 if (avail > 0) {
341 if (avail > remaining)
342 avail = remaining;
343 int written = line.write(data, data.length - remaining, avail);
344 remaining -= written;
345 log("Playing: " + written + " bytes written");
346 } else {
347 delay(100);
348 }
349 }
350
351 line.drain();
352 line.stop();
353 }
354
355 // helper routines
356 static long startTime = currentTimeMillis();
357 static long currentTimeMillis() {
358 //return System.nanoTime() / 1000000L;
359 return System.currentTimeMillis();
360 }
361 static void log(String s) {
362 long time = currentTimeMillis() - startTime;
363 long ms = time % 1000;
364 time /= 1000;
365 long sec = time % 60;
366 time /= 60;
367 long min = time % 60;
368 time /= 60;
369 System.out.println(""
370 + (time < 10 ? "0" : "") + time
371 + ":" + (min < 10 ? "0" : "") + min
372 + ":" + (sec < 10 ? "0" : "") + sec
373 + "." + (ms < 10 ? "00" : (ms < 100 ? "0" : "")) + ms
374 + " (" + Thread.currentThread().getName() + ") " + s);
375 }
376 static void delay(int millis) {
377 try {
378 Thread.sleep(millis);
379 } catch (InterruptedException e) {}
380 }
381 }