590 lines
24 KiB
Java
590 lines
24 KiB
Java
/*
|
|
* 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.io.IOException;
|
|
import java.util.Vector;
|
|
|
|
import javax.sound.sampled.AudioFormat;
|
|
import javax.sound.sampled.AudioInputStream;
|
|
import javax.sound.sampled.AudioSystem;
|
|
|
|
|
|
/**
|
|
* Converts among signed/unsigned and little/big endianness of sampled.
|
|
*
|
|
* @author Jan Borgersen
|
|
*/
|
|
public final class PCMtoPCMCodec extends SunCodec {
|
|
|
|
|
|
private static final AudioFormat.Encoding[] inputEncodings = {
|
|
AudioFormat.Encoding.PCM_SIGNED,
|
|
AudioFormat.Encoding.PCM_UNSIGNED,
|
|
};
|
|
|
|
private static final AudioFormat.Encoding[] outputEncodings = {
|
|
AudioFormat.Encoding.PCM_SIGNED,
|
|
AudioFormat.Encoding.PCM_UNSIGNED,
|
|
};
|
|
|
|
|
|
|
|
private static final int tempBufferSize = 64;
|
|
private byte tempBuffer [] = null;
|
|
|
|
/**
|
|
* Constructs a new PCMtoPCM codec object.
|
|
*/
|
|
public PCMtoPCMCodec() {
|
|
|
|
super( inputEncodings, outputEncodings);
|
|
}
|
|
|
|
// NEW CODE
|
|
|
|
|
|
/**
|
|
*/
|
|
public AudioFormat.Encoding[] getTargetEncodings(AudioFormat sourceFormat){
|
|
|
|
if( sourceFormat.getEncoding().equals( AudioFormat.Encoding.PCM_SIGNED ) ||
|
|
sourceFormat.getEncoding().equals( AudioFormat.Encoding.PCM_UNSIGNED ) ) {
|
|
|
|
AudioFormat.Encoding encs[] = new AudioFormat.Encoding[2];
|
|
encs[0] = AudioFormat.Encoding.PCM_SIGNED;
|
|
encs[1] = AudioFormat.Encoding.PCM_UNSIGNED;
|
|
return encs;
|
|
} else {
|
|
return new AudioFormat.Encoding[0];
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
public AudioFormat[] getTargetFormats(AudioFormat.Encoding targetEncoding, AudioFormat sourceFormat){
|
|
|
|
// filter out targetEncoding from the old getOutputFormats( sourceFormat ) method
|
|
|
|
AudioFormat[] formats = getOutputFormats( sourceFormat );
|
|
Vector newFormats = new Vector();
|
|
for(int i=0; i<formats.length; i++ ) {
|
|
if( formats[i].getEncoding().equals( targetEncoding ) ) {
|
|
newFormats.addElement( formats[i] );
|
|
}
|
|
}
|
|
|
|
AudioFormat[] formatArray = new AudioFormat[newFormats.size()];
|
|
|
|
for (int i = 0; i < formatArray.length; i++) {
|
|
formatArray[i] = (AudioFormat)(newFormats.elementAt(i));
|
|
}
|
|
|
|
return formatArray;
|
|
}
|
|
|
|
|
|
/**
|
|
*/
|
|
public AudioInputStream getAudioInputStream(AudioFormat.Encoding targetEncoding, AudioInputStream sourceStream) {
|
|
|
|
if( isConversionSupported(targetEncoding, sourceStream.getFormat()) ) {
|
|
|
|
AudioFormat sourceFormat = sourceStream.getFormat();
|
|
AudioFormat targetFormat = new AudioFormat( targetEncoding,
|
|
sourceFormat.getSampleRate(),
|
|
sourceFormat.getSampleSizeInBits(),
|
|
sourceFormat.getChannels(),
|
|
sourceFormat.getFrameSize(),
|
|
sourceFormat.getFrameRate(),
|
|
sourceFormat.isBigEndian() );
|
|
|
|
return getAudioInputStream( targetFormat, sourceStream );
|
|
|
|
} else {
|
|
throw new IllegalArgumentException("Unsupported conversion: " + sourceStream.getFormat().toString() + " to " + targetEncoding.toString() );
|
|
}
|
|
|
|
}
|
|
/**
|
|
* use old code
|
|
*/
|
|
public AudioInputStream getAudioInputStream(AudioFormat targetFormat, AudioInputStream sourceStream){
|
|
|
|
return getConvertedStream( targetFormat, sourceStream );
|
|
}
|
|
|
|
|
|
|
|
|
|
// OLD CODE
|
|
|
|
/**
|
|
* Opens the codec with the specified parameters.
|
|
* @param stream stream from which data to be processed should be read
|
|
* @param outputFormat desired data format of the stream after processing
|
|
* @return stream from which processed data may be read
|
|
* @throws IllegalArgumentException if the format combination supplied is
|
|
* not supported.
|
|
*/
|
|
/* public AudioInputStream getConvertedStream(AudioFormat outputFormat, AudioInputStream stream) {*/
|
|
private AudioInputStream getConvertedStream(AudioFormat outputFormat, AudioInputStream stream) {
|
|
|
|
AudioInputStream cs = null;
|
|
|
|
AudioFormat inputFormat = stream.getFormat();
|
|
|
|
if( inputFormat.matches(outputFormat) ) {
|
|
|
|
cs = stream;
|
|
} else {
|
|
|
|
cs = (AudioInputStream) (new PCMtoPCMCodecStream(stream, outputFormat));
|
|
tempBuffer = new byte[tempBufferSize];
|
|
}
|
|
return cs;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Obtains the set of output formats supported by the codec
|
|
* given a particular input format.
|
|
* If no output formats are supported for this input format,
|
|
* returns an array of length 0.
|
|
* @return array of supported output formats.
|
|
*/
|
|
/* public AudioFormat[] getOutputFormats(AudioFormat inputFormat) { */
|
|
private AudioFormat[] getOutputFormats(AudioFormat inputFormat) {
|
|
|
|
Vector formats = new Vector();
|
|
AudioFormat format;
|
|
|
|
int sampleSize = inputFormat.getSampleSizeInBits();
|
|
boolean isBigEndian = inputFormat.isBigEndian();
|
|
|
|
|
|
if ( sampleSize==8 ) {
|
|
if ( AudioFormat.Encoding.PCM_SIGNED.equals(inputFormat.getEncoding()) ) {
|
|
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
}
|
|
|
|
if ( AudioFormat.Encoding.PCM_UNSIGNED.equals(inputFormat.getEncoding()) ) {
|
|
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
}
|
|
|
|
} else if ( sampleSize==16 ) {
|
|
|
|
if ( AudioFormat.Encoding.PCM_SIGNED.equals(inputFormat.getEncoding()) && isBigEndian ) {
|
|
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
true );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
}
|
|
|
|
if ( AudioFormat.Encoding.PCM_UNSIGNED.equals(inputFormat.getEncoding()) && isBigEndian ) {
|
|
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
true );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
}
|
|
|
|
if ( AudioFormat.Encoding.PCM_SIGNED.equals(inputFormat.getEncoding()) && !isBigEndian ) {
|
|
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
true );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
true );
|
|
formats.addElement(format);
|
|
}
|
|
|
|
if ( AudioFormat.Encoding.PCM_UNSIGNED.equals(inputFormat.getEncoding()) && !isBigEndian ) {
|
|
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
false );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_UNSIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
true );
|
|
formats.addElement(format);
|
|
format = new AudioFormat(AudioFormat.Encoding.PCM_SIGNED,
|
|
inputFormat.getSampleRate(),
|
|
inputFormat.getSampleSizeInBits(),
|
|
inputFormat.getChannels(),
|
|
inputFormat.getFrameSize(),
|
|
inputFormat.getFrameRate(),
|
|
true );
|
|
formats.addElement(format);
|
|
}
|
|
}
|
|
AudioFormat[] formatArray;
|
|
|
|
synchronized(formats) {
|
|
|
|
formatArray = new AudioFormat[formats.size()];
|
|
|
|
for (int i = 0; i < formatArray.length; i++) {
|
|
|
|
formatArray[i] = (AudioFormat)(formats.elementAt(i));
|
|
}
|
|
}
|
|
|
|
return formatArray;
|
|
}
|
|
|
|
|
|
class PCMtoPCMCodecStream extends AudioInputStream {
|
|
|
|
private final int PCM_SWITCH_SIGNED_8BIT = 1;
|
|
private final int PCM_SWITCH_ENDIAN = 2;
|
|
private final int PCM_SWITCH_SIGNED_LE = 3;
|
|
private final int PCM_SWITCH_SIGNED_BE = 4;
|
|
private final int PCM_UNSIGNED_LE2SIGNED_BE = 5;
|
|
private final int PCM_SIGNED_LE2UNSIGNED_BE = 6;
|
|
private final int PCM_UNSIGNED_BE2SIGNED_LE = 7;
|
|
private final int PCM_SIGNED_BE2UNSIGNED_LE = 8;
|
|
|
|
private final int sampleSizeInBytes;
|
|
private int conversionType = 0;
|
|
|
|
|
|
PCMtoPCMCodecStream(AudioInputStream stream, AudioFormat outputFormat) {
|
|
|
|
super(stream, outputFormat, -1);
|
|
|
|
int sampleSizeInBits = 0;
|
|
AudioFormat.Encoding inputEncoding = null;
|
|
AudioFormat.Encoding outputEncoding = null;
|
|
boolean inputIsBigEndian;
|
|
boolean outputIsBigEndian;
|
|
|
|
AudioFormat inputFormat = stream.getFormat();
|
|
|
|
// throw an IllegalArgumentException if not ok
|
|
if ( ! (isConversionSupported(inputFormat, outputFormat)) ) {
|
|
|
|
throw new IllegalArgumentException("Unsupported conversion: " + inputFormat.toString() + " to " + outputFormat.toString());
|
|
}
|
|
|
|
inputEncoding = inputFormat.getEncoding();
|
|
outputEncoding = outputFormat.getEncoding();
|
|
inputIsBigEndian = inputFormat.isBigEndian();
|
|
outputIsBigEndian = outputFormat.isBigEndian();
|
|
sampleSizeInBits = inputFormat.getSampleSizeInBits();
|
|
sampleSizeInBytes = sampleSizeInBits/8;
|
|
|
|
// determine conversion to perform
|
|
|
|
if( sampleSizeInBits==8 ) {
|
|
if( AudioFormat.Encoding.PCM_UNSIGNED.equals(inputEncoding) &&
|
|
AudioFormat.Encoding.PCM_SIGNED.equals(outputEncoding) ) {
|
|
conversionType = PCM_SWITCH_SIGNED_8BIT;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_SWITCH_SIGNED_8BIT");
|
|
|
|
} else if( AudioFormat.Encoding.PCM_SIGNED.equals(inputEncoding) &&
|
|
AudioFormat.Encoding.PCM_UNSIGNED.equals(outputEncoding) ) {
|
|
conversionType = PCM_SWITCH_SIGNED_8BIT;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_SWITCH_SIGNED_8BIT");
|
|
}
|
|
} else {
|
|
|
|
if( inputEncoding.equals(outputEncoding) && (inputIsBigEndian != outputIsBigEndian) ) {
|
|
|
|
conversionType = PCM_SWITCH_ENDIAN;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_SWITCH_ENDIAN");
|
|
|
|
|
|
} else if (AudioFormat.Encoding.PCM_UNSIGNED.equals(inputEncoding) && !inputIsBigEndian &&
|
|
AudioFormat.Encoding.PCM_SIGNED.equals(outputEncoding) && outputIsBigEndian) {
|
|
|
|
conversionType = PCM_UNSIGNED_LE2SIGNED_BE;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_UNSIGNED_LE2SIGNED_BE");
|
|
|
|
} else if (AudioFormat.Encoding.PCM_SIGNED.equals(inputEncoding) && !inputIsBigEndian &&
|
|
AudioFormat.Encoding.PCM_UNSIGNED.equals(outputEncoding) && outputIsBigEndian) {
|
|
|
|
conversionType = PCM_SIGNED_LE2UNSIGNED_BE;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_SIGNED_LE2UNSIGNED_BE");
|
|
|
|
} else if (AudioFormat.Encoding.PCM_UNSIGNED.equals(inputEncoding) && inputIsBigEndian &&
|
|
AudioFormat.Encoding.PCM_SIGNED.equals(outputEncoding) && !outputIsBigEndian) {
|
|
|
|
conversionType = PCM_UNSIGNED_BE2SIGNED_LE;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_UNSIGNED_BE2SIGNED_LE");
|
|
|
|
} else if (AudioFormat.Encoding.PCM_SIGNED.equals(inputEncoding) && inputIsBigEndian &&
|
|
AudioFormat.Encoding.PCM_UNSIGNED.equals(outputEncoding) && !outputIsBigEndian) {
|
|
|
|
conversionType = PCM_SIGNED_BE2UNSIGNED_LE;
|
|
if(Printer.debug) Printer.debug("PCMtoPCMCodecStream: conversionType = PCM_SIGNED_BE2UNSIGNED_LE");
|
|
|
|
}
|
|
}
|
|
|
|
// set the audio stream length in frames if we know it
|
|
|
|
frameSize = inputFormat.getFrameSize();
|
|
if( frameSize == AudioSystem.NOT_SPECIFIED ) {
|
|
frameSize=1;
|
|
}
|
|
if( stream instanceof AudioInputStream ) {
|
|
frameLength = stream.getFrameLength();
|
|
} else {
|
|
frameLength = AudioSystem.NOT_SPECIFIED;
|
|
}
|
|
|
|
// set framePos to zero
|
|
framePos = 0;
|
|
|
|
}
|
|
|
|
/**
|
|
* Note that this only works for sign conversions.
|
|
* Other conversions require a read of at least 2 bytes.
|
|
*/
|
|
|
|
public int read() throws IOException {
|
|
|
|
// $$jb: do we want to implement this function?
|
|
|
|
int temp;
|
|
byte tempbyte;
|
|
|
|
if( frameSize==1 ) {
|
|
if( conversionType == PCM_SWITCH_SIGNED_8BIT ) {
|
|
temp = super.read();
|
|
|
|
if( temp < 0 ) return temp; // EOF or error
|
|
|
|
tempbyte = (byte) (temp & 0xf);
|
|
tempbyte = (tempbyte >= 0) ? (byte)(0x80 | tempbyte) : (byte)(0x7F & tempbyte);
|
|
temp = (int) tempbyte & 0xf;
|
|
|
|
return temp;
|
|
|
|
} else {
|
|
// $$jb: what to return here?
|
|
throw new IOException("cannot read a single byte if frame size > 1");
|
|
}
|
|
} else {
|
|
throw new IOException("cannot read a single byte if frame size > 1");
|
|
}
|
|
}
|
|
|
|
|
|
public int read(byte[] b) throws IOException {
|
|
|
|
return read(b, 0, b.length);
|
|
}
|
|
|
|
public int read(byte[] b, int off, int len) throws IOException {
|
|
|
|
|
|
int i;
|
|
|
|
// don't read fractional frames
|
|
if ( len%frameSize != 0 ) {
|
|
len -= (len%frameSize);
|
|
}
|
|
// don't read past our own set length
|
|
if( (frameLength!=AudioSystem.NOT_SPECIFIED) && ( (len/frameSize) >(frameLength-framePos)) ) {
|
|
len = (int)(frameLength-framePos) * frameSize;
|
|
}
|
|
|
|
int readCount = super.read(b, off, len);
|
|
byte tempByte;
|
|
|
|
if(readCount<0) { // EOF or error
|
|
return readCount;
|
|
}
|
|
|
|
// now do the conversions
|
|
|
|
switch( conversionType ) {
|
|
|
|
case PCM_SWITCH_SIGNED_8BIT:
|
|
switchSigned8bit(b,off,len,readCount);
|
|
break;
|
|
|
|
case PCM_SWITCH_ENDIAN:
|
|
switchEndian(b,off,len,readCount);
|
|
break;
|
|
|
|
case PCM_SWITCH_SIGNED_LE:
|
|
switchSignedLE(b,off,len,readCount);
|
|
break;
|
|
|
|
case PCM_SWITCH_SIGNED_BE:
|
|
switchSignedBE(b,off,len,readCount);
|
|
break;
|
|
|
|
case PCM_UNSIGNED_LE2SIGNED_BE:
|
|
case PCM_SIGNED_LE2UNSIGNED_BE:
|
|
switchSignedLE(b,off,len,readCount);
|
|
switchEndian(b,off,len,readCount);
|
|
break;
|
|
|
|
case PCM_UNSIGNED_BE2SIGNED_LE:
|
|
case PCM_SIGNED_BE2UNSIGNED_LE:
|
|
switchSignedBE(b,off,len,readCount);
|
|
switchEndian(b,off,len,readCount);
|
|
break;
|
|
|
|
default:
|
|
// do nothing
|
|
}
|
|
|
|
// we've done the conversion, just return the readCount
|
|
return readCount;
|
|
|
|
}
|
|
|
|
private void switchSigned8bit(byte[] b, int off, int len, int readCount) {
|
|
|
|
for(int i=off; i < (off+readCount); i++) {
|
|
b[i] = (b[i] >= 0) ? (byte)(0x80 | b[i]) : (byte)(0x7F & b[i]);
|
|
}
|
|
}
|
|
|
|
private void switchSignedBE(byte[] b, int off, int len, int readCount) {
|
|
|
|
for(int i=off; i < (off+readCount); i+= sampleSizeInBytes ) {
|
|
b[i] = (b[i] >= 0) ? (byte)(0x80 | b[i]) : (byte)(0x7F & b[i]);
|
|
}
|
|
}
|
|
|
|
private void switchSignedLE(byte[] b, int off, int len, int readCount) {
|
|
|
|
for(int i=(off+sampleSizeInBytes-1); i < (off+readCount); i+= sampleSizeInBytes ) {
|
|
b[i] = (b[i] >= 0) ? (byte)(0x80 | b[i]) : (byte)(0x7F & b[i]);
|
|
}
|
|
}
|
|
|
|
private void switchEndian(byte[] b, int off, int len, int readCount) {
|
|
|
|
if(sampleSizeInBytes == 2) {
|
|
for(int i=off; i < (off+readCount); i += sampleSizeInBytes ) {
|
|
byte temp;
|
|
temp = b[i];
|
|
b[i] = b[i+1];
|
|
b[i+1] = temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
} // end class PCMtoPCMCodecStream
|
|
|
|
} // end class PCMtoPCMCodec
|