/*

 * 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.io.IOException;

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

 * @bug 4834461

 * @summary Applet hang when you load it during sound card is in use

 * @run main/manual PlaySine

 */

public class PlaySine {

    static int sampleRate = 8000;

    static double frequency = 2000.0;

    static double RAD = 2.0 * Math.PI;

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

    static SourceDataLine source;

    static Mixer mixer = null;

    static AudioInputStream ais = null;

    static AudioFormat audioFormat;

    static String filename;

    public static void constructAIS() {

        try {

            ais = AudioSystem.getAudioInputStream(new File(filename));

        } catch (Exception e) {

            println("ERROR: could not open "+filename+": "+e.getMessage());

        }

    }

    public static void print(String s) {

        System.out.print(s);

    }

    public static void println(String s) {

        System.out.println(s);

    }

    public static void key() {

        println("");

        print("Press ENTER to continue...");

        try {

            System.in.read();

        } catch (IOException ioe) {

        }

    }

    static int audioLen = -1;

    static int audioOffset = -1;

    public static void writeData() {

        if (audioLen == -1) {

            audioLen = audioData.length;

        }

        if (audioOffset < 0) {

            audioOffset = audioLen;

        }

        try {

            if (audioOffset >= audioLen) {

                audioOffset = 0;

                if (ais!=null) {

                    do {

                        audioLen = ais.read(audioData, 0, audioData.length);

                        if (audioLen < 0) {

                            constructAIS();

                        }

                    } while (audioLen < 0);

                }

            }

            int toWrite = audioLen - audioOffset;

            int written = source.write(audioData, audioOffset, toWrite);

            audioOffset+=written;

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    public static int play(boolean shouldPlay) {

        int res = 0;

        DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);

        try {

            println("Getting line from mixer...");

            source = (SourceDataLine) mixer.getLine(info);

            println("Opening line...");

            println("  -- if the program is hanging here, kill the process that has blocks the audio device now.");

            source.open(audioFormat);

            println("Starting line...");

            source.start();

            println("Writing audio data for 1 second...");

            long startTime = System.currentTimeMillis();

            while (System.currentTimeMillis() - startTime < 1000) {

                writeData();

                Thread.sleep(100);

            }

            res = 1;

        } catch (IllegalArgumentException iae) {

            println("IllegalArgumentException: "+iae.getMessage());

            println("Sound device cannot handle this audio format.");

            println("ERROR: Test environment not correctly set up.");

            if (source!=null) {

                source.close();

            }

            return 3;

        } catch (LineUnavailableException lue) {

            println("LineUnavailableException: "+lue.getMessage());

            if (shouldPlay) {

                println("ERROR: the line should be available now!.");

                println("       Verify that you killed the other audio process.");

            } else {

                println("Correct behavior! the bug is fixed.");

            }

            res = 2;

        } catch (Exception e) {

            println("Unexpected Exception: "+e.toString());

        }

        if (source != null) {

            println("Draining...");

            try {

                source.drain();

            } catch (NullPointerException npe) {

                println("(NullPointerException: bug fixed in J2SE 1.4.2");

            }

            println("Stopping...");

            source.stop();

            println("Closing...");

            source.close();

            source = null;

        }

        return res;

    }

    public static void main(String[] args) throws Exception {

        println("This is an interactive test. You can run it with a filename as argument");

        println("It is only meant to be run on linux, with the (old) OSS kernel drivers (/dev/dsp)");

        println("This test should not be run on systems with ALSA installed, or kernel 2.6 or higher.");

        println("");

        println("The test verifies that Java Sound fails correctly if another process is blocking");

        println("the audio device.");

        println("");

        println("Checking sanity...");

        Mixer.Info[] mixers=null;

        mixers = AudioSystem.getMixerInfo();

        for (int i=0; i<mixers.length; i++) {

            try {

                Mixer thisMixer = AudioSystem.getMixer(mixers[i]);

                String mixerName = thisMixer.getMixerInfo().getName();

                if (mixerName.indexOf("Java Sound")>=0

                    && mixerName.indexOf("Engine")>=0) {

                    mixer = thisMixer;

                    break;

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

        if (mixer == null) {

            if (mixers.length==0) {

                System.out.println("ERROR: No mixers available!");

            } else {

                println("ERROR: Java Sound Engine could not be found.");

            }

            println("Cannot run this test.");

            return;

        }

        println("  ...using mixer "+mixer.getMixerInfo());

        String osname = System.getProperty("os.name");

        if ((osname == null) || (osname.toLowerCase().indexOf("linux")<0)) {

            println("ERROR: not running on linux (you are running on "+osname+")");

            return;

        }

        println("  ...running on "+osname);

        println("  ...sanity test OK.");

        filename = null;

        if (args.length>0) {

            File f = new File(args[0]);

            if (f.exists()) {

                filename = args[0];

                println("Opening "+filename);

                constructAIS();

                if (ais!=null) {

                    audioFormat = ais.getFormat();

                }

            }

        }

        if (ais == null) {

            println("Using self-generated sine wave for playback");

            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);

            }

        }

        println("");

        println("Now, on a second console, run the following command:");

        println("    cat - < /dev/zero > /dev/dsp");

        key();

        println("After you press ENTER now, the mixer will be opened.");

        println("There are 3 possible cases that can occur:");

        println("1) you'll hear a sine wave");

        println("   -> you are running with mixing OSS drivers. ");

        println("      Some soundcards only provide mixing OSS drivers.");

        println("      Test environment not valid. ");

        println("      Repeat on another machine where you can reproduce the bug first.");

        println("2) this program stops doing anything after 'Opening line...'");

        println("   -> this is the bug.");

        println("      Kill the command on the other console with Ctrl-C, this program");

        println("      should continue working then.");

        println("3) this program reports a LineUnavailableException");

        println("   -> bug is fixed.");

        println("      OR you run with non-blocking OSS drivers.");

        println("      make sure that you can reproduce this bug first with e.g. J2SE 1.4.1");

        key();

        int playedFirst = play(false);

        int playedSecond = 0;

        if (playedFirst == 2) {

            println("");

            println("Now kill the other process with Ctrl-C.");

            println("After that, this program should be able to play ");

            println("the sine wave without problems.");

            key();

            playedSecond = play(true);

        }

        println("");

        if (playedFirst == 1) {

            println("Test FAILED.");

        }

        else if (playedFirst == 2 && playedSecond == 1) {

            println("Test SUCCESSFUL");

        } else {

            println("Test not failed (but not successful either...).");

        }

    }

}