jdk-sandbox: comparison jdk/src/java.desktop/share/classes/com/sun/media/sound/AudioFloatFormatConverter.java

equal deleted inserted replaced

-:e97e9982be6d
+:afabcfc2f3ef
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Objects;
 import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioFormat.Encoding;
 import javax.sound.sampled.AudioInputStream;
 import javax.sound.sampled.AudioSystem;
-import javax.sound.sampled.AudioFormat.Encoding;
 import javax.sound.sampled.spi.FormatConversionProvider;
 /**
 * This class is used to convert between 8,16,24,32 bit signed/unsigned
 * big/litle endian fixed/floating stereo/mono/multi-channel audio streams and
 this.stream = stream;
 converter = AudioFloatConverter.getConverter(targetFormat);
 fsize = ((targetFormat.getSampleSizeInBits() + 7) / 8);
 }
+@Override
 public int read() throws IOException {
 byte[] b = new byte[1];
 int ret = read(b);
 if (ret < 0)
 return ret;
 return b[0] & 0xFF;
 }
+@Override
 public int read(byte[] b, int off, int len) throws IOException {
 int flen = len / fsize;
 if (readfloatbuffer == null || readfloatbuffer.length < flen)
 readfloatbuffer = new float[flen];
 return ret;
 converter.toByteArray(readfloatbuffer, 0, ret, b, off);
 return ret * fsize;
 }
+@Override
 public int available() throws IOException {
 int ret = stream.available();
 if (ret < 0)
 return ret;
 return ret * fsize;
 }
+@Override
 public void close() throws IOException {
 stream.close();
 }
+@Override
 public synchronized void mark(int readlimit) {
 stream.mark(readlimit * fsize);
 }
+@Override
 public boolean markSupported() {
 return stream.markSupported();
 }
+@Override
 public synchronized void reset() throws IOException {
 stream.reset();
 }
+@Override
 public long skip(long n) throws IOException {
 long ret = stream.skip(n / fsize);
 if (ret < 0)
 return ret;
 return ret * fsize;
 targetChannels, (format.getFrameSize() / sourceChannels)
 * targetChannels, format.getFrameRate(), format
 .isBigEndian());
 }
+@Override
 public int available() throws IOException {
 return (ais.available() / sourceChannels) * targetChannels;
 }
+@Override
 public void close() throws IOException {
 ais.close();
 }
+@Override
 public AudioFormat getFormat() {
 return targetFormat;
 }
+@Override
 public long getFrameLength() {
 return ais.getFrameLength();
 }
+@Override
 public void mark(int readlimit) {
 ais.mark((readlimit / targetChannels) * sourceChannels);
 }
+@Override
 public boolean markSupported() {
 return ais.markSupported();
 }
+@Override
 public int read(float[] b, int off, int len) throws IOException {
 int len2 = (len / targetChannels) * sourceChannels;
 if (conversion_buffer == null || conversion_buffer.length < len2)
 conversion_buffer = new float[len2];
 int ret = ais.read(conversion_buffer, 0, len2);
 }
 }
 return (ret / sourceChannels) * targetChannels;
 }
+@Override
 public void reset() throws IOException {
 ais.reset();
 }
+@Override
 public long skip(long len) throws IOException {
 long ret = ais.skip((len / targetChannels) * sourceChannels);
 if (ret < 0)
 return ret;
 return (ret / sourceChannels) * targetChannels;
 ibuffer2 = new float[nrofchannels * buffer_len];
 ibuffer_index = buffer_len + pad;
 ibuffer_len = buffer_len;
 }
+@Override
 public int available() throws IOException {
 return 0;
 }
+@Override
 public void close() throws IOException {
 ais.close();
 }
+@Override
 public AudioFormat getFormat() {
 return targetFormat;
 }
+@Override
 public long getFrameLength() {
 return AudioSystem.NOT_SPECIFIED; // ais.getFrameLength();
 }
+@Override
 public void mark(int readlimit) {
 ais.mark((int) (readlimit * pitch[0]));
 mark_ibuffer_index = ibuffer_index;
 mark_ibuffer_len = ibuffer_len;
 if (mark_ibuffer == null) {
 to[i] = from[i];
 }
 }
 }
+@Override
 public boolean markSupported() {
 return ais.markSupported();
 }
 private void readNextBuffer() throws IOException {
 }
 }
 }
+@Override
 public int read(float[] b, int off, int len) throws IOException {
 if (cbuffer == null || cbuffer[0].length < len / nrofchannels) {
 cbuffer = new float[nrofchannels][len / nrofchannels];
 }
 }
 }
 return len - remain * nrofchannels;
 }
+@Override
 public void reset() throws IOException {
 ais.reset();
 if (mark_ibuffer == null)
 return;
 ibuffer_index = mark_ibuffer_index;
 }
 }
 }
+@Override
 public long skip(long len) throws IOException {
 if (len < 0)
 return 0;
 if (skipbuffer == null)
 skipbuffer = new float[1024 * targetFormat.getFrameSize()];
 private final Encoding[] formats = {Encoding.PCM_SIGNED,
 Encoding.PCM_UNSIGNED,
 Encoding.PCM_FLOAT};
+@Override
 public AudioInputStream getAudioInputStream(Encoding targetEncoding,
 AudioInputStream sourceStream) {
 if (!isConversionSupported(targetEncoding, sourceStream.getFormat())) {
 throw new IllegalArgumentException(
 "Unsupported conversion: " + sourceStream.getFormat()
 .toString() + " to " + targetEncoding.toString());
 }
 AudioFormat targetFormat = new AudioFormat(encoding, samplerate, bits,
 channels, channels * bits / 8, samplerate, bigendian);
 return getAudioInputStream(targetFormat, sourceStream);
 }
+@Override
 public AudioInputStream getAudioInputStream(AudioFormat targetFormat,
 AudioInputStream sourceStream) {
 if (!isConversionSupported(targetFormat, sourceStream.getFormat()))
 throw new IllegalArgumentException("Unsupported conversion: "
 + sourceStream.getFormat().toString() + " to "
 + targetFormat.toString());
 return getAudioInputStream(targetFormat, AudioFloatInputStream
 return new AudioInputStream(new AudioFloatFormatConverterInputStream(
 targetFormat, sourceStream), targetFormat, sourceStream
 .getFrameLength());
 }
+@Override
 public Encoding[] getSourceEncodings() {
 return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED,
 Encoding.PCM_FLOAT };
 }
+@Override
 public Encoding[] getTargetEncodings() {
 return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED,
 Encoding.PCM_FLOAT };
 }
+@Override
 public Encoding[] getTargetEncodings(AudioFormat sourceFormat) {
 if (AudioFloatConverter.getConverter(sourceFormat) == null)
 return new Encoding[0];
 return new Encoding[] { Encoding.PCM_SIGNED, Encoding.PCM_UNSIGNED,
 Encoding.PCM_FLOAT };
 }
+@Override
 public AudioFormat[] getTargetFormats(Encoding targetEncoding,
 AudioFormat sourceFormat) {
 Objects.requireNonNull(targetEncoding);
 if (AudioFloatConverter.getConverter(sourceFormat) == null)
 return new AudioFormat[0];
 int channels = sourceFormat.getChannels();
-ArrayList<AudioFormat> formats = new ArrayList<AudioFormat>();
+ArrayList<AudioFormat> formats = new ArrayList<>();
 if (targetEncoding.equals(Encoding.PCM_SIGNED))
 formats.add(new AudioFormat(Encoding.PCM_SIGNED,
 AudioSystem.NOT_SPECIFIED, 8, channels, channels,
 AudioSystem.NOT_SPECIFIED, false));
 }
 return formats.toArray(new AudioFormat[formats.size()]);
 }
+@Override
 public boolean isConversionSupported(AudioFormat targetFormat,
 AudioFormat sourceFormat) {
 Objects.requireNonNull(targetFormat);
 if (AudioFloatConverter.getConverter(sourceFormat) == null)
 return false;
 if (AudioFloatConverter.getConverter(targetFormat) == null)
 return false;
 if (targetFormat.getChannels() <= 0)
 return false;
 return true;
 }
+@Override
 public boolean isConversionSupported(Encoding targetEncoding,
 AudioFormat sourceFormat) {
 Objects.requireNonNull(targetEncoding);
 if (AudioFloatConverter.getConverter(sourceFormat) == null)
 return false;
 for (int i = 0; i < formats.length; i++) {
 if (targetEncoding.equals(formats[i]))

changeset 40444	afabcfc2f3ef
parent 35684	900e28dae561
child 41772	f26d4b69228b