public final class ResampleInputStream extends InputStream
Constructor and Description |
---|
ResampleInputStream(InputStream inputStream,
int rateIn,
int rateOut)
Create a new ResampleInputStream, which converts the sample rate
|
Modifier and Type | Method and Description |
---|---|
void |
close()
Closes this stream.
|
protected void |
finalize()
Invoked when the garbage collector has detected that this instance is no longer reachable.
|
int |
read()
Reads a single byte from this stream and returns it as an integer in the
range from 0 to 255.
|
int |
read(byte[] b)
Equivalent to
read(buffer, 0, buffer.length) . |
int |
read(byte[] b,
int offset,
int length)
Reads at most
length bytes from this stream and stores them in
the byte array b starting at offset . |
available, mark, markSupported, reset, skip
public ResampleInputStream(InputStream inputStream, int rateIn, int rateOut)
inputStream
- InputStream containing 16 bit PCM.rateIn
- the input sample rate.rateOut
- the output sample rate.
This only handles rateIn == rateOut / 2 for the moment.public int read() throws IOException
InputStream
read
in class InputStream
IOException
- if the stream is closed or another IOException occurs.public int read(byte[] b) throws IOException
InputStream
read(buffer, 0, buffer.length)
.read
in class InputStream
IOException
public int read(byte[] b, int offset, int length) throws IOException
InputStream
length
bytes from this stream and stores them in
the byte array b
starting at offset
.read
in class InputStream
b
- the byte array in which to store the bytes read.offset
- the initial position in buffer
to store the bytes read
from this stream.length
- the maximum number of bytes to store in b
.IOException
- if the stream is closed or another IOException occurs.public void close() throws IOException
InputStream
close
in interface Closeable
close
in interface AutoCloseable
close
in class InputStream
IOException
- if an error occurs while closing this stream.protected void finalize() throws Throwable
Object
Note that objects that override finalize
are significantly more expensive than
objects that don't. Finalizers may be run a long time after the object is no longer
reachable, depending on memory pressure, so it's a bad idea to rely on them for cleanup.
Note also that finalizers are run on a single VM-wide finalizer thread,
so doing blocking work in a finalizer is a bad idea. A finalizer is usually only necessary
for a class that has a native peer and needs to call a native method to destroy that peer.
Even then, it's better to provide an explicit close
method (and implement
Closeable
), and insist that callers manually dispose of instances. This
works well for something like files, but less well for something like a BigInteger
where typical calling code would have to deal with lots of temporaries. Unfortunately,
code that creates lots of temporaries is the worst kind of code from the point of view of
the single finalizer thread.
If you must use finalizers, consider at least providing your own
ReferenceQueue
and having your own thread process that queue.
Unlike constructors, finalizers are not automatically chained. You are responsible for
calling super.finalize()
yourself.
Uncaught exceptions thrown by finalizers are ignored and do not terminate the finalizer thread. See Effective Java Item 7, "Avoid finalizers" for more.