Back to index...

	/*
	* 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

Back to index...