/*
* Copyright (c) 1999, 2014, 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 javax.sound.sampled;
import java.io.IOException;
/**
* The {@code Clip} interface represents a special kind of data line whose audio
* data can be loaded prior to playback, instead of being streamed in real time.
* <p>
* Because the data is pre-loaded and has a known length, you can set a clip to
* start playing at any position in its audio data. You can also create a loop,
* so that when the clip is played it will cycle repeatedly. Loops are specified
* with a starting and ending sample frame, along with the number of times that
* the loop should be played.
* <p>
* Clips may be obtained from a {@link Mixer} that supports lines of this type.
* Data is loaded into a clip when it is opened.
* <p>
* Playback of an audio clip may be started and stopped using the
* {@link #start start} and {@link #stop stop} methods. These methods do not
* reset the media position; {@code start} causes playback to continue from the
* position where playback was last stopped. To restart playback from the
* beginning of the clip's audio data, simply follow the invocation of
* {@code stop} with {@code setFramePosition(0)}, which rewinds the media to the
* beginning of the clip.
*
* @author Kara Kytle
* @since 1.3
*/
public interface Clip extends DataLine {
/**
* A value indicating that looping should continue indefinitely rather than
* complete after a specific number of loops.
*
* @see #loop
*/
int LOOP_CONTINUOUSLY = -1;
/**
* Opens the clip, meaning that it should acquire any required system
* resources and become operational. The clip is opened with the format and
* audio data indicated. If this operation succeeds, the line is marked as
* open and an {@link LineEvent.Type#OPEN OPEN} event is dispatched to the
* line's listeners.
* <p>
* Invoking this method on a line which is already open is illegal and may
* result in an {@code IllegalStateException}.
* <p>
* Note that some lines, once closed, cannot be reopened. Attempts to reopen
* such a line will always result in a {@code LineUnavailableException}.
*
* @param format the format of the supplied audio data
* @param data a byte array containing audio data to load into the clip
* @param offset the point at which to start copying, expressed in
* <em>bytes</em> from the beginning of the array
* @param bufferSize the number of <em>bytes</em> of data to load into the
* clip from the array
* @throws LineUnavailableException if the line cannot be opened due to
* resource restrictions
* @throws IllegalArgumentException if the buffer size does not represent an
* integral number of sample frames, or if {@code format} is not
* fully specified or invalid
* @throws IllegalStateException if the line is already open
* @throws SecurityException if the line cannot be opened due to security
* restrictions
* @see #close
* @see #isOpen
* @see LineListener
*/
void open(AudioFormat format, byte[] data, int offset, int bufferSize)
throws LineUnavailableException;
/**
* Opens the clip with the format and audio data present in the provided
* audio input stream. Opening a clip means that it should acquire any
* required system resources and become operational. If this operation input
* stream. If this operation succeeds, the line is marked open and an
* {@link LineEvent.Type#OPEN OPEN} event is dispatched to the line's
* listeners.
* <p>
* Invoking this method on a line which is already open is illegal and may
* result in an {@code IllegalStateException}.
* <p>
* Note that some lines, once closed, cannot be reopened. Attempts to reopen
* such a line will always result in a {@code LineUnavailableException}.
*
* @param stream an audio input stream from which audio data will be read
* into the clip
* @throws LineUnavailableException if the line cannot be opened due to
* resource restrictions
* @throws IOException if an I/O exception occurs during reading of the
* stream
* @throws IllegalArgumentException if the stream's audio format is not
* fully specified or invalid
* @throws IllegalStateException if the line is already open
* @throws SecurityException if the line cannot be opened due to security
* restrictions
* @see #close
* @see #isOpen
* @see LineListener
*/
void open(AudioInputStream stream)
throws LineUnavailableException, IOException;
/**
* Obtains the media length in sample frames.
*
* @return the media length, expressed in sample frames, or
* {@code AudioSystem.NOT_SPECIFIED} if the line is not open
* @see AudioSystem#NOT_SPECIFIED
*/
int getFrameLength();
/**
* Obtains the media duration in microseconds.
*
* @return the media duration, expressed in microseconds, or
* {@code AudioSystem.NOT_SPECIFIED} if the line is not open
* @see AudioSystem#NOT_SPECIFIED
*/
long getMicrosecondLength();
/**
* Sets the media position in sample frames. The position is zero-based; the
* first frame is frame number zero. When the clip begins playing the next
* time, it will start by playing the frame at this position.
* <p>
* To obtain the current position in sample frames, use the
* {@link DataLine#getFramePosition getFramePosition} method of
* {@code DataLine}.
*
* @param frames the desired new media position, expressed in sample frames
*/
void setFramePosition(int frames);
/**
* Sets the media position in microseconds. When the clip begins playing the
* next time, it will start at this position. The level of precision is not
* guaranteed. For example, an implementation might calculate the
* microsecond position from the current frame position and the audio sample
* frame rate. The precision in microseconds would then be limited to the
* number of microseconds per sample frame.
* <p>
* To obtain the current position in microseconds, use the
* {@link DataLine#getMicrosecondPosition getMicrosecondPosition} method of
* {@code DataLine}.
*
* @param microseconds the desired new media position, expressed in
* microseconds
*/
void setMicrosecondPosition(long microseconds);
/**
* Sets the first and last sample frames that will be played in the loop.
* The ending point must be greater than or equal to the starting point, and
* both must fall within the size of the loaded media. A value of 0 for
* the starting point means the beginning of the loaded media. Similarly, a
* value of -1 for the ending point indicates the last frame of the media.
*
* @param start the loop's starting position, in sample frames (zero-based)
* @param end the loop's ending position, in sample frames (zero-based),
* or -1 to indicate the final frame
* @throws IllegalArgumentException if the requested loop points cannot be
* set, usually because one or both falls outside the media's
* duration or because the ending point is before the starting point
*/
void setLoopPoints(int start, int end);
/**
* Starts looping playback from the current position. Playback will continue
* to the loop's end point, then loop back to the loop start point
* {@code count} times, and finally continue playback to the end of the
* clip.
* <p>
* If the current position when this method is invoked is greater than the
* loop end point, playback simply continues to the end of the clip without
* looping.
* <p>
* A {@code count} value of 0 indicates that any current looping should
* cease and playback should continue to the end of the clip. The behavior
* is undefined when this method is invoked with any other value during a
* loop operation.
* <p>
* If playback is stopped during looping, the current loop status is
* cleared; the behavior of subsequent loop and start requests is not
* affected by an interrupted loop operation.
*
* @param count the number of times playback should loop back from the
* loop's end position to the loop's start position, or
* {@link #LOOP_CONTINUOUSLY} to indicate that looping should
* continue until interrupted
*/
void loop(int count);
}