Quelle  StopStart.java   Sprache: JAVA

/*
 * Copyright (c) 2003, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.File;
import java.util.Random;

import javax.sound.sampled.AudioFormat;
import javax.sound.sampled.AudioInputStream;
import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.DataLine;
import javax.sound.sampled.LineUnavailableException;
import javax.sound.sampled.Mixer;
import javax.sound.sampled.SourceDataLine;

/**
 * @test
 * @key sound
 * @bug 4828556
 * @summary stopping and starting sampled audio plays small chunk in infinite
 *          loop
 */
public class StopStart implements Runnable {

    static int sampleRate = 8000;
    static double frequency = 2000.0;
    static double RAD = 2.0 * Math.PI;
    static Random random = new Random();

    static byte[] audioData = new byte[sampleRate/2];
    static SourceDataLine source;

    static boolean terminated = false;

    static int buffersWritten = 0;
    static long bytesWritten = 0;
    static int buffersWrittenAfter5Seconds;

    static AudioInputStream ais = null;
    static AudioFormat audioFormat;
    static String filename;

    static int executedTests=0;
    static int successfulTests = 0;

    public static void constructAIS() throws Exception {
        ais = AudioSystem.getAudioInputStream(new File(filename));
    }

    public static void doStartStopTest1() throws Exception {
        System.out.println("TEST 1: play for 3 seconds, stop/start/stop/start/play for 3 seconds...");
        source.start();
        Thread.sleep(100);
        bytesWritten = 0;
        System.out.println("Waiting for 3 seconds...");
        Thread.sleep(3000);
        buffersWrittenAfter5Seconds = buffersWritten;
        System.out.println("Buffers Written: "+buffersWritten);
        System.out.println("stop()->start()->stop()->start()");
        source.stop();
        //System.out.println("start()");
        source.start();
        //System.out.println("stop()2 ----------------------------------------------------------");
        source.stop();
        //System.out.println("start()");
        source.start();
        System.out.println("Buffers Written: "+buffersWritten);
        System.out.println("Waiting for 3 seconds...");
        Thread.sleep(3000);
        System.out.println("Buffers Written: "+buffersWritten);
        if (buffersWritten >= ((buffersWrittenAfter5Seconds * 2) - ((buffersWrittenAfter5Seconds / 4)))) {
            successfulTests++;
        }
    }

    private static int nextWaitTime() {
        int waitTime = random.nextInt(25);
        waitTime*=waitTime;
        if (waitTime<20) waitTime = 0;
        return waitTime;
    }


    public static void doStartStopTest2() throws Exception {
        System.out.println("TEST 2: start and stop 100 times with random wait in between");
        int max=100;
        for (int i=0; i<max; i++) {
            System.out.println("Round "+i);
            System.out.println("Start....");
            source.start();
            int waitTime = nextWaitTime();
            System.out.println("Waiting for "+waitTime+"ms...");
            if (waitTime>0) {
                Thread.sleep(waitTime);
            }
            System.out.println("stop()");
            source.stop();
            waitTime = nextWaitTime();
            System.out.println("Waiting for "+waitTime+"ms...");
            if (waitTime>0) {
                Thread.sleep(waitTime);
            }
        }
    }

    public static void doStartStopTest3() throws Exception {
        System.out.println("TEST 3: start and stop 100 times with random wait only every 10 rounds ");
        int max=100;
        for (int i=0; i<max; i++) {
            System.out.println("Round "+i);
            System.out.println("Start....");
            source.start();
            if (i % 10 == 9) {
                int waitTime = nextWaitTime();
                System.out.println("Waiting for "+waitTime+"ms...");
                if (waitTime>0) {
                    Thread.sleep(waitTime);
                }
            }
            System.out.println("stop()");
            source.stop();
            if (i % 13 == 12) {
                int waitTime = nextWaitTime();
                System.out.println("Waiting for "+waitTime+"ms...");
                if (waitTime>0) {
                    Thread.sleep(waitTime);
                }
            }
        }
    }

    public static void runTest(int testNum) {
        terminated = false;
        Thread thread = null;
        buffersWrittenAfter5Seconds = 0;
        // make the tests reproduceable by always seeding with same value
        random.setSeed(1);
        try {
            executedTests++;
            thread = new Thread(new StopStart());
            thread.start();
            switch (testNum) {
            case 1: doStartStopTest1(); break;
            case 2: doStartStopTest2(); break;
            case 3: doStartStopTest3(); break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        source.stop();
        source.close();
        if (thread!=null) {
            terminated = true;
            System.out.println("Waiting for thread to die...");
            try {
                thread.join();
            } catch (InterruptedException ie) {
                ie.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        filename = null;
        if (args.length>0) {
            File f = new File(args[0]);
            if (f.exists()) {
                filename = args[0];
                System.out.println("Opening "+filename);
                constructAIS();
                audioFormat = ais.getFormat();
            }
        }
        if (filename == null) {
            audioFormat = new AudioFormat((float)sampleRate, 8, 1, true, true);
            for (int i=0; i<audioData.length; i++) {
                audioData[i] = (byte)(Math.sin(RAD*frequency/sampleRate*i)*127.0);
            }
        }
        long startTime = System.currentTimeMillis();
        Mixer.Info[] mixers = AudioSystem.getMixerInfo();
        for (int i=0; i<mixers.length; i++) {
            try {
                Mixer mixer = AudioSystem.getMixer(mixers[i]);
                DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
                String mixerName = mixer.getMixerInfo().getName();
                try {
                    source = (SourceDataLine) mixer.getLine(info);
                    source.open(audioFormat);
                } catch (IllegalArgumentException iae) {
                    System.out.println("Mixer "+mixerName+" does not provide a SourceDataLine.");
                    continue;
                } catch (LineUnavailableException lue) {
                    System.out.println("Mixer "+mixerName+": no lines available.");
                    continue;
                }
                System.out.println("***** Testing on Mixer "+mixerName+":");
                //runTest(2);
                //runTest(3);
                runTest(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (mixers.length==0) {
            System.out.println("No mixers available!");
        } else {
            long duration = System.currentTimeMillis() - startTime;

            System.out.println("Test took "+(duration/1000)+"s and "+(duration % 1000)+"ms.");
        }

        System.out.println("Exiting main()");
        if (executedTests>0) {
            if (successfulTests == 0) {
                if (args.length == 0) {
                    throw new Exception("Test FAILED");
                }
                System.out.println("test FAILED.");
            } else {
                System.out.println("test successful.");
            }
        } else {
            System.out.println("Could not execute any tests - are soundcards correctly installed?");
            System.out.println("Test NOT FAILED.");
        }
    }

    public void run() {
        int len = audioData.length;
        int offset = len;
        System.out.println("Thread: started. Beginning audio i/o");
        while (!terminated) {
            try {
                //if (!source.isActive()) {
                //      Thread.sleep(50);
                //}
                if (offset >= len) {
                    offset = 0;
                    if (ais!=null) {
                        do {
                            len = ais.read(audioData, 0, audioData.length);
                            if (len < 0) {
                                constructAIS();
                            }
                        } while (len < 0);
                    }
                }
                int toWrite = len - offset;
                int written = source.write(audioData, offset, toWrite);
                offset+=written;
                bytesWritten += written;
                buffersWritten = (int) (bytesWritten / audioData.length);
            } catch (Exception e) {
                e.printStackTrace();
                terminated = true;
            }
        }
        System.out.println("Thread: closing line");
        source.stop();
        source.close();
        System.out.println("Thread finished");
    }
}