diff options
Diffstat (limited to 'libjava/classpath/gnu/javax')
35 files changed, 7321 insertions, 341 deletions
diff --git a/libjava/classpath/gnu/javax/crypto/DiffieHellmanImpl.java b/libjava/classpath/gnu/javax/crypto/DiffieHellmanImpl.java new file mode 100644 index 00000000000..4797af7cf79 --- /dev/null +++ b/libjava/classpath/gnu/javax/crypto/DiffieHellmanImpl.java @@ -0,0 +1,159 @@ +/* DiffieHellmanImpl.java -- implementation of the Diffie-Hellman key agreement. + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.crypto; + +import gnu.java.security.provider.GnuDHPublicKey; + +import java.math.BigInteger; + +import java.security.Key; +import java.security.InvalidKeyException; +import java.security.PrivateKey; +import java.security.PublicKey; +import java.security.SecureRandom; +import java.security.spec.AlgorithmParameterSpec; + +import javax.crypto.KeyAgreementSpi; +import javax.crypto.SecretKey; +import javax.crypto.interfaces.DHPrivateKey; +import javax.crypto.interfaces.DHPublicKey; +import javax.crypto.spec.DHParameterSpec; +import javax.crypto.spec.SecretKeySpec; + +/** + * The Diffie-Hellman key agreement. + * + * @author Casey Marshall (csm@gnu.org) + */ +public final class DiffieHellmanImpl extends KeyAgreementSpi +{ + + /** The private key being used for this agreement. */ + private DHPrivateKey key; + + /** The current result. */ + private BigInteger result; + + /** True if the caller told us we are done. */ + private boolean last_phase_done; + + /** Trivial default constructor. */ + public DiffieHellmanImpl () + { + key = null; + result = null; + last_phase_done = false; + } + + // KeyAgreementSpi methods. + + protected Key engineDoPhase (final Key incoming, final boolean lastPhase) + throws InvalidKeyException + { + if (key == null) + throw new IllegalStateException ("not initialized"); + if (last_phase_done) + throw new IllegalStateException ("last phase already done"); + + if (!(incoming instanceof DHPublicKey)) + throw new InvalidKeyException ("expecting javax.crypto.interfaces.DHPublicKey"); + DHPublicKey pub = (DHPublicKey) incoming; + DHParameterSpec s1 = key.getParams(); + DHParameterSpec s2 = pub.getParams(); + if (!s1.getG().equals (s2.getG()) + || !s1.getP().equals (s2.getP()) + || s1.getL() != s2.getL()) + throw new InvalidKeyException ("supplied key is not compatible"); + + result = pub.getY().modPow (key.getX(), s1.getP()); + if (lastPhase) + { + last_phase_done = true; + return null; + } + + throw new IllegalArgumentException ("only supports two-party Diffie Hellman"); + } + + protected byte[] engineGenerateSecret () + { + if (result == null || !last_phase_done) + throw new IllegalStateException ("not finished"); + + byte[] buf = result.toByteArray (); + if (buf[0] == 0x00) + { + byte[] buf2 = new byte[buf.length - 1]; + System.arraycopy (buf, 1, buf2, 0, buf2.length); + buf = buf2; + } + return buf; + } + + protected int engineGenerateSecret (final byte[] secret, final int offset) + { + byte[] s = engineGenerateSecret(); + System.arraycopy (s, 0, secret, offset, s.length); + return s.length; + } + + protected SecretKey engineGenerateSecret (final String algorithm) + throws InvalidKeyException + { + byte[] s = engineGenerateSecret(); + return new SecretKeySpec (s, algorithm); + } + + protected void engineInit (final Key key, final SecureRandom random) + throws InvalidKeyException + { + if (!(key instanceof DHPrivateKey)) + throw new InvalidKeyException ("not a javax.crypto.interfaces.DHPrivateKey"); + this.key = (DHPrivateKey) key; + result = null; + last_phase_done = false; + } + + protected void engineInit (final Key key, final AlgorithmParameterSpec params, + final SecureRandom random) + throws InvalidKeyException + { + engineInit (key, random); + } +} diff --git a/libjava/classpath/gnu/javax/crypto/GnuDHPrivateKey.java b/libjava/classpath/gnu/javax/crypto/GnuDHPrivateKey.java new file mode 100644 index 00000000000..f70cd7d2aec --- /dev/null +++ b/libjava/classpath/gnu/javax/crypto/GnuDHPrivateKey.java @@ -0,0 +1,90 @@ +/* GnuDHPrivateKey.java -- a Diffie-Hellman private key. + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.crypto; + +import java.math.BigInteger; + +import javax.crypto.interfaces.DHKey; +import javax.crypto.interfaces.DHPrivateKey; +import javax.crypto.spec.DHParameterSpec; + +/** + * A Diffie-Hellman private key. + * + * @author Casey Marshall (csm@gnu.org) + */ +public class GnuDHPrivateKey implements DHPrivateKey +{ + + private final BigInteger x; + private final DHParameterSpec params; + + public GnuDHPrivateKey (final BigInteger x, final DHParameterSpec params) + { + x.getClass (); + params.getClass (); + this.x = x; + this.params = params; + } + + public DHParameterSpec getParams() + { + return params; + } + + public String getAlgorithm() + { + return "DiffieHellman"; + } + + public String getFormat () + { + return "NONE"; + } + + public byte[] getEncoded () + { + return null; + } + + public BigInteger getX () + { + return x; + } +} diff --git a/libjava/classpath/gnu/javax/crypto/RSACipherImpl.java b/libjava/classpath/gnu/javax/crypto/RSACipherImpl.java new file mode 100644 index 00000000000..0a4c29db6f1 --- /dev/null +++ b/libjava/classpath/gnu/javax/crypto/RSACipherImpl.java @@ -0,0 +1,311 @@ +/* DiffieHellmanImpl.java -- implementation of the Diffie-Hellman key agreement. + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.crypto; + +import gnu.classpath.ByteArray; +import gnu.classpath.debug.Component; +import gnu.classpath.debug.SystemLogger; + +import java.math.BigInteger; + +import java.security.AlgorithmParameters; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.Key; +import java.security.NoSuchAlgorithmException; +import java.security.SecureRandom; + +import java.security.interfaces.RSAKey; +import java.security.interfaces.RSAPrivateKey; +import java.security.interfaces.RSAPrivateCrtKey; +import java.security.interfaces.RSAPublicKey; + +import java.security.spec.AlgorithmParameterSpec; + +import java.util.logging.Logger; + +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.CipherSpi; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import javax.crypto.ShortBufferException; + +public class RSACipherImpl extends CipherSpi +{ + private static final Logger logger = SystemLogger.SYSTEM; + + private static final byte[] EMPTY = new byte[0]; + private int opmode = -1; + private RSAPrivateKey decipherKey = null; + private RSAPublicKey blindingKey = null; + private RSAPublicKey encipherKey = null; + private SecureRandom random = null; + private byte[] dataBuffer = null; + private int pos = 0; + + protected void engineSetMode (String mode) throws NoSuchAlgorithmException + { + throw new NoSuchAlgorithmException ("only one mode available"); + } + + protected void engineSetPadding (String pad) throws NoSuchPaddingException + { + throw new NoSuchPaddingException ("only one padding available"); + } + + protected int engineGetBlockSize () + { + return 1; + } + + protected int engineGetOutputSize (int inputLen) + { + int outputLen = 0; + if (decipherKey != null) + { + outputLen = (decipherKey.getModulus ().bitLength () + 7) / 8; + } + else if (encipherKey != null) + { + outputLen = (encipherKey.getModulus ().bitLength () + 7) / 8; + } + else + throw new IllegalStateException ("not initialized"); + if (inputLen > outputLen) + throw new IllegalArgumentException ("not configured to encode " + inputLen + + "bytes; at most " + outputLen); + return outputLen; + } + + protected int engineGetKeySize (final Key key) throws InvalidKeyException + { + if (!(key instanceof RSAKey)) + throw new InvalidKeyException ("not an RSA key"); + return ((RSAKey) key).getModulus ().bitLength (); + } + + protected byte[] engineGetIV () + { + return null; + } + + protected AlgorithmParameters engineGetParameters() + { + return null; + } + + protected void engineInit (int opmode, Key key, SecureRandom random) + throws InvalidKeyException + { + int outputLen = 0; + if (opmode == Cipher.ENCRYPT_MODE) + { + if (!(key instanceof RSAPublicKey)) + throw new InvalidKeyException ("expecting a RSAPublicKey"); + encipherKey = (RSAPublicKey) key; + decipherKey = null; + blindingKey = null; + outputLen = (encipherKey.getModulus ().bitLength () + 7) / 8; + } + else if (opmode == Cipher.DECRYPT_MODE) + { + if (key instanceof RSAPrivateKey) + { + decipherKey = (RSAPrivateKey) key; + encipherKey = null; + blindingKey = null; + outputLen = (decipherKey.getModulus ().bitLength () + 7) / 8; + } + else if (key instanceof RSAPublicKey) + { + if (decipherKey == null) + throw new IllegalStateException ("must configure decryption key first"); + if (!decipherKey.getModulus ().equals (((RSAPublicKey) key).getModulus ())) + throw new InvalidKeyException ("blinding key is not compatible"); + blindingKey = (RSAPublicKey) key; + return; + } + else + throw new InvalidKeyException ("expecting either an RSAPrivateKey or an RSAPublicKey (for blinding)"); + } + else + throw new IllegalArgumentException ("only encryption and decryption supported"); + this.random = random; + this.opmode = opmode; + pos = 0; + dataBuffer = new byte[outputLen]; + } + + protected void engineInit (int opmode, Key key, AlgorithmParameterSpec spec, SecureRandom random) + throws InvalidKeyException + { + engineInit (opmode, key, random); + } + + protected void engineInit (int opmode, Key key, AlgorithmParameters params, SecureRandom random) + throws InvalidKeyException + { + engineInit (opmode, key, random); + } + + protected byte[] engineUpdate (byte[] in, int offset, int length) + { + if (opmode != Cipher.ENCRYPT_MODE && opmode != Cipher.DECRYPT_MODE) + throw new IllegalStateException ("not initialized"); + System.arraycopy (in, offset, dataBuffer, pos, length); + pos += length; + return EMPTY; + } + + protected int engineUpdate (byte[] in, int offset, int length, byte[] out, int outOffset) + { + engineUpdate (in, offset, length); + return 0; + } + + protected byte[] engineDoFinal (byte[] in, int offset, int length) + throws IllegalBlockSizeException, BadPaddingException + { + engineUpdate (in, offset, length); + if (opmode == Cipher.DECRYPT_MODE) + { + if (pos < dataBuffer.length) + throw new IllegalBlockSizeException ("expecting exactly " + dataBuffer.length + " bytes"); + BigInteger enc = new BigInteger (1, dataBuffer); + byte[] dec = rsaDecrypt (enc); + logger.log (Component.CRYPTO, "RSA: decryption produced\n{0}", + new ByteArray (dec)); + if (dec[0] != 0x02) + throw new BadPaddingException ("expected padding type 2"); + int i; + for (i = 1; i < dec.length && dec[i] != 0x00; i++); + int len = dec.length - i; + byte[] result = new byte[len]; + System.arraycopy (dec, i, result, 0, len); + pos = 0; + return result; + } + else + { + offset = dataBuffer.length - pos; + if (offset < 3) + throw new IllegalBlockSizeException ("input is too large to encrypt"); + byte[] dec = new byte[dataBuffer.length]; + dec[0] = 0x02; + if (random == null) + random = new SecureRandom (); + byte[] pad = new byte[offset - 2]; + random.nextBytes (pad); + for (int i = 0; i < pad.length; i++) + if (pad[i] == 0) + pad[i] = 1; + System.arraycopy (pad, 0, dec, 1, pad.length); + dec[dec.length - pos] = 0x00; + System.arraycopy (dataBuffer, 0, dec, offset, pos); + logger.log (Component.CRYPTO, "RSA: produced padded plaintext\n{0}", + new ByteArray (dec)); + BigInteger x = new BigInteger (1, dec); + BigInteger y = x.modPow (encipherKey.getPublicExponent (), + encipherKey.getModulus ()); + byte[] enc = y.toByteArray (); + if (enc[0] == 0x00) + { + byte[] tmp = new byte[enc.length - 1]; + System.arraycopy (enc, 1, tmp, 0, tmp.length); + enc = tmp; + } + pos = 0; + return enc; + } + } + + protected int engineDoFinal (byte[] out, int offset) + throws ShortBufferException, IllegalBlockSizeException, BadPaddingException + { + byte[] result = engineDoFinal (EMPTY, 0, 0); + if (out.length - offset < result.length) + throw new ShortBufferException ("need " + result.length + ", have " + + (out.length - offset)); + System.arraycopy (result, 0, out, offset, result.length); + return result.length; + } + + protected int engineDoFinal (final byte[] input, final int offset, final int length, + final byte[] output, final int outputOffset) + throws ShortBufferException, IllegalBlockSizeException, BadPaddingException + { + byte[] result = engineDoFinal (input, offset, length); + if (output.length - outputOffset < result.length) + throw new ShortBufferException ("need " + result.length + ", have " + + (output.length - outputOffset)); + System.arraycopy (result, 0, output, outputOffset, result.length); + return result.length; + } + + /** + * Decrypts the ciphertext, employing RSA blinding if possible. + */ + private byte[] rsaDecrypt (BigInteger enc) + { + if (random == null) + random = new SecureRandom (); + BigInteger n = decipherKey.getModulus (); + BigInteger r = null; + BigInteger pubExp = null; + if (blindingKey != null) + pubExp = blindingKey.getPublicExponent (); + if (pubExp != null && (decipherKey instanceof RSAPrivateCrtKey)) + pubExp = ((RSAPrivateCrtKey) decipherKey).getPublicExponent (); + if (pubExp != null) + { + r = new BigInteger (n.bitLength () - 1, random); + enc = r.modPow (pubExp, n).multiply (enc).mod (n); + } + + BigInteger dec = enc.modPow (decipherKey.getPrivateExponent (), n); + + if (pubExp != null) + { + dec = dec.multiply (r.modInverse (n)).mod (n); + } + + return dec.toByteArray (); + } +} diff --git a/libjava/classpath/gnu/javax/imageio/bmp/BMPDecoder.java b/libjava/classpath/gnu/javax/imageio/bmp/BMPDecoder.java new file mode 100644 index 00000000000..c4a582bfa20 --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/BMPDecoder.java @@ -0,0 +1,169 @@ +/* BMPDecoder.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.awt.image.ColorModel; +import java.awt.image.IndexColorModel; +import java.awt.image.BufferedImage; + +public abstract class BMPDecoder { + + protected BMPInfoHeader infoHeader; + protected BMPFileHeader fileHeader; + protected long offset; + + public BMPDecoder(BMPFileHeader fh, BMPInfoHeader ih){ + fileHeader = fh; + infoHeader = ih; + offset = BMPFileHeader.SIZE + BMPInfoHeader.SIZE; + } + + /** + * Determines the coding type of the bitmap and returns the corresponding + * decoder. + */ + public static BMPDecoder getDecoder(BMPFileHeader fh, BMPInfoHeader ih){ + switch(ih.getCompression()){ + case BMPInfoHeader.BI_RGB: // uncompressed RGB + switch(ih.getBitCount()){ + case 32: + return new DecodeBF32(fh, ih, true); + + case 24: + return new DecodeRGB24(fh, ih); + + case 16: + return new DecodeBF16(fh, ih, true); + + case 8: + return new DecodeRGB8(fh, ih); + + case 4: + return new DecodeRGB4(fh, ih); + + case 1: + return new DecodeRGB1(fh, ih); + + default: + return null; + } + + case BMPInfoHeader.BI_RLE8: + return new DecodeRLE8(fh, ih); + + case BMPInfoHeader.BI_RLE4: + return new DecodeRLE4(fh, ih); + + case BMPInfoHeader.BI_BITFIELDS: + switch(ih.getBitCount()){ + case 16: + return new DecodeBF16(fh, ih, false); + + case 32: + return new DecodeBF32(fh, ih, false); + + default: + return null; + } + + default: + return null; + } + } + + /** + * The image decoder. + */ + public abstract BufferedImage decode(ImageInputStream in) + throws IOException, BMPException; + + /** + * Reads r,g,b bit masks from an inputstream + */ + protected int[] readBitMasks(ImageInputStream in) throws IOException { + int[] bitmasks = new int[3]; + byte[] temp = new byte[12]; + if(in.read(temp) != 12) + throw new IOException("Couldn't read bit masks."); + offset += 12; + + ByteBuffer buf = ByteBuffer.wrap(temp); + buf.order(ByteOrder.LITTLE_ENDIAN); + bitmasks[0] = buf.getInt(); + bitmasks[1] = buf.getInt(); + bitmasks[2] = buf.getInt(); + return bitmasks; + } + + /** + * Reads an N-color palette from an inputstream in RGBQUAD format and + * returns an equivalent ColorModel object + */ + protected IndexColorModel readPalette(ImageInputStream in) throws IOException { + int N = infoHeader.getNumberOfPaletteEntries(); + byte[] r = new byte[N]; + byte[] g = new byte[N]; + byte[] b = new byte[N]; + for(int i=0;i<N;i++){ + byte[] RGBquad = new byte[4]; + if(in.read(RGBquad) != 4) + throw new IOException("Error reading palette information."); + // RGBQUAD structure is b,g,r,0 + r[i] = RGBquad[2]; + g[i] = RGBquad[1]; + b[i] = RGBquad[0]; + } + + offset += 4*N; + return new IndexColorModel(8, N, r, g, b); + } + + /** + * Read bytes to the start of the image data + */ + protected void skipToImage(ImageInputStream in) throws IOException { + byte[] d = new byte[1]; + long n = fileHeader.getOffset() - offset; + for(int i=0;i<n;i++) + in.read(d); + } +} diff --git a/libjava/classpath/gnu/javax/imageio/bmp/BMPException.java b/libjava/classpath/gnu/javax/imageio/bmp/BMPException.java new file mode 100644 index 00000000000..d3c62e7597e --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/BMPException.java @@ -0,0 +1,47 @@ +/* BMPException.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import javax.imageio.IIOException; + +public class BMPException extends IIOException { + + public BMPException(String message){ + super(message); + } +} diff --git a/libjava/classpath/gnu/javax/imageio/bmp/BMPFileHeader.java b/libjava/classpath/gnu/javax/imageio/bmp/BMPFileHeader.java new file mode 100644 index 00000000000..246e0eacfeb --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/BMPFileHeader.java @@ -0,0 +1,128 @@ +/* BMPFileHeader.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + +public class BMPFileHeader { + /** Header signature, always 'BM' */ + private final static short bfType = 0x424d; + + /** Bitmap file size, in bytes. */ + private long bfSize; + + /** Offset from the beginning of the file to the bitmap data */ + private long bfOffBits; + + /** BITMAPFILEHEADER is 14 bytes */ + public static final int SIZE = 14; + + /** + * Creates the header from an input stream, which is not closed. + * @throws IOException if an I/O error occured. + * @throws BMPException if the header was invalid + */ + public BMPFileHeader(ImageInputStream in) throws IOException, BMPException { + byte[] data = new byte[SIZE]; + + if (in.read(data) != SIZE) + throw new IOException("Couldn't read header."); + ByteBuffer buf = ByteBuffer.wrap(data); + + if(buf.getShort(0) != bfType) + throw new BMPException("Not a BMP file."); + + buf.order(ByteOrder.LITTLE_ENDIAN); + + // get size (keep unsigned) + bfSize = ((long)buf.getInt(2) & (0xFFFFFFFF)); + + // Two reserved shorts are here, and should be zero, + // perhaps they should be tested to be zero, but I don't + // feel this strictness is necessary. + + bfOffBits = ((long)buf.getInt(10) & (0xFFFFFFFF)); + } + + /** + * Writes the header to an output stream, which is not closed or flushed. + * @throws IOException if an I/O error occured. + */ + public void write(OutputStream out) throws IOException { + ByteBuffer buf = ByteBuffer.allocate(SIZE); + buf.putShort(0, bfType); // ID + buf.putInt(2, (int)(bfSize & (0xFFFFFFFF))); // size + buf.putInt(6, 0); // 4 reserved bytes set to zero + buf.putInt(2, (int)(bfOffBits & (0xFFFFFFFF))); // size + out.write(buf.array()); + } + + /** + * Sets the file size + */ + public void setSize(long size){ + bfSize = size; + } + + /** + * Sets the bitmap offset within the file + */ + public void setOffset(long offset){ + bfOffBits = offset; + } + + /** + * Gets the file size + */ + public long getSize(){ + return bfSize; + } + + /** + * Gets the bitmap offset within the file + */ + public long getOffset(){ + return bfOffBits; + } +} + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/BMPImageReader.java b/libjava/classpath/gnu/javax/imageio/bmp/BMPImageReader.java new file mode 100644 index 00000000000..3341d4b4aed --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/BMPImageReader.java @@ -0,0 +1,153 @@ +/* BMPImageReader.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.*; +import javax.imageio.spi.*; +import javax.imageio.metadata.*; +import javax.imageio.stream.ImageInputStream; +import java.util.Iterator; +import java.awt.image.BufferedImage; + +public class BMPImageReader extends ImageReader { + private BMPInfoHeader infoHeader; + private BMPFileHeader fileHeader; + private BMPDecoder decoder; + + protected BMPImageReader(ImageReaderSpi originatingProvider){ + super(originatingProvider); + infoHeader = null; + fileHeader = null; + decoder = null; + } + + private void validateIndex(int imageIndex) + throws IndexOutOfBoundsException { + if (imageIndex != 0) + throw new IndexOutOfBoundsException("Invalid image index."); + } + + public void setInput(Object input) { + super.setInput(input); + } + + public void setInput(Object input, + boolean seekForwardOnly, + boolean ignoreMetadata) { + super.setInput(input, seekForwardOnly, ignoreMetadata); + } + + public void setInput(Object input, boolean isStreamable) { + super.setInput(input, isStreamable); + + if (!(input instanceof ImageInputStream)) + throw new IllegalArgumentException("Input not an ImageInputStream."); + } + + private void checkStream() throws IOException { + if (!(input instanceof ImageInputStream)) + throw new IllegalStateException("Input not an ImageInputStream."); + if(input == null) + throw new IllegalStateException("No input stream."); + + } + + private void readHeaders() throws IOException, IIOException { + if(fileHeader != null) + return; + + checkStream(); + + fileHeader = new BMPFileHeader((ImageInputStream)input); + infoHeader = new BMPInfoHeader((ImageInputStream)input); + decoder = BMPDecoder.getDecoder(fileHeader, infoHeader); + } + + public int getWidth(int imageIndex) throws IOException { + validateIndex(imageIndex); + readHeaders(); + return infoHeader.getWidth(); + } + + public int getHeight(int imageIndex) throws IOException { + validateIndex(imageIndex); + readHeaders(); + return infoHeader.getHeight(); + } + + public Iterator getImageTypes(int imageIndex){ + validateIndex(imageIndex); + return null; + } + + /** + * Returns the number of images. BMP files can only contain a single one. + */ + public int getNumImages(boolean allowSearch){ + return 1; + } + + + // FIXME: Support metadata + public IIOMetadata getImageMetadata(int imageIndex){ + validateIndex(imageIndex); + return null; + } + + // FIXME: Support metadata + public IIOMetadata getStreamMetadata(){ + return null; + } + + /** + * Reads the image indexed by imageIndex and returns it as + * a complete BufferedImage, using a supplied ImageReadParam. + */ + public BufferedImage read(int imageIndex, ImageReadParam param) + throws IOException, IIOException { + validateIndex(imageIndex); + readHeaders(); + return decoder.decode((ImageInputStream)input); + } + + +} + + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/BMPImageReaderSpi.java b/libjava/classpath/gnu/javax/imageio/bmp/BMPImageReaderSpi.java new file mode 100644 index 00000000000..b175c7d076b --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/BMPImageReaderSpi.java @@ -0,0 +1,123 @@ +/* BMPImageReaderSpi.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import java.util.Locale; +import javax.imageio.ImageReader; +import javax.imageio.spi.ImageReaderSpi; +import javax.imageio.stream.ImageInputStream; + +public class BMPImageReaderSpi extends ImageReaderSpi { + + static final String vendorName = "GNU"; + static final String version = "0.1"; + static final String readerClassName = + "gnu.javax.imageio.bmp.BMPImageReader"; + static final String[] names = { "Microsoft Windows BMP" }; + static final String[] suffixes = { ".bmp", ".bm" }; + static final String[] MIMETypes = { + "image/bmp", + "image/x-windows-bmp"}; + + static final String[] writerSpiNames = null; + //{"com.mycompany.imageio.MyFormatImageWriterSpi" }; + + static final boolean supportsStandardStreamMetadataFormat = false; + static final String nativeStreamMetadataFormatName = null; + static final String nativeStreamMetadataFormatClassName = null; + static final String[] extraStreamMetadataFormatNames = null; + static final String[] extraStreamMetadataFormatClassNames = null; + static final boolean supportsStandardImageMetadataFormat = false; + static final String nativeImageMetadataFormatName = null; + static final String nativeImageMetadataFormatClassName = null; + static final String[] extraImageMetadataFormatNames = null; + static final String[] extraImageMetadataFormatClassNames = null; + + public BMPImageReaderSpi() { + super(vendorName, version, + names, suffixes, MIMETypes, + readerClassName, + STANDARD_INPUT_TYPE, // Accept ImageImageInputStreams + writerSpiNames, + supportsStandardStreamMetadataFormat, + nativeStreamMetadataFormatName, + nativeStreamMetadataFormatClassName, + extraStreamMetadataFormatNames, + extraStreamMetadataFormatClassNames, + supportsStandardImageMetadataFormat, + nativeImageMetadataFormatName, + nativeImageMetadataFormatClassName, + extraImageMetadataFormatNames, + extraImageMetadataFormatClassNames); + } + + public String getDescription(Locale locale) { + return "Microsoft BMP v3"; + } + + public boolean canDecodeInput(Object input) + throws IOException { + if (!(input instanceof ImageInputStream)) + return false; + + ImageInputStream in = (ImageInputStream)input; + boolean retval; + + in.mark(); + try { + new BMPFileHeader(in); + retval = true; + } catch(BMPException e){ + retval = false; + } + in.reset(); + + return retval; + } + + public ImageReader createReaderInstance(Object extension) { + return new BMPImageReader(this); + } +} + + + + + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/BMPInfoHeader.java b/libjava/classpath/gnu/javax/imageio/bmp/BMPInfoHeader.java new file mode 100644 index 00000000000..edcb4e644cc --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/BMPInfoHeader.java @@ -0,0 +1,201 @@ +/* BMPInfoHeader.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.awt.Dimension; + +public class BMPInfoHeader { + /** Size of the bitmap info header*/ + private int biSize; + + /** Pixel width of the bitmap */ + private int biWidth; + + /** Pixel height of the bitmap */ + private int biHeight; + + /** Number of bitplanes = 1 */ + private short biPlanes; + + /** Number of bpp = 1,4,8,24 */ + private short biBitCount; + + /** Compression type, RGB8, RLE8, RLE4, BITFIELDS */ + private int biCompression; + + /** Byte size of the uncompressed bitmap, can be 0. */ + private int biSizeImage; + + /** X resolution, dots per meter */ + private int biXPelsPerMeter; + + /** Y resolution, dots per meter */ + private int biYPelsPerMeter; + + /** Number of colors used (palette only, can be 0 for all) */ + private int biClrUsed; + + /** Number of 'important' colors, 0 for all */ + private int biClrImportant; + + /** BITMAPINFOHEADER is 40 bytes */ + public static final int SIZE = 40; + + /** + * Compression types + */ + public static final int BI_RGB = 0; + public static final int BI_RLE8 = 1; + public static final int BI_RLE4 = 2; + public static final int BI_BITFIELDS = 3; + + /** + * Creates the header from an input stream, which is not closed. + * @throws IOException if an I/O error occured. + * @throws BMPException if the header was invalid + */ + public BMPInfoHeader(ImageInputStream in) throws IOException, BMPException { + byte[] data = new byte[SIZE]; + + if (in.read(data) != SIZE) + throw new IOException("Couldn't read header."); + ByteBuffer buf = ByteBuffer.wrap(data); + buf.order(ByteOrder.LITTLE_ENDIAN); + + int n; + if((n=buf.getInt()) != SIZE) + throw new BMPException("Invalid BITMAPINFOHEADER size: "+n); + + biWidth = buf.getInt(); + biHeight = buf.getInt(); + biPlanes = buf.getShort(); + setBitCount(buf.getShort()); + setCompression(buf.getInt()); + biSizeImage = buf.getInt(); + biXPelsPerMeter = buf.getInt(); + biYPelsPerMeter = buf.getInt(); + biClrUsed = buf.getInt(); + biClrImportant = buf.getInt(); + } + + public void setBitCount(short bitcount) throws BMPException { + switch(bitcount){ + case 1: + case 4: + case 8: + case 16: + case 24: + case 32: + biBitCount = bitcount; + break; + + default: + throw new BMPException("Invalid number of bits per pixel: "+ + bitcount); + } + } + + public short getBitCount() { return biBitCount; } + + public void setCompression(int compression) throws BMPException { + switch(compression){ + case BI_RLE8: + if(getBitCount() != 8) + throw new BMPException("Invalid number of bits per pixel."); + biCompression = compression; + break; + case BI_RLE4: + if(getBitCount() != 4) + throw new BMPException("Invalid number of bits per pixel."); + biCompression = compression; + break; + + case BI_RGB: + case BI_BITFIELDS: + biCompression = compression; + break; + + default: + throw new BMPException("Unknown bitmap compression type."); + } + } + + public int getNumberOfPaletteEntries(){ + if(biClrUsed == 0) + switch(biBitCount){ + case 1: + return 2; + case 4: + return 16; + case 8: + return 256; + + default: // should not happen + return 0; + } + + return biClrUsed; + } + + public int getCompression(){ + return biCompression; + } + + public Dimension getSize(){ + return new Dimension(biWidth, biHeight); + } + + public int getWidth(){ + return biWidth; + } + + public int getHeight(){ + return biHeight; + } + + public void setSize(Dimension d){ + biWidth = (int)d.getWidth(); + biHeight = (int)d.getHeight(); + } + +} diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeBF16.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeBF16.java new file mode 100644 index 00000000000..702c93ab3ca --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeBF16.java @@ -0,0 +1,104 @@ +/* DecodeBF16.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.awt.image.BufferedImage; +import java.awt.image.ColorModel; +import java.awt.image.DirectColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferUShort; +import java.awt.image.SinglePixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeBF16 extends BMPDecoder { + private int[] bitmasks; + private boolean useDefaultMasks; + + public DecodeBF16(BMPFileHeader fh, BMPInfoHeader ih, + boolean udm){ + super(fh,ih); + + useDefaultMasks = udm; + if(useDefaultMasks) // 5-6-5 mask, B,G,R + bitmasks = new int[] { 0x00F800, 0x0007E0, 0x00001F }; + } + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + if(!useDefaultMasks) + bitmasks = readBitMasks(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + + // BMP scanlines are padded to dword offsets + int scansize = (w + (w&1)) << 1; + short[] data = new short[w*h]; + + for(int y=h-1;y>=0;y--){ + byte[] scanline = new byte[scansize]; + if(in.read(scanline) != scansize) + throw new IOException("Couldn't read image data."); + + for(int x=0;x<w;x++) + data[x + y*w] = (short)((scanline[x*2] & (0xFF)) | + ((scanline[x*2+1] & (0xFF)) << 8)); + } + + ColorModel cm = new DirectColorModel(16, + bitmasks[0], bitmasks[1], bitmasks[2]); + SampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_USHORT, + w, h, + bitmasks); + DataBuffer db = new DataBufferUShort(data, w*h, 0); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + return new BufferedImage(cm, raster, false, null); + } + +} + + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeBF32.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeBF32.java new file mode 100644 index 00000000000..ee64f4b0eac --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeBF32.java @@ -0,0 +1,108 @@ +/* DecodeBF32.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.awt.image.BufferedImage; +import java.awt.image.ColorModel; +import java.awt.image.DirectColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferInt; +import java.awt.image.SinglePixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeBF32 extends BMPDecoder { + private int[] bitmasks; + private boolean useDefaultMasks; + + public DecodeBF32(BMPFileHeader fh, BMPInfoHeader ih, + boolean udm){ + super(fh,ih); + + useDefaultMasks = udm; + if(useDefaultMasks) + bitmasks = new int[] { 0x00FF0000, 0x0000FF00, 0x000000FF }; + } + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + if(!useDefaultMasks) + bitmasks = readBitMasks(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + + // BMP scanlines are padded to dword offsets + int scansize = w << 2; + int[] data = new int[w*h]; + + + for(int y=h-1;y>=0;y--){ + byte[] scanline = new byte[scansize]; + if(in.read(scanline) != scansize) + throw new IOException("Couldn't read image data."); + + for(int x=0;x<w;x++) + data[x + y*w] = ((scanline[x<<2] & (0xFF)) | + ((scanline[(x<<2)+1] & (0xFF)) << 8) | + ((scanline[(x<<2)+2] & (0xFF)) << 16) | + ((scanline[(x<<2)+3] & (0xFF)) << 24)); + } + + ColorModel cm = new DirectColorModel(32, + bitmasks[0], bitmasks[1], bitmasks[2]); + SampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT, + w, h, + bitmasks); + DataBuffer db = new DataBufferInt(data, w*h); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + + return new BufferedImage(cm, raster, false, null); + } + +} + + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB1.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB1.java new file mode 100644 index 00000000000..9ca82d9ee4a --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB1.java @@ -0,0 +1,96 @@ +/* DecodeRGB1.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.awt.image.BufferedImage; +import java.awt.image.IndexColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferByte; +import java.awt.image.MultiPixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeRGB1 extends BMPDecoder { + + public DecodeRGB1(BMPFileHeader fh, BMPInfoHeader ih){ + super(fh, ih); + } + + public BufferedImage decode(ImageInputStream in) + throws IOException, BMPException { + + IndexColorModel palette = readPalette(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + int size = (w*h)>>3; + + int scansize = w>>3; + byte[] data = new byte[size]; + + for(int y=h-1;y>=0;y--){ + // Scanlines are padded to dword boundries + int readsize = scansize; + if((readsize & 3) != 0) readsize += (4 - (scansize & 3)); + + byte[] scanline = new byte[readsize]; + if(in.read(scanline) != readsize) + throw new IOException("Couldn't read image data."); + + for(int x=0;x<scansize;x++) + data[x + y*scansize] = scanline[x]; + } + + SampleModel sm = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, + w, h, 1); + + DataBuffer db = new DataBufferByte(data, size, 0); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + + return new BufferedImage(palette, raster, false, null); + } + +} + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB24.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB24.java new file mode 100644 index 00000000000..2a910cb3063 --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB24.java @@ -0,0 +1,77 @@ +/* DecodeRGB24.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.awt.image.BufferedImage; +import java.awt.Dimension; + +public class DecodeRGB24 extends BMPDecoder { + + public DecodeRGB24(BMPFileHeader fh, BMPInfoHeader ih){ + super(fh, ih); + } + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + BufferedImage image = new BufferedImage(w, h, + BufferedImage.TYPE_INT_RGB); + // BMP scanlines are padded to dword offsets + int scansize = ((w*3 & 3) != 0)? w*3 + 4 - (w*3 & 3): w*3; + int[] data = new int[w*h]; + + for(int y=h-1;y>=0;y--){ + byte[] scanline = new byte[scansize]; + if(in.read(scanline) != scansize) + throw new IOException("Couldn't read image data."); + + for(int x=0;x<w;x++) + data[x + y*w] = scanline[x*3] + + (scanline[x*3+1] << 8) + + (scanline[x*3+2] << 16); + } + image.setRGB(0, 0, w, h, data, 0, w); + return image; + } + +} diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB4.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB4.java new file mode 100644 index 00000000000..a10d390ab82 --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB4.java @@ -0,0 +1,92 @@ +/* DecodeRGB4.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.awt.image.BufferedImage; +import java.awt.image.IndexColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferByte; +import java.awt.image.MultiPixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeRGB4 extends BMPDecoder { + + public DecodeRGB4(BMPFileHeader fh, BMPInfoHeader ih){ + super(fh, ih); + } + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + IndexColorModel palette = readPalette(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + int size = (w*h) >> 1; + + // Scanline padded to dword offsets + int wbytes = (w + (w & 1)) >> 1; + int scansize = ((wbytes & 3) != 0)? (wbytes + 4 - (wbytes&3)) : wbytes; + + byte[] data = new byte[wbytes*h]; + + for(int y=h-1;y>=0;y--){ + byte[] scanline = new byte[scansize]; + if(in.read(scanline) != scansize) + throw new IOException("Couldn't read image data."); + + for(int x=0;x<wbytes;x++) + data[x + y*wbytes] = scanline[x]; + } + SampleModel sm = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, + w, h, 4); + + DataBuffer db = new DataBufferByte(data, w*h, 0); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + + return new BufferedImage(palette, raster, false, null); + } + +} + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB8.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB8.java new file mode 100644 index 00000000000..dfe4a19e8be --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRGB8.java @@ -0,0 +1,90 @@ +/* DecodeRGB8.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.awt.image.BufferedImage; +import java.awt.image.IndexColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferByte; +import java.awt.image.SinglePixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeRGB8 extends BMPDecoder { + + public DecodeRGB8(BMPFileHeader fh, BMPInfoHeader ih){ + super(fh, ih); + } + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + IndexColorModel palette = readPalette(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + + // BMP scanlines are padded to dword offsets + int scansize = ((w & 3) != 0)? w + 4 - (w & 3): w; + byte[] data = new byte[w*h]; + + for(int y=h-1;y>=0;y--){ + byte[] scanline = new byte[scansize]; + if(in.read(scanline) != scansize) + throw new IOException("Couldn't read image data."); + + for(int x=0;x<w;x++) + data[x + y*w] = scanline[x]; + } + + SampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_BYTE, + w, h, + new int[] {0xFF}); + DataBuffer db = new DataBufferByte(data, w*h, 0); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + + return new BufferedImage(palette, raster, false, null); + } + +} + + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeRLE4.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRLE4.java new file mode 100644 index 00000000000..55d314f05f1 --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRLE4.java @@ -0,0 +1,176 @@ +/* DecodeRLE4.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.awt.image.BufferedImage; +import java.awt.image.IndexColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferByte; +import java.awt.image.MultiPixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeRLE4 extends BMPDecoder { + + public DecodeRLE4(BMPFileHeader fh, BMPInfoHeader ih){ + super(fh, ih); + } + + /** + * RLE control codes + */ + private static final byte ESCAPE = (byte)0; + private static final byte EOL = (byte)0; // end of line + private static final byte EOB = (byte)1; // end of bitmap + private static final byte DELTA = (byte)2; // delta + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + IndexColorModel palette = readPalette(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + + byte[] data = uncompress(w, h, in); + SampleModel sm = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, + w, h, 4); + + DataBuffer db = new DataBufferByte(data, w*h, 0); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + + return new BufferedImage(palette, raster, false, null); + } + + private byte[] uncompress(int w, int h, ImageInputStream in) + throws BMPException, IOException { + byte[] cmd = new byte[2]; + byte[] data = new byte[w*h>>1]; + int offIn = 0; + int x=0,y=0; + + // width in bytes + w += (w&1); + w = w >> 1; + + try { + while(((x>>1) + y*w) < w*h){ + if(in.read(cmd) != 2) + throw new IOException("Error reading compressed data."); + + if(cmd[0] == ESCAPE){ + switch(cmd[1]){ + case EOB: // end of bitmap + return data; + case EOL: // end of line + x = 0; + y++; + break; + case DELTA: // delta + if(in.read(cmd) != 2) + throw new IOException("Error reading compressed data."); + int dx = cmd[0] & (0xFF); + int dy = cmd[1] & (0xFF); + x += dx; + y += dy; + break; + + default: + // decode a literal run + int length = cmd[1] & (0xFF); + + // size of run, which is word aligned. + int bytesize = length; + bytesize += (bytesize & 1); + bytesize >>= 1; + bytesize += (bytesize & 1); + + byte[] run = new byte[bytesize]; + if(in.read(run) != bytesize) + throw new IOException("Error reading compressed data."); + + if((x&1) == 0){ + length += (length&1); + length >>= 1; + System.arraycopy(run, 0, data, ((x>>1) + w*(h-y-1)), + length); + } else { + for(int i=0;i<length;i++){ + if((i&1) == 0) // copy high to low + data[((x+i)>>1) + w*(h-y-1)] + |= ((run[i>>1]&0xF0) >> 4); + else // copy low to high + data[((x+i)>>1) + w*(h-y-1)] + |= ((run[i>>1]&0x0F) << 4); + } + } + x += cmd[1] & (0xFF); + break; + } + } else { + // decode a byte run + int length = cmd[0] & (0xFF); + if((x&1) == 0){ + length += (length&1); + length >>= 1; + for(int i=0;i<length;i++) + data[(h-y-1)*w + i + (x >> 1)] = cmd[1]; + } else { + for(int i=0;i<length;i++){ + if((i&1) == 0) // copy high to low + data[((x+i)>>1) + w*(h-y-1)] + |= ((cmd[1]&0xF0) >> 4); + else // copy low to high + data[((x+i)>>1) + w*(h-y-1)] + |= ((cmd[1]&0x0F) << 4); + } + } + x += cmd[0] & (0xFF); + } + } + return data; + } catch(ArrayIndexOutOfBoundsException e){ + throw new BMPException("Invalid RLE data."); + } + } +} + diff --git a/libjava/classpath/gnu/javax/imageio/bmp/DecodeRLE8.java b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRLE8.java new file mode 100644 index 00000000000..1d00e6751d0 --- /dev/null +++ b/libjava/classpath/gnu/javax/imageio/bmp/DecodeRLE8.java @@ -0,0 +1,143 @@ +/* DecodeRLE8.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +package gnu.javax.imageio.bmp; + +import java.io.IOException; +import javax.imageio.stream.ImageInputStream; +import java.awt.image.BufferedImage; +import java.awt.image.IndexColorModel; +import java.awt.image.Raster; +import java.awt.image.WritableRaster; +import java.awt.image.DataBuffer; +import java.awt.image.DataBufferByte; +import java.awt.image.SinglePixelPackedSampleModel; +import java.awt.image.SampleModel; +import java.awt.Dimension; + +public class DecodeRLE8 extends BMPDecoder { + + public DecodeRLE8(BMPFileHeader fh, BMPInfoHeader ih){ + super(fh, ih); + } + + /** + * RLE control codes + */ + private static final byte ESCAPE = (byte)0; + private static final byte EOL = (byte)0; // end of line + private static final byte EOB = (byte)1; // end of bitmap + private static final byte DELTA = (byte)2; // delta + + public BufferedImage decode(ImageInputStream in) throws IOException, BMPException { + IndexColorModel palette = readPalette(in); + skipToImage(in); + + Dimension d = infoHeader.getSize(); + int h = (int)d.getHeight(); + int w = (int)d.getWidth(); + + byte[] data = uncompress(w, h, in); + SampleModel sm = new SinglePixelPackedSampleModel(DataBuffer.TYPE_BYTE, + w, h, + new int[] {0xFF}); + DataBuffer db = new DataBufferByte(data, w*h, 0); + WritableRaster raster = Raster.createWritableRaster(sm, db, null); + + return new BufferedImage(palette, raster, false, null); + } + + private byte[] uncompress(int w, int h, ImageInputStream in) + throws BMPException, IOException { + byte[] cmd = new byte[2]; + byte[] data = new byte[w*h]; + int offIn = 0; + int x=0,y=0; + + try { + while((x + y*w) < w*h){ + if(in.read(cmd) != 2) + throw new IOException("Error reading compressed data."); + + if(cmd[0] == ESCAPE){ + switch(cmd[1]){ + case EOB: // end of bitmap + return data; + case EOL: // end of line + x = 0; + y++; + break; + case DELTA: // delta + if(in.read(cmd) != 2) + throw new IOException("Error reading compressed data."); + int dx = cmd[0] & (0xFF); + int dy = cmd[1] & (0xFF); + x += dx; + y += dy; + break; + + default: + // decode a literal run + int length = cmd[1] & (0xFF); + int copylength = length; + + // absolute mode must be word-aligned + length += (length & 1); + + byte[] run = new byte[length]; + if(in.read(run) != length) + throw new IOException("Error reading compressed data."); + + System.arraycopy(run, 0, data, (x+w*(h-y-1)), + copylength); + x += copylength; + break; + } + } else { + // decode a byte run + int length = cmd[0] & (0xFF); + for(int i=0;i<length;i++) + data[(h-y-1)*w + x++] = cmd[1]; + } + } + return data; + } catch(ArrayIndexOutOfBoundsException e){ + throw new BMPException("Invalid RLE data."); + } + } +} + diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/CorbaInput.java b/libjava/classpath/gnu/javax/rmi/CORBA/CorbaInput.java new file mode 100644 index 00000000000..e80cabf6b2b --- /dev/null +++ b/libjava/classpath/gnu/javax/rmi/CORBA/CorbaInput.java @@ -0,0 +1,297 @@ +/* CorbaInput.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.rmi.CORBA; + +import gnu.CORBA.CDR.gnuRuntime; + +import org.omg.CORBA_2_3.portable.InputStream; + +import java.io.DataInputStream; +import java.io.IOException; +import java.io.ObjectInput; +import java.io.ObjectInputStream; +import java.io.Serializable; + +/** + * Converts calls on java ObjectOutputStream to calls on CORBA OutputStream. A + * class to substitute for objects using readObject method. + * + * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) + */ +public class CorbaInput + extends ObjectInputStream + implements ObjectInput +{ + + /** + * The underlying CORBA stream from where the actual input is taken. + */ + public InputStream stream; + + /** + * The utility class to write the object fields in default way. + */ + final RmiUtilities util; + + /** + * The object currently being read. + */ + Object current; + + /** + * The offset of the object currently being read. + */ + int offset; + + /** + * The repository id of the object currently being read. + */ + String rid; + + /** + * The runtime, related to the object currently being read. + */ + gnuRuntime runtime; + + /** + * Create an instance, delegating calls to the given CORBA stream. + */ + public CorbaInput(InputStream an_input, Object firstObject, + RmiUtilities an_util, int an_offset, String a_rid, + gnuRuntime a_runtime) + throws Exception + { + stream = an_input; + current = firstObject; + util = an_util; + + offset = an_offset; + rid = a_rid; + runtime = a_runtime; + } + + /** @inheritDoc */ + public int available() + throws IOException + { + return stream.available(); + } + + /** + * No action. + */ + public void close() + throws IOException + { + } + + /** @inheritDoc */ + public void defaultReadObject() + throws IOException, ClassNotFoundException + { + util.readFields(offset, rid, (Serializable) current, stream, runtime); + } + + /** @inheritDoc */ + public void mark(int readlimit) + { + stream.mark(readlimit); + } + + /** @inheritDoc */ + public boolean markSupported() + { + return stream.markSupported(); + } + + /** @inheritDoc */ + public int read() + throws IOException + { + return stream.read(); + } + + /** @inheritDoc */ + public int read(byte[] buf, int off, int len) + throws IOException + { + return stream.read(buf, off, len); + } + + /** @inheritDoc */ + public int read(byte[] b) + throws IOException + { + return stream.read(b); + } + + /** @inheritDoc */ + public boolean readBoolean() + throws IOException + { + return stream.read_boolean(); + } + + /** @inheritDoc */ + public byte readByte() + throws IOException + { + return (byte) stream.read(); + } + + /** @inheritDoc */ + public char readChar() + throws IOException + { + return stream.read_char(); + } + + /** @inheritDoc */ + public double readDouble() + throws IOException + { + return stream.read_double(); + } + + /** @inheritDoc */ + public float readFloat() + throws IOException + { + return stream.read_float(); + } + + /** @inheritDoc */ + public void readFully(byte[] buf, int off, int len) + throws IOException + { + // This class only reads from the buffered streams. + stream.read(buf, off, len); + } + + /** @inheritDoc */ + public void readFully(byte[] buf) + throws IOException + { + // This class only reads from the buffered streams. + stream.read(buf); + } + + /** @inheritDoc */ + public int readInt() + throws IOException + { + return stream.read_long(); + } + + /** @inheritDoc */ + public String readLine() + throws IOException + { + return new DataInputStream(this).readLine(); + } + + /** @inheritDoc */ + public long readLong() + throws IOException + { + return stream.read_longlong(); + } + + /** @inheritDoc */ + public short read_short() + throws IOException + { + return stream.read_short(); + } + + /** @inheritDoc */ + public int readUnsignedByte() + throws IOException + { + return (stream.read() & 0xFF); + } + + /** @inheritDoc */ + public int readUnsignedShort() + throws IOException + { + return (stream.read_short() & 0xFFFF); + } + + /** + * Read as wide string (not as UTF). + */ + public String readUTF() + throws IOException + { + return stream.read_wstring(); + } + + /** @inheritDoc */ + public void reset() + throws IOException + { + stream.reset(); + } + + /** @inheritDoc */ + public long skip(long n) + throws IOException + { + return stream.skip(n); + } + + /** @inheritDoc */ + public int skipBytes(int len) + throws IOException + { + return (int) stream.skip(len); + } + + /** + * Objects are read as abstract interfaces. + */ + protected Object readObjectOverride() + throws IOException, ClassNotFoundException + { + current = stream.read_abstract_interface(); + return current; + } + +} diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/CorbaOutput.java b/libjava/classpath/gnu/javax/rmi/CORBA/CorbaOutput.java new file mode 100644 index 00000000000..1c723407980 --- /dev/null +++ b/libjava/classpath/gnu/javax/rmi/CORBA/CorbaOutput.java @@ -0,0 +1,219 @@ +/* CorbaOutput.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.rmi.CORBA; + +import org.omg.CORBA_2_3.portable.OutputStream; + +import java.io.IOException; +import java.io.ObjectOutput; +import java.io.ObjectOutputStream; +import java.io.Serializable; + +/** + * A class to substitute as an ObjectOutputStream for objects using writeObject + * method. + * + * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) + */ +public class CorbaOutput + extends ObjectOutputStream + implements ObjectOutput +{ + /** + * A CORBA stream where the output is forwarded. + */ + final OutputStream stream; + + /** + * The utility class to write the object fields in default way. + */ + final RmiUtilities util; + + /** + * The object currently being written. + */ + Object current; + + /** + * Create an instance, delegating calls to the given CORBA stream. + */ + public CorbaOutput(OutputStream an_output, Object firstObject, + RmiUtilities an_util) + throws Exception + { + stream = an_output; + current = firstObject; + util = an_util; + } + + /** + * No action. + */ + public void close() + throws IOException + { + } + + /** @inheritDoc */ + public void flush() + throws IOException + { + stream.flush(); + } + + /** @inheritDoc */ + public void write(byte[] buf, int off, int len) + throws IOException + { + stream.write(buf, off, len); + } + + /** @inheritDoc */ + public void write(byte[] buf) + throws IOException + { + stream.write(buf); + } + + /** @inheritDoc */ + public void write(int val) + throws IOException + { + stream.write(val); + } + + /** @inheritDoc */ + public void writeBoolean(boolean val) + throws IOException + { + stream.write_boolean(val); + } + + /** @inheritDoc */ + public void writeByte(int val) + throws IOException + { + stream.write(val); + } + + /** @inheritDoc */ + public void writeBytes(String str) + throws IOException + { + stream.write_string(str); + } + + /** @inheritDoc */ + public void writeChar(int val) + throws IOException + { + stream.write_wchar((char) val); + } + + /** @inheritDoc */ + public void writeChars(String str) + throws IOException + { + stream.write_char_array(str.toCharArray(), 0, str.length()); + } + + /** @inheritDoc */ + public void writeDouble(double val) + throws IOException + { + stream.write_double(val); + } + + /** @inheritDoc */ + public void writeFloat(float val) + throws IOException + { + stream.write_float(val); + } + + /** @inheritDoc */ + public void writeInt(int val) + throws IOException + { + stream.write_long(val); + } + + /** @inheritDoc */ + public void writeLong(long val) + throws IOException + { + stream.write_longlong(val); + } + + /** + * Objects are written as abstract interfaces. + */ + protected void writeObjectOverride(Object obj) + throws IOException + { + current = obj; + stream.write_abstract_interface(obj); + } + + /** @inheritDoc */ + public void writeShort(int val) + throws IOException + { + stream.write_short((short) val); + } + + /** + * Such strings are written as wide strings, not as UTF. + */ + public void writeUTF(String str) + throws IOException + { + stream.write_wstring(str); + } + + /** + * @inheritDoc + */ + public void defaultWriteObject() + throws IOException + { + util.writeFields(stream, (Serializable) current); + } + +} diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/DefaultWriteObjectTester.java b/libjava/classpath/gnu/javax/rmi/CORBA/DefaultWriteObjectTester.java new file mode 100644 index 00000000000..5bdf7dac933 --- /dev/null +++ b/libjava/classpath/gnu/javax/rmi/CORBA/DefaultWriteObjectTester.java @@ -0,0 +1,85 @@ +/* DefaultWriteObjectTester.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.rmi.CORBA; + +import gnu.CORBA.CDR.BufferedCdrOutput; + +import java.io.IOException; + +/** + * Tests if the defaultWriteObject method has been called. + * This information is required by RMI-IIOP header. + * + * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) + */ +public class DefaultWriteObjectTester + extends CorbaOutput +{ + /** + * The flag, indicating, that the defaultWriteObject method was called. + */ + public boolean dwo_called; + + /** + * Create an instance, delegating calls to the given CORBA stream. + */ + public DefaultWriteObjectTester(Object firstObject) + throws Exception + { + super(new BufferedCdrOutput(), firstObject, null); + } + + /** + * Set the flag that defaultWriteObject was called. + */ + public void defaultWriteObject() + throws IOException + { + dwo_called = true; + } + + /** + * Do not write other objects. + */ + protected void writeObjectOverride(Object obj) + throws IOException + { + } + +} diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/DelegateFactory.java b/libjava/classpath/gnu/javax/rmi/CORBA/DelegateFactory.java index d71546d7561..0607c9f9626 100644 --- a/libjava/classpath/gnu/javax/rmi/CORBA/DelegateFactory.java +++ b/libjava/classpath/gnu/javax/rmi/CORBA/DelegateFactory.java @@ -1,5 +1,5 @@ /* DelegateFactory.java -- - Copyright (C) 2002, 2004 Free Software Foundation, Inc. + Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,38 +38,70 @@ exception statement from your version. */ package gnu.javax.rmi.CORBA; -import java.util.HashMap; +import gnu.CORBA.ObjectCreator; + +/** + * This class produces delegates, using the system properties. If not + * corresponding property is specified, returns default implementations. + * + * @author Wu Gansha (gansha.wu@intel.com) + * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) + */ public class DelegateFactory { - private static HashMap cache = new HashMap(4); - - public static synchronized Object getInstance(String type) - throws GetDelegateInstanceException + /** + * The name to get a stub delegate. + */ + public static final String STUB = "Stub"; + + /** + * The name to get the util delegate. + */ + public static final String UTIL = "Util"; + + /** + * The name to get the ValueHandler delegate. + */ + public static final String VALUEHANDLER = "ValueHandler"; + + /** + * The name to get the PortableRemoteObject delegate. + */ + public static final String PORTABLE_REMOTE_OBJECT = "PortableRemoteObject"; + + /** + * Get an instance of the given delegate. As in all cases the singleton + * instance is used, the caching here would be redundant. + * + * @param type a delegate type. + * + * @return the associated delegate. + * + * @throws InternalError if the delegate class, indicated in the system + * properties, cannot be instantiated. + */ + public static Object getInstance(String type) + throws InternalError { - Object r = cache.get(type); - if (r != null) - return r; - String dcname = System.getProperty("javax.rmi.CORBA." + type + "Class"); + String propertyName = "javax.rmi.CORBA." + type + "Class"; + String dcname = System.getProperty(propertyName); if (dcname == null) { - //throw new DelegateException - // ("no javax.rmi.CORBA.XXXClass property sepcified."); - dcname = "gnu.javax.rmi.CORBA." + type + "DelegateImpl"; + // // No javax.rmi.CORBA.XXXClass property sepcified. + dcname = "gnu.javax.rmi.CORBA." + type + "DelegateImpl"; } try { - Class dclass = Class.forName(dcname, - true, - Thread.currentThread().getContextClassLoader()); - r = dclass.newInstance(); - cache.put(type, r); - return r; + Class dclass = ObjectCreator.forName(dcname); + return dclass.newInstance(); } - catch(Exception e) + catch (Exception e) { - throw new GetDelegateInstanceException - ("Exception when trying to get delegate instance:" + dcname, e); + InternalError ierr = new InternalError("Exception when trying to get " + + type + "delegate instance:" + dcname); + ierr.initCause(e); + throw ierr; } } } diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/PortableRemoteObjectDelegateImpl.java b/libjava/classpath/gnu/javax/rmi/CORBA/PortableRemoteObjectDelegateImpl.java index 6a7e6b74622..ea4f73811f0 100644 --- a/libjava/classpath/gnu/javax/rmi/CORBA/PortableRemoteObjectDelegateImpl.java +++ b/libjava/classpath/gnu/javax/rmi/CORBA/PortableRemoteObjectDelegateImpl.java @@ -1,5 +1,5 @@ /* PortableRemoteObjectDelegateImpl.java -- - Copyright (C) 2002, 2004 Free Software Foundation, Inc. + Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,99 +38,325 @@ exception statement from your version. */ package gnu.javax.rmi.CORBA; -import gnu.javax.rmi.PortableServer; +import gnu.CORBA.SimpleDelegate; +import gnu.CORBA.Unexpected; +import gnu.CORBA.Poa.LocalDelegate; +import gnu.CORBA.Poa.ORB_1_4; +import gnu.CORBA.Poa.AOM; import java.rmi.NoSuchObjectException; import java.rmi.Remote; import java.rmi.RemoteException; +import java.rmi.server.RMIClassLoader; import javax.rmi.CORBA.PortableRemoteObjectDelegate; +import javax.rmi.CORBA.Stub; +import javax.rmi.CORBA.Tie; +import javax.rmi.CORBA.Util; +import org.omg.CORBA.BAD_PARAM; +import org.omg.CORBA.ORB; +import org.omg.CORBA.portable.Delegate; +import org.omg.CORBA.portable.ObjectImpl; +import org.omg.PortableServer.POA; +import org.omg.PortableServer.POAHelper; +import org.omg.PortableServer.Servant; +import org.omg.PortableServer.POAManagerPackage.State; + +/** + * Implements PortableRemoteObjectDelegate. + * + * @author Wu Gansha (gansha.wu@intel.com) (stub) + * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) (implementation) + */ public class PortableRemoteObjectDelegateImpl implements PortableRemoteObjectDelegate { - - public PortableRemoteObjectDelegateImpl() - { - } - - public void connect(Remote remote, Remote remote1) + /** + * <p> + * Makes the remote object <code>a_target</code> ready for remote + * communication using the same communications runtime as for the passed + * <code>a_source</code> parameter. The a_target is connected to the same + * ORB (and, if applicable, to the same POA) as the a_source. + * + * @param a_target the target to connect to ORB, must be an instance of either + * {@link ObjectImpl} (Stubs and old-style ties) or {@link Servant} (POA-bases + * ties). + * + * @param a_source the object, providing the connection information, must be + * an instance of either {@link ObjectImpl} (Stubs and old-style ties) or + * {@link Servant} (POA-bases ties). + * + * @throws RemoteException if the target is already connected to another ORB. + */ + public void connect(Remote a_target, Remote a_source) throws RemoteException { - throw new Error("Not implemented for PortableRemoteObjectDelegateImpl"); - } - - public void exportObject(Remote obj) - throws RemoteException - { - PortableServer.exportObject(obj); + ORB orb = null; + POA poa = null; + boolean ok = false; + + try + { + if (a_source instanceof Servant) + { + Servant s = (Servant) a_source; + orb = s._orb(); + poa = s._poa(); + ok = true; + } + + if (!ok && a_source instanceof ObjectImpl) + { + ObjectImpl o = (ObjectImpl) a_source; + orb = o._orb(); + ok = true; + try + { + if (orb instanceof ORB_1_4) + { + // POA information available. + ORB_1_4 xorb = (ORB_1_4) orb; + Delegate d = o._get_delegate(); + + if (d instanceof LocalDelegate) + { + LocalDelegate l = (LocalDelegate) d; + poa = l.poa; + } + else if (d instanceof SimpleDelegate) + { + byte[] ior_key = ((SimpleDelegate) d).getIor().key; + AOM.Obj ref = xorb.rootPOA.findIorKey(ior_key); + if (ref != null) + poa = ref.poa; + } + } + } + catch (Exception ex) + { + // OK, POA info is not available, but as ORB is available, we + // will connect in a default way. + } + } + } + catch (Exception ex) + { + RuntimeException rex = new RuntimeException("Unable to get info from " + + a_source); + rex.initCause(ex); + throw rex; + } + + if (!ok && a_source instanceof Tie) + { + Tie t = (Tie) a_source; + orb = t.orb(); + poa = null; + ok = true; + } + + if (orb == null) + throw new RemoteException("Unable to determine ORB from " + a_source); + + if (a_target instanceof Stub) + { + StubDelegateImpl.connect((Stub) a_target, orb, poa); + } + else if (a_target instanceof Servant) + { + try + { + if (poa == null) + { + poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); + // Activate if not active. + if (poa.the_POAManager().get_state().value() == State._HOLDING) + poa.the_POAManager().activate(); + } + poa.servant_to_reference((Servant) a_target); + } + catch (Exception ex) + { + throw new Unexpected(ex); + } + } + else if (a_target instanceof org.omg.CORBA.Object) + { + // Connect as object. + orb.connect((org.omg.CORBA.Object) a_target); + } + else if (a_target instanceof Tie) + { + // We avoid calling this because it will aways connect to the root poa. + ((Tie) a_target).orb(orb); + } } + /** + * Narrow the given object to the instance of the given class. The currently + * supported narrowing types are: + * + * 1. Simple widening conversion.<br> + * 2. ObjectImpl -> RMI interface.<br> + * 3. ObjectImpl -> ObjectImpl.<br> + * 4. Tie -> Remote (implementation)<br> + * 5. Remote (implementation) -> Tie.<br> + * + * The narrowing has sense only for derived classes. + */ public Object narrow(Object narrowFrom, Class narrowTo) throws ClassCastException { if (narrowTo == null) throw new ClassCastException("Can't narrow to null class"); - if (narrowFrom == null) + else if (narrowFrom == null) return null; + else + // Simple narrowing case. + if (narrowTo.isAssignableFrom(narrowFrom.getClass())) + return narrowFrom; + else if (narrowTo.isInterface() || narrowFrom instanceof ObjectImpl) + { + // Narrow CORBA object to passed interface. + + String interf = narrowTo.getName(); + String stubClassName; - Class fromClass = narrowFrom.getClass(); - Object result = null; - + stubClassName = getStubClassName(interf); + + try + { + // Replace the interface class by the stub class. + narrowTo = Util.loadClass(stubClassName, null, + narrowTo.getClassLoader()); + } + catch (ClassNotFoundException e) + { + ClassCastException cex = new ClassCastException("Class not found: " + + stubClassName); + cex.initCause(e); + throw cex; + } + } + else if (narrowFrom instanceof Tie) + { + // Try to substitute the return tie target as a return value. + Remote target = ((Tie) narrowFrom).getTarget(); + if (target != null && narrowTo.isAssignableFrom(target.getClass())) + return target; + } + + Object narrowed; try { - if (narrowTo.isAssignableFrom(fromClass)) - result = narrowFrom; - else - { - System.out.println("We still haven't implement this case: narrow " - + narrowFrom + " of type " + fromClass + " to " - + narrowTo); - Class[] cs = fromClass.getInterfaces(); - for (int i = 0; i < cs.length; i++) - System.out.println(cs[i]); - Exception e1 = new Exception(); - try - { - throw e1; - } - catch(Exception ee) - { - ee.printStackTrace(); - } - System.exit(2); - //throw new Error("We still haven't implement this case: narrow " - // + narrowFrom + " of type " + fromClass + " to " - // + narrowTo); - /* - ObjectImpl objimpl = (ObjectImpl)narrowFrom; - if(objimpl._is_a(PortableServer.getTypeName(narrowTo))) - result = PortableServer.getStubFromObjectImpl(objimpl, narrowTo); - */ - } - } - catch(Exception e) - { - result = null; - } - - if (result == null) - throw new ClassCastException("Can't narrow from " - + fromClass + " to " + narrowTo); - - return result; + narrowed = narrowTo.newInstance(); + } + catch (Exception e) + { + ClassCastException cex = new ClassCastException("Cannot instantiate " + + narrowTo.getName()); + cex.initCause(e); + throw cex; + } + + if (narrowed instanceof ObjectImpl) + { + // This also works for the instances of the Stub. + ObjectImpl target = (ObjectImpl) narrowed; + // Set the delegate, as is done in *Helper.narrow(..). + target._set_delegate(((ObjectImpl) narrowFrom)._get_delegate()); + } + else if (narrowed instanceof Tie && narrowFrom instanceof Remote) + { + // Try to set the narrowing object as a target for the Tie. + ((Tie) narrowed).setTarget((Remote) narrowFrom); + } + else + throw new ClassCastException("Narrowing of " + narrowFrom.getClass() + + " to " + narrowTo + " is either not possible or not implemented."); + + return narrowed; } - - public Remote toStub(Remote obj) + + /** + * Get the Stub class name for the name, representing the given interface. + */ + static String getStubClassName(String interf) + { + String stubClassName; + int p = interf.lastIndexOf('.'); + + if (p < 0) + // The interface is defined in the default package. + stubClassName = "_" + interf + "_Stub"; + else + stubClassName = interf.substring(0, p + 1) + "_" + + interf.substring(p + 1) + "_Stub"; + return stubClassName; + } + + /** + * Get stub for the given implementation, searching by class name pattern. The + * found stub must implement Remote for this method to succeed. + */ + public Remote toStub(Remote ObjImpl) throws NoSuchObjectException { - return PortableServer.toStub(obj); + String icn = ObjImpl.getClass().getName(); + if (!icn.endsWith("Impl")) + throw new BAD_PARAM("Invalid class name '" + icn + + "', must end with 'Impl'"); + + String sn = "_" + icn.substring(0, icn.length() - "Impl".length()) + + "_Stub"; + + Class stubClass; + Object o_stub; + + try + { + stubClass = RMIClassLoader.loadClass(sn); + o_stub = stubClass.newInstance(); + } + catch (Exception e) + { + NoSuchObjectException n = new NoSuchObjectException(sn); + n.initCause(e); + throw n; + } + + if (!Remote.class.isAssignableFrom(stubClass)) + throw new ClassCastException(stubClass.getName() + + " exists but cannot be returned as it does not inherit from " + + Remote.class.getName()); + + return (Remote) o_stub; } + /** + * If the object tie is no longer in use, disconnet it from the orb. + */ public void unexportObject(Remote obj) throws NoSuchObjectException { - PortableServer.unexportObject(obj); + Util.unexportObject(obj); + } + + /** + * Find or create a tie for this target and mark it as being used by the given + * object. + */ + public void exportObject(Remote obj) + throws RemoteException + { + if (obj instanceof Stub) + Util.registerTarget(StubDelegateImpl.getTieFromStub((Stub) obj), obj); + else if (obj instanceof Tie) + { + Tie t = (Tie) obj; + Util.registerTarget(t, null); + } } } diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/RmiUtilities.java b/libjava/classpath/gnu/javax/rmi/CORBA/RmiUtilities.java new file mode 100644 index 00000000000..91bfa3776dc --- /dev/null +++ b/libjava/classpath/gnu/javax/rmi/CORBA/RmiUtilities.java @@ -0,0 +1,946 @@ +/* RmiUtilities.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.rmi.CORBA; + +import gnu.CORBA.OrbFunctional; +import gnu.CORBA.Minor; +import gnu.CORBA.Unexpected; +import gnu.CORBA.CDR.Vio; +import gnu.CORBA.CDR.gnuRuntime; +import gnu.CORBA.CDR.gnuValueStream; +import gnu.CORBA.CDR.HeadlessInput; + +import org.omg.CORBA.MARSHAL; +import org.omg.CORBA.StringValueHelper; +import org.omg.CORBA.WStringValueHelper; +import org.omg.CORBA.portable.Delegate; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.ObjectImpl; +import org.omg.CORBA.portable.OutputStream; +import org.omg.CORBA.portable.ValueBase; +import org.omg.PortableServer.POA; +import org.omg.PortableServer.POAHelper; +import org.omg.PortableServer.Servant; +import org.omg.PortableServer.POAManagerPackage.State; +import org.omg.SendingContext.RunTime; + +import java.io.ByteArrayOutputStream; +import java.io.DataOutputStream; +import java.io.Externalizable; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.rmi.Remote; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Iterator; +import java.util.TreeSet; +import java.util.WeakHashMap; + +import javax.rmi.PortableRemoteObject; +import javax.rmi.CORBA.Stub; +import javax.rmi.CORBA.Tie; +import javax.rmi.CORBA.Util; + +/** + * Defines methods that must be accessible in several derived classes. + * + * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) + */ +public class RmiUtilities +{ + /** + * The currently used RMI-IIOP version format. + */ + public static byte VERSION = 1; + + /** + * The non - writable class fields. + */ + static final int NON_WRITABLE = Modifier.STATIC | Modifier.TRANSIENT; + + /** + * The standard String repository Id. + */ + public static final String RMI_STRING_ID = StringValueHelper.id(); + + /** + * The standard Class repository Id. + */ + public static final String RMI_CLASS_ID = "RMI:javax.rmi.CORBA.ClassDesc:2BABDA04587ADCCC:CFBF02CF5294176B"; + + /** + * The standard string array repository Id. + */ + public static final String RMI_STRING_ARRAY_ID = "RMI:[Ljava.lang.String;:071DA8BE7F971128:A0F0A4387A3BB342"; + + /** + * An instance of the wide string value helper for writing strings. + */ + static WStringValueHelper wStringValueHelper = new WStringValueHelper(); + + /** + * Set of serializable classes that have .writeObject and .readObject defined. + * Contains weak references to ensure that the classes will be unloadable. + */ + WeakHashMap io_format = new WeakHashMap(); + + /** + * The standard IO format with no .writeObject and .readObject defined. + */ + static final Object STANDARD = new Object(); + + /** + * The custom IO format with .writeObject and .readObject defined, + * defaultWriteObject called. + */ + static final Object CUSTOM_DWO = new Object(); + + /** + * The custom IO format with .writeObject and .readObject defined, + * defaultWriteObject has not been called. + */ + static final Object CUSTOM_NO_DWO = new Object(); + + /** + * The arguments for readObject. + */ + static final Class[] READ_OBJECT_ARGS = new Class[] { ObjectInputStream.class }; + + /** + * The arguments for writeObject. + */ + static final Class[] WRITE_OBJECT_ARGS = new Class[] { ObjectOutputStream.class }; + + /** + * The undocumented field that is heading the Sun's object data, written with + * writeObject. + */ + static final int S_X = 16908034; + + /** + * Write all fields of the passed value. + */ + void writeFields(OutputStream an_output, Serializable object) + { + org.omg.CORBA_2_3.portable.OutputStream output = (org.omg.CORBA_2_3.portable.OutputStream) an_output; + try + { + Class o_class = object.getClass(); + Field[] fields = getWritableFields(o_class); + Field f; + + Class fc; + + for (int i = 0; i < fields.length; i++) + { + f = fields[i]; + fc = f.getType(); + Object v = f.get(object); + + if (fc == String.class) + { + output.write_value((Serializable) v, wStringValueHelper); + } + else if (fc == int.class) + output.write_long(((Integer) v).intValue()); + else if (fc == long.class) + output.write_longlong(((Number) v).longValue()); + else if (fc == double.class) + output.write_double(((Number) v).doubleValue()); + else if (fc == float.class) + output.write_float(((Number) v).floatValue()); + else if (fc == boolean.class) + output.write_boolean(((Boolean) v).booleanValue()); + else if (fc == short.class) + output.write_short(((Number) v).shortValue()); + else if (fc == byte.class) + output.write_octet(((Number) v).byteValue()); + else if (fc == char.class) + output.write_wchar(((Character) v).charValue()); + else + { + if (!fc.isInterface() && Remote.class.isAssignableFrom(fc)) + fc = getExportedInterface(fc); + writeMember(output, v, fc); + } + } + } + catch (Exception ex) + { + MARSHAL m = new MARSHAL("Cannot write " + object); + m.minor = Minor.ValueFields; + m.initCause(ex); + throw m; + } + } + + /** + * Write a memeber (field) of the data structure. + */ + void writeMember(org.omg.CORBA_2_3.portable.OutputStream output, + Object object, Class xClass) + { + if (output instanceof gnuValueStream) + { + gnuRuntime g = ((gnuValueStream) output).getRunTime(); + // Reset the target as we are already beyond the critical point + // where is must have the value being written. + if (g != null) + g.target = null; + } + if (Serializable.class.isAssignableFrom(xClass) + || Remote.class.isAssignableFrom(xClass)) + { + // Object handles null reference on its own. + if (org.omg.CORBA.Object.class.isAssignableFrom(xClass) + || Remote.class.isAssignableFrom(xClass)) + { + if (object == null) + output.write_Object(null); + else if (isTieRequired(object)) + exportTie(output, object, xClass); + else + writeValue(output, (Serializable) object); + } + else + output.write_value((Serializable) object, xClass); + } + else + { + MARSHAL m = new MARSHAL(xClass + " is not Serializable"); + m.minor = Minor.NonSerializable; + throw m; + } + } + + /** + * Check if the object must be wrapped into Tie, connected to the ORB and then + * the corresponding Stub be written. + */ + public boolean isTieRequired(Object object) + { + return object instanceof Remote && !(object instanceof Stub); + } + + /** + * Get the interface under that the class of this object must be exposed. The + * interface must be derived from Remote. + */ + Class getExportedInterface(Object object) + throws MARSHAL + { + Class fc = null; + Class[] interfaces = object.getClass().getInterfaces(); + for (int i = 0; i < interfaces.length; i++) + { + if (!Remote.class.equals(interfaces[i])) + if (Remote.class.isAssignableFrom(interfaces[i])) + { + if (fc == null) + fc = interfaces[i]; + else + { + MARSHAL m = new MARSHAL("Both " + fc + " and " + interfaces[i] + + " extends Remote"); + m.minor = Minor.TargetConversion; + throw m; + } + } + } + if (fc == null) + { + MARSHAL m = new MARSHAL(object.getClass() + + " does not implement any interface, derived from Remote"); + m.minor = Minor.TargetConversion; + throw m; + } + return fc; + } + + /** + * Get the persistent hash code for the given class, as defined by OMG + * standard. The inheritance, field names and types (but not the visibility) + * are taken into consideration as well as the presence of the writeObject + * method are taken into consideration. The class name and methods, if any, + * are not taken into consideration. + */ + public static long getHashCode(Class c) + { + Class of = c.isArray() ? c.getComponentType() : null; + if (c.isArray() + && ((!Serializable.class.isAssignableFrom(of) || of.isPrimitive() || Remote.class.isAssignableFrom(of)))) + return 0; + if (!Serializable.class.isAssignableFrom(c)) + return 0; + try + { + ByteArrayOutputStream bout = new ByteArrayOutputStream(); + DataOutputStream out = new DataOutputStream(bout); + + Class superClass = c.getSuperclass(); + if (superClass != null) + out.writeLong(getHashCode(superClass)); + + int writeObjectPresentCode; + try + { + c.getDeclaredMethod("writeObject", + new Class[] { ObjectOutputStream.class }); + writeObjectPresentCode = 2; // Exists. + } + catch (NoSuchMethodException e) + { + writeObjectPresentCode = 1; // Missing. + } + out.writeInt(writeObjectPresentCode); + + Field[] fields = c.getDeclaredFields(); + + Arrays.sort(fields, new Comparator() + { + public int compare(Object a, Object b) + { + Field fa = (Field) a; + Field fb = (Field) b; + return fa.getName().compareTo(fb.getName()); + } + }); + + Field f; + for (int i = 0; i < fields.length; i++) + { + f = fields[i]; + if ((f.getModifiers() & NON_WRITABLE) == 0) + { + out.writeUTF(f.getName()); + out.writeUTF(getDescriptor(f.getType())); + } + } + + out.flush(); + out.close(); + MessageDigest shaDigest; + try + { + shaDigest = MessageDigest.getInstance("SHA"); + } + catch (Exception ex) + { + throw new InternalError("SHA digesting algorithm is not available"); + } + + // Return the digest value to the calling + // method as an array of bytes. + byte[] sha = shaDigest.digest(bout.toByteArray()); + + long hash = 0; + for (int i = 0; i < Math.min(8, sha.length); i++) + { + hash += (long) (sha[i] & 255) << (i * 8); + } + return hash; + } + catch (IOException ioex) + { + throw new Unexpected(ioex); + } + } + + /** + * Converts to hexadecimal string, supplementing leading zeros. + */ + public static String toHex(long l) + { + StringBuffer b = new StringBuffer(); + b.append(Long.toHexString(l).toUpperCase()); + while (b.length() < 16) + b.insert(0, '0'); + return b.toString(); + } + + /** + * Returns a <code>String</code> representing the type-encoding of a class. + */ + static String getDescriptor(Class type) + { + if (type.equals(boolean.class)) + return "Z"; + if (type.equals(byte.class)) + return "B"; + if (type.equals(short.class)) + return "S"; + if (type.equals(char.class)) + return "C"; + if (type.equals(int.class)) + return "I"; + if (type.equals(long.class)) + return "J"; + if (type.equals(float.class)) + return "F"; + if (type.equals(double.class)) + return "D"; + if (type.equals(void.class)) + return "V"; + else if (type.isArray()) + { + StringBuffer l = new StringBuffer("["); + Class component = type.getComponentType(); + + while (component.isArray()) + { + l.append('['); + component = component.getComponentType(); + } + + l.append('L'); + l.append(component.getName().replace('.', '/')); + l.append(';'); + return l.toString(); + } + else + return "L" + type.getName().replace('.', '/') + ';'; + } + + public static Field[] getWritableFields(Class c) + { + TreeSet set = new TreeSet(new Comparator() + { + public int compare(Object a, Object b) + { + return ((Field) a).getName().compareTo(((Field) b).getName()); + } + }); + + while (!c.equals(Object.class)) + { + Field[] f = c.getDeclaredFields(); + for (int i = 0; i < f.length; i++) + { + if ((f[i].getModifiers() & NON_WRITABLE) == 0) + { + f[i].setAccessible(true); + set.add(f[i]); + } + } + c = c.getSuperclass(); + } + + Field[] r = new Field[set.size()]; + int p = 0; + Iterator it = set.iterator(); + while (it.hasNext()) + { + r[p++] = (Field) it.next(); + } + return r; + } + + /** + * The method is called for Remotes that are not Stubs. It is assumed, that + * the Remote is an implementation. The method searches for the suitable tie + * and, if found, exports it by creating and connecting the stub. Such export + * is supported since jdk 1.5. + */ + void exportTie(org.omg.CORBA_2_3.portable.OutputStream output, + Object implementation, Class interfaceClass) + { + try + { + // Remote, but non - stub class (implementation) + // must be replaced by stub. + Tie t = Util.getTie((Remote) implementation); + if (t instanceof Servant) + { + POA rootPoa = POAHelper.narrow(output.orb().resolve_initial_references( + "RootPOA")); + org.omg.CORBA.Object co = rootPoa.servant_to_reference((Servant) t); + Stub stub = (Stub) PortableRemoteObject.narrow(co, interfaceClass); + writeRemoteObject(output, stub); + + if (rootPoa.the_POAManager().get_state().value() == State._HOLDING) + rootPoa.the_POAManager().activate(); + } + else if (t instanceof org.omg.CORBA.Object) + { + org.omg.CORBA.Object co = (org.omg.CORBA.Object) t; + output.orb().connect(co); + + Stub stub = (Stub) PortableRemoteObject.narrow(co, interfaceClass); + writeRemoteObject(output, stub); + } + } + catch (Exception ex) + { + MARSHAL m = new MARSHAL("Unable to export " + implementation); + m.minor = Minor.TargetConversion; + m.initCause(ex); + throw m; + } + } + + /** + * Start the ORB, if it is not already runnning. + */ + void ensureOrbRunning(org.omg.CORBA_2_3.portable.OutputStream output) + { + // Ensure ORB is running. + if (output.orb() instanceof OrbFunctional) + { + ((OrbFunctional) output.orb()).ensureRunning(); + } + } + + /** + * Write data to the CORBA output stream. Writes the object contents only; the + * header must be already written. For object, containing objects, may be + * called recursively. + * + * @param an_output a stream to write to, must be + * org.omg.CORBA_2_3.portable.OutputStream + * @param object an object to write. + */ + public void writeRemoteObject(OutputStream an_output, Object object) + { + org.omg.CORBA_2_3.portable.OutputStream output = (org.omg.CORBA_2_3.portable.OutputStream) an_output; + + if (isTieRequired(object)) + { + // Find the interface that is implemented by the object and extends + // Remote. + Class fc = getExportedInterface(object); + exportTie(output, object, fc); + } + else if (object instanceof org.omg.CORBA.Object) + { + ensureOrbRunning(output); + an_output.write_Object((org.omg.CORBA.Object) object); + } + else if (object != null && object instanceof Serializable) + writeFields(an_output, (Serializable) object); + } + + /** + * Write data to the CORBA output stream. Writes the object contents only; the + * header must be already written. For object, containing objects, may be + * called recursively. + * + * @param an_output a stream to write to, must be + * org.omg.CORBA_2_3.portable.OutputStream + * @param object an object to write. + */ + public void writeValue(OutputStream an_output, Serializable object) + { + org.omg.CORBA_2_3.portable.OutputStream output = (org.omg.CORBA_2_3.portable.OutputStream) an_output; + + if (isTieRequired(object)) + { + // Find the interface that is implemented by the object and extends + // Remote. + Class fc = getExportedInterface(object); + exportTie(output, object, fc); + } + else if (object instanceof org.omg.CORBA.Object) + { + ensureOrbRunning(output); + an_output.write_Object((org.omg.CORBA.Object) object); + } + else if (object instanceof Externalizable) + { + try + { + ObjectOutputStream stream = new CorbaOutput(output, object, + this); + stream.write(VERSION); + ((Externalizable) object).writeExternal(stream); + } + catch (Exception ex) + { + MARSHAL m = new MARSHAL("writeExternal failed"); + m.minor = Minor.Value; + m.initCause(ex); + throw m; + } + } + else if (object instanceof Serializable) + { + Object mode = null; + synchronized (io_format) + { + mode = io_format.get(object.getClass()); + if (mode == STANDARD) + { + writeFields(an_output, (Serializable) object); + return; + } + } + try + { + Method m = object.getClass().getDeclaredMethod("writeObject", + WRITE_OBJECT_ARGS); + m.setAccessible(true); // May be private. + + try + { + ObjectOutputStream stream = new CorbaOutput(output, + object, this); + + // Write version. + stream.write(VERSION); + + if (mode == CUSTOM_DWO) + // Write true, supposing that the defaultWriteObject + // has been called. + stream.write(1); + else if (mode == CUSTOM_NO_DWO) + // Write false (has not been called) + stream.write(0); + else + { + // Measure. + DefaultWriteObjectTester tester = new DefaultWriteObjectTester(object); + m.invoke(object, new Object[] { tester }); + + synchronized (io_format) + { + io_format.put(object.getClass(), + tester.dwo_called ? CUSTOM_DWO : CUSTOM_NO_DWO); + stream.write(tester.dwo_called ? 1 : 0); + } + } + + m.invoke(object, new Object[] { stream }); + stream.flush(); + } + catch (Exception ex) + { + MARSHAL mx = new MARSHAL(object.getClass().getName() + + ".writeObject failed"); + mx.initCause(ex); + throw mx; + } + } + catch (NoSuchMethodException e) + { + // Write in a standard way. + writeFields(an_output, (Serializable) object); + synchronized (io_format) + { + io_format.put(object.getClass(), STANDARD); + } + } + } + } + + /** + * Read data from the CDR input stream. Reads the object contents only; the + * header must be already read (the repository id or ids ara passed). For + * object, containing objects, may be called recursively. + * + * @param an_input the stream to read from, must be + * org.omg.CORBA_2_3.portable.InputStream + * @param object the instance of the object being read. + * @param id the repository Id from the stream in the case when single id was + * specified. + * @param ids the repository Ids from the stream in the case when multiple ids + * were specified. + * @param codebase the codebase, if it was included in the header of the value + * type. Null if not codebase was included. + * + * @return the object, extracted from the stream. + */ + /** + * Read value from the input stream in the case when the value is not + * Streamable or CustomMarshalled. + */ + public Serializable readValue(InputStream in, int offset, Class clz, + String repositoryID, RunTime sender) + { + if (in instanceof HeadlessInput) + ((HeadlessInput) in).subsequentCalls = true; + + gnuRuntime g; + Serializable object = null; + + try + { + g = (gnuRuntime) sender; + object = g.target; + } + catch (ClassCastException e) + { + // Working with the other CORBA implementation. + g = null; + } + + org.omg.CORBA_2_3.portable.InputStream input = (org.omg.CORBA_2_3.portable.InputStream) in; + + if (Remote.class.isAssignableFrom(clz) + || ValueBase.class.isAssignableFrom(clz)) + { + // Interface is narrowed into Stub. + if (clz.isInterface()) + try + { + clz = Util.loadClass( + PortableRemoteObjectDelegateImpl.getStubClassName(clz.getName()), + null, clz.getClassLoader()); + } + catch (ClassNotFoundException e) + { + MARSHAL m = new MARSHAL("Cannot get stub from interface " + + clz.getClass().getName()); + m.minor = Minor.TargetConversion; + m.initCause(e); + throw m; + } + + // Remote needs special handling. + if (ObjectImpl.class.isAssignableFrom(clz)) + { + // First read CORBA object reference. + Object ro = input.read_Object(); + + ObjectImpl obj = (ObjectImpl) ro; + if (obj == null) + return null; + + Delegate delegate = obj._get_delegate(); + object = instantiate(offset, clz, g); + ((ObjectImpl) object)._set_delegate(delegate); + } + // The object - specific data follows. + } + else if (org.omg.CORBA.Object.class.isAssignableFrom(clz)) + object = (Serializable) input.read_Object(); + + if (object == null) + object = instantiate(offset, clz, g); + + // The sentence below prevents attempt to read the internal fields of the + // ObjectImpl (or RMI Stub) that might follow the object definition. + // Sun's jre 1.5 does not write this information. The stubs, generated + // by rmic, does not contain such fields. + if (object instanceof ObjectImpl) + return object; + + if (object instanceof Externalizable) + { + try + { + CorbaInput stream = new CorbaInput(input, object, this, + offset, repositoryID, g); + + byte version = stream.readByte(); + if (version != 1) + throw new MARSHAL("Unsuported RMI-IIOP version " + version); + + ((Externalizable) object).readExternal(stream); + } + catch (Exception ex) + { + MARSHAL m = new MARSHAL("readExternal failed"); + m.initCause(ex); + throw m; + } + } + else + { + Object mode = null; + synchronized (io_format) + { + mode = io_format.get(object.getClass()); + } + + if (mode == STANDARD) + { + readFields(offset, repositoryID, object, input, g); + } + else + { + try + { + Method m = object.getClass().getDeclaredMethod("readObject", + READ_OBJECT_ARGS); + try + { + m.setAccessible(true); // May be private. + + CorbaInput stream = new CorbaInput(input, + object, this, offset, repositoryID, g); + + byte version = stream.readByte(); + if (version != 1) + throw new MARSHAL("Unsuported RMI-IIOP version " + + version); + + // This would indicate is defaultWriteObject has been + // called, + // but the readObject method normally takes care about this. + boolean dwo = stream.readByte() != 0; + + m.invoke(object, new Object[] { stream }); + synchronized (io_format) + { + io_format.put(object.getClass(), dwo ? CUSTOM_DWO + : CUSTOM_NO_DWO); + } + } + catch (Exception ex) + { + ex.printStackTrace(); + MARSHAL mx = new MARSHAL(object.getClass().getName() + + ".readObject failed"); + mx.initCause(ex); + throw mx; + } + } + catch (NoSuchMethodException e) + { + // Read in a standard way. + synchronized (io_format) + { + io_format.put(object.getClass(), STANDARD); + readFields(offset, repositoryID, object, input, g); + } + } + } + } + return object; + } + + /** + * Create an instance. + */ + Serializable instantiate(int offset, Class clz, gnuRuntime g) + throws MARSHAL + { + Serializable object; + try + { + object = (Serializable) Vio.instantiateAnyWay(clz); + g.objectWritten(object, offset); + } + catch (Exception e) + { + MARSHAL m = new MARSHAL("Unable to instantiate " + clz); + m.minor = Minor.Instantiation; + m.initCause(e); + throw m; + } + return object; + } + + /** + * Read fields of the object. + */ + void readFields(int offset, String repositoryID, Serializable object, + org.omg.CORBA_2_3.portable.InputStream input, gnuRuntime r) + throws MARSHAL + { + Field f = null; + Class o_class = object.getClass(); + + try + { + // The returned field array must already be in canonical order. + Field[] fields = getWritableFields(o_class); + + Class fc; + + for (int i = 0; i < fields.length; i++) + { + // Full value type header expected ahead. + if (input instanceof HeadlessInput) + ((HeadlessInput) input).subsequentCalls = true; + + f = fields[i]; + fc = f.getType(); + + Object v; + + if (fc == String.class) + { + v = input.read_value(wStringValueHelper); + } + else if (fc == int.class) + v = new Integer(input.read_long()); + else if (fc == long.class) + v = new Long(input.read_longlong()); + else if (fc == double.class) + v = new Double(input.read_double()); + else if (fc == float.class) + v = new Float(input.read_float()); + else if (fc == boolean.class) + v = input.read_boolean() ? Boolean.TRUE : Boolean.FALSE; + else if (fc == short.class) + v = new Short(input.read_short()); + else if (fc == byte.class) + v = new Byte(input.read_octet()); + else if (fc == char.class) + v = new Character(input.read_char()); + else if (org.omg.CORBA.Object.class.isAssignableFrom(fc) + || Remote.class.isAssignableFrom(fc)) + { + v = readValue(input, offset, fc, null, r); + } + else + { + v = Vio.read(input, fc); + } + + f.set(object, v); + } + } + catch (Exception ex) + { + MARSHAL m = new MARSHAL("Cannot read " + o_class.getName() + " field " + + f); + m.initCause(ex); + m.minor = Minor.ValueFields; + throw m; + } + } + +} diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/StubDelegateImpl.java b/libjava/classpath/gnu/javax/rmi/CORBA/StubDelegateImpl.java index 998d59e3379..afc254ddb49 100644 --- a/libjava/classpath/gnu/javax/rmi/CORBA/StubDelegateImpl.java +++ b/libjava/classpath/gnu/javax/rmi/CORBA/StubDelegateImpl.java @@ -1,5 +1,5 @@ -/* StubDelegateImpl.java -- - Copyright (C) 2002, 2004 Free Software Foundation, Inc. +/* StubDelegateImpl.java -- + Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,67 +38,273 @@ exception statement from your version. */ package gnu.javax.rmi.CORBA; +import gnu.CORBA.ObjectCreator; +import gnu.CORBA.Unexpected; +import gnu.CORBA.CDR.BufferredCdrInput; +import gnu.CORBA.CDR.BufferedCdrOutput; + import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; +import java.rmi.Remote; import java.rmi.RemoteException; + +import javax.rmi.PortableRemoteObject; import javax.rmi.CORBA.Stub; import javax.rmi.CORBA.StubDelegate; +import javax.rmi.CORBA.Tie; +import javax.rmi.CORBA.Util; +import org.omg.CORBA.BAD_PARAM; +import org.omg.CORBA.ORB; +import org.omg.CORBA.portable.Delegate; +import org.omg.CORBA.portable.ObjectImpl; +import org.omg.PortableServer.POA; +import org.omg.PortableServer.POAHelper; +import org.omg.PortableServer.Servant; +import org.omg.PortableServer.POAManagerPackage.State; + +/** + * The default stub delegate. + * + * @author Wu Gansha (gansha.wu@intel.com) (stub) + * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) (implementation) + */ public class StubDelegateImpl implements StubDelegate { - - private int hashCode; - - public StubDelegateImpl(){ - hashCode = 0; + /** + * <p> + * Finds the suitable {@link Tie} for this Stub and connects it to the given + * ORB. The tie is found by the name pattern. If the found tie is derived from + * {@link org.omg.CORBA.PortableServer.Servant}, it is connected to the root + * POA, also activating it (if not already active). + * </p> + * <p> + * This method does not allow to specify, to which POA the found Tie must be + * connected and requires to use the deprecated method {@link ORB#connect}. + * Many useful POA features remain unaccessible. A better alternative it might + * be to generate a {@link org.omg.CORBA.PortableServer.Servant} - derived Tie + * (-poa key in rmic) and connect it to POA in one of the many ways, listed in + * the description of the {@link orb.omg.PortableServer} package). The + * obtained CORBA object can be narrowed into stub using + * {@link PortableRemoteObject#narrow}. + * </p> + * + * @param orb the ORB where the Stub must be connected. + * + * @throws RemoteException if the stub is already connected to some other ORB. + * If the stub is already connected to the ORB that was passed as parameter, + * the method returns without action. + * + * @throws BAD_PARAM if the name of this stub does not match the stub name + * pattern, "_*_Stub" or if the Tie class, "_*Impl_Tie", does not exists or an + * instance of this class cannot be instantiated. + */ + public void connect(Stub self, ORB orb) + throws RemoteException + { + connect(self, orb, null); } - // XXX javax.rmi.ORB -> org.omg.CORBA.ORB - public void connect(Stub self, javax.rmi.ORB orb) + + /** + * Connect when the POA is specified. + */ + public static void connect(Stub self, ORB orb, POA poa) throws RemoteException { - throw new Error("Not implemented for StubDelegate"); + ORB oorb = null; + try + { + Delegate d = self._get_delegate(); + if (d != null) + oorb = d.orb(self); + } + catch (Exception e) + { + // Failed to get Delegate or ORB. + // (possible ony for user-written Stubs). + } + + if (oorb != null) + { + if (!oorb.equals(orb)) + throw new RemoteException("Stub " + self + + " is connected to another ORB, " + orb); + else + return; + } + + Tie t = null; + if (self instanceof Remote) + t = Util.getTie((Remote) self); + + // Find by name pattern. + if (t == null) + t = getTieFromStub(self); + + Delegate delegate; + + if (t instanceof Servant) + { + try + { + if (poa == null) + { + poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA")); + // Activate if not active. + if (poa.the_POAManager().get_state().value() == State._HOLDING) + poa.the_POAManager().activate(); + } + + ObjectImpl obj = (ObjectImpl) poa.servant_to_reference((Servant) t); + delegate = obj._get_delegate(); + } + catch (Exception ex) + { + throw new Unexpected(ex); + } + } + else if (t instanceof ObjectImpl) + { + ObjectImpl o = (ObjectImpl) t; + orb.connect(o); + delegate = o._get_delegate(); + } + else + throw new BAD_PARAM("The Tie must be either Servant or ObjectImpl"); + + self._set_delegate(delegate); } - public boolean equals(Stub self, Object obj) + /** + * Locate a tie class, appropriate to the given stub class, by the name + * pattern. + */ + public static Tie getTieFromStub(java.lang.Object self) { - if(self == null || obj == null) - return self == obj; - if(!(obj instanceof Stub)) - return false; - return self.hashCode() == ((Stub)obj).hashCode(); + Tie t; + String sn = self.getClass().getName(); + if (!sn.endsWith("_Stub")) + throw new BAD_PARAM("The stub name, " + sn + + ", does not match _*_Stub pattern"); + + String tn = sn.substring(0, sn.length() - "_Stub".length()) + "Impl_Tie"; + Class tieClass = null; + + try + { + tieClass = ObjectCreator.forName(tn); + t = (Tie) tieClass.newInstance(); + if (self instanceof Remote) + Util.registerTarget(t, (Remote) self); + } + catch (Exception e) + { + BAD_PARAM bad = new BAD_PARAM("Unable to instantiate '" + tn + "'"); + bad.initCause(e); + throw bad; + } + return t; + } + + /** + * Compare two stubs for equality. + */ + public boolean equals(Stub self, java.lang.Object obj) + { + if (obj instanceof ObjectImpl) + { + ObjectImpl other = (ObjectImpl) obj; + Delegate d1 = other._get_delegate(); + Delegate d2 = self._get_delegate(); + if (d1 == null || d2 == null) + return d1 == d2; + else + return d1.equals(d2); + } + else return false; } + /** + * Get the hash code (from IOR reference). + */ public int hashCode(Stub self) { - //FIX ME - return hashCode; + Delegate d = self._get_delegate(); + return d==null?0:d.hashCode(); } + /** + * Returns the IOR reference of the connected ORB. + * + * @see ORB#object_to_string(org.omg.CORBA.Object); + */ public String toString(Stub self) { try { - return self._orb().object_to_string(self); + return self._orb().object_to_string(self); } - // XXX javax.rmi.BAD_OPERATION -> org.omg.CORBA.BAD_OPERATION - catch(javax.rmi.BAD_OPERATION bad_operation) + catch (Exception ex) { - return null; + return null; } } - public void readObject(Stub self, ObjectInputStream s) + /** + * This should never be called. The ORB must be supplied. + * + * @see #connect + */ + public void readObject(Stub self, ObjectInputStream input) throws IOException, ClassNotFoundException { - throw new Error("Not implemented for StubDelegate"); + readObject(self, input, null); } - public void writeObject(Stub self, ObjectOutputStream s) + /** + * Read as CORBA object when the ORB is known. The ORB must be set under the + * previous call of Stub.connect. The Stub is automatically registered with + * this ORB. + */ + public void readObject(Stub self, ObjectInputStream input, ORB orb) + throws IOException, ClassNotFoundException + { + byte[] b = (byte[]) input.readObject(); + BufferredCdrInput in = new BufferredCdrInput(b); + + if (orb != null) + in.setOrb(orb); + + ObjectImpl r = (ObjectImpl) in.read_Object(); + + self._set_delegate(r._get_delegate()); + } + + /** + * Write as CORBA object. The ORB is taken from the + * org.omg.CORBA.portable.Delegate. The Stub is automatically registered with + * this ORB (if not already done). + */ + public void writeObject(Stub self, ObjectOutputStream output) + throws IOException + { + writeObject(self, output, null); + } + + /** + * Write as CORBA object. The ORB must be either set under the previous call + * of Stub.connect or it is taken from the org.omg.CORBA.portable.Delegate. + * The Stub is automatically registered with this ORB (if not already done). + */ + public void writeObject(Stub self, ObjectOutputStream output, ORB orb) throws IOException { - throw new Error("Not implemented for StubDelegate"); + BufferedCdrOutput out = new BufferedCdrOutput(); + out.setOrb(orb == null ? self._orb() : orb); + out.write_Object(self); + + output.writeObject(out.buffer.toByteArray()); } - -} +}
\ No newline at end of file diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/ValueHandlerImpl.java b/libjava/classpath/gnu/javax/rmi/CORBA/TieTargetRecord.java index 906381fe478..70e751a6f2c 100644 --- a/libjava/classpath/gnu/javax/rmi/CORBA/ValueHandlerImpl.java +++ b/libjava/classpath/gnu/javax/rmi/CORBA/TieTargetRecord.java @@ -1,5 +1,5 @@ -/* ValueHandlerImpl.java -- - Copyright (C) 2002 Free Software Foundation, Inc. +/* TieTargetRecord.java -- + Copyright (C) 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,45 +38,56 @@ exception statement from your version. */ package gnu.javax.rmi.CORBA; -import java.io.*; -//import org.omg.CORBA.portable.InputStream; -//import org.omg.CORBA.portable.OutputStream; -//import org.omg.SendingContext.RunTime; -import javax.rmi.CORBA.ValueHandler; +import java.util.HashSet; -public class ValueHandlerImpl - implements ValueHandler +import javax.rmi.CORBA.Tie; + +/** + * Represents a Tie, connected to possibly multiple invocation targets. + * + * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) + */ +public class TieTargetRecord { + /** + * The associated Tie. + */ + public final Tie tie; - public String getRMIRepositoryID(Class clz) - { - throw new Error("Not implemented for ValueHandler"); - } + /** + * The objects, exposing the tie. + */ + public HashSet targets = new HashSet(); - // XXX - Runtime -> RunTime - public Runtime getRunTimeCodeBase() + /** + * Create a new record. + */ + public TieTargetRecord(Tie a_tie) { - throw new Error("Not implemented for ValueHandler"); + tie = a_tie; } - - public boolean isCustomMarshaled(Class clz) - { - throw new Error("Not implemented for ValueHandler"); - } - - // XXX - Runtime -> RunTime - public Serializable readValue(InputStream in, int offset, Class clz, String repositoryID, Runtime sender) + + /** + * Add a target. + */ + public void add(Object target) { - throw new Error("Not implemented for ValueHandler"); + targets.add(target); } - - public Serializable writeReplace(Serializable value) + + /** + * Remove target. + */ + public void remove(Object target) { - throw new Error("Not implemented for ValueHandler"); + targets.remove(target); } - - public void writeValue(OutputStream out, Serializable value) + + /** + * Return true if the tie has no associated invocation targets. + */ + public boolean unused() { - throw new Error("Not implemented for ValueHandler"); + return targets.size() == 0; } } diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/UtilDelegateImpl.java b/libjava/classpath/gnu/javax/rmi/CORBA/UtilDelegateImpl.java index 7bed2aa22dc..66a4e24ff18 100644 --- a/libjava/classpath/gnu/javax/rmi/CORBA/UtilDelegateImpl.java +++ b/libjava/classpath/gnu/javax/rmi/CORBA/UtilDelegateImpl.java @@ -1,5 +1,5 @@ -/* UtilDelegateImpl.java -- - Copyright (C) 2002 Free Software Foundation, Inc. +/* UtilDelegateImpl.java -- + Copyright (C) 2002, 2005 Free Software Foundation, Inc. This file is part of GNU Classpath. @@ -38,115 +38,717 @@ exception statement from your version. */ package gnu.javax.rmi.CORBA; +import gnu.CORBA.Minor; +import gnu.CORBA.ObjectCreator; +import gnu.CORBA.Poa.ORB_1_4; +import gnu.CORBA.Poa.AOM; +import gnu.CORBA.Poa.gnuPOA; +import gnu.CORBA.typecodes.GeneralTypeCode; + +import org.omg.CORBA.Any; +import org.omg.CORBA.BAD_PARAM; +import org.omg.CORBA.COMM_FAILURE; +import org.omg.CORBA.CompletionStatus; +import org.omg.CORBA.INVALID_TRANSACTION; +import org.omg.CORBA.INV_OBJREF; +import org.omg.CORBA.MARSHAL; +import org.omg.CORBA.NO_PERMISSION; +import org.omg.CORBA.OBJECT_NOT_EXIST; +import org.omg.CORBA.OMGVMCID; +import org.omg.CORBA.ORB; +import org.omg.CORBA.SystemException; +import org.omg.CORBA.TCKind; +import org.omg.CORBA.TRANSACTION_REQUIRED; +import org.omg.CORBA.TRANSACTION_ROLLEDBACK; +import org.omg.CORBA.TypeCode; +import org.omg.CORBA.UNKNOWN; +import org.omg.CORBA.portable.InputStream; +import org.omg.CORBA.portable.OutputStream; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.rmi.AccessException; +import java.rmi.MarshalException; +import java.rmi.NoSuchObjectException; import java.rmi.Remote; import java.rmi.RemoteException; +import java.rmi.ServerError; +import java.rmi.ServerException; +import java.rmi.UnexpectedException; import java.rmi.server.RMIClassLoader; -import java.net.MalformedURLException; -import java.io.*; -//import org.omg.CORBA.ORB; -//import org.omg.CORBA.SystemException; -//import org.omg.CORBA.portable.InputStream; -//import org.omg.CORBA.portable.OutputStream; -import javax.rmi.CORBA.*; +import java.util.Hashtable; + +import javax.rmi.CORBA.Stub; +import javax.rmi.CORBA.Tie; +import javax.rmi.CORBA.Util; +import javax.rmi.CORBA.UtilDelegate; +import javax.rmi.CORBA.ValueHandler; +import javax.transaction.InvalidTransactionException; +import javax.transaction.TransactionRequiredException; +import javax.transaction.TransactionRolledbackException; +/** + * The implementation of UtilDelegate. + * + * @author Wu Gansha (gansha.wu@intel.com) (stub) + * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) (implementation) + */ public class UtilDelegateImpl + extends RmiUtilities implements UtilDelegate { - // XXX javax.rmi.ORB -> org.omg.CORBA.ORB - public Object copyObject(Object obj, javax.rmi.ORB orb) + /** + * The instance of the value handler, requested once. + */ + static ValueHandler m_ValueHandler; + + /** + * The global map of all ties to they records. + */ + static Hashtable m_Ties = new Hashtable(); + + /** + * The global map of all targets to they records. + */ + static Hashtable m_Targets = new Hashtable(); + + /** + * The standard package for that the exception names are omitted. + */ + static final String m_StandardPackage = "org.omg.CORBA."; + + /** + * Make a deep copy of the object. + */ + public Object copyObject(Object obj, ORB orb) throws RemoteException { - throw new Error("Not implemented for UtilDelegate"); + // Strings are immutable, can be shared. + if (obj instanceof String) + return obj; + else if (obj == null) + return null; + else if (obj instanceof String[] || obj instanceof String[][] + || obj instanceof String[][][]) + { + // String arrays can be just cloned. + return ((Object[]) obj).clone(); + } + else if (obj instanceof Serializable) + { + try + { + ByteArrayOutputStream a = new ByteArrayOutputStream(); + ObjectOutputStream ou = new ObjectOutputStream(a); + ou.writeObject(obj); + ou.close(); + ObjectInputStream input = new ObjectInputStream( + new ByteArrayInputStream(a.toByteArray())); + return input.readObject(); + } + catch (Exception ex) + { + RemoteException rex = new RemoteException("Cannot copy " + obj); + throw rex; + } + } + else + return obj; } - // XXX javax.rmi.ORB -> org.omg.CORBA.ORB - public Object[] copyObjects(Object obj[], javax.rmi.ORB orb) + /** + * Make a deep copy of the object array. + */ + public Object[] copyObjects(Object[] obj, ORB orb) throws RemoteException { - throw new Error("Not implemented for UtilDelegate"); + return (Object[]) copyObject(obj, orb); } public ValueHandler createValueHandler() { - throw new Error("Not implemented for UtilDelegate"); + if (m_ValueHandler == null) + m_ValueHandler = (ValueHandler) DelegateFactory.getInstance(DelegateFactory.VALUEHANDLER); + return m_ValueHandler; } - + + /** + * Returns the codebase of the given class. + */ public String getCodebase(Class clz) { - throw new Error("Not implemented for UtilDelegate"); + return RMIClassLoader.getClassAnnotation(clz); } - + + /** + * Get the Tie that handles invocations on the given target. If the target/Tie + * pair has not been previously registered using {@link #registerTarget}, + * this method tries to locate a tie class by the name pattern. If this + * succeeds, the tie-target pair is also registered. + * + * @return the Tie. + */ public Tie getTie(Remote target) { - throw new Error("Not implemented for UtilDelegate"); + synchronized (m_Targets) + { + Tie tie; + TieTargetRecord r = ((TieTargetRecord) m_Targets.get(target)); + if (r == null) + { + if (target instanceof Stub) + { + tie = StubDelegateImpl.getTieFromStub(target); + registerTarget(tie, target); + } + else + { + // Treat this as implementation. + String tieClassName = getTieClassName(target.getClass().getName()); + try + { + Class tieClass = Util.loadClass(tieClassName, null, + target.getClass().getClassLoader()); + tie = (Tie) tieClass.newInstance(); + } + catch (Exception e) + { + MARSHAL m = new MARSHAL("Unable to instantiate " + + tieClassName); + m.minor = Minor.TargetConversion; + m.initCause(e); + throw m; + } + tie.setTarget(target); + registerTarget(tie, target); + } + } + else + tie = r.tie; + return tie; + } + } + + /** + * Get the Stub class name for the name, representing the given interface. + */ + private String getTieClassName(String interf) + { + String stubClassName; + int p = interf.lastIndexOf('.'); + + if (p < 0) + // The interface is defined in the default package. + stubClassName = "_" + interf + "_Tie"; + else + stubClassName = interf.substring(0, p + 1) + "_" + + interf.substring(p + 1) + "_Tie"; + return stubClassName; } - + + /** + * Register the Tie-target pair. As the Tie is a Servant, it can potentially + * be connected to several objects and hence may be registered with several + * targets. + */ + public void registerTarget(Tie tie, Remote target) + { + synchronized (m_Ties) + { + synchronized (m_Targets) + { + TieTargetRecord r = (TieTargetRecord) m_Ties.get(tie); + if (r == null) + { + // First registration for this Tie. + r = new TieTargetRecord(tie); + m_Ties.put(tie, r); + } + if (target != null) + { + r.add(target); + m_Targets.put(target, r); + } + } + } + } + + /** + * Deactivate the associated Tie, if it is found and is not connected to other + * registered targets. Independing from the POA policies, the transparent + * reactivation will not be possible. + */ + public void unexportObject(Remote target) + throws NoSuchObjectException + { + synchronized (m_Ties) + { + synchronized (m_Targets) + { + TieTargetRecord r = ((TieTargetRecord) m_Targets.get(target)); + if (r != null) + { + if (target instanceof org.omg.CORBA.Object) + r.tie.orb().disconnect((org.omg.CORBA.Object) target); + + if (r.unused()) + { + m_Targets.remove(target); + m_Ties.remove(r.tie); + r.tie.deactivate(); + + if (r.tie.orb() instanceof ORB_1_4) + { + // Standard case, when more deep cleanup is possible. + // Independing from the POA policies, the object will + // not be activable transparently. + ORB_1_4 orb = (ORB_1_4) r.tie.orb(); + + if (target instanceof org.omg.CORBA.Object) + { + AOM.Obj record = orb.rootPOA.findObject((org.omg.CORBA.Object) target); + + if (record != null && record.servant == r.tie + && record.poa instanceof gnuPOA) + { + ((gnuPOA) record.poa).aom.remove(record.key); + record.deactivated = true; + record.servant = null; + } + } + } + } + } + } + } + } + + /** + * Checks if the given stub is local. + * + * @param stub a stub to check. + * @return true if the stub is local, false otherwise. + */ public boolean isLocal(Stub stub) throws RemoteException { - throw new Error("Not implemented for UtilDelegate"); + try + { + return stub._is_local(); + } + catch (SystemException e) + { + RemoteException rex = new RemoteException(); + rex.initCause(e); + throw rex; + } } + /** + * Load the class. The method uses class loaders from the call stact first. If + * this fails, the further behaviour depends on the System Property + * "java.rmi.server.useCodebaseOnly" with default value "false". + * + * <ul> + * <li>Try the current thread context class loader first.</li> + * <li>If remoteCodebase is non-null and useCodebaseOnly is "false" then call + * java.rmi.server.RMIClassLoader.loadClass (remoteCodebase, className)</li> + * <li> If remoteCodebase is null or useCodebaseOnly is true then call + * java.rmi.server.RMIClassLoader.loadClass(className)</li> + * <li>If a class is still not successfully loaded and the loader != null + * then try Class.forName(className, false, loader). </li> + * </ul> + * + * @param className the name of the class. + * @param remoteCodebase the codebase. + * @param loader the class loader. + * @return the loaded class. + * + * @throws ClassNotFoundException of the class cannot be loaded. + */ public Class loadClass(String className, String remoteCodebase, - ClassLoader loader) + ClassLoader loader) throws ClassNotFoundException { - try{ - if (remoteCodebase == null) - return RMIClassLoader.loadClass(className); - else - return RMIClassLoader.loadClass(remoteCodebase, className); - } - catch (MalformedURLException e1) + if (loader == null) + loader = Thread.currentThread().getContextClassLoader(); + + String p_useCodebaseOnly = System.getProperty("java.rmi.server.useCodebaseOnly"); + + boolean useCodebaseOnly = p_useCodebaseOnly != null + && p_useCodebaseOnly.trim().equalsIgnoreCase("true"); + + try { - throw new ClassNotFoundException(className, e1); + if (remoteCodebase != null && !useCodebaseOnly) + return RMIClassLoader.loadClass(remoteCodebase, className); } - catch(ClassNotFoundException e2) + catch (Exception e) { - if(loader != null) - return loader.loadClass(className); - else - return null; + // This failed but try others. } + + try + { + if (remoteCodebase == null || useCodebaseOnly) + return RMIClassLoader.loadClass(remoteCodebase, className); + } + catch (Exception e) + { + // This failed but try others. + } + + if (loader != null) + return Class.forName(className, true, loader); + + throw new ClassNotFoundException(className + " at " + remoteCodebase); } + /** + * Converts CORBA {@link SystemException} into RMI {@link RemoteException}. + * The exception is converted as defined in the following table: + * <p> + * <table border = "1"> + * <tr> + * <th>CORBA Exception</th> + * <th>RMI Exception</th> + * </tr> + * <tr> + * <td>{@link COMM_FAILURE}</td> + * <td>{@link MarshalException}</td> + * </tr> + * <tr> + * <td>{@link INV_OBJREF}</td> + * <td>{@link NoSuchObjectException}</td> + * </tr> + * <tr> + * <td>{@link NO_PERMISSION}</td> + * <td>{@link AccessException}</td> + * </tr> + * <tr> + * <td>{@link MARSHAL}</td> + * <td>{@link MarshalException}</td> + * </tr> + * <tr> + * <td>{@link BAD_PARAM} (all other cases)</td> + * <td>{@link MarshalException}</td> + * </tr> + * <tr> + * <td>{@link OBJECT_NOT_EXIST}</td> + * <td>{@link NoSuchObjectException}</td> + * </tr> + * <tr> + * <td>{@link TRANSACTION_REQUIRED}</td> + * <td>{@link TransactionRequiredException}</td> + * </tr> + * <tr> + * <td>{@link TRANSACTION_ROLLEDBACK}</td> + * <td>{@link TransactionRolledbackException}</td> + * </tr> + * <tr> + * <td>{@link INVALID_TRANSACTION}</td> + * <td>{@link InvalidTransactionException}</td> + * </tr> + * <tr> + * <td bgcolor="lightgray">Any other {@link SystemException}</td> + * <td bgcolor="lightgray">{@link RemoteException}</td> + * </tr> + * </table> + * </p> + * <p> + * The exception detailed message always consists of + * <ol> + * <li>the string "CORBA "</li> + * <li>the CORBA name of the system exception</li> + * <li>single space</li> + * <li>the hexadecimal value of the system exception's minor code, preceeded + * by 0x (higher bits contain {@link OMGVMCID}).</li> + * <li>single space</li> + * <li>the {@link CompletionStatus} of the exception: "Yes", "No" or "Maybe".</li> + * </ol> + * <p> + * For instance, if the Internet connection was refused: + * </p> + * <p> + * <pre> + * <code>CORBA COMM_FAILURE 0x535500C9 No</code> + * </p> + * <p> + * The original CORBA exception is set as the cause of the RemoteException + * being created. + * </p> + */ public RemoteException mapSystemException(SystemException ex) { - throw new Error("Not implemented for UtilDelegate"); + RemoteException rex; + + String status; + + switch (ex.completed.value()) + { + case CompletionStatus._COMPLETED_MAYBE: + status = "Maybe"; + break; + + case CompletionStatus._COMPLETED_NO: + status = "No"; + break; + + case CompletionStatus._COMPLETED_YES: + status = "Yes"; + break; + + default: + status = "Unexpected completion status " + ex.completed.value(); + } + + String name = ex.getClass().getName(); + + if (name.startsWith(m_StandardPackage)) + name = name.substring(m_StandardPackage.length()); + + String message = "CORBA " + name + " 0x" + Integer.toHexString(ex.minor) + + " " + status; + + if (ex instanceof COMM_FAILURE) + rex = new MarshalException(message, ex); + else if (ex instanceof INV_OBJREF) + { + rex = new NoSuchObjectException(message); + rex.detail = ex; + } + else if (ex instanceof NO_PERMISSION) + rex = new AccessException(message, ex); + else if (ex instanceof MARSHAL) + rex = new MarshalException(message, ex); + else if (ex instanceof BAD_PARAM) + rex = new MarshalException(message, ex); + else if (ex instanceof OBJECT_NOT_EXIST) + { + rex = new NoSuchObjectException(message); + rex.detail = ex; + } + else if (ex instanceof TRANSACTION_REQUIRED) + { + rex = new TransactionRequiredException(message); + rex.detail = ex; + } + else if (ex instanceof TRANSACTION_ROLLEDBACK) + { + rex = new TransactionRolledbackException(message); + rex.detail = ex; + } + else if (ex instanceof INVALID_TRANSACTION) + { + rex = new InvalidTransactionException(message); + rex.detail = ex; + } + else if (ex instanceof UNKNOWN) + rex = wrapException(ex.getCause()); + else + rex = new RemoteException(message, ex); + + return rex; } - public Object readAny(InputStream in) + /** + * Converts the exception that was thrown by the implementation method on a + * server side into RemoteException that can be transferred and re-thrown on a + * client side. The method converts exceptions as defined in the following + * table: <table border = "1"> + * <tr> + * <th>Exception to map (or subclass)</th> + * <th>Maps into</th> + * </tr> + * <tr> + * <td>{@link Error}</td> + * <td>{@link ServerError}</td> + * </tr> + * <tr> + * <td>{@link RemoteException}</td> + * <td>{@link ServerException}</td> + * </tr> + * <tr> + * <td>{@link SystemException}</td> + * <td>wrapException({@link #mapSystemException})</td> + * </tr> + * <tr> + * <td>{@link RuntimeException}</td> + * <td><b>rethrows</b></td> + * </tr> + * <tr> + * <td>Any other exception</td> + * <td>{@link UnexpectedException}</td> + * </tr> + * </table> + * + * @param ex an exception that was thrown on a server side implementation. + * + * @return the corresponding RemoteException unless it is a RuntimeException. + * + * @throws RuntimeException the passed exception if it is an instance of + * RuntimeException. + * + * @specnote It is the same behavior, as in Suns implementations 1.4.0-1.5.0. + */ + public RemoteException wrapException(Throwable ex) + throws RuntimeException { - throw new Error("Not implemented for UtilDelegate"); + if (ex instanceof RuntimeException) + throw (RuntimeException) ex; + else if (ex instanceof Error) + return new ServerError(ex.getMessage(), (Error) ex); + else if (ex instanceof RemoteException) + return new ServerException(ex.getMessage(), (Exception) ex); + else if (ex instanceof SystemException) + return wrapException(mapSystemException((SystemException) ex)); + else + return new UnexpectedException("Unexpected", (Exception) ex); } - public void registerTarget(Tie tie, Remote target) + /** + * Write abstract interface to the CORBA output stream. The write format is + * matching CORBA abstract interface. Remotes and CORBA objects are written as + * objects, other classes are supposed to be value types and are written as + * such. {@link Remote}s are processed as defined in + * {@link #writeRemoteObject}. The written data contains discriminator, + * defining, that was written. Another method that writes the same content is + * {@link org.omg.CORBA_2_3.portable.OutputStream#write_abstract_interface(java.lang.Object)}. + * + * @param output a stream to write to, must be + * {@link org.omg.CORBA_2_3.portable.OutputStream}. + * + * @param object an object to write, must be CORBA object, Remote + */ + public void writeAbstractObject(OutputStream output, Object object) { - throw new Error("Not implemented for UtilDelegate"); + ((org.omg.CORBA_2_3.portable.OutputStream) output).write_abstract_interface(object); } - - public void unexportObject(Remote target) + + /** + * Write the passed java object to the output stream in the form of the CORBA + * {@link Any}. This includes creating an writing the object {@link TypeCode} + * first. Such Any can be later read by a non-RMI-IIOP CORBA implementation + * and manipulated, for instance, by means, provided in + * {@link org.omg.DynamicAny.DynAny}. Depending from the passed value, this + * method writes CORBA object, value type or value box. For value types Null + * is written with the abstract interface, its typecode having repository id + * "IDL:omg.org/CORBA/AbstractBase:1.0" and the empty string name. + * + * @param output the object to write. + * @param object the java object that must be written in the form of the CORBA + * {@link Any}. + */ + public void writeAny(OutputStream output, Object object) { - throw new Error("Not implemented for UtilDelegate"); + Any any = output.orb().create_any(); + if (object == null) + { + GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_abstract_interface); + t.setId("IDL:omg.org/CORBA/AbstractBase:1.0"); + t.setName(""); + any.type(t); + output.write_any(any); + return; + } + else if (object instanceof org.omg.CORBA.Object + && !(object instanceof Remote)) + { + // Write as value type. + boolean inserted = ObjectCreator.insertWithHelper(any, object); + if (inserted) + { + output.write_any(any); + return; + } + } + + if (object instanceof org.omg.CORBA.Object) + writeAnyAsRemote(output, object); + else if (object instanceof Serializable) + { + any.insert_Value((Serializable) object); + output.write_any(any); + } + else + { + MARSHAL m = new MARSHAL(object.getClass().getName() + + " must be CORBA Object, Remote or Serializable"); + m.minor = Minor.NonSerializable; + throw m; + } } - - public RemoteException wrapException(Throwable orig) + + /** + * Write Any as for remote object. + */ + void writeAnyAsRemote(OutputStream output, Object object) { - throw new Error("Not implemented for UtilDelegate"); + GeneralTypeCode t = new GeneralTypeCode(TCKind.tk_objref); + t.setId(m_ValueHandler.getRMIRepositoryID(object.getClass())); + t.setName(object.getClass().getName()); + + // Writing Any (typecode, followed by value). + output.write_TypeCode(t); + writeRemoteObject(output, object); } - - public void writeAbstractObject(OutputStream out, Object obj) + + /** + * Get the class name excluding the package name. + */ + String getName(String n) { - throw new Error("Not implemented for UtilDelegate"); + int p = n.lastIndexOf('.'); + if (p < 0) + return n; + else + return n.substring(p + 1); } - - public void writeAny(OutputStream out, Object obj) + + /** + * Read Any from the input stream. + */ + public Object readAny(InputStream input) { - throw new Error("Not implemented for UtilDelegate"); + return input.read_any(); } - public void writeRemoteObject(OutputStream out, Object obj) + /** + * Write the passed parameter to the output stream as CORBA object. If the + * parameter is an instance of Remote and not an instance of Stub, the method + * instantiates a suitable Tie, connects the parameter to this Tie and then + * connects that Tie to the ORB that is requested from the output stream. Then + * the object reference is written to the stream, making remote invocations + * possible. This method is used in write_value(..) method group in + * {@link org.omg.CORBA_2_3.portable.OutputStream} and also may be called + * directly from generated Stubs and Ties. + * + * @param output a stream to write to, must be + * org.omg.CORBA_2_3.portable.OutputStream + * @param object an object to write. + */ + public void writeRemoteObject(OutputStream an_output, Object object) { - throw new Error("Not implemented for UtilDelegate"); + org.omg.CORBA_2_3.portable.OutputStream output = (org.omg.CORBA_2_3.portable.OutputStream) an_output; + if (object == null) + an_output.write_Object(null); + else if (isTieRequired(object)) + { + // Find the interface that is implemented by the object and extends + // Remote. + Class fc = getExportedInterface(object); + exportTie(output, object, fc); + } + else if (object instanceof org.omg.CORBA.Object) + { + ensureOrbRunning(output); + an_output.write_Object((org.omg.CORBA.Object) object); + } + else if (object != null && object instanceof Serializable) + writeFields(an_output, (Serializable) object); } -} + +}
\ No newline at end of file diff --git a/libjava/classpath/gnu/javax/rmi/CORBA/ValueHandlerDelegateImpl.java b/libjava/classpath/gnu/javax/rmi/CORBA/ValueHandlerDelegateImpl.java new file mode 100644 index 00000000000..dc3b3cd6ee8 --- /dev/null +++ b/libjava/classpath/gnu/javax/rmi/CORBA/ValueHandlerDelegateImpl.java @@ -0,0 +1,163 @@ +/* ValueHandlerDelegateImpl.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.rmi.CORBA; + +import gnu.CORBA.CDR.gnuRuntime; + +import org.omg.CORBA.BAD_PARAM; +import org.omg.CORBA.CustomMarshal; +import org.omg.CORBA.portable.OutputStream; +import org.omg.CORBA.portable.Streamable; +import org.omg.SendingContext.RunTime; + +import java.io.Externalizable; +import java.io.ObjectStreamClass; +import java.io.Serializable; +import java.rmi.Remote; + +import javax.rmi.CORBA.ValueHandler; +import javax.rmi.CORBA.ValueHandlerMultiFormat; + +/** + * Implementation of the ValueHandler. + * + * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) (implementation) + */ +public class ValueHandlerDelegateImpl + extends RmiUtilities + implements ValueHandler, ValueHandlerMultiFormat +{ + /** + * Return the maximal supported stream format version. We currently + * support the version 1. + * + * TODO Support the version 2. + */ + public byte getMaximumStreamFormatVersion() + { + return 1; + } + + /** + * Write value using the given stream format version. + */ + public void writeValue(OutputStream output, Serializable value, byte version) + { + if (version!=1) + throw new BAD_PARAM("Unsupported stream format version "+version); + else + writeValue(output, value); + } + + /** + * This implementation associates RunTime with stream rather than with the + * value handler and this method is not used in the implementation. It is + * implemented just for the sake of compatibility. + */ + public RunTime getRunTimeCodeBase() + { + return new gnuRuntime(null, null); + } + + /** + * Checks if an instance of this class can write its fields itself. + */ + public boolean isCustomMarshaled(Class clz) + { + return CustomMarshal.class.isAssignableFrom(clz) + || Streamable.class.isAssignableFrom(clz); + } + + /** + * No replacement, returns the passed parameter. + */ + public Serializable writeReplace(Serializable value) + { + return value; + } + + /** + * Compute the repository id in the RMI hashed format. + */ + public String getRMIRepositoryID(final Class cx) + { + long hash = 0; + Class of = cx.isArray() ? cx.getComponentType() : null; + + if (cx.equals(String[].class)) + return RMI_STRING_ARRAY_ID; + else if (cx.equals(String.class)) + return RMI_STRING_ID; + else if (cx.equals(Class.class)) + return RMI_CLASS_ID; + else if (Remote.class.isAssignableFrom(cx) + || !Serializable.class.isAssignableFrom(cx) + || cx.isInterface() + || (cx.isArray() && (!Serializable.class.isAssignableFrom(of) + || of.isPrimitive() || Remote.class.isAssignableFrom(of))) + + ) + // Some classes that have zero hash code and serial no version id + // included. + return "RMI:" + cx.getName() + ":" + toHex(hash); + else if (cx.isArray()) + // Arrays have the same hashcode and uid as they components. + return "RMI:" + cx.getName() + ":" + toHex(getHashCode(of)) + ":" + + toHex(getSid(of)); + else + { + if (Externalizable.class.isAssignableFrom(cx)) + hash = 1; + else + hash = getHashCode(cx); + + return "RMI:" + cx.getName() + ":" + toHex(hash) + ":" + + toHex(getSid(cx)); + } + } + + /** + * Get the class serial version UID. + */ + long getSid(Class cx) + { + ObjectStreamClass osc = ObjectStreamClass.lookup(cx); + return osc.getSerialVersionUID(); + } +}
\ No newline at end of file diff --git a/libjava/classpath/gnu/javax/rmi/PortableServer.java b/libjava/classpath/gnu/javax/rmi/PortableServer.java deleted file mode 100644 index 4a841387dd7..00000000000 --- a/libjava/classpath/gnu/javax/rmi/PortableServer.java +++ /dev/null @@ -1,141 +0,0 @@ -/* PortableServer.java -- - Copyright (C) 2002, 2004 Free Software Foundation, Inc. - -This file is part of GNU Classpath. - -GNU Classpath is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. - -GNU Classpath 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 for more details. - -You should have received a copy of the GNU General Public License -along with GNU Classpath; see the file COPYING. If not, write to the -Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA -02110-1301 USA. - -Linking this library statically or dynamically with other modules is -making a combined work based on this library. Thus, the terms and -conditions of the GNU General Public License cover the whole -combination. - -As a special exception, the copyright holders of this library give you -permission to link this library with independent modules to produce an -executable, regardless of the license terms of these independent -modules, and to copy and distribute the resulting executable under -terms of your choice, provided that you also meet, for each linked -independent module, the terms and conditions of the license of that -module. An independent module is a module which is not derived from -or based on this library. If you modify this library, you may extend -this exception to your version of the library, but you are not -obligated to do so. If you do not wish to do so, delete this -exception statement from your version. */ - - -package gnu.javax.rmi; - -import java.rmi.Remote; -import java.rmi.RemoteException; -import java.rmi.NoSuchObjectException; -import java.rmi.server.UnicastRemoteObject; -import java.rmi.server.RemoteStub; -import java.util.Hashtable; - -import javax.rmi.CORBA.*; - -/** - * The relationship of PortableRemoteObjectImpl with PortableServer - * is like that of UnicastRemoteObject with UnicastServer - */ -public class PortableServer -{ - static private Hashtable tieCache = new Hashtable(); - static private Object NO_TIE = new Object(); - - public static final synchronized void exportObject(Remote obj) - throws RemoteException - { - if(Util.getTie(obj) != null) - return; - - Tie tie = getTieFromRemote(obj); - if (tie != null) - Util.registerTarget(tie, obj); - else - UnicastRemoteObject.exportObject(obj); - } - - public static final void unexportObject(Remote obj) - { - if (Util.getTie(obj) != null) - Util.unexportObject(obj); - if (tieCache.get(obj) != null) //?? - tieCache.remove(obj); - } - - public static final Remote toStub(Remote obj) - throws NoSuchObjectException - { - if (obj instanceof Stub || obj instanceof RemoteStub) - return obj; - - Tie tie = Util.getTie(obj); - Remote stub; - if (tie != null) - stub = getStubFromTie(tie); - else - throw new NoSuchObjectException("Can't toStub an unexported object"); - return stub; - } - - static synchronized Tie getTieFromRemote(Remote obj) - { - Object tie = tieCache.get(obj); - if (tie == null) - { - tie = getTieFromClass(obj.getClass()); - if(tie == null) - tieCache.put(obj, NO_TIE); - else - tieCache.put(obj, tie); - } - else - if(tie != NO_TIE) - { - try - { - tie = obj.getClass().newInstance(); - } - catch(Exception _) - { - tie = null; - } - } - else //NO_TIE - tie = null; - - return (Tie)tie; - } - - static synchronized Tie getTieFromClass(Class clz) - { - //FIX ME - return null; - } - - public static Remote getStubFromTie(Tie tie) - { - //FIX ME - return null; - } - - public static Remote getStubFromObjectImpl(ObjectImpl objimpl, Class toClass) - { - //FIX ME - return null; - } -} diff --git a/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaInputPortDevice.java b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaInputPortDevice.java new file mode 100644 index 00000000000..fb9e684d096 --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaInputPortDevice.java @@ -0,0 +1,130 @@ +/* AlsaInputPortDevice.java -- ALSA MIDI In Port + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.alsa; + +import javax.sound.midi.MidiUnavailableException; +import javax.sound.midi.Receiver; +import javax.sound.midi.Transmitter; +import gnu.javax.sound.midi.alsa.AlsaMidiDeviceProvider.AlsaPortInfo; + +/** + * ALSA MIDI In Port. + * + * @author Anthony Green (green@redhat.com) + * + */ +public class AlsaInputPortDevice extends AlsaPortDevice +{ + + AlsaInputPortDevice (AlsaPortInfo info) + { + super(info); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#open() + */ + public void open() throws MidiUnavailableException + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#close() + */ + public void close() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#isOpen() + */ + public boolean isOpen() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMicrosecondPosition() + */ + public long getMicrosecondPosition() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMaxReceivers() + */ + public int getMaxReceivers() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMaxTransmitters() + */ + public int getMaxTransmitters() + { + // TODO Auto-generated method stub + return 1; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getReceiver() + */ + public Receiver getReceiver() throws MidiUnavailableException + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getTransmitter() + */ + public Transmitter getTransmitter() throws MidiUnavailableException + { + return new AlsaTransmitter(); + } +} diff --git a/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaMidiDeviceProvider.java b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaMidiDeviceProvider.java new file mode 100644 index 00000000000..4951be6059c --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaMidiDeviceProvider.java @@ -0,0 +1,216 @@ +/* AlsaMidiDeviceProvider.java -- The ALSA MIDI Device Provider + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.alsa; + +import gnu.classpath.Configuration; + +import javax.sound.midi.MidiDevice; +import javax.sound.midi.MidiDevice.Info; +import javax.sound.midi.spi.MidiDeviceProvider; + +/** + * Provide ALSA MIDI devices. + * + * @author Anthony Green (green@redhat.com) + * + */ +public class AlsaMidiDeviceProvider extends MidiDeviceProvider +{ + /** + * Abstract base for ALSA specific MIDI device info. + * + * @author Anthony Green (green@redhat.com) + * + */ + private static abstract class AlsaInfo extends Info + { + /** + * Create an ALSA specific MIDI device info object. + * + * @param name the device name + * @param description the device description + */ + public AlsaInfo(String name, String description) + { + super(name, "Alsa", description, "0.0"); + } + + abstract MidiDevice getDevice (); + } + + /** + * ALSA MIDI Port. + * + * @author Anthony Green (green@redhat.com) + * + */ + public static abstract class AlsaPortInfo extends AlsaInfo + { + long client; + long port; + + /** + * Create ALSA MIDI In Port. + * + * @param name the device name + * @param description the device description + * @param client the client ID + * @param port the port ID + */ + public AlsaPortInfo(String name, String description, long client, long port) + { + super(name, description); + this.client = client; + this.port = port; + } + } + + /** + * ALSA Sequencer specific info. + * + * @author Anthony Green (green@redhat.com) + * + */ + private static class AlsaSequencerInfo extends AlsaInfo + { + public AlsaSequencerInfo(String name, String description) + { + super(name, description); + } + + MidiDevice getDevice() + { + return AlsaMidiSequencerDevice.getInstance(); + } + } + + /** + * ALSA MIDI In Port. + * + * @author Anthony Green (green@redhat.com) + * + */ + private static class AlsaInputPortInfo extends AlsaPortInfo + { + public AlsaInputPortInfo(String name, String description, long client, long port) + { + super(name, description, client, port); + } + + MidiDevice getDevice() + { + return new AlsaInputPortDevice(this); + } + } + + /** + * ALSA MIDI Out Port. + * + * @author Anthony Green (green@redhat.com) + * + */ + private static class AlsaOutputPortInfo extends AlsaPortInfo + { + public AlsaOutputPortInfo(String name, String description, long client, long port) + { + super(name, description, client, port); + } + + MidiDevice getDevice() + { + return new AlsaOutputPortDevice(this); + } + } + + private static AlsaInfo[] infos; + + private static native AlsaInfo[] getInputDeviceInfo_(); + private static native AlsaInfo[] getOutputDeviceInfo_(); + + /** + * Initialize the ALSA system + */ + private static native void init_(); + + static + { + if (Configuration.INIT_LOAD_LIBRARY) + { + System.loadLibrary("gjsmalsa"); + } + + init_(); + + AlsaInfo inputs[] = getInputDeviceInfo_(); + AlsaInfo outputs[] = getOutputDeviceInfo_(); + + infos = new AlsaInfo[inputs.length + outputs.length + 1]; + infos[0] = new AlsaSequencerInfo ("/dev/snd/seq", "ALSA Sequencer"); + System.arraycopy(inputs, 0, infos, 1, inputs.length); + System.arraycopy(outputs, 0, infos, 1 + inputs.length, outputs.length); + } + + public AlsaMidiDeviceProvider() + { + // Nothing. + } + + /* (non-Javadoc) + * @see javax.sound.midi.spi.MidiDeviceProvider#getDeviceInfo() + */ + public Info[] getDeviceInfo() + { + return infos; + } + + /* (non-Javadoc) + * @see javax.sound.midi.spi.MidiDeviceProvider#getDevice(javax.sound.midi.MidiDevice.Info) + */ + public MidiDevice getDevice(Info info) + { + for (int i = 0; i < infos.length; i++) + { + if (info.equals(infos[i])) + { + return infos[i].getDevice(); + } + } + throw new IllegalArgumentException("Don't recognize MIDI device " + info); + } +} diff --git a/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaMidiSequencerDevice.java b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaMidiSequencerDevice.java new file mode 100644 index 00000000000..c91f1e39851 --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaMidiSequencerDevice.java @@ -0,0 +1,519 @@ +/* AlsaMidiSequencerDevice.java -- The ALSA MIDI sequencer device + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.alsa; + +import java.io.IOException; +import java.io.InputStream; + +import javax.sound.midi.ControllerEventListener; +import javax.sound.midi.InvalidMidiDataException; +import javax.sound.midi.MetaEventListener; +import javax.sound.midi.MidiUnavailableException; +import javax.sound.midi.Receiver; +import javax.sound.midi.Sequence; +import javax.sound.midi.Sequencer; +import javax.sound.midi.Track; +import javax.sound.midi.Transmitter; + +// FIXME: These next two imports are only required by gcj it seems. +import javax.sound.midi.MidiDevice.Info; +import javax.sound.midi.Sequencer.SyncMode; + +/** + * The ALSA MIDI sequencer device. This is a singleton device. + * + * @author green@redhat.com + * + */ +public class AlsaMidiSequencerDevice implements Sequencer +{ + // The singleton instance. + public final static AlsaMidiSequencerDevice instance = new AlsaMidiSequencerDevice(); + + // A pointer to a native chunk of memory + private long nativeState; + + // The sequence to process + private Sequence sequence; + + /** + * A private constructor. There should only be one instance of this + * device. + */ + private AlsaMidiSequencerDevice() + { + super(); + } + + /** + * Return the sequencer singleton. + * + * @return the sequencer singleton + */ + public static AlsaMidiSequencerDevice getInstance() + { + return instance; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setSequence(javax.sound.midi.Sequence) + */ + public void setSequence(Sequence seq) throws InvalidMidiDataException + { + sequence = seq; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setSequence(java.io.InputStream) + */ + public void setSequence(InputStream istream) throws IOException, + InvalidMidiDataException + { + // TODO Auto-generated method stub + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getSequence() + */ + public Sequence getSequence() + { + return sequence; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#start() + */ + public void start() + { + // TODO Auto-generated method stub + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#stop() + */ + public void stop() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#isRunning() + */ + public boolean isRunning() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#startRecording() + */ + public void startRecording() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#stopRecording() + */ + public void stopRecording() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#isRecording() + */ + public boolean isRecording() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#recordEnable(javax.sound.midi.Track, int) + */ + public void recordEnable(Track track, int channel) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#recordDisable(javax.sound.midi.Track) + */ + public void recordDisable(Track track) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTempoInBPM() + */ + public float getTempoInBPM() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setTempoInBPM(float) + */ + public void setTempoInBPM(float bpm) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTempoInMPQ() + */ + public float getTempoInMPQ() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setTempoInMPQ(float) + */ + public void setTempoInMPQ(float mpq) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setTempoFactor(float) + */ + public void setTempoFactor(float factor) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTempoFactor() + */ + public float getTempoFactor() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTickLength() + */ + public long getTickLength() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTickPosition() + */ + public long getTickPosition() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setTickPosition(long) + */ + public void setTickPosition(long tick) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getMicrosecondLength() + */ + public long getMicrosecondLength() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getMicrosecondPosition() + */ + public long getMicrosecondPosition() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setMicrosecondPosition(long) + */ + public void setMicrosecondPosition(long microsecond) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setMasterSyncMode(javax.sound.midi.Sequencer.SyncMode) + */ + public void setMasterSyncMode(SyncMode sync) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getMasterSyncMode() + */ + public SyncMode getMasterSyncMode() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getMasterSyncModes() + */ + public SyncMode[] getMasterSyncModes() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setSlaveSyncMode(javax.sound.midi.Sequencer.SyncMode) + */ + public void setSlaveSyncMode(SyncMode sync) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getSlaveSyncMode() + */ + public SyncMode getSlaveSyncMode() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getSlaveSyncModes() + */ + public SyncMode[] getSlaveSyncModes() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setTrackMute(int, boolean) + */ + public void setTrackMute(int track, boolean mute) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTrackMute(int) + */ + public boolean getTrackMute(int track) + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#setTrackSolo(int, boolean) + */ + public void setTrackSolo(int track, boolean solo) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#getTrackSolo(int) + */ + public boolean getTrackSolo(int track) + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#addMetaEventListener(javax.sound.midi.MetaEventListener) + */ + public boolean addMetaEventListener(MetaEventListener listener) + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#removeMetaEventListener(javax.sound.midi.MetaEventListener) + */ + public void removeMetaEventListener(MetaEventListener listener) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#addControllerEventListener(javax.sound.midi.ControllerEventListener, int[]) + */ + public int[] addControllerEventListener(ControllerEventListener listener, + int[] controllers) + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Sequencer#removeControllerEventListener(javax.sound.midi.ControllerEventListener, int[]) + */ + public int[] removeControllerEventListener(ControllerEventListener listener, + int[] controllers) + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getDeviceInfo() + */ + public Info getDeviceInfo() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#open() + */ + public void open() throws MidiUnavailableException + { + synchronized(this) + { + // Check to see if we're open already. + if (nativeState != 0) + return; + + nativeState = open_(); + } + } + + /** + * Allocate the native state object, and open the sequencer. + * + * @return a long representation of a pointer to the nativeState. + */ + private native long open_(); + + /** + * Close the sequencer and free the native state object. + */ + private native void close_(long nativeState); + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#close() + */ + public void close() + { + synchronized(this) + { + close_(nativeState); + nativeState = 0; + } + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#isOpen() + */ + public boolean isOpen() + { + synchronized(this) + { + return (nativeState != 0); + } + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMaxReceivers() + */ + public int getMaxReceivers() + { + return -1; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMaxTransmitters() + */ + public int getMaxTransmitters() + { + return -1; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getReceiver() + */ + public Receiver getReceiver() throws MidiUnavailableException + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getTransmitter() + */ + public Transmitter getTransmitter() throws MidiUnavailableException + { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaOutputPortDevice.java b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaOutputPortDevice.java new file mode 100644 index 00000000000..bc5a5593967 --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaOutputPortDevice.java @@ -0,0 +1,131 @@ +/* AlsaOutputPortDevice.java -- ALSA MIDI Output Port Device + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.alsa; + +import gnu.javax.sound.midi.alsa.AlsaMidiDeviceProvider.AlsaPortInfo; + +import javax.sound.midi.MidiUnavailableException; +import javax.sound.midi.Receiver; +import javax.sound.midi.Transmitter; + +/** + * ALSA MIDI Out Device + * + * @author Anthony Green (green@redhat.com) + * + */ +public class AlsaOutputPortDevice extends AlsaPortDevice +{ + AlsaOutputPortDevice (AlsaPortInfo info) + { + super(info); + } + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#open() + */ + public void open() throws MidiUnavailableException + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#close() + */ + public void close() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#isOpen() + */ + public boolean isOpen() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMicrosecondPosition() + */ + public long getMicrosecondPosition() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMaxReceivers() + */ + public int getMaxReceivers() + { + // TODO Auto-generated method stub + return 1; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMaxTransmitters() + */ + public int getMaxTransmitters() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getReceiver() + */ + public Receiver getReceiver() throws MidiUnavailableException + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getTransmitter() + */ + public Transmitter getTransmitter() throws MidiUnavailableException + { + // TODO Auto-generated method stub + return null; + } + +} diff --git a/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaPortDevice.java b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaPortDevice.java new file mode 100644 index 00000000000..d666be1f1ba --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/alsa/AlsaPortDevice.java @@ -0,0 +1,153 @@ +/* AlsaPortDevice.java -- ALSA MIDI Port Devices + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.alsa; + +import javax.sound.midi.MidiDevice; +import javax.sound.midi.MidiMessage; +import javax.sound.midi.Receiver; +import javax.sound.midi.Transmitter; + +// FIXME: This next import is only rquired for gcj it seems. +import javax.sound.midi.MidiDevice.Info; + +import gnu.javax.sound.midi.alsa.AlsaMidiDeviceProvider.AlsaPortInfo; + +/** + * ALSA Port Device + * + * @author Anthony Green (green@redhat.com) + * + */ +public abstract class AlsaPortDevice implements MidiDevice +{ + /** + * The ALSA Receiver class. + * + * @author Anthony Green (green@redhat.com) + * + */ + public class AlsaReceiver implements Receiver + { + /* (non-Javadoc) + * @see javax.sound.midi.Receiver#send(javax.sound.midi.MidiMessage, long) + */ + public void send(MidiMessage message, long timeStamp) + throws IllegalStateException + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Receiver#close() + */ + public void close() + { + // TODO Auto-generated method stub + + } + } + + AlsaMidiDeviceProvider.AlsaPortInfo info; + + public AlsaPortDevice (AlsaPortInfo info) + { + this.info = info; + } + + public Info getDeviceInfo() + { + return info; + } + + native void run_receiver_thread_ (long client, long port, Receiver receiver); + + /** + * The ALSA Transmitter class. + * + * @author Anthony Green (green@redhat.com) + * + */ + protected class AlsaTransmitter implements Transmitter, Runnable + { + private Receiver receiver; + + public void run() + { + run_receiver_thread_ (info.client, info.port, receiver); + } + + /* (non-Javadoc) + * @see javax.sound.midi.Transmitter#setReceiver(javax.sound.midi.Receiver) + */ + public void setReceiver(Receiver receiver) + { + synchronized (this) + { + this.receiver = receiver; + } + + // Create the processing thread + new Thread(this).start(); + } + + /* (non-Javadoc) + * @see javax.sound.midi.Transmitter#getReceiver() + */ + public Receiver getReceiver() + { + synchronized (this) + { + return receiver; + } + } + + /* (non-Javadoc) + * @see javax.sound.midi.Transmitter#close() + */ + public void close() + { + synchronized (this) + { + receiver.close(); + receiver = null; + } + } + } +} diff --git a/libjava/classpath/gnu/javax/sound/midi/dssi/DSSIMidiDeviceProvider.java b/libjava/classpath/gnu/javax/sound/midi/dssi/DSSIMidiDeviceProvider.java new file mode 100644 index 00000000000..baf61732d18 --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/dssi/DSSIMidiDeviceProvider.java @@ -0,0 +1,173 @@ +/* DSSIMidiDeviceProvider.java -- DSSI Device Provider + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.dssi; + +import java.util.ArrayList; +import java.util.List; +import java.io.File; +import java.io.FilenameFilter; + +import gnu.classpath.Configuration; +import gnu.javax.sound.midi.alsa.AlsaMidiSequencerDevice; + +import javax.sound.midi.MidiDevice; +import javax.sound.midi.MidiDevice.Info; +import javax.sound.midi.spi.MidiDeviceProvider; + +/** + * A DSSI MIDI device provider. + * + * DSSI (pronounced "dizzy") is an API for audio plugins, with particular + * application for software synthesis plugins with native user interfaces. + * + * Read about DSSI at http://dssi.sourceforge.net + * + * @author Anthony Green (green@redhat.com) + * + */ +public class DSSIMidiDeviceProvider extends MidiDeviceProvider +{ + /** + * The MidiDevice.Info specialized for DSSI synthesizers. + * + * @author Anthony Green (green@redhat.com) + * + */ + private static class DSSIInfo extends Info + { + String soname; + long index; + + public DSSIInfo(String name, String vendor, String description, + String version, String soname, long index) + { + super(name, vendor, description, version); + this.soname = soname; + this.index = index; + } + } + + static native long dlopen_(String soname); + static native void dlclose_(long sohandle); + static native long getDSSIHandle_(long sohandle, long index); + static native String getDSSIName_(long handle); + static native String getDSSICopyright_(long handle); + static native String getDSSIVendor_(long handle); + static native String getDSSILabel_(long handle); + + private static List examineLibrary(String soname) + { + List list = new ArrayList(); + long index = 0; + long handle; + + long sohandle = dlopen_(soname); + if (sohandle == 0) + return list; + do + { + handle = getDSSIHandle_(sohandle, index); + if (handle == 0) + break; + String name = getDSSILabel_(handle); + String copyright = getDSSICopyright_(handle); + String label = getDSSIName_(handle); + String vendor = getDSSIVendor_(handle); + list.add(new DSSIInfo(name, vendor, label, + "DSSI-1", soname, index)); + index++; + } while (true); + + // Close the library and free memory + dlclose_(sohandle); + + return list; + } + + private static DSSIInfo[] infos; + + static + { + if (Configuration.INIT_LOAD_LIBRARY) + System.loadLibrary("gjsmdssi"); + + File dssidir = new File("/usr/lib/dssi/"); + String sofiles[] = dssidir.list(new FilenameFilter() + { + public boolean accept(File dir, String n) + { + return n.endsWith(".so"); + } + }); + List ilist = new ArrayList(); + for (int i = 0; i < sofiles.length; i++) + ilist.addAll(examineLibrary(new File(dssidir, sofiles[i]).getAbsolutePath())); + infos = (DSSIInfo[]) ilist.toArray(new DSSIInfo[ilist.size()]); + } + + public DSSIMidiDeviceProvider() + { + // Empty. + } + + /* Return the Info array. + * @see javax.sound.midi.spi.MidiDeviceProvider#getDeviceInfo() + */ + public Info[] getDeviceInfo() + { + return infos; + } + + /* Get a MIDI Device for info. + * @see javax.sound.midi.spi.MidiDeviceProvider#getDevice(javax.sound.midi.MidiDevice.Info) + */ + public MidiDevice getDevice(Info info) + { + for (int i = 0; i < infos.length; i++) + { + if (info.equals(infos[i])) + { + return new DSSISynthesizer(infos[i], + infos[i].soname, + infos[i].index); + } + } + throw new IllegalArgumentException("Don't recognize MIDI device " + info); + } +} diff --git a/libjava/classpath/gnu/javax/sound/midi/dssi/DSSISynthesizer.java b/libjava/classpath/gnu/javax/sound/midi/dssi/DSSISynthesizer.java new file mode 100644 index 00000000000..ca09b305078 --- /dev/null +++ b/libjava/classpath/gnu/javax/sound/midi/dssi/DSSISynthesizer.java @@ -0,0 +1,745 @@ +/* DSSISynthesizer.java -- DSSI Synthesizer Provider + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.sound.midi.dssi; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import javax.sound.midi.Instrument; +import javax.sound.midi.MidiChannel; +import javax.sound.midi.MidiMessage; +import javax.sound.midi.MidiUnavailableException; +import javax.sound.midi.Patch; +import javax.sound.midi.Receiver; +import javax.sound.midi.ShortMessage; +import javax.sound.midi.Soundbank; +import javax.sound.midi.SoundbankResource; +import javax.sound.midi.Synthesizer; +import javax.sound.midi.Transmitter; +import javax.sound.midi.VoiceStatus; + +// FIXME: This import in only required for gcj it seems. +import javax.sound.midi.MidiDevice.Info; + +/** + * DSSI soft-synth support. + * + * All DSSI soft-synths are expected to be installed in /usr/lib/dssi. + * + * @author Anthony Green (green@redhat.com) + * + */ +public class DSSISynthesizer implements Synthesizer +{ + /** + * The DSSI Instrument class. + * + * @author Anthony Green (green@redhat.com) + * + */ + class DSSIInstrument extends Instrument + { + DSSIInstrument (Soundbank soundbank, Patch patch, String name) + { + super (soundbank, patch, name, null); + } + + /* @see javax.sound.midi.SoundbankResource#getData() + */ + public Object getData() + { + return null; + } + + } + +/** + * DSSISoundbank holds all instruments. + * + * @author Anthony Green (green@redhat.com) + * + */ + class DSSISoundbank implements Soundbank + { + private String name; + private String description; + private List instruments = new ArrayList(); + private List resources = new ArrayList(); + private String vendor; + private String version; + + public DSSISoundbank(String name, String description, String vendor, String version) + { + this.name = name; + this.description = description; + this.vendor = vendor; + this.version = version; + } + + void add(Instrument instrument) + { + instruments.add(instrument); + } + + /* @see javax.sound.midi.Soundbank#getName() + */ + public String getName() + { + return name; + } + + /* @see javax.sound.midi.Soundbank#getVersion() + */ + public String getVersion() + { + return version; + } + + /* @see javax.sound.midi.Soundbank#getVendor() + */ + public String getVendor() + { + return vendor; + } + + /* @see javax.sound.midi.Soundbank#getDescription() + */ + public String getDescription() + { + return description; + } + + /* @see javax.sound.midi.Soundbank#getResources() + */ + public SoundbankResource[] getResources() + { + return (SoundbankResource[]) + resources.toArray(new SoundbankResource[resources.size()]); + } + + /* @see javax.sound.midi.Soundbank#getInstruments() + */ + public Instrument[] getInstruments() + { + return (Instrument[]) + instruments.toArray(new Instrument[instruments.size()]); + } + + /* @see javax.sound.midi.Soundbank#getInstrument(javax.sound.midi.Patch) + */ + public Instrument getInstrument(Patch patch) + { + Iterator itr = instruments.iterator(); + + while (itr.hasNext()) + { + Instrument i = (Instrument) itr.next(); + if (i.getPatch().equals(patch)) + return i; + } + + return null; + } + } + +/** + * The Receiver class receives all MIDI messages from a connected + * Transmitter. + * + * @author Anthony Green (green@redhat.com) + * + */ + class DSSIReceiver implements Receiver + { + /* (non-Javadoc) + * @see javax.sound.midi.Receiver#send(javax.sound.midi.MidiMessage, long) + */ + public void send(MidiMessage message, long timeStamp) + throws IllegalStateException + { + if (message instanceof ShortMessage) + { + ShortMessage smessage = (ShortMessage) message; + + switch (message.getStatus()) + { + case ShortMessage.NOTE_ON: + int velocity = smessage.getData2(); + if (velocity > 0) + channels[smessage.getChannel()].noteOn(smessage.getData1(), + smessage.getData2()); + else + channels[smessage.getChannel()].noteOff(smessage.getData1()); + break; + case ShortMessage.CONTROL_CHANGE: + channels[smessage.getChannel()].controlChange(smessage.getData1(), + smessage.getData2()); + break; + default: + System.out.println ("Unhandled message: " + message.getStatus()); + break; + } + } + } + + /* (non-Javadoc) + * @see javax.sound.midi.Receiver#close() + */ + public void close() + { + // TODO Auto-generated method stub + } + + } + + static native void noteOn_(long handle, int channel, int noteNumber, int velocity); + static native void noteOff_(long handle, int channel, int noteNumber, int velocity); + static native void setPolyPressure_(long handle, int channel, int noteNumber, int pressure); + static native int getPolyPressure_(long handle, int channel, int noteNumber); + static native void controlChange_(long handle, int channel, int control, int value); + static native void open_(long handle); + static native void close_(long handle); + static native String getProgramName_(long handle, int index); + static native int getProgramBank_(long handle, int index); + static native int getProgramProgram_(long handle, int index); + static native void selectProgram_(long handle, int bank, int program); + + /** + * @author Anthony Green (green@redhat.com) + * + */ + public class DSSIMidiChannel implements MidiChannel + { + int channel = 0; + + /** + * Default contructor. + */ + public DSSIMidiChannel(int channel) + { + super(); + this.channel = channel; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#noteOn(int, int) + */ + public void noteOn(int noteNumber, int velocity) + { + noteOn_(sohandle, channel, noteNumber, velocity); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#noteOff(int, int) + */ + public void noteOff(int noteNumber, int velocity) + { + noteOff_(sohandle, channel, noteNumber, velocity); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#noteOff(int) + */ + public void noteOff(int noteNumber) + { + noteOff_(sohandle, channel, noteNumber, -1); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setPolyPressure(int, int) + */ + public void setPolyPressure(int noteNumber, int pressure) + { + setPolyPressure_(sohandle, channel, noteNumber, pressure); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getPolyPressure(int) + */ + public int getPolyPressure(int noteNumber) + { + return getPolyPressure_(sohandle, channel, noteNumber); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setChannelPressure(int) + */ + public void setChannelPressure(int pressure) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getChannelPressure() + */ + public int getChannelPressure() + { + // TODO Auto-generated method stub + return 0; + } + + /* @see javax.sound.midi.MidiChannel#controlChange(int, int) */ + public void controlChange(int controller, int value) + { + controlChange_(sohandle, channel, controller, value); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getController(int) + */ + public int getController(int controller) + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#programChange(int) + */ + public void programChange(int program) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#programChange(int, int) + */ + public void programChange(int bank, int program) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getProgram() + */ + public int getProgram() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setPitchBend(int) + */ + public void setPitchBend(int bend) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getPitchBend() + */ + public int getPitchBend() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#resetAllControllers() + */ + public void resetAllControllers() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#allNotesOff() + */ + public void allNotesOff() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#allSoundOff() + */ + public void allSoundOff() + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#localControl(boolean) + */ + public boolean localControl(boolean on) + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setMono(boolean) + */ + public void setMono(boolean on) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getMono() + */ + public boolean getMono() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setOmni(boolean) + */ + public void setOmni(boolean on) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getOmni() + */ + public boolean getOmni() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setMute(boolean) + */ + public void setMute(boolean mute) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getMute() + */ + public boolean getMute() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#setSolo(boolean) + */ + public void setSolo(boolean solo) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiChannel#getSolo() + */ + public boolean getSolo() + { + // TODO Auto-generated method stub + return false; + } + + } + + long sohandle; + long handle; + private Info info; + + MidiChannel channels[] = new MidiChannel[16]; + + // The list of known soundbanks, and the default one. + List soundbanks = new ArrayList(); + DSSISoundbank defaultSoundbank; + + /** + * Create a DSSI Synthesizer. + * + * @param info the DSSIInfo for this soft-synth + * @param soname the name of the .so file for this DSSI synth + * @param index the DSSI index for this soft-synth + */ + public DSSISynthesizer(Info info, String soname, long index) + { + super(); + this.info = info; + sohandle = DSSIMidiDeviceProvider.dlopen_(soname); + handle = DSSIMidiDeviceProvider.getDSSIHandle_(sohandle, index); + channels[0] = new DSSIMidiChannel(0); + defaultSoundbank = new DSSISoundbank("name", "description", + "vendor", "version"); + soundbanks.add(defaultSoundbank); + + int i = 0; + String name; + do + { + name = getProgramName_(sohandle, i); + if (name != null) + { + defaultSoundbank. + add(new DSSIInstrument(defaultSoundbank, + new Patch(getProgramBank_(sohandle, i), + getProgramProgram_(sohandle, i)), + name)); + i++; + } + } while (name != null); + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#getMaxPolyphony() + */ + public int getMaxPolyphony() + { + // TODO Auto-generated method stub + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#getLatency() + */ + public long getLatency() + { + // DSSI and LADSPA provide no way to determine the latency. + // Let's just return 0 for now. + return 0; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#getChannels() + */ + public MidiChannel[] getChannels() + { + return channels; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#getVoiceStatus() + */ + public VoiceStatus[] getVoiceStatus() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#isSoundbankSupported(javax.sound.midi.Soundbank) + */ + public boolean isSoundbankSupported(Soundbank soundbank) + { + // TODO Auto-generated method stub + return false; + } + + /* @see javax.sound.midi.Synthesizer#loadInstrument(javax.sound.midi.Instrument) + */ + public boolean loadInstrument(Instrument instrument) + { + // FIXME: perhaps this isn't quite right. It can probably + // be in any soundbank. + if (instrument.getSoundbank() != defaultSoundbank) + throw new IllegalArgumentException ("Synthesizer doesn't support this instrument's soundbank"); + + Patch patch = instrument.getPatch(); + selectProgram_(sohandle, patch.getBank(), patch.getProgram()); + return true; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#unloadInstrument(javax.sound.midi.Instrument) + */ + public void unloadInstrument(Instrument instrument) + { + // TODO Auto-generated method stub + + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#remapInstrument(javax.sound.midi.Instrument, javax.sound.midi.Instrument) + */ + public boolean remapInstrument(Instrument from, Instrument to) + { + // TODO Auto-generated method stub + return false; + } + + /* @see javax.sound.midi.Synthesizer#getDefaultSoundbank() + */ + public Soundbank getDefaultSoundbank() + { + return defaultSoundbank; + } + + /* @see javax.sound.midi.Synthesizer#getAvailableInstruments() + */ + public Instrument[] getAvailableInstruments() + { + List instruments = new ArrayList(); + Iterator itr = soundbanks.iterator(); + while (itr.hasNext()) + { + Soundbank sb = (Soundbank) itr.next(); + Instrument ins[] = sb.getInstruments(); + for (int i = 0; i < ins.length; i++) + instruments.add(ins[i]); + } + return (Instrument[]) + instruments.toArray(new Instrument[instruments.size()]); + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#getLoadedInstruments() + */ + public Instrument[] getLoadedInstruments() + { + // TODO Auto-generated method stub + return null; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#loadAllInstruments(javax.sound.midi.Soundbank) + */ + public boolean loadAllInstruments(Soundbank soundbank) + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#unloadAllInstruments(javax.sound.midi.Soundbank) + */ + public void unloadAllInstruments(Soundbank soundbank) + { + // TODO Auto-generated method stub + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#loadInstruments(javax.sound.midi.Soundbank, javax.sound.midi.Patch[]) + */ + public boolean loadInstruments(Soundbank soundbank, Patch[] patchList) + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.Synthesizer#unloadInstruments(javax.sound.midi.Soundbank, javax.sound.midi.Patch[]) + */ + public void unloadInstruments(Soundbank soundbank, Patch[] patchList) + { + // TODO Auto-generated method stub + + } + + /* @see javax.sound.midi.MidiDevice#getDeviceInfo() + */ + public Info getDeviceInfo() + { + return info; + } + + /* @see javax.sound.midi.MidiDevice#open() + */ + public void open() throws MidiUnavailableException + { + open_(sohandle); + } + + /* @see javax.sound.midi.MidiDevice#close() + */ + public void close() + { + close_(sohandle); + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#isOpen() + */ + public boolean isOpen() + { + // TODO Auto-generated method stub + return false; + } + + /* (non-Javadoc) + * @see javax.sound.midi.MidiDevice#getMicrosecondPosition() + */ + public long getMicrosecondPosition() + { + // TODO Auto-generated method stub + return 0; + } + + /* @see javax.sound.midi.MidiDevice#getMaxReceivers() + */ + public int getMaxReceivers() + { + return 1; + } + + /* @see javax.sound.midi.MidiDevice#getMaxTransmitters() + */ + public int getMaxTransmitters() + { + return 0; + } + + /* @see javax.sound.midi.MidiDevice#getReceiver() + */ + public Receiver getReceiver() throws MidiUnavailableException + { + return new DSSIReceiver(); + } + + /* @see javax.sound.midi.MidiDevice#getTransmitter() + */ + public Transmitter getTransmitter() throws MidiUnavailableException + { + return null; + } +} |