| /* |
| * Copyright (c) 1999, 2013, 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 java.util.Vector; |
| |
| import javax.sound.sampled.Control; |
| import javax.sound.sampled.Mixer; |
| import javax.sound.sampled.Line; |
| import javax.sound.sampled.LineUnavailableException; |
| |
| /** |
| * Abstract Mixer. Implements Mixer (with abstract methods) and specifies |
| * some other common methods for use by our implementation. |
| * |
| * @author Kara Kytle |
| */ |
| //$$fb 2002-07-26: let AbstractMixer be an AbstractLine and NOT an AbstractDataLine! |
| abstract class AbstractMixer extends AbstractLine implements Mixer { |
| |
| // STATIC VARIABLES |
| protected static final int PCM = 0; |
| protected static final int ULAW = 1; |
| protected static final int ALAW = 2; |
| |
| |
| // IMMUTABLE PROPERTIES |
| |
| /** |
| * Info object describing this mixer. |
| */ |
| private final Mixer.Info mixerInfo; |
| |
| /** |
| * source lines provided by this mixer |
| */ |
| protected Line.Info[] sourceLineInfo; |
| |
| /** |
| * target lines provided by this mixer |
| */ |
| protected Line.Info[] targetLineInfo; |
| |
| /** |
| * if any line of this mixer is started |
| */ |
| private boolean started = false; |
| |
| /** |
| * if this mixer had been opened manually with open() |
| * If it was, then it won't be closed automatically, |
| * only when close() is called manually. |
| */ |
| private boolean manuallyOpened = false; |
| |
| |
| /** |
| * Supported formats for the mixer. |
| */ |
| //$$fb DELETE |
| //protected Vector formats = new Vector(); |
| |
| |
| // STATE VARIABLES |
| |
| |
| /** |
| * Source lines (ports) currently open |
| */ |
| private final Vector sourceLines = new Vector(); |
| |
| |
| /** |
| * Target lines currently open. |
| */ |
| private final Vector targetLines = new Vector(); |
| |
| |
| /** |
| * Constructs a new AbstractMixer. |
| * @param mixer the mixer with which this line is associated |
| * @param controls set of supported controls |
| */ |
| protected AbstractMixer(Mixer.Info mixerInfo, |
| Control[] controls, |
| Line.Info[] sourceLineInfo, |
| Line.Info[] targetLineInfo) { |
| |
| // Line.Info, AbstractMixer, Control[] |
| super(new Line.Info(Mixer.class), null, controls); |
| |
| // setup the line part |
| this.mixer = this; |
| if (controls == null) { |
| controls = new Control[0]; |
| } |
| |
| // setup the mixer part |
| this.mixerInfo = mixerInfo; |
| this.sourceLineInfo = sourceLineInfo; |
| this.targetLineInfo = targetLineInfo; |
| } |
| |
| |
| // MIXER METHODS |
| |
| |
| public final Mixer.Info getMixerInfo() { |
| return mixerInfo; |
| } |
| |
| |
| public final Line.Info[] getSourceLineInfo() { |
| Line.Info[] localArray = new Line.Info[sourceLineInfo.length]; |
| System.arraycopy(sourceLineInfo, 0, localArray, 0, sourceLineInfo.length); |
| return localArray; |
| } |
| |
| |
| public final Line.Info[] getTargetLineInfo() { |
| |
| Line.Info[] localArray = new Line.Info[targetLineInfo.length]; |
| System.arraycopy(targetLineInfo, 0, localArray, 0, targetLineInfo.length); |
| return localArray; |
| } |
| |
| |
| public final Line.Info[] getSourceLineInfo(Line.Info info) { |
| |
| int i; |
| Vector vec = new Vector(); |
| |
| for (i = 0; i < sourceLineInfo.length; i++) { |
| |
| if (info.matches(sourceLineInfo[i])) { |
| vec.addElement(sourceLineInfo[i]); |
| } |
| } |
| |
| Line.Info[] returnedArray = new Line.Info[vec.size()]; |
| for (i = 0; i < returnedArray.length; i++) { |
| returnedArray[i] = (Line.Info)vec.elementAt(i); |
| } |
| |
| return returnedArray; |
| } |
| |
| |
| public final Line.Info[] getTargetLineInfo(Line.Info info) { |
| |
| int i; |
| Vector vec = new Vector(); |
| |
| for (i = 0; i < targetLineInfo.length; i++) { |
| |
| if (info.matches(targetLineInfo[i])) { |
| vec.addElement(targetLineInfo[i]); |
| } |
| } |
| |
| Line.Info[] returnedArray = new Line.Info[vec.size()]; |
| for (i = 0; i < returnedArray.length; i++) { |
| returnedArray[i] = (Line.Info)vec.elementAt(i); |
| } |
| |
| return returnedArray; |
| } |
| |
| |
| public final boolean isLineSupported(Line.Info info) { |
| |
| int i; |
| |
| for (i = 0; i < sourceLineInfo.length; i++) { |
| |
| if (info.matches(sourceLineInfo[i])) { |
| return true; |
| } |
| } |
| |
| for (i = 0; i < targetLineInfo.length; i++) { |
| |
| if (info.matches(targetLineInfo[i])) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| public abstract Line getLine(Line.Info info) throws LineUnavailableException; |
| |
| public abstract int getMaxLines(Line.Info info); |
| |
| protected abstract void implOpen() throws LineUnavailableException; |
| protected abstract void implStart(); |
| protected abstract void implStop(); |
| protected abstract void implClose(); |
| |
| |
| public final Line[] getSourceLines() { |
| |
| Line[] localLines; |
| |
| synchronized(sourceLines) { |
| |
| localLines = new Line[sourceLines.size()]; |
| |
| for (int i = 0; i < localLines.length; i++) { |
| localLines[i] = (Line)sourceLines.elementAt(i); |
| } |
| } |
| |
| return localLines; |
| } |
| |
| |
| public final Line[] getTargetLines() { |
| |
| Line[] localLines; |
| |
| synchronized(targetLines) { |
| |
| localLines = new Line[targetLines.size()]; |
| |
| for (int i = 0; i < localLines.length; i++) { |
| localLines[i] = (Line)targetLines.elementAt(i); |
| } |
| } |
| |
| return localLines; |
| } |
| |
| |
| /** |
| * Default implementation always throws an exception. |
| */ |
| public final void synchronize(Line[] lines, boolean maintainSync) { |
| throw new IllegalArgumentException("Synchronization not supported by this mixer."); |
| } |
| |
| |
| /** |
| * Default implementation always throws an exception. |
| */ |
| public final void unsynchronize(Line[] lines) { |
| throw new IllegalArgumentException("Synchronization not supported by this mixer."); |
| } |
| |
| |
| /** |
| * Default implementation always returns false. |
| */ |
| public final boolean isSynchronizationSupported(Line[] lines, |
| boolean maintainSync) { |
| return false; |
| } |
| |
| |
| // OVERRIDES OF ABSTRACT DATA LINE METHODS |
| |
| /** |
| * This implementation tries to open the mixer with its current format and buffer size settings. |
| */ |
| public final synchronized void open() throws LineUnavailableException { |
| open(true); |
| } |
| |
| /** |
| * This implementation tries to open the mixer with its current format and buffer size settings. |
| */ |
| final synchronized void open(boolean manual) throws LineUnavailableException { |
| if (Printer.trace) Printer.trace(">> AbstractMixer: open()"); |
| if (!isOpen()) { |
| implOpen(); |
| // if the mixer is not currently open, set open to true and send event |
| setOpen(true); |
| if (manual) { |
| manuallyOpened = true; |
| } |
| } |
| |
| if (Printer.trace) Printer.trace("<< AbstractMixer: open() succeeded"); |
| } |
| |
| |
| // METHOD FOR INTERNAL IMPLEMENTATION USE |
| |
| |
| /** |
| * The default implementation of this method just determines whether |
| * this line is a source or target line, calls open(no-arg) on the |
| * mixer, and adds the line to the appropriate vector. |
| * The mixer may be opened at a format different than the line's |
| * format if it is a DataLine. |
| */ |
| final synchronized void open(Line line) throws LineUnavailableException { |
| |
| if (Printer.trace) Printer.trace(">> AbstractMixer: open(line = " + line + ")"); |
| |
| // $$kk: 06.11.99: ignore ourselves for now |
| if (this.equals(line)) { |
| if (Printer.trace) Printer.trace("<< AbstractMixer: open(" + line + ") nothing done"); |
| return; |
| } |
| |
| // source line? |
| if (isSourceLine(line.getLineInfo())) { |
| if (! sourceLines.contains(line) ) { |
| // call the no-arg open method for the mixer; it should open at its |
| // default format if it is not open yet |
| open(false); |
| |
| // we opened successfully! add the line to the list |
| sourceLines.addElement(line); |
| } |
| } else { |
| // target line? |
| if(isTargetLine(line.getLineInfo())) { |
| if (! targetLines.contains(line) ) { |
| // call the no-arg open method for the mixer; it should open at its |
| // default format if it is not open yet |
| open(false); |
| |
| // we opened successfully! add the line to the list |
| targetLines.addElement(line); |
| } |
| } else { |
| if (Printer.err) Printer.err("Unknown line received for AbstractMixer.open(Line): " + line); |
| } |
| } |
| |
| if (Printer.trace) Printer.trace("<< AbstractMixer: open(" + line + ") completed"); |
| } |
| |
| |
| /** |
| * Removes this line from the list of open source lines and |
| * open target lines, if it exists in either. |
| * If the list is now empty, closes the mixer. |
| */ |
| final synchronized void close(Line line) { |
| |
| if (Printer.trace) Printer.trace(">> AbstractMixer: close(" + line + ")"); |
| |
| // $$kk: 06.11.99: ignore ourselves for now |
| if (this.equals(line)) { |
| if (Printer.trace) Printer.trace("<< AbstractMixer: close(" + line + ") nothing done"); |
| return; |
| } |
| |
| sourceLines.removeElement(line); |
| targetLines.removeElement(line); |
| |
| if (Printer.debug) Printer.debug("AbstractMixer: close(line): sourceLines.size() now: " + sourceLines.size()); |
| if (Printer.debug) Printer.debug("AbstractMixer: close(line): targetLines.size() now: " + targetLines.size()); |
| |
| |
| if (sourceLines.isEmpty() && targetLines.isEmpty() && !manuallyOpened) { |
| if (Printer.trace) Printer.trace("AbstractMixer: close(" + line + "): need to close the mixer"); |
| close(); |
| } |
| |
| if (Printer.trace) Printer.trace("<< AbstractMixer: close(" + line + ") succeeded"); |
| } |
| |
| |
| /** |
| * Close all lines and then close this mixer. |
| */ |
| public final synchronized void close() { |
| if (Printer.trace) Printer.trace(">> AbstractMixer: close()"); |
| if (isOpen()) { |
| // close all source lines |
| Line[] localLines = getSourceLines(); |
| for (int i = 0; i<localLines.length; i++) { |
| localLines[i].close(); |
| } |
| |
| // close all target lines |
| localLines = getTargetLines(); |
| for (int i = 0; i<localLines.length; i++) { |
| localLines[i].close(); |
| } |
| |
| implClose(); |
| |
| // set the open state to false and send events |
| setOpen(false); |
| } |
| manuallyOpened = false; |
| if (Printer.trace) Printer.trace("<< AbstractMixer: close() succeeded"); |
| } |
| |
| /** |
| * Starts the mixer. |
| */ |
| final synchronized void start(Line line) { |
| |
| if (Printer.trace) Printer.trace(">> AbstractMixer: start(" + line + ")"); |
| |
| // $$kk: 06.11.99: ignore ourselves for now |
| if (this.equals(line)) { |
| if (Printer.trace) Printer.trace("<< AbstractMixer: start(" + line + ") nothing done"); |
| return; |
| } |
| |
| // we just start the mixer regardless of anything else here. |
| if (!started) { |
| if (Printer.debug) Printer.debug("AbstractMixer: start(line): starting the mixer"); |
| implStart(); |
| started = true; |
| } |
| |
| if (Printer.trace) Printer.trace("<< AbstractMixer: start(" + line + ") succeeded"); |
| } |
| |
| |
| /** |
| * Stops the mixer if this was the last running line. |
| */ |
| final synchronized void stop(Line line) { |
| |
| if (Printer.trace) Printer.trace(">> AbstractMixer: stop(" + line + ")"); |
| |
| // $$kk: 06.11.99: ignore ourselves for now |
| if (this.equals(line)) { |
| if (Printer.trace) Printer.trace("<< AbstractMixer: stop(" + line + ") nothing done"); |
| return; |
| } |
| |
| Vector localSourceLines = (Vector)sourceLines.clone(); |
| for (int i = 0; i < localSourceLines.size(); i++) { |
| |
| // if any other open line is running, return |
| |
| // this covers clips and source data lines |
| if (localSourceLines.elementAt(i) instanceof AbstractDataLine) { |
| AbstractDataLine sourceLine = (AbstractDataLine)localSourceLines.elementAt(i); |
| if ( sourceLine.isStartedRunning() && (!sourceLine.equals(line)) ) { |
| if (Printer.trace) Printer.trace("<< AbstractMixer: stop(" + line + ") found running sourceLine: " + sourceLine); |
| return; |
| } |
| } |
| } |
| |
| Vector localTargetLines = (Vector)targetLines.clone(); |
| for (int i = 0; i < localTargetLines.size(); i++) { |
| |
| // if any other open line is running, return |
| // this covers target data lines |
| if (localTargetLines.elementAt(i) instanceof AbstractDataLine) { |
| AbstractDataLine targetLine = (AbstractDataLine)localTargetLines.elementAt(i); |
| if ( targetLine.isStartedRunning() && (!targetLine.equals(line)) ) { |
| if (Printer.trace) Printer.trace("<< AbstractMixer: stop(" + line + ") found running targetLine: " + targetLine); |
| return; |
| } |
| } |
| } |
| |
| // otherwise, stop |
| if (Printer.debug) Printer.debug("AbstractMixer: stop(line): stopping the mixer"); |
| started = false; |
| implStop(); |
| |
| if (Printer.trace) Printer.trace("<< AbstractMixer: stop(" + line + ") succeeded"); |
| } |
| |
| |
| |
| /** |
| * Determines whether this is a source line for this mixer. |
| * Right now this just checks whether it's supported, but should |
| * check whether it actually belongs to this mixer.... |
| */ |
| final boolean isSourceLine(Line.Info info) { |
| |
| for (int i = 0; i < sourceLineInfo.length; i++) { |
| if (info.matches(sourceLineInfo[i])) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| /** |
| * Determines whether this is a target line for this mixer. |
| * Right now this just checks whether it's supported, but should |
| * check whether it actually belongs to this mixer.... |
| */ |
| final boolean isTargetLine(Line.Info info) { |
| |
| for (int i = 0; i < targetLineInfo.length; i++) { |
| if (info.matches(targetLineInfo[i])) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| /** |
| * Returns the first complete Line.Info object it finds that |
| * matches the one specified, or null if no matching Line.Info |
| * object is found. |
| */ |
| final Line.Info getLineInfo(Line.Info info) { |
| if (info == null) { |
| return null; |
| } |
| // $$kk: 05.31.99: need to change this so that |
| // the format and buffer size get set in the |
| // returned info object for data lines?? |
| for (int i = 0; i < sourceLineInfo.length; i++) { |
| if (info.matches(sourceLineInfo[i])) { |
| return sourceLineInfo[i]; |
| } |
| } |
| |
| for (int i = 0; i < targetLineInfo.length; i++) { |
| if (info.matches(targetLineInfo[i])) { |
| return targetLineInfo[i]; |
| } |
| } |
| |
| return null; |
| } |
| |
| } |
