| /* ImageIO.java -- |
| Copyright (C) 2004, 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 javax.imageio; |
| |
| import java.awt.image.BufferedImage; |
| import java.awt.image.RenderedImage; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.net.URL; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Iterator; |
| |
| import javax.imageio.spi.IIORegistry; |
| import javax.imageio.spi.ImageInputStreamSpi; |
| import javax.imageio.spi.ImageOutputStreamSpi; |
| import javax.imageio.spi.ImageReaderSpi; |
| import javax.imageio.spi.ImageTranscoderSpi; |
| import javax.imageio.spi.ImageWriterSpi; |
| import javax.imageio.spi.ServiceRegistry; |
| import javax.imageio.stream.ImageInputStream; |
| import javax.imageio.stream.ImageOutputStream; |
| import javax.imageio.stream.MemoryCacheImageInputStream; |
| import javax.imageio.stream.MemoryCacheImageOutputStream; |
| |
| /** |
| * An uninstantiable class that provides static methods for locating |
| * and using image readers and writers. |
| */ |
| public final class ImageIO |
| { |
| /** |
| * Construct an ImageIO. Private since ImageIO is not instantiable. |
| */ |
| private ImageIO() |
| { |
| } |
| |
| private static final class ReaderFormatFilter implements ServiceRegistry.Filter |
| { |
| private String formatName; |
| |
| public ReaderFormatFilter(String formatName) |
| { |
| this.formatName = formatName; |
| } |
| |
| public boolean filter (Object provider) |
| { |
| if (provider instanceof ImageReaderSpi) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) provider; |
| String[] formatNames = spi.getFormatNames(); |
| |
| for (int i = formatNames.length - 1; i >= 0; --i) |
| if (formatName.equals(formatNames[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class ReaderMIMETypeFilter implements ServiceRegistry.Filter |
| { |
| private String MIMEType; |
| |
| public ReaderMIMETypeFilter(String MIMEType) |
| { |
| this.MIMEType = MIMEType; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageReaderSpi) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) provider; |
| String[] mimetypes = spi.getMIMETypes(); |
| |
| for (int i = mimetypes.length - 1; i >= 0; --i) |
| if (MIMEType.equals(mimetypes[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class ReaderObjectFilter implements ServiceRegistry.Filter |
| { |
| private Object object; |
| |
| public ReaderObjectFilter(Object object) |
| { |
| this.object = object; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageReaderSpi) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) provider; |
| |
| try |
| { |
| if (spi.canDecodeInput(object)) |
| return true; |
| } |
| catch (IOException e) |
| { |
| // Return false in this case |
| } |
| } |
| return false; |
| } |
| } |
| |
| private static final class ReaderSuffixFilter implements ServiceRegistry.Filter |
| { |
| private String fileSuffix; |
| |
| public ReaderSuffixFilter(String fileSuffix) |
| { |
| this.fileSuffix = fileSuffix; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageReaderSpi) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) provider; |
| String[] suffixes = spi.getFileSuffixes(); |
| |
| for (int i = suffixes.length - 1; i >= 0; --i) |
| if (fileSuffix.equals(suffixes[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class WriterFormatFilter implements ServiceRegistry.Filter |
| { |
| private String formatName; |
| |
| public WriterFormatFilter(String formatName) |
| { |
| this.formatName = formatName; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageWriterSpi) |
| { |
| ImageWriterSpi spi = (ImageWriterSpi) provider; |
| String[] formatNames = spi.getFormatNames(); |
| |
| for (int i = formatNames.length - 1; i >= 0; --i) |
| if (formatName.equals(formatNames[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class WriterMIMETypeFilter implements ServiceRegistry.Filter |
| { |
| private String MIMEType; |
| |
| public WriterMIMETypeFilter(String MIMEType) |
| { |
| this.MIMEType = MIMEType; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageWriterSpi) |
| { |
| ImageWriterSpi spi = (ImageWriterSpi) provider; |
| String[] mimetypes = spi.getMIMETypes(); |
| |
| for (int i = mimetypes.length - 1; i >= 0; --i) |
| if (MIMEType.equals(mimetypes[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class WriterSuffixFilter implements ServiceRegistry.Filter |
| { |
| private String fileSuffix; |
| |
| public WriterSuffixFilter(String fileSuffix) |
| { |
| this.fileSuffix = fileSuffix; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageWriterSpi) |
| { |
| ImageWriterSpi spi = (ImageWriterSpi) provider; |
| String[] suffixes = spi.getFileSuffixes(); |
| |
| for (int i = suffixes.length - 1; i >= 0; --i) |
| if (fileSuffix.equals(suffixes[i])) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class WriterObjectFilter implements ServiceRegistry.Filter |
| { |
| private ImageTypeSpecifier type; |
| private String formatName; |
| |
| public WriterObjectFilter(ImageTypeSpecifier type, |
| String formatName) |
| { |
| this.type = type; |
| this.formatName = formatName; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageWriterSpi) |
| { |
| ImageWriterSpi spi = (ImageWriterSpi) provider; |
| |
| if (spi.canEncodeImage(type)) |
| { |
| String[] formatNames = spi.getFormatNames(); |
| for (int i = formatNames.length - 1; i >= 0; --i) |
| if (formatName.equals(formatNames[i])) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class TranscoderFilter implements ServiceRegistry.Filter |
| { |
| private ImageReader reader; |
| private ImageWriter writer; |
| |
| public TranscoderFilter(ImageReader reader, |
| ImageWriter writer) |
| { |
| this.reader = reader; |
| this.writer = writer; |
| } |
| |
| public boolean filter(Object provider) |
| { |
| if (provider instanceof ImageTranscoderSpi) |
| { |
| ImageTranscoderSpi spi = (ImageTranscoderSpi) provider; |
| |
| if (spi.getReaderServiceProviderName().equals |
| (reader.getOriginatingProvider().getClass().getName()) |
| && spi.getWriterServiceProviderName().equals |
| (writer.getOriginatingProvider().getClass().getName())) |
| return true; |
| } |
| |
| return false; |
| } |
| } |
| |
| private static final class ImageReaderIterator |
| implements Iterator<ImageReader> |
| { |
| Iterator<ImageReaderSpi> it; |
| Object readerExtension; |
| |
| public ImageReaderIterator(Iterator<ImageReaderSpi> it, |
| Object readerExtension) |
| { |
| this.it = it; |
| this.readerExtension = readerExtension; |
| } |
| |
| public ImageReaderIterator(Iterator<ImageReaderSpi> it) |
| { |
| this.it = it; |
| } |
| |
| public boolean hasNext() |
| { |
| return it.hasNext(); |
| } |
| |
| public ImageReader next() |
| { |
| try |
| { |
| ImageReaderSpi spi = it.next(); |
| return (readerExtension == null |
| ? spi.createReaderInstance() |
| : spi.createReaderInstance(readerExtension)); |
| } |
| catch (IOException e) |
| { |
| return null; |
| } |
| } |
| |
| public void remove() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| private static final class ImageWriterIterator |
| implements Iterator<ImageWriter> |
| { |
| Iterator<ImageWriterSpi> it; |
| Object writerExtension; |
| |
| public ImageWriterIterator(Iterator<ImageWriterSpi> it, |
| Object writerExtension) |
| { |
| this.it = it; |
| this.writerExtension = writerExtension; |
| } |
| |
| public ImageWriterIterator(Iterator<ImageWriterSpi> it) |
| { |
| this.it = it; |
| } |
| |
| public boolean hasNext() |
| { |
| return it.hasNext(); |
| } |
| |
| public ImageWriter next() |
| { |
| try |
| { |
| ImageWriterSpi spi = it.next(); |
| return (writerExtension == null |
| ? spi.createWriterInstance() |
| : spi.createWriterInstance(writerExtension)); |
| } |
| catch (IOException e) |
| { |
| return null; |
| } |
| } |
| |
| public void remove() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| private static File cacheDirectory; |
| private static boolean useCache = true; |
| |
| private static Iterator<ImageReader> getReadersByFilter(Class<ImageReaderSpi> type, |
| ServiceRegistry.Filter filter, |
| Object readerExtension) |
| { |
| try |
| { |
| Iterator<ImageReaderSpi> it |
| = getRegistry().getServiceProviders(type, filter, true); |
| return new ImageReaderIterator(it, readerExtension); |
| } |
| catch (IllegalArgumentException e) |
| { |
| return Collections.EMPTY_SET.iterator(); |
| } |
| } |
| |
| private static Iterator<ImageWriter> getWritersByFilter(Class<ImageWriterSpi> type, |
| ServiceRegistry.Filter filter, |
| Object writerExtension) |
| { |
| try |
| { |
| Iterator<ImageWriterSpi> it |
| = getRegistry().getServiceProviders(type, filter, true); |
| return new ImageWriterIterator(it, writerExtension); |
| } |
| catch (IllegalArgumentException e) |
| { |
| return Collections.EMPTY_SET.iterator(); |
| } |
| } |
| |
| /** |
| * Retrieve the current cache directory. |
| * |
| * @return the current cache directory or null if none is set. |
| */ |
| public static File getCacheDirectory() |
| { |
| return cacheDirectory; |
| } |
| |
| /** |
| * Retrieve an iterator over all registered readers for the given |
| * format. |
| * |
| * @param formatName an infomal format name (e.g. "jpeg" or "bmp") |
| * |
| * @return an iterator over a collection of image readers |
| * |
| * @exception IllegalArgumentException if formatName is null |
| */ |
| public static Iterator<ImageReader> getImageReadersByFormatName(String formatName) |
| { |
| if (formatName == null) |
| throw new IllegalArgumentException("formatName may not be null"); |
| |
| return getReadersByFilter(ImageReaderSpi.class, |
| new ReaderFormatFilter(formatName), |
| formatName); |
| } |
| |
| /** |
| * Retrieve an iterator over all registered readers for the given |
| * MIME type. |
| * |
| * @param MIMEType a MIME specification for an image type |
| * (e.g. "image/jpeg" or "image/x-bmp") |
| * |
| * @return an iterator over a collection of image readers |
| * |
| * @exception IllegalArgumentException if MIMEType is null |
| */ |
| public static Iterator<ImageReader> getImageReadersByMIMEType(String MIMEType) |
| { |
| if (MIMEType == null) |
| throw new IllegalArgumentException("MIMEType may not be null"); |
| |
| return getReadersByFilter(ImageReaderSpi.class, |
| new ReaderMIMETypeFilter(MIMEType), |
| MIMEType); |
| } |
| |
| /** |
| * Retrieve an iterator over all registered readers for the given |
| * file suffix. |
| * |
| * @param fileSuffix an image file suffix (e.g. "jpg" or "bmp") |
| * |
| * @return an iterator over a collection of image readers |
| * |
| * @exception IllegalArgumentException if fileSuffix is null |
| */ |
| public static Iterator<ImageReader> getImageReadersBySuffix(String fileSuffix) |
| { |
| if (fileSuffix == null) |
| throw new IllegalArgumentException("formatName may not be null"); |
| |
| return getReadersByFilter(ImageReaderSpi.class, |
| new ReaderSuffixFilter(fileSuffix), |
| fileSuffix); |
| } |
| |
| /** |
| * Retrieve an iterator over all registered writers for the given |
| * format. |
| * |
| * @param formatName an infomal format name (e.g. "jpeg" or "bmp") |
| * |
| * @return an iterator over a collection of image writers |
| * |
| * @exception IllegalArgumentException if formatName is null |
| */ |
| public static Iterator<ImageWriter> getImageWritersByFormatName(String formatName) |
| { |
| if (formatName == null) |
| throw new IllegalArgumentException("formatName may not be null"); |
| |
| return getWritersByFilter(ImageWriterSpi.class, |
| new WriterFormatFilter(formatName), |
| formatName); |
| } |
| |
| /** |
| * Retrieve an iterator over all registered writers for the given |
| * MIME type. |
| * |
| * @param MIMEType a MIME specification for an image type |
| * (e.g. "image/jpeg" or "image/x-bmp") |
| * |
| * @return an iterator over a collection of image writers |
| * |
| * @exception IllegalArgumentException if MIMEType is null |
| */ |
| public static Iterator<ImageWriter> getImageWritersByMIMEType(String MIMEType) |
| { |
| if (MIMEType == null) |
| throw new IllegalArgumentException("MIMEType may not be null"); |
| |
| return getWritersByFilter(ImageWriterSpi.class, |
| new WriterMIMETypeFilter(MIMEType), |
| MIMEType); |
| } |
| |
| /** |
| * Retrieve an iterator over all registered writers for the given |
| * file suffix. |
| * |
| * @param fileSuffix an image file suffix (e.g. "jpg" or "bmp") |
| * |
| * @return an iterator over a collection of image writers |
| * |
| * @exception IllegalArgumentException if fileSuffix is null |
| */ |
| public static Iterator<ImageWriter> getImageWritersBySuffix(String fileSuffix) |
| { |
| if (fileSuffix == null) |
| throw new IllegalArgumentException("fileSuffix may not be null"); |
| |
| return getWritersByFilter(ImageWriterSpi.class, |
| new WriterSuffixFilter(fileSuffix), |
| fileSuffix); |
| } |
| |
| /** |
| * Retrieve all the informal format names supported by the |
| * collection of registered image readers. |
| * |
| * @return an array of format names |
| */ |
| public static String[] getReaderFormatNames() |
| { |
| try |
| { |
| Iterator it = |
| getRegistry().getServiceProviders(ImageReaderSpi.class, true); |
| ArrayList result = new ArrayList(); |
| |
| while (it.hasNext()) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) it.next(); |
| String[] names = spi.getFormatNames(); |
| |
| for (int i = names.length - 1; i >= 0; --i) |
| result.add(names[i]); |
| } |
| |
| return (String[]) result.toArray(new String[result.size()]); |
| } |
| catch (IllegalArgumentException e) |
| { |
| return new String[0]; |
| } |
| } |
| |
| /** |
| * Retrieve all the MIME types supported by the collection of |
| * registered image readers. |
| * |
| * @return an array of MIME types |
| */ |
| public static String[] getReaderMIMETypes() |
| { |
| try |
| { |
| Iterator it = |
| getRegistry().getServiceProviders(ImageReaderSpi.class, true); |
| ArrayList result = new ArrayList(); |
| |
| while (it.hasNext()) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) it.next(); |
| String[] names = spi.getMIMETypes(); |
| |
| for (int i = names.length - 1; i >= 0; --i) |
| result.add(names[i]); |
| } |
| |
| return (String[]) result.toArray(new String[result.size()]); |
| } |
| catch (IllegalArgumentException e) |
| { |
| return new String[0]; |
| } |
| } |
| |
| private static IIORegistry getRegistry() |
| { |
| return IIORegistry.getDefaultInstance(); |
| } |
| |
| /** |
| * Check whether or not an on-disk cache is used for image input and |
| * output streams. |
| * |
| * @return true if an on-disk cache is available, false otherwise |
| */ |
| public static boolean getUseCache() |
| { |
| return useCache; |
| } |
| |
| /** |
| * Retrieve all the informal format names supported by the |
| * collection of registered image writers. |
| * |
| * @return an array of format names |
| */ |
| public static String[] getWriterFormatNames() |
| { |
| try |
| { |
| Iterator it = |
| getRegistry().getServiceProviders(ImageWriterSpi.class, true); |
| ArrayList result = new ArrayList(); |
| |
| while (it.hasNext()) |
| { |
| ImageWriterSpi spi = (ImageWriterSpi) it.next(); |
| String[] names = spi.getFormatNames(); |
| |
| for (int i = names.length - 1; i >= 0; --i) |
| result.add(names[i]); |
| } |
| |
| return (String[]) result.toArray(new String[result.size()]); |
| } |
| catch (IllegalArgumentException e) |
| { |
| return new String[0]; |
| } |
| } |
| |
| /** |
| * Retrieve all the MIME types supported by the collection of |
| * registered image writers. |
| * |
| * @return an array of MIME types |
| */ |
| public static String[] getWriterMIMETypes() |
| { |
| try |
| { |
| Iterator it = |
| getRegistry().getServiceProviders(ImageWriterSpi.class, true); |
| ArrayList result = new ArrayList(); |
| |
| while (it.hasNext()) |
| { |
| ImageWriterSpi spi = (ImageWriterSpi) it.next(); |
| String[] names = spi.getMIMETypes(); |
| |
| for (int i = names.length - 1; i >= 0; --i) |
| result.add(names[i]); |
| } |
| |
| return (String[]) result.toArray(new String[result.size()]); |
| } |
| catch (IllegalArgumentException e) |
| { |
| return new String[0]; |
| } |
| } |
| |
| /** |
| * Rescans the application classpath for ImageIO service providers |
| * and registers them. |
| */ |
| public static void scanForPlugins() |
| { |
| IIORegistry.getDefaultInstance().registerApplicationClasspathSpis(); |
| } |
| |
| /** |
| * Set the directory to be used for caching image data. A null |
| * argument means to use the default system temporary directory. |
| * This cache directory is only used if getUseCache returns true. |
| * |
| * @param cacheDirectory the directory where image data should be |
| * cached |
| * |
| * @exception IllegalArgumentException if cacheDirectory is not a |
| * directory |
| */ |
| public static void setCacheDirectory(File cacheDirectory) |
| { |
| // FIXME: add SecurityManager call |
| if (cacheDirectory != null) |
| { |
| if (!cacheDirectory.isDirectory()) |
| throw new IllegalArgumentException("cacheDirectory must be a directory"); |
| |
| cacheDirectory.canWrite(); |
| } |
| |
| ImageIO.cacheDirectory = cacheDirectory; |
| } |
| |
| /** |
| * Control whether or not an on-disk cache is used. This cache is |
| * used to store input or output data from an image data stream when |
| * data in the stream needs to be re-processed. |
| * |
| * If useCache is false the cache will be stored in memory. Doing |
| * so eliminates file creation and deletion overhead. The default |
| * is to use an on-disk cache. |
| * |
| * @param useCache true to use an on-disk cache, false otherwise |
| */ |
| public static void setUseCache(boolean useCache) |
| { |
| ImageIO.useCache = useCache; |
| } |
| |
| /** |
| * Write an image to a file using a registered writer that supports |
| * the given format, overwriting the file if it already exists. |
| * |
| * @param im the image data to write |
| * @param formatName an informal description of the output format |
| * @param output the file to which the image will be written |
| * |
| * @return false if no registered writer supports the given format, |
| * true otherwise |
| * |
| * @exception IllegalArgumentException if any argument is null |
| * @exception IOException if a writing error occurs |
| */ |
| public static boolean write(RenderedImage im, |
| String formatName, |
| File output) |
| throws IOException |
| { |
| if (im == null || formatName == null || output == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| return write(im, formatName, new FileOutputStream(output)); |
| } |
| |
| /** |
| * Write an image to an output stream using a registered writer that |
| * supports the given format. |
| * |
| * @param im the image data to write |
| * @param formatName an informal description of the output format |
| * @param output the output stream to which the image will be |
| * written |
| * |
| * @return false if no registered writer supports the given format, |
| * true otherwise |
| * |
| * @exception IllegalArgumentException if any argument is null |
| * @exception IOException if a writing error occurs |
| */ |
| public static boolean write(RenderedImage im, |
| String formatName, |
| OutputStream output) |
| throws IOException |
| { |
| if (im == null || formatName == null || output == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| return write(im, formatName, new MemoryCacheImageOutputStream(output)); |
| } |
| |
| /** |
| * Write an image to an ImageOutputStream using a registered writer |
| * that supports the given format. Image data is written starting |
| * at the ImageOutputStream's current stream pointer, overwriting |
| * any existing data. |
| * |
| * @param im the image data to write |
| * @param formatName an informal description of the output format |
| * @param output the image output stream to which the image will be |
| * written |
| * |
| * @return false if no registered writer supports the given format, |
| * true otherwise |
| * |
| * @exception IllegalArgumentException if any argument is null |
| * @exception IOException if a writing error occurs |
| */ |
| public static boolean write(RenderedImage im, |
| String formatName, |
| ImageOutputStream output) |
| throws IOException |
| { |
| if (im == null || formatName == null || output == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| Iterator writers = getImageWritersByFormatName(formatName); |
| IIOImage img = new IIOImage(im, null, null); |
| while (writers.hasNext()) |
| { |
| ImageWriter w = (ImageWriter) writers.next(); |
| try |
| { |
| w.setOutput(output); |
| } |
| catch (IllegalArgumentException e) |
| { |
| continue; |
| } |
| |
| w.write(null, img, null); |
| w.dispose(); |
| output.close(); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Create a buffered image from an image input stream. An image |
| * reader that supports the given image data is automatically |
| * selected from the collection of registered readers. If no |
| * registered reader can handle the input format, null is returned. |
| * |
| * @param stream the image input stream from which to read image |
| * data |
| * |
| * @return a new buffered image created from the given image data, |
| * or null |
| * |
| * @exception IllegalArgumentException if stream is null |
| * @exception IOException if a reading error occurs |
| */ |
| public static BufferedImage read(ImageInputStream stream) |
| throws IOException |
| { |
| if (stream == null) |
| throw new IllegalArgumentException("null argument"); |
| |
| Iterator providers = getRegistry().getServiceProviders(ImageReaderSpi.class, true); |
| while (providers.hasNext()) |
| { |
| ImageReaderSpi spi = (ImageReaderSpi) providers.next(); |
| if (spi.canDecodeInput(stream)) |
| { |
| ImageReader reader = spi.createReaderInstance(); |
| reader.setInput(stream); |
| return reader.read(0, null); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Create a buffered image from a URL. An image reader that |
| * supports the given image data is automatically selected from the |
| * collection of registered readers. If no registered reader can |
| * handle the input format, null is returned. |
| * |
| * The image data will be cached in the current cache directory if |
| * caching is enabled. |
| * |
| * This method does not locate readers that read data directly from |
| * a URL. To locate such readers manually, use IIORegistry and |
| * ImageReaderSpi. |
| * |
| * @param input the URL from which to retrieve the image file |
| * |
| * @return a new buffered image created from the given image URL, or |
| * null |
| * |
| * @exception IllegalArgumentException if input is null |
| * @exception IOException if a reading error occurs |
| */ |
| public static BufferedImage read(URL input) |
| throws IOException |
| { |
| if (input == null) |
| throw new IllegalArgumentException("null argument"); |
| |
| return read(input.openStream()); |
| } |
| |
| /** |
| * Create a buffered image from an input stream. An image reader |
| * that supports the given image data is automatically selected from |
| * the collection of registered readers. If no registered reader |
| * can handle the input format, null is returned. |
| * |
| * The image data will be cached in the current cache directory if |
| * caching is enabled. |
| * |
| * This method does not locate readers that read data directly from |
| * an input stream. To locate such readers manually, use |
| * IIORegistry and ImageReaderSpi. |
| * |
| * @param input the input stream from which to read the image data |
| * |
| * @return a new buffered image created from the given input stream, |
| * or null |
| * |
| * @exception IllegalArgumentException if input is null |
| * @exception IOException if a reading error occurs |
| */ |
| public static BufferedImage read(InputStream input) |
| throws IOException |
| { |
| if (input == null) |
| throw new IllegalArgumentException("null argument"); |
| |
| return read(new MemoryCacheImageInputStream(input)); |
| } |
| |
| /** |
| * Create a buffered image from a file. An image reader that |
| * supports the given image data is automatically selected from the |
| * collection of registered readers. If no registered reader can |
| * handle the input format, null is returned. |
| * |
| * The image data will be cached in the current cache directory if |
| * caching is enabled. |
| * |
| * This method does not locate readers that read data directly from |
| * a file. To locate such readers manually, use IIORegistry and |
| * ImageReaderSpi. |
| * |
| * @param input the file from which to read image data |
| * |
| * @return a new buffered image created from the given image file, |
| * or null |
| * |
| * @exception IllegalArgumentException if input is null |
| * @exception IOException if a reading error occurs |
| */ |
| public static BufferedImage read(File input) |
| throws IOException |
| { |
| if (input == null) |
| throw new IllegalArgumentException("null argument"); |
| |
| return read(new FileInputStream(input)); |
| } |
| |
| /** |
| * Create an image input stream from the given object. The |
| * collection of ImageInputStreamSpis registered with the |
| * IIORegistry is searched for an image input stream that can take |
| * input from the given object. null is returned if no such SPI is |
| * registered. |
| * |
| * The image data will be cached in the current cache directory if |
| * caching is enabled. |
| * |
| * @param input an object from which to read image data |
| * |
| * @return an ImageInputStream that can read data from input, or |
| * null |
| * |
| * @exception IllegalArgumentException if input is null |
| * @exception IOException if caching is required but not enabled |
| */ |
| public static ImageInputStream createImageInputStream (Object input) |
| throws IOException |
| { |
| if (input == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| Iterator spis = getRegistry().getServiceProviders |
| (ImageInputStreamSpi.class, true); |
| |
| ImageInputStreamSpi foundSpi = null; |
| |
| while(spis.hasNext()) |
| { |
| ImageInputStreamSpi spi = (ImageInputStreamSpi) spis.next(); |
| |
| if (input.getClass().equals(spi.getInputClass())) |
| { |
| foundSpi = spi; |
| break; |
| } |
| } |
| |
| return foundSpi == null ? null : |
| foundSpi.createInputStreamInstance (input, |
| getUseCache(), |
| getCacheDirectory()); |
| } |
| |
| /** |
| * Create an image output stream from the given object. The |
| * collection of ImageOutputStreamSpis registered with the |
| * IIORegistry is searched for an image output stream that can send |
| * output to the given object. null is returned if no such SPI is |
| * registered. |
| * |
| * The image data will be cached in the current cache directory if |
| * caching is enabled. |
| * |
| * @param output an object to which to write image data |
| * |
| * @return an ImageOutputStream that can send data to output, or |
| * null |
| * |
| * @exception IllegalArgumentException if output is null |
| * @exception IOException if caching is required but not enabled |
| */ |
| public static ImageOutputStream createImageOutputStream (Object output) |
| throws IOException |
| { |
| if (output == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| Iterator spis = getRegistry().getServiceProviders |
| (ImageOutputStreamSpi.class, true); |
| |
| ImageOutputStreamSpi foundSpi = null; |
| |
| while(spis.hasNext()) |
| { |
| ImageOutputStreamSpi spi = (ImageOutputStreamSpi) spis.next(); |
| |
| if (output.getClass().equals(spi.getOutputClass())) |
| { |
| foundSpi = spi; |
| break; |
| } |
| } |
| |
| return foundSpi == null ? null : |
| foundSpi.createOutputStreamInstance (output, |
| getUseCache(), |
| getCacheDirectory()); |
| } |
| |
| /** |
| * Retrieve an image reader corresponding to an image writer, or |
| * null if writer is not registered or if no corresponding reader is |
| * registered. |
| * |
| * @param writer a registered image writer |
| * |
| * @return an image reader corresponding to writer, or null |
| * |
| * @exception IllegalArgumentException if writer is null |
| */ |
| public static ImageReader getImageReader (ImageWriter writer) |
| { |
| if (writer == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| ImageWriterSpi spi = writer.getOriginatingProvider(); |
| |
| String[] readerSpiNames = spi.getImageReaderSpiNames(); |
| |
| ImageReader r = null; |
| |
| if (readerSpiNames != null) |
| { |
| try |
| { |
| Class readerClass = Class.forName (readerSpiNames[0]); |
| r = (ImageReader) readerClass.newInstance (); |
| } |
| catch (Exception e) |
| { |
| return null; |
| } |
| } |
| return r; |
| } |
| |
| /** |
| * Retrieve an iterator over the collection of registered image |
| * readers that support reading data from the given object. |
| * |
| * @param input the object for which to retrieve image readers |
| * |
| * @return an iterator over a collection of image readers |
| */ |
| public static Iterator<ImageReader> getImageReaders (Object input) |
| { |
| if (input == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| Iterator<ImageReaderSpi> spiIterator |
| = getRegistry().getServiceProviders (ImageReaderSpi.class, |
| new ReaderObjectFilter(input), |
| true); |
| return new ImageReaderIterator(spiIterator); |
| } |
| |
| /** |
| * Retrieve an iterator over the collection of registered image |
| * writers that support writing images of the given type and in the |
| * given format. |
| * |
| * @param type the output image's colour and sample models |
| * @param formatName the output image format |
| * |
| * @return an iterator over a collection of image writers |
| */ |
| public static Iterator<ImageWriter> getImageWriters (ImageTypeSpecifier type, |
| String formatName) |
| { |
| if (type == null || formatName == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| final Iterator<ImageWriterSpi> spiIterator |
| = getRegistry().getServiceProviders (ImageWriterSpi.class, |
| new WriterObjectFilter(type, |
| formatName), |
| true); |
| return new ImageWriterIterator(spiIterator); |
| } |
| |
| /** |
| * Retrieve an image writer corresponding to an image reader, or |
| * null if reader is not registered or if no corresponding writer is |
| * registered. This method is useful for preserving metadata |
| * without needing to understand its format, since the returned |
| * writer will be able to write, unchanged, the metadata passed to |
| * it by the reader. |
| * |
| * @param reader a registered image reader |
| * |
| * @return an image writer corresponding to reader, or null |
| * |
| * @exception IllegalArgumentException if reader is null |
| */ |
| public static ImageWriter getImageWriter (ImageReader reader) |
| { |
| if (reader == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| ImageReaderSpi spi = reader.getOriginatingProvider(); |
| |
| String[] writerSpiNames = spi.getImageWriterSpiNames(); |
| |
| ImageWriter w = null; |
| |
| if (writerSpiNames != null) |
| { |
| try |
| { |
| Class writerClass = Class.forName (writerSpiNames[0]); |
| w = (ImageWriter) writerClass.newInstance (); |
| } |
| catch (Exception e) |
| { |
| return null; |
| } |
| } |
| return w; |
| } |
| |
| /** |
| * Retrieve an iterator over a collection of image transcoders that |
| * support transcoding from the given image reader's metadata format |
| * to the given writer's metadata format. |
| * |
| * @param reader an image reader |
| * @param writer an image writer |
| * |
| * @return an iterator over a collection of image transcoders |
| * |
| * @exception IllegalArgumentException if either reader or writer is |
| * null |
| */ |
| public static Iterator<ImageTranscoder> getImageTranscoders (ImageReader reader, |
| ImageWriter writer) |
| { |
| if (reader == null || writer == null) |
| throw new IllegalArgumentException ("null argument"); |
| |
| final Iterator<ImageTranscoderSpi> spiIterator |
| = getRegistry().getServiceProviders (ImageTranscoderSpi.class, |
| new TranscoderFilter (reader, |
| writer), |
| true); |
| return new Iterator<ImageTranscoder>() |
| { |
| public boolean hasNext() |
| { |
| return spiIterator.hasNext(); |
| } |
| |
| public ImageTranscoder next() |
| { |
| return spiIterator.next().createTranscoderInstance(); |
| } |
| |
| public void remove() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| }; |
| } |
| } |