| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface DataLine extends Line
DataLine
adds media-related functionality to its
superinterface, {@link Line}
. This functionality includes
transport-control methods that start, stop, drain, and flush
the audio data that passes through the line. A data line can also
report the current position, volume, and audio format of the media.
Data lines are used for output of audio by means of the
subinterfaces {@link SourceDataLine}
or
{@link Clip}
, which allow an application program to write data. Similarly,
audio input is handled by the subinterface {@link TargetDataLine}
,
which allows data to be read.
A data line has an internal buffer in which
the incoming or outgoing audio data is queued. The
{@link #drain()}
method blocks until this internal buffer
becomes empty, usually because all queued data has been processed. The
{@link #flush()}
method discards any available queued data
from the internal buffer.
A data line produces {@link LineEvent.Type#START START}
and
{@link LineEvent.Type#STOP STOP}
events whenever
it begins or ceases active presentation or capture of data. These events
can be generated in response to specific requests, or as a result of
less direct state changes. For example, if {@link #start()}
is called
on an inactive data line, and data is available for capture or playback, a
START
event will be generated shortly, when data playback
or capture actually begins. Or, if the flow of data to an active data
line is constricted so that a gap occurs in the presentation of data,
a STOP
event is generated.
Mixers often support synchronized control of multiple data lines.
Synchronization can be established through the Mixer interface's
{@link Mixer#synchronize synchronize}
method.
See the description of the {@link Mixer Mixer}
interface
for a more complete description.
Nested Class Summary | |
---|---|
static class |
Besides the class information inherited from its superclass, DataLine.Info provides additional information specific to data lines. |
Nested classes/interfaces inherited from class javax.sound.sampled.Line |
---|
Line.Info |
Method Summary | |
---|---|
int |
Obtains the number of bytes of data currently available to the application for processing in the data line's internal buffer. |
void |
drain() Drains queued data from the line by continuing data I/O until the data line's internal buffer has been emptied. |
void |
flush() Flushes queued data from the line. |
int |
Obtains the maximum number of bytes of data that will fit in the data line's internal buffer. |
AudioFormat |
Obtains the current format (encoding, sample rate, number of channels, etc.) of the data line's audio data. |
int |
Obtains the current position in the audio data, in sample frames. |
float |
getLevel() Obtains the current volume level for the line. |
long |
Obtains the current position in the audio data, in sample frames. |
long |
Obtains the current position in the audio data, in microseconds. |
boolean |
isActive() Indicates whether the line is engaging in active I/O (such as playback or capture). |
boolean |
Indicates whether the line is running. |
void |
start() Allows a line to engage in data I/O. |
void |
stop() Stops the line. |
Methods inherited from class javax.sound.sampled.Line |
---|
addLineListener, close, getControl, getControls, getLineInfo, isControlSupported, isOpen, open, removeLineListener |
Method Detail |
---|
public int available()
Note that the units used are bytes, but will always correspond to an integral number of sample frames of audio data.
An application is guaranteed that a read or
write operation of up to the number of bytes returned from
available()
will not block; however, there is no guarantee
that attempts to read or write more data will block.
public void drain()
drain()
is invoked on a stopped line that has data in its queue, the method will
block until the line is running and the data queue becomes empty. If
drain()
is invoked by one thread, and another continues to
fill the data queue, the operation will not complete.
This method always returns when the data line is closed.
public void flush()
public int getBufferSize()
public AudioFormat getFormat()
If the line is not open and has never been opened, it returns
the default format. The default format is an implementation
specific audio format, or, if the DataLine.Info
object, which was used to retrieve this DataLine
,
specifies at least one fully qualified audio format, the
last one will be used as the default format. Opening the
line with a specific audio format (e.g.
{@link SourceDataLine#open(AudioFormat)}) will override the
default format.
public int getFramePosition()
getLongFramePosition
instead.
public float getLevel()
{@link AudioSystem#NOT_SPECIFIED}
public long getLongFramePosition()
public long getMicrosecondPosition()
public boolean isActive()
{@link LineEvent.Type#START START}
event to its listeners. Similarly, when
an active line becomes inactive, it sends a
{@link LineEvent.Type#STOP STOP}
event.
true
if the line is actively capturing or rendering
sound, otherwise false
public boolean isRunning()
false
.
An open line begins running when the first data is presented in response to an
invocation of the start
method, and continues
until presentation ceases in response to a call to stop
or
because playback completes.
true
if the line is running, otherwise false
public void start()
{@link LineEvent.Type#START START}
event is generated.
public void stop()
flush
method.
When audio capture or playback stops, a {@link LineEvent.Type#STOP STOP}
event is generated.
| |||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |