--- /dev/null
+package javajs.util;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.DataLine;
+import javax.sound.sampled.SourceDataLine;
+
+import sun.audio.AudioData;
+import sun.audio.AudioDataStream;
+import sun.audio.AudioPlayer;
+
+
+/**
+ * The JSAudioThread adds a layer to JSThread that is specific for audio.
+ * This class utilizes JSAudioLine, which is not fully fleshed out.
+ *
+ * Two very simple interfaces,
+ *
+ * (new JSAudioThread()).playULawData(byte[] b);
+ *
+ * and
+ *
+ * (new JSAudioThread(audioFormat)).playOnce(byte[] b, offset, length);
+ *
+ * allow straightforward audio production without having to work with
+ * SourceDataLine directly.
+ *
+ * As a JSThread, this class implements myInit(), isLooping(), myLoop(),
+ * whenDone(), onException(), and doFinally().
+ *
+ * If the constructor JSAudioThread(JSAudioThreadUser, AudioFormat, byte[]) is
+ * used, then the JSAudioThreadUser must simply implement fillAudioBuffer(),
+ * checkSoundStatus(), and audioThreadExiting() for very simple streaming audio.
+ * JSAudioThread will then take care of all the timing issues.
+ *
+ * But the implementer is welcome to override any of the JSThread overrides
+ * themselves in order to customize this further.
+ *
+ * The standard streaming case, then is:
+ *
+ * audioThread = new JSAudioThread(audioUser, audioFormat, audioByteBuffer);
+ * audioThread.start();
+ *
+ * where audioUser provides
+ *
+ * checkSoundStatus() (called in isLooping()),
+ *
+ * fillAudioBuffer() (called in myLoop()),
+ *
+ * and
+ *
+ * audioThreadExiting() (called in doFinally()).
+ *
+ * @author Bob Hanson
+ *
+ */
+public class JSAudioThread extends JSThread {
+
+ protected Owner owner;
+ protected boolean done;
+ protected int myBufferLength;
+ protected SourceDataLine line;
+ protected int rate, nChannels, bitsPerSample;
+
+ protected byte[] audioByteBuffer;
+ protected int audioBufferByteLength;
+
+ private AudioFormat audioFormat;
+ private int myBufferOffset;
+ private int playCount;
+
+ public JSAudioThread(Owner owner, AudioFormat audioFormat, byte[] audioByteBuffer) {
+ this.owner = owner;
+ setFormat(audioFormat);
+ setBuffer(audioByteBuffer);
+ }
+
+ /**
+ * A convenience constructor requiring standard settings of
+ * signed (for 8-bit) and littleEndian (for 16-bit)
+ *
+ * @param owner
+ * @param rate
+ * @param bitsPerSample
+ * @param nChannels
+ * @param audioByteBuffer
+ */
+ public JSAudioThread(Owner owner, int rate, int bitsPerSample, int nChannels, byte[] audioByteBuffer) {
+ this.owner = owner;
+ setFormat(new AudioFormat(rate, bitsPerSample, nChannels, true, false));
+ setBuffer(audioByteBuffer);
+ }
+
+ /**
+ * primarily available for (new JSAudioThread()).playULawData
+ *
+ */
+ public JSAudioThread() {
+ }
+
+ /**
+ * primarily available for (new JSAudioThread()).playOnce
+ *
+ */
+ public JSAudioThread(AudioFormat audioFormat) {
+ setFormat(audioFormat);
+ }
+
+ /**
+ *
+ * A simple 8-bit uLaw data player
+ *
+ * @param data
+ */
+ public void playULawData(byte[] data) {
+ // this constructor uses default new AudioFormat(ULAW,8000,8,1,1,8000,true)
+ // threading is taken care of by the browser in JavaScript
+ AudioPlayer.player.start(new AudioDataStream(new AudioData(data)));
+ }
+
+
+ /**
+ * Just play once through; no additions
+ *
+ * @param data
+ */
+ public void playOnce(byte[] data, int offset, int length) {
+ setBuffer(data);
+ myBufferOffset = offset;
+ myBufferLength = length;
+ playCount = 1;
+ start();
+ }
+
+ public void setBuffer(byte[] audioByteBuffer) {
+ this.audioByteBuffer = audioByteBuffer;
+ audioBufferByteLength = audioByteBuffer.length;
+ }
+
+ public SourceDataLine getLine() {
+ return line;
+ }
+
+ public AudioFormat getFormat() {
+ return audioFormat;
+ }
+
+ public void setFormat(AudioFormat audioFormat) {
+ this.audioFormat = audioFormat;
+ rate = (int) audioFormat.getSampleRate();
+ bitsPerSample = audioFormat.getSampleSizeInBits();
+ nChannels = audioFormat.getChannels();
+ }
+
+ public void resetAudio() {
+ if (line == null)
+ return;
+ line.flush();
+ line.close();
+ line = null;
+ }
+
+ /**
+ * Standard initialization of a SourceDataLine
+ *
+ */
+ @Override
+ protected boolean myInit() {
+ try {
+ DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat);
+ if (line != null)
+ line.close();
+ line = (SourceDataLine) AudioSystem.getLine(info);
+ line.open(audioFormat, audioBufferByteLength);
+ line.start();
+ } catch (Exception e) {
+ e.printStackTrace();
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ protected boolean isLooping() {
+ return !done && (--playCount >= 0 || owner != null && owner.checkSoundStatus());
+ }
+
+ @Override
+ protected boolean myLoop() {
+ if (!done) {
+ if ((myBufferLength = (owner == null ? myBufferLength : owner.fillAudioBuffer())) <= 0)
+ return !(done = true);
+ try {
+ if (line == null)
+ myInit();
+ line.write(audioByteBuffer, myBufferOffset, myBufferLength);
+ } catch (Exception e) {
+ e.printStackTrace();
+ done = true;
+ }
+ }
+ return !done;
+ }
+
+ @Override
+ protected void whenDone() {
+ done = true;
+ resetAudio();
+ }
+
+ @Override
+ protected int getDelayMillis() {
+ // about 25% of the actual play time
+ return 1000 // ms/sec
+ * (myBufferLength * 8 / bitsPerSample) // * samples
+ / rate // * seconds/sample)
+ / nChannels // / number of channels
+ / 4; // * 25%
+ }
+
+ @Override
+ protected void onException(Exception e) {
+ e.printStackTrace();
+ }
+
+ @Override
+ protected void doFinally() {
+ if (owner != null)
+ owner.audioThreadExiting();
+ }
+
+ public interface Owner {
+
+ /**
+ *
+ * @return true if thread should continue; false if not
+ *
+ */
+ boolean checkSoundStatus();
+
+ /** fill audio buffer
+ *
+ * @return number of bytes to write to audio line
+ *
+ */
+ int fillAudioBuffer();
+
+ /**
+ * called from the finally clause when complete
+ *
+ */
+ void audioThreadExiting();
+
+
+ }
+
+}
+
git://source.jalview.org / jalview.git / blobdiff