460 lines
15 KiB
Java
460 lines
15 KiB
Java
/*
|
|
* Copyright (c) 1999, 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. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
package com.sun.media.sound;
|
|
|
|
import javax.sound.sampled.AudioFormat;
|
|
import javax.sound.sampled.AudioSystem;
|
|
import javax.sound.sampled.Control;
|
|
import javax.sound.sampled.DataLine;
|
|
import javax.sound.sampled.LineEvent;
|
|
import javax.sound.sampled.LineUnavailableException;
|
|
|
|
|
|
/**
|
|
* AbstractDataLine
|
|
*
|
|
* @author Kara Kytle
|
|
*/
|
|
abstract class AbstractDataLine extends AbstractLine implements DataLine {
|
|
|
|
// DEFAULTS
|
|
|
|
// default format
|
|
private final AudioFormat defaultFormat;
|
|
|
|
// default buffer size in bytes
|
|
private final int defaultBufferSize;
|
|
|
|
// the lock for synchronization
|
|
protected final Object lock = new Object();
|
|
|
|
// STATE
|
|
|
|
// current format
|
|
protected AudioFormat format;
|
|
|
|
// current buffer size in bytes
|
|
protected int bufferSize;
|
|
|
|
private volatile boolean running;
|
|
private volatile boolean started;
|
|
private volatile boolean active;
|
|
|
|
/**
|
|
* Constructs a new AbstractLine.
|
|
*/
|
|
protected AbstractDataLine(DataLine.Info info, AbstractMixer mixer, Control[] controls) {
|
|
this(info, mixer, controls, null, AudioSystem.NOT_SPECIFIED);
|
|
}
|
|
|
|
/**
|
|
* Constructs a new AbstractLine.
|
|
*/
|
|
protected AbstractDataLine(DataLine.Info info, AbstractMixer mixer, Control[] controls, AudioFormat format, int bufferSize) {
|
|
|
|
super(info, mixer, controls);
|
|
|
|
// record the default values
|
|
if (format != null) {
|
|
defaultFormat = format;
|
|
} else {
|
|
// default CD-quality
|
|
defaultFormat = new AudioFormat(44100.0f, 16, 2, true, Platform.isBigEndian());
|
|
}
|
|
if (bufferSize > 0) {
|
|
defaultBufferSize = bufferSize;
|
|
} else {
|
|
// 0.5 seconds buffer
|
|
defaultBufferSize = ((int) (defaultFormat.getFrameRate() / 2)) * defaultFormat.getFrameSize();
|
|
}
|
|
|
|
// set the initial values to the defaults
|
|
this.format = defaultFormat;
|
|
this.bufferSize = defaultBufferSize;
|
|
}
|
|
|
|
|
|
// DATA LINE METHODS
|
|
|
|
public final void open(AudioFormat format, int bufferSize) throws LineUnavailableException {
|
|
//$$fb 2001-10-09: Bug #4517739: avoiding deadlock by synchronizing to mixer !
|
|
synchronized (mixer) {
|
|
if (Printer.trace) Printer.trace("> AbstractDataLine.open(format, bufferSize) (class: "+getClass().getName());
|
|
|
|
// if the line is not currently open, try to open it with this format and buffer size
|
|
if (!isOpen()) {
|
|
// make sure that the format is specified correctly
|
|
// $$fb part of fix for 4679187: Clip.open() throws unexpected Exceptions
|
|
Toolkit.isFullySpecifiedAudioFormat(format);
|
|
|
|
if (Printer.debug) Printer.debug(" need to open the mixer...");
|
|
// reserve mixer resources for this line
|
|
//mixer.open(this, format, bufferSize);
|
|
mixer.open(this);
|
|
|
|
try {
|
|
// open the data line. may throw LineUnavailableException.
|
|
implOpen(format, bufferSize);
|
|
|
|
// if we succeeded, set the open state to true and send events
|
|
setOpen(true);
|
|
|
|
} catch (LineUnavailableException e) {
|
|
// release mixer resources for this line and then throw the exception
|
|
mixer.close(this);
|
|
throw e;
|
|
}
|
|
} else {
|
|
if (Printer.debug) Printer.debug(" dataline already open");
|
|
|
|
// if the line is already open and the requested format differs from the
|
|
// current settings, throw an IllegalStateException
|
|
//$$fb 2002-04-02: fix for 4661602: Buffersize is checked when re-opening line
|
|
if (!format.matches(getFormat())) {
|
|
throw new IllegalStateException("Line is already open with format " + getFormat() +
|
|
" and bufferSize " + getBufferSize());
|
|
}
|
|
//$$fb 2002-07-26: allow changing the buffersize of already open lines
|
|
if (bufferSize > 0) {
|
|
setBufferSize(bufferSize);
|
|
}
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace("< AbstractDataLine.open(format, bufferSize) completed");
|
|
}
|
|
}
|
|
|
|
|
|
public final void open(AudioFormat format) throws LineUnavailableException {
|
|
open(format, AudioSystem.NOT_SPECIFIED);
|
|
}
|
|
|
|
|
|
/**
|
|
* This implementation always returns 0.
|
|
*/
|
|
public int available() {
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* This implementation does nothing.
|
|
*/
|
|
public void drain() {
|
|
if (Printer.trace) Printer.trace("AbstractDataLine: drain");
|
|
}
|
|
|
|
|
|
/**
|
|
* This implementation does nothing.
|
|
*/
|
|
public void flush() {
|
|
if (Printer.trace) Printer.trace("AbstractDataLine: flush");
|
|
}
|
|
|
|
|
|
public final void start() {
|
|
//$$fb 2001-10-09: Bug #4517739: avoiding deadlock by synchronizing to mixer !
|
|
synchronized(mixer) {
|
|
if (Printer.trace) Printer.trace("> "+getClass().getName()+".start() - AbstractDataLine");
|
|
|
|
// $$kk: 06.06.99: if not open, this doesn't work....???
|
|
if (isOpen()) {
|
|
|
|
if (!isStartedRunning()) {
|
|
mixer.start(this);
|
|
implStart();
|
|
running = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
synchronized(lock) {
|
|
lock.notifyAll();
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace("< "+getClass().getName()+".start() - AbstractDataLine");
|
|
}
|
|
|
|
|
|
public final void stop() {
|
|
|
|
//$$fb 2001-10-09: Bug #4517739: avoiding deadlock by synchronizing to mixer !
|
|
synchronized(mixer) {
|
|
if (Printer.trace) Printer.trace("> "+getClass().getName()+".stop() - AbstractDataLine");
|
|
|
|
// $$kk: 06.06.99: if not open, this doesn't work.
|
|
if (isOpen()) {
|
|
|
|
if (isStartedRunning()) {
|
|
|
|
implStop();
|
|
mixer.stop(this);
|
|
|
|
running = false;
|
|
|
|
// $$kk: 11.10.99: this is not exactly correct, but will probably work
|
|
if (started && (!isActive())) {
|
|
setStarted(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
synchronized(lock) {
|
|
lock.notifyAll();
|
|
}
|
|
|
|
if (Printer.trace) Printer.trace("< "+getClass().getName()+".stop() - AbstractDataLine");
|
|
}
|
|
|
|
// $$jb: 12.10.99: The official API for this is isRunning().
|
|
// Per the denied RFE 4297981,
|
|
// the change to isStarted() is technically an unapproved API change.
|
|
// The 'started' variable is false when playback of data stops.
|
|
// It is changed throughout the implementation with setStarted().
|
|
// This state is what should be returned by isRunning() in the API.
|
|
// Note that the 'running' variable is true between calls to
|
|
// start() and stop(). This state is accessed now through the
|
|
// isStartedRunning() method, defined below. I have not changed
|
|
// the variable names at this point, since 'running' is accessed
|
|
// in MixerSourceLine and MixerClip, and I want to touch as little
|
|
// code as possible to change isStarted() back to isRunning().
|
|
|
|
public final boolean isRunning() {
|
|
return started;
|
|
}
|
|
|
|
public final boolean isActive() {
|
|
return active;
|
|
}
|
|
|
|
|
|
public final long getMicrosecondPosition() {
|
|
|
|
long microseconds = getLongFramePosition();
|
|
if (microseconds != AudioSystem.NOT_SPECIFIED) {
|
|
microseconds = Toolkit.frames2micros(getFormat(), microseconds);
|
|
}
|
|
return microseconds;
|
|
}
|
|
|
|
|
|
public final AudioFormat getFormat() {
|
|
return format;
|
|
}
|
|
|
|
|
|
public final int getBufferSize() {
|
|
return bufferSize;
|
|
}
|
|
|
|
/**
|
|
* This implementation does NOT change the buffer size
|
|
*/
|
|
public final int setBufferSize(int newSize) {
|
|
return getBufferSize();
|
|
}
|
|
|
|
/**
|
|
* This implementation returns AudioSystem.NOT_SPECIFIED.
|
|
*/
|
|
public final float getLevel() {
|
|
return (float)AudioSystem.NOT_SPECIFIED;
|
|
}
|
|
|
|
|
|
// HELPER METHODS
|
|
|
|
/**
|
|
* running is true after start is called and before stop is called,
|
|
* regardless of whether data is actually being presented.
|
|
*/
|
|
// $$jb: 12.10.99: calling this method isRunning() conflicts with
|
|
// the official API that was once called isStarted(). Since we
|
|
// use this method throughout the implementation, I am renaming
|
|
// it to isStartedRunning(). This is part of backing out the
|
|
// change denied in RFE 4297981.
|
|
|
|
final boolean isStartedRunning() {
|
|
return running;
|
|
}
|
|
|
|
/**
|
|
* This method sets the active state and generates
|
|
* events if it changes.
|
|
*/
|
|
final void setActive(boolean active) {
|
|
|
|
if (Printer.trace) Printer.trace("> AbstractDataLine: setActive(" + active + ")");
|
|
|
|
//boolean sendEvents = false;
|
|
//long position = getLongFramePosition();
|
|
|
|
synchronized (this) {
|
|
|
|
//if (Printer.debug) Printer.debug(" AbstractDataLine: setActive: this.active: " + this.active);
|
|
//if (Printer.debug) Printer.debug(" active: " + active);
|
|
|
|
if (this.active != active) {
|
|
this.active = active;
|
|
//sendEvents = true;
|
|
}
|
|
}
|
|
|
|
//if (Printer.debug) Printer.debug(" this.active: " + this.active);
|
|
//if (Printer.debug) Printer.debug(" sendEvents: " + sendEvents);
|
|
|
|
|
|
// $$kk: 11.19.99: take ACTIVE / INACTIVE / EOM events out;
|
|
// putting them in is technically an API change.
|
|
// do not generate ACTIVE / INACTIVE events for now
|
|
// if (sendEvents) {
|
|
//
|
|
// if (active) {
|
|
// sendEvents(new LineEvent(this, LineEvent.Type.ACTIVE, position));
|
|
// } else {
|
|
// sendEvents(new LineEvent(this, LineEvent.Type.INACTIVE, position));
|
|
// }
|
|
//}
|
|
}
|
|
|
|
/**
|
|
* This method sets the started state and generates
|
|
* events if it changes.
|
|
*/
|
|
final void setStarted(boolean started) {
|
|
|
|
if (Printer.trace) Printer.trace("> AbstractDataLine: setStarted(" + started + ")");
|
|
|
|
boolean sendEvents = false;
|
|
long position = getLongFramePosition();
|
|
|
|
synchronized (this) {
|
|
|
|
//if (Printer.debug) Printer.debug(" AbstractDataLine: setStarted: this.started: " + this.started);
|
|
//if (Printer.debug) Printer.debug(" started: " + started);
|
|
|
|
if (this.started != started) {
|
|
this.started = started;
|
|
sendEvents = true;
|
|
}
|
|
}
|
|
|
|
//if (Printer.debug) Printer.debug(" this.started: " + this.started);
|
|
//if (Printer.debug) Printer.debug(" sendEvents: " + sendEvents);
|
|
|
|
if (sendEvents) {
|
|
|
|
if (started) {
|
|
sendEvents(new LineEvent(this, LineEvent.Type.START, position));
|
|
} else {
|
|
sendEvents(new LineEvent(this, LineEvent.Type.STOP, position));
|
|
}
|
|
}
|
|
if (Printer.trace) Printer.trace("< AbstractDataLine: setStarted completed");
|
|
}
|
|
|
|
|
|
/**
|
|
* This method generates a STOP event and sets the started state to false.
|
|
* It is here for historic reasons when an EOM event existed.
|
|
*/
|
|
final void setEOM() {
|
|
|
|
if (Printer.trace) Printer.trace("> AbstractDataLine: setEOM()");
|
|
//$$fb 2002-04-21: sometimes, 2 STOP events are generated.
|
|
// better use setStarted() to send STOP event.
|
|
setStarted(false);
|
|
if (Printer.trace) Printer.trace("< AbstractDataLine: setEOM() completed");
|
|
}
|
|
|
|
|
|
|
|
|
|
// OVERRIDES OF ABSTRACT LINE METHODS
|
|
|
|
/**
|
|
* Try to open the line with the current format and buffer size values.
|
|
* If the line is not open, these will be the defaults. If the
|
|
* line is open, this should return quietly because the values
|
|
* requested will match the current ones.
|
|
*/
|
|
public final void open() throws LineUnavailableException {
|
|
|
|
if (Printer.trace) Printer.trace("> "+getClass().getName()+".open() - AbstractDataLine");
|
|
|
|
// this may throw a LineUnavailableException.
|
|
open(format, bufferSize);
|
|
if (Printer.trace) Printer.trace("< "+getClass().getName()+".open() - AbstractDataLine");
|
|
}
|
|
|
|
|
|
/**
|
|
* This should also stop the line. The closed line should not be running or active.
|
|
* After we close the line, we reset the format and buffer size to the defaults.
|
|
*/
|
|
public final void close() {
|
|
//$$fb 2001-10-09: Bug #4517739: avoiding deadlock by synchronizing to mixer !
|
|
synchronized (mixer) {
|
|
if (Printer.trace) Printer.trace("> "+getClass().getName()+".close() - in AbstractDataLine.");
|
|
|
|
if (isOpen()) {
|
|
|
|
// stop
|
|
stop();
|
|
|
|
// set the open state to false and send events
|
|
setOpen(false);
|
|
|
|
// close resources for this line
|
|
implClose();
|
|
|
|
// release mixer resources for this line
|
|
mixer.close(this);
|
|
|
|
// reset format and buffer size to the defaults
|
|
format = defaultFormat;
|
|
bufferSize = defaultBufferSize;
|
|
}
|
|
}
|
|
if (Printer.trace) Printer.trace("< "+getClass().getName()+".close() - in AbstractDataLine");
|
|
}
|
|
|
|
|
|
// IMPLEMENTATIONS OF ABSTRACT LINE ABSTRACE METHODS
|
|
|
|
|
|
// ABSTRACT METHODS
|
|
|
|
abstract void implOpen(AudioFormat format, int bufferSize) throws LineUnavailableException;
|
|
abstract void implClose();
|
|
|
|
abstract void implStart();
|
|
abstract void implStop();
|
|
}
|