1241 lines
35 KiB
Java
1241 lines
35 KiB
Java
/* 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);
|
|
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();
|
|
}
|
|
};
|
|
}
|
|
}
|